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

                (or

                  (list %burn (pair (nat %amount) (pair (address %from_) (nat %token_id))))

                  (pair %mint (address %address)

                              (pair (nat %amount)

                                    (pair (map %metadata string bytes) (nat %token_id))))))

              (or (pair %send_hug (address %address) (map %metadata string bytes))

                  (or (address %set_administrator)

                      (pair %set_metadata (string %k) (bytes %v)))))

            (or

              (or (unit %toggle_pause)

                  (or

                    (list %transfer (pair (address %from_)

                                         (list %txs (pair (address %to_)

                                                         (pair (nat %token_id)

                                                               (nat %amount))))))

                    (address %update_hux_address)))

              (or

                (or (nat %update_max_supply)

                    (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 (nat %update_price_of_a_hug)

                    (pair %update_token_metadata (map %metadata string bytes)

                                                 (nat %token_id))))));

storage (pair

          (pair (pair (address %administrator) (nat %all_tokens))

                (pair (address %hux_token_address)

                      (pair (big_map %ledger (pair address nat) nat) (nat %max_supply))))

          (pair

            (pair (big_map %metadata string bytes)

                  (pair

                    (big_map %operators

                      (pair (address %owner) (pair (address %operator) (nat %token_id)))

                      unit)

                    (bool %paused)))

            (pair (nat %price_of_a_hug)

                  (pair

                    (big_map %token_metadata nat

                                             (pair (nat %token_id)

                                                   (map %token_info string bytes)))

                    (big_map %total_supply nat nat)))));

code { CAST (pair

              (or

                (or

                  (or

                    (pair (list (pair address nat))

                          (contract (list (pair (pair address nat) nat))))

                    (or (list (pair nat (pair address nat)))

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

                  (or (pair address (map string bytes)) (or address (pair string bytes))))

                (or

                  (or unit

                      (or (list (pair address (list (pair address (pair nat nat)))))

                          address))

                  (or

                    (or nat

                        (list (or (pair address (pair address nat))

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

                    (or nat (pair (map string bytes) nat)))))

              (pair

                (pair (pair address nat)

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

                (pair

                  (pair (big_map string bytes)

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

                  (pair nat

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

                              (big_map nat nat)))))) ;

       UNPAIR ;

       IF_LEFT

         { IF_LEFT

             { IF_LEFT

                 { SWAP ;

                   DUP ;

                   DUG 2 ;

                   GET 3 ;

                   GET 4 ;

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

                   DUP ;

                   CAR ;

                   MAP { DUP 3 ;

                         GET 7 ;

                         SWAP ;

                         DUP ;

                         DUG 2 ;

                         CDR ;

                         MEM ;

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

                         DUP 3 ;

                         CAR ;

                         GET 5 ;

                         SWAP ;

                         DUP ;

                         CDR ;

                         SWAP ;

                         DUP ;

                         DUG 3 ;

                         CAR ;

                         PAIR ;

                         MEM ;

                         IF

                           { DUP 3 ;

                             CAR ;

                             GET 5 ;

                             SWAP ;

                             DUP ;

                             CDR ;

                             SWAP ;

                             DUP ;

                             DUG 3 ;

                             CAR ;

                             PAIR ;

                             GET ;

                             IF_NONE { PUSH int 412 ; FAILWITH } {} ;

                             SWAP ;

                             PAIR }

                           { PUSH nat 0 ; SWAP ; PAIR } } ;

                   NIL operation ;

                   DIG 2 ;

                   CDR ;

                   PUSH mutez 0 ;

                   DIG 3 ;

                   TRANSFER_TOKENS ;

                   CONS }

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET 3 ;

                       GET 4 ;

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

                       DUP ;

                       ITER { DUP 3 ;

                              GET 7 ;

                              SWAP ;

                              DUP ;

                              DUG 2 ;

                              GET 4 ;

                              MEM ;

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

                              DUP ;

                              CAR ;

                              DUP 4 ;

                              CAR ;

                              GET 5 ;

                              DIG 2 ;

                              DUP ;

                              GET 4 ;

                              SWAP ;

                              DUP ;

                              DUG 4 ;

                              GET 3 ;

                              PAIR ;

                              GET ;

                              IF_NONE { PUSH int 178 ; FAILWITH } {} ;

                              COMPARE ;

                              GE ;

                              IF

                                {}

                                { PUSH string "FA2_INSUFFICIENT_BALANCE" ; FAILWITH } ;

                              DUP 3 ;

                              UNPAIR ;

                              UNPAIR ;

                              SWAP ;

                              UNPAIR ;

                              SWAP ;

                              UNPAIR ;

                              DUP ;

                              DIG 6 ;

                              DUP ;

                              GET 4 ;

                              SWAP ;

                              DUP ;

                              DUG 8 ;

                              GET 3 ;

                              PAIR ;

                              DUP ;

                              DUG 2 ;

                              GET ;

                              IF_NONE { PUSH int 312 ; FAILWITH } { DROP } ;

                              DUP 7 ;

                              CAR ;

                              DIG 9 ;

                              CAR ;

                              GET 5 ;

                              DIG 8 ;

                              DUP ;

                              GET 4 ;

                              SWAP ;

                              DUP ;

                              DUG 10 ;

                              GET 3 ;

                              PAIR ;

                              GET ;

                              IF_NONE { PUSH int 313 ; FAILWITH } {} ;

                              SUB ;

                              ISNAT ;

                              IF_NONE { PUSH int 312 ; FAILWITH } {} ;

                              SOME ;

                              SWAP ;

                              UPDATE ;

                              PAIR ;

                              SWAP ;

                              PAIR ;

                              SWAP ;

                              PAIR ;

                              PAIR ;

                              DUP ;

                              DUG 3 ;

                              DUP ;

                              GET 8 ;

                              DUP 3 ;

                              CAR ;

                              DIG 5 ;

                              GET 8 ;

                              DUP 5 ;

                              GET 4 ;

                              GET ;

                              IF_NONE { PUSH int 316 ; FAILWITH } {} ;

                              SUB ;

                              ISNAT ;

                              IF_NONE { PUSH int 315 ; FAILWITH } {} ;

                              SOME ;

                              DUP 4 ;

                              GET 4 ;

                              UPDATE ;

                              UPDATE 8 ;

                              DUG 2 ;

                              PUSH nat 0 ;

                              DUP 4 ;

                              GET 8 ;

                              DUP 3 ;

                              GET 4 ;

                              GET ;

                              IF_NONE { PUSH int 318 ; FAILWITH } {} ;

                              COMPARE ;

                              EQ ;

                              IF

                                { DIG 2 ;

                                  DUP ;

                                  GET 8 ;

                                  NONE nat ;

                                  DUP 4 ;

                                  GET 4 ;

                                  UPDATE ;

                                  UPDATE 8 ;

                                  DUP ;

                                  GET 7 ;

                                  NONE (pair nat (map string bytes)) ;

                                  DUP 4 ;

                                  GET 4 ;

                                  UPDATE ;

                                  UPDATE 7 ;

                                  DUG 2 }

                                {} ;

                              PUSH nat 0 ;

                              DUP 4 ;

                              CAR ;

                              GET 5 ;

                              DIG 2 ;

                              DUP ;

                              GET 4 ;

                              SWAP ;

                              DUP ;

                              DUG 4 ;

                              GET 3 ;

                              PAIR ;

                              GET ;

                              IF_NONE { PUSH int 321 ; FAILWITH } {} ;

                              COMPARE ;

                              EQ ;

                              IF

                                { DIG 2 ;

                                  UNPAIR ;

                                  UNPAIR ;

                                  SWAP ;

                                  UNPAIR ;

                                  SWAP ;

                                  UNPAIR ;

                                  NONE nat ;

                                  DIG 6 ;

                                  DUP ;

                                  GET 4 ;

                                  SWAP ;

                                  GET 3 ;

                                  PAIR ;

                                  UPDATE ;

                                  PAIR ;

                                  SWAP ;

                                  PAIR ;

                                  SWAP ;

                                  PAIR ;

                                  PAIR ;

                                  SWAP }

                                { DROP } } ;

                       DROP }

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

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

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       GET 5 ;

                       SWAP ;

                       DUP ;

                       GET 6 ;

                       SWAP ;

                       DUP ;

                       DUG 3 ;

                       CAR ;

                       PAIR ;

                       MEM ;

                       IF

                         { SWAP ;

                           UNPAIR ;

                           UNPAIR ;

                           SWAP ;

                           UNPAIR ;

                           SWAP ;

                           UNPAIR ;

                           DUP ;

                           DIG 6 ;

                           DUP ;

                           GET 6 ;

                           SWAP ;

                           DUP ;

                           DUG 8 ;

                           CAR ;

                           PAIR ;

                           DUP ;

                           DUG 2 ;

                           GET ;

                           IF_NONE { PUSH int 207 ; FAILWITH } {} ;

                           DUP 8 ;

                           GET 3 ;

                           ADD ;

                           SOME ;

                           SWAP ;

                           UPDATE ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           PAIR ;

                           SWAP }

                         { SWAP ;

                           UNPAIR ;

                           UNPAIR ;

                           SWAP ;

                           UNPAIR ;

                           SWAP ;

                           UNPAIR ;

                           DUP 6 ;

                           GET 3 ;

                           SOME ;

                           DIG 6 ;

                           DUP ;

                           GET 6 ;

                           SWAP ;

                           DUP ;

                           DUG 8 ;

                           CAR ;

                           PAIR ;

                           UPDATE ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           PAIR ;

                           SWAP } ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CDR ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET 6 ;

                       COMPARE ;

                       LT ;

                       IF

                         { SWAP ;

                           DUP ;

                           GET 8 ;

                           DUP ;

                           DUP 4 ;

                           GET 6 ;

                           DUP ;

                           DUG 2 ;

                           GET ;

                           IF_NONE { PUSH int 214 ; FAILWITH } {} ;

                           DIG 4 ;

                           GET 3 ;

                           ADD ;

                           SOME ;

                           SWAP ;

                           UPDATE ;

                           UPDATE 8 }

                         { DUP ;

                           GET 6 ;

                           DUP 3 ;

                           CAR ;

                           CAR ;

                           CDR ;

                           COMPARE ;

                           EQ ;

                           IF

                             {}

                             { PUSH string "Token-IDs should be consecutive" ; FAILWITH } ;

                           SWAP ;

                           DUP ;

                           GET 8 ;

                           DUP 3 ;

                           GET 3 ;

                           SOME ;

                           DUP 4 ;

                           GET 6 ;

                           UPDATE ;

                           UPDATE 8 ;

                           DUP ;

                           GET 7 ;

                           DIG 2 ;

                           DUP ;

                           GET 5 ;

                           SWAP ;

                           DUP ;

                           DUG 4 ;

                           GET 6 ;

                           PAIR ;

                           SOME ;

                           DIG 3 ;

                           GET 6 ;

                           UPDATE ;

                           UPDATE 7 ;

                           UNPAIR ;

                           UNPAIR ;

                           UNPAIR ;

                           SWAP ;

                           PUSH nat 1 ;

                           ADD ;

                           SWAP ;

                           PAIR ;

                           PAIR ;

                           PAIR } } ;

                   NIL operation } }

             { IF_LEFT

                 { SWAP ;

                   DUP ;

                   CAR ;

                   GET 6 ;

                   SWAP ;

                   DUP ;

                   DUG 3 ;

                   CAR ;

                   CAR ;

                   CDR ;

                   COMPARE ;

                   LT ;

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

                   NIL operation ;

                   DUP 3 ;

                   CAR ;

                   GET 3 ;

                   CONTRACT %transfer (list (pair (address %from_)

                                                 (list %txs (pair (address %to_)

                                                                 (pair (nat %token_id)

                                                                       (nat %amount)))))) ;

                   IF_NONE { PUSH string "Err: here" ; FAILWITH } {} ;

                   PUSH mutez 0 ;

                   NIL (pair address (list (pair address (pair nat nat)))) ;

                   NIL (pair address (pair nat nat)) ;

                   DUP 7 ;

                   GET 5 ;

                   PUSH nat 0 ;

                   DUP 8 ;

                   CAR ;

                   PAIR 3 ;

                   CONS ;

                   SENDER ;

                   PAIR ;

                   CONS ;

                   TRANSFER_TOKENS ;

                   CONS ;

                   DUP 3 ;

                   UNPAIR ;

                   UNPAIR ;

                   SWAP ;

                   UNPAIR ;

                   SWAP ;

                   UNPAIR ;

                   PUSH (option nat) (Some 1) ;

                   DIG 8 ;

                   CAR ;

                   CAR ;

                   CDR ;

                   DUP 9 ;

                   CAR ;

                   PAIR ;

                   UPDATE ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   DUP ;

                   DUG 3 ;

                   UNPAIR ;

                   UNPAIR ;

                   SWAP ;

                   UNPAIR ;

                   SWAP ;

                   UNPAIR ;

                   PUSH (option nat) (Some 1) ;

                   DIG 8 ;

                   CAR ;

                   CAR ;

                   CDR ;

                   SENDER ;

                   PAIR ;

                   UPDATE ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   DUP ;

                   DUG 3 ;

                   DUP ;

                   GET 8 ;

                   PUSH (option nat) (Some 2) ;

                   DIG 5 ;

                   CAR ;

                   CAR ;

                   CDR ;

                   UPDATE ;

                   UPDATE 8 ;

                   DUP ;

                   DUG 3 ;

                   DUP ;

                   GET 7 ;

                   DIG 3 ;

                   CDR ;

                   DUP 5 ;

                   CAR ;

                   CAR ;

                   CDR ;

                   PAIR ;

                   SOME ;

                   DIG 4 ;

                   CAR ;

                   CAR ;

                   CDR ;

                   UPDATE ;

                   UPDATE 7 ;

                   UNPAIR ;

                   UNPAIR ;

                   UNPAIR ;

                   SWAP ;

                   PUSH nat 1 ;

                   ADD ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   PAIR ;

                   SWAP }

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

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

                       SWAP ;

                       UNPAIR ;

                       UNPAIR ;

                       CDR ;

                       DIG 3 ;

                       PAIR ;

                       PAIR ;

                       PAIR }

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

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

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       UNPAIR ;

                       DUP 5 ;

                       CDR ;

                       SOME ;

                       DIG 5 ;

                       CAR ;

                       UPDATE ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       PAIR } ;

                   NIL operation } } }

         { IF_LEFT

             { IF_LEFT

                 { DROP ;

                   DUP ;

                   CAR ;

                   CAR ;

                   CAR ;

                   SENDER ;

                   COMPARE ;

                   EQ ;

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

                   DUP ;

                   UNPAIR ;

                   SWAP ;

                   UNPAIR ;

                   UNPAIR ;

                   SWAP ;

                   CAR ;

                   DIG 4 ;

                   GET 3 ;

                   GET 4 ;

                   NOT ;

                   SWAP ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   SWAP ;

                   PAIR }

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET 3 ;

                       GET 4 ;

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

                       DUP ;

                       ITER { DUP ;

                              CDR ;

                              ITER { DUP 4 ;

                                     CAR ;

                                     CAR ;

                                     CAR ;

                                     SENDER ;

                                     COMPARE ;

                                     EQ ;

                                     IF

                                       { PUSH bool True }

                                       { SWAP ; DUP ; DUG 2 ; CAR ; SENDER ; COMPARE ; EQ } ;

                                     IF

                                       { PUSH bool True }

                                       { DUP 4 ;

                                         GET 3 ;

                                         GET 3 ;

                                         SWAP ;

                                         DUP ;

                                         DUG 2 ;

                                         GET 3 ;

                                         SENDER ;

                                         DUP 5 ;

                                         CAR ;

                                         PAIR 3 ;

                                         MEM } ;

                                     IF

                                       {}

                                       { PUSH string "FA2_NOT_OPERATOR" ; FAILWITH } ;

                                     DUP 4 ;

                                     GET 7 ;

                                     SWAP ;

                                     DUP ;

                                     DUG 2 ;

                                     GET 3 ;

                                     MEM ;

                                     IF

                                       {}

                                       { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;

                                     DUP ;

                                     GET 4 ;

                                     PUSH nat 0 ;

                                     COMPARE ;

                                     LT ;

                                     IF

                                       { DUP ;

                                         GET 4 ;

                                         DUP 5 ;

                                         CAR ;

                                         GET 5 ;

                                         DUP 3 ;

                                         GET 3 ;

                                         DUP 5 ;

                                         CAR ;

                                         PAIR ;

                                         GET ;

                                         IF_NONE { PUSH int 178 ; FAILWITH } {} ;

                                         COMPARE ;

                                         GE ;

                                         IF

                                           {}

                                           { PUSH string "FA2_INSUFFICIENT_BALANCE" ;

                                             FAILWITH } ;

                                         DUP 4 ;

                                         UNPAIR ;

                                         UNPAIR ;

                                         SWAP ;

                                         UNPAIR ;

                                         SWAP ;

                                         UNPAIR ;

                                         DUP ;

                                         DUP 7 ;

                                         GET 3 ;

                                         DUP 9 ;

                                         CAR ;

                                         PAIR ;

                                         DUP ;

                                         DUG 2 ;

                                         GET ;

                                         IF_NONE { PUSH int 363 ; FAILWITH } { DROP } ;

                                         DUP 7 ;

                                         GET 4 ;

                                         DIG 10 ;

                                         CAR ;

                                         GET 5 ;

                                         DUP 9 ;

                                         GET 3 ;

                                         DUP 11 ;

                                         CAR ;

                                         PAIR ;

                                         GET ;

                                         IF_NONE { PUSH int 364 ; FAILWITH } {} ;

                                         SUB ;

                                         ISNAT ;

                                         IF_NONE { PUSH int 363 ; FAILWITH } {} ;

                                         SOME ;

                                         SWAP ;

                                         UPDATE ;

                                         PAIR ;

                                         SWAP ;

                                         PAIR ;

                                         SWAP ;

                                         PAIR ;

                                         PAIR ;

                                         DUP ;

                                         DUG 4 ;

                                         CAR ;

                                         GET 5 ;

                                         SWAP ;

                                         DUP ;

                                         GET 3 ;

                                         SWAP ;

                                         DUP ;

                                         DUG 3 ;

                                         CAR ;

                                         PAIR ;

                                         MEM ;

                                         IF

                                           { DIG 3 ;

                                             UNPAIR ;

                                             UNPAIR ;

                                             SWAP ;

                                             UNPAIR ;

                                             SWAP ;

                                             UNPAIR ;

                                             DUP ;

                                             DIG 6 ;

                                             DUP ;

                                             GET 3 ;

                                             SWAP ;

                                             DUP ;

                                             DUG 8 ;

                                             CAR ;

                                             PAIR ;

                                             DUP ;

                                             DUG 2 ;

                                             GET ;

                                             IF_NONE { PUSH int 371 ; FAILWITH } {} ;

                                             DIG 7 ;

                                             GET 4 ;

                                             ADD ;

                                             SOME ;

                                             SWAP ;

                                             UPDATE ;

                                             PAIR ;

                                             SWAP ;

                                             PAIR ;

                                             SWAP ;

                                             PAIR ;

                                             PAIR ;

                                             DUG 2 }

                                           { DIG 3 ;

                                             UNPAIR ;

                                             UNPAIR ;