parameter (or

            (or

              (or

                (or (address %add_trusted_freezer)

                    (pair %balance_of

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

                      (contract %callback (list (pair

                                                (pair %request (address %owner)

                                                               (nat %token_id))

                                                (nat %balance))))))

                (or (address %change_admin)

                    (pair %freeze (pair (nat %amt) (address %freezer))

                                  (pair (nat %token_id) (address %user)))))

              (or (or (bool %operatorsAllowed) (address %rem_trusted_freezer))

                  (or

                    (list %transfer (pair (address %from_)

                                         (list %txs (pair (address %to_)

                                                         (pair (nat %token_id)

                                                               (nat %amount))))))

                    (pair %unfreeze (pair (option %amt nat) (address %freezer))

                                    (pair (nat %token_id) (address %user))))))

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

              (bytes %update_token_icon)));

storage (pair

          (pair

            (pair (address %admin)

                  (big_map %ledger address

                                   (pair (pair (set %allowances address) (nat %balance))

                                         (pair (map %freezed address nat)

                                               (nat %max_freezed)))))

            (pair (big_map %metadata string bytes) (bool %operators_allowed)))

          (pair

            (pair

              (big_map %token_metadata nat

                                       (pair (nat %token_id)

                                             (map %token_info string bytes)))

              (nat %total_supply))

            (set %trusted_freezers address)));

code { LAMBDA

         (pair address

               (pair

                 (pair

                   (pair address

                         (big_map address

                                  (pair (pair (set address) nat)

                                        (pair (map address nat) nat))))

                   (pair (big_map string bytes) bool))

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

                       (set address))))

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

         { UNPAIR ;

           SWAP ;

           CAR ;

           CAR ;

           CDR ;

           SWAP ;

           GET ;

           IF_NONE

             { PUSH nat 0 ; EMPTY_MAP address nat ; PAIR ; PUSH nat 0 ; EMPTY_SET address ; PAIR ; PAIR }

             {} } ;

       SWAP ;

       UNPAIR ;

       IF_LEFT

         { IF_LEFT

             { IF_LEFT

                 { IF_LEFT

                     { DIG 2 ;

                       DROP ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       SENDER ;

                       COMPARE ;

                       NEQ ;

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

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CDR ;

                       CDR ;

                       SWAP ;

                       PUSH bool True ;

                       SWAP ;

                       UPDATE ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CDR ;

                       CAR ;

                       PAIR ;

                       SWAP ;

                       CAR ;

                       PAIR ;

                       NIL operation ;

                       PAIR }

                     { SWAP ;

                       DUP ;

                       DIG 2 ;

                       NIL (pair (pair address nat) nat) ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       ITER { DUP ;

                              DUG 2 ;

                              CDR ;

                              PUSH nat 0 ;

                              COMPARE ;

                              NEQ ;

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

                              DUP 4 ;

                              DUP 3 ;

                              CAR ;

                              PAIR ;

                              DUP 7 ;

                              SWAP ;

                              EXEC ;

                              DIG 2 ;

                              SWAP ;

                              DUP ;

                              DUG 2 ;

                              CDR ;

                              CDR ;

                              DIG 2 ;

                              CAR ;

                              CDR ;

                              SUB ;

                              ISNAT ;

                              IF_NONE { PUSH string "NAT EXPECTED" ; FAILWITH } {} ;

                              SWAP ;

                              PAIR ;

                              CONS } ;

                       DIG 2 ;

                       DIG 4 ;

                       DROP 2 ;

                       NIL operation ;

                       DIG 2 ;

                       CDR ;

                       PUSH mutez 0 ;

                       DIG 3 ;

                       TRANSFER_TOKENS ;

                       CONS ;

                       PAIR } }

                 { IF_LEFT

                     { DIG 2 ;

                       DROP ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       SENDER ;

                       COMPARE ;

                       NEQ ;

                       IF

                         { DROP ; PUSH string "FA2_NOT_ADMIN" ; FAILWITH }

                         { SWAP ; DUP ; DUG 2 ; CDR ; DUP 3 ; CAR ; CDR ; DIG 3 ; CAR ; CAR ; CDR ; DIG 3 ; PAIR ; PAIR ; PAIR } ;

                       NIL operation ;

                       PAIR }

                     { DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       PAIR ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CDR ;

                       CDR ;

                       DIG 2 ;

                       CAR ;

                       CDR ;

                       DIG 2 ;

                       UNPAIR ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       DUP 5 ;

                       PAIR ;

                       DIG 5 ;

                       SWAP ;

                       EXEC ;

                       DUP ;

                       DUG 2 ;

                       CDR ;

                       CAR ;

                       DUP 5 ;

                       GET ;

                       IF_NONE { PUSH nat 0 } {} ;

                       ADD ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CDR ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       COMPARE ;

                       GT ;

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

                       DUP 3 ;

                       CDR ;

                       CDR ;

                       DUP 5 ;

                       MEM ;

                       NOT ;

                       IF

                         { PUSH string "FA2_UNTRUSTED_FREEZER" ; FAILWITH }

                         { DUP 4 ;

                           SENDER ;

                           COMPARE ;

                           NEQ ;

                           IF

                             { PUSH string "FA2_ONLY_FREEZER_CAN_FREEZE" ; FAILWITH }

                             { SWAP ;

                               DUP ;

                               DUG 2 ;

                               CAR ;

                               CAR ;

                               DUP 5 ;

                               MEM ;

                               NOT ;

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

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CDR ;

                       CDR ;

                       DUP 3 ;

                       CDR ;

                       CAR ;

                       DUP 3 ;

                       DIG 6 ;

                       SWAP ;

                       SOME ;

                       SWAP ;

                       UPDATE ;

                       PAIR ;

                       DIG 2 ;

                       CAR ;

                       PAIR ;

                       DUP 3 ;

                       CDR ;

                       DUP 4 ;

                       CAR ;

                       CDR ;

                       DUP 5 ;

                       CAR ;

                       CAR ;

                       CDR ;

                       DUP 4 ;

                       CDR ;

                       CDR ;

                       DUP 6 ;

                       COMPARE ;

                       GT ;

                       IF

                         { DIG 4 ; DUP 5 ; CDR ; CAR ; PAIR ; DIG 4 ; CAR ; PAIR }

                         { DIG 4 ; DROP ; DIG 3 } ;

                       DIG 5 ;

                       SWAP ;

                       SOME ;

                       SWAP ;

                       UPDATE ;

                       DIG 3 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       PAIR ;

                       PAIR ;

                       PAIR ;

                       NIL operation ;

                       PAIR } } }

             { IF_LEFT

                 { DIG 2 ;

                   DROP ;

                   IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       SENDER ;

                       COMPARE ;

                       NEQ ;

                       IF

                         { DROP ; PUSH string "FA2_NOT_ADMIN" ; FAILWITH }

                         { SWAP ; DUP ; DUG 2 ; CDR ; SWAP ; DUP 3 ; CAR ; CDR ; CAR ; PAIR ; DIG 2 ; CAR ; CAR ; PAIR ; PAIR } ;

                       NIL operation ;

                       PAIR }

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       SENDER ;

                       COMPARE ;

                       NEQ ;

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

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CDR ;

                       CDR ;

                       SWAP ;

                       PUSH bool False ;

                       SWAP ;

                       UPDATE ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CDR ;

                       CAR ;

                       PAIR ;

                       SWAP ;

                       CAR ;

                       PAIR ;

                       NIL operation ;

                       PAIR } }

                 { IF_LEFT

                     { ITER { SWAP ;

                              DUP ;

                              DUP 3 ;

                              CAR ;

                              PAIR ;

                              DUP 4 ;

                              SWAP ;

                              EXEC ;

                              SENDER ;

                              DUP 4 ;

                              CAR ;

                              COMPARE ;

                              EQ ;

                              IF

                                { DROP ; UNIT }

                                { SWAP ;

                                  DUP ;

                                  DUG 2 ;

                                  CAR ;

                                  CDR ;

                                  CDR ;

                                  NOT ;

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

                                  CAR ;

                                  CAR ;

                                  SENDER ;

                                  MEM ;

                                  IF

                                    { UNIT }

                                    { PUSH string "FA2_NOT_OPERATOR" ; FAILWITH } } ;

                              DROP ;

                              SWAP ;

                              DUP ;

                              DUG 2 ;

                              CDR ;

                              ITER { SWAP ;

                                     DUP 3 ;

                                     SWAP ;

                                     DUP ;

                                     DUG 2 ;

                                     SWAP ;

                                     DUP ;

                                     DUG 2 ;

                                     CAR ;

                                     PAIR ;

                                     DUP 6 ;

                                     SWAP ;

                                     EXEC ;

                                     DUP 4 ;

                                     GET 3 ;

                                     PUSH nat 0 ;

                                     COMPARE ;

                                     NEQ ;

                                     IF

                                       { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH }

                                       {} ;

                                     DUP 4 ;

                                     GET 4 ;

                                     SWAP ;

                                     DUP ;

                                     DUG 2 ;

                                     CDR ;

                                     CDR ;

                                     DUP 3 ;

                                     CAR ;

                                     CDR ;

                                     SUB ;

                                     ISNAT ;

                                     IF_NONE

                                       { PUSH string "NAT EXPECTED" ; FAILWITH }

                                       {} ;

                                     COMPARE ;

                                     LT ;

                                     IF

                                       { PUSH string "FA2_INSUFFICIENT_BALANCE" ;

                                         FAILWITH }

                                       {} ;

                                     DUP ;

                                     CDR ;

                                     DUP 5 ;

                                     GET 4 ;

                                     DUP 3 ;

                                     CAR ;

                                     CDR ;

                                     SUB ;

                                     ABS ;

                                     DIG 2 ;

                                     CAR ;

                                     CAR ;

                                     PAIR ;

                                     PAIR ;

                                     DUP 3 ;

                                     CDR ;

                                     DUP 4 ;

                                     CAR ;

                                     CDR ;

                                     DUP 5 ;

                                     CAR ;

                                     CAR ;

                                     CDR ;

                                     DIG 3 ;

                                     DIG 4 ;

                                     CAR ;

                                     SWAP ;

                                     SOME ;

                                     SWAP ;

                                     UPDATE ;

                                     DIG 3 ;

                                     CAR ;

                                     CAR ;

                                     CAR ;

                                     PAIR ;

                                     PAIR ;

                                     PAIR ;

                                     DUP ;

                                     DUP 3 ;

                                     CAR ;

                                     PAIR ;

                                     DUP 5 ;

                                     SWAP ;

                                     EXEC ;

                                     DUP ;

                                     CDR ;

                                     DUP 4 ;

                                     GET 4 ;

                                     DUP 3 ;

                                     CAR ;

                                     CDR ;

                                     ADD ;

                                     DIG 2 ;

                                     CAR ;

                                     CAR ;

                                     PAIR ;

                                     PAIR ;

                                     SWAP ;

                                     DUP ;

                                     DUG 2 ;

                                     CDR ;

                                     DUP 3 ;

                                     CAR ;

                                     CDR ;

                                     DUP 4 ;

                                     CAR ;

                                     CAR ;

                                     CDR ;

                                     DIG 3 ;

                                     DIG 5 ;

                                     CAR ;

                                     SWAP ;

                                     SOME ;

                                     SWAP ;

                                     UPDATE ;

                                     DIG 3 ;

                                     CAR ;

                                     CAR ;

                                     CAR ;

                                     PAIR ;

                                     PAIR ;

                                     PAIR } ;

                              SWAP ;

                              DROP } ;

                       SWAP ;

                       DROP ;

                       NIL operation ;

                       PAIR }

                     { DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       PAIR ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CDR ;

                       CDR ;

                       DIG 2 ;

                       CAR ;

                       CDR ;

                       DIG 2 ;

                       UNPAIR ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       DUP 5 ;

                       PAIR ;

                       DIG 5 ;

                       SWAP ;

                       EXEC ;

                       DUP 3 ;

                       CDR ;

                       CDR ;

                       DUP 5 ;

                       MEM ;

                       NOT ;

                       IF

                         { SENDER ;

                           DUP 6 ;

                           COMPARE ;

                           NEQ ;

                           IF

                             { PUSH string "FA2_ONLY_USER_CAN_UNFREEZE_UNTRUSTED_FREEZER" ;

                               FAILWITH }

                             { UNIT } }

                         { DUP 4 ;

                           SENDER ;

                           COMPARE ;

                           NEQ ;

                           IF

                             { PUSH string "FA2_ONLY_FREEZER_CAN_UNFREEZE" ; FAILWITH }

                             { DUP ;

                               CAR ;

                               CAR ;

                               DUP 5 ;

                               MEM ;

                               NOT ;

                               IF

                                 { PUSH string "FA2_NOT_OPERATOR" ; FAILWITH }

                                 { UNIT } } } ;

                       DROP ;

                       DUP ;

                       CDR ;

                       CAR ;

                       DUP 5 ;

                       GET ;

                       IF_NONE { PUSH nat 0 } {} ;

                       DIG 2 ;

                       IF_NONE

                         { PUSH nat 0 ;

                           SWAP ;

                           DUP ;

                           DUG 2 ;

                           COMPARE ;

                           NEQ ;

                           IF

                             { SWAP ;

                               DUP ;

                               DUG 2 ;

                               CDR ;

                               CDR ;

                               DUP 3 ;

                               CDR ;

                               CAR ;

                               DIG 5 ;

                               NONE nat ;

                               SWAP ;

                               UPDATE ;

                               PAIR ;

                               DIG 2 ;

                               CAR ;

                               PAIR }

                             { DIG 3 ; DROP ; SWAP } }

                         { PUSH nat 0 ;

                           DUP 3 ;

                           COMPARE ;

                           EQ ;

                           IF

                             { DIG 4 ; DROP 2 ; PUSH string "NOTHING_FREEZED" ; FAILWITH }

                             { PUSH int 0 ;

                               SWAP ;

                               DUP ;

                               DUG 2 ;

                               DUP 4 ;

                               SUB ;

                               COMPARE ;

                               GT ;

                               IF

                                 { DUP 3 ;

                                   CDR ;

                                   CDR ;

                                   DUP 4 ;

                                   CDR ;

                                   CAR ;

                                   DIG 2 ;

                                   DUP 4 ;

                                   SUB ;

                                   ISNAT ;

                                   IF_NONE { PUSH nat 0 } {} ;

                                   DIG 6 ;

                                   SWAP ;

                                   SOME ;

                                   SWAP ;

                                   UPDATE ;

                                   PAIR ;

                                   DIG 2 ;

                                   CAR ;

                                   PAIR }

                                 { PUSH int 0 ;

                                   SWAP ;

                                   DUP 3 ;

                                   SUB ;

                                   COMPARE ;

                                   EQ ;

                                   IF

                                     { SWAP ;

                                       DUP ;

                                       DUG 2 ;

                                       CDR ;

                                       CDR ;

                                       DUP 3 ;

                                       CDR ;

                                       CAR ;

                                       DIG 5 ;

                                       NONE nat ;

                                       SWAP ;

                                       UPDATE ;

                                       PAIR ;

                                       DIG 2 ;

                                       CAR ;

                                       PAIR }

                                     { DIG 3 ;

                                       DROP ;

                                       PUSH string "CANT_UNFREEZE_MORE_THAN_FREEZED" ;

                                       FAILWITH } } } } ;

                       DUP ;

                       CDR ;

                       CDR ;

                       DIG 2 ;

                       COMPARE ;

                       EQ ;

                       IF

                         { PUSH nat 0 ;

                           SWAP ;

                           DUP ;

                           DUG 2 ;

                           CDR ;

                           CAR ;

                           ITER { CDR ;

                                  SWAP ;

                                  DUP ;

                                  DUG 2 ;

                                  SWAP ;

                                  DUP ;

                                  DUG 2 ;

                                  COMPARE ;

                                  GT ;

                                  IF { SWAP ; DROP } { DROP } } ;

                           SWAP ;

                           DUP ;

                           DUG 2 ;

                           CDR ;

                           CAR ;

                           PAIR ;

                           SWAP ;

                           CAR ;

                           PAIR }

                         {} ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CDR ;

                       DUP 3 ;

                       CAR ;

                       CDR ;

                       DUP 4 ;

                       CAR ;

                       CAR ;

                       CDR ;

                       DIG 3 ;

                       DIG 5 ;

                       SWAP ;

                       SOME ;

                       SWAP ;

                       UPDATE ;

                       DIG 3 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       PAIR ;

                       PAIR ;

                       PAIR ;

                       NIL operation ;

                       PAIR } } } }

         { IF_LEFT

             { ITER { IF_LEFT

                        { DUP ;

                          GET 4 ;

                          PUSH nat 0 ;

                          COMPARE ;

                          NEQ ;

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

                          DUP ;

                          CAR ;

                          SENDER ;

                          COMPARE ;

                          NEQ ;

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

                          SWAP ;

                          DUP ;

                          DUG 2 ;

                          SWAP ;

                          DUP ;

                          DUG 2 ;

                          CAR ;

                          PAIR ;

                          DUP 4 ;

                          SWAP ;

                          EXEC ;

                          DUP 3 ;

                          CDR ;

                          DUP 4 ;

                          CAR ;

                          CDR ;

                          DUP 5 ;

                          CAR ;

                          CAR ;

                          CDR ;

                          DUP 4 ;

                          CDR ;

                          DUP 5 ;

                          CAR ;

                          CDR ;

                          DIG 5 ;

                          CAR ;

                          CAR ;

                          DUP 7 ;

                          GET 3 ;

                          PUSH bool True ;

                          SWAP ;

                          UPDATE ;

                          PAIR ;

                          PAIR ;

                          DIG 4 ;

                          CAR ;

                          SWAP ;

                          SOME ;

                          SWAP ;

                          UPDATE ;

                          DIG 3 ;

                          CAR ;

                          CAR ;

                          CAR ;

                          PAIR ;

                          PAIR ;

                          PAIR }

                        { DUP ;

                          GET 4 ;

                          PUSH nat 0 ;

                          COMPARE ;

                          NEQ ;

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

                          DUP ;

                          CAR ;

                          SENDER ;

                          COMPARE ;

                          NEQ ;

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

                          SWAP ;

                          DUP ;

                          DUG 2 ;

                          SWAP ;

                          DUP ;

                          DUG 2 ;

                          CAR ;

                          PAIR ;

                          DUP 4 ;

                          SWAP ;

                          EXEC ;

                          DUP 3 ;

                          CDR ;

                          DUP 4 ;

                          CAR ;

                          CDR ;

                          DUP 5 ;

                          CAR ;

                          CAR ;

                          CDR ;

                          DUP 4 ;

                          CDR ;

                          DUP 5 ;

                          CAR ;

                          CDR ;

                          DIG 5 ;

                          CAR ;

                          CAR ;

                          DUP 7 ;

                          GET 3 ;

                          PUSH bool False ;

                          SWAP ;

                          UPDATE ;

                          PAIR ;

                          PAIR ;

                          DIG 4 ;

                          CAR ;

                          SWAP ;

                          SOME ;

                          SWAP ;

                          UPDATE ;

                          DIG 3 ;

                          CAR ;

                          CAR ;

                          CAR ;

                          PAIR ;

                          PAIR ;

                          PAIR } } ;

               SWAP ;

               DROP ;

               NIL operation ;

               PAIR }

             { DIG 2 ;

               DROP ;

               SWAP ;

               DUP ;

               DUG 2 ;

               CAR ;

               CAR ;

               CAR ;

               SENDER ;

               COMPARE ;

               NEQ ;

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

               SWAP ;

               DUP ;

               DUG 2 ;

               CDR ;

               CAR ;

               CAR ;

               PUSH nat 0 ;

               GET ;

               IF_NONE

                 { DROP }

                 { DUP 3 ;