parameter (or

            (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

                    (list %set_token_metadatas (pair (nat %stmp_tid)

                                                    (map %stmp_tdata string bytes)))

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

                  (or (string %set_token_metadata_path) (list %drop nat)))))

            (or

              (or

                (or

                  (list %do_transfer (pair (address %from_)

                                          (list %txs (pair (address %to_)

                                                          (pair (nat %token_id)

                                                                (nat %amount))))))

                  (list %transfer (pair (address %from_)

                                       (list %txs (pair (address %to_)

                                                       (pair (nat %token_id)

                                                             (nat %amount)))))))

                (or

                  (list %transfer_gasless (pair

                                           (list %transfer_params (pair (address %from_)

                                                                       (list %txs (pair

                                                                                   (address %to_)

                                                                                   (pair

                                                                                     (nat %token_id)

                                                                                     (nat %amount))))))

                                           (key %user_pk)

                                           (signature %user_sig)))

                  (nat %burn)))

              (pair %burn_gasless (list %bg_token_id nat) (key %bg_user_pk)

                                  (signature %bg_user_sig))));

storage (pair (address %owner) (address %minter) (address %permits)

              (string %token_metadata_path)

              (bool %mint_completed)

              (big_map %coowners address unit)

              (option %owner_candidate address)

              (bool %paused)

              (big_map %token_metadata nat

                                       (pair (nat %token_id)

                                             (map %token_info string bytes)))

              (big_map %ledger nat address)

              (set %operator (pair address nat address))

              (big_map %operator_for_all (pair address address) unit)

              (big_map %metadata string bytes));

code { LAMBDA

         nat

         string

         { PUSH unit Unit ;

           DUP 2 ;

           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 4 ;

           COMPARE ;

           GT ;

           LOOP { DUP 2 ;

                  DUP 2 ;

                  PUSH nat 10 ;

                  DUP 6 ;

                  EDIV ;

                  IF_NONE

                    { PUSH string "DIV_BY_ZERO" ; FAILWITH }

                    { DUP ; CDR ; SWAP ; DROP 1 } ;

                  GET ;

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

                  CONCAT ;

                  DIP 1 { SWAP ; DROP 1 } ;

                  SWAP ;

                  PUSH nat 10 ;

                  DUP 4 ;

                  EDIV ;

                  IF_NONE

                    { PUSH string "DIV_BY_ZERO" ; FAILWITH }

                    { DUP ; CAR ; SWAP ; DROP 1 } ;

                  DIP 1 { DIG 2 ; DROP 1 } ;

                  DUG 2 ;

                  PUSH nat 0 ;

                  DUP 4 ;

                  COMPARE ;

                  GT } ;

           DUP 5 ;

           PUSH nat 0 ;

           COMPARE ;

           EQ ;

           IF { PUSH string "0" } { DUP 2 } ;

           DIP 1 { DIG 3 ; DROP 1 } ;

           DUG 3 ;

           DROP 3 ;

           SWAP ;

           DROP 1 } ;

       LAMBDA

         string

         bytes

         { PUSH unit Unit ;

           DUP 2 ;

           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 1 { DIG 3 ; DROP 1 } ;

           DUG 3 ;

           DROP 3 ;

           SWAP ;

           DROP 1 } ;

       LAMBDA

         (pair (big_map (pair address address) unit) (set (pair address 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 ;

                  GET 1 ;

                  DUP 2 ;

                  GET 2 ;

                  DUP ;

                  ITER { DUP 5 ;

                         IF

                           { DUP 3 ;

                             SENDER ;

                             COMPARE ;

                             NEQ ;

                             IF

                               { DUP 8 ;

                                 DUP 4 ;

                                 DUP 3 ;

                                 GET 2 ;

                                 GET 1 ;

                                 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 1 { DIG 4 ; DROP 1 } ;

                         DUG 4 ;

                         DROP 1 } ;

                  DROP 3 } ;

           DUP ;

           DIP 1 { SWAP ; DROP 1 } ;

           SWAP ;

           DROP 1 ;

           DUG 3 ;

           DROP 3 } ;

       LAMBDA

         (pair address

               (list (pair (address %from_)

                          (list %txs (pair (address %to_)

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

         bool

         { UNPAIR ;

           PUSH unit Unit ;

           PUSH bool True ;

           DUP 4 ;

           ITER { DUP 2 ;

                  IF

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

                    { PUSH bool False } ;

                  DIP 1 { SWAP ; DROP 1 } ;

                  SWAP ;

                  DROP 1 } ;

           DUP ;

           DIP 1 { SWAP ; DROP 1 } ;

           SWAP ;

           DROP 1 ;

           DUG 2 ;

           DROP 2 } ;

       NIL operation ;

       DIG 5 ;

       UNPAIR ;

       DIP 1 { UNPAIR 13 } ;

       IF_LEFT

         { IF_LEFT

             { IF_LEFT

                 { IF_LEFT

                     { IF_LEFT

                         { UNPAIR ;

                           NIL operation ;

                           NIL operation ;

                           DUP 18 ;

                           ITER { CONS } ;

                           DUP 4 ;

                           AMOUNT ;

                           DUP 5 ;

                           MAP { DUP 17 ;

                                 DUP 2 ;

                                 GET 2 ;

                                 GET ;

                                 IF_NONE

                                   { PUSH nat 0 }

                                   { DUP 2 ;

                                     GET 1 ;

                                     DUP 2 ;

                                     COMPARE ;

                                     EQ ;

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

                                     SWAP ;

                                     DROP 1 } ;

                                 DUP 2 ;

                                 PAIR ;

                                 SWAP ;

                                 DROP 1 } ;

                           TRANSFER_TOKENS ;

                           CONS ;

                           ITER { CONS } ;

                           DIP 1 { DIG 15 ; DROP 1 } ;

                           DUG 15 ;

                           DROP 2 ;

                           PAIR 13 ;

                           SWAP ;

                           PAIR }

                         { DUP 2 ;

                           SENDER ;

                           COMPARE ;

                           EQ ;

                           IF

                             { PUSH bool True }

                             { DUP 7 ;

                               SENDER ;

                               MEM ;

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

                           NOT ;

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

                           DUP ;

                           SOME ;

                           DIP 1 { DIG 7 ; DROP 1 } ;

                           DUG 7 ;

                           DROP 1 ;

                           PAIR 13 ;

                           SWAP ;

                           PAIR } }

                     { IF_LEFT

                         { DROP 1 ;

                           DUP 7 ;

                           IF_NONE

                             { PUSH bool False }

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

                           NOT ;

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

                           SENDER ;

                           SWAP ;

                           DROP 1 ;

                           NONE address ;

                           DIP 1 { DIG 6 ; DROP 1 } ;

                           DUG 6 ;

                           PAIR 13 ;

                           SWAP ;

                           PAIR }

                         { DUP 2 ;

                           SENDER ;

                           COMPARE ;

                           EQ ;

                           NOT ;

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

                           DUP ;

                           DIP 1 { DIG 3 ; DROP 1 } ;

                           DUG 3 ;

                           DROP 1 ;

                           PAIR 13 ;

                           SWAP ;

                           PAIR } } }

                 { IF_LEFT

                     { IF_LEFT

                         { DUP 2 ;

                           SENDER ;

                           COMPARE ;

                           EQ ;

                           NOT ;

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

                           DUP 9 ;

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

                           DUP 7 ;

                           DUP 2 ;

                           MEM ;

                           IF

                             { PUSH string "coowners" ;

                               PUSH string "KEY_EXISTS" ;

                               PAIR ;

                               FAILWITH }

                             { DUP 7 ;

                               PUSH unit Unit ;

                               SOME ;

                               DUP 3 ;

                               UPDATE ;

                               DIP 1 { DIG 6 ; DROP 1 } ;

                               DUG 6 } ;

                           DROP 1 ;

                           PAIR 13 ;

                           SWAP ;

                           PAIR }

                         { DUP 2 ;

                           SENDER ;

                           COMPARE ;

                           EQ ;

                           NOT ;

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

                           DUP 9 ;

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

                           DUP 7 ;

                           NONE unit ;

                           DUP 3 ;

                           UPDATE ;

                           DIP 1 { DIG 6 ; DROP 1 } ;

                           DUG 6 ;

                           DROP 1 ;

                           PAIR 13 ;

                           SWAP ;

                           PAIR } }

                     { IF_LEFT

                         { DUP 2 ;

                           SENDER ;

                           COMPARE ;

                           EQ ;

                           NOT ;

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

                           DUP ;

                           DIP 1 { DIG 2 ; DROP 1 } ;

                           DUG 2 ;

                           DROP 1 ;

                           PAIR 13 ;

                           SWAP ;

                           PAIR }

                         { DROP 1 ;

                           DUP ;

                           SENDER ;

                           COMPARE ;

                           EQ ;

                           NOT ;

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

                           PUSH bool True ;

                           DIP 1 { DIG 4 ; DROP 1 } ;

                           DUG 4 ;

                           PAIR 13 ;

                           SWAP ;

                           PAIR } } } }

             { IF_LEFT

                 { IF_LEFT

                     { IF_LEFT

                         { DROP 1 ;

                           DUP ;

                           SENDER ;

                           COMPARE ;

                           EQ ;

                           NOT ;

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

                           DUP 8 ;

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

                           PUSH bool True ;

                           DIP 1 { DIG 7 ; DROP 1 } ;

                           DUG 7 ;

                           PAIR 13 ;

                           SWAP ;

                           PAIR }

                         { DROP 1 ;

                           DUP ;

                           SENDER ;

                           COMPARE ;

                           EQ ;

                           NOT ;

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

                           DUP 8 ;

                           NOT ;

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

                           PUSH bool False ;

                           DIP 1 { DIG 7 ; DROP 1 } ;

                           DUG 7 ;

                           PAIR 13 ;

                           SWAP ;

                           PAIR } }

                     { IF_LEFT

                         { UNPAIR ;

                           SWAP ;

                           DUP 3 ;

                           SENDER ;

                           COMPARE ;

                           EQ ;

                           NOT ;

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

                           DUP 10 ;

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

                           DUP 15 ;

                           DUP 2 ;

                           DUP 4 ;

                           UPDATE ;

                           DIP 1 { DIG 14 ; DROP 1 } ;

                           DUG 14 ;

                           DROP 2 ;

                           PAIR 13 ;

                           SWAP ;

                           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 10 ;

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

                           DUP 11 ;

                           DUP 12 ;

                           DUP 4 ;

                           GET ;

                           IF_NONE

                             { PUSH string "token_metadata" ;

                               PUSH string "ASSET_NOT_FOUND" ;

                               PAIR ;

                               FAILWITH }

                             {} ;

                           CDR ;

                           DUP 4 ;

                           SWAP ;

                           DROP 1 ;

                           DUP 3 ;

                           SWAP ;

                           PAIR ;

                           SOME ;

                           DUP 4 ;

                           UPDATE ;

                           DIP 1 { DIG 10 ; DROP 1 } ;

                           DUG 10 ;

                           DROP 2 ;

                           PAIR 13 ;

                           SWAP ;

                           PAIR } } }

                 { IF_LEFT

                     { IF_LEFT

                         { 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 9 ;

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

                           DUP ;

                           ITER { DUP 11 ;

                                  DUP 12 ;

                                  DUP 3 ;

                                  GET 1 ;

                                  GET ;

                                  IF_NONE

                                    { PUSH string "token_metadata" ;

                                      PUSH string "ASSET_NOT_FOUND" ;

                                      PAIR ;

                                      FAILWITH }

                                    {} ;

                                  CDR ;

                                  DUP 3 ;

                                  GET 1 ;

                                  SWAP ;

                                  DROP 1 ;

                                  DUP 3 ;

                                  GET 2 ;

                                  SWAP ;

                                  PAIR ;

                                  SOME ;

                                  DUP 3 ;

                                  GET 1 ;

                                  UPDATE ;

                                  DIP 1 { DIG 10 ; DROP 1 } ;

                                  DUG 10 ;

                                  DROP 1 } ;

                           DROP 1 ;

                           PAIR 13 ;

                           SWAP ;

                           PAIR }

                         { DUP 9 ;

                           IF

                             { PUSH string "fa2_r1" ;

                               PUSH string "INVALID_CONDITION" ;

                               PAIR ;

                               FAILWITH }

                             {} ;

                           DUP ;

                           ITER { DUP ;

                                  IF_LEFT

                                    { SENDER ;

                                      DUP 2 ;

                                      GET 1 ;

                                      GET 0 ;

                                      COMPARE ;

                                      EQ ;

                                      NOT ;

                                      IF

                                        { PUSH string "CALLER_NOT_OWNER" ; FAILWITH }

                                        {} ;

                                      DUP 14 ;

                                      PUSH bool True ;

                                      DUP 3 ;

                                      GET 1 ;

                                      GET 0 ;

                                      DUP 4 ;

                                      GET 2 ;

                                      GET 2 ;

                                      PAIR ;

                                      DUP 4 ;

                                      GET 2 ;

                                      GET 1 ;

                                      PAIR ;

                                      UPDATE ;

                                      DIP 1 { DIG 13 ; DROP 1 } ;

                                      DUG 13 ;

                                      DROP 1 }

                                    { SENDER ;

                                      DUP 2 ;

                                      GET 1 ;

                                      GET 0 ;

                                      COMPARE ;

                                      EQ ;

                                      NOT ;

                                      IF

                                        { PUSH string "CALLER_NOT_OWNER" ; FAILWITH }

                                        {} ;

                                      DUP 14 ;

                                      PUSH bool False ;

                                      DUP 3 ;

                                      GET 1 ;

                                      GET 0 ;

                                      DUP 4 ;

                                      GET 2 ;

                                      GET 2 ;

                                      PAIR ;

                                      DUP 4 ;

                                      GET 2 ;

                                      GET 1 ;

                                      PAIR ;

                                      UPDATE ;

                                      DIP 1 { DIG 13 ; DROP 1 } ;

                                      DUG 13 ;

                                      DROP 1 } ;

                                  DROP 1 } ;

                           DROP 1 ;

                           PAIR 13 ;

                           SWAP ;

                           PAIR } }

                     { IF_LEFT

                         { 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 9 ;

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

                           DUP ;

                           DIP 1 { DIG 4 ; DROP 1 } ;

                           DUG 4 ;

                           DROP 1 ;

                           PAIR 13 ;

                           SWAP ;

                           PAIR }

                         { 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 6 ;

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

                           DUP 9 ;

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

                           DUP ;

                           ITER { DUP 12 ;

                                  DUP 2 ;

                                  MEM ;

                                  IF

                                    { PUSH string "ledger" ;

                                      PUSH string "KEY_EXISTS" ;

                                      PAIR ;

                                      FAILWITH }

                                    { DUP 12 ;

                                      DUP 5 ;

                                      SOME ;

                                      DUP 3 ;

                                      UPDATE ;

                                      DIP 1 { DIG 11 ; DROP 1 } ;

                                      DUG 11 } ;

                                  PUSH string ".json" ;

                                  DUP 21 ;

                                  DUP 3 ;

                                  EXEC ;

                                  DUP 8 ;

                                  CONCAT ;

                                  CONCAT ;

                                  EMPTY_MAP string bytes ;

                                  DUP 21 ;

                                  DUP 3 ;

                                  EXEC ;

                                  SOME ;

                                  PUSH string "" ;

                                  UPDATE ;

                                  DUP 13 ;

                                  DUP 4 ;

                                  MEM ;

                                  IF

                                    { PUSH string "token_metadata" ;

                                      PUSH string "KEY_EXISTS" ;

                                      PAIR ;

                                      FAILWITH }

                                    { DUP 13 ;

                                      DUP 2 ;

                                      DUP 5 ;

                                      PAIR ;

                                      SOME ;

                                      DUP 5 ;

                                      UPDATE ;

                                      DIP 1 { DIG 12 ; DROP 1 } ;

                                      DUG 12 } ;

                                  DROP 3 } ;

                           DROP 1 ;

                           PAIR 13 ;

                           SWAP ;

                           PAIR } } } } }

         { IF_LEFT

             { IF_LEFT

                 { IF_LEFT

                     { SELF_ADDRESS ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       NOT ;

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

                       DUP ;

                       ITER { DUP ;

                              GET 1 ;

                              DUP 2 ;

                              GET 2 ;

                              DUP ;

                              ITER { DUP ;

                                     GET 2 ;

                                     GET 1 ;

                                     DUP 16 ;

                                     DUP 2 ;

                                     GET ;

                                     IF_NONE

                                       { NONE address }

                                       { DUP ; SOME ; SWAP ; DROP 1 } ;

                                     IF_NONE

                                       { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH }

                                       {} ;

                                     DUP 5 ;

                                     DUP 2 ;

                                     COMPARE ;

                                     EQ ;

                                     IF

                                       { PUSH nat 1 ;

                                         DUP 4 ;

                                         GET 2 ;