parameter (or

            (or

              (or

                (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)))))

                  (address %declare_ownership))

                (or (unit %claim_ownership) (address %set_permits)))

              (or (or (address %add_coowner) (address %remove_coowner))

                  (or (address %set_minter) (unit %set_mint_completed))))

            (or

              (or (or (unit %pause) (unit %unpause))

                  (or (pair %set_metadata (string %k) (option %d bytes))

                      (pair %set_token_metadata (nat %tid) (map %tdata string bytes))))

              (or

                (or

                  (or

                    (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)))))

                    (string %set_token_metadata_path))

                  (or (nat %drop)

                      (list %do_transfer (pair (address %from_)

                                              (list %txs (pair (address %to_)

                                                              (pair (nat %token_id)

                                                                    (nat %amount))))))))

                (or

                  (or

                    (list %transfer (pair (address %from_)

                                         (list %txs (pair (address %to_)

                                                         (pair (nat %token_id)

                                                               (nat %amount))))))

                    (list %transfer_gasless (pair

                                             (list %transfer_params (pair

                                                                     (address %from_)

                                                                     (list %txs (pair

                                                                                 (address %to_)

                                                                                 (pair

                                                                                   (nat %token_id)

                                                                                   (nat %amount))))))

                                             (pair (key %user_pk) (signature %user_sig)))))

                  (or (nat %burn)

                      (pair %burn_gasless (list %bg_token_id nat)

                                          (pair (key %bg_user_pk)

                                                (signature %bg_user_sig))))))));

storage (pair (address %owner)

              (pair (address %minter)

                    (pair (address %permits)

                          (pair (string %token_metadata_path)

                                (pair (nat %next_token_id)

                                      (pair (bool %mint_completed)

                                            (pair (set %coowners address)

                                                  (pair

                                                    (option %owner_candidate address)

                                                    (pair (bool %paused)

                                                          (pair

                                                            (big_map %token_metadata nat

                                                                                     (pair

                                                                                       (nat %token_id)

                                                                                       (map %token_info

                                                                                         string

                                                                                         bytes)))

                                                            (pair

                                                              (big_map %ledger nat

                                                                               address)

                                                              (pair

                                                                (set %operator (pair

                                                                                address

                                                                                (pair

                                                                                  nat

                                                                                  address)))

                                                                (pair

                                                                  (big_map %operator_for_all

                                                                    (pair address

                                                                          address)

                                                                    unit)

                                                                  (big_map %metadata

                                                                    string

                                                                    bytes))))))))))))));

code { LAMBDA

         nat

         string

         { PUSH unit Unit ;

           PUSH nat 0 ;

           DUP 3 ;

           COMPARE ;

           GT ;

           IF

             { PUSH string "" ;

               EMPTY_MAP nat string ;

               PUSH string "9" ;

               SOME ;

               PUSH nat 9 ;

               UPDATE ;

               PUSH string "8" ;

               SOME ;

               PUSH nat 8 ;

               UPDATE ;

               PUSH string "7" ;

               SOME ;

               PUSH nat 7 ;

               UPDATE ;

               PUSH string "6" ;

               SOME ;

               PUSH nat 6 ;

               UPDATE ;

               PUSH string "5" ;

               SOME ;

               PUSH nat 5 ;

               UPDATE ;

               PUSH string "4" ;

               SOME ;

               PUSH nat 4 ;

               UPDATE ;

               PUSH string "3" ;

               SOME ;

               PUSH nat 3 ;

               UPDATE ;

               PUSH string "2" ;

               SOME ;

               PUSH nat 2 ;

               UPDATE ;

               PUSH string "1" ;

               SOME ;

               PUSH nat 1 ;

               UPDATE ;

               PUSH string "0" ;

               SOME ;

               PUSH nat 0 ;

               UPDATE ;

               PUSH nat 0 ;

               DUP 5 ;

               COMPARE ;

               GT ;

               LOOP { PUSH nat 10 ;

                      DUP 5 ;

                      EDIV ;

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

                      DUP 3 ;

                      DUP 3 ;

                      DUP 3 ;

                      CDR ;

                      GET ;

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

                      CONCAT ;

                      DIP { DIG 2 ; DROP } ;

                      DUG 2 ;

                      DUP ;

                      CAR ;

                      DIP { DIG 4 ; DROP } ;

                      DUG 4 ;

                      DROP ;

                      PUSH nat 0 ;

                      DUP 5 ;

                      COMPARE ;

                      GT } ;

               DUP 2 ;

               DIP { DIG 2 ; DROP } ;

               DUG 2 ;

               DROP 2 }

             { PUSH string "0" ; SWAP ; DROP } ;

           DUG 1 ;

           DROP } ;

       LAMBDA

         (pair string string)

         bytes

         { UNPAIR 2 ;

           PUSH unit Unit ;

           DUP 3 ;

           PACK ;

           PUSH int 6 ;

           DUP 2 ;

           SIZE ;

           INT ;

           SUB ;

           ABS ;

           DUP 2 ;

           DUP 2 ;

           PUSH nat 6 ;

           SLICE ;

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

           DUP ;

           DIP { DIG 3 ; DROP } ;

           DUG 3 ;

           DROP 3 ;

           DUG 2 ;

           DROP 2 } ;

       LAMBDA

         (pair (big_map (pair address address) unit)

               (pair (set (pair address (pair nat address)))

                     (list (pair (address %from_)

                                (list %txs (pair (address %to_)

                                                (pair (nat %token_id) (nat %amount))))))))

         bool

         { UNPAIR 3 ;

           PUSH unit Unit ;

           PUSH bool True ;

           DUP 5 ;

           ITER { DUP ;

                  CAR ;

                  DUP 2 ;

                  CDR ;

                  DUP ;

                  ITER { DUP 5 ;

                         IF

                           { DUP 3 ;

                             SENDER ;

                             COMPARE ;

                             NEQ ;

                             IF

                               { DUP 8 ;

                                 DUP 4 ;

                                 DUP 3 ;

                                 CDR ;

                                 CAR ;

                                 PAIR ;

                                 SENDER ;

                                 PAIR ;

                                 MEM ;

                                 IF

                                   { PUSH bool True }

                                   { DUP 7 ;

                                     DUP 4 ;

                                     SENDER ;

                                     PAIR ;

                                     MEM ;

                                     IF { PUSH bool True } { PUSH bool False } } }

                               { PUSH bool True } ;

                             IF { PUSH bool True } { PUSH bool False } }

                           { PUSH bool False } ;

                         DIP { DIG 4 ; DROP } ;

                         DUG 4 ;

                         DROP } ;

                  DROP 3 } ;

           DUP ;

           DIP { DIG 1 ; DROP } ;

           DUG 1 ;

           DROP ;

           DUG 3 ;

           DROP 3 } ;

       LAMBDA

         (pair address

               (list (pair (address %from_)

                          (list %txs (pair (address %to_)

                                          (pair (nat %token_id) (nat %amount)))))))

         bool

         { UNPAIR 2 ;

           PUSH unit Unit ;

           PUSH bool True ;

           DUP 4 ;

           ITER { DUP 2 ;

                  IF

                    { DUP ; CAR ; DUP 5 ; COMPARE ; EQ ; IF { PUSH bool True } { PUSH bool False } }

                    { PUSH bool False } ;

                  DIP { DIG 1 ; DROP } ;

                  DUG 1 ;

                  DROP } ;

           DUP ;

           DIP { DIG 1 ; DROP } ;

           DUG 1 ;

           DROP ;

           DUG 2 ;

           DROP 2 } ;

       NIL operation ;

       DIG 5 ;

       UNPAIR ;

       DIP { UNPAIR 14 } ;

       IF_LEFT

         { IF_LEFT

             { IF_LEFT

                 { IF_LEFT

                     { UNPAIR ;

                       NIL operation ;

                       NIL operation ;

                       DUP 19 ;

                       ITER { CONS } ;

                       DUP 4 ;

                       AMOUNT ;

                       DUP 5 ;

                       MAP { DUP 18 ;

                             DUP 2 ;

                             CDR ;

                             GET ;

                             IF_NONE

                               { PUSH nat 0 }

                               { DUP 2 ;

                                 CAR ;

                                 DUP 2 ;

                                 COMPARE ;

                                 EQ ;

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

                                 SWAP ;

                                 DROP } ;

                             DUP 2 ;

                             PAIR ;

                             SWAP ;

                             DROP } ;

                       TRANSFER_TOKENS ;

                       CONS ;

                       ITER { CONS } ;

                       DIP { DIG 16 ; DROP } ;

                       DUG 16 ;

                       DROP 2 ;

                       PAIR 14 ;

                       DIG 1 ;

                       PAIR }

                     { DUP 2 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF

                         { PUSH bool True }

                         { DUP 8 ; SENDER ; MEM ; IF { PUSH bool True } { PUSH bool False } } ;

                       NOT ;

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

                       DUP ;

                       SOME ;

                       DIP { DIG 8 ; DROP } ;

                       DUG 8 ;

                       DROP ;

                       PAIR 14 ;

                       DIG 1 ;

                       PAIR } }

                 { IF_LEFT

                     { DROP ;

                       DUP 8 ;

                       IF_NONE

                         { PUSH bool False }

                         { SENDER ; DUP 2 ; COMPARE ; EQ ; SWAP ; DROP } ;

                       NOT ;

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

                       SENDER ;

                       SWAP ;

                       DROP ;

                       NONE address ;

                       DIP { DIG 7 ; DROP } ;

                       DUG 7 ;

                       PAIR 14 ;

                       DIG 1 ;

                       PAIR }

                     { DUP 2 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       NOT ;

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

                       DUP ;

                       DIP { DIG 3 ; DROP } ;

                       DUG 3 ;

                       DROP ;

                       PAIR 14 ;

                       DIG 1 ;

                       PAIR } } }

             { IF_LEFT

                 { IF_LEFT

                     { DUP 2 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       NOT ;

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

                       DUP 10 ;

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

                       DUP 8 ;

                       DUP 2 ;

                       MEM ;

                       IF

                         { PUSH string "coowners" ; PUSH string "KEY_EXISTS" ; PAIR ; FAILWITH }

                         { DUP 8 ; PUSH bool True ; DUP 3 ; UPDATE ; DIP { DIG 7 ; DROP } ; DUG 7 } ;

                       DROP ;

                       PAIR 14 ;

                       DIG 1 ;

                       PAIR }

                     { DUP 2 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       NOT ;

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

                       DUP 10 ;

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

                       DUP 8 ;

                       PUSH bool False ;

                       DUP 3 ;

                       UPDATE ;

                       DIP { DIG 7 ; DROP } ;

                       DUG 7 ;

                       DROP ;

                       PAIR 14 ;

                       DIG 1 ;

                       PAIR } }

                 { IF_LEFT

                     { DUP 2 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       NOT ;

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

                       DUP ;

                       DIP { DIG 2 ; DROP } ;

                       DUG 2 ;

                       DROP ;

                       PAIR 14 ;

                       DIG 1 ;

                       PAIR }

                     { DROP ;

                       DUP ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       NOT ;

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

                       PUSH bool True ;

                       DIP { DIG 5 ; DROP } ;

                       DUG 5 ;

                       PAIR 14 ;

                       DIG 1 ;

                       PAIR } } } }

         { IF_LEFT

             { IF_LEFT

                 { IF_LEFT

                     { DROP ;

                       DUP ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       NOT ;

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

                       DUP 9 ;

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

                       PUSH bool True ;

                       DIP { DIG 8 ; DROP } ;

                       DUG 8 ;

                       PAIR 14 ;

                       DIG 1 ;

                       PAIR }

                     { DROP ;

                       DUP ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       NOT ;

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

                       DUP 9 ;

                       NOT ;

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

                       PUSH bool False ;

                       DIP { DIG 8 ; DROP } ;

                       DUG 8 ;

                       PAIR 14 ;

                       DIG 1 ;

                       PAIR } }

                 { IF_LEFT

                     { UNPAIR ;

                       SWAP ;

                       DUP 3 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       NOT ;

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

                       DUP 11 ;

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

                       DUP 16 ;

                       DUP 2 ;

                       DUP 4 ;

                       UPDATE ;

                       DIP { DIG 15 ; DROP } ;

                       DUG 15 ;

                       DROP 2 ;

                       PAIR 14 ;

                       DIG 1 ;

                       PAIR }

                     { UNPAIR ;

                       SWAP ;

                       DUP 3 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF

                         { PUSH bool True }

                         { DUP 4 ;

                           SENDER ;

                           COMPARE ;

                           EQ ;

                           IF { PUSH bool True } { PUSH bool False } } ;

                       NOT ;

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

                       DUP 11 ;

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

                       DUP 12 ;

                       DUP 13 ;

                       DUP 4 ;

                       GET ;

                       IF_NONE

                         { PUSH string "token_metadata" ;

                           PUSH string "ASSET_NOT_FOUND" ;

                           PAIR ;

                           FAILWITH }

                         {} ;

                       UNPAIR ;

                       DROP ;

                       DUP 4 ;

                       SWAP ;

                       DROP ;

                       DUP 3 ;

                       SWAP ;

                       PAIR ;

                       SOME ;

                       DUP 4 ;

                       UPDATE ;

                       DIP { DIG 11 ; DROP } ;

                       DUG 11 ;

                       DROP 2 ;

                       PAIR 14 ;

                       DIG 1 ;

                       PAIR } } }

             { IF_LEFT

                 { IF_LEFT

                     { IF_LEFT

                         { DUP 10 ;

                           IF

                             { PUSH string "fa2_r1" ;

                               PUSH string "INVALID_CONDITION" ;

                               PAIR ;

                               FAILWITH }

                             {} ;

                           DUP ;

                           ITER { DUP ;

                                  IF_LEFT

                                    { SENDER ;

                                      DUP 2 ;

                                      CAR ;

                                      COMPARE ;

                                      EQ ;

                                      NOT ;

                                      IF

                                        { PUSH string "CALLER_NOT_OWNER" ; FAILWITH }

                                        {} ;

                                      DUP 15 ;

                                      PUSH bool True ;

                                      DUP 3 ;

                                      CAR ;

                                      DUP 4 ;

                                      CDR ;

                                      CDR ;

                                      PAIR ;

                                      DUP 4 ;

                                      CDR ;

                                      CAR ;

                                      PAIR ;

                                      UPDATE ;

                                      DIP { DIG 14 ; DROP } ;

                                      DUG 14 ;

                                      DROP }

                                    { SENDER ;

                                      DUP 2 ;

                                      CAR ;

                                      COMPARE ;

                                      EQ ;

                                      NOT ;

                                      IF

                                        { PUSH string "CALLER_NOT_OWNER" ; FAILWITH }

                                        {} ;

                                      DUP 15 ;

                                      PUSH bool False ;

                                      DUP 3 ;

                                      CAR ;

                                      DUP 4 ;

                                      CDR ;

                                      CDR ;

                                      PAIR ;

                                      DUP 4 ;

                                      CDR ;

                                      CAR ;

                                      PAIR ;

                                      UPDATE ;

                                      DIP { DIG 14 ; DROP } ;

                                      DUG 14 ;

                                      DROP } ;

                                  DROP } ;

                           DROP ;

                           PAIR 14 ;

                           DIG 1 ;

                           PAIR }

                         { DUP 2 ;

                           SENDER ;

                           COMPARE ;

                           EQ ;

                           IF

                             { PUSH bool True }

                             { DUP 3 ;

                               SENDER ;

                               COMPARE ;

                               EQ ;

                               IF { PUSH bool True } { PUSH bool False } } ;

                           NOT ;

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

                           DUP 10 ;

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

                           DUP ;

                           DIP { DIG 4 ; DROP } ;

                           DUG 4 ;

                           DROP ;

                           PAIR 14 ;

                           DIG 1 ;

                           PAIR } }

                     { IF_LEFT

                         { DUP 3 ;

                           SENDER ;

                           COMPARE ;

                           EQ ;

                           IF

                             { PUSH bool True }

                             { DUP 2 ;

                               SENDER ;

                               COMPARE ;

                               EQ ;

                               IF { PUSH bool True } { PUSH bool False } } ;

                           NOT ;

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

                           DUP 7 ;

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

                           DUP 10 ;

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

                           PUSH nat 201 ;

                           DUP 2 ;

                           COMPARE ;

                           LT ;

                           NOT ;

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

                           PUSH nat 0 ;

                           DUP 2 ;

                           DUP 2 ;

                           COMPARE ;

                           LT ;

                           LOOP { DUP 13 ;

                                  DUP 8 ;

                                  MEM ;

                                  IF

                                    { PUSH string "ledger" ;

                                      PUSH string "KEY_EXISTS" ;

                                      PAIR ;

                                      FAILWITH }

                                    { DUP 13 ;

                                      DUP 5 ;

                                      SOME ;

                                      DUP 9 ;

                                      UPDATE ;

                                      DIP { DIG 12 ; DROP } ;

                                      DUG 12 } ;

                                  PUSH string ".json" ;

                                  DUP 22 ;

                                  DUP 9 ;

                                  EXEC ;

                                  DUP 8 ;

                                  CONCAT ;

                                  CONCAT ;

                                  EMPTY_MAP string bytes ;

                                  DUP 22 ;

                                  DUP 3 ;

                                  PUSH string "ERROR_SLICE" ;

                                  PAIR ;

                                  EXEC ;

                                  SOME ;

                                  PUSH string "" ;

                                  UPDATE ;

                                  DUP 14 ;

                                  DUP 10 ;

                                  MEM ;

                                  IF

                                    { PUSH string "token_metadata" ;

                                      PUSH string "KEY_EXISTS" ;

                                      PAIR ;

                                      FAILWITH }

                                    { DUP 14 ;

                                      DUP 2 ;

                                      DUP 11 ;

                                      PAIR ;

                                      SOME ;

                                      DUP 11 ;

                                      UPDATE ;

                                      DIP { DIG 13 ; DROP } ;

                                      DUG 13 } ;

                                  PUSH nat 1 ;

                                  DUP 10 ;

                                  ADD ;

                                  DIP { DIG 8 ; DROP } ;

                                  DUG 8 ;

                                  PUSH nat 1 ;

                                  DUP 4 ;

                                  ADD ;

                                  DIP { DIG 2 ; DROP } ;

                                  DUG 2 ;

                                  DROP 2 ;

                                  DUP 2 ;

                                  DUP 2 ;

                                  COMPARE ;

                                  LT } ;

                           DROP 2 ;

                           PAIR 14 ;

                           DIG 1 ;

                           PAIR }

                         { SELF_ADDRESS ;

                           SENDER ;

                           COMPARE ;

                           EQ ;

                           NOT ;

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

                           DUP ;

                           ITER { DUP ;

                                  CAR ;

                                  DUP 2 ;

                                  CDR ;

                                  DUP ;

                                  ITER { DUP ;

                                         CDR ;

                                         CAR ;

                                         DUP 17 ;

                                         DUP 2 ;

                                         GET ;

                                         IF_NONE

                                           { NONE address }

                                           { DUP ; SOME ; SWAP ; DROP } ;

                                         IF_NONE

                                           { PUSH string "FA2_TOKEN_UNDEFINED" ;

                                             FAILWITH }

                                           {} ;

                                         DUP 5 ;

                                         DUP 2 ;

                                         COMPARE ;

                                         EQ ;

                                         IF

                                           { PUSH nat 1 ;

                                             DUP 4 ;

                                             CDR ;

                                             CDR ;

                                             COMPARE ;

                                             EQ ;

                                             IF { PUSH bool True } { PUSH bool False } }

                                           { PUSH bool False } ;

                                         NOT ;

                                         IF

                                           { PUSH string "FA2_INSUFFICIENT_BALANCE" ;

                                             FAILWITH }

                                           {} ;

                                         DUP 18 ;

                                         DUP 4 ;

                                         CAR ;

                                         SOME ;

                                         DUP 4 ;

                                         UPDATE ;

                                         DIP { DIG 17 ; DROP } ;

                                         DUG 17 ;

                                         DROP 3 } ;

                                  DROP 3 } ;

                           DROP ;

                           PAIR 14 ;

                           DIG 1 ;

                           PAIR } } }

                 { IF_LEFT

                     { IF_LEFT

                         { DUP 10 ;

                           IF

                             { PUSH string "fa2_r4" ;

                               PUSH string "INVALID_CONDITION" ;

                               PAIR ;

                               FAILWITH }

                             {} ;

                           DUP 18 ;

                           DUP 2 ;

                           DUP 15 ;

                           PAIR ;

                           DUP 16 ;

                           PAIR ;