parameter (or (list %update_token_pool_internal (pair (pair address nat) nat))

              (or (unit %update_pools)

                  (or (address %set_lqt_address)

                      (or (unit %default)

                          (or (unit %accept_admin_proposal)

                              (or (address %propose_new_admin)

                                  (or (option %set_cfmm_delegate key_hash)

                                      (or (address %set_reward_recipient)

                                          (or

                                            (pair %token_to_cash_internal

                                              (pair (address %to)

                                                    (pair (nat %tokensSold)

                                                          (pair (nat %minCashBought)

                                                                (timestamp %deadline))))

                                              address)

                                            (or

                                              (pair %token_to_cash (address %to)

                                                                   (pair

                                                                     (nat %tokensSold)

                                                                     (pair

                                                                       (nat %minCashBought)

                                                                       (timestamp %deadline))))

                                              (or

                                                (pair %cash_to_token_internal

                                                  (pair (address %to)

                                                        (pair (nat %minTokensBought)

                                                              (timestamp %deadline)))

                                                  address)

                                                (or

                                                  (pair %cash_to_token (address %to)

                                                                       (pair

                                                                         (nat %minTokensBought)

                                                                         (timestamp %deadline)))

                                                  (or

                                                    (pair %change_token_fee

                                                      (nat %numerator)

                                                      (nat %denominator))

                                                    (or

                                                      (pair %change_cash_fee

                                                        (nat %numerator)

                                                        (nat %denominator))

                                                      (or

                                                        (pair %remove_liquidity_internal

                                                          (pair (address %to)

                                                                (pair (nat %lqtBurned)

                                                                      (pair

                                                                        (nat %minCashWithdrawn)

                                                                        (pair

                                                                          (nat %minTokensWithdrawn)

                                                                          (timestamp %deadline)))))

                                                          address)

                                                        (or

                                                          (pair %remove_liquidity

                                                            (address %to)

                                                            (pair (nat %lqtBurned)

                                                                  (pair

                                                                    (nat %minCashWithdrawn)

                                                                    (pair

                                                                      (nat %minTokensWithdrawn)

                                                                      (timestamp %deadline)))))

                                                          (or

                                                            (pair %add_liquidity_internal

                                                              (pair (address %owner)

                                                                    (pair

                                                                      (nat %minLqtMinted)

                                                                      (pair

                                                                        (nat %maxTokensDeposited)

                                                                        (timestamp %deadline))))

                                                              address)

                                                            (pair %add_liquidity

                                                              (address %owner)

                                                              (pair (nat %minLqtMinted)

                                                                    (pair

                                                                      (nat %maxTokensDeposited)

                                                                      (timestamp %deadline)))))))))))))))))))));

storage (pair (address %tokenAddress)

              (pair (nat %tokenId)

                    (pair (nat %tokenPool)

                          (pair (nat %tokenMultiplier)

                                (pair (nat %cashPool)

                                      (pair (nat %cashMultiplier)

                                            (pair (address %admin)

                                                  (pair (address %proposedAdmin)

                                                        (pair (nat %lqtTotal)

                                                              (pair

                                                                (address %lqtAddress)

                                                                (pair

                                                                  (address %rewardRecipient)

                                                                  (pair

                                                                    (nat %pendingPoolUpdates)

                                                                    (pair

                                                                      (pair %cashFeeRatio

                                                                        (nat %numerator)

                                                                        (nat %denominator))

                                                                      (pair %tokenFeeRatio

                                                                        (nat %numerator)

                                                                        (nat %denominator)))))))))))))));

code { UNPAIR ;

       IF_LEFT

         { DUP 2 ;

           CAR ;

           SENDER ;

           COMPARE ;

           NEQ ;

           PUSH nat 0 ;

           DUP 4 ;

           GET 23 ;

           COMPARE ;

           EQ ;

           OR ;

           IF

             { DROP 2 ; PUSH nat 29 ; FAILWITH }

             { IF_CONS { SWAP ; DROP ; CDR } { PUSH nat 30 ; FAILWITH } ;

               PUSH nat 1 ;

               DUP 3 ;

               GET 23 ;

               SUB ;

               ISNAT ;

               IF_NONE { PUSH nat 38 ; FAILWITH } {} ;

               DUG 2 ;

               UPDATE 5 ;

               SWAP ;

               UPDATE 23 ;

               NIL operation ;

               PAIR } }

         { IF_LEFT

             { DROP ;

               SELF_ADDRESS ;

               SENDER ;

               COMPARE ;

               NEQ ;

               SOURCE ;

               SENDER ;

               COMPARE ;

               NEQ ;

               AND ;

               IF

                 { DROP ; PUSH nat 25 ; FAILWITH }

                 { PUSH mutez 0 ;

                   AMOUNT ;

                   COMPARE ;

                   GT ;

                   IF

                     { DROP ; PUSH nat 10 ; FAILWITH }

                     { SELF %update_token_pool_internal ;

                       DUP 2 ;

                       CAR ;

                       CONTRACT %balance_of (pair (list (pair address nat))

                                                  (contract (list (pair (pair address nat)

                                                                      nat)))) ;

                       IF_NONE { PUSH nat 28 ; FAILWITH } {} ;

                       PUSH mutez 0 ;

                       DIG 2 ;

                       NIL (pair address nat) ;

                       DUP 5 ;

                       GET 3 ;

                       SELF_ADDRESS ;

                       PAIR ;

                       CONS ;

                       PAIR ;

                       TRANSFER_TOKENS ;

                       SWAP ;

                       BALANCE ;

                       PUSH mutez 1 ;

                       SWAP ;

                       EDIV ;

                       IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;

                       CAR ;

                       UPDATE 9 ;

                       PUSH nat 1 ;

                       UPDATE 23 ;

                       NIL operation ;

                       DIG 2 ;

                       CONS ;

                       PAIR } } }

             { IF_LEFT

                 { PUSH address "tz1Ke2h7sDdakHJQh8WX4Z372du1KChsksyU" ;

                   DUP 3 ;

                   GET 19 ;

                   COMPARE ;

                   NEQ ;

                   IF

                     { DROP 2 ; PUSH nat 24 ; FAILWITH }

                     { UPDATE 19 ; NIL operation ; PAIR } }

                 { IF_LEFT

                     { DROP ; NIL operation ; PAIR }

                     { IF_LEFT

                         { DROP ;

                           DUP ;

                           GET 15 ;

                           SENDER ;

                           COMPARE ;

                           NEQ ;

                           IF

                             { DROP ; PUSH nat 27 ; FAILWITH }

                             { DUP ; GET 15 ; UPDATE 13 ; NIL operation ; PAIR } }

                         { IF_LEFT

                             { DUP 2 ;

                               GET 13 ;

                               SENDER ;

                               COMPARE ;

                               NEQ ;

                               IF

                                 { DROP 2 ; PUSH nat 26 ; FAILWITH }

                                 { UPDATE 15 ; NIL operation ; PAIR } }

                             { IF_LEFT

                                 { DUP 2 ;

                                   GET 13 ;

                                   SENDER ;

                                   COMPARE ;

                                   NEQ ;

                                   IF

                                     { DROP 2 ; PUSH nat 26 ; FAILWITH }

                                     { SWAP ; NIL operation ; DIG 2 ; SET_DELEGATE ; CONS ; PAIR } }

                                 { IF_LEFT

                                     { DUP 2 ;

                                       GET 13 ;

                                       SENDER ;

                                       COMPARE ;

                                       NEQ ;

                                       IF

                                         { DROP 2 ; PUSH nat 26 ; FAILWITH }

                                         { UPDATE 21 ; NIL operation ; PAIR } }

                                     { IF_LEFT

                                         { UNPAIR ;

                                           UNPAIR 4 ;

                                           PUSH nat 0 ;

                                           DUP 7 ;

                                           GET 23 ;

                                           COMPARE ;

                                           GT ;

                                           IF

                                             { DROP 6 ; PUSH nat 6 ; FAILWITH }

                                             { DIG 3 ;

                                               NOW ;

                                               COMPARE ;

                                               GE ;

                                               IF

                                                 { DROP 5 ; PUSH nat 3 ; FAILWITH }

                                                 { SELF_ADDRESS ;

                                                   SENDER ;

                                                   COMPARE ;

                                                   NEQ ;

                                                   IF

                                                     { DROP 5 ; PUSH nat 36 ; FAILWITH }

                                                     { DUP 5 ;

                                                       GET 7 ;

                                                       DUP 6 ;

                                                       GET 11 ;

                                                       DUP 2 ;

                                                       DUP 8 ;

                                                       GET 5 ;

                                                       MUL ;

                                                       DUP 2 ;

                                                       DUP 9 ;

                                                       GET 9 ;

                                                       MUL ;

                                                       DIG 3 ;

                                                       DUP 6 ;

                                                       MUL ;

                                                       DUP 3 ;

                                                       ADD ;

                                                       DUP 2 ;

                                                       DIG 3 ;

                                                       MUL ;

                                                       EDIV ;

                                                       IF_NONE

                                                         { PUSH string "DIV by 0" ;

                                                           FAILWITH }

                                                         {} ;

                                                       CAR ;

                                                       SWAP ;

                                                       SUB ;

                                                       ISNAT ;

                                                       IF_NONE

                                                         { DROP ; PUSH nat 2 ; FAILWITH }

                                                         { EDIV ;

                                                           IF_NONE

                                                             { PUSH string "DIV by 0" ;

                                                               FAILWITH }

                                                             {} ;

                                                           CAR } ;

                                                       DUP 6 ;

                                                       GET 25 ;

                                                       CDR ;

                                                       DUP 2 ;

                                                       DUP 8 ;

                                                       GET 25 ;

                                                       CAR ;

                                                       MUL ;

                                                       EDIV ;

                                                       IF_NONE

                                                         { PUSH string "DIV by 0" ;

                                                           FAILWITH }

                                                         {} ;

                                                       CAR ;

                                                       DIG 4 ;

                                                       DUP 2 ;

                                                       COMPARE ;

                                                       LT ;

                                                       IF

                                                         { DROP ; PUSH nat 8 ; FAILWITH }

                                                         {} ;

                                                       PUSH int 2 ;

                                                       DUP 2 ;

                                                       DIG 3 ;

                                                       SUB ;

                                                       EDIV ;

                                                       IF_NONE

                                                         { PUSH string "DIV by 0" ;

                                                           FAILWITH }

                                                         {} ;

                                                       CAR ;

                                                       ISNAT ;

                                                       IF_NONE

                                                         { PUSH nat 1 ; FAILWITH }

                                                         {} ;

                                                       PUSH mutez 1 ;

                                                       DUP 3 ;

                                                       MUL ;

                                                       PUSH mutez 1 ;

                                                       DUP 3 ;

                                                       MUL ;

                                                       DUP 6 ;

                                                       SELF_ADDRESS ;

                                                       DIG 8 ;

                                                       DUP 10 ;

                                                       DUP ;

                                                       CAR ;

                                                       CONTRACT %transfer (list (pair

                                                                                 address

                                                                                 (list (pair

                                                                                        address

                                                                                        (pair

                                                                                          nat

                                                                                          nat))))) ;

                                                       IF_NONE

                                                         { PUSH nat 0 ; FAILWITH }

                                                         {} ;

                                                       PUSH mutez 0 ;

                                                       NIL (pair address

                                                                 (list (pair address

                                                                            (pair nat

                                                                                  nat)))) ;

                                                       NIL (pair address (pair nat nat)) ;

                                                       DIG 7 ;

                                                       DIG 5 ;

                                                       GET 3 ;

                                                       PAIR ;

                                                       DIG 6 ;

                                                       PAIR ;

                                                       CONS ;

                                                       DIG 4 ;

                                                       PAIR ;

                                                       CONS ;

                                                       TRANSFER_TOKENS ;

                                                       DIG 5 ;

                                                       CONTRACT unit ;

                                                       IF_NONE

                                                         { PUSH nat 35 ; FAILWITH }

                                                         {} ;

                                                       DIG 3 ;

                                                       UNIT ;

                                                       TRANSFER_TOKENS ;

                                                       DIG 3 ;

                                                       DIG 4 ;

                                                       ADD ;

                                                       DUP 6 ;

                                                       GET 9 ;

                                                       SUB ;

                                                       ISNAT ;

                                                       IF_NONE

                                                         { PUSH nat 1 ; FAILWITH }

                                                         {} ;

                                                       DUP 6 ;

                                                       DIG 5 ;

                                                       DIG 6 ;

                                                       GET 5 ;

                                                       ADD ;

                                                       UPDATE 5 ;

                                                       SWAP ;

                                                       UPDATE 9 ;

                                                       PUSH mutez 0 ;

                                                       DUP 5 ;

                                                       COMPARE ;

                                                       GT ;

                                                       IF

                                                         { DUP ;

                                                           GET 21 ;

                                                           CONTRACT unit ;

                                                           IF_NONE

                                                             { PUSH nat 35 ; FAILWITH }

                                                             {} ;

                                                           DIG 4 ;

                                                           UNIT ;

                                                           TRANSFER_TOKENS ;

                                                           SWAP ;

                                                           NIL operation ;

                                                           DIG 2 ;

                                                           CONS }

                                                         { DIG 3 ; DROP ; NIL operation } ;

                                                       DIG 2 ;

                                                       CONS ;

                                                       DIG 2 ;

                                                       CONS ;

                                                       PAIR } } } }

                                         { IF_LEFT

                                             { PUSH mutez 0 ;

                                               AMOUNT ;

                                               COMPARE ;

                                               GT ;

                                               IF

                                                 { DROP 2 ; PUSH nat 10 ; FAILWITH }

                                                 { SELF %update_pools ;

                                                   SELF %token_to_cash_internal ;

                                                   SWAP ;

                                                   PUSH mutez 0 ;

                                                   UNIT ;

                                                   TRANSFER_TOKENS ;

                                                   SENDER ;

                                                   DIG 3 ;

                                                   PAIR ;

                                                   DIG 2 ;

                                                   PUSH mutez 0 ;

                                                   DIG 2 ;

                                                   TRANSFER_TOKENS ;

                                                   DIG 2 ;

                                                   NIL operation ;

                                                   DIG 2 ;

                                                   CONS ;

                                                   DIG 2 ;

                                                   CONS ;

                                                   PAIR } }

                                             { IF_LEFT

                                                 { CAR ;

                                                   UNPAIR 3 ;

                                                   AMOUNT ;

                                                   PUSH mutez 1 ;

                                                   SWAP ;

                                                   EDIV ;

                                                   IF_NONE

                                                     { PUSH string "DIV by 0" ; FAILWITH }

                                                     {} ;

                                                   CAR ;

                                                   PUSH nat 0 ;

                                                   DUP 6 ;

                                                   GET 23 ;

                                                   COMPARE ;

                                                   GT ;

                                                   IF

                                                     { DROP 5 ; PUSH nat 6 ; FAILWITH }

                                                     { DIG 3 ;

                                                       NOW ;

                                                       COMPARE ;

                                                       GE ;

                                                       IF

                                                         { DROP 4 ; PUSH nat 3 ; FAILWITH }

                                                         { SELF_ADDRESS ;

                                                           SENDER ;

                                                           COMPARE ;

                                                           NEQ ;

                                                           IF

                                                             { DROP 4 ;

                                                               PUSH nat 36 ;

                                                               FAILWITH }

                                                             { DUP ;

                                                               DUP 5 ;

                                                               GET 9 ;

                                                               SUB ;

                                                               ISNAT ;

                                                               IF_NONE

                                                                 { PUSH nat 2 ; FAILWITH }

                                                                 {} ;

                                                               DUP 5 ;

                                                               GET 7 ;

                                                               DUP 6 ;

                                                               GET 11 ;

                                                               DUP ;

                                                               DIG 3 ;

                                                               MUL ;

                                                               DUP 3 ;

                                                               DUP 8 ;

                                                               GET 5 ;

                                                               MUL ;

                                                               DIG 2 ;

                                                               DIG 4 ;

                                                               MUL ;

                                                               DUP 3 ;

                                                               ADD ;

                                                               DUP 2 ;

                                                               DIG 3 ;

                                                               MUL ;

                                                               EDIV ;

                                                               IF_NONE

                                                                 { PUSH string "DIV by 0" ;

                                                                   FAILWITH }

                                                                 {} ;

                                                               CAR ;

                                                               SWAP ;

                                                               SUB ;

                                                               ISNAT ;

                                                               IF_NONE

                                                                 { DROP ;

                                                                   PUSH nat 2 ;

                                                                   FAILWITH }

                                                                 { EDIV ;

                                                                   IF_NONE

                                                                     { PUSH string "DIV by 0" ;

                                                                       FAILWITH }

                                                                     {} ;

                                                                   CAR } ;

                                                               DUP 4 ;

                                                               GET 26 ;

                                                               CDR ;

                                                               DUP 2 ;

                                                               DUP 6 ;

                                                               GET 26 ;

                                                               CAR ;

                                                               MUL ;

                                                               EDIV ;

                                                               IF_NONE

                                                                 { PUSH string "DIV by 0" ;

                                                                   FAILWITH }

                                                                 {} ;

                                                               CAR ;

                                                               DIG 3 ;

                                                               DUP 2 ;

                                                               COMPARE ;

                                                               LT ;

                                                               IF

                                                                 { DROP ;

                                                                   PUSH nat 18 ;

                                                                   FAILWITH }

                                                                 {} ;

                                                               PUSH int 2 ;

                                                               DUP 2 ;

                                                               DIG 3 ;

                                                               SUB ;

                                                               EDIV ;

                                                               IF_NONE

                                                                 { PUSH string "DIV by 0" ;

                                                                   FAILWITH }

                                                                 {} ;

                                                               CAR ;

                                                               ISNAT ;

                                                               IF_NONE

                                                                 { PUSH nat 19 ;

                                                                   FAILWITH }

                                                                 {} ;

                                                               DUP ;

                                                               DUP 3 ;

                                                               ADD ;

                                                               DUP 5 ;

                                                               GET 5 ;

                                                               SUB ;

                                                               ISNAT ;

                                                               IF_NONE

                                                                 { PUSH nat 19 ;

                                                                   FAILWITH }

                                                                 {} ;

                                                               DIG 4 ;

                                                               SWAP ;

                                                               UPDATE 5 ;

                                                               DIG 2 ;

                                                               DIG 3 ;

                                                               SELF_ADDRESS ;

                                                               DUP 4 ;

                                                               DUP ;

                                                               CAR ;

                                                               CONTRACT %transfer (list (pair

                                                                                         address

                                                                                         (list (pair

                                                                                                address

                                                                                                (pair

                                                                                                  nat

                                                                                                  nat))))) ;

                                                               IF_NONE

                                                                 { PUSH nat 0 ; FAILWITH }

                                                                 {} ;

                                                               PUSH mutez 0 ;

                                                               NIL (pair address

                                                                         (list (pair

                                                                                address

                                                                                (pair

                                                                                  nat

                                                                                  nat)))) ;

                                                               NIL (pair address

                                                                         (pair nat nat)) ;

                                                               DIG 7 ;

                                                               DIG 5 ;

                                                               GET 3 ;

                                                               PAIR ;

                                                               DIG 6 ;

                                                               PAIR ;

                                                               CONS ;

                                                               DIG 4 ;

                                                               PAIR ;

                                                               CONS ;

                                                               TRANSFER_TOKENS ;

                                                               DIG 2 ;

                                                               DUP 3 ;

                                                               GET 21 ;

                                                               SELF_ADDRESS ;

                                                               DUP 5 ;

                                                               DUP ;

                                                               CAR ;

                                                               CONTRACT %transfer (list (pair

                                                                                         address

                                                                                         (list (pair

                                                                                                address

                                                                                                (pair

                                                                                                  nat

                                                                                                  nat))))) ;

                                                               IF_NONE

                                                                 { PUSH nat 0 ; FAILWITH }

                                                                 {} ;

                                                               PUSH mutez 0 ;

                                                               NIL (pair address

                                                                         (list (pair

                                                                                address

                                                                                (pair

                                                                                  nat

                                                                                  nat)))) ;

                                                               NIL (pair address

                                                                         (pair nat nat)) ;

                                                               DIG 7 ;

                                                               DIG 5 ;

                                                               GET 3 ;

                                                               PAIR ;

                                                               DIG 6 ;

                                                               PAIR ;

                                                               CONS ;

                                                               DIG 4 ;

                                                               PAIR ;

                                                               CONS ;

                                                               TRANSFER_TOKENS ;

                                                               DIG 2 ;

                                                               NIL operation ;

                                                               DIG 2 ;

                                                               CONS ;

                                                               DIG 2 ;

                                                               CONS ;

                                                               PAIR } } } }

                                                 { IF_LEFT

                                                     { SELF %update_pools ;

                                                       SELF %cash_to_token_internal ;

                                                       SWAP ;

                                                       PUSH mutez 0 ;

                                                       UNIT ;

                                                       TRANSFER_TOKENS ;

                                                       SENDER ;

                                                       DIG 3 ;

                                                       PAIR ;

                                                       AMOUNT ;

                                                       DIG 3 ;

                                                       SWAP ;

                                                       DIG 2 ;

                                                       TRANSFER_TOKENS ;

                                                       DIG 2 ;

                                                       NIL operation ;

                                                       DIG 2 ;

                                                       CONS ;

                                                       DIG 2 ;

                                                       CONS ;

                                                       PAIR }

                                                     { IF_LEFT

                                                         { DUP 2 ;

                                                           GET 13 ;

                                                           SENDER ;

                                                           COMPARE ;

                                                           NEQ ;

                                                           IF

                                                             { DROP 2 ;

                                                               PUSH nat 26 ;

                                                               FAILWITH }

                                                             { UPDATE 26 ;

                                                               NIL operation ;

                                                               PAIR } }

                                                         { IF_LEFT

                                                             { DUP 2 ;

                                                               GET 13 ;

                                                               SENDER ;

                                                               COMPARE ;

                                                               NEQ ;

                                                               IF

                                                                 { DROP 2 ;

                                                                   PUSH nat 26 ;

                                                                   FAILWITH }

                                                                 { UPDATE 25 ;

                                                                   NIL operation ;

                                                                   PAIR } }

                                                             { IF_LEFT

                                                                 { UNPAIR ;

                                                                   UNPAIR 5 ;

                                                                   PUSH nat 0 ;

                                                                   DUP 8 ;

                                                                   GET 23 ;

                                                                   COMPARE ;

                                                                   GT ;

                                                                   IF

                                                                     { DROP 7 ;

                                                                       PUSH nat 6 ;

                                                                       FAILWITH }

                                                                     { DIG 4 ;

                                                                       NOW ;

                                                                       COMPARE ;

                                                                       GE ;

                                                                       IF

                                                                         { DROP 6 ;

                                                                           PUSH nat 3 ;

                                                                           FAILWITH }

                                                                         { SELF_ADDRESS ;

                                                                           SENDER ;

                                                                           COMPARE ;

                                                                           NEQ ;

                                                                           IF

                                                                             { DROP 6 ;

                                                                               PUSH nat 36 ;

                                                                               FAILWITH }

                                                                             { DUP 6 ;

                                                                               GET 17 ;

                                                                               DUP 7 ;

                                                                               GET 9 ;

                                                                               DUP 4 ;

                                                                               MUL ;

                                                                               EDIV ;

                                                                               IF_NONE

                                                                                 { PUSH string "DIV by 0" ;

                                                                                   FAILWITH }

                                                                                 {} ;

                                                                               CAR ;

                                                                               DUP 7 ;

                                                                               GET 17 ;

                                                                               DUP 8 ;

                                                                               GET 5 ;

                                                                               DUP 5 ;

                                                                               MUL ;

                                                                               EDIV ;

                                                                               IF_NONE

                                                                                 { PUSH string "DIV by 0" ;

                                                                                   FAILWITH }

                                                                                 {} ;

                                                                               CAR ;

                                                                               DIG 4 ;

                                                                               DUP 3 ;

                                                                               COMPARE ;

                                                                               LT ;

                                                                               IF

                                                                                 { DROP 7 ;

                                                                                   PUSH nat 11 ;

                                                                                   FAILWITH }

                                                                                 { DIG 4 ;

                                                                                   DUP 2 ;

                                                                                   COMPARE ;

                                                                                   LT ;

                                                                                   IF

                                                                                     { DROP 6 ;

                                                                                       PUSH nat 13 ;

                                                                                       FAILWITH }

                                                                                     { DUP 4 ;

                                                                                       DUP 7 ;

                                                                                       GET 17 ;

                                                                                       SUB ;

                                                                                       ISNAT ;

                                                                                       IF_NONE

                                                                                         { PUSH nat 14 ;

                                                                                           FAILWITH }

                                                                                         {} ;

                                                                                       DUP 2 ;

                                                                                       DUP 8 ;

                                                                                       GET 5 ;

                                                                                       SUB ;

                                                                                       ISNAT ;

                                                                                       IF_NONE

                                                                                         { PUSH nat 15 ;

                                                                                           FAILWITH }

                                                                                         {} ;

                                                                                       DUP 4 ;

                                                                                       DUP 9 ;

                                                                                       GET 9 ;

                                                                                       SUB ;

                                                                                       ISNAT ;

                                                                                       IF_NONE

                                                                                         { PUSH nat 16 ;

                                                                                           FAILWITH }

                                                                                         {} ;

                                                                                       DIG 6 ;

                                                                                       PUSH int 0 ;

                                                                                       SUB ;

                                                                                       DIG 7 ;

                                                                                       DUP 9 ;

                                                                                       GET 19 ;

                                                                                       CONTRACT %mintOrBurn (pair

                                                                                                              (int %quantity)

                                                                                                              (address %target)) ;

                                                                                       IF_NONE

                                                                                         { PUSH nat 12 ;

                                                                                           FAILWITH }

                                                                                         {} ;

                                                                                       PUSH mutez 0 ;

                                                                                       DIG 2 ;

                                                                                       DIG 3 ;

                                                                                       PAIR ;

                                                                                       TRANSFER_TOKENS ;

                                                                                       DIG 4 ;

                                                                                       DUP 7 ;

                                                                                       SELF_ADDRESS ;

                                                                                       DUP 10 ;

                                                                                       DUP ;

                                                                                       CAR ;

                                                                                       CONTRACT %transfer (list (pair

                                                                                                                 address

                                                                                                                 (list (pair

                                                                                                                        address

                                                                                                                        (pair

                                                                                                                          nat

                                                                                                                          nat))))) ;

                                                                                       IF_NONE

                                                                                         { PUSH nat 0 ;

                                                                                           FAILWITH }

                                                                                         {} ;

                                                                                       PUSH mutez 0 ;

                                                                                       NIL (pair

                                                                                             address

                                                                                             (list (pair

                                                                                                    address

                                                                                                    (pair

                                                                                                      nat

                                                                                                      nat)))) ;

                                                                                       NIL (pair

                                                                                             address

                                                                                             (pair

                                                                                               nat

                                                                                               nat)) ;

                                                                                       DIG 7 ;

                                                                                       DIG 5 ;

                                                                                       GET 3 ;

                                                                                       PAIR ;

                                                                                       DIG 6 ;

                                                                                       PAIR ;

                                                                                       CONS ;

                                                                                       DIG 4 ;

                                                                                       PAIR ;