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

              (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_tokens_metadatas (pair (nat %mup_id)

                                                      (list %mup_lines (pair

                                                                        (string %mul_key)

                                                                        (bytes %mul_value)))))

                  (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

                  (list %transfer (pair (address %from_)

                                       (list %txs (pair (address %to_)

                                                       (pair (nat %token_id)

                                                             (nat %amount))))))

                  (string %set_token_metadata_path)))

              (or (or (address %add_minter) (address %remove_minter))

                  (or (list %mint_list address) (nat %burn)))));

storage (pair (address %owner)

              (pair (address %coowner)

                    (pair (string %token_metadata_path)

                          (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 %minters address unit)

                                                      (pair (nat %next_token_id)

                                                            (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 } ;

       NIL operation ;

       DIG 3 ;

       UNPAIR ;

       DIP { UNPAIR 11 } ;

       IF_LEFT

         { IF_LEFT

             { IF_LEFT

                 { IF_LEFT

                     { UNPAIR ;

                       NIL operation ;

                       NIL operation ;

                       DUP 16 ;

                       ITER { CONS } ;

                       DUP 4 ;

                       AMOUNT ;

                       DUP 5 ;

                       MAP { DUP 14 ;

                             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 13 ; DROP } ;

                       DUG 13 ;

                       DROP 2 ;

                       PAIR 11 ;

                       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 ;

                       SOME ;

                       DIP { DIG 4 ; DROP } ;

                       DUG 4 ;

                       DROP ;

                       PAIR 11 ;

                       DIG 1 ;

                       PAIR } }

                 { IF_LEFT

                     { DROP ;

                       DUP 4 ;

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

                       DUG 3 ;

                       PAIR 11 ;

                       DIG 1 ;

                       PAIR }

                     { DUP 2 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       NOT ;

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

                       DUP ;

                       DIP { DIG 2 ; DROP } ;

                       DUG 2 ;

                       DROP ;

                       PAIR 11 ;

                       DIG 1 ;

                       PAIR } } }

             { IF_LEFT

                 { IF_LEFT

                     { DROP ;

                       DUP ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       NOT ;

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

                       DUP 5 ;

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

                       PUSH bool True ;

                       DIP { DIG 4 ; DROP } ;

                       DUG 4 ;

                       PAIR 11 ;

                       DIG 1 ;

                       PAIR }

                     { DROP ;

                       DUP ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       NOT ;

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

                       DUP 5 ;

                       NOT ;

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

                       PUSH bool False ;

                       DIP { DIG 4 ; DROP } ;

                       DUG 4 ;

                       PAIR 11 ;

                       DIG 1 ;

                       PAIR } }

                 { IF_LEFT

                     { UNPAIR ;

                       SWAP ;

                       DUP 3 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       NOT ;

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

                       DUP 7 ;

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

                       DUP 13 ;

                       DUP 2 ;

                       DUP 4 ;

                       UPDATE ;

                       DIP { DIG 12 ; DROP } ;

                       DUG 12 ;

                       DROP 2 ;

                       PAIR 11 ;

                       DIG 1 ;

                       PAIR }

                     { UNPAIR ;

                       SWAP ;

                       DUP 3 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF

                         { PUSH bool True }

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

                       NOT ;

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

                       DUP 7 ;

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

                       DUP 8 ;

                       DUP 9 ;

                       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 7 ; DROP } ;

                       DUG 7 ;

                       DROP 2 ;

                       PAIR 11 ;

                       DIG 1 ;

                       PAIR } } } }

         { IF_LEFT

             { IF_LEFT

                 { IF_LEFT

                     { DUP 2 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF

                         { PUSH bool True }

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

                       NOT ;

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

                       DUP 6 ;

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

                       DUP ;

                       ITER { DUP ;

                              CAR ;

                              DUP 2 ;

                              CDR ;

                              DUP 10 ;

                              DUP 3 ;

                              GET ;

                              DUP ;

                              IF_NONE

                                { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH }

                                {} ;

                              DUP ;

                              CDR ;

                              DUP 4 ;

                              ITER { DUP ;

                                     CAR ;

                                     DUP 2 ;

                                     CDR ;

                                     DIG 3 ;

                                     DUP 2 ;

                                     SOME ;

                                     DUP 4 ;

                                     UPDATE ;

                                     DUG 3 ;

                                     DROP 3 } ;

                              DUP 13 ;

                              DUP 14 ;

                              DUP 7 ;

                              GET ;

                              IF_NONE

                                { PUSH string "token_metadata" ;

                                  PUSH string "ASSET_NOT_FOUND" ;

                                  PAIR ;

                                  FAILWITH }

                                {} ;

                              UNPAIR ;

                              DROP ;

                              DUP 7 ;

                              SWAP ;

                              DROP ;

                              DUP 3 ;

                              SWAP ;

                              PAIR ;

                              SOME ;

                              DUP 7 ;

                              UPDATE ;

                              DIP { DIG 12 ; DROP } ;

                              DUG 12 ;

                              DROP 6 } ;

                       DROP ;

                       PAIR 11 ;

                       DIG 1 ;

                       PAIR }

                     { PUSH bool False ;

                       NOT ;

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

                       DROP ;

                       PAIR 11 ;

                       DIG 1 ;

                       PAIR } }

                 { IF_LEFT

                     { PUSH bool False ;

                       NOT ;

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

                       DROP ;

                       PAIR 11 ;

                       DIG 1 ;

                       PAIR }

                     { DUP 2 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF

                         { PUSH bool True }

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

                       NOT ;

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

                       DUP 6 ;

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

                       DUP ;

                       DIP { DIG 3 ; DROP } ;

                       DUG 3 ;

                       DROP ;

                       PAIR 11 ;

                       DIG 1 ;

                       PAIR } } }

             { IF_LEFT

                 { IF_LEFT

                     { DUP 2 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       NOT ;

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

                       DUP 6 ;

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

                       DUP 10 ;

                       DUP 2 ;

                       MEM ;

                       IF

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

                         { DUP 10 ;

                           PUSH unit Unit ;

                           SOME ;

                           DUP 3 ;

                           UPDATE ;

                           DIP { DIG 9 ; DROP } ;

                           DUG 9 } ;

                       DROP ;

                       PAIR 11 ;

                       DIG 1 ;

                       PAIR }

                     { DUP 2 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       NOT ;

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

                       DUP 6 ;

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

                       DUP 10 ;

                       NONE unit ;

                       DUP 3 ;

                       UPDATE ;

                       DIP { DIG 9 ; DROP } ;

                       DUG 9 ;

                       DROP ;

                       PAIR 11 ;

                       DIG 1 ;

                       PAIR } }

                 { IF_LEFT

                     { DUP 10 ;

                       SENDER ;

                       MEM ;

                       NOT ;

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

                       DUP 6 ;

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

                       PUSH nat 51 ;

                       DUP 2 ;

                       SIZE ;

                       COMPARE ;

                       LT ;

                       NOT ;

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

                       DUP ;

                       ITER { DUP 9 ;

                              DUP 13 ;

                              MEM ;

                              IF

                                { PUSH string "ledger" ;

                                  PUSH string "KEY_EXISTS" ;

                                  PAIR ;

                                  FAILWITH }

                                { DUP 9 ; DUP 2 ; SOME ; DUP 14 ; UPDATE ; DIP { DIG 8 ; DROP } ; DUG 8 } ;

                              PUSH string ".json" ;

                              DUP 17 ;

                              DUP 14 ;

                              EXEC ;

                              DUP 7 ;

                              CONCAT ;

                              CONCAT ;

                              EMPTY_MAP string bytes ;

                              DUP 17 ;

                              DUP 3 ;

                              PUSH string "ERROR_SLICE" ;

                              PAIR ;

                              EXEC ;

                              SOME ;

                              PUSH string "" ;

                              UPDATE ;

                              DUP 10 ;

                              DUP 15 ;

                              MEM ;

                              IF

                                { PUSH string "token_metadata" ;

                                  PUSH string "KEY_EXISTS" ;

                                  PAIR ;

                                  FAILWITH }

                                { DUP 10 ;

                                  DUP 2 ;

                                  DUP 16 ;

                                  PAIR ;

                                  SOME ;

                                  DUP 16 ;

                                  UPDATE ;

                                  DIP { DIG 9 ; DROP } ;

                                  DUG 9 } ;

                              PUSH nat 1 ;

                              DUP 15 ;

                              ADD ;

                              DIP { DIG 13 ; DROP } ;

                              DUG 13 ;

                              DROP 3 } ;

                       DROP ;

                       PAIR 11 ;

                       DIG 1 ;

                       PAIR }

                     { DUP 8 ;

                       DUP 2 ;

                       GET ;

                       IF_NONE { NONE address } { DUP ; SOME ; SWAP ; DROP } ;

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

                       SENDER ;

                       DUP 2 ;

                       COMPARE ;

                       EQ ;

                       NOT ;

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

                       DUP 7 ;

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

                       DUP 9 ;

                       NONE address ;

                       DUP 4 ;

                       UPDATE ;

                       DIP { DIG 8 ; DROP } ;

                       DUG 8 ;

                       DUP 8 ;

                       NONE (pair nat (map string bytes)) ;

                       DUP 4 ;

                       UPDATE ;

                       DIP { DIG 7 ; DROP } ;

                       DUG 7 ;

                       DROP 2 ;

                       PAIR 11 ;

                       DIG 1 ;

                       PAIR } } } } ;

       DIP { DROP 2 } }