BCD

Tezos Contract Explorer
Search Networks Deploy
  • Home
  • /
  • Tezosx
  • /
  • KT1TcPZ...HUEP
FA2
operations (11)Storage Code Interact Tokens Metadata Fork Details
Latest
​x
560
1319
 
1
parameter (or
2
            (or
3
              (or
4
                (or (nat %admin_burn)
5
                    (pair %balance_of
6
                      (list %requests (pair (address %owner) (nat %token_id)))
7
                      (contract %callback (list (pair
8
                                                (pair %request (address %owner)
9
                                                               (nat %token_id))
10
                                                (nat %balance))))))
11
                (or (list %burn_tokens nat)
12
                    (or (list %cache_addresses address) (nat %clear_lien_flag))))
13
              (or
14
                (or (pair %lock (address %expected_owner) (nat %token_id))
15
                    (list %mint_tokens (pair (address %address) (bytes %metadata_hash))))
16
                (or (pair %push_metadata_hash (list %pages bytes) (nat %start_token_id))
17
                    (or
18
                      (pair %push_pages (nat %expected_next_token_id)
19
                                        (list %pages bytes))
20
                      (pair %set_hub (option %old address) (option %new address))))))
21
            (or
22
              (or
23
                (or
24
                  (pair %set_jurisdiction (list %token_ids nat) (string %jurisdiction))
25
                  (pair %set_jurisdiction_admin (string %jurisdiction) (address %admin)))
26
                (or (pair %set_jurisdiction_uri (string %jurisdiction) (bytes %uri))
27
                    (or (nat %set_lien_flag)
28
                        (pair %settle (nat %burn_token_id)
29
                                      (pair (string %dest_jurisdiction)
30
                                            (pair (bytes %metadata_hash)
31
                                                  (address %mint_target)))))))
32
              (or
33
                (or
34
                  (list %transfer (pair (address %from_)
35
                                       (list %txs (pair (address %to_)
36
                                                       (pair (nat %token_id)
37
                                                             (nat %amount))))))
38
                  (or
39
                    (pair %transfer_and_rebind (bytes %metadata_hash)
40
                                               (pair (address %new_owner)
41
                                                     (nat %token_id)))
42
                    (nat %unlock)))
43
                (or
44
                  (pair %update_administrators (list %remove address)
45
                                               (list %add address))
46
                  (or
47
                    (pair %update_contract_metadata
48
                      (list %add (pair (string %key) (bytes %value)))
49
                      (list %remove string))
50
                    (list %update_operators (or
51
                                             (pair %add_operator (address %owner)
52
                                                                 (pair
53
                                                                   (address %operator)
54
                                                                   (nat %token_id)))
55
                                             (pair %remove_operator (address %owner)
56
                                                                    (pair
57
                                                                      (address %operator)
58
                                                                      (nat %token_id))))))))));
59
storage (pair (big_map %addr_to_index address nat)
60
              (pair (set %admins address)
61
                    (pair (option %hub address)
62
                          (pair (big_map %jurisdiction_admins string address)
63
                                (pair (big_map %jurisdiction_of nat string)
64
                                      (pair (big_map %jurisdiction_uris string bytes)
65
                                            (pair (big_map %lien_flag nat bool)
66
                                                  (pair (big_map %locked nat bool)
67
                                                        (pair
68
                                                          (big_map %metadata string
69
                                                                             bytes)
70
                                                          (pair
71
                                                            (bytes %metadata_base_uri)
72
                                                            (pair
73
                                                              (big_map %metadata_pages
74
                                                                nat
75
                                                                bytes)
76
                                                              (pair
77
                                                                (nat %next_addr_index)
78
                                                                (pair
79
                                                                  (nat %next_token_id)
80
                                                                  (pair
81
                                                                    (big_map %operators
82
                                                                      (pair
83
                                                                        (address %owner)
84
                                                                        (pair
85
                                                                          (address %operator)
86
                                                                          (nat %token_id)))
87
                                                                      unit)
88
                                                                    (big_map %pages nat
89
                                                                                    bytes)))))))))))))));
90
code { LAMBDA
91
         (pair
92
           (pair
93
             (lambda
94
               (pair address
95
                     (pair (big_map address nat)
96
                           (pair (set address)
97
                                 (pair (option address)
98
                                       (pair (big_map string address)
99
                                             (pair (big_map nat string)
100
                                                   (pair (big_map string bytes)
101
                                                         (pair (big_map nat bool)
102
                                                               (pair (big_map nat bool)
103
                                                                     (pair
104
                                                                       (big_map string
105
                                                                                bytes)
106
                                                                       (pair bytes
107
                                                                             (pair
108
                                                                               (big_map
109
                                                                                 nat
110
                                                                                 bytes)
111
                                                                               (pair nat
112
                                                                                     (pair
113
                                                                                       nat
114
                                                                                       (pair
115
                                                                                         (big_map
116
                                                                                           (pair
117
                                                                                             address
118
                                                                                             (pair
119
                                                                                               address
120
                                                                                               nat))
121
                                                                                           unit)
122
                                                                                         (big_map
123
                                                                                           nat
124
                                                                                           bytes))))))))))))))))
125
               (pair (option nat)
126
                     (pair (big_map address nat)
127
                           (pair (set address)
128
                                 (pair (option address)
129
                                       (pair (big_map string address)
130
                                             (pair (big_map nat string)
131
                                                   (pair (big_map string bytes)
132
                                                         (pair (big_map nat bool)
133
                                                               (pair (big_map nat bool)
134
                                                                     (pair
135
                                                                       (big_map string
136
                                                                                bytes)
137
                                                                       (pair bytes
138
                                                                             (pair
139
                                                                               (big_map
140
                                                                                 nat
141
                                                                                 bytes)
142
                                                                               (pair nat
143
                                                                                     (pair
144
                                                                                       nat
145
                                                                                       (pair
146
                                                                                         (big_map
147
                                                                                           (pair
148
                                                                                             address
149
                                                                                             (pair
150
                                                                                               address
151
                                                                                               nat))
152
                                                                                           unit)
153
                                                                                         (big_map
154
                                                                                           nat
155
                                                                                           bytes)))))))))))))))))
156
             (pair address nat))
157
           (pair (big_map address nat)
158
                 (pair (set address)
159
                       (pair (option address)
160
                             (pair (big_map string address)
161
                                   (pair (big_map nat string)
162
                                         (pair (big_map string bytes)
163
                                               (pair (big_map nat bool)
164
                                                     (pair (big_map nat bool)
165
                                                           (pair (big_map string bytes)
166
                                                                 (pair bytes
167
                                                                       (pair
168
                                                                         (big_map nat
169
                                                                                  bytes)
170
                                                                         (pair nat
171
                                                                               (pair nat
172
                                                                                     (pair
173
                                                                                       (big_map
174
                                                                                         (pair
175
                                                                                           address
176
                                                                                           (pair
177
                                                                                             address
178
                                                                                             nat))
179
                                                                                         unit)
180
                                                                                       (big_map
181
                                                                                         nat
182
                                                                                         bytes))))))))))))))))
183
         (pair nat
184
               (pair (big_map address nat)
185
                     (pair (set address)
186
                           (pair (option address)
187
                                 (pair (big_map string address)
188
                                       (pair (big_map nat string)
189
                                             (pair (big_map string bytes)
190
                                                   (pair (big_map nat bool)
191
                                                         (pair (big_map nat bool)
192
                                                               (pair
193
                                                                 (big_map string bytes)
194
                                                                 (pair bytes
195
                                                                       (pair
196
                                                                         (big_map nat
197
                                                                                  bytes)
198
                                                                         (pair nat
199
                                                                               (pair nat
200
                                                                                     (pair
201
                                                                                       (big_map
202
                                                                                         (pair
203
                                                                                           address
204
                                                                                           (pair
205
                                                                                             address
206
                                                                                             nat))
207
                                                                                         unit)
208
                                                                                       (big_map
209
                                                                                         nat
210
                                                                                         bytes))))))))))))))))
211
         { UNPAIR ;
212
           DUP ;
213
           GET 4 ;
214
           DUP 3 ;
215
           GET 25 ;
216
           DUP 2 ;
217
           COMPARE ;
218
           LT ;
219
           IF {} { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;
220
           PUSH nat 1024 ;
221
           DUP 2 ;
222
           EDIV ;
223
           IF_NONE { PUSH int 909 ; FAILWITH } { CAR } ;
224
           DUP 4 ;
225
           GET 28 ;
226
           SWAP ;
227
           GET ;
228
           IF_NONE { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } {} ;
229
           PUSH nat 1024 ;
230
           DIG 2 ;
231
           EDIV ;
232
           IF_NONE { PUSH int 911 ; FAILWITH } { CDR } ;
233
           LAMBDA
234
             (pair nat (pair bytes nat))
235
             (option bytes)
236
             { DUP ;
237
               UNPAIR 3 ;
238
               DUP 2 ;
239
               SIZE ;
240
               DUP 4 ;
241
               DUP 3 ;
242
               MUL ;
243
               DUP 2 ;
244
               DUP 2 ;
245
               COMPARE ;
246
               GE ;
247
               IF
248
                 { DROP 6 ; NONE bytes }
249
                 { DIG 2 ;
250
                   DROP ;
251
                   DIG 4 ;
252
                   DROP ;
253
                   PUSH nat 0 ;
254
                   DUP 5 ;
255
                   DIG 3 ;
256
                   EDIV ;
257
                   IF_NONE { PUSH int 90 ; FAILWITH } { CDR } ;
258
                   COMPARE ;
259
                   EQ ;
260
                   IF {} { PUSH string "CORRUPTED_PAGE_SIZE" ; FAILWITH } ;
261
                   SWAP ;
262
                   DUG 2 ;
263
                   SLICE ;
264
                   IF_NONE { PUSH string "SLICE_OUT_OF_BOUNDS_IN_PAGE" ; FAILWITH } {} ;
265
                   SOME } } ;
266
           PUSH nat 4 ;
267
           DIG 3 ;
268
           DIG 3 ;
269
           PAIR 3 ;
270
           EXEC ;
271
           IF_NONE { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } {} ;
272
           PUSH bytes 0x00000000 ;
273
           DUP 2 ;
274
           COMPARE ;
275
           NEQ ;
276
           IF {} { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;
277
           PUSH nat 0 ;
278
           DIG 2 ;
279
           DUP ;
280
           GET 3 ;
281
           SWAP ;
282
           CAR ;
283
           DIG 4 ;
284
           DIG 2 ;
285
           PAIR ;
286
           EXEC ;
287
           UNPAIR ;
288
           SWAP ;
289
           DUG 3 ;
290
           IF_NONE
291
             { SWAP ; DROP }
292
             { LAMBDA
293
                 bytes
294
                 bytes
295
                 { DUP ;
296
                   SIZE ;
297
                   PUSH nat 5 ;
298
                   DUP 2 ;
299
                   COMPARE ;
300
                   LT ;
301
                   IF
302
                     {}
303
                     { PUSH string "Value too long, must be 4 bytes or less" ; FAILWITH } ;
304
                   PUSH nat 4 ;
305
                   DUP 2 ;
306
                   COMPARE ;
307
                   EQ ;
308
                   IF
309
                     { DROP }
310
                     { DUP ;
311
                       INT ;
312
                       EQ ;
313
                       IF
314
                         { DROP 2 ; PUSH bytes 0x00000000 }
315
                         { PUSH nat 1 ;
316
                           DUP 2 ;
317
                           COMPARE ;
318
                           EQ ;
319
                           IF
320
                             { DROP ; PUSH bytes 0x000000 ; CONCAT }
321
                             { PUSH nat 2 ;
322
                               COMPARE ;
323
                               EQ ;
324
                               IF
325
                                 { PUSH bytes 0x0000 ; CONCAT }
326
                                 { PUSH bytes 0x00 ; CONCAT } } } } } ;
327
               DUP 2 ;
328
               BYTES ;
329
               EXEC ;
330
               DUP ;
331
               DUP 5 ;
332
               COMPARE ;
333
               EQ ;
334
               IF { DIG 2 ; DROP 4 ; PUSH nat 1 } { DROP 2 ; SWAP ; DROP } } ;
335
           PAIR } ;
336
       SWAP ;
337
       LAMBDA
338
         (pair address
339
               (pair (big_map address nat)
340
                     (pair (set address)
341
                           (pair (option address)
342
                                 (pair (big_map string address)
343
                                       (pair (big_map nat string)
344
                                             (pair (big_map string bytes)
345
                                                   (pair (big_map nat bool)
346
                                                         (pair (big_map nat bool)
347
                                                               (pair
348
                                                                 (big_map string bytes)
349
                                                                 (pair bytes
350
                                                                       (pair
351
                                                                         (big_map nat
352
                                                                                  bytes)
353
                                                                         (pair nat
354
                                                                               (pair nat
355
                                                                                     (pair
356
                                                                                       (big_map
357
                                                                                         (pair
358
                                                                                           address
359
                                                                                           (pair
360
                                                                                             address
361
                                                                                             nat))
362
                                                                                         unit)
363
                                                                                       (big_map
364
                                                                                         nat
365
                                                                                         bytes))))))))))))))))
366
         (pair nat
367
               (pair (big_map address nat)
368
                     (pair (set address)
369
                           (pair (option address)
370
                                 (pair (big_map string address)
371
                                       (pair (big_map nat string)
372
                                             (pair (big_map string bytes)
373
                                                   (pair (big_map nat bool)
374
                                                         (pair (big_map nat bool)
375
                                                               (pair
376
                                                                 (big_map string bytes)
377
                                                                 (pair bytes
378
                                                                       (pair
379
                                                                         (big_map nat
380
                                                                                  bytes)
381
                                                                         (pair nat
382
                                                                               (pair nat
383
                                                                                     (pair
384
                                                                                       (big_map
385
                                                                                         (pair
386
                                                                                           address
387
                                                                                           (pair
388
                                                                                             address
389
                                                                                             nat))
390
                                                                                         unit)
391
                                                                                       (big_map
392
                                                                                         nat
393
                                                                                         bytes))))))))))))))))
394
         { UNPAIR ;
395
           DUP 2 ;
396
           CAR ;
397
           DUP 2 ;
398
           MEM ;
399
           IF
400
             { DUP 2 ; CAR ; SWAP ; GET ; IF_NONE { PUSH int 23 ; FAILWITH } {} }
401
             { DUP 2 ;
402
               GET 23 ;
403
               DIG 2 ;
404
               DUP ;
405
               CAR ;
406
               DUP 3 ;
407
               SOME ;
408
               DIG 4 ;
409
               UPDATE ;
410
               UPDATE 1 ;
411
               PUSH nat 1 ;
412
               DUP 3 ;
413
               ADD ;
414
               UPDATE 23 ;
415
               SWAP } ;
416
           PAIR } ;
417
       SWAP ;
418
       LAMBDA
419
         (pair unit
420
               (pair (big_map address nat)
421
                     (pair (set address)
422
                           (pair (option address)
423
                                 (pair (big_map string address)
424
                                       (pair (big_map nat string)
425
                                             (pair (big_map string bytes)
426
                                                   (pair (big_map nat bool)
427
                                                         (pair (big_map nat bool)
428
                                                               (pair
429
                                                                 (big_map string bytes)
430
                                                                 (pair bytes
431
                                                                       (pair
432
                                                                         (big_map nat
433
                                                                                  bytes)
434
                                                                         (pair nat
435
                                                                               (pair nat
436
                                                                                     (pair
437
                                                                                       (big_map
438
                                                                                         (pair
439
                                                                                           address
440
                                                                                           (pair
441
                                                                                             address
442
                                                                                             nat))
443
                                                                                         unit)
444
                                                                                       (big_map
445
                                                                                         nat
446
                                                                                         bytes))))))))))))))))
447
         (pair bool
448
               (pair (big_map address nat)
449
                     (pair (set address)
450
                           (pair (option address)
451
                                 (pair (big_map string address)
452
                                       (pair (big_map nat string)
453
                                             (pair (big_map string bytes)
454
                                                   (pair (big_map nat bool)
455
                                                         (pair (big_map nat bool)
456
                                                               (pair
457
                                                                 (big_map string bytes)
458
                                                                 (pair bytes
459
                                                                       (pair
460
                                                                         (big_map nat
461
                                                                                  bytes)
462
                                                                         (pair nat
463
                                                                               (pair nat
464
                                                                                     (pair
465
                                                                                       (big_map
466
                                                                                         (pair
467
                                                                                           address
468
                                                                                           (pair
469
                                                                                             address
470
                                                                                             nat))
471
                                                                                         unit)
472
                                                                                       (big_map
473
                                                                                         nat
474
                                                                                         bytes))))))))))))))))
475
         { CDR ; DUP ; GET 3 ; SENDER ; MEM ; PAIR } ;
476
       SWAP ;
477
       LAMBDA
478
         (pair unit
479
               (pair (big_map address nat)
480
                     (pair (set address)
481
                           (pair (option address)
482
                                 (pair (big_map string address)
483
                                       (pair (big_map nat string)
484
                                             (pair (big_map string bytes)
485
                                                   (pair (big_map nat bool)
486
                                                         (pair (big_map nat bool)
487
                                                               (pair
488
                                                                 (big_map string bytes)
489
                                                                 (pair bytes
490
                                                                       (pair
491
                                                                         (big_map nat
492
                                                                                  bytes)
493
                                                                         (pair nat
494
                                                                               (pair nat
495
                                                                                     (pair
496
                                                                                       (big_map
497
                                                                                         (pair
498
                                                                                           address
499
                                                                                           (pair
500
                                                                                             address
501
                                                                                             nat))
502
                                                                                         unit)
503
                                                                                       (big_map
504
                                                                                         nat
505
                                                                                         bytes))))))))))))))))
506
         (pair bool
507
               (pair (big_map address nat)
508
                     (pair (set address)
509
                           (pair (option address)
510
                                 (pair (big_map string address)
511
                                       (pair (big_map nat string)
512
                                             (pair (big_map string bytes)
513
                                                   (pair (big_map nat bool)
514
                                                         (pair (big_map nat bool)
515
                                                               (pair
516
                                                                 (big_map string bytes)
517
                                                                 (pair bytes
518
                                                                       (pair
519
                                                                         (big_map nat
520
                                                                                  bytes)
521
                                                                         (pair nat
522
                                                                               (pair nat
523
                                                                                     (pair
524
                                                                                       (big_map
525
                                                                                         (pair
526
                                                                                           address
527
                                                                                           (pair
528
                                                                                             address
529
                                                                                             nat))
530
                                                                                         unit)
531
                                                                                       (big_map
532
                                                                                         nat
533
                                                                                         bytes))))))))))))))))
534
         { CDR ;
535
           PUSH bool False ;
536
           DUP 2 ;
537
           GET 5 ;
538
           IF_NONE {} { SWAP ; DROP ; SENDER ; COMPARE ; EQ } ;
539
           PAIR } ;
540
       SWAP ;
541
       LAMBDA
542
         (pair string
543
               (pair (big_map address nat)
544
                     (pair (set address)
545
                           (pair (option address)
546
                                 (pair (big_map string address)
547
                                       (pair (big_map nat string)
548
                                             (pair (big_map string bytes)
549
                                                   (pair (big_map nat bool)
550
                                                         (pair (big_map nat bool)
551
                                                               (pair
552
                                                                 (big_map string bytes)
553
                                                                 (pair bytes
554
                                                                       (pair
555
                                                                         (big_map nat
556
                                                                                  bytes)
557
                                                                         (pair nat
558
                                                                               (pair nat
559
                                                                                     (pair
560
                                                                                       (big_map
561
                                                                                         (pair
562
                                                                                           address
563
                                                                                           (pair
564
                                                                                             address
565
                                                                                             nat))
566
                                                                                         unit)
567
                                                                                       (big_map
568
                                                                                         nat
569
                                                                                         bytes))))))))))))))))
570
         (pair bool
571
               (pair (big_map address nat)
572
                     (pair (set address)
573
                           (pair (option address)
574
                                 (pair (big_map string address)
575
                                       (pair (big_map nat string)
576
                                             (pair (big_map string bytes)
577
                                                   (pair (big_map nat bool)
578
                                                         (pair (big_map nat bool)
579
                                                               (pair
580
                                                                 (big_map string bytes)
581
                                                                 (pair bytes
582
                                                                       (pair
583
                                                                         (big_map nat
584
                                                                                  bytes)
585
                                                                         (pair nat
586
                                                                               (pair nat
587
                                                                                     (pair
588
                                                                                       (big_map
589
                                                                                         (pair
590
                                                                                           address
591
                                                                                           (pair
592
                                                                                             address
593
                                                                                             nat))
594
                                                                                         unit)
595
                                                                                       (big_map
596
                                                                                         nat
597
                                                                                         bytes))))))))))))))))
598
         { UNPAIR ;
599
           DUP 2 ;
600
           GET 7 ;
601
           DUP 2 ;
602
           MEM ;
603
           IF
604
             { DUP 2 ; GET 7 ; SWAP ; GET ; IF_NONE { PUSH int 498 ; FAILWITH } {} ; SENDER ; COMPARE ; EQ }
605
             { DROP ; DUP ; GET 3 ; SENDER ; MEM } ;
606
           PAIR } ;
607
       SWAP ;
608
       LAMBDA
609
         (pair address
610
               (pair (big_map address nat)
611
                     (pair (set address)
612
                           (pair (option address)
613
                                 (pair (big_map string address)
614
                                       (pair (big_map nat string)
615
                                             (pair (big_map string bytes)
616
                                                   (pair (big_map nat bool)
617
                                                         (pair (big_map nat bool)
618
                                                               (pair
619
                                                                 (big_map string bytes)
620
                                                                 (pair bytes
621
                                                                       (pair
622
                                                                         (big_map nat
623
                                                                                  bytes)
624
                                                                         (pair nat
625
                                                                               (pair nat
626
                                                                                     (pair
627
                                                                                       (big_map
628
                                                                                         (pair
629
                                                                                           address
630
                                                                                           (pair
631
                                                                                             address
632
                                                                                             nat))
633
                                                                                         unit)
634
                                                                                       (big_map
635
                                                                                         nat
636
                                                                                         bytes))))))))))))))))
637
         (pair (option nat)
638
               (pair (big_map address nat)
639
                     (pair (set address)
640
                           (pair (option address)
641
                                 (pair (big_map string address)
642
                                       (pair (big_map nat string)
643
                                             (pair (big_map string bytes)
644
                                                   (pair (big_map nat bool)
645
                                                         (pair (big_map nat bool)
646
                                                               (pair
647
                                                                 (big_map string bytes)
648
                                                                 (pair bytes
649
                                                                       (pair
650
                                                                         (big_map nat
651
                                                                                  bytes)
652
                                                                         (pair nat
653
                                                                               (pair nat
654
                                                                                     (pair
655
                                                                                       (big_map
656
                                                                                         (pair
657
                                                                                           address
658
                                                                                           (pair
659
                                                                                             address
660
                                                                                             nat))
661
                                                                                         unit)
662
                                                                                       (big_map
663
                                                                                         nat
664
                                                                                         bytes))))))))))))))))
665
         { UNPAIR ; SWAP ; DUP ; CAR ; DIG 2 ; GET ; PAIR } ;
666
       SWAP ;
667
       UNPAIR ;
668
       IF_LEFT
669
         { IF_LEFT
670
             { IF_LEFT
671
                 { IF_LEFT
672
                     { DUP 2 ;
673
                       GET 25 ;
674
                       DUP 2 ;
675
                       COMPARE ;
676
                       LT ;
677
                       IF {} { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;
678
                       DUP 2 ;
679
                       GET 15 ;
680
                       DUP 2 ;
681
                       GET ;
682
                       IF_NONE { PUSH bool False } {} ;
683
                       IF { PUSH string "TOKEN_LOCKED" ; FAILWITH } {} ;
684
                       DUP 2 ;
685
                       GET 9 ;
686
                       DUP 2 ;
687
                       GET ;
688
                       IF_NONE { PUSH string "" } {} ;
689
                       DUP 5 ;
690
                       DUP 2 ;
691
                       SWAP ;
692
                       DIG 4 ;
693
                       DIG 2 ;
694
                       PAIR ;
695
                       EXEC ;
696
                       UNPAIR ;
697
                       DUG 9 ;
698
                       DUG 9 ;
699
                       DUG 9 ;
700
                       DUG 9 ;
701
                       DIG 7 ;
702
                       DIG 9 ;
703
                       DIG 9 ;
704
                       DIG 9 ;
705
                       IF {} { PUSH string "NOT_JURISDICTION_ADMIN" ; FAILWITH } ;
706
                       PUSH nat 1024 ;
707
                       DUP 3 ;
708
                       EDIV ;
709
                       IF_NONE { PUSH int 874 ; FAILWITH } { CAR } ;
710
                       DUP 4 ;
711
                       GET 28 ;
712
                       DUP 2 ;
713
                       GET ;
714
                       IF_NONE { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } {} ;
715
                       PUSH nat 1024 ;
716
                       DUP 5 ;
717
                       EDIV ;
718
                       IF_NONE { PUSH int 876 ; FAILWITH } { CDR } ;
719
                       DIG 5 ;
720
                       DUP ;
721
                       GET 28 ;
722
                       LAMBDA
723
                         (pair nat (pair bytes bytes))
724
                         bytes
725
                         { DUP ;
726
                           UNPAIR 3 ;
727
                           DUP 3 ;
728
                           SIZE ;
729
                           DUP 3 ;
730
                           SIZE ;
731
                           PUSH nat 0 ;
732
                           DUP 3 ;
733
                           DUP 3 ;
734
                           EDIV ;
735
                           IF_NONE { PUSH int 102 ; FAILWITH } { CDR } ;
736
                           COMPARE ;
737
                           EQ ;
738
                           IF
739
                             {}
740
                             { PUSH string "UPDATE_PAGE_CORRUPTED_SIZE" ; FAILWITH } ;
741
                           DUP 2 ;
742
                           DUP 4 ;
743
                           MUL ;
744
                           DUP 3 ;
745
                           DUP 2 ;
746
                           ADD ;
747
                           DUP 2 ;
748
                           INT ;
749
                           EQ ;
750
                           IF
751
                             { PUSH bytes 0x }
752
                             { DUP 6 ;
753
                               DUP 3 ;
754
                               PUSH nat 0 ;
755
                               SLICE ;
756
                               IF_NONE
757
                                 { PUSH string "UPDATE_INDEX_OUT_OF_BOUNDS" ; FAILWITH }
758
                                 {} } ;
759
                           DUP 4 ;
760
                           DUP 3 ;
761
                           COMPARE ;
762
                           EQ ;
763
                           IF
764
                             { SWAP ;
765
                               DROP ;
766
                               SWAP ;
767
                               DROP ;
768
                               SWAP ;
769
                               DROP ;
770
                               SWAP ;
771
                               DROP ;
772
                               SWAP ;
773
                               DROP ;
774
                               SWAP ;
775
                               DROP ;
776
                               DIG 2 ;
777
                               DROP ;
778
                               CONCAT }
779
                             { DIG 2 ;
780
                               DROP ;
781
                               DIG 3 ;
782
                               DROP ;
783
                               DIG 3 ;
784
                               DROP ;
785
                               DIG 5 ;
786
                               DROP ;
787
                               DUP 2 ;
788
                               DIG 3 ;
789
                               SUB ;
790
                               ISNAT ;
791
                               IF_NONE
792
                                 { PUSH string "UPDATE_SLICE_OUT_OF_BOUNDS" ; FAILWITH }
793
                                 {} ;
794
                               DIG 3 ;
795
                               SWAP ;
796
                               DIG 3 ;
797
                               SLICE ;
798
                               IF_NONE { PUSH int 116 ; FAILWITH } {} ;
799
                               NIL bytes ;
800
                               SWAP ;
801
                               CONS ;
802
                               DIG 2 ;
803
                               CONS ;
804
                               SWAP ;
805
                               CONS ;
806
                               CONCAT } } ;
807
                       PUSH bytes 0x00000000 ;
808
                       DUP 6 ;
809
                       DUP 6 ;
810
                       PAIR 3 ;
811
                       EXEC ;
812
                       SOME ;
813
                       DUP 6 ;
814
                       UPDATE ;
815
                       UPDATE 28 ;
816
                       DUG 5 ;
817
                       PUSH nat 128 ;
818
                       DUP 6 ;
819
                       EDIV ;
820
                       IF_NONE { PUSH int 881 ; FAILWITH } { CAR } ;
821
                       DUP 7 ;
822
                       GET 21 ;
823
                       DUP 2 ;
824
                       GET ;
825
                       IF_NONE { PUSH bytes 0x } {} ;
826
                       PUSH nat 128 ;
827
                       DUP 8 ;
828
                       EDIV ;
829
                       IF_NONE { PUSH int 883 ; FAILWITH } { CDR } ;
830
                       PUSH nat 32 ;
831
                       DUP 2 ;
832
                       MUL ;
833
                       DUP 3 ;
834
                       SIZE ;
835
                       COMPARE ;
836
                       GT ;
837
                       IF
838
                         { DIG 3 ;
839
                           DROP ;
840
                           DIG 3 ;
841
                           DROP ;
842
                           DIG 3 ;
843
                           DROP ;
844
                           DIG 3 ;
845
                           DROP ;
846
                           DIG 5 ;
847
                           DROP ;
848
                           DIG 5 ;
849
                           DROP ;
850
                           DIG 5 ;
851
                           DROP ;
852
                           DIG 5 ;
853
                           DROP ;
854
                           DIG 5 ;
855
                           DROP ;
856
                           DIG 5 ;
857
                           DROP ;
858
                           DIG 4 ;
859
                           DUP ;
860
                           GET 21 ;
861
                           LAMBDA
862
                             (pair nat (pair bytes bytes))
863
                             bytes
864
                             { DUP ;
865
                               UNPAIR 3 ;
866
                               DUP 3 ;
867
                               SIZE ;
868
                               DUP 3 ;
869
                               SIZE ;
870
                               PUSH nat 0 ;
871
                               DUP 3 ;
872
                               DUP 3 ;
873
                               EDIV ;
874
                               IF_NONE { PUSH int 102 ; FAILWITH } { CDR } ;
875
                               COMPARE ;
876
                               EQ ;
877
                               IF
878
                                 {}
879
                                 { PUSH string "UPDATE_PAGE_CORRUPTED_SIZE" ; FAILWITH } ;
880
                               DUP 2 ;
881
                               DUP 4 ;
882
                               MUL ;
883
                               DUP 3 ;
884
                               DUP 2 ;
885
                               ADD ;
886
                               DUP 2 ;
887
                               INT ;
888
                               EQ ;
889
                               IF
890
                                 { PUSH bytes 0x }
891
                                 { DUP 6 ;
892
                                   DUP 3 ;
893
                                   PUSH nat 0 ;
894
                                   SLICE ;
895
                                   IF_NONE
896
                                     { PUSH string "UPDATE_INDEX_OUT_OF_BOUNDS" ;
897
                                       FAILWITH }
898
                                     {} } ;
899
                               DUP 4 ;
900
                               DUP 3 ;
901
                               COMPARE ;
902
                               EQ ;
903
                               IF
904
                                 { SWAP ;
905
                                   DROP ;
906
                                   SWAP ;
907
                                   DROP ;
908
                                   SWAP ;
909
                                   DROP ;
910
                                   SWAP ;
911
                                   DROP ;
912
                                   SWAP ;
913
                                   DROP ;
914
                                   SWAP ;
915
                                   DROP ;
916
                                   DIG 2 ;
917
                                   DROP ;
918
                                   CONCAT }
919
                                 { DIG 2 ;
920
                                   DROP ;
921
                                   DIG 3 ;
922
                                   DROP ;
923
                                   DIG 3 ;
924
                                   DROP ;
925
                                   DIG 5 ;
926
                                   DROP ;
927
                                   DUP 2 ;
928
                                   DIG 3 ;
929
                                   SUB ;
930
                                   ISNAT ;
931
                                   IF_NONE
932
                                     { PUSH string "UPDATE_SLICE_OUT_OF_BOUNDS" ;
933
                                       FAILWITH }
934
                                     {} ;
935
                                   DIG 3 ;
936
                                   SWAP ;
937
                                   DIG 3 ;
938
                                   SLICE ;
939
                                   IF_NONE { PUSH int 116 ; FAILWITH } {} ;
940
                                   NIL bytes ;
941
                                   SWAP ;
942
                                   CONS ;
943
                                   DIG 2 ;
944
                                   CONS ;
945
                                   SWAP ;
946
                                   CONS ;
947
                                   CONCAT } } ;
948
                           PUSH bytes 0x0000000000000000000000000000000000000000000000000000000000000000 ;
949
                           DIG 5 ;
950
                           DIG 5 ;
951
                           PAIR 3 ;
952
                           EXEC ;
953
                           SOME ;
954
                           DIG 3 ;
955
                           UPDATE ;
956
                           UPDATE 21 ;
957
                           SWAP }
958
                         { DROP 7 ;
959
                           DIG 2 ;
960
                           DROP ;
961
                           DIG 2 ;
962
                           DROP ;
963
                           DIG 2 ;
964
                           DROP ;
965
                           DIG 2 ;
966
                           DROP ;
967
                           DIG 2 ;
968
                           DROP ;
969
                           DIG 2 ;
970
                           DROP } ;
971
                       DUP 2 ;
972
                       GET 9 ;
973
                       DUP 2 ;
974
                       MEM ;
975
                       IF
976
                         { SWAP ; DUP ; GET 9 ; NONE string ; DUP 4 ; UPDATE ; UPDATE 9 ; SWAP }
977
                         {} ;
978
                       DUP 2 ;
979
                       GET 13 ;
980
                       DUP 2 ;
981
                       MEM ;
982
                       IF
983
                         { SWAP ; DUP ; GET 13 ; NONE bool ; DUP 4 ; UPDATE ; UPDATE 13 ; SWAP }
984
                         {} ;
985
                       NIL operation ;
986
                       DUP 2 ;
987
                       PUSH nat 0 ;
988
                       PUSH int -1 ;
989
                       PAIR 3 ;
990
                       EMIT %total_supply_update (pair (int %diff)
991
                                                       (pair (nat %new_total_supply)
992
                                                             (nat %token_id))) ;
993
                       CONS ;
994
                       SWAP ;
995
                       PUSH (option string) (Some "offline_completion") ;
996
                       PAIR ;
997
                       EMIT %TitleBurned (pair (option %reason string) (nat %token_id)) ;
998
                       CONS }
999
                     { NIL (pair (pair address nat) nat) ;
1000
                       DUP 2 ;
1001
                       CAR ;
1002
                       ITER { SWAP ;
1003
                              DUP 10 ;
1004
                              DUP 3 ;
1005
                              CDR ;
1006
                              DUP 4 ;
1007
                              CAR ;
1008
                              DUP 8 ;
1009
                              PAIR 3 ;
1010
                              SWAP ;
1011
                              DIG 5 ;
1012
                              DIG 2 ;
1013
                              PAIR ;
1014
                              EXEC ;
1015
                              UNPAIR ;
1016
                              DUG 10 ;
1017
                              DUG 10 ;
1018
                              DUG 10 ;
1019
                              DUG 10 ;
1020
                              DUG 10 ;
1021
                              DIG 7 ;
1022
                              DIG 10 ;
1023
                              DIG 10 ;
1024
                              DIG 10 ;
1025
                              DIG 10 ;
1026
                              DIG 2 ;
1027
                              PAIR ;
1028
                              CONS } ;
1029
                       DIG 3 ;
1030
                       DROP ;
1031
                       DIG 3 ;
1032
                       DROP ;
1033
                       DIG 3 ;
1034
                       DROP ;
1035
                       DIG 3 ;
1036
                       DROP ;
1037
                       DIG 3 ;
1038
                       DROP ;
1039
                       DIG 3 ;
1040
                       DROP ;
1041
                       NIL operation ;
1042
                       DIG 2 ;
1043
                       CDR ;
1044
                       PUSH mutez 0 ;
1045
                       DIG 3 ;
1046
                       NIL (pair (pair address nat) nat) ;
1047
                       SWAP ;
1048
                       ITER { CONS } ;
1049
                       TRANSFER_TOKENS ;
1050
                       CONS } }
1051
                 { IF_LEFT
1052
                     { LAMBDA
1053
                         bytes
1054
                         bytes
1055
                         { DUP ;
1056
                           SIZE ;
1057
                           PUSH nat 5 ;
1058
                           DUP 2 ;
1059
                           COMPARE ;
1060
                           LT ;
1061
                           IF
1062
                             {}
1063
                             { PUSH string "Value too long, must be 4 bytes or less" ;
1064
                               FAILWITH } ;
1065
                           PUSH nat 4 ;
1066
                           DUP 2 ;
1067
                           COMPARE ;
1068
                           EQ ;
1069
                           IF
1070
                             { DROP }
1071
                             { DUP ;
1072
                               INT ;
1073
                               EQ ;
1074
                               IF
1075
                                 { DROP 2 ; PUSH bytes 0x00000000 }
1076
                                 { PUSH nat 1 ;
1077
                                   DUP 2 ;
1078
                                   COMPARE ;
1079
                                   EQ ;
1080
                                   IF
1081
                                     { DROP ; PUSH bytes 0x000000 ; CONCAT }
1082
                                     { PUSH nat 2 ;
1083
                                       COMPARE ;
1084
                                       EQ ;
1085
                                       IF
1086
                                         { PUSH bytes 0x0000 ; CONCAT }
1087
                                         { PUSH bytes 0x00 ; CONCAT } } } } } ;
1088
                       DUP 8 ;
1089
                       SENDER ;
1090
                       SWAP ;
1091
                       DIG 4 ;
1092
                       DIG 2 ;
1093
                       PAIR ;
1094
                       EXEC ;
1095
                       UNPAIR ;
1096
                       DUG 9 ;
1097
                       DUG 9 ;
1098
                       DUG 9 ;
1099
                       DUG 9 ;
1100
                       DIG 7 ;
1101
                       DIG 9 ;
1102
                       DIG 9 ;
1103
                       DIG 9 ;
1104
                       BYTES ;
1105
                       EXEC ;
1106
                       NIL operation ;
1107
                       DUP 3 ;
1108
                       ITER { DUP 5 ;
1109
                              GET 25 ;
1110
                              DUP 2 ;
1111
                              COMPARE ;
1112
                              LT ;
1113
                              IF {} { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;
1114
                              DUP 5 ;
1115
                              GET 15 ;
1116
                              DUP 2 ;
1117
                              GET ;
1118
                              IF_NONE { PUSH bool False } {} ;
1119
                              IF { PUSH string "TOKEN_LOCKED" ; FAILWITH } {} ;
1120
                              PUSH nat 1024 ;
1121
                              DUP 2 ;
1122
                              EDIV ;
1123
                              IF_NONE { PUSH int 452 ; FAILWITH } { CAR } ;
1124
                              DUP 6 ;
1125
                              GET 28 ;
1126
                              DUP 2 ;
1127
                              GET ;
1128
                              IF_NONE
1129
                                { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH }
1130
                                {} ;
1131
                              PUSH nat 1024 ;
1132
                              DUP 4 ;
1133
                              EDIV ;
1134
                              IF_NONE { PUSH int 454 ; FAILWITH } { CDR } ;
1135
                              LAMBDA
1136
                                (pair nat (pair bytes nat))
1137
                                (option bytes)
1138
                                { DUP ;
1139
                                  UNPAIR 3 ;
1140
                                  DUP 2 ;
1141
                                  SIZE ;
1142
                                  DUP 4 ;
1143
                                  DUP 3 ;
1144
                                  MUL ;
1145
                                  DUP 2 ;
1146
                                  DUP 2 ;
1147
                                  COMPARE ;
1148
                                  GE ;
1149
                                  IF
1150
                                    { DROP 6 ; NONE bytes }
1151
                                    { DIG 2 ;
1152
                                      DROP ;
1153
                                      DIG 4 ;
1154
                                      DROP ;
1155
                                      PUSH nat 0 ;
1156
                                      DUP 5 ;
1157
                                      DIG 3 ;
1158
                                      EDIV ;
1159
                                      IF_NONE { PUSH int 90 ; FAILWITH } { CDR } ;
1160
                                      COMPARE ;
1161
                                      EQ ;
1162
                                      IF
1163
                                        {}
1164
                                        { PUSH string "CORRUPTED_PAGE_SIZE" ; FAILWITH } ;
1165
                                      SWAP ;
1166
                                      DUG 2 ;
1167
                                      SLICE ;
1168
                                      IF_NONE
1169
                                        { PUSH string "SLICE_OUT_OF_BOUNDS_IN_PAGE" ;
1170
                                          FAILWITH }
1171
                                        {} ;
1172
                                      SOME } } ;
1173
                              PUSH nat 4 ;
1174
                              DUP 4 ;
1175
                              DUP 4 ;
1176
                              PAIR 3 ;
1177
                              EXEC ;
1178
                              IF_NONE
1179
                                { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH }
1180
                                {} ;
1181
                              PUSH bytes 0x00000000 ;
1182
                              DUP 2 ;
1183
                              COMPARE ;
1184
                              NEQ ;
1185
                              IF {} { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;
1186
                              DUP 7 ;
1187
                              DUP 2 ;
1188
                              COMPARE ;
1189
                              EQ ;
1190
                              IF
1191
                                { PUSH bool True }
1192
                                { DUP 13 ;
1193
                                  UNIT ;
1194
                                  SWAP ;
1195
                                  DIG 10 ;
1196
                                  DIG 2 ;
1197
                                  PAIR ;
1198
                                  EXEC ;
1199
                                  UNPAIR ;
1200
                                  DIG 15 ;
1201
                                  DIG 15 ;
1202
                                  DIG 15 ;
1203
                                  DIG 15 ;
1204
                                  DIG 15 ;
1205
                                  DIG 15 ;
1206
                                  DIG 7 ;
1207
                                  DUG 15 ;
1208
                                  DUG 15 ;
1209
                                  DUG 15 ;
1210
                                  DUG 15 ;
1211
                                  DUG 15 ;
1212
                                  DUG 15 ;
1213
                                  DUG 15 } ;
1214
                              IF {} { PUSH string "FA2_NOT_OWNER" ; FAILWITH } ;
1215
                              PUSH bytes 0x00000000 ;
1216
                              LAMBDA
1217
                                (pair nat (pair bytes bytes))
1218
                                bytes
1219
                                { DUP ;
1220
                                  UNPAIR 3 ;
1221
                                  DUP 3 ;
1222
                                  SIZE ;
1223
                                  DUP 3 ;
1224
                                  SIZE ;
1225
                                  PUSH nat 0 ;
1226
                                  DUP 3 ;
1227
                                  DUP 3 ;
1228
                                  EDIV ;
1229
                                  IF_NONE { PUSH int 102 ; FAILWITH } { CDR } ;
1230
                                  COMPARE ;
1231
                                  EQ ;
1232
                                  IF
1233
                                    {}
1234
                                    { PUSH string "UPDATE_PAGE_CORRUPTED_SIZE" ;
1235
                                      FAILWITH } ;
1236
                                  DUP 2 ;
1237
                                  DUP 4 ;
1238
                                  MUL ;
1239
                                  DUP 3 ;
1240
                                  DUP 2 ;
1241
                                  ADD ;
1242
                                  DUP 2 ;
1243
                                  INT ;
1244
                                  EQ ;
1245
                                  IF
1246
                                    { PUSH bytes 0x }
1247
                                    { DUP 6 ;
1248
                                      DUP 3 ;
1249
                                      PUSH nat 0 ;
1250
                                      SLICE ;
1251
                                      IF_NONE
1252
                                        { PUSH string "UPDATE_INDEX_OUT_OF_BOUNDS" ;
1253
                                          FAILWITH }
1254
                                        {} } ;
1255
                                  DUP 4 ;
1256
                                  DUP 3 ;
1257
                                  COMPARE ;
1258
                                  EQ ;
1259
                                  IF
1260
                                    { SWAP ;
1261
                                      DROP ;
1262
                                      SWAP ;
1263
                                      DROP ;
1264
                                      SWAP ;
1265
                                      DROP ;
1266
                                      SWAP ;
1267
                                      DROP ;
1268
                                      SWAP ;
1269
                                      DROP ;
1270
                                      SWAP ;
1271
                                      DROP ;
1272
                                      DIG 2 ;
1273
                                      DROP ;
1274
                                      CONCAT }
1275
                                    { DIG 2 ;
1276
                                      DROP ;
1277
                                      DIG 3 ;
1278
                                      DROP ;
1279
                                      DIG 3 ;
1280
                                      DROP ;
1281
                                      DIG 5 ;
1282
                                      DROP ;
1283
                                      DUP 2 ;
1284
                                      DIG 3 ;
1285
                                      SUB ;
1286
                                      ISNAT ;
1287
                                      IF_NONE
1288
                                        { PUSH string "UPDATE_SLICE_OUT_OF_BOUNDS" ;
1289
                                          FAILWITH }
1290
                                        {} ;
1291
                                      DIG 3 ;
1292
                                      SWAP ;
1293
                                      DIG 3 ;
1294
                                      SLICE ;
1295
                                      IF_NONE { PUSH int 116 ; FAILWITH } {} ;
1296
                                      NIL bytes ;
1297
                                      SWAP ;
1298
                                      CONS ;
1299
                                      DIG 2 ;
1300
                                      CONS ;
1301
                                      SWAP ;
1302
                                      CONS ;
1303
                                      CONCAT } } ;
1304
                              DUP 2 ;
1305
                              DUP 6 ;
1306
                              DUP 6 ;
1307
                              PAIR 3 ;
1308
                              EXEC ;
1309
                              DIG 10 ;
1310
                              DUP ;
1311
                              GET 28 ;
1312
                              DUP 3 ;
1313
                              SOME ;
1314
                              DUP 9 ;
1315
                              UPDATE ;
1316
                              UPDATE 28 ;
1317
                              DUG 10 ;
1318
                              DUP 8 ;
1319
                              DUP 8 ;
1320
                              SENDER ;
1321
                              PUSH nat 0 ;
1322
                              PUSH int -1 ;
1323
                              PAIR 4 ;
1324
                              DIG 2 ;
1325
                              DROP ;
1326
                              DIG 2 ;
1327
                              DROP ;
1328
                              DIG 2 ;
1329
                              DROP ;
1330
                              DIG 2 ;
1331
                              DROP ;
1332
                              DIG 2 ;
1333
                              DROP ;
1334
                              DIG 2 ;
1335
                              DROP ;
1336
                              DIG 3 ;
1337
                              DROP ;
1338
                              EMIT %balance_update (pair (int %diff)
1339
                                                         (pair (nat %new_balance)
1340
                                                               (pair (address %owner)
1341
                                                                     (nat %token_id)))) ;
1342
                              CONS ;
1343
                              SWAP ;
1344
                              PUSH nat 0 ;
1345
                              PUSH int -1 ;
1346
                              PAIR 3 ;
1347
                              EMIT %total_supply_update (pair (int %diff)
1348
                                                              (pair
1349
                                                                (nat %new_total_supply)
1350
                                                                (nat %token_id))) ;
1351
                              CONS } ;
1352
                       SWAP ;
1353
                       DROP ;
1354
                       SWAP ;
1355
                       DROP ;
1356
                       DIG 2 ;
1357
                       DROP ;
1358
                       DIG 2 ;
1359
                       DROP ;
1360
                       DIG 2 ;
1361
                       DROP ;
1362
                       DIG 2 ;
1363
                       DROP ;
1364
                       DIG 2 ;
1365
                       DROP ;
1366
                       DIG 2 ;
1367
                       DROP }
1368
                     { IF_LEFT
1369
                         { DUP 2 ;
1370
                           GET 3 ;
1371
                           SENDER ;
1372
                           MEM ;
1373
                           IF {} { PUSH string "FA2_NOT_ADMIN" ; FAILWITH } ;
1374
                           DUP ;
1375
                           ITER { DUP 8 ; DIG 3 ; DIG 2 ; PAIR ; EXEC ; CDR ; DUG 7 ; DUG 7 ; DIG 6 ; DIG 7 } ;
1376
                           DROP ;
1377
                           SWAP ;
1378
                           DROP ;
1379
                           SWAP ;
1380
                           DROP ;
1381
                           SWAP ;
1382
                           DROP ;
1383
                           SWAP ;
1384
                           DROP ;
1385
                           SWAP ;
1386
                           DROP ;
1387
                           SWAP ;
1388
                           DROP }
1389
                         { DIG 2 ;
1390
                           DROP ;
1391
                           DIG 3 ;
1392
                           DROP ;
1393
                           DIG 3 ;
1394
                           DROP ;
1395
                           DIG 3 ;
1396
                           DROP ;
1397
                           DIG 3 ;
1398
                           DROP ;
1399
                           DUP 2 ;
1400
                           GET 25 ;
1401
                           DUP 2 ;
1402
                           COMPARE ;
1403
                           LT ;
1404
                           IF {} { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;
1405
                           DUP 2 ;
1406
                           GET 9 ;
1407
                           DUP 2 ;
1408
                           GET ;
1409
                           IF_NONE { PUSH string "" } {} ;
1410
                           DIG 3 ;
1411
                           DIG 3 ;
1412
                           DIG 2 ;
1413
                           PAIR ;
1414
                           EXEC ;
1415
                           UNPAIR ;
1416
                           SWAP ;
1417
                           DUG 2 ;
1418
                           IF {} { PUSH string "NOT_JURISDICTION_ADMIN" ; FAILWITH } ;
1419
                           DUP 2 ;
1420
                           GET 13 ;
1421
                           DUP 2 ;
1422
                           MEM ;
1423
                           IF
1424
                             { SWAP ;
1425
                               DUP ;
1426
                               GET 13 ;
1427
                               PUSH (option bool) (Some False) ;
1428
                               DIG 3 ;
1429
                               UPDATE ;
1430
                               UPDATE 13 }
1431
                             { DROP } } ;
1432
                       NIL operation } } }
1433
             { IF_LEFT
1434
                 { IF_LEFT
1435
                     { DIG 3 ;
1436
                       DROP ;
1437
                       DIG 4 ;
1438
                       DROP ;
1439
                       DIG 4 ;
1440
                       DROP ;
1441
                       DIG 4 ;
1442
                       DROP ;
1443
                       DIG 3 ;
1444
                       UNIT ;
1445
                       SWAP ;
1446
                       DIG 3 ;
1447
                       DIG 2 ;
1448
                       PAIR ;
1449
                       EXEC ;
1450
                       UNPAIR ;
1451
                       DIG 3 ;
1452
                       DIG 2 ;
1453
                       DIG 3 ;
1454
                       DIG 3 ;
1455
                       IF {} { PUSH string "NOT_HUB" ; FAILWITH } ;
1456
                       DUP 2 ;
1457
                       GET 25 ;
1458
                       DUP 2 ;
1459
                       CDR ;
1460
                       COMPARE ;
1461
                       LT ;
1462
                       IF {} { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;
1463
                       DUP 2 ;
1464
                       GET 15 ;
1465
                       DUP 2 ;
1466
                       CDR ;
1467
                       GET ;
1468
                       IF_NONE { PUSH bool False } {} ;
1469
                       IF { PUSH string "ALREADY_LOCKED" ; FAILWITH } {} ;
1470
                       PUSH nat 1024 ;
1471
                       DUP 2 ;
1472
                       CDR ;
1473
                       EDIV ;
1474
                       IF_NONE { PUSH int 614 ; FAILWITH } { CAR } ;
1475
                       DUP 3 ;
1476
                       GET 28 ;
1477
                       SWAP ;
1478
                       GET ;
1479
                       IF_NONE { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } {} ;
1480
                       PUSH nat 1024 ;
1481
                       DUP 3 ;
1482
                       CDR ;
1483
                       EDIV ;
1484
                       IF_NONE { PUSH int 616 ; FAILWITH } { CDR } ;
1485
                       LAMBDA
1486
                         (pair nat (pair bytes nat))
1487
                         (option bytes)
1488
                         { DUP ;
1489
                           UNPAIR 3 ;
1490
                           DUP 2 ;
1491
                           SIZE ;
1492
                           DUP 4 ;
1493
                           DUP 3 ;
1494
                           MUL ;
1495
                           DUP 2 ;
1496
                           DUP 2 ;
1497
                           COMPARE ;
1498
                           GE ;
1499
                           IF
1500
                             { DROP 6 ; NONE bytes }
1501
                             { DIG 2 ;
1502
                               DROP ;
1503
                               DIG 4 ;
1504
                               DROP ;
1505
                               PUSH nat 0 ;
1506
                               DUP 5 ;
1507
                               DIG 3 ;
1508
                               EDIV ;
1509
                               IF_NONE { PUSH int 90 ; FAILWITH } { CDR } ;
1510
                               COMPARE ;
1511
                               EQ ;
1512
                               IF {} { PUSH string "CORRUPTED_PAGE_SIZE" ; FAILWITH } ;
1513
                               SWAP ;
1514
                               DUG 2 ;
1515
                               SLICE ;
1516
                               IF_NONE
1517
                                 { PUSH string "SLICE_OUT_OF_BOUNDS_IN_PAGE" ; FAILWITH }
1518
                                 {} ;
1519
                               SOME } } ;
1520
                       PUSH nat 4 ;
1521
                       DIG 3 ;
1522
                       DIG 3 ;
1523
                       PAIR 3 ;
1524
                       EXEC ;
1525
                       IF_NONE { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } {} ;
1526
                       DIG 3 ;
1527
                       DUP 3 ;
1528
                       CAR ;
1529
                       SWAP ;
1530
                       DIG 4 ;
1531
                       DIG 2 ;
1532
                       PAIR ;
1533
                       EXEC ;
1534
                       UNPAIR ;
1535
                       SWAP ;
1536
                       DUG 3 ;
1537
                       IF_NONE { PUSH string "OWNER_MISMATCH" ; FAILWITH } {} ;
1538
                       BYTES ;
1539
                       DUP ;
1540
                       SIZE ;
1541
                       PUSH nat 5 ;
1542
                       DUP 2 ;
1543
                       COMPARE ;
1544
                       LT ;
1545
                       IF
1546
                         {}
1547
                         { PUSH string "Value too long, must be 4 bytes or less" ;
1548
                           FAILWITH } ;
1549
                       PUSH nat 4 ;
1550
                       DUP 2 ;
1551
                       COMPARE ;
1552
                       EQ ;
1553
                       IF
1554
                         { DROP }
1555
                         { DUP ;
1556
                           INT ;
1557
                           EQ ;
1558
                           IF
1559
                             { DROP 2 ; PUSH bytes 0x00000000 }
1560
                             { PUSH nat 1 ;
1561
                               DUP 2 ;
1562
                               COMPARE ;
1563
                               EQ ;
1564
                               IF
1565
                                 { DROP ; PUSH bytes 0x000000 ; CONCAT }
1566
                                 { PUSH nat 2 ;
1567
                                   COMPARE ;
1568
                                   EQ ;
1569
                                   IF
1570
                                     { PUSH bytes 0x0000 ; CONCAT }
1571
                                     { PUSH bytes 0x00 ; CONCAT } } } } ;
1572
                       COMPARE ;
1573
                       EQ ;
1574
                       IF {} { PUSH string "OWNER_MISMATCH" ; FAILWITH } ;
1575
                       DUP 2 ;
1576
                       GET 13 ;
1577
                       DUP 2 ;
1578
                       CDR ;
1579
                       GET ;
1580
                       IF_NONE { PUSH bool False } {} ;
1581
                       IF { PUSH string "LIEN_ACTIVE" ; FAILWITH } {} ;
1582
                       SWAP ;
1583
                       DUP ;
1584
                       GET 15 ;
1585
                       PUSH (option bool) (Some True) ;
1586
                       DIG 3 ;
1587
                       CDR ;
1588
                       UPDATE ;
1589
                       UPDATE 15 ;
1590
                       NIL operation }
1591
                     { DUP 6 ;
1592
                       UNIT ;
1593
                       SWAP ;
1594
                       DIG 3 ;
1595
                       DIG 2 ;
1596
                       PAIR ;
1597
                       EXEC ;
1598
                       UNPAIR ;
1599
                       DUG 8 ;
1600
                       DUG 8 ;
1601
                       DUG 8 ;
1602
                       DIG 7 ;
1603
                       DIG 8 ;
1604
                       DIG 8 ;
1605
                       IF {} { PUSH string "FA2_NOT_ADMIN" ; FAILWITH } ;
1606
                       DUP 2 ;
1607
                       GET 25 ;
1608
                       PUSH nat 1024 ;
1609
                       DUP 2 ;
1610
                       EDIV ;
1611
                       IF_NONE { PUSH int 274 ; FAILWITH } { CAR } ;
1612
                       DUP 4 ;
1613
                       GET 28 ;
1614
                       DUP 2 ;
1615
                       GET ;
1616
                       IF_NONE { PUSH bytes 0x } {} ;
1617
                       PUSH bool True ;
1618
                       NIL operation ;
1619
                       DUP 6 ;
1620
                       ITER { LAMBDA
1621
                                bytes
1622
                                bytes
1623
                                { DUP ;
1624
                                  SIZE ;
1625
                                  PUSH nat 5 ;
1626
                                  DUP 2 ;
1627
                                  COMPARE ;
1628
                                  LT ;
1629
                                  IF
1630
                                    {}
1631
                                    { PUSH string "Value too long, must be 4 bytes or less" ;
1632
                                      FAILWITH } ;
1633
                                  PUSH nat 4 ;
1634
                                  DUP 2 ;
1635
                                  COMPARE ;
1636
                                  EQ ;
1637
                                  IF
1638
                                    { DROP }
1639
                                    { DUP ;
1640
                                      INT ;
1641
                                      EQ ;
1642
                                      IF
1643
                                        { DROP 2 ; PUSH bytes 0x00000000 }
1644
                                        { PUSH nat 1 ;
1645
                                          DUP 2 ;
1646
                                          COMPARE ;
1647
                                          EQ ;
1648
                                          IF
1649
                                            { DROP ; PUSH bytes 0x000000 ; CONCAT }
1650
                                            { PUSH nat 2 ;
1651
                                              COMPARE ;
1652
                                              EQ ;
1653
                                              IF
1654
                                                { PUSH bytes 0x0000 ; CONCAT }
1655
                                                { PUSH bytes 0x00 ; CONCAT } } } } } ;
1656
                              DUP 14 ;
1657
                              DUP 3 ;
1658
                              CAR ;
1659
                              SWAP ;
1660
                              DIG 10 ;
1661
                              DIG 2 ;
1662
                              PAIR ;
1663
                              EXEC ;
1664
                              UNPAIR ;
1665
                              DIG 15 ;
1666
                              DIG 15 ;
1667
                              DIG 15 ;
1668
                              DIG 15 ;
1669
                              DIG 15 ;
1670
                              DIG 15 ;
1671
                              DIG 7 ;
1672
                              DUG 15 ;
1673
                              DUG 15 ;
1674
                              DUG 15 ;
1675
                              DUG 15 ;
1676
                              DUG 15 ;
1677
                              DUG 15 ;
1678
                              DUG 15 ;
1679
                              BYTES ;
1680
                              EXEC ;
1681
                              PUSH nat 1024 ;
1682
                              DUP 8 ;
1683
                              EDIV ;
1684
                              IF_NONE { PUSH int 282 ; FAILWITH } { CDR } ;
1685
                              DUP ;
1686
                              INT ;
1687
                              EQ ;
1688
                              IF { DUP 5 ; NOT } { PUSH bool False } ;
1689
                              IF
1690
                                { DIG 9 ;
1691
                                  DUP ;
1692
                                  GET 28 ;
1693
                                  DIG 7 ;
1694
                                  SOME ;
1695
                                  DUP 9 ;
1696
                                  UPDATE ;
1697
                                  UPDATE 28 ;
1698
                                  DUG 8 ;
1699
                                  PUSH bytes 0x ;
1700
                                  DUG 5 ;
1701
                                  DIG 6 ;
1702
                                  PUSH nat 1 ;
1703
                                  ADD ;
1704
                                  DUG 6 }
1705
                                {} ;
1706
                              LAMBDA
1707
                                (pair nat (pair bytes bytes))
1708
                                bytes
1709
                                { DUP ;
1710
                                  UNPAIR 3 ;
1711
                                  PUSH nat 4 ;
1712
                                  PUSH nat 1 ;
1713
                                  DUP 3 ;
1714
                                  ADD ;
1715
                                  MUL ;
1716
                                  DUP 3 ;
1717
                                  SIZE ;
1718
                                  DUP 2 ;
1719
                                  DUP 2 ;
1720
                                  COMPARE ;
1721
                                  LT ;
1722
                                  LOOP { PUSH bytes 0x00000000 ;
1723
                                         DIG 4 ;
1724
                                         CONCAT ;
1725
                                         DUG 3 ;
1726
                                         PUSH nat 4 ;
1727
                                         ADD ;
1728
                                         DUP 2 ;
1729
                                         DUP 2 ;
1730
                                         COMPARE ;
1731
                                         LT } ;
1732
                                  DROP 2 ;
1733
                                  DIG 3 ;
1734
                                  DROP ;
1735
                                  LAMBDA
1736
                                    (pair nat (pair bytes bytes))
1737
                                    bytes
1738
                                    { DUP ;
1739
                                      UNPAIR 3 ;
1740
                                      DUP 3 ;
1741
                                      SIZE ;
1742
                                      DUP 3 ;
1743
                                      SIZE ;
1744
                                      PUSH nat 0 ;
1745
                                      DUP 3 ;
1746
                                      DUP 3 ;
1747
                                      EDIV ;
1748
                                      IF_NONE { PUSH int 102 ; FAILWITH } { CDR } ;
1749
                                      COMPARE ;
1750
                                      EQ ;
1751
                                      IF
1752
                                        {}
1753
                                        { PUSH string "UPDATE_PAGE_CORRUPTED_SIZE" ;
1754
                                          FAILWITH } ;
1755
                                      DUP 2 ;
1756
                                      DUP 4 ;
1757
                                      MUL ;
1758
                                      DUP 3 ;
1759
                                      DUP 2 ;
1760
                                      ADD ;
1761
                                      DUP 2 ;
1762
                                      INT ;
1763
                                      EQ ;
1764
                                      IF
1765
                                        { PUSH bytes 0x }
1766
                                        { DUP 6 ;
1767
                                          DUP 3 ;
1768
                                          PUSH nat 0 ;
1769
                                          SLICE ;
1770
                                          IF_NONE
1771
                                            { PUSH string "UPDATE_INDEX_OUT_OF_BOUNDS" ;
1772
                                              FAILWITH }
1773
                                            {} } ;
1774
                                      DUP 4 ;
1775
                                      DUP 3 ;
1776
                                      COMPARE ;
1777
                                      EQ ;
1778
                                      IF
1779
                                        { SWAP ;
1780
                                          DROP ;
1781
                                          SWAP ;
1782
                                          DROP ;
1783
                                          SWAP ;
1784
                                          DROP ;
1785
                                          SWAP ;
1786
                                          DROP ;
1787
                                          SWAP ;
1788
                                          DROP ;
1789
                                          SWAP ;
1790
                                          DROP ;
1791
                                          DIG 2 ;
1792
                                          DROP ;
1793
                                          CONCAT }
1794
                                        { DIG 2 ;
1795
                                          DROP ;
1796
                                          DIG 3 ;
1797
                                          DROP ;
1798
                                          DIG 3 ;
1799
                                          DROP ;
1800
                                          DIG 5 ;
1801
                                          DROP ;
1802
                                          DUP 2 ;
1803
                                          DIG 3 ;
1804
                                          SUB ;
1805
                                          ISNAT ;
1806
                                          IF_NONE
1807
                                            { PUSH string "UPDATE_SLICE_OUT_OF_BOUNDS" ;
1808
                                              FAILWITH }
1809
                                            {} ;
1810
                                          DIG 3 ;
1811
                                          SWAP ;
1812
                                          DIG 3 ;
1813
                                          SLICE ;
1814
                                          IF_NONE { PUSH int 116 ; FAILWITH } {} ;
1815
                                          NIL bytes ;
1816
                                          SWAP ;
1817
                                          CONS ;
1818
                                          DIG 2 ;
1819
                                          CONS ;
1820
                                          SWAP ;
1821
                                          CONS ;
1822
                                          CONCAT } } ;
1823
                                  DUG 3 ;
1824
                                  PAIR 3 ;
1825
                                  EXEC } ;
1826
                              DUP 3 ;
1827
                              DIG 7 ;
1828
                              DUP 4 ;
1829
                              PAIR 3 ;
1830
                              EXEC ;
1831
                              DUG 5 ;
1832
                              PUSH nat 128 ;
1833
                              DUP 9 ;
1834
                              EDIV ;
1835
                              IF_NONE { PUSH int 290 ; FAILWITH } { CAR } ;
1836
                              PUSH nat 128 ;
1837
                              DUP 10 ;
1838
                              EDIV ;
1839
                              IF_NONE { PUSH int 291 ; FAILWITH } { CDR } ;
1840
                              DUP 12 ;
1841
                              GET 21 ;
1842
                              DUP 3 ;
1843
                              GET ;
1844
                              IF_NONE { PUSH bytes 0x } {} ;
1845
                              DIG 12 ;
1846
                              DUP ;
1847
                              GET 21 ;
1848
                              LAMBDA
1849
                                (pair nat (pair bytes bytes))
1850
                                bytes
1851
                                { DUP ;
1852
                                  UNPAIR 3 ;
1853
                                  PUSH nat 32 ;
1854
                                  PUSH nat 1 ;
1855
                                  DUP 3 ;
1856
                                  ADD ;
1857
                                  MUL ;
1858
                                  DUP 3 ;
1859
                                  SIZE ;
1860
                                  DUP 2 ;
1861
                                  DUP 2 ;
1862
                                  COMPARE ;
1863
                                  LT ;
1864
                                  LOOP { PUSH bytes 0x0000000000000000000000000000000000000000000000000000000000000000 ;
1865
                                         DIG 4 ;
1866
                                         CONCAT ;
1867
                                         DUG 3 ;
1868
                                         PUSH nat 32 ;
1869
                                         ADD ;
1870
                                         DUP 2 ;
1871
                                         DUP 2 ;
1872
                                         COMPARE ;
1873
                                         LT } ;
1874
                                  DROP 2 ;
1875
                                  DIG 3 ;
1876
                                  DROP ;
1877
                                  LAMBDA
1878
                                    (pair nat (pair bytes bytes))
1879
                                    bytes
1880
                                    { DUP ;
1881
                                      UNPAIR 3 ;
1882
                                      DUP 3 ;
1883
                                      SIZE ;
1884
                                      DUP 3 ;
1885
                                      SIZE ;
1886
                                      PUSH nat 0 ;
1887
                                      DUP 3 ;
1888
                                      DUP 3 ;
1889
                                      EDIV ;
1890
                                      IF_NONE { PUSH int 102 ; FAILWITH } { CDR } ;
1891
                                      COMPARE ;
1892
                                      EQ ;
1893
                                      IF
1894
                                        {}
1895
                                        { PUSH string "UPDATE_PAGE_CORRUPTED_SIZE" ;
1896
                                          FAILWITH } ;
1897
                                      DUP 2 ;
1898
                                      DUP 4 ;
1899
                                      MUL ;
1900
                                      DUP 3 ;
1901
                                      DUP 2 ;
1902
                                      ADD ;
1903
                                      DUP 2 ;
1904
                                      INT ;
1905
                                      EQ ;
1906
                                      IF
1907
                                        { PUSH bytes 0x }
1908
                                        { DUP 6 ;
1909
                                          DUP 3 ;
1910
                                          PUSH nat 0 ;
1911
                                          SLICE ;
1912
                                          IF_NONE
1913
                                            { PUSH string "UPDATE_INDEX_OUT_OF_BOUNDS" ;
1914
                                              FAILWITH }
1915
                                            {} } ;
1916
                                      DUP 4 ;
1917
                                      DUP 3 ;
1918
                                      COMPARE ;
1919
                                      EQ ;
1920
                                      IF
1921
                                        { SWAP ;
1922
                                          DROP ;
1923
                                          SWAP ;
1924
                                          DROP ;
1925
                                          SWAP ;
1926
                                          DROP ;
1927
                                          SWAP ;
1928
                                          DROP ;
1929
                                          SWAP ;
1930
                                          DROP ;
1931
                                          SWAP ;
1932
                                          DROP ;
1933
                                          DIG 2 ;
1934
                                          DROP ;
1935
                                          CONCAT }
1936
                                        { DIG 2 ;
1937
                                          DROP ;
1938
                                          DIG 3 ;
1939
                                          DROP ;
1940
                                          DIG 3 ;
1941
                                          DROP ;
1942
                                          DIG 5 ;
1943
                                          DROP ;
1944
                                          DUP 2 ;
1945
                                          DIG 3 ;
1946
                                          SUB ;
1947
                                          ISNAT ;
1948
                                          IF_NONE
1949
                                            { PUSH string "UPDATE_SLICE_OUT_OF_BOUNDS" ;
1950
                                              FAILWITH }
1951
                                            {} ;
1952
                                          DIG 3 ;
1953
                                          SWAP ;
1954
                                          DIG 3 ;
1955
                                          SLICE ;
1956
                                          IF_NONE { PUSH int 116 ; FAILWITH } {} ;
1957
                                          NIL bytes ;
1958
                                          SWAP ;
1959
                                          CONS ;
1960
                                          DIG 2 ;
1961
                                          CONS ;
1962
                                          SWAP ;
1963
                                          CONS ;
1964
                                          CONCAT } } ;
1965
                                  DUG 3 ;
1966
                                  PAIR 3 ;
1967
                                  EXEC } ;
1968
                              DUP 9 ;
1969
                              CDR ;
1970
                              DUP 5 ;
1971
                              DUP 7 ;
1972
                              PAIR 3 ;
1973
                              EXEC ;
1974
                              SOME ;
1975
                              DUP 6 ;
1976
                              UPDATE ;
1977
                              UPDATE 21 ;
1978
                              DUG 12 ;
1979
                              DUP 7 ;
1980
                              DUP 12 ;
1981
                              DUP 8 ;
1982
                              CAR ;
1983
                              PUSH nat 1 ;
1984
                              PUSH int 1 ;
1985
                              PAIR 4 ;
1986
                              DIG 2 ;
1987
                              DROP ;
1988
                              DIG 2 ;
1989
                              DROP ;
1990
                              DIG 2 ;
1991
                              DROP ;
1992
                              DIG 2 ;
1993
                              DROP ;
1994
                              DIG 2 ;
1995
                              DROP ;
1996
                              DIG 2 ;
1997
                              DROP ;
1998
                              DIG 2 ;
1999
                              DROP ;
2000
                              DIG 2 ;
2001
                              DROP ;
2002
                              EMIT %balance_update (pair (int %diff)
2003
                                                         (pair (nat %new_balance)
2004
                                                               (pair (address %owner)
2005
                                                                     (nat %token_id)))) ;
2006
                              CONS ;
2007
                              DUP 4 ;
2008
                              PUSH nat 1 ;
2009
                              PUSH int 1 ;
2010
                              PAIR 3 ;
2011
                              EMIT %total_supply_update (pair (int %diff)
2012
                                                              (pair
2013
                                                                (nat %new_total_supply)
2014
                                                                (nat %token_id))) ;
2015
                              CONS ;
2016
                              DIG 3 ;
2017
                              PUSH nat 1 ;
2018
                              ADD ;
2019
                              DUG 3 ;
2020
                              PUSH bool False ;
2021
                              SWAP } ;
2022
                       SWAP ;
2023
                       DROP ;
2024
                       DIG 4 ;
2025
                       DROP ;
2026
                       DIG 5 ;
2027
                       DROP ;
2028
                       DIG 5 ;
2029
                       DROP ;
2030
                       DIG 5 ;
2031
                       DROP ;
2032
                       DIG 5 ;
2033
                       DROP ;
2034
                       DIG 5 ;
2035
                       DROP ;
2036
                       DIG 5 ;
2037
                       DROP ;
2038
                       DIG 4 ;
2039
                       DIG 4 ;
2040
                       UPDATE 25 ;
2041
                       DUP ;
2042
                       GET 28 ;
2043
                       DIG 3 ;
2044
                       SOME ;
2045
                       DIG 4 ;
2046
                       UPDATE ;
2047
                       UPDATE 28 ;
2048
                       SWAP } }
2049
                 { IF_LEFT
2050
                     { DUP 6 ;
2051
                       UNIT ;
2052
                       SWAP ;
2053
                       DIG 3 ;
2054
                       DIG 2 ;
2055
                       PAIR ;
2056
                       EXEC ;
2057
                       UNPAIR ;
2058
                       DUG 8 ;
2059
                       DUG 8 ;
2060
                       DUG 8 ;
2061
                       DIG 7 ;
2062
                       DIG 8 ;
2063
                       DIG 8 ;
2064
                       IF {} { PUSH string "FA2_NOT_ADMIN" ; FAILWITH } ;
2065
                       DUP ;
2066
                       CAR ;
2067
                       SIZE ;
2068
                       DUP ;
2069
                       INT ;
2070
                       GT ;
2071
                       IF {} { PUSH string "EMPTY_PAGES" ; FAILWITH } ;
2072
                       PUSH nat 32 ;
2073
                       PUSH nat 128 ;
2074
                       MUL ;
2075
                       PUSH nat 128 ;
2076
                       DUP 4 ;
2077
                       CDR ;
2078
                       EDIV ;
2079
                       IF_NONE { PUSH int 405 ; FAILWITH } { CAR } ;
2080
                       PUSH bool True ;
2081
                       PUSH nat 0 ;
2082
                       DUP 6 ;
2083
                       CAR ;
2084
                       ITER { DUP ;
2085
                              SIZE ;
2086
                              DUP ;
2087
                              INT ;
2088
                              GT ;
2089
                              IF {} { PUSH string "EMPTY_PAGE" ; FAILWITH } ;
2090
                              PUSH nat 0 ;
2091
                              PUSH nat 32 ;
2092
                              DUP 3 ;
2093
                              EDIV ;
2094
                              IF_NONE { PUSH int 412 ; FAILWITH } { CDR } ;
2095
                              COMPARE ;
2096
                              EQ ;
2097
                              IF {} { PUSH string "INVALID_PAGE_SIZE" ; FAILWITH } ;
2098
                              DUP 6 ;
2099
                              DUP 2 ;
2100
                              COMPARE ;
2101
                              LE ;
2102
                              IF {} { PUSH string "PAGE_TOO_LARGE" ; FAILWITH } ;
2103
                              DIG 2 ;
2104
                              PUSH nat 1 ;
2105
                              ADD ;
2106
                              DUG 2 ;
2107
                              DUP 7 ;
2108
                              DUP 4 ;
2109
                              COMPARE ;
2110
                              LT ;
2111
                              IF
2112
                                { DUP 6 ;
2113
                                  DUP 2 ;
2114
                                  COMPARE ;
2115
                                  EQ ;
2116
                                  IF
2117
                                    {}
2118
                                    { PUSH string "INTERMEDIATE_PAGE_NOT_FULL" ;
2119
                                      FAILWITH } }
2120
                                {} ;
2121
                              DUP 4 ;
2122
                              IF
2123
                                { DIG 3 ;
2124
                                  DROP ;
2125
                                  DUP 8 ;
2126
                                  GET 21 ;
2127
                                  DUP 5 ;
2128
                                  GET ;
2129
                                  IF_NONE { PUSH bytes 0x } {} ;
2130
                                  DUP ;
2131
                                  SIZE ;
2132
                                  DUP ;
2133
                                  INT ;
2134
                                  GT ;
2135
                                  IF
2136
                                    { DUP ;
2137
                                      DIG 3 ;
2138
                                      COMPARE ;
2139
                                      GE ;
2140
                                      IF
2141
                                        {}
2142
                                        { PUSH string "PAGE_SHORTER_THAN_EXISTING" ;
2143
                                          FAILWITH } ;
2144
                                      SWAP ;
2145
                                      DUP 3 ;
2146
                                      DIG 2 ;
2147
                                      PUSH nat 0 ;
2148
                                      SLICE ;
2149
                                      IF_NONE
2150
                                        { PUSH string "SLICE_ERROR" ; FAILWITH }
2151
                                        {} ;
2152
                                      COMPARE ;
2153
                                      EQ ;
2154
                                      IF
2155
                                        {}
2156
                                        { PUSH string "OVERLAP_MISMATCH" ; FAILWITH } }
2157
                                    { DROP 3 } ;
2158
                                  PUSH bool False ;
2159
                                  DUG 2 }
2160
                                { DROP } ;
2161
                              DIG 7 ;
2162
                              DUP ;
2163
                              GET 21 ;
2164
                              DIG 2 ;
2165
                              SOME ;
2166
                              DUP 6 ;
2167
                              UPDATE ;
2168
                              UPDATE 21 ;
2169
                              DUG 6 ;
2170
                              DIG 2 ;
2171
                              PUSH nat 1 ;
2172
                              ADD ;
2173
                              DUG 2 } ;
2174
                       DROP 6 ;
2175
                       SWAP ;
2176
                       DROP ;
2177
                       SWAP ;
2178
                       DROP ;
2179
                       SWAP ;
2180
                       DROP ;
2181
                       SWAP ;
2182
                       DROP ;
2183
                       SWAP ;
2184
                       DROP ;
2185
                       SWAP ;
2186
                       DROP }
2187
                     { IF_LEFT
2188
                         { DUP 6 ;
2189
                           UNIT ;
2190
                           SWAP ;
2191
                           DIG 3 ;
2192
                           DIG 2 ;
2193
                           PAIR ;
2194
                           EXEC ;
2195
                           UNPAIR ;
2196
                           DUG 8 ;
2197
                           DUG 8 ;
2198
                           DUG 8 ;
2199
                           DIG 7 ;
2200
                           DIG 8 ;
2201
                           DIG 8 ;
2202
                           IF {} { PUSH string "FA2_NOT_ADMIN" ; FAILWITH } ;
2203
                           DUP ;
2204
                           CAR ;
2205
                           DUP 3 ;
2206
                           GET 25 ;
2207
                           COMPARE ;
2208
                           EQ ;
2209
                           IF {} { PUSH string "RACE_CONDITION" ; FAILWITH } ;
2210
                           DUP ;
2211
                           CDR ;
2212
                           SIZE ;
2213
                           DUP ;
2214
                           INT ;
2215
                           GT ;
2216
                           IF {} { PUSH string "EMPTY_PAGES" ; FAILWITH } ;
2217
                           PUSH nat 4 ;
2218
                           PUSH nat 1024 ;
2219
                           MUL ;
2220
                           PUSH nat 1024 ;
2221
                           DUP 4 ;
2222
                           CAR ;
2223
                           EDIV ;
2224
                           IF_NONE { PUSH int 340 ; FAILWITH } { CAR } ;
2225
                           PUSH bool True ;
2226
                           PUSH nat 0 ;
2227
                           PUSH nat 0 ;
2228
                           DUP 7 ;
2229
                           CDR ;
2230
                           ITER { DUP ;
2231
                                  SIZE ;
2232
                                  DUP ;
2233
                                  INT ;
2234
                                  GT ;
2235
                                  IF {} { PUSH string "EMPTY_PAGE" ; FAILWITH } ;
2236
                                  PUSH nat 0 ;
2237
                                  PUSH nat 4 ;
2238
                                  DUP 3 ;
2239
                                  EDIV ;
2240
                                  IF_NONE { PUSH int 348 ; FAILWITH } { CDR } ;
2241
                                  COMPARE ;
2242
                                  EQ ;
2243
                                  IF {} { PUSH string "INVALID_PAGE_SIZE" ; FAILWITH } ;
2244
                                  DUP 7 ;
2245
                                  DUP 2 ;
2246
                                  COMPARE ;
2247
                                  LE ;
2248
                                  IF {} { PUSH string "PAGE_TOO_LARGE" ; FAILWITH } ;
2249
                                  DIG 2 ;
2250
                                  PUSH nat 1 ;
2251
                                  ADD ;
2252
                                  DUG 2 ;
2253
                                  DUP 8 ;
2254
                                  DUP 4 ;
2255
                                  COMPARE ;
2256
                                  LT ;
2257
                                  IF
2258
                                    { DUP 7 ;
2259
                                      DUP 2 ;
2260
                                      COMPARE ;
2261
                                      EQ ;
2262
                                      IF
2263
                                        {}
2264
                                        { PUSH string "INTERMEDIATE_PAGE_NOT_FULL" ;
2265
                                          FAILWITH } }
2266
                                    {} ;
2267
                                  DUP 5 ;
2268
                                  IF
2269
                                    { DIG 4 ;
2270
                                      DROP ;
2271
                                      DUP 9 ;
2272
                                      GET 28 ;
2273
                                      DUP 6 ;
2274
                                      GET ;
2275
                                      IF_NONE { PUSH bytes 0x } {} ;
2276
                                      DUP ;
2277
                                      SIZE ;
2278
                                      DUP ;
2279
                                      INT ;
2280
                                      GT ;
2281
                                      IF
2282
                                        { DIG 5 ;
2283
                                          DROP ;
2284
                                          DUP ;
2285
                                          DUP 4 ;
2286
                                          COMPARE ;
2287
                                          GE ;
2288
                                          IF
2289
                                            {}
2290
                                            { PUSH string "PAGE_SHORTER_THAN_EXISTING" ;
2291
                                              FAILWITH } ;
2292
                                          SWAP ;
2293
                                          DUP 4 ;
2294
                                          DIG 2 ;
2295
                                          PUSH nat 0 ;
2296
                                          SLICE ;
2297
                                          IF_NONE
2298
                                            { PUSH string "SLICE_ERROR" ; FAILWITH }
2299
                                            {} ;
2300
                                          COMPARE ;
2301
                                          EQ ;
2302
                                          IF
2303
                                            {}
2304
                                            { PUSH string "OVERLAP_MISMATCH" ; FAILWITH } }
2305
                                        { DROP 2 ; DIG 3 ; DROP } ;
2306
                                      PUSH bool False ;
2307
                                      DUG 3 }
2308
                                    { DIG 3 ; DROP } ;
2309
                                  PUSH nat 4 ;
2310
                                  SWAP ;
2311
                                  EDIV ;
2312
                                  IF_NONE { PUSH int 366 ; FAILWITH } { CAR } ;
2313
                                  DUG 2 ;
2314
                                  DIG 8 ;
2315
                                  DUP ;
2316
                                  GET 28 ;
2317
                                  DIG 2 ;
2318
                                  SOME ;
2319
                                  DUP 7 ;
2320
                                  UPDATE ;
2321
                                  UPDATE 28 ;
2322
                                  DUG 7 ;
2323
                                  DIG 3 ;
2324
                                  PUSH nat 1 ;
2325
                                  ADD ;
2326
                                  DUG 3 } ;
2327
                           DROP ;
2328
                           SWAP ;
2329
                           DROP ;
2330
                           DIG 2 ;
2331
                           DROP ;
2332
                           DIG 2 ;
2333
                           DROP ;
2334
                           DIG 2 ;
2335
                           DROP ;
2336
                           DIG 3 ;
2337
                           DROP ;
2338
                           DIG 3 ;
2339
                           DROP ;
2340
                           DIG 3 ;
2341
                           DROP ;
2342
                           DIG 3 ;
2343
                           DROP ;
2344
                           DIG 3 ;
2345
                           DROP ;
2346
                           DIG 3 ;
2347
                           DROP ;
2348
                           DIG 2 ;
2349
                           SWAP ;
2350
                           PUSH nat 1024 ;
2351
                           PUSH nat 1 ;
2352
                           DIG 4 ;
2353
                           SUB ;
2354
                           ISNAT ;
2355
                           IF_NONE { PUSH int 371 ; FAILWITH } {} ;
2356
                           MUL ;
2357
                           ADD ;
2358
                           UPDATE 25 }
2359
                         { DIG 2 ;
2360
                           DROP ;
2361
                           DIG 2 ;
2362
                           DROP ;
2363
                           DIG 2 ;
2364
                           DROP ;
2365
                           DIG 3 ;
2366
                           DROP ;
2367
                           DIG 3 ;
2368
                           DROP ;
2369
                           DIG 2 ;
2370
                           UNIT ;
2371
                           SWAP ;
2372
                           DIG 3 ;
2373
                           DIG 2 ;
2374
                           PAIR ;
2375
                           EXEC ;
2376
                           UNPAIR ;
2377
                           SWAP ;
2378
                           DUG 2 ;
2379
                           IF {} { PUSH string "FA2_NOT_ADMIN" ; FAILWITH } ;
2380
                           DUP ;
2381
                           CAR ;
2382
                           DUP 3 ;
2383
                           GET 5 ;
2384
                           COMPARE ;
2385
                           EQ ;
2386
                           IF {} { PUSH string "HUB_MISMATCH" ; FAILWITH } ;
2387
                           CDR ;
2388
                           UPDATE 5 } } ;
2389
                   NIL operation } } }
2390
         { IF_LEFT
2391
             { IF_LEFT
2392
                 { IF_LEFT
2393
                     { DUP 6 ;
2394
                       UNIT ;
2395
                       SWAP ;
2396
                       DIG 3 ;
2397
                       DIG 2 ;
2398
                       PAIR ;
2399
                       EXEC ;
2400
                       UNPAIR ;
2401
                       DUG 8 ;
2402
                       DUG 8 ;
2403
                       DUG 8 ;
2404
                       DIG 7 ;
2405
                       DIG 8 ;
2406
                       DIG 8 ;
2407
                       IF {} { PUSH string "FA2_NOT_ADMIN" ; FAILWITH } ;
2408
                       DUP ;
2409
                       CAR ;
2410
                       ITER { DUP 3 ;
2411
                              GET 25 ;
2412
                              DUP 2 ;
2413
                              COMPARE ;
2414
                              LT ;
2415
                              IF {} { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;
2416
                              DIG 2 ;
2417
                              DUP ;
2418
                              GET 9 ;
2419
                              DUP 4 ;
2420
                              CDR ;
2421
                              SOME ;
2422
                              DIG 3 ;
2423
                              UPDATE ;
2424
                              UPDATE 9 ;
2425
                              SWAP } ;
2426
                       DROP ;
2427
                       SWAP ;
2428
                       DROP ;
2429
                       SWAP ;
2430
                       DROP ;
2431
                       SWAP ;
2432
                       DROP ;
2433
                       SWAP ;
2434
                       DROP ;
2435
                       SWAP ;
2436
                       DROP ;
2437
                       SWAP ;
2438
                       DROP }
2439
                     { DIG 2 ;
2440
                       DROP ;
2441
                       DIG 2 ;
2442
                       DROP ;
2443
                       DIG 2 ;
2444
                       DROP ;
2445
                       DIG 3 ;
2446
                       DROP ;
2447
                       DIG 3 ;
2448
                       DROP ;
2449
                       DIG 2 ;
2450
                       UNIT ;
2451
                       SWAP ;
2452
                       DIG 3 ;
2453
                       DIG 2 ;
2454
                       PAIR ;
2455
                       EXEC ;
2456
                       UNPAIR ;
2457
                       SWAP ;
2458
                       DUG 2 ;
2459
                       IF {} { PUSH string "FA2_NOT_ADMIN" ; FAILWITH } ;
2460
                       SWAP ;
2461
                       DUP ;
2462
                       GET 7 ;
2463
                       DUP 3 ;
2464
                       CDR ;
2465
                       SOME ;
2466
                       DIG 3 ;
2467
                       CAR ;
2468
                       UPDATE ;
2469
                       UPDATE 7 } ;
2470
                   NIL operation }
2471
                 { IF_LEFT
2472
                     { DIG 2 ;
2473
                       DROP ;
2474
                       DIG 3 ;
2475
                       DROP ;
2476
                       DIG 2 ;
2477
                       SWAP ;
2478
                       DUP ;
2479
                       CAR ;
2480
                       DIG 2 ;
2481
                       DIG 3 ;
2482
                       DIG 2 ;
2483
                       PAIR ;
2484
                       EXEC ;
2485
                       UNPAIR ;
2486
                       DIG 5 ;
2487
                       DIG 5 ;
2488
                       DIG 5 ;
2489
                       DIG 4 ;
2490
                       DIG 5 ;
2491
                       DIG 5 ;
2492
                       IF
2493
                         { DIG 2 ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP ; PUSH bool True }
2494
                         { DIG 3 ;
2495
                           DROP ;
2496
                           DIG 3 ;
2497
                           DROP ;
2498
                           DIG 2 ;
2499
                           UNIT ;
2500
                           SWAP ;
2501
                           DIG 3 ;
2502
                           DIG 2 ;
2503
                           PAIR ;
2504
                           EXEC ;
2505
                           UNPAIR ;
2506
                           SWAP ;
2507
                           DUG 2 } ;
2508
                       IF {} { PUSH string "NOT_AUTHORIZED" ; FAILWITH } ;
2509
                       SWAP ;
2510
                       DUP ;
2511
                       GET 11 ;
2512
                       DUP 3 ;
2513
                       CDR ;
2514
                       SOME ;
2515
                       DUP 4 ;
2516
                       CAR ;
2517
                       UPDATE ;
2518
                       UPDATE 11 ;
2519
                       SWAP ;
2520
                       EMIT %JurisdictionUriSet (pair (string %jurisdiction)
2521
                                                      (bytes %uri)) ;
2522
                       NIL operation ;
2523
                       SWAP ;
2524
                       CONS }
2525
                     { IF_LEFT
2526
                         { DIG 2 ;
2527
                           DROP ;
2528
                           DIG 3 ;
2529
                           DROP ;
2530
                           DIG 3 ;
2531
                           DROP ;
2532
                           DIG 3 ;
2533
                           DROP ;
2534
                           DIG 3 ;
2535
                           DROP ;
2536
                           DUP 2 ;
2537
                           GET 25 ;
2538
                           DUP 2 ;
2539
                           COMPARE ;
2540
                           LT ;
2541
                           IF {} { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;
2542
                           DUP 2 ;
2543
                           GET 9 ;
2544
                           DUP 2 ;
2545
                           GET ;
2546
                           IF_NONE { PUSH string "" } {} ;
2547
                           DIG 3 ;
2548
                           DIG 3 ;
2549
                           DIG 2 ;
2550
                           PAIR ;
2551
                           EXEC ;
2552
                           UNPAIR ;
2553
                           SWAP ;
2554
                           DUG 2 ;
2555
                           IF {} { PUSH string "NOT_JURISDICTION_ADMIN" ; FAILWITH } ;
2556
                           SWAP ;
2557
                           DUP ;
2558
                           GET 13 ;
2559
                           PUSH (option bool) (Some True) ;
2560
                           DIG 3 ;
2561
                           UPDATE ;
2562
                           UPDATE 13 ;
2563
                           NIL operation }
2564
                         { DUP 5 ;
2565
                           UNIT ;
2566
                           SWAP ;
2567
                           DIG 3 ;
2568
                           DIG 2 ;
2569
                           PAIR ;
2570
                           EXEC ;
2571
                           UNPAIR ;
2572
                           DUG 8 ;
2573
                           DUG 8 ;
2574
                           DUG 8 ;
2575
                           DIG 7 ;
2576
                           DIG 8 ;
2577
                           DIG 8 ;
2578
                           IF {} { PUSH string "NOT_HUB" ; FAILWITH } ;
2579
                           DUP ;
2580
                           CAR ;
2581
                           DUP 3 ;
2582
                           GET 25 ;
2583
                           DUP 2 ;
2584
                           COMPARE ;
2585
                           LT ;
2586
                           IF {} { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;
2587
                           PUSH nat 1024 ;
2588
                           DUP 2 ;
2589
                           EDIV ;
2590
                           IF_NONE { PUSH int 669 ; FAILWITH } { CAR } ;
2591
                           DUP 4 ;
2592
                           GET 28 ;
2593
                           DUP 2 ;
2594
                           GET ;
2595
                           IF_NONE { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } {} ;
2596
                           PUSH nat 1024 ;
2597
                           DUP 4 ;
2598
                           EDIV ;
2599
                           IF_NONE { PUSH int 671 ; FAILWITH } { CDR } ;
2600
                           DIG 5 ;
2601
                           DUP ;
2602
                           GET 28 ;
2603
                           LAMBDA
2604
                             (pair nat (pair bytes bytes))
2605
                             bytes
2606
                             { DUP ;
2607
                               UNPAIR 3 ;
2608
                               DUP 3 ;
2609
                               SIZE ;
2610
                               DUP 3 ;
2611
                               SIZE ;
2612
                               PUSH nat 0 ;
2613
                               DUP 3 ;
2614
                               DUP 3 ;
2615
                               EDIV ;
2616
                               IF_NONE { PUSH int 102 ; FAILWITH } { CDR } ;
2617
                               COMPARE ;
2618
                               EQ ;
2619
                               IF
2620
                                 {}
2621
                                 { PUSH string "UPDATE_PAGE_CORRUPTED_SIZE" ; FAILWITH } ;
2622
                               DUP 2 ;
2623
                               DUP 4 ;
2624
                               MUL ;
2625
                               DUP 3 ;
2626
                               DUP 2 ;
2627
                               ADD ;
2628
                               DUP 2 ;
2629
                               INT ;
2630
                               EQ ;
2631
                               IF
2632
                                 { PUSH bytes 0x }
2633
                                 { DUP 6 ;
2634
                                   DUP 3 ;
2635
                                   PUSH nat 0 ;
2636
                                   SLICE ;
2637
                                   IF_NONE
2638
                                     { PUSH string "UPDATE_INDEX_OUT_OF_BOUNDS" ;
2639
                                       FAILWITH }
2640
                                     {} } ;
2641
                               DUP 4 ;
2642
                               DUP 3 ;
2643
                               COMPARE ;
2644
                               EQ ;
2645
                               IF
2646
                                 { SWAP ;
2647
                                   DROP ;
2648
                                   SWAP ;
2649
                                   DROP ;
2650
                                   SWAP ;
2651
                                   DROP ;
2652
                                   SWAP ;
2653
                                   DROP ;
2654
                                   SWAP ;
2655
                                   DROP ;
2656
                                   SWAP ;
2657
                                   DROP ;
2658
                                   DIG 2 ;
2659
                                   DROP ;
2660
                                   CONCAT }
2661
                                 { DIG 2 ;
2662
                                   DROP ;
2663
                                   DIG 3 ;
2664
                                   DROP ;
2665
                                   DIG 3 ;
2666
                                   DROP ;
2667
                                   DIG 5 ;
2668
                                   DROP ;
2669
                                   DUP 2 ;
2670
                                   DIG 3 ;
2671
                                   SUB ;
2672
                                   ISNAT ;
2673
                                   IF_NONE
2674
                                     { PUSH string "UPDATE_SLICE_OUT_OF_BOUNDS" ;
2675
                                       FAILWITH }
2676
                                     {} ;
2677
                                   DIG 3 ;
2678
                                   SWAP ;
2679
                                   DIG 3 ;
2680
                                   SLICE ;
2681
                                   IF_NONE { PUSH int 116 ; FAILWITH } {} ;
2682
                                   NIL bytes ;
2683
                                   SWAP ;
2684
                                   CONS ;
2685
                                   DIG 2 ;
2686
                                   CONS ;
2687
                                   SWAP ;
2688
                                   CONS ;
2689
                                   CONCAT } } ;
2690
                           PUSH bytes 0x00000000 ;
2691
                           DUP 6 ;
2692
                           DUP 6 ;
2693
                           PAIR 3 ;
2694
                           EXEC ;
2695
                           SOME ;
2696
                           DUP 6 ;
2697
                           UPDATE ;
2698
                           UPDATE 28 ;
2699
                           DUG 5 ;
2700
                           DUP 6 ;
2701
                           GET 15 ;
2702
                           DUP 5 ;
2703
                           MEM ;
2704
                           IF
2705
                             { DIG 5 ; DUP ; GET 15 ; NONE bool ; DUP 7 ; UPDATE ; UPDATE 15 ; DUG 5 }
2706
                             {} ;
2707
                           PUSH nat 128 ;
2708
                           DUP 5 ;
2709
                           EDIV ;
2710
                           IF_NONE { PUSH int 678 ; FAILWITH } { CAR } ;
2711
                           DUP 7 ;
2712
                           GET 21 ;
2713
                           DUP 2 ;
2714
                           GET ;
2715
                           IF_NONE { PUSH bytes 0x } {} ;
2716
                           PUSH nat 128 ;
2717
                           DUP 7 ;
2718
                           EDIV ;
2719
                           IF_NONE { PUSH int 682 ; FAILWITH } { CDR } ;
2720
                           PUSH nat 32 ;
2721
                           DUP 2 ;
2722
                           MUL ;
2723
                           DUP 3 ;
2724
                           SIZE ;
2725
                           COMPARE ;
2726
                           GT ;
2727
                           IF
2728
                             { DIG 8 ;
2729
                               DUP ;
2730
                               GET 21 ;
2731
                               LAMBDA
2732
                                 (pair nat (pair bytes bytes))
2733
                                 bytes
2734
                                 { DUP ;
2735
                                   UNPAIR 3 ;
2736
                                   DUP 3 ;
2737
                                   SIZE ;
2738
                                   DUP 3 ;
2739
                                   SIZE ;
2740
                                   PUSH nat 0 ;
2741
                                   DUP 3 ;
2742
                                   DUP 3 ;
2743
                                   EDIV ;
2744
                                   IF_NONE { PUSH int 102 ; FAILWITH } { CDR } ;
2745
                                   COMPARE ;
2746
                                   EQ ;
2747
                                   IF
2748
                                     {}
2749
                                     { PUSH string "UPDATE_PAGE_CORRUPTED_SIZE" ;
2750
                                       FAILWITH } ;
2751
                                   DUP 2 ;
2752
                                   DUP 4 ;
2753
                                   MUL ;
2754
                                   DUP 3 ;
2755
                                   DUP 2 ;
2756
                                   ADD ;
2757
                                   DUP 2 ;
2758
                                   INT ;
2759
                                   EQ ;
2760
                                   IF
2761
                                     { PUSH bytes 0x }
2762
                                     { DUP 6 ;
2763
                                       DUP 3 ;
2764
                                       PUSH nat 0 ;
2765
                                       SLICE ;
2766
                                       IF_NONE
2767
                                         { PUSH string "UPDATE_INDEX_OUT_OF_BOUNDS" ;
2768
                                           FAILWITH }
2769
                                         {} } ;
2770
                                   DUP 4 ;
2771
                                   DUP 3 ;
2772
                                   COMPARE ;
2773
                                   EQ ;
2774
                                   IF
2775
                                     { SWAP ;
2776
                                       DROP ;
2777
                                       SWAP ;
2778
                                       DROP ;
2779
                                       SWAP ;
2780
                                       DROP ;
2781
                                       SWAP ;
2782
                                       DROP ;
2783
                                       SWAP ;
2784
                                       DROP ;
2785
                                       SWAP ;
2786
                                       DROP ;
2787
                                       DIG 2 ;
2788
                                       DROP ;
2789
                                       CONCAT }
2790
                                     { DIG 2 ;
2791
                                       DROP ;
2792
                                       DIG 3 ;
2793
                                       DROP ;
2794
                                       DIG 3 ;
2795
                                       DROP ;
2796
                                       DIG 5 ;
2797
                                       DROP ;
2798
                                       DUP 2 ;
2799
                                       DIG 3 ;
2800
                                       SUB ;
2801
                                       ISNAT ;
2802
                                       IF_NONE
2803
                                         { PUSH string "UPDATE_SLICE_OUT_OF_BOUNDS" ;
2804
                                           FAILWITH }
2805
                                         {} ;
2806
                                       DIG 3 ;
2807
                                       SWAP ;
2808
                                       DIG 3 ;
2809
                                       SLICE ;
2810
                                       IF_NONE { PUSH int 116 ; FAILWITH } {} ;
2811
                                       NIL bytes ;
2812
                                       SWAP ;
2813
                                       CONS ;
2814
                                       DIG 2 ;
2815
                                       CONS ;
2816
                                       SWAP ;
2817
                                       CONS ;
2818
                                       CONCAT } } ;
2819
                               PUSH bytes 0x0000000000000000000000000000000000000000000000000000000000000000 ;
2820
                               DUP 6 ;
2821
                               DUP 6 ;
2822
                               PAIR 3 ;
2823
                               EXEC ;
2824
                               SOME ;
2825
                               DUP 6 ;
2826
                               UPDATE ;
2827
                               UPDATE 21 ;
2828
                               DUG 8 }
2829
                             {} ;
2830
                           DUP 9 ;
2831
                           GET 9 ;
2832
                           DUP 8 ;
2833
                           MEM ;
2834
                           IF
2835
                             { DIG 8 ; DUP ; GET 9 ; NONE string ; DUP 10 ; UPDATE ; UPDATE 9 ; DUG 8 }
2836
                             {} ;
2837
                           NIL operation ;
2838
                           DUP 8 ;
2839
                           PUSH nat 0 ;
2840
                           PUSH int -1 ;
2841
                           PAIR 3 ;
2842
                           EMIT %total_supply_update (pair (int %diff)
2843
                                                           (pair (nat %new_total_supply)
2844
                                                                 (nat %token_id))) ;
2845
                           CONS ;
2846
                           DUP 8 ;
2847
                           NONE string ;
2848
                           PAIR ;
2849
                           EMIT %TitleBurned (pair (option %reason string)
2850
                                                   (nat %token_id)) ;
2851
                           CONS ;
2852
                           DUP 10 ;
2853
                           GET 25 ;
2854
                           PUSH nat 1024 ;
2855
                           DUP 2 ;
2856
                           EDIV ;
2857
                           IF_NONE { PUSH int 706 ; FAILWITH } { CAR } ;
2858
                           DUP 12 ;
2859
                           GET 28 ;
2860
                           DUP 2 ;
2861
                           GET ;
2862
                           IF_NONE { PUSH bytes 0x } {} ;
2863
                           PUSH nat 1024 ;
2864
                           DUP 4 ;
2865
                           EDIV ;
2866
                           IF_NONE { PUSH int 708 ; FAILWITH } { CDR } ;
2867
                           DUP 19 ;
2868
                           DUP 14 ;
2869
                           GET 6 ;
2870
                           SWAP ;
2871
                           DIG 15 ;
2872
                           DIG 2 ;
2873
                           PAIR ;
2874
                           EXEC ;
2875
                           UNPAIR ;
2876
                           DIG 20 ;
2877
                           DIG 20 ;
2878
                           DIG 20 ;
2879
                           DIG 20 ;
2880
                           DIG 20 ;
2881
                           DIG 20 ;
2882
                           DIG 7 ;
2883
                           DUG 20 ;
2884
                           DUG 20 ;
2885
                           DUG 20 ;
2886
                           DUG 20 ;
2887
                           DUG 20 ;
2888
                           DUG 20 ;
2889
                           DUG 20 ;
2890
                           LAMBDA
2891
                             (pair nat (pair bytes bytes))
2892
                             bytes
2893
                             { DUP ;
2894
                               UNPAIR 3 ;
2895
                               PUSH nat 4 ;
2896
                               PUSH nat 1 ;
2897
                               DUP 3 ;
2898
                               ADD ;
2899
                               MUL ;
2900
                               DUP 3 ;
2901
                               SIZE ;
2902
                               DUP 2 ;
2903
                               DUP 2 ;
2904
                               COMPARE ;
2905
                               LT ;
2906
                               LOOP { PUSH bytes 0x00000000 ;
2907
                                      DIG 4 ;
2908
                                      CONCAT ;
2909
                                      DUG 3 ;
2910
                                      PUSH nat 4 ;
2911
                                      ADD ;
2912
                                      DUP 2 ;
2913
                                      DUP 2 ;
2914
                                      COMPARE ;
2915
                                      LT } ;
2916
                               DROP 2 ;
2917
                               DIG 3 ;
2918
                               DROP ;
2919
                               LAMBDA
2920
                                 (pair nat (pair bytes bytes))
2921
                                 bytes
2922
                                 { DUP ;
2923
                                   UNPAIR 3 ;
2924
                                   DUP 3 ;
2925
                                   SIZE ;
2926
                                   DUP 3 ;
2927
                                   SIZE ;
2928
                                   PUSH nat 0 ;
2929
                                   DUP 3 ;
2930
                                   DUP 3 ;
2931
                                   EDIV ;
2932
                                   IF_NONE { PUSH int 102 ; FAILWITH } { CDR } ;
2933
                                   COMPARE ;
2934
                                   EQ ;
2935
                                   IF
2936
                                     {}
2937
                                     { PUSH string "UPDATE_PAGE_CORRUPTED_SIZE" ;
2938
                                       FAILWITH } ;
2939
                                   DUP 2 ;
2940
                                   DUP 4 ;
2941
                                   MUL ;
2942
                                   DUP 3 ;
2943
                                   DUP 2 ;
2944
                                   ADD ;
2945
                                   DUP 2 ;
2946
                                   INT ;
2947
                                   EQ ;
2948
                                   IF
2949
                                     { PUSH bytes 0x }
2950
                                     { DUP 6 ;
2951
                                       DUP 3 ;
2952
                                       PUSH nat 0 ;
2953
                                       SLICE ;
2954
                                       IF_NONE
2955
                                         { PUSH string "UPDATE_INDEX_OUT_OF_BOUNDS" ;
2956
                                           FAILWITH }
2957
                                         {} } ;
2958
                                   DUP 4 ;
2959
                                   DUP 3 ;
2960
                                   COMPARE ;
2961
                                   EQ ;
2962
                                   IF
2963
                                     { SWAP ;
2964
                                       DROP ;
2965
                                       SWAP ;
2966
                                       DROP ;
2967
                                       SWAP ;
2968
                                       DROP ;
2969
                                       SWAP ;
2970
                                       DROP ;
2971
                                       SWAP ;
2972
                                       DROP ;
2973
                                       SWAP ;
2974
                                       DROP ;
2975
                                       DIG 2 ;
2976
                                       DROP ;
2977
                                       CONCAT }
2978
                                     { DIG 2 ;
2979
                                       DROP ;
2980
                                       DIG 3 ;
2981
                                       DROP ;
2982
                                       DIG 3 ;
2983
                                       DROP ;
2984
                                       DIG 5 ;
2985
                                       DROP ;
2986
                                       DUP 2 ;
2987
                                       DIG 3 ;
2988
                                       SUB ;
2989
                                       ISNAT ;
2990
                                       IF_NONE
2991
                                         { PUSH string "UPDATE_SLICE_OUT_OF_BOUNDS" ;
2992
                                           FAILWITH }
2993
                                         {} ;
2994
                                       DIG 3 ;
2995
                                       SWAP ;
2996
                                       DIG 3 ;
2997
                                       SLICE ;
2998
                                       IF_NONE { PUSH int 116 ; FAILWITH } {} ;
2999
                                       NIL bytes ;
3000
                                       SWAP ;
3001
                                       CONS ;
3002
                                       DIG 2 ;
3003
                                       CONS ;
3004
                                       SWAP ;
3005
                                       CONS ;
3006
                                       CONCAT } } ;
3007
                               DUG 3 ;
3008
                               PAIR 3 ;
3009
                               EXEC } ;
3010
                           LAMBDA
3011
                             bytes
3012
                             bytes
3013
                             { DUP ;
3014
                               SIZE ;
3015
                               PUSH nat 5 ;
3016
                               DUP 2 ;
3017
                               COMPARE ;
3018
                               LT ;
3019
                               IF
3020
                                 {}
3021
                                 { PUSH string "Value too long, must be 4 bytes or less" ;
3022
                                   FAILWITH } ;
3023
                               PUSH nat 4 ;
3024
                               DUP 2 ;
3025
                               COMPARE ;
3026
                               EQ ;
3027
                               IF
3028
                                 { DROP }
3029
                                 { DUP ;
3030
                                   INT ;
3031
                                   EQ ;
3032
                                   IF
3033
                                     { DROP 2 ; PUSH bytes 0x00000000 }
3034
                                     { PUSH nat 1 ;
3035
                                       DUP 2 ;
3036
                                       COMPARE ;
3037
                                       EQ ;
3038
                                       IF
3039
                                         { DROP ; PUSH bytes 0x000000 ; CONCAT }
3040
                                         { PUSH nat 2 ;
3041
                                           COMPARE ;
3042
                                           EQ ;
3043
                                           IF
3044
                                             { PUSH bytes 0x0000 ; CONCAT }
3045
                                             { PUSH bytes 0x00 ; CONCAT } } } } } ;
3046
                           DUP 3 ;
3047
                           BYTES ;
3048
                           EXEC ;
3049
                           DIG 4 ;
3050
                           DUP 5 ;
3051
                           PAIR 3 ;
3052
                           EXEC ;
3053
                           DUG 2 ;
3054
                           DIG 14 ;
3055
                           DUP ;
3056
                           GET 28 ;
3057
                           DUP 5 ;
3058
                           SOME ;
3059
                           DUP 7 ;
3060
                           UPDATE ;
3061
                           UPDATE 28 ;
3062
                           PUSH nat 1 ;
3063
                           DUP 7 ;
3064
                           ADD ;
3065
                           UPDATE 25 ;
3066
                           DUP ;
3067
                           GET 9 ;
3068
                           DUP 16 ;
3069
                           GET 3 ;
3070
                           SOME ;
3071
                           DUP 8 ;
3072
                           UPDATE ;
3073
                           UPDATE 9 ;
3074
                           DUG 14 ;
3075
                           PUSH nat 128 ;
3076
                           DUP 6 ;
3077
                           EDIV ;
3078
                           IF_NONE { PUSH int 720 ; FAILWITH } { CAR } ;
3079
                           PUSH nat 128 ;
3080
                           DUP 7 ;
3081
                           EDIV ;
3082
                           IF_NONE { PUSH int 721 ; FAILWITH } { CDR } ;
3083
                           DUP 17 ;
3084
                           GET 21 ;
3085
                           DUP 3 ;
3086
                           GET ;
3087
                           IF_NONE { PUSH bytes 0x } {} ;
3088
                           DIG 17 ;
3089
                           DUP ;
3090
                           GET 21 ;
3091
                           LAMBDA
3092
                             (pair nat (pair bytes bytes))
3093
                             bytes
3094
                             { DUP ;
3095
                               UNPAIR 3 ;
3096
                               PUSH nat 32 ;
3097
                               PUSH nat 1 ;
3098
                               DUP 3 ;
3099
                               ADD ;
3100
                               MUL ;
3101
                               DUP 3 ;
3102
                               SIZE ;
3103
                               DUP 2 ;
3104
                               DUP 2 ;
3105
                               COMPARE ;
3106
                               LT ;
3107
                               LOOP { PUSH bytes 0x0000000000000000000000000000000000000000000000000000000000000000 ;
3108
                                      DIG 4 ;
3109
                                      CONCAT ;
3110
                                      DUG 3 ;
3111
                                      PUSH nat 32 ;
3112
                                      ADD ;
3113
                                      DUP 2 ;
3114
                                      DUP 2 ;
3115
                                      COMPARE ;
3116
                                      LT } ;
3117
                               DROP 2 ;
3118
                               DIG 3 ;
3119
                               DROP ;
3120
                               LAMBDA
3121
                                 (pair nat (pair bytes bytes))
3122
                                 bytes
3123
                                 { DUP ;
3124
                                   UNPAIR 3 ;
3125
                                   DUP 3 ;
3126
                                   SIZE ;
3127
                                   DUP 3 ;
3128
                                   SIZE ;
3129
                                   PUSH nat 0 ;
3130
                                   DUP 3 ;
3131
                                   DUP 3 ;
3132
                                   EDIV ;
3133
                                   IF_NONE { PUSH int 102 ; FAILWITH } { CDR } ;
3134
                                   COMPARE ;
3135
                                   EQ ;
3136
                                   IF
3137
                                     {}
3138
                                     { PUSH string "UPDATE_PAGE_CORRUPTED_SIZE" ;
3139
                                       FAILWITH } ;
3140
                                   DUP 2 ;
3141
                                   DUP 4 ;
3142
                                   MUL ;
3143
                                   DUP 3 ;
3144
                                   DUP 2 ;
3145
                                   ADD ;
3146
                                   DUP 2 ;
3147
                                   INT ;
3148
                                   EQ ;
3149
                                   IF
3150
                                     { PUSH bytes 0x }
3151
                                     { DUP 6 ;
3152
                                       DUP 3 ;
3153
                                       PUSH nat 0 ;
3154
                                       SLICE ;
3155
                                       IF_NONE
3156
                                         { PUSH string "UPDATE_INDEX_OUT_OF_BOUNDS" ;
3157
                                           FAILWITH }
3158
                                         {} } ;
3159
                                   DUP 4 ;
3160
                                   DUP 3 ;
3161
                                   COMPARE ;
3162
                                   EQ ;
3163
                                   IF
3164
                                     { SWAP ;
3165
                                       DROP ;
3166
                                       SWAP ;
3167
                                       DROP ;
3168
                                       SWAP ;
3169
                                       DROP ;
3170
                                       SWAP ;
3171
                                       DROP ;
3172
                                       SWAP ;
3173
                                       DROP ;
3174
                                       SWAP ;
3175
                                       DROP ;
3176
                                       DIG 2 ;
3177
                                       DROP ;
3178
                                       CONCAT }
3179
                                     { DIG 2 ;
3180
                                       DROP ;
3181
                                       DIG 3 ;
3182
                                       DROP ;
3183
                                       DIG 3 ;
3184
                                       DROP ;
3185
                                       DIG 5 ;
3186
                                       DROP ;
3187
                                       DUP 2 ;
3188
                                       DIG 3 ;
3189
                                       SUB ;
3190
                                       ISNAT ;
3191
                                       IF_NONE
3192
                                         { PUSH string "UPDATE_SLICE_OUT_OF_BOUNDS" ;
3193
                                           FAILWITH }
3194
                                         {} ;
3195
                                       DIG 3 ;
3196
                                       SWAP ;
3197
                                       DIG 3 ;
3198
                                       SLICE ;
3199
                                       IF_NONE { PUSH int 116 ; FAILWITH } {} ;
3200
                                       NIL bytes ;
3201
                                       SWAP ;
3202
                                       CONS ;
3203
                                       DIG 2 ;
3204
                                       CONS ;
3205
                                       SWAP ;
3206
                                       CONS ;
3207
                                       CONCAT } } ;
3208
                               DUG 3 ;
3209
                               PAIR 3 ;
3210
                               EXEC } ;
3211
                           DUP 20 ;
3212
                           GET 5 ;
3213
                           DUP 5 ;
3214
                           DUP 7 ;
3215
                           PAIR 3 ;
3216
                           EXEC ;
3217
                           SOME ;
3218
                           DUP 6 ;
3219
                           UPDATE ;
3220
                           UPDATE 21 ;
3221
                           DUG 17 ;
3222
                           DUP 9 ;
3223
                           DUP 9 ;
3224
                           DUP 19 ;
3225
                           GET 6 ;
3226
                           PUSH nat 1 ;
3227
                           PUSH int 1 ;
3228
                           PAIR 4 ;
3229
                           DIG 2 ;
3230
                           DROP ;
3231
                           DIG 2 ;
3232
                           DROP ;
3233
                           DIG 2 ;
3234
                           DROP ;
3235
                           DIG 2 ;
3236
                           DROP ;
3237
                           DIG 2 ;
3238
                           DROP ;
3239
                           DIG 2 ;
3240
                           DROP ;
3241
                           DIG 2 ;
3242
                           DROP ;
3243
                           DIG 3 ;
3244
                           DROP ;
3245
                           DIG 3 ;
3246
                           DROP ;
3247
                           DIG 3 ;
3248
                           DROP ;
3249
                           DIG 3 ;
3250
                           DROP ;
3251
                           DIG 3 ;
3252
                           DROP ;
3253
                           DIG 3 ;
3254
                           DROP ;
3255
                           DIG 3 ;
3256
                           DROP ;
3257
                           DIG 3 ;
3258
                           DROP ;
3259
                           DIG 5 ;
3260
                           DROP ;
3261
                           DIG 5 ;
3262
                           DROP ;
3263
                           DIG 5 ;
3264
                           DROP ;
3265
                           DIG 5 ;
3266
                           DROP ;
3267
                           DIG 5 ;
3268
                           DROP ;
3269
                           DIG 5 ;
3270
                           DROP ;
3271
                           EMIT %balance_update (pair (int %diff)
3272
                                                      (pair (nat %new_balance)
3273
                                                            (pair (address %owner)
3274
                                                                  (nat %token_id)))) ;
3275
                           CONS ;
3276
                           DUP 2 ;
3277
                           PUSH nat 1 ;
3278
                           PUSH int 1 ;
3279
                           PAIR 3 ;
3280
                           EMIT %total_supply_update (pair (int %diff)
3281
                                                           (pair (nat %new_total_supply)
3282
                                                                 (nat %token_id))) ;
3283
                           CONS ;
3284
                           SWAP ;
3285
                           DIG 2 ;
3286
                           DUP ;
3287
                           GET 6 ;
3288
                           SWAP ;
3289
                           GET 3 ;
3290
                           PAIR 3 ;
3291
                           EMIT %TitleMinted (pair (string %dest_jurisdiction)
3292
                                                   (pair (address %owner)
3293
                                                         (nat %token_id))) ;
3294
                           CONS } } } }
3295
             { IF_LEFT
3296
                 { IF_LEFT
3297
                     { PUSH string "FA2_TX_DENIED" ; FAILWITH }
3298
                     { IF_LEFT
3299
                         { DUP 2 ;
3300
                           GET 25 ;
3301
                           DUP 2 ;
3302
                           GET 4 ;
3303
                           COMPARE ;
3304
                           LT ;
3305
                           IF {} { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;
3306
                           DUP 2 ;
3307
                           GET 15 ;
3308
                           DUP 2 ;
3309
                           GET 4 ;
3310
                           GET ;
3311
                           IF_NONE { PUSH bool False } {} ;
3312
                           IF { PUSH string "TOKEN_LOCKED" ; FAILWITH } {} ;
3313
                           DUP 2 ;
3314
                           GET 9 ;
3315
                           DUP 2 ;
3316
                           GET 4 ;
3317
                           GET ;
3318
                           IF_NONE { PUSH string "" } {} ;
3319
                           DUP 5 ;
3320
                           DUP 2 ;
3321
                           SWAP ;
3322
                           DIG 4 ;
3323
                           DIG 2 ;
3324
                           PAIR ;
3325
                           EXEC ;
3326
                           UNPAIR ;
3327
                           DUG 9 ;
3328
                           DUG 9 ;
3329
                           DUG 9 ;
3330
                           DUG 9 ;
3331
                           DIG 7 ;
3332
                           DIG 9 ;
3333
                           DIG 9 ;
3334
                           DIG 9 ;
3335
                           IF {} { PUSH string "NOT_JURISDICTION_ADMIN" ; FAILWITH } ;
3336
                           PUSH nat 1024 ;
3337
                           DUP 3 ;
3338
                           GET 4 ;
3339
                           EDIV ;
3340
                           IF_NONE { PUSH int 772 ; FAILWITH } { CAR } ;
3341
                           DUP 4 ;
3342
                           GET 28 ;
3343
                           DUP 2 ;
3344
                           GET ;
3345
                           IF_NONE { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } {} ;
3346
                           PUSH nat 1024 ;
3347
                           DUP 5 ;
3348
                           GET 4 ;
3349
                           EDIV ;
3350
                           IF_NONE { PUSH int 774 ; FAILWITH } { CDR } ;
3351
                           LAMBDA
3352
                             (pair nat (pair bytes nat))
3353
                             (option bytes)
3354
                             { DUP ;
3355
                               UNPAIR 3 ;
3356
                               DUP 2 ;
3357
                               SIZE ;
3358
                               DUP 4 ;
3359
                               DUP 3 ;
3360
                               MUL ;
3361
                               DUP 2 ;
3362
                               DUP 2 ;
3363
                               COMPARE ;
3364
                               GE ;
3365
                               IF
3366
                                 { DROP 6 ; NONE bytes }
3367
                                 { DIG 2 ;
3368
                                   DROP ;
3369
                                   DIG 4 ;
3370
                                   DROP ;
3371
                                   PUSH nat 0 ;
3372
                                   DUP 5 ;
3373
                                   DIG 3 ;
3374
                                   EDIV ;
3375
                                   IF_NONE { PUSH int 90 ; FAILWITH } { CDR } ;
3376
                                   COMPARE ;
3377
                                   EQ ;
3378
                                   IF
3379
                                     {}
3380
                                     { PUSH string "CORRUPTED_PAGE_SIZE" ; FAILWITH } ;
3381
                                   SWAP ;
3382
                                   DUG 2 ;
3383
                                   SLICE ;
3384
                                   IF_NONE
3385
                                     { PUSH string "SLICE_OUT_OF_BOUNDS_IN_PAGE" ;
3386
                                       FAILWITH }
3387
                                     {} ;
3388
                                   SOME } } ;
3389
                           PUSH nat 4 ;
3390
                           DUP 4 ;
3391
                           DUP 4 ;
3392
                           PAIR 3 ;
3393
                           EXEC ;
3394
                           IF_NONE { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } {} ;
3395
                           PUSH bytes 0x00000000 ;
3396
                           DUP 2 ;
3397
                           COMPARE ;
3398
                           NEQ ;
3399
                           IF {} { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;
3400
                           DUP 8 ;
3401
                           SENDER ;
3402
                           SWAP ;
3403
                           DIG 8 ;
3404
                           DIG 2 ;
3405
                           PAIR ;
3406
                           EXEC ;
3407
                           UNPAIR ;
3408
                           DIG 13 ;
3409
                           DIG 13 ;
3410
                           DIG 13 ;
3411
                           DIG 13 ;
3412
                           DIG 13 ;
3413
                           DIG 13 ;
3414
                           DIG 7 ;
3415
                           DIG 13 ;
3416
                           DIG 13 ;
3417
                           DIG 13 ;
3418
                           DIG 13 ;
3419
                           DIG 13 ;
3420
                           DIG 13 ;
3421
                           DIG 13 ;
3422
                           IF_NONE { PUSH string "FA2_NOT_OWNER" ; FAILWITH } {} ;
3423
                           LAMBDA
3424
                             bytes
3425
                             bytes
3426
                             { DUP ;
3427
                               SIZE ;
3428
                               PUSH nat 5 ;
3429
                               DUP 2 ;
3430
                               COMPARE ;
3431
                               LT ;
3432
                               IF
3433
                                 {}
3434
                                 { PUSH string "Value too long, must be 4 bytes or less" ;
3435
                                   FAILWITH } ;
3436
                               PUSH nat 4 ;
3437
                               DUP 2 ;
3438
                               COMPARE ;
3439
                               EQ ;
3440
                               IF
3441
                                 { DROP }
3442
                                 { DUP ;
3443
                                   INT ;
3444
                                   EQ ;
3445
                                   IF
3446
                                     { DROP 2 ; PUSH bytes 0x00000000 }
3447
                                     { PUSH nat 1 ;
3448
                                       DUP 2 ;
3449
                                       COMPARE ;
3450
                                       EQ ;
3451
                                       IF
3452
                                         { DROP ; PUSH bytes 0x000000 ; CONCAT }
3453
                                         { PUSH nat 2 ;
3454
                                           COMPARE ;
3455
                                           EQ ;
3456
                                           IF
3457
                                             { PUSH bytes 0x0000 ; CONCAT }
3458
                                             { PUSH bytes 0x00 ; CONCAT } } } } } ;
3459
                           DUP 2 ;
3460
                           BYTES ;
3461
                           EXEC ;
3462
                           DUP ;
3463
                           DUP 4 ;
3464
                           COMPARE ;
3465
                           EQ ;
3466
                           IF {} { PUSH string "FA2_NOT_OWNER" ; FAILWITH } ;
3467
                           DUP 14 ;
3468
                           DUP 9 ;
3469
                           GET 3 ;
3470
                           SWAP ;
3471
                           DIG 10 ;
3472
                           DIG 2 ;
3473
                           PAIR ;
3474
                           EXEC ;
3475
                           UNPAIR ;
3476
                           DIG 15 ;
3477
                           DIG 15 ;
3478
                           DIG 15 ;
3479
                           DIG 15 ;
3480
                           DIG 15 ;
3481
                           DIG 15 ;
3482
                           DIG 7 ;
3483
                           DUG 15 ;
3484
                           DUG 15 ;
3485
                           DUG 15 ;
3486
                           DUG 15 ;
3487
                           DUG 15 ;
3488
                           DUG 15 ;
3489
                           DUG 15 ;
3490
                           DIG 9 ;
3491
                           DUP ;
3492
                           GET 28 ;
3493
                           LAMBDA
3494
                             (pair nat (pair bytes bytes))
3495
                             bytes
3496
                             { DUP ;
3497
                               UNPAIR 3 ;
3498
                               DUP 3 ;
3499
                               SIZE ;
3500
                               DUP 3 ;
3501
                               SIZE ;
3502
                               PUSH nat 0 ;
3503
                               DUP 3 ;
3504
                               DUP 3 ;
3505
                               EDIV ;
3506
                               IF_NONE { PUSH int 102 ; FAILWITH } { CDR } ;
3507
                               COMPARE ;
3508
                               EQ ;
3509
                               IF
3510
                                 {}
3511
                                 { PUSH string "UPDATE_PAGE_CORRUPTED_SIZE" ; FAILWITH } ;
3512
                               DUP 2 ;
3513
                               DUP 4 ;
3514
                               MUL ;
3515
                               DUP 3 ;
3516
                               DUP 2 ;
3517
                               ADD ;
3518
                               DUP 2 ;
3519
                               INT ;
3520
                               EQ ;
3521
                               IF
3522
                                 { PUSH bytes 0x }
3523
                                 { DUP 6 ;
3524
                                   DUP 3 ;
3525
                                   PUSH nat 0 ;
3526
                                   SLICE ;
3527
                                   IF_NONE
3528
                                     { PUSH string "UPDATE_INDEX_OUT_OF_BOUNDS" ;
3529
                                       FAILWITH }
3530
                                     {} } ;
3531
                               DUP 4 ;
3532
                               DUP 3 ;
3533
                               COMPARE ;
3534
                               EQ ;
3535
                               IF
3536
                                 { SWAP ;
3537
                                   DROP ;
3538
                                   SWAP ;
3539
                                   DROP ;
3540
                                   SWAP ;
3541
                                   DROP ;
3542
                                   SWAP ;
3543
                                   DROP ;
3544
                                   SWAP ;
3545
                                   DROP ;
3546
                                   SWAP ;
3547
                                   DROP ;
3548
                                   DIG 2 ;
3549
                                   DROP ;
3550
                                   CONCAT }
3551
                                 { DIG 2 ;
3552
                                   DROP ;
3553
                                   DIG 3 ;
3554
                                   DROP ;
3555
                                   DIG 3 ;
3556
                                   DROP ;
3557
                                   DIG 5 ;
3558
                                   DROP ;
3559
                                   DUP 2 ;
3560
                                   DIG 3 ;
3561
                                   SUB ;
3562
                                   ISNAT ;
3563
                                   IF_NONE
3564
                                     { PUSH string "UPDATE_SLICE_OUT_OF_BOUNDS" ;
3565
                                       FAILWITH }
3566
                                     {} ;
3567
                                   DIG 3 ;
3568
                                   SWAP ;
3569
                                   DIG 3 ;
3570
                                   SLICE ;
3571
                                   IF_NONE { PUSH int 116 ; FAILWITH } {} ;
3572
                                   NIL bytes ;
3573
                                   SWAP ;
3574
                                   CONS ;
3575
                                   DIG 2 ;
3576
                                   CONS ;
3577
                                   SWAP ;
3578
                                   CONS ;
3579
                                   CONCAT } } ;
3580
                           LAMBDA
3581
                             bytes
3582
                             bytes
3583
                             { DUP ;
3584
                               SIZE ;
3585
                               PUSH nat 5 ;
3586
                               DUP 2 ;
3587
                               COMPARE ;
3588
                               LT ;
3589
                               IF
3590
                                 {}
3591
                                 { PUSH string "Value too long, must be 4 bytes or less" ;
3592
                                   FAILWITH } ;
3593
                               PUSH nat 4 ;
3594
                               DUP 2 ;
3595
                               COMPARE ;
3596
                               EQ ;
3597
                               IF
3598
                                 { DROP }
3599
                                 { DUP ;
3600
                                   INT ;
3601
                                   EQ ;
3602
                                   IF
3603
                                     { DROP 2 ; PUSH bytes 0x00000000 }
3604
                                     { PUSH nat 1 ;
3605
                                       DUP 2 ;
3606
                                       COMPARE ;
3607
                                       EQ ;
3608
                                       IF
3609
                                         { DROP ; PUSH bytes 0x000000 ; CONCAT }
3610
                                         { PUSH nat 2 ;
3611
                                           COMPARE ;
3612
                                           EQ ;
3613
                                           IF
3614
                                             { PUSH bytes 0x0000 ; CONCAT }
3615
                                             { PUSH bytes 0x00 ; CONCAT } } } } } ;
3616
                           DUP 5 ;
3617
                           BYTES ;
3618
                           EXEC ;
3619
                           DUP 10 ;
3620
                           DUP 10 ;
3621
                           PAIR 3 ;
3622
                           EXEC ;
3623
                           SOME ;
3624
                           DUP 10 ;
3625
                           UPDATE ;
3626
                           UPDATE 28 ;
3627
                           DUG 9 ;
3628
                           PUSH nat 128 ;
3629
                           DUP 10 ;
3630
                           GET 4 ;
3631
                           EDIV ;
3632
                           IF_NONE { PUSH int 798 ; FAILWITH } { CAR } ;
3633
                           PUSH nat 128 ;
3634
                           DUP 11 ;
3635
                           GET 4 ;
3636
                           EDIV ;
3637
                           IF_NONE { PUSH int 799 ; FAILWITH } { CDR } ;
3638
                           DUP 12 ;
3639
                           GET 21 ;
3640
                           DUP 3 ;
3641
                           GET ;
3642
                           IF_NONE { PUSH bytes 0x } {} ;
3643
                           DIG 12 ;
3644
                           DUP ;
3645
                           GET 21 ;
3646
                           LAMBDA
3647
                             (pair nat (pair bytes bytes))
3648
                             bytes
3649
                             { DUP ;
3650
                               UNPAIR 3 ;
3651
                               PUSH nat 32 ;
3652
                               PUSH nat 1 ;
3653
                               DUP 3 ;
3654
                               ADD ;
3655
                               MUL ;
3656
                               DUP 3 ;
3657
                               SIZE ;
3658
                               DUP 2 ;
3659
                               DUP 2 ;
3660
                               COMPARE ;
3661
                               LT ;
3662
                               LOOP { PUSH bytes 0x0000000000000000000000000000000000000000000000000000000000000000 ;
3663
                                      DIG 4 ;
3664
                                      CONCAT ;
3665
                                      DUG 3 ;
3666
                                      PUSH nat 32 ;
3667
                                      ADD ;
3668
                                      DUP 2 ;
3669
                                      DUP 2 ;
3670
                                      COMPARE ;
3671
                                      LT } ;
3672
                               DROP 2 ;
3673
                               DIG 3 ;
3674
                               DROP ;
3675
                               LAMBDA
3676
                                 (pair nat (pair bytes bytes))
3677
                                 bytes
3678
                                 { DUP ;
3679
                                   UNPAIR 3 ;
3680
                                   DUP 3 ;
3681
                                   SIZE ;
3682
                                   DUP 3 ;
3683
                                   SIZE ;
3684
                                   PUSH nat 0 ;
3685
                                   DUP 3 ;
3686
                                   DUP 3 ;
3687
                                   EDIV ;
3688
                                   IF_NONE { PUSH int 102 ; FAILWITH } { CDR } ;
3689
                                   COMPARE ;
3690
                                   EQ ;
3691
                                   IF
3692
                                     {}
3693
                                     { PUSH string "UPDATE_PAGE_CORRUPTED_SIZE" ;
3694
                                       FAILWITH } ;
3695
                                   DUP 2 ;
3696
                                   DUP 4 ;
3697
                                   MUL ;
3698
                                   DUP 3 ;
3699
                                   DUP 2 ;
3700
                                   ADD ;
3701
                                   DUP 2 ;
3702
                                   INT ;
3703
                                   EQ ;
3704
                                   IF
3705
                                     { PUSH bytes 0x }
3706
                                     { DUP 6 ;
3707
                                       DUP 3 ;
3708
                                       PUSH nat 0 ;
3709
                                       SLICE ;
3710
                                       IF_NONE
3711
                                         { PUSH string "UPDATE_INDEX_OUT_OF_BOUNDS" ;
3712
                                           FAILWITH }
3713
                                         {} } ;
3714
                                   DUP 4 ;
3715
                                   DUP 3 ;
3716
                                   COMPARE ;
3717
                                   EQ ;
3718
                                   IF
3719
                                     { SWAP ;
3720
                                       DROP ;
3721
                                       SWAP ;
3722
                                       DROP ;
3723
                                       SWAP ;
3724
                                       DROP ;
3725
                                       SWAP ;
3726
                                       DROP ;
3727
                                       SWAP ;
3728
                                       DROP ;
3729
                                       SWAP ;
3730
                                       DROP ;
3731
                                       DIG 2 ;
3732
                                       DROP ;
3733
                                       CONCAT }
3734
                                     { DIG 2 ;
3735
                                       DROP ;
3736
                                       DIG 3 ;
3737
                                       DROP ;
3738
                                       DIG 3 ;
3739
                                       DROP ;
3740
                                       DIG 5 ;
3741
                                       DROP ;
3742
                                       DUP 2 ;
3743
                                       DIG 3 ;
3744
                                       SUB ;
3745
                                       ISNAT ;
3746
                                       IF_NONE
3747
                                         { PUSH string "UPDATE_SLICE_OUT_OF_BOUNDS" ;
3748
                                           FAILWITH }
3749
                                         {} ;
3750
                                       DIG 3 ;
3751
                                       SWAP ;
3752
                                       DIG 3 ;
3753
                                       SLICE ;
3754
                                       IF_NONE { PUSH int 116 ; FAILWITH } {} ;
3755
                                       NIL bytes ;
3756
                                       SWAP ;
3757
                                       CONS ;
3758
                                       DIG 2 ;
3759
                                       CONS ;
3760
                                       SWAP ;
3761
                                       CONS ;
3762
                                       CONCAT } } ;
3763
                               DUG 3 ;
3764
                               PAIR 3 ;
3765
                               EXEC } ;
3766
                           DUP 15 ;
3767
                           CAR ;
3768
                           DUP 5 ;
3769
                           DUP 7 ;
3770
                           PAIR 3 ;
3771
                           EXEC ;
3772
                           SOME ;
3773
                           DUP 6 ;
3774
                           UPDATE ;
3775
                           UPDATE 21 ;
3776
                           DUG 12 ;
3777
                           DUP 12 ;
3778
                           GET 3 ;
3779
                           SENDER ;
3780
                           COMPARE ;
3781
                           NEQ ;
3782
                           IF
3783
                             { NIL operation ;
3784
                               DUP ;
3785
                               DUP 14 ;
3786
                               GET 4 ;
3787
                               SENDER ;
3788
                               PUSH nat 0 ;
3789
                               PUSH int -1 ;
3790
                               PAIR 4 ;
3791
                               DIG 2 ;
3792
                               DROP ;
3793
                               EMIT %balance_update (pair (int %diff)
3794
                                                          (pair (nat %new_balance)
3795
                                                                (pair (address %owner)
3796
                                                                      (nat %token_id)))) ;
3797
                               CONS ;
3798
                               DUP ;
3799
                               DUP 14 ;
3800
                               GET 4 ;
3801
                               DUP 15 ;
3802
                               GET 3 ;
3803
                               PUSH nat 1 ;
3804
                               PUSH int 1 ;
3805
                               PAIR 4 ;
3806
                               DIG 2 ;
3807
                               DROP ;
3808
                               EMIT %balance_update (pair (int %diff)
3809
                                                          (pair (nat %new_balance)
3810
                                                                (pair (address %owner)
3811
                                                                      (nat %token_id)))) ;
3812
                               CONS }
3813
                             { NIL operation } ;
3814
                           DUP ;
3815
                           DUP 14 ;
3816
                           GET 4 ;
3817
                           DUP 15 ;
3818
                           GET 3 ;
3819
                           SENDER ;
3820
                           PUSH nat 1 ;
3821
                           PAIR 4 ;
3822
                           DIG 2 ;
3823
                           DROP ;
3824
                           DIG 2 ;
3825
                           DROP ;
3826
                           DIG 2 ;
3827
                           DROP ;
3828
                           DIG 2 ;
3829
                           DROP ;
3830
                           DIG 2 ;
3831
                           DROP ;
3832
                           DIG 2 ;
3833
                           DROP ;
3834
                           DIG 2 ;
3835
                           DROP ;
3836
                           DIG 2 ;
3837
                           DROP ;
3838
                           DIG 2 ;
3839
                           DROP ;
3840
                           DIG 2 ;
3841
                           DROP ;
3842
                           DIG 2 ;
3843
                           DROP ;
3844
                           DIG 2 ;
3845
                           DROP ;
3846
                           DIG 4 ;
3847
                           DROP ;
3848
                           DIG 4 ;
3849
                           DROP ;
3850
                           DIG 4 ;
3851
                           DROP ;
3852
                           DIG 4 ;
3853
                           DROP ;
3854
                           DIG 4 ;
3855
                           DROP ;
3856
                           DIG 4 ;
3857
                           DROP ;
3858
                           EMIT %transfer_event (pair (nat %amount)
3859
                                                      (pair (address %from_)
3860
                                                            (pair (address %to_)
3861
                                                                  (nat %token_id)))) ;
3862
                           CONS ;
3863
                           SWAP ;
3864
                           DUP ;
3865
                           GET 4 ;
3866
                           SWAP ;
3867
                           GET 3 ;
3868
                           SENDER ;
3869
                           PAIR 3 ;
3870
                           EMIT %TitleClaimed (pair (address %from_)
3871
                                                    (pair (address %to_) (nat %token_id))) ;
3872
                           CONS }
3873
                         { DIG 2 ;
3874
                           DROP ;
3875
                           DIG 2 ;
3876
                           DROP ;
3877
                           DIG 3 ;
3878
                           DROP ;
3879
                           DIG 3 ;
3880
                           DROP ;
3881
                           DIG 3 ;
3882
                           DROP ;
3883
                           DIG 2 ;
3884
                           UNIT ;
3885
                           SWAP ;
3886
                           DIG 3 ;
3887
                           DIG 2 ;
3888
                           PAIR ;
3889
                           EXEC ;
3890
                           UNPAIR ;
3891
                           SWAP ;
3892
                           DUG 2 ;
3893
                           IF {} { PUSH string "NOT_HUB" ; FAILWITH } ;
3894
                           DUP 2 ;
3895
                           GET 15 ;
3896
                           DUP 2 ;
3897
                           GET ;
3898
                           IF_NONE { PUSH bool False } {} ;
3899
                           IF
3900
                             { SWAP ;
3901
                               DUP ;
3902
                               GET 15 ;
3903
                               PUSH (option bool) (Some False) ;
3904
                               DIG 3 ;
3905
                               UPDATE ;
3906
                               UPDATE 15 }
3907
                             { DROP } ;
3908
                           NIL operation } } }
3909
                 { IF_LEFT
3910
                     { DUP 6 ;
3911
                       UNIT ;
3912
                       SWAP ;
3913
                       DIG 3 ;
3914
                       DIG 2 ;
3915
                       PAIR ;
3916
                       EXEC ;
3917
                       UNPAIR ;
3918
                       DUG 8 ;
3919
                       DUG 8 ;
3920
                       DUG 8 ;
3921
                       DIG 7 ;
3922
                       DIG 8 ;
3923
                       DIG 8 ;
3924
                       IF {} { PUSH string "FA2_NOT_ADMIN" ; FAILWITH } ;
3925
                       DUP ;
3926
                       CAR ;
3927
                       ITER { DIG 2 ; DUP ; GET 3 ; PUSH bool False ; DIG 3 ; UPDATE ; UPDATE 3 ; SWAP } ;
3928
                       DUP ;
3929
                       CDR ;
3930
                       ITER { DIG 2 ; DUP ; GET 3 ; PUSH bool True ; DIG 3 ; UPDATE ; UPDATE 3 ; SWAP } ;
3931
                       DROP ;
3932
                       SWAP ;
3933
                       DROP ;
3934
                       SWAP ;
3935
                       DROP ;
3936
                       SWAP ;
3937
                       DROP ;
3938
                       SWAP ;
3939
                       DROP ;
3940
                       SWAP ;
3941
                       DROP ;
3942
                       SWAP ;
3943
                       DROP ;
3944
                       NIL operation }
3945
                     { IF_LEFT
3946
                         { DUP 6 ;
3947
                           UNIT ;
3948
                           SWAP ;
3949
                           DIG 3 ;
3950
                           DIG 2 ;
3951
                           PAIR ;
3952
                           EXEC ;
3953
                           UNPAIR ;
3954
                           DUG 8 ;
3955
                           DUG 8 ;
3956
                           DUG 8 ;
3957
                           DIG 7 ;
3958
                           DIG 8 ;
3959
                           DIG 8 ;
3960
                           IF {} { PUSH string "FA2_NOT_ADMIN" ; FAILWITH } ;
3961
                           DUP ;
3962
                           CDR ;
3963
                           ITER { DIG 2 ; DUP ; GET 17 ; NONE bytes ; DIG 3 ; UPDATE ; UPDATE 17 ; SWAP } ;
3964
                           DUP ;
3965
                           CAR ;
3966
                           ITER { DIG 2 ;
3967
                                  DUP ;
3968
                                  GET 17 ;
3969
                                  DUP 3 ;
3970
                                  CDR ;
3971
                                  SOME ;
3972
                                  DIG 3 ;
3973
                                  CAR ;
3974
                                  UPDATE ;
3975
                                  UPDATE 17 ;
3976
                                  SWAP } ;
3977
                           DROP ;
3978
                           SWAP ;
3979
                           DROP ;
3980
                           SWAP ;
3981
                           DROP ;
3982
                           SWAP ;
3983
                           DROP ;
3984
                           SWAP ;
3985
                           DROP ;
3986
                           SWAP ;
3987
                           DROP ;
3988
                           SWAP ;
3989
                           DROP ;
3990
                           NIL operation }
3991
                         { NIL operation ;
3992
                           DUP 2 ;
3993
                           ITER { DUP ;
3994
                                  IF_LEFT
3995
                                    { SENDER ;
3996
                                      DUP 2 ;
3997
                                      CAR ;
3998
                                      COMPARE ;
3999
                                      EQ ;
4000
                                      IF {} { PUSH string "FA2_NOT_OWNER" ; FAILWITH } ;
4001
                                      DIG 4 ;
4002
                                      DUP ;
4003
                                      GET 27 ;
4004
                                      PUSH (option unit) (Some Unit) ;
4005
                                      DUP 4 ;
4006
                                      UPDATE ;
4007
                                      UPDATE 27 ;
4008
                                      DUG 4 ;
4009
                                      DUP 3 ;
4010
                                      DUP 2 ;
4011
                                      GET 4 ;
4012
                                      DUP 3 ;
4013
                                      CAR ;
4014
                                      DUP 4 ;
4015
                                      GET 3 ;
4016
                                      PUSH bool True ;
4017
                                      PAIR 4 ;
4018
                                      DIG 2 ;
4019
                                      DROP ;
4020
                                      DIG 2 ;
4021
                                      DROP ;
4022
                                      DIG 2 ;
4023
                                      DROP ;
4024
                                      EMIT %operator_update (pair (bool %is_operator)
4025
                                                                  (pair
4026
                                                                    (address %operator)
4027
                                                                    (pair
4028
                                                                      (address %owner)
4029
                                                                      (nat %token_id)))) ;
4030
                                      CONS }
4031
                                    { SENDER ;
4032
                                      DUP 2 ;
4033
                                      CAR ;
4034
                                      COMPARE ;
4035
                                      EQ ;
4036
                                      IF {} { PUSH string "FA2_NOT_OWNER" ; FAILWITH } ;
4037
                                      DIG 4 ;
4038
                                      DUP ;
4039
                                      GET 27 ;
4040
                                      NONE unit ;
4041
                                      DUP 4 ;
4042
                                      UPDATE ;
4043
                                      UPDATE 27 ;
4044
                                      DUG 4 ;
4045
                                      DUP 3 ;
4046
                                      DUP 2 ;
4047
                                      GET 4 ;
4048
                                      DUP 3 ;
4049
                                      CAR ;
4050
                                      DUP 4 ;
4051
                                      GET 3 ;
4052
                                      PUSH bool False ;
4053
                                      PAIR 4 ;
4054
                                      DIG 2 ;
4055
                                      DROP ;
4056
                                      DIG 2 ;
4057
                                      DROP ;
4058
                                      DIG 2 ;
4059
                                      DROP ;
4060
                                      EMIT %operator_update (pair (bool %is_operator)
4061
                                                                  (pair
4062
                                                                    (address %operator)
4063
                                                                    (pair
4064
                                                                      (address %owner)
4065
                                                                      (nat %token_id)))) ;
4066
                                      CONS } } ;
4067
                           SWAP ;
4068
                           DROP ;
4069
                           DIG 2 ;
4070
                           DROP ;
4071
                           DIG 2 ;
4072
                           DROP ;
4073
                           DIG 2 ;
4074
                           DROP ;
4075
                           DIG 2 ;
4076
                           DROP ;
4077
                           DIG 2 ;
4078
                           DROP ;
4079
                           DIG 2 ;
4080
                           DROP } } } } } ;
4081
       NIL operation ;
4082
       SWAP ;
4083
       ITER { CONS } ;
4084
       PAIR }