BCD

Tezos Contract Explorer
Search Networks Deploy
  • Home
  • /
  • Tezosx
  • /
  • KT1WKo4...Qm7B
operations (1)Storage Code Interact Tokens Fork Views Details
Latest
​x
775
1278
 
1
{ parameter (or
2
              (pair %transfer (address %caller_alias)
3
                              (pair (address %to_) (nat %amount)))
4
              (or
5
                (pair %approve (address %caller_alias)
6
                               (pair (address %spender) (nat %amount)))
7
                (or
8
                  (pair %transferFrom (address %caller_alias)
9
                                      (pair (address %from_)
10
                                            (pair (address %to_) (nat %amount))))
11
                  (or
12
                    (pair %mint (address %caller_alias)
13
                                (pair (address %to_) (nat %amount)))
14
                    (or
15
                      (pair %burn (address %caller_alias)
16
                                  (pair (address %from_) (nat %amount)))
17
                      (or
18
                        (pair %freezePartial (address %caller_alias)
19
                                             (pair (address %addr) (nat %amount)))
20
                        (or
21
                          (pair %unfreezePartial (address %caller_alias)
22
                                                 (pair (address %addr) (nat %amount)))
23
                          (or
24
                            (pair %freezeAddress (address %caller_alias) (address %addr))
25
                            (or
26
                              (pair %unfreezeAddress (address %caller_alias)
27
                                                     (address %addr))
28
                              (or
29
                                (pair %forcedTransfer (address %caller_alias)
30
                                                      (pair (address %from_)
31
                                                            (pair (address %to_)
32
                                                                  (nat %amount))))
33
                                (or
34
                                  (pair %recoveryAddress (address %caller_alias)
35
                                                         (pair (address %lost_wallet)
36
                                                               (pair
37
                                                                 (address %new_wallet)
38
                                                                 (address %investor_onchain_id))))
39
                                  (or (address %pause)
40
                                      (or (address %unpause)
41
                                          (or
42
                                            (pair %setName (address %caller_alias)
43
                                                           (string %new_name))
44
                                            (or
45
                                              (pair %setSymbol (address %caller_alias)
46
                                                               (string %new_symbol))
47
                                              (or
48
                                                (pair %setOnchainID
49
                                                  (address %caller_alias)
50
                                                  (address %new_onchain_id))
51
                                                (or
52
                                                  (pair %setVersion
53
                                                    (address %caller_alias)
54
                                                    (string %new_version))
55
                                                  (or
56
                                                    (pair %bindIR
57
                                                      (address %caller_alias)
58
                                                      (address %ir_addr))
59
                                                    (or
60
                                                      (pair %bindMC
61
                                                        (address %caller_alias)
62
                                                        (address %mc_addr))
63
                                                      (or
64
                                                        (pair %setOwner
65
                                                          (address %caller_alias)
66
                                                          (address %new_owner))
67
                                                        (or (address %setAdmin)
68
                                                            (or
69
                                                              (pair %addAgent
70
                                                                (address %caller_alias)
71
                                                                (address %agent_alias))
72
                                                              (pair %removeAgent
73
                                                                (address %caller_alias)
74
                                                                (address %agent_alias)))))))))))))))))))))))) ;
75
  storage (pair (address %admin)
76
                (pair (address %owner)
77
                      (pair (address %admin_sentinel)
78
                            (pair (address %bound_ir)
79
                                  (pair (address %bound_mc)
80
                                        (pair (big_map %balances address nat)
81
                                              (pair
82
                                                (big_map %allowances
83
                                                  (pair address address)
84
                                                  nat)
85
                                                (pair (nat %total_supply)
86
                                                      (pair
87
                                                        (big_map %frozen address nat)
88
                                                        (pair
89
                                                          (big_map %frozen_addrs address
90
                                                                                 bool)
91
                                                          (pair (bool %paused)
92
                                                                (pair (string %name)
93
                                                                      (pair
94
                                                                        (string %symbol)
95
                                                                        (pair
96
                                                                          (nat %decimals)
97
                                                                          (pair
98
                                                                            (string %version)
99
                                                                            (pair
100
                                                                              (address %onchain_id)
101
                                                                              (big_map %agents
102
                                                                                address
103
                                                                                unit))))))))))))))))) ;
104
  code { UNPAIR ;
105
         IF_LEFT
106
           { DUP 2 ;
107
             CAR ;
108
             SENDER ;
109
             COMPARE ;
110
             NEQ ;
111
             IF { PUSH string "TOKEN_NOT_ADMIN" ; FAILWITH } {} ;
112
             DUP ;
113
             CAR ;
114
             DUP 2 ;
115
             GET 4 ;
116
             DUP 3 ;
117
             GET 3 ;
118
             DUP 5 ;
119
             GET 21 ;
120
             IF { PUSH string "TOKEN_PAUSED" ; FAILWITH } {} ;
121
             DUP 5 ;
122
             GET 19 ;
123
             DUP 4 ;
124
             GET ;
125
             IF_NONE { PUSH bool False } {} ;
126
             IF { PUSH string "TOKEN_FROZEN_ADDRESS" ; FAILWITH } {} ;
127
             DUP 5 ;
128
             GET 19 ;
129
             DUP 2 ;
130
             GET ;
131
             IF_NONE { PUSH bool False } {} ;
132
             IF { PUSH string "TOKEN_FROZEN_ADDRESS" ; FAILWITH } {} ;
133
             DUP 2 ;
134
             DUP 6 ;
135
             GET 17 ;
136
             DUP 5 ;
137
             GET ;
138
             IF_NONE { PUSH nat 0 } {} ;
139
             DUP 7 ;
140
             GET 11 ;
141
             DUP 6 ;
142
             GET ;
143
             IF_NONE { PUSH nat 0 } {} ;
144
             SUB ;
145
             ISNAT ;
146
             IF_NONE { PUSH nat 0 } {} ;
147
             COMPARE ;
148
             LT ;
149
             IF { PUSH string "TOKEN_INSUFFICIENT_FREE_BALANCE" ; FAILWITH } {} ;
150
             DUP 5 ;
151
             GET 7 ;
152
             DUP 2 ;
153
             VIEW "isVerified" bool ;
154
             IF_NONE
155
               { PUSH string "TOKEN_IR_VIEW_FAILED" ; FAILWITH }
156
               { IF {} { PUSH string "TOKEN_NOT_VERIFIED_RECIPIENT" ; FAILWITH } } ;
157
             DUP 5 ;
158
             GET 9 ;
159
             DUG 2 ;
160
             DUP 4 ;
161
             PAIR 3 ;
162
             VIEW "canTransfer" bool ;
163
             IF_NONE
164
               { PUSH string "TOKEN_MC_VIEW_FAILED" ; FAILWITH }
165
               { IF {} { PUSH string "TOKEN_COMPLIANCE_DENIED" ; FAILWITH } } ;
166
             DUP 2 ;
167
             GET 4 ;
168
             DUP 3 ;
169
             GET 3 ;
170
             DUP 2 ;
171
             DUP 6 ;
172
             GET 11 ;
173
             DUP 5 ;
174
             GET ;
175
             IF_NONE { PUSH nat 0 } {} ;
176
             SUB ;
177
             ISNAT ;
178
             IF_NONE { PUSH string "TOKEN_INSUFFICIENT_BALANCE" ; FAILWITH } {} ;
179
             DUP 6 ;
180
             DUP 2 ;
181
             INT ;
182
             EQ ;
183
             IF
184
               { SWAP ; DROP ; DIG 5 ; GET 11 ; NONE nat ; DUP 6 ; UPDATE }
185
               { DIG 6 ; GET 11 ; DIG 2 ; SOME ; DUP 6 ; UPDATE } ;
186
             UPDATE 11 ;
187
             DIG 2 ;
188
             DUP 2 ;
189
             GET 11 ;
190
             DUP 4 ;
191
             GET ;
192
             IF_NONE { PUSH nat 0 } {} ;
193
             ADD ;
194
             DUP 2 ;
195
             DUP 2 ;
196
             INT ;
197
             EQ ;
198
             IF
199
               { SWAP ; DROP ; SWAP ; GET 11 ; NONE nat ; DIG 3 ; UPDATE }
200
               { DIG 2 ; GET 11 ; DIG 2 ; SOME ; DIG 3 ; UPDATE } ;
201
             UPDATE 11 ;
202
             DUP ;
203
             GET 9 ;
204
             CONTRACT %transferred (pair (address %from_)
205
                                         (pair (address %to_) (nat %amount))) ;
206
             IF_NONE { PUSH string "TOKEN_MC_HOOK_NOT_FOUND" ; FAILWITH } {} ;
207
             PUSH mutez 0 ;
208
             DUP 5 ;
209
             GET 4 ;
210
             DIG 5 ;
211
             GET 3 ;
212
             DIG 5 ;
213
             PAIR 3 ;
214
             TRANSFER_TOKENS ;
215
             SWAP ;
216
             NIL operation ;
217
             DIG 2 ;
218
             CONS }
219
           { IF_LEFT
220
               { DUP 2 ;
221
                 CAR ;
222
                 SENDER ;
223
                 COMPARE ;
224
                 NEQ ;
225
                 IF { PUSH string "TOKEN_NOT_ADMIN" ; FAILWITH } {} ;
226
                 DUP ;
227
                 GET 4 ;
228
                 DUP 2 ;
229
                 GET 3 ;
230
                 DIG 2 ;
231
                 CAR ;
232
                 DUP 4 ;
233
                 DUP 4 ;
234
                 INT ;
235
                 EQ ;
236
                 IF
237
                   { DIG 3 ; DROP ; DIG 3 ; GET 13 ; NONE nat ; DIG 4 ; DIG 4 ; PAIR ; UPDATE }
238
                   { DIG 4 ; GET 13 ; DIG 4 ; SOME ; DIG 4 ; DIG 4 ; PAIR ; UPDATE } ;
239
                 UPDATE 13 ;
240
                 NIL operation }
241
               { IF_LEFT
242
                   { DUP 2 ;
243
                     CAR ;
244
                     SENDER ;
245
                     COMPARE ;
246
                     NEQ ;
247
                     IF { PUSH string "TOKEN_NOT_ADMIN" ; FAILWITH } {} ;
248
                     DUP ;
249
                     GET 6 ;
250
                     DUP 3 ;
251
                     GET 13 ;
252
                     DUP 3 ;
253
                     CAR ;
254
                     DUP 4 ;
255
                     GET 3 ;
256
                     PAIR ;
257
                     GET ;
258
                     IF_NONE { PUSH nat 0 } {} ;
259
                     SUB ;
260
                     ISNAT ;
261
                     IF_NONE
262
                       { PUSH string "TOKEN_INSUFFICIENT_ALLOWANCE" ; FAILWITH }
263
                       {} ;
264
                     DUP 2 ;
265
                     GET 6 ;
266
                     DUP 3 ;
267
                     GET 5 ;
268
                     DUP 4 ;
269
                     GET 3 ;
270
                     DUP 6 ;
271
                     GET 21 ;
272
                     IF { PUSH string "TOKEN_PAUSED" ; FAILWITH } {} ;
273
                     DUP 6 ;
274
                     GET 19 ;
275
                     DUP 2 ;
276
                     GET ;
277
                     IF_NONE { PUSH bool False } {} ;
278
                     IF { PUSH string "TOKEN_FROZEN_ADDRESS" ; FAILWITH } {} ;
279
                     DUP 6 ;
280
                     GET 19 ;
281
                     DUP 3 ;
282
                     GET ;
283
                     IF_NONE { PUSH bool False } {} ;
284
                     IF { PUSH string "TOKEN_FROZEN_ADDRESS" ; FAILWITH } {} ;
285
                     DUP 3 ;
286
                     DUP 7 ;
287
                     GET 17 ;
288
                     DUP 3 ;
289
                     GET ;
290
                     IF_NONE { PUSH nat 0 } {} ;
291
                     DUP 8 ;
292
                     GET 11 ;
293
                     DUP 4 ;
294
                     GET ;
295
                     IF_NONE { PUSH nat 0 } {} ;
296
                     SUB ;
297
                     ISNAT ;
298
                     IF_NONE { PUSH nat 0 } {} ;
299
                     COMPARE ;
300
                     LT ;
301
                     IF
302
                       { PUSH string "TOKEN_INSUFFICIENT_FREE_BALANCE" ; FAILWITH }
303
                       {} ;
304
                     DUP 6 ;
305
                     GET 7 ;
306
                     DUP 3 ;
307
                     VIEW "isVerified" bool ;
308
                     IF_NONE
309
                       { PUSH string "TOKEN_IR_VIEW_FAILED" ; FAILWITH }
310
                       { IF
311
                           {}
312
                           { PUSH string "TOKEN_NOT_VERIFIED_RECIPIENT" ; FAILWITH } } ;
313
                     DUP 6 ;
314
                     GET 9 ;
315
                     DUG 3 ;
316
                     PAIR 3 ;
317
                     VIEW "canTransfer" bool ;
318
                     IF_NONE
319
                       { PUSH string "TOKEN_MC_VIEW_FAILED" ; FAILWITH }
320
                       { IF {} { PUSH string "TOKEN_COMPLIANCE_DENIED" ; FAILWITH } } ;
321
                     DUP 2 ;
322
                     GET 6 ;
323
                     DUP 3 ;
324
                     GET 5 ;
325
                     DUP 4 ;
326
                     GET 3 ;
327
                     DUP 5 ;
328
                     CAR ;
329
                     DUP 6 ;
330
                     GET 3 ;
331
                     DUP 8 ;
332
                     DUP 7 ;
333
                     INT ;
334
                     EQ ;
335
                     IF
336
                       { DIG 6 ; DROP ; DIG 7 ; GET 13 ; NONE nat ; DIG 4 ; DIG 4 ; PAIR ; UPDATE }
337
                       { DIG 8 ; GET 13 ; DIG 7 ; SOME ; DIG 4 ; DIG 4 ; PAIR ; UPDATE } ;
338
                     UPDATE 13 ;
339
                     DUP 4 ;
340
                     DUP 2 ;
341
                     GET 11 ;
342
                     DUP 4 ;
343
                     GET ;
344
                     IF_NONE { PUSH nat 0 } {} ;
345
                     SUB ;
346
                     ISNAT ;
347
                     IF_NONE
348
                       { PUSH string "TOKEN_INSUFFICIENT_BALANCE" ; FAILWITH }
349
                       {} ;
350
                     DUP 2 ;
351
                     DUP 2 ;
352
                     INT ;
353
                     EQ ;
354
                     IF
355
                       { SWAP ; DROP ; SWAP ; GET 11 ; NONE nat ; DIG 3 ; UPDATE }
356
                       { DIG 2 ; GET 11 ; DIG 2 ; SOME ; DIG 3 ; UPDATE } ;
357
                     UPDATE 11 ;
358
                     DIG 2 ;
359
                     DUP 2 ;
360
                     GET 11 ;
361
                     DUP 4 ;
362
                     GET ;
363
                     IF_NONE { PUSH nat 0 } {} ;
364
                     ADD ;
365
                     DUP 2 ;
366
                     DUP 2 ;
367
                     INT ;
368
                     EQ ;
369
                     IF
370
                       { SWAP ; DROP ; SWAP ; GET 11 ; NONE nat ; DIG 3 ; UPDATE }
371
                       { DIG 2 ; GET 11 ; DIG 2 ; SOME ; DIG 3 ; UPDATE } ;
372
                     UPDATE 11 ;
373
                     DUP ;
374
                     GET 9 ;
375
                     CONTRACT %transferred (pair (address %from_)
376
                                                 (pair (address %to_) (nat %amount))) ;
377
                     IF_NONE { PUSH string "TOKEN_MC_HOOK_NOT_FOUND" ; FAILWITH } {} ;
378
                     PUSH mutez 0 ;
379
                     DUP 4 ;
380
                     GET 6 ;
381
                     DUP 5 ;
382
                     GET 5 ;
383
                     DIG 5 ;
384
                     GET 3 ;
385
                     PAIR 3 ;
386
                     TRANSFER_TOKENS ;
387
                     SWAP ;
388
                     NIL operation ;
389
                     DIG 2 ;
390
                     CONS }
391
                   { IF_LEFT
392
                       { DUP 2 ;
393
                         CAR ;
394
                         SENDER ;
395
                         COMPARE ;
396
                         NEQ ;
397
                         IF { PUSH string "TOKEN_NOT_ADMIN" ; FAILWITH } {} ;
398
                         DUP ;
399
                         CAR ;
400
                         DUP 3 ;
401
                         GET 3 ;
402
                         DUP 2 ;
403
                         COMPARE ;
404
                         EQ ;
405
                         IF
406
                           { DROP }
407
                           { DUP 3 ;
408
                             GET 32 ;
409
                             SWAP ;
410
                             MEM ;
411
                             IF {} { PUSH string "TOKEN_NOT_AGENT" ; FAILWITH } } ;
412
                         DUP 2 ;
413
                         GET 21 ;
414
                         IF { PUSH string "TOKEN_PAUSED" ; FAILWITH } {} ;
415
                         DUP 2 ;
416
                         GET 7 ;
417
                         DUP 2 ;
418
                         GET 3 ;
419
                         VIEW "isVerified" bool ;
420
                         IF_NONE
421
                           { PUSH string "TOKEN_IR_VIEW_FAILED" ; FAILWITH }
422
                           { IF
423
                               {}
424
                               { PUSH string "TOKEN_NOT_VERIFIED_RECIPIENT" ; FAILWITH } } ;
425
                         DUP ;
426
                         GET 4 ;
427
                         DUP 3 ;
428
                         GET 11 ;
429
                         DUP 3 ;
430
                         GET 3 ;
431
                         GET ;
432
                         IF_NONE { PUSH nat 0 } {} ;
433
                         ADD ;
434
                         DUP 2 ;
435
                         GET 3 ;
436
                         DUP 4 ;
437
                         DUP 3 ;
438
                         INT ;
439
                         EQ ;
440
                         IF
441
                           { DIG 2 ; DROP ; DIG 3 ; GET 11 ; NONE nat ; DIG 3 ; UPDATE }
442
                           { DIG 4 ; GET 11 ; DIG 3 ; SOME ; DIG 3 ; UPDATE } ;
443
                         UPDATE 11 ;
444
                         DUP ;
445
                         DUP 3 ;
446
                         GET 4 ;
447
                         DIG 2 ;
448
                         GET 15 ;
449
                         ADD ;
450
                         UPDATE 15 ;
451
                         DUP ;
452
                         GET 9 ;
453
                         CONTRACT %created (pair (address %to_) (nat %amount)) ;
454
                         IF_NONE
455
                           { PUSH string "TOKEN_MC_HOOK_NOT_FOUND" ; FAILWITH }
456
                           {} ;
457
                         PUSH mutez 0 ;
458
                         DUP 4 ;
459
                         GET 4 ;
460
                         DIG 4 ;
461
                         GET 3 ;
462
                         PAIR ;
463
                         TRANSFER_TOKENS ;
464
                         SWAP ;
465
                         NIL operation ;
466
                         DIG 2 ;
467
                         CONS }
468
                       { IF_LEFT
469
                           { DUP 2 ;
470
                             CAR ;
471
                             SENDER ;
472
                             COMPARE ;
473
                             NEQ ;
474
                             IF { PUSH string "TOKEN_NOT_ADMIN" ; FAILWITH } {} ;
475
                             DUP ;
476
                             CAR ;
477
                             DUP 3 ;
478
                             GET 3 ;
479
                             DUP 2 ;
480
                             COMPARE ;
481
                             EQ ;
482
                             IF
483
                               { DROP }
484
                               { DUP 3 ;
485
                                 GET 32 ;
486
                                 SWAP ;
487
                                 MEM ;
488
                                 IF {} { PUSH string "TOKEN_NOT_AGENT" ; FAILWITH } } ;
489
                             DUP 2 ;
490
                             GET 21 ;
491
                             IF { PUSH string "TOKEN_PAUSED" ; FAILWITH } {} ;
492
                             DUP ;
493
                             GET 4 ;
494
                             DUP 3 ;
495
                             GET 11 ;
496
                             DUP 3 ;
497
                             GET 3 ;
498
                             GET ;
499
                             IF_NONE { PUSH nat 0 } {} ;
500
                             SUB ;
501
                             ISNAT ;
502
                             IF_NONE
503
                               { PUSH string "TOKEN_INSUFFICIENT_BALANCE" ; FAILWITH }
504
                               {} ;
505
                             DUP 2 ;
506
                             GET 3 ;
507
                             DUP 4 ;
508
                             DUP 3 ;
509
                             INT ;
510
                             EQ ;
511
                             IF
512
                               { DUP 5 ; GET 11 ; NONE nat ; DIG 3 ; UPDATE }
513
                               { DUP 5 ; GET 11 ; DUP 4 ; SOME ; DIG 3 ; UPDATE } ;
514
                             UPDATE 11 ;
515
                             DUP 2 ;
516
                             DIG 4 ;
517
                             GET 17 ;
518
                             DUP 5 ;
519
                             GET 3 ;
520
                             GET ;
521
                             IF_NONE { PUSH nat 0 } {} ;
522
                             COMPARE ;
523
                             GT ;
524
                             IF
525
                               { DUP 3 ;
526
                                 GET 3 ;
527
                                 DUP 2 ;
528
                                 DUP 4 ;
529
                                 INT ;
530
                                 EQ ;
531
                                 IF
532
                                   { DIG 3 ; DROP ; DIG 2 ; GET 17 ; NONE nat ; DIG 3 ; UPDATE }
533
                                   { DIG 2 ; GET 17 ; DIG 3 ; SOME ; DIG 3 ; UPDATE } ;
534
                                 UPDATE 17 }
535
                               { SWAP ; DROP } ;
536
                             DUP ;
537
                             DUP 3 ;
538
                             GET 4 ;
539
                             DIG 2 ;
540
                             GET 15 ;
541
                             SUB ;
542
                             ISNAT ;
543
                             IF_NONE
544
                               { PUSH string "TOKEN_INSUFFICIENT_BALANCE" ; FAILWITH }
545
                               {} ;
546
                             UPDATE 15 ;
547
                             DUP ;
548
                             GET 9 ;
549
                             CONTRACT %destroyed (pair (address %from_) (nat %amount)) ;
550
                             IF_NONE
551
                               { PUSH string "TOKEN_MC_HOOK_NOT_FOUND" ; FAILWITH }
552
                               {} ;
553
                             PUSH mutez 0 ;
554
                             DUP 4 ;
555
                             GET 4 ;
556
                             DIG 4 ;
557
                             GET 3 ;
558
                             PAIR ;
559
                             TRANSFER_TOKENS ;
560
                             SWAP ;
561
                             NIL operation ;
562
                             DIG 2 ;
563
                             CONS }
564
                           { IF_LEFT
565
                               { DUP 2 ;
566
                                 CAR ;
567
                                 SENDER ;
568
                                 COMPARE ;
569
                                 NEQ ;
570
                                 IF { PUSH string "TOKEN_NOT_ADMIN" ; FAILWITH } {} ;
571
                                 DUP ;
572
                                 CAR ;
573
                                 DUP 3 ;
574
                                 GET 3 ;
575
                                 DUP 2 ;
576
                                 COMPARE ;
577
                                 EQ ;
578
                                 IF
579
                                   { DROP }
580
                                   { DUP 3 ;
581
                                     GET 32 ;
582
                                     SWAP ;
583
                                     MEM ;
584
                                     IF
585
                                       {}
586
                                       { PUSH string "TOKEN_NOT_AGENT" ; FAILWITH } } ;
587
                                 DUP 2 ;
588
                                 GET 11 ;
589
                                 DUP 2 ;
590
                                 GET 3 ;
591
                                 GET ;
592
                                 IF_NONE { PUSH nat 0 } {} ;
593
                                 DUP 2 ;
594
                                 GET 4 ;
595
                                 DUP 4 ;
596
                                 GET 17 ;
597
                                 DUP 4 ;
598
                                 GET 3 ;
599
                                 GET ;
600
                                 IF_NONE { PUSH nat 0 } {} ;
601
                                 ADD ;
602
                                 DUP 2 ;
603
                                 DUP 2 ;
604
                                 COMPARE ;
605
                                 GT ;
606
                                 IF { DROP } { SWAP ; DROP } ;
607
                                 SWAP ;
608
                                 GET 3 ;
609
                                 DUP 3 ;
610
                                 DUP 3 ;
611
                                 INT ;
612
                                 EQ ;
613
                                 IF
614
                                   { DIG 2 ; DROP ; DIG 2 ; GET 17 ; NONE nat ; DIG 3 ; UPDATE }
615
                                   { DIG 3 ; GET 17 ; DIG 3 ; SOME ; DIG 3 ; UPDATE } ;
616
                                 UPDATE 17 ;
617
                                 NIL operation }
618
                               { IF_LEFT
619
                                   { DUP 2 ;
620
                                     CAR ;
621
                                     SENDER ;
622
                                     COMPARE ;
623
                                     NEQ ;
624
                                     IF
625
                                       { PUSH string "TOKEN_NOT_ADMIN" ; FAILWITH }
626
                                       {} ;
627
                                     DUP ;
628
                                     CAR ;
629
                                     DUP 3 ;
630
                                     GET 3 ;
631
                                     DUP 2 ;
632
                                     COMPARE ;
633
                                     EQ ;
634
                                     IF
635
                                       { DROP }
636
                                       { DUP 3 ;
637
                                         GET 32 ;
638
                                         SWAP ;
639
                                         MEM ;
640
                                         IF
641
                                           {}
642
                                           { PUSH string "TOKEN_NOT_AGENT" ; FAILWITH } } ;
643
                                     DUP ;
644
                                     GET 4 ;
645
                                     DUP 3 ;
646
                                     GET 17 ;
647
                                     DUP 3 ;
648
                                     GET 3 ;
649
                                     GET ;
650
                                     IF_NONE { PUSH nat 0 } {} ;
651
                                     SUB ;
652
                                     ISNAT ;
653
                                     IF_NONE { PUSH nat 0 } {} ;
654
                                     SWAP ;
655
                                     GET 3 ;
656
                                     DUP 3 ;
657
                                     DUP 3 ;
658
                                     INT ;
659
                                     EQ ;
660
                                     IF
661
                                       { DIG 2 ; DROP ; DIG 2 ; GET 17 ; NONE nat ; DIG 3 ; UPDATE }
662
                                       { DIG 3 ; GET 17 ; DIG 3 ; SOME ; DIG 3 ; UPDATE } ;
663
                                     UPDATE 17 ;
664
                                     NIL operation }
665
                                   { IF_LEFT
666
                                       { DUP 2 ;
667
                                         CAR ;
668
                                         SENDER ;
669
                                         COMPARE ;
670
                                         NEQ ;
671
                                         IF
672
                                           { PUSH string "TOKEN_NOT_ADMIN" ; FAILWITH }
673
                                           {} ;
674
                                         DUP ;
675
                                         CAR ;
676
                                         DUP 3 ;
677
                                         GET 3 ;
678
                                         DUP 2 ;
679
                                         COMPARE ;
680
                                         EQ ;
681
                                         IF
682
                                           { DROP }
683
                                           { DUP 3 ;
684
                                             GET 32 ;
685
                                             SWAP ;
686
                                             MEM ;
687
                                             IF
688
                                               {}
689
                                               { PUSH string "TOKEN_NOT_AGENT" ;
690
                                                 FAILWITH } } ;
691
                                         SWAP ;
692
                                         DUP ;
693
                                         GET 19 ;
694
                                         PUSH bool True ;
695
                                         SOME ;
696
                                         DIG 3 ;
697
                                         CDR ;
698
                                         UPDATE ;
699
                                         UPDATE 19 ;
700
                                         NIL operation }
701
                                       { IF_LEFT
702
                                           { DUP 2 ;
703
                                             CAR ;
704
                                             SENDER ;
705
                                             COMPARE ;
706
                                             NEQ ;
707
                                             IF
708
                                               { PUSH string "TOKEN_NOT_ADMIN" ;
709
                                                 FAILWITH }
710
                                               {} ;
711
                                             DUP ;
712
                                             CAR ;
713
                                             DUP 3 ;
714
                                             GET 3 ;
715
                                             DUP 2 ;
716
                                             COMPARE ;
717
                                             EQ ;
718
                                             IF
719
                                               { DROP }
720
                                               { DUP 3 ;
721
                                                 GET 32 ;
722
                                                 SWAP ;
723
                                                 MEM ;
724
                                                 IF
725
                                                   {}
726
                                                   { PUSH string "TOKEN_NOT_AGENT" ;
727
                                                     FAILWITH } } ;
728
                                             SWAP ;
729
                                             DUP ;
730
                                             GET 19 ;
731
                                             PUSH bool False ;
732
                                             SOME ;
733
                                             DIG 3 ;
734
                                             CDR ;
735
                                             UPDATE ;
736
                                             UPDATE 19 ;
737
                                             NIL operation }
738
                                           { IF_LEFT
739
                                               { DUP 2 ;
740
                                                 CAR ;
741
                                                 SENDER ;
742
                                                 COMPARE ;
743
                                                 NEQ ;
744
                                                 IF
745
                                                   { PUSH string "TOKEN_NOT_ADMIN" ;
746
                                                     FAILWITH }
747
                                                   {} ;
748
                                                 DUP ;
749
                                                 CAR ;
750
                                                 DUP 3 ;
751
                                                 GET 3 ;
752
                                                 DUP 2 ;
753
                                                 COMPARE ;
754
                                                 EQ ;
755
                                                 IF
756
                                                   { DROP }
757
                                                   { DUP 3 ;
758
                                                     GET 32 ;
759
                                                     SWAP ;
760
                                                     MEM ;
761
                                                     IF
762
                                                       {}
763
                                                       { PUSH string "TOKEN_NOT_AGENT" ;
764
                                                         FAILWITH } } ;
765
                                                 DUP 2 ;
766
                                                 GET 21 ;
767
                                                 IF
768
                                                   { PUSH string "TOKEN_PAUSED" ;
769
                                                     FAILWITH }
770
                                                   {} ;
771
                                                 DUP 2 ;
772
                                                 GET 7 ;
773
                                                 DUP 2 ;
774
                                                 GET 5 ;
775
                                                 VIEW "isVerified" bool ;
776
                                                 IF_NONE
777
                                                   { PUSH string "TOKEN_IR_VIEW_FAILED" ;
778
                                                     FAILWITH }
779
                                                   { IF
780
                                                       {}
781
                                                       { PUSH string "TOKEN_NOT_VERIFIED_RECIPIENT" ;
782
                                                         FAILWITH } } ;
783
                                                 DUP ;
784
                                                 GET 5 ;
785
                                                 DUP 2 ;
786
                                                 GET 3 ;
787
                                                 COMPARE ;
788
                                                 EQ ;
789
                                                 IF
790
                                                   { DROP ; NIL operation }
791
                                                   { DUP ;
792
                                                     GET 6 ;
793
                                                     DUP 3 ;
794
                                                     GET 11 ;
795
                                                     DUP 3 ;
796
                                                     GET 3 ;
797
                                                     GET ;
798
                                                     IF_NONE { PUSH nat 0 } {} ;
799
                                                     SUB ;
800
                                                     ISNAT ;
801
                                                     IF_NONE
802
                                                       { PUSH string "TOKEN_INSUFFICIENT_BALANCE" ;
803
                                                         FAILWITH }
804
                                                       {} ;
805
                                                     DUP 2 ;
806
                                                     GET 3 ;
807
                                                     DUP 4 ;
808
                                                     DUP 3 ;
809
                                                     INT ;
810
                                                     EQ ;
811
                                                     IF
812
                                                       { DUP 5 ;
813
                                                         GET 11 ;
814
                                                         NONE nat ;
815
                                                         DIG 3 ;
816
                                                         UPDATE }
817
                                                       { DUP 5 ;
818
                                                         GET 11 ;
819
                                                         DUP 4 ;
820
                                                         SOME ;
821
                                                         DIG 3 ;
822
                                                         UPDATE } ;
823
                                                     UPDATE 11 ;
824
                                                     DUP 2 ;
825
                                                     DIG 4 ;
826
                                                     GET 17 ;
827
                                                     DUP 5 ;
828
                                                     GET 3 ;
829
                                                     GET ;
830
                                                     IF_NONE { PUSH nat 0 } {} ;
831
                                                     COMPARE ;
832
                                                     GT ;
833
                                                     IF
834
                                                       { DUP 3 ;
835
                                                         GET 3 ;
836
                                                         DUP 2 ;
837
                                                         DUP 4 ;
838
                                                         INT ;
839
                                                         EQ ;
840
                                                         IF
841
                                                           { DIG 3 ;
842
                                                             DROP ;
843
                                                             DIG 2 ;
844
                                                             GET 17 ;
845
                                                             NONE nat ;
846
                                                             DIG 3 ;
847
                                                             UPDATE }
848
                                                           { DIG 2 ;
849
                                                             GET 17 ;
850
                                                             DIG 3 ;
851
                                                             SOME ;
852
                                                             DIG 3 ;
853
                                                             UPDATE } ;
854
                                                         UPDATE 17 }
855
                                                       { SWAP ; DROP } ;
856
                                                     DUP 2 ;
857
                                                     GET 6 ;
858
                                                     DUP 2 ;
859
                                                     GET 11 ;
860
                                                     DUP 4 ;
861
                                                     GET 5 ;
862
                                                     GET ;
863
                                                     IF_NONE { PUSH nat 0 } {} ;
864
                                                     ADD ;
865
                                                     DUP 3 ;
866
                                                     GET 5 ;
867
                                                     DIG 2 ;
868
                                                     DUP ;
869
                                                     DUP 4 ;
870
                                                     INT ;
871
                                                     EQ ;
872
                                                     IF
873
                                                       { DIG 3 ;
874
                                                         DROP ;
875
                                                         SWAP ;
876
                                                         GET 11 ;
877
                                                         NONE nat ;
878
                                                         DIG 3 ;
879
                                                         UPDATE }
880
                                                       { SWAP ;
881
                                                         GET 11 ;
882
                                                         DIG 3 ;
883
                                                         SOME ;
884
                                                         DIG 3 ;
885
                                                         UPDATE } ;
886
                                                     UPDATE 11 ;
887
                                                     DUP ;
888
                                                     GET 9 ;
889
                                                     CONTRACT %transferred (pair
890
                                                                             (address %from_)
891
                                                                             (pair
892
                                                                               (address %to_)
893
                                                                               (nat %amount))) ;
894
                                                     IF_NONE
895
                                                       { PUSH string "TOKEN_MC_HOOK_NOT_FOUND" ;
896
                                                         FAILWITH }
897
                                                       {} ;
898
                                                     PUSH mutez 0 ;
899
                                                     DUP 4 ;
900
                                                     GET 6 ;
901
                                                     DUP 5 ;
902
                                                     GET 5 ;
903
                                                     DIG 5 ;
904
                                                     GET 3 ;
905
                                                     PAIR 3 ;
906
                                                     TRANSFER_TOKENS ;
907
                                                     SWAP ;
908
                                                     NIL operation ;
909
                                                     DIG 2 ;
910
                                                     CONS } }
911
                                               { IF_LEFT
912
                                                   { DUP 2 ;
913
                                                     CAR ;
914
                                                     SENDER ;
915
                                                     COMPARE ;
916
                                                     NEQ ;
917
                                                     IF
918
                                                       { PUSH string "TOKEN_NOT_ADMIN" ;
919
                                                         FAILWITH }
920
                                                       {} ;
921
                                                     DUP ;
922
                                                     CAR ;
923
                                                     DUP 3 ;
924
                                                     GET 3 ;
925
                                                     DUP 2 ;
926
                                                     COMPARE ;
927
                                                     EQ ;
928
                                                     IF
929
                                                       { DROP }
930
                                                       { DUP 3 ;
931
                                                         GET 32 ;
932
                                                         SWAP ;
933
                                                         MEM ;
934
                                                         IF
935
                                                           {}
936
                                                           { PUSH string "TOKEN_NOT_AGENT" ;
937
                                                             FAILWITH } } ;
938
                                                     DUP 2 ;
939
                                                     GET 21 ;
940
                                                     IF
941
                                                       { PUSH string "TOKEN_PAUSED" ;
942
                                                         FAILWITH }
943
                                                       {} ;
944
                                                     DUP 2 ;
945
                                                     GET 7 ;
946
                                                     DUP 2 ;
947
                                                     GET 5 ;
948
                                                     VIEW "isVerified" bool ;
949
                                                     IF_NONE
950
                                                       { PUSH string "TOKEN_IR_VIEW_FAILED" ;
951
                                                         FAILWITH }
952
                                                       {} ;
953
                                                     IF
954
                                                       {}
955
                                                       { PUSH string "TOKEN_RECOVERY_IDENTITY_MISMATCH" ;
956
                                                         FAILWITH } ;
957
                                                     DUP 2 ;
958
                                                     GET 7 ;
959
                                                     DUP 2 ;
960
                                                     GET 5 ;
961
                                                     VIEW "identityOf" address ;
962
                                                     IF_NONE
963
                                                       { PUSH string "TOKEN_RECOVERY_IDENTITY_MISMATCH" ;
964
                                                         FAILWITH }
965
                                                       {} ;
966
                                                     DUP 2 ;
967
                                                     GET 6 ;
968
                                                     COMPARE ;
969
                                                     NEQ ;
970
                                                     IF
971
                                                       { PUSH string "TOKEN_RECOVERY_IDENTITY_MISMATCH" ;
972
                                                         FAILWITH }
973
                                                       {} ;
974
                                                     DUP 2 ;
975
                                                     GET 11 ;
976
                                                     DUP 2 ;
977
                                                     GET 3 ;
978
                                                     GET ;
979
                                                     IF_NONE { PUSH nat 0 } {} ;
980
                                                     DUP ;
981
                                                     INT ;
982
                                                     EQ ;
983
                                                     IF
984
                                                       { PUSH string "TOKEN_RECOVERY_NO_BALANCE" ;
985
                                                         FAILWITH }
986
                                                       {} ;
987
                                                     PUSH nat 0 ;
988
                                                     DUP 3 ;
989
                                                     GET 3 ;
990
                                                     DUP 5 ;
991
                                                     DUP 3 ;
992
                                                     INT ;
993
                                                     EQ ;
994
                                                     IF
995
                                                       { DIG 2 ;
996
                                                         DROP ;
997
                                                         DUP 5 ;
998
                                                         GET 11 ;
999
                                                         NONE nat ;
1000
                                                         DIG 3 ;
1001
                                                         UPDATE }
1002
                                                       { DUP 6 ;
1003
                                                         GET 11 ;
1004
                                                         DIG 3 ;
1005
                                                         SOME ;
1006
                                                         DIG 3 ;
1007
                                                         UPDATE } ;
1008
                                                     UPDATE 11 ;
1009
                                                     DUP 2 ;
1010
                                                     DUP 2 ;
1011
                                                     GET 11 ;
1012
                                                     DUP 5 ;
1013
                                                     GET 5 ;
1014
                                                     GET ;
1015
                                                     IF_NONE { PUSH nat 0 } {} ;
1016
                                                     ADD ;
1017
                                                     DUP 4 ;
1018
                                                     GET 5 ;
1019
                                                     DIG 2 ;
1020
                                                     DUP ;
1021
                                                     DUP 4 ;
1022
                                                     INT ;
1023
                                                     EQ ;
1024
                                                     IF
1025
                                                       { DIG 3 ;
1026
                                                         DROP ;
1027
                                                         SWAP ;
1028
                                                         GET 11 ;
1029
                                                         NONE nat ;
1030
                                                         DIG 3 ;
1031
                                                         UPDATE }
1032
                                                       { SWAP ;
1033
                                                         GET 11 ;
1034
                                                         DIG 3 ;
1035
                                                         SOME ;
1036
                                                         DIG 3 ;
1037
                                                         UPDATE } ;
1038
                                                     UPDATE 11 ;
1039
                                                     PUSH nat 0 ;
1040
                                                     DUP 4 ;
1041
                                                     GET 3 ;
1042
                                                     DUP 3 ;
1043
                                                     DUP 3 ;
1044
                                                     INT ;
1045
                                                     EQ ;
1046
                                                     IF
1047
                                                       { DIG 2 ;
1048
                                                         DROP ;
1049
                                                         DIG 2 ;
1050
                                                         GET 17 ;
1051
                                                         NONE nat ;
1052
                                                         DIG 3 ;
1053
                                                         UPDATE }
1054
                                                       { DIG 3 ;
1055
                                                         GET 17 ;
1056
                                                         DIG 3 ;
1057
                                                         SOME ;
1058
                                                         DIG 3 ;
1059
                                                         UPDATE } ;
1060
                                                     UPDATE 17 ;
1061
                                                     DIG 3 ;
1062
                                                     GET 17 ;
1063
                                                     DUP 4 ;
1064
                                                     GET 3 ;
1065
                                                     GET ;
1066
                                                     IF_NONE { PUSH nat 0 } {} ;
1067
                                                     DUP 2 ;
1068
                                                     GET 17 ;
1069
                                                     DUP 5 ;
1070
                                                     GET 5 ;
1071
                                                     GET ;
1072
                                                     IF_NONE { PUSH nat 0 } {} ;
1073
                                                     ADD ;
1074
                                                     DUP 4 ;
1075
                                                     GET 5 ;
1076
                                                     DIG 2 ;
1077
                                                     DUP ;
1078
                                                     DUP 4 ;
1079
                                                     INT ;
1080
                                                     EQ ;
1081
                                                     IF
1082
                                                       { DIG 3 ;
1083
                                                         DROP ;
1084
                                                         SWAP ;
1085
                                                         GET 17 ;
1086
                                                         NONE nat ;
1087
                                                         DIG 3 ;
1088
                                                         UPDATE }
1089
                                                       { SWAP ;
1090
                                                         GET 17 ;
1091
                                                         DIG 3 ;
1092
                                                         SOME ;
1093
                                                         DIG 3 ;
1094
                                                         UPDATE } ;
1095
                                                     UPDATE 17 ;
1096
                                                     DUP ;
1097
                                                     GET 9 ;
1098
                                                     CONTRACT %transferred (pair
1099
                                                                             (address %from_)
1100
                                                                             (pair
1101
                                                                               (address %to_)
1102
                                                                               (nat %amount))) ;
1103
                                                     IF_NONE
1104
                                                       { PUSH string "TOKEN_MC_HOOK_NOT_FOUND" ;
1105
                                                         FAILWITH }
1106
                                                       {} ;
1107
                                                     PUSH mutez 0 ;
1108
                                                     DIG 3 ;
1109
                                                     DUP 5 ;
1110
                                                     GET 5 ;
1111
                                                     DIG 5 ;
1112
                                                     GET 3 ;
1113
                                                     PAIR 3 ;
1114
                                                     TRANSFER_TOKENS ;
1115
                                                     SWAP ;
1116
                                                     NIL operation ;
1117
                                                     DIG 2 ;
1118
                                                     CONS }
1119
                                                   { IF_LEFT
1120
                                                       { DUP 2 ;
1121
                                                         CAR ;
1122
                                                         SENDER ;
1123
                                                         COMPARE ;
1124
                                                         NEQ ;
1125
                                                         IF
1126
                                                           { PUSH string "TOKEN_NOT_ADMIN" ;
1127
                                                             FAILWITH }
1128
                                                           {} ;
1129
                                                         DUP 2 ;
1130
                                                         GET 3 ;
1131
                                                         DUP 2 ;
1132
                                                         COMPARE ;
1133
                                                         EQ ;
1134
                                                         IF
1135
                                                           { DROP }
1136
                                                           { DUP 2 ;
1137
                                                             GET 32 ;
1138
                                                             SWAP ;
1139
                                                             MEM ;
1140
                                                             IF
1141
                                                               {}
1142
                                                               { PUSH string "TOKEN_NOT_AGENT" ;
1143
                                                                 FAILWITH } } ;
1144
                                                         PUSH bool True ;
1145
                                                         UPDATE 21 }
1146
                                                       { IF_LEFT
1147
                                                           { DUP 2 ;
1148
                                                             CAR ;
1149
                                                             SENDER ;
1150
                                                             COMPARE ;
1151
                                                             NEQ ;
1152
                                                             IF
1153
                                                               { PUSH string "TOKEN_NOT_ADMIN" ;
1154
                                                                 FAILWITH }
1155
                                                               {} ;
1156
                                                             DUP 2 ;
1157
                                                             GET 3 ;
1158
                                                             DUP 2 ;
1159
                                                             COMPARE ;
1160
                                                             EQ ;
1161
                                                             IF
1162
                                                               { DROP }
1163
                                                               { DUP 2 ;
1164
                                                                 GET 32 ;
1165
                                                                 SWAP ;
1166
                                                                 MEM ;
1167
                                                                 IF
1168
                                                                   {}
1169
                                                                   { PUSH string "TOKEN_NOT_AGENT" ;
1170
                                                                     FAILWITH } } ;
1171
                                                             PUSH bool False ;
1172
                                                             UPDATE 21 }
1173
                                                           { IF_LEFT
1174
                                                               { DUP 2 ;
1175
                                                                 CAR ;
1176
                                                                 SENDER ;
1177
                                                                 COMPARE ;
1178
                                                                 NEQ ;
1179
                                                                 IF
1180
                                                                   { PUSH string "TOKEN_NOT_ADMIN" ;
1181
                                                                     FAILWITH }
1182
                                                                   {} ;
1183
                                                                 DUP 2 ;
1184
                                                                 GET 3 ;
1185
                                                                 DUP 2 ;
1186
                                                                 CAR ;
1187
                                                                 COMPARE ;
1188
                                                                 NEQ ;
1189
                                                                 IF
1190
                                                                   { PUSH string "TOKEN_NOT_OWNER" ;
1191
                                                                     FAILWITH }
1192
                                                                   {} ;
1193
                                                                 CDR ;
1194
                                                                 UPDATE 23 }
1195
                                                               { IF_LEFT
1196
                                                                   { DUP 2 ;
1197
                                                                     CAR ;
1198
                                                                     SENDER ;
1199
                                                                     COMPARE ;
1200
                                                                     NEQ ;
1201
                                                                     IF
1202
                                                                       { PUSH string "TOKEN_NOT_ADMIN" ;
1203
                                                                         FAILWITH }
1204
                                                                       {} ;
1205
                                                                     DUP 2 ;
1206
                                                                     GET 3 ;
1207
                                                                     DUP 2 ;
1208
                                                                     CAR ;
1209
                                                                     COMPARE ;
1210
                                                                     NEQ ;
1211
                                                                     IF
1212
                                                                       { PUSH string "TOKEN_NOT_OWNER" ;
1213
                                                                         FAILWITH }
1214
                                                                       {} ;
1215
                                                                     CDR ;
1216
                                                                     UPDATE 25 }
1217
                                                                   { IF_LEFT
1218
                                                                       { DUP 2 ;
1219
                                                                         CAR ;
1220
                                                                         SENDER ;
1221
                                                                         COMPARE ;
1222
                                                                         NEQ ;
1223
                                                                         IF
1224
                                                                           { PUSH string "TOKEN_NOT_ADMIN" ;
1225
                                                                             FAILWITH }
1226
                                                                           {} ;
1227
                                                                         DUP 2 ;
1228
                                                                         GET 3 ;
1229
                                                                         DUP 2 ;
1230
                                                                         CAR ;
1231
                                                                         COMPARE ;
1232
                                                                         NEQ ;
1233
                                                                         IF
1234
                                                                           { PUSH string "TOKEN_NOT_OWNER" ;
1235
                                                                             FAILWITH }
1236
                                                                           {} ;
1237
                                                                         CDR ;
1238
                                                                         UPDATE 31 }
1239
                                                                       { IF_LEFT
1240
                                                                           { DUP 2 ;
1241
                                                                             CAR ;
1242
                                                                             SENDER ;
1243
                                                                             COMPARE ;
1244
                                                                             NEQ ;
1245
                                                                             IF
1246
                                                                               { PUSH string "TOKEN_NOT_ADMIN" ;
1247
                                                                                 FAILWITH }
1248
                                                                               {} ;
1249
                                                                             DUP 2 ;
1250
                                                                             GET 3 ;
1251
                                                                             DUP 2 ;
1252
                                                                             CAR ;
1253
                                                                             COMPARE ;
1254
                                                                             NEQ ;
1255
                                                                             IF
1256
                                                                               { PUSH string "TOKEN_NOT_OWNER" ;
1257
                                                                                 FAILWITH }
1258
                                                                               {} ;
1259
                                                                             CDR ;
1260
                                                                             UPDATE 29 }
1261
                                                                           { IF_LEFT
1262
                                                                               { DUP 2 ;
1263
                                                                                 CAR ;
1264
                                                                                 SENDER ;
1265
                                                                                 COMPARE ;
1266
                                                                                 NEQ ;
1267
                                                                                 IF
1268
                                                                                   { PUSH string "TOKEN_NOT_ADMIN" ;
1269
                                                                                     FAILWITH }
1270
                                                                                   {} ;
1271
                                                                                 DUP 2 ;
1272
                                                                                 GET 3 ;
1273
                                                                                 DUP 2 ;
1274
                                                                                 CAR ;
1275
                                                                                 COMPARE ;
1276
                                                                                 NEQ ;
1277
                                                                                 IF
1278
                                                                                   { PUSH string "TOKEN_NOT_OWNER" ;
1279
                                                                                     FAILWITH }
1280
                                                                                   {} ;
1281
                                                                                 DUP 2 ;
1282
                                                                                 GET 5 ;
1283
                                                                                 DUP 3 ;
1284
                                                                                 GET 7 ;
1285
                                                                                 COMPARE ;
1286
                                                                                 EQ ;
1287
                                                                                 IF
1288
                                                                                   {}
1289
                                                                                   { PUSH string "TOKEN_ALREADY_BOUND_IR" ;
1290
                                                                                     FAILWITH } ;
1291
                                                                                 CDR ;
1292
                                                                                 UPDATE 7 }
1293
                                                                               { IF_LEFT
1294
                                                                                   { DUP 2 ;
1295
                                                                                     CAR ;
1296
                                                                                     SENDER ;
1297
                                                                                     COMPARE ;
1298
                                                                                     NEQ ;
1299
                                                                                     IF
1300
                                                                                       { PUSH string "TOKEN_NOT_ADMIN" ;
1301
                                                                                         FAILWITH }
1302
                                                                                       {} ;
1303
                                                                                     DUP 2 ;
1304
                                                                                     GET 3 ;
1305
                                                                                     DUP 2 ;
1306
                                                                                     CAR ;
1307
                                                                                     COMPARE ;
1308
                                                                                     NEQ ;
1309
                                                                                     IF
1310
                                                                                       { PUSH string "TOKEN_NOT_OWNER" ;
1311
                                                                                         FAILWITH }
1312
                                                                                       {} ;
1313
                                                                                     DUP 2 ;
1314
                                                                                     GET 5 ;
1315
                                                                                     DUP 3 ;
1316
                                                                                     GET 9 ;
1317
                                                                                     COMPARE ;
1318
                                                                                     EQ ;
1319
                                                                                     IF
1320
                                                                                       {}
1321
                                                                                       { PUSH string "TOKEN_ALREADY_BOUND_MC" ;
1322
                                                                                         FAILWITH } ;
1323
                                                                                     CDR ;
1324
                                                                                     UPDATE 9 }
1325
                                                                                   { IF_LEFT
1326
                                                                                       { DUP 2 ;
1327
                                                                                         CAR ;
1328
                                                                                         SENDER ;
1329
                                                                                         COMPARE ;
1330
                                                                                         NEQ ;
1331
                                                                                         IF
1332
                                                                                           { PUSH string "TOKEN_NOT_ADMIN" ;
1333
                                                                                             FAILWITH }
1334
                                                                                           {} ;
1335
                                                                                         DUP 2 ;
1336
                                                                                         GET 3 ;
1337
                                                                                         DUP 2 ;
1338
                                                                                         CAR ;
1339
                                                                                         COMPARE ;
1340
                                                                                         NEQ ;
1341
                                                                                         IF
1342
                                                                                           { PUSH string "TOKEN_NOT_OWNER" ;
1343
                                                                                             FAILWITH }
1344
                                                                                           {} ;
1345
                                                                                         CDR ;
1346
                                                                                         UPDATE 3 }
1347
                                                                                       { IF_LEFT
1348
                                                                                           { DUP 2 ;
1349
                                                                                             CAR ;
1350
                                                                                             SENDER ;
1351
                                                                                             COMPARE ;
1352
                                                                                             NEQ ;
1353
                                                                                             IF
1354
                                                                                               { PUSH string "TOKEN_NOT_ADMIN" ;
1355
                                                                                                 FAILWITH }
1356
                                                                                               {} ;
1357
                                                                                             UPDATE 1 }
1358
                                                                                           { IF_LEFT
1359
                                                                                               { DUP 2 ;
1360
                                                                                                 CAR ;
1361
                                                                                                 SENDER ;
1362
                                                                                                 COMPARE ;
1363
                                                                                                 NEQ ;
1364
                                                                                                 IF
1365
                                                                                                   { PUSH string "TOKEN_NOT_ADMIN" ;
1366
                                                                                                     FAILWITH }
1367
                                                                                                   {} ;
1368
                                                                                                 DUP 2 ;
1369
                                                                                                 GET 3 ;
1370
                                                                                                 DUP 2 ;
1371
                                                                                                 CAR ;
1372
                                                                                                 COMPARE ;
1373
                                                                                                 NEQ ;
1374
                                                                                                 IF
1375
                                                                                                   { PUSH string "TOKEN_NOT_OWNER" ;
1376
                                                                                                     FAILWITH }
1377
                                                                                                   {} ;
1378
                                                                                                 SWAP ;
1379
                                                                                                 DUP ;
1380
                                                                                                 GET 32 ;
1381
                                                                                                 UNIT ;
1382
                                                                                                 SOME ;
1383
                                                                                                 DIG 3 ;
1384
                                                                                                 CDR ;
1385
                                                                                                 UPDATE ;
1386
                                                                                                 UPDATE 32 }
1387
                                                                                               { DUP 2 ;
1388
                                                                                                 CAR ;
1389
                                                                                                 SENDER ;
1390
                                                                                                 COMPARE ;
1391
                                                                                                 NEQ ;
1392
                                                                                                 IF
1393
                                                                                                   { PUSH string "TOKEN_NOT_ADMIN" ;
1394
                                                                                                     FAILWITH }
1395
                                                                                                   {} ;
1396
                                                                                                 DUP 2 ;
1397
                                                                                                 GET 3 ;
1398
                                                                                                 DUP 2 ;
1399
                                                                                                 CAR ;
1400
                                                                                                 COMPARE ;
1401
                                                                                                 NEQ ;
1402
                                                                                                 IF
1403
                                                                                                   { PUSH string "TOKEN_NOT_OWNER" ;
1404
                                                                                                     FAILWITH }
1405
                                                                                                   {} ;
1406
                                                                                                 DUP 2 ;
1407
                                                                                                 GET 32 ;
1408
                                                                                                 DUP 2 ;
1409
                                                                                                 CDR ;
1410
                                                                                                 MEM ;
1411
                                                                                                 IF
1412
                                                                                                   {}
1413
                                                                                                   { PUSH string "AGENT_NOT_FOUND" ;
1414
                                                                                                     FAILWITH } ;
1415
                                                                                                 SWAP ;
1416
                                                                                                 DUP ;
1417
                                                                                                 GET 32 ;
1418
                                                                                                 NONE unit ;
1419
                                                                                                 DIG 3 ;
1420
                                                                                                 CDR ;
1421
                                                                                                 UPDATE ;
1422
                                                                                                 UPDATE 32 } } } } } } } } } } } ;
1423
                                                     NIL operation } } } } } } } } } } } ;
1424
         PAIR } ;
1425
  view "balanceOf" address nat
1426
        { UNPAIR ; SWAP ; GET 11 ; SWAP ; GET ; IF_NONE { PUSH nat 0 } {} } ;
1427
  view "allowance" (pair address address) nat
1428
        { UNPAIR ; UNPAIR ; DIG 2 ; GET 13 ; DUG 2 ; PAIR ; GET ; IF_NONE { PUSH nat 0 } {} } ;
1429
  view "getFrozenTokens" address nat
1430
        { UNPAIR ; SWAP ; GET 17 ; SWAP ; GET ; IF_NONE { PUSH nat 0 } {} } ;
1431
  view "isFrozen" address bool
1432
        { UNPAIR ; SWAP ; GET 19 ; SWAP ; GET ; IF_NONE { PUSH bool False } {} } ;
1433
  view "totalSupply" unit nat { GET 17 } ;
1434
  view "name" unit string { GET 25 } ;
1435
  view "symbol" unit string { GET 27 } ;
1436
  view "decimals" unit nat { GET 29 } ;
1437
  view "paused" unit bool { GET 23 } ;
1438
  view "onchainID" unit address { GET 33 } ;
1439
  view "version" unit string { GET 31 } ;
1440
  view "isAgent" address bool { UNPAIR ; SWAP ; GET 32 ; SWAP ; MEM } ;
1441
  view "owner" unit address { GET 5 } }