parameter (or

            (or

              (or

                (or %admin (or (unit %confirm_admin) (bool %pause)) (address %set_admin))

                (or %assets

                  (or %fa2

                    (or

                      (pair %balance_of

                        (list %requests (pair (address %owner) (nat %token_id)))

                        (contract %callback (list (pair

                                                  (pair %request (address %owner)

                                                                 (nat %token_id))

                                                  (nat %balance)))))

                      (list %transfer (pair (address %from_)

                                           (list %txs (pair (address %to_)

                                                           (pair (nat %token_id)

                                                                 (nat %amount)))))))

                    (list %update_operators (or

                                             (pair %add_operator (address %owner)

                                                                 (pair

                                                                   (address %operator)

                                                                   (nat %token_id)))

                                             (pair %remove_operator (address %owner)

                                                                    (pair

                                                                      (address %operator)

                                                                      (nat %token_id))))))

                  (pair %token_metadata (list %token_ids nat)

                                        (lambda %handler

                                          (list (pair (nat %token_id)

                                                     (map %token_info string bytes)))

                                          unit))))

              (or (pair %burn (nat %from_) (nat %to_))

                  (or %minting (unit %mint) (unit %reserve))))

            (or (pair %update (nat %token_id) (string %token_url)) (unit %withdraw)));

storage (pair

          (pair

            (pair

              (pair

                (pair %admin (pair (address %admin) (bool %paused))

                             (option %pending_admin address))

                (big_map %ledger nat address))

              (pair (nat %max_hollows) (big_map %metadata string bytes)))

            (pair

              (pair (nat %next_token_id)

                    (big_map %operators (pair address (pair address nat)) unit))

              (pair (string %provenance_url)

                    (set %token_defs (pair (nat %from_) (nat %to_))))))

          (big_map %token_metadata nat

                                   (pair (nat %token_id) (map %token_info string bytes))));

code { PUSH string "FA2_TOKEN_UNDEFINED" ;

       PUSH string "FA2_INSUFFICIENT_BALANCE" ;

       LAMBDA

         (pair (pair (pair nat nat) (pair (pair nat (map string bytes)) (list address)))

               (pair

                 (pair (big_map nat address)

                       (pair (pair (big_map nat (pair nat (map string bytes))) nat)

                             (set (pair nat nat))))

                 (big_map (pair address (pair address nat)) unit)))

         (pair

           (pair (big_map nat address)

                 (pair (pair (big_map nat (pair nat (map string bytes))) nat)

                       (set (pair nat nat))))

           (big_map (pair address (pair address nat)) unit))

         { UNPAIR ;

           DUP ;

           CAR ;

           CAR ;

           SWAP ;

           DUP ;

           DUG 2 ;

           CAR ;

           CDR ;

           SUB ;

           ISNAT ;

           IF_NONE

             { PUSH string "EMPTY_TOKEN_DEF_RANGE" ; FAILWITH }

             { SWAP ;

               DUP ;

               DUG 2 ;

               GET 4 ;

               SIZE ;

               SWAP ;

               COMPARE ;

               NEQ ;

               IF { PUSH string "INVALID_OWNERS_LENGTH" ; FAILWITH } {} } ;

           DUP ;

           CAR ;

           CAR ;

           DUP 3 ;

           CAR ;

           CDR ;

           CAR ;

           CDR ;

           COMPARE ;

           GT ;

           IF

             { DROP 2 ; PUSH string "USED_TOKEN_IDS" ; FAILWITH }

             { DUP ;

               CAR ;

               CAR ;

               SWAP ;

               DUP ;

               DUG 2 ;

               GET 4 ;

               NIL (pair address nat) ;

               DIG 2 ;

               PAIR ;

               SWAP ;

               ITER { SWAP ; DUP ; CDR ; SWAP ; DUP ; DUG 2 ; CAR ; DIG 3 ; PAIR ; CONS ; PUSH nat 1 ; DIG 2 ; CAR ; ADD ; PAIR } ;

               CDR ;

               DUP 3 ;

               CAR ;

               CAR ;

               SWAP ;

               ITER { UNPAIR ; DIG 2 ; SWAP ; DIG 2 ; SWAP ; SOME ; SWAP ; UPDATE } ;

               DUP 3 ;

               CDR ;

               DUP 4 ;

               CAR ;

               CDR ;

               CDR ;

               DUP 4 ;

               CAR ;

               PUSH bool True ;

               SWAP ;

               UPDATE ;

               DUP 4 ;

               CAR ;

               CDR ;

               DUP 6 ;

               CAR ;

               CDR ;

               CAR ;

               CAR ;

               DUP 6 ;

               GET 3 ;

               DIG 6 ;

               CAR ;

               CAR ;

               SWAP ;

               SOME ;

               SWAP ;

               UPDATE ;

               PAIR ;

               PAIR ;

               DIG 3 ;

               CAR ;

               CAR ;

               PAIR ;

               CDR ;

               DIG 2 ;

               PAIR ;

               PAIR } } ;

       LAMBDA

         (pair (pair address bool) (option address))

         unit

         { CAR ;

           CAR ;

           SENDER ;

           COMPARE ;

           NEQ ;

           IF { PUSH string "NOT_AN_ADMIN" ; FAILWITH } { UNIT } } ;

       LAMBDA

         (pair (pair address bool) (option address))

         unit

         { CAR ; CDR ; IF { PUSH string "PAUSED" ; FAILWITH } { UNIT } } ;

       EMPTY_MAP int string ;

       PUSH string "10" ;

       SOME ;

       PUSH int 10 ;

       UPDATE ;

       PUSH string "9" ;

       SOME ;

       PUSH int 9 ;

       UPDATE ;

       PUSH string "8" ;

       SOME ;

       PUSH int 8 ;

       UPDATE ;

       PUSH string "7" ;

       SOME ;

       PUSH int 7 ;

       UPDATE ;

       PUSH string "6" ;

       SOME ;

       PUSH int 6 ;

       UPDATE ;

       PUSH string "5" ;

       SOME ;

       PUSH int 5 ;

       UPDATE ;

       PUSH string "4" ;

       SOME ;

       PUSH int 4 ;

       UPDATE ;

       PUSH string "3" ;

       SOME ;

       PUSH int 3 ;

       UPDATE ;

       PUSH string "2" ;

       SOME ;

       PUSH int 2 ;

       UPDATE ;

       PUSH string "1" ;

       SOME ;

       PUSH int 1 ;

       UPDATE ;

       PUSH string "0" ;

       SOME ;

       PUSH int 0 ;

       UPDATE ;

       LAMBDA

         (pair int (map int string))

         string

         { UNPAIR ; GET ; IF_NONE { PUSH string "" } {} } ;

       PAIR ;

       LAMBDA

         (pair (pair (lambda (pair int (map int string)) string) (map int string))

               (pair int string))

         string

         { UNPAIR ;

           UNPAIR ;

           DIG 2 ;

           LEFT string ;

           LOOP_LEFT { UNPAIR ;

                       PUSH int 10 ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       COMPARE ;

                       LE ;

                       IF

                         { SWAP ;

                           DUP 4 ;

                           DIG 2 ;

                           PAIR ;

                           DUP 3 ;

                           SWAP ;

                           EXEC ;

                           CONCAT ;

                           RIGHT (pair int string) }

                         { SWAP ;

                           DUP 4 ;

                           PUSH int 10 ;

                           DUP 4 ;

                           EDIV ;

                           IF_NONE { PUSH string "MOD by 0" ; FAILWITH } {} ;

                           CDR ;

                           INT ;

                           PAIR ;

                           DUP 4 ;

                           SWAP ;

                           EXEC ;

                           CONCAT ;

                           PUSH int 10 ;

                           DIG 2 ;

                           EDIV ;

                           IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;

                           CAR ;

                           PAIR ;

                           LEFT string } } ;

           SWAP ;

           DIG 2 ;

           DROP 2 } ;

       SWAP ;

       APPLY ;

       DUP 4 ;

       SWAP ;

       DUP ;

       DUG 2 ;

       PAIR ;

       LAMBDA

         (pair

           (pair (lambda (pair int string) string)

                 (lambda

                   (pair

                     (pair (pair nat nat)

                           (pair (pair nat (map string bytes)) (list address)))

                     (pair

                       (pair (big_map nat address)

                             (pair

                               (pair (big_map nat (pair nat (map string bytes))) nat)

                               (set (pair nat nat))))

                       (big_map (pair address (pair address nat)) unit)))

                   (pair

                     (pair (big_map nat address)

                           (pair (pair (big_map nat (pair nat (map string bytes))) nat)

                                 (set (pair nat nat))))

                     (big_map (pair address (pair address nat)) unit))))

           (pair nat

                 (pair

                   (pair (big_map nat address)

                         (pair (pair (big_map nat (pair nat (map string bytes))) nat)

                               (set (pair nat nat))))

                   (big_map (pair address (pair address nat)) unit))))

         (pair

           (pair (big_map nat address)

                 (pair (pair (big_map nat (pair nat (map string bytes))) nat)

                       (set (pair nat nat))))

           (big_map (pair address (pair address nat)) unit))

         { UNPAIR ;

           UNPAIR ;

           DIG 2 ;

           UNPAIR ;

           DUP ;

           PUSH nat 1 ;

           DUP 3 ;

           ADD ;

           SWAP ;

           PAIR ;

           PUSH string "" ;

           DUP 3 ;

           INT ;

           PAIR ;

           DIG 4 ;

           SWAP ;

           EXEC ;

           PUSH string ".json" ;

           SWAP ;

           CONCAT ;

           PUSH string "https://arweave.net/cMeBC8zKMTXtEdNGOpke5_y6XRhtcYrOb2LMljgdifo/" ;

           CONCAT ;

           PACK ;

           PUSH nat 6 ;

           SWAP ;

           DUP ;

           DUG 2 ;

           SIZE ;

           SUB ;

           ABS ;

           DIG 2 ;

           DIG 3 ;

           EMPTY_MAP string bytes ;

           DIG 4 ;

           DIG 4 ;

           PUSH nat 6 ;

           SLICE ;

           IF_NONE { PUSH string "SLICE" ; FAILWITH } {} ;

           SOME ;

           PUSH string "" ;

           UPDATE ;

           SWAP ;

           PAIR ;

           NIL address ;

           SOURCE ;

           CONS ;

           SWAP ;

           PAIR ;

           SWAP ;

           PAIR ;

           SWAP ;

           DUP ;

           DUG 2 ;

           SWAP ;

           PAIR ;

           DIG 2 ;

           SWAP ;

           EXEC ;

           DUP ;

           CDR ;

           DUP 3 ;

           CDR ;

           DUP 3 ;

           CAR ;

           CDR ;

           DIG 4 ;

           CAR ;

           CAR ;

           PAIR ;

           CDR ;

           DIG 3 ;

           CAR ;

           CAR ;

           PAIR ;

           PAIR ;

           CAR ;

           PAIR } ;

       SWAP ;

       APPLY ;

       DIG 7 ;

       UNPAIR ;

       IF_LEFT

         { IF_LEFT

             { DIG 2 ;

               DIG 3 ;

               DIG 6 ;

               DROP 3 ;

               IF_LEFT

                 { DIG 2 ;

                   DIG 4 ;

                   DIG 5 ;

                   DROP 3 ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CAR ;

                   SWAP ;

                   IF_LEFT

                     { IF_LEFT

                         { DIG 3 ;

                           DROP 2 ;

                           DUP ;

                           CDR ;

                           IF_NONE

                             { DROP ; PUSH string "NO_PENDING_ADMIN" ; FAILWITH }

                             { SENDER ;

                               COMPARE ;

                               EQ ;

                               IF

                                 { NONE address ; SWAP ; CAR ; CDR ; SENDER ; PAIR ; PAIR }

                                 { DROP ; PUSH string "NOT_A_PENDING_ADMIN" ; FAILWITH } } ;

                           NIL operation ;

                           PAIR }

                         { SWAP ;

                           DUP ;

                           DUG 2 ;

                           DIG 4 ;

                           SWAP ;

                           EXEC ;

                           DROP ;

                           SWAP ;

                           DUP ;

                           DUG 2 ;

                           CDR ;

                           SWAP ;

                           DIG 2 ;

                           CAR ;

                           CAR ;

                           PAIR ;

                           PAIR ;

                           NIL operation ;

                           PAIR } }

                     { SWAP ; DUP ; DUG 2 ; DIG 4 ; SWAP ; EXEC ; DROP ; SOME ; SWAP ; CAR ; PAIR ; NIL operation ; PAIR } ;

                   UNPAIR ;

                   DUP 3 ;

                   CDR ;

                   DUP 4 ;

                   CAR ;

                   CDR ;

                   DUP 5 ;

                   CAR ;

                   CAR ;

                   CDR ;

                   DIG 5 ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CDR ;

                   DIG 5 ;

                   PAIR ;

                   PAIR ;

                   PAIR ;

                   PAIR ;

                   SWAP ;

                   PAIR }

                 { DIG 3 ;

                   DROP ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CAR ;

                   DIG 3 ;

                   SWAP ;

                   EXEC ;

                   DROP ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CDR ;

                   CAR ;

                   CDR ;

                   DUP 3 ;

                   CAR ;

                   CDR ;

                   CDR ;

                   CDR ;

                   DUP 4 ;

                   CAR ;

                   CDR ;

                   CAR ;

                   CAR ;

                   DUP 5 ;

                   CDR ;

                   PAIR ;

                   PAIR ;

                   DUP 4 ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CDR ;

                   PAIR ;

                   PAIR ;

                   SWAP ;

                   IF_LEFT

                     { IF_LEFT

                         { IF_LEFT

                             { DIG 3 ;

                               DROP ;

                               SWAP ;

                               DUP ;

                               DUG 2 ;

                               CAR ;

                               CAR ;

                               SWAP ;

                               DUP ;

                               CAR ;

                               MAP { DUP 3 ;

                                     SWAP ;

                                     DUP ;

                                     DUG 2 ;

                                     CDR ;

                                     GET ;

                                     IF_NONE

                                       { DROP ; DUP 5 ; FAILWITH }

                                       { SWAP ;

                                         DUP ;

                                         CAR ;

                                         DIG 2 ;

                                         COMPARE ;

                                         EQ ;

                                         IF { PUSH nat 1 } { PUSH nat 0 } ;

                                         SWAP ;

                                         PAIR } } ;

                               DIG 2 ;

                               DIG 5 ;

                               DROP 2 ;

                               SWAP ;

                               CDR ;

                               PUSH mutez 0 ;

                               DIG 2 ;

                               TRANSFER_TOKENS ;

                               SWAP ;

                               NIL operation ;

                               DIG 2 ;

                               CONS ;

                               PAIR }

                             { SWAP ;

                               DUP ;

                               DUG 2 ;

                               CAR ;

                               CAR ;

                               DUP 3 ;

                               CDR ;

                               PAIR ;

                               LAMBDA

                                 (pair (pair address address)

                                       (pair nat

                                             (big_map (pair address (pair address nat))

                                                      unit)))

                                 unit

                                 { UNPAIR ;

                                   UNPAIR ;

                                   DIG 2 ;

                                   UNPAIR ;

                                   DUP 4 ;

                                   DUP 4 ;

                                   COMPARE ;

                                   EQ ;

                                   IF

                                     { DROP 4 ; UNIT }

                                     { DIG 3 ;

                                       PAIR ;

                                       DIG 2 ;

                                       PAIR ;

                                       MEM ;

                                       IF

                                         { UNIT }

                                         { PUSH string "FA2_NOT_OPERATOR" ; FAILWITH } } } ;

                               DUG 2 ;

                               UNPAIR ;

                               SWAP ;

                               DIG 2 ;

                               ITER { DUP ;

                                      DUG 2 ;

                                      CDR ;

                                      ITER { SWAP ;

                                             PUSH nat 0 ;

                                             DUP 3 ;

                                             GET 4 ;

                                             COMPARE ;

                                             EQ ;

                                             IF

                                               { SWAP ; DROP }

                                               { PUSH nat 1 ;

                                                 DUP 3 ;

                                                 GET 4 ;

                                                 COMPARE ;

                                                 NEQ ;

                                                 IF

                                                   { DROP 2 ; DUP 6 ; FAILWITH }

                                                   { DUP ;

                                                     DUP 3 ;

                                                     GET 3 ;

                                                     GET ;

                                                     IF_NONE

                                                       { DROP 2 ; DUP 7 ; FAILWITH }

                                                       { DUP 4 ;

                                                         CAR ;

                                                         SWAP ;

                                                         DUP ;

                                                         DUG 2 ;

                                                         COMPARE ;

                                                         NEQ ;

                                                         IF

                                                           { DROP 3 ; DUP 6 ; FAILWITH }

                                                           { DUP 5 ;

                                                             DUP 4 ;

                                                             GET 3 ;

                                                             PAIR ;

                                                             SENDER ;

                                                             DIG 2 ;

                                                             PAIR ;

                                                             PAIR ;

                                                             DUP 6 ;

                                                             SWAP ;

                                                             EXEC ;

                                                             DROP ;

                                                             SWAP ;

                                                             DUP ;

                                                             DUG 2 ;

                                                             CAR ;

                                                             SOME ;

                                                             DIG 2 ;

                                                             GET 3 ;

                                                             UPDATE } } } } } ;

                                      SWAP ;

                                      DROP } ;

                               SWAP ;

                               DIG 2 ;

                               DIG 5 ;

                               DIG 6 ;

                               DROP 4 ;

                               SWAP ;

                               DUP ;

                               DUG 2 ;

                               CDR ;

                               DIG 2 ;

                               CAR ;

                               CDR ;

                               DIG 2 ;

                               PAIR ;

                               PAIR ;

                               NIL operation ;

                               PAIR } }

                         { DIG 3 ;

                           DIG 4 ;

                           DROP 2 ;

                           SWAP ;

                           DUP ;

                           DUG 2 ;

                           CDR ;

                           SWAP ;

                           SENDER ;

                           DUG 2 ;

                           ITER { SWAP ;

                                  DUP 3 ;

                                  DUP 3 ;

                                  IF_LEFT {} {} ;

                                  CAR ;

                                  COMPARE ;

                                  EQ ;

                                  IF {} { PUSH string "FA2_NOT_OWNER" ; FAILWITH } ;

                                  SWAP ;

                                  IF_LEFT

                                    { SWAP ;

                                      UNIT ;

                                      SOME ;

                                      DUP 3 ;

                                      GET 4 ;

                                      DUP 4 ;

                                      GET 3 ;

                                      PAIR ;

                                      DIG 3 ;

                                      CAR ;

                                      PAIR ;

                                      UPDATE }

                                    { DUP ;

                                      DUG 2 ;

                                      GET 4 ;

                                      DUP 3 ;

                                      GET 3 ;

                                      PAIR ;

                                      DIG 2 ;

                                      CAR ;

                                      PAIR ;

                                      NONE unit ;

                                      SWAP ;

                                      UPDATE } } ;

                           SWAP ;

                           DROP ;

                           SWAP ;

                           CAR ;

                           PAIR ;

                           NIL operation ;

                           PAIR } }

                     { DIG 3 ;

                       DIG 4 ;

                       DROP 2 ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CDR ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       MAP { SWAP ;

                             DUP ;

                             DUG 2 ;

                             CAR ;

                             CAR ;

                             SWAP ;

                             DUP ;

                             DUG 2 ;

                             GET ;

                             IF_NONE

                               { DROP ; PUSH string "NO_DATA" ; FAILWITH }

                               { SWAP ; UPDATE 1 } } ;

                       SWAP ;

                       DROP ;

                       SWAP ;

                       CDR ;

                       SWAP ;

                       EXEC ;

                       DROP ;

                       NIL operation ;

                       PAIR } ;

                   UNPAIR ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CDR ;

                   CAR ;

                   CAR ;

                   DUP 4 ;

                   CDR ;

                   DUP 5 ;

                   CAR ;

                   CDR ;

                   DUP 6 ;

                   CAR ;

                   CAR ;

                   CDR ;

                   DUP 6 ;

                   CAR ;

                   CAR ;

                   DIG 7 ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CAR ;

                   PAIR ;

                   PAIR ;

                   PAIR ;

                   PAIR ;

                   DUP ;

                   CDR ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CDR ;

                   CDR ;

                   DUP 6 ;

                   CDR ;

                   DUP 4 ;

                   CAR ;

                   CDR ;

                   CAR ;

                   CAR ;

                   PAIR ;

                   PAIR ;

                   DIG 2 ;

                   CAR ;

                   CAR ;

                   PAIR ;

                   PAIR ;

                   DUP ;

                   CDR ;

                   DUP 5 ;

                   CAR ;

                   CDR ;

                   CDR ;

                   DUP 3 ;

                   CAR ;

                   CDR ;

                   CDR ;

                   CAR ;

                   PAIR ;

                   DUP 3 ;

                   CAR ;

                   CDR ;

                   CAR ;

                   PAIR ;

                   DIG 2 ;

                   CAR ;

                   CAR ;

                   PAIR ;

                   PAIR ;

                   DUP ;