{ parameter (or

              (or

                (or

                  (or

                    (or (unit %acceptAdminProposal)

                        (pair %addLiquidity (address %owner)

                                            (pair (nat %minLqtMinted)

                                                  (pair (nat %maxTokensDeposited)

                                                        (pair (nat %cashDeposited)

                                                              (timestamp %deadline))))))

                    (or

                      (pair %addLiquidityInternal

                        (pair (address %owner)

                              (pair (nat %minLqtMinted)

                                    (pair (nat %maxTokensDeposited)

                                          (pair (nat %cashDeposited)

                                                (timestamp %deadline)))))

                        address)

                      (pair %cashToToken (address %to)

                                         (pair (nat %minTokensBought)

                                               (pair (nat %cashSold)

                                                     (timestamp %deadline))))))

                  (or

                    (or

                      (pair %cashToTokenInternal

                        (pair (address %to)

                              (pair (nat %minTokensBought)

                                    (pair (nat %cashSold) (timestamp %deadline))))

                        address)

                      (pair %changeFee (nat %numerator) (nat %denominator)))

                    (or (contract %fetchLqtTokenPriceInCash nat)

                        (contract %fetchLqtTokenPriceInToken nat))))

                (or

                  (or

                    (or

                      (pair %fetchLqtTokenPriceInternal (contract nat)

                                                        (or (unit %cash) (unit %token)))

                      (address %proposeNewAdmin))

                    (or

                      (pair %removeLiquidity (address %to)

                                             (pair (nat %lqtBurned)

                                                   (pair (nat %minCashWithdrawn)

                                                         (pair (nat %minTokensWithdrawn)

                                                               (timestamp %deadline)))))

                      (pair %removeLiquidityInternal

                        (pair (address %to)

                              (pair (nat %lqtBurned)

                                    (pair (nat %minCashWithdrawn)

                                          (pair (nat %minTokensWithdrawn)

                                                (timestamp %deadline)))))

                        address)))

                  (or (or (address %setLqtAddress) (address %setRewardRecipient))

                      (or

                        (pair %tokenToCash (address %to)

                                           (pair (nat %tokensSold)

                                                 (pair (nat %minCashBought)

                                                       (timestamp %deadline))))

                        (pair %tokenToCashInternal

                          (pair (address %to)

                                (pair (nat %tokensSold)

                                      (pair (nat %minCashBought) (timestamp %deadline))))

                          address)))))

              (or

                (or (list %updateCashPoolInternal (pair (pair address nat) nat))

                    (unit %updatePools))

                (list %updateTokenPoolInternal (pair (pair address nat) nat)))) ;

  storage (pair (address %tokenAddress)

                (pair (nat %tokenId)

                      (pair (nat %tokenPool)

                            (pair (nat %tokenMultiplier)

                                  (pair (address %cashAddress)

                                        (pair (nat %cashId)

                                              (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 %feeRatio

                                                                                  (nat %numerator)

                                                                                  (nat %denominator))

                                                                                (address %targetPriceOracle)))))))))))))))) ;

  code { LAMBDA

           (pair nat nat)

           (pair nat nat)

           { UNPAIR ;

             DUP 2 ;

             DUP 2 ;

             ADD ;

             DUG 2 ;

             SUB ;

             DUP 2 ;

             DUP 3 ;

             MUL ;

             DUP ;

             MUL ;

             DUP ;

             MUL ;

             DIG 2 ;

             DUP 2 ;

             EDIV ;

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

             CAR ;

             DUP 3 ;

             DUP 4 ;

             MUL ;

             DUP ;

             MUL ;

             DUP ;

             MUL ;

             PUSH int 0 ;

             DUP 5 ;

             COMPARE ;

             EQ ;

             IF

               { DIG 3 ; DROP ; PUSH int 0 }

               { DIG 3 ; DUP 2 ; EDIV ; IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; CAR } ;

             SWAP ;

             DIG 3 ;

             SUB ;

             ISNAT ;

             IF_NONE { PUSH nat 2 ; FAILWITH } {} ;

             DUG 2 ;

             ADD ;

             ISNAT ;

             IF_NONE { PUSH nat 2 ; FAILWITH } {} ;

             PUSH nat 8 ;

             MUL ;

             SWAP ;

             PAIR } ;

         LAMBDA

           (pair (lambda (pair nat nat) (pair nat nat))

                 (pair (pair (pair nat nat) (pair int nat)) (pair nat nat)))

           nat

           { UNPAIR ;

             SWAP ;

             LEFT nat ;

             LOOP_LEFT { PUSH int 0 ;

                         DUP 2 ;

                         CAR ;

                         CDR ;

                         CAR ;

                         COMPARE ;

                         EQ ;

                         IF

                           { CAR ;

                             CAR ;

                             CDR ;

                             RIGHT (pair (pair (pair nat nat) (pair int nat))

                                         (pair nat nat)) }

                           { DUP ;

                             CAR ;

                             CAR ;

                             CDR ;

                             DUP 2 ;

                             CDR ;

                             CDR ;

                             SUB ;

                             ISNAT ;

                             IF_NONE { PUSH nat 2 ; FAILWITH } {} ;

                             DUP 2 ;

                             CAR ;

                             CAR ;

                             CAR ;

                             DUP 3 ;

                             CDR ;

                             CAR ;

                             ADD ;

                             PAIR ;

                             DUP 3 ;

                             SWAP ;

                             EXEC ;

                             UNPAIR ;

                             DUP 3 ;

                             CAR ;

                             CDR ;

                             CDR ;

                             SWAP ;

                             SUB ;

                             ISNAT ;

                             IF_NONE

                               { DROP ; PUSH nat 2 ; FAILWITH }

                               { EDIV ;

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

                                 CAR ;

                                 DUP 2 ;

                                 CAR ;

                                 CAR ;

                                 CDR ;

                                 ADD } ;

                             DUP 2 ;

                             CDR ;

                             DUP 3 ;

                             CAR ;

                             CDR ;

                             DIG 2 ;

                             DUP 4 ;

                             CAR ;

                             CAR ;

                             CAR ;

                             PAIR ;

                             PAIR ;

                             PAIR ;

                             DUP ;

                             CDR ;

                             DUP 2 ;

                             CAR ;

                             CDR ;

                             CDR ;

                             PUSH int 1 ;

                             DIG 4 ;

                             CAR ;

                             CDR ;

                             CAR ;

                             SUB ;

                             PAIR ;

                             DIG 2 ;

                             CAR ;

                             CAR ;

                             PAIR ;

                             PAIR ;

                             LEFT nat } } ;

             SWAP ;

             DROP } ;

         DUP 2 ;

         APPLY ;

         DIG 2 ;

         UNPAIR ;

         PUSH mutez 0 ;

         AMOUNT ;

         COMPARE ;

         NEQ ;

         IF

           { DROP 4 ; PUSH nat 10 ; FAILWITH }

           { IF_LEFT

               { IF_LEFT

                   { IF_LEFT

                       { DIG 2 ;

                         DIG 3 ;

                         DROP 2 ;

                         IF_LEFT

                           { IF_LEFT

                               { DROP ;

                                 DUP ;

                                 GET 19 ;

                                 SENDER ;

                                 COMPARE ;

                                 NEQ ;

                                 IF

                                   { DROP ; PUSH nat 27 ; FAILWITH }

                                   { DUP ; GET 19 ; UPDATE 17 ; NIL operation ; PAIR } }

                               { SELF %updatePools ;

                                 SELF %addLiquidityInternal ;

                                 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

                               { UNPAIR ;

                                 UNPAIR 5 ;

                                 PUSH nat 0 ;

                                 DUP 8 ;

                                 GET 27 ;

                                 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 39 ; FAILWITH }

                                           { DUP 6 ;

                                             GET 13 ;

                                             DUP ;

                                             DUP 8 ;

                                             GET 21 ;

                                             DUP 7 ;

                                             MUL ;

                                             EDIV ;

                                             IF_NONE

                                               { PUSH string "DIV by 0" ; FAILWITH }

                                               {} ;

                                             CAR ;

                                             SWAP ;

                                             DUP 8 ;

                                             GET 5 ;

                                             DUP 7 ;

                                             MUL ;

                                             SWAP ;

                                             INT ;

                                             SWAP ;

                                             NEG ;

                                             EDIV ;

                                             IF_NONE

                                               { PUSH string "DIV by 0" ; FAILWITH }

                                               {} ;

                                             CAR ;

                                             ABS ;

                                             DIG 4 ;

                                             DUP 2 ;

                                             COMPARE ;

                                             GT ;

                                             IF

                                               { DROP 7 ; PUSH nat 4 ; FAILWITH }

                                               { DIG 3 ;

                                                 DUP 3 ;

                                                 COMPARE ;

                                                 LT ;

                                                 IF

                                                   { DROP 6 ; PUSH nat 5 ; FAILWITH }

                                                   { DUP 6 ;

                                                     DUP 3 ;

                                                     DUP 8 ;

                                                     GET 21 ;

                                                     ADD ;

                                                     UPDATE 21 ;

                                                     DUP 2 ;

                                                     DUP 8 ;

                                                     GET 5 ;

                                                     ADD ;

                                                     UPDATE 5 ;

                                                     DUP 5 ;

                                                     DIG 7 ;

                                                     GET 13 ;

                                                     ADD ;

                                                     UPDATE 13 ;

                                                     SWAP ;

                                                     SELF_ADDRESS ;

                                                     DUP 7 ;

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

                                                     SELF_ADDRESS ;

                                                     DIG 6 ;

                                                     DUP 5 ;

                                                     DUP ;

                                                     GET 9 ;

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

                                                     PAIR ;

                                                     DIG 6 ;

                                                     PAIR ;

                                                     CONS ;

                                                     DIG 4 ;

                                                     PAIR ;

                                                     CONS ;

                                                     TRANSFER_TOKENS ;

                                                     DIG 3 ;

                                                     INT ;

                                                     DIG 4 ;

                                                     DUP 5 ;

                                                     GET 23 ;

                                                     CONTRACT %mintOrBurn (pair

                                                                            (int %quantity)

                                                                            (address %target)) ;

                                                     IF_NONE

                                                       { PUSH nat 12 ; FAILWITH }

                                                       {} ;

                                                     PUSH mutez 0 ;

                                                     DIG 2 ;

                                                     DIG 3 ;

                                                     PAIR ;

                                                     TRANSFER_TOKENS ;

                                                     DIG 3 ;

                                                     NIL operation ;

                                                     DIG 2 ;

                                                     CONS ;

                                                     DIG 2 ;

                                                     CONS ;

                                                     DIG 2 ;

                                                     CONS ;

                                                     PAIR } } } } } }

                               { SELF %updatePools ;

                                 SELF %cashToTokenInternal ;

                                 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

                           { IF_LEFT

                               { UNPAIR ;

                                 UNPAIR 4 ;

                                 PUSH nat 0 ;

                                 DUP 7 ;

                                 GET 27 ;

                                 COMPARE ;

                                 GT ;

                                 IF

                                   { DROP 8 ; PUSH nat 6 ; FAILWITH }

                                   { DIG 3 ;

                                     NOW ;

                                     COMPARE ;

                                     GE ;

                                     IF

                                       { DROP 7 ; PUSH nat 3 ; FAILWITH }

                                       { SELF_ADDRESS ;

                                         SENDER ;

                                         COMPARE ;

                                         NEQ ;

                                         IF

                                           { DROP 7 ; PUSH nat 39 ; FAILWITH }

                                           { DUP 5 ;

                                             GET 30 ;

                                             UNIT ;

                                             VIEW "get_token_price_in_cash" nat ;

                                             IF_NONE { PUSH nat 40 ; FAILWITH } {} ;

                                             PUSH nat 1000000000000 ;

                                             DUP 7 ;

                                             GET 15 ;

                                             MUL ;

                                             SWAP ;

                                             DUP 7 ;

                                             GET 7 ;

                                             MUL ;

                                             DUP 2 ;

                                             DUP 8 ;

                                             GET 13 ;

                                             MUL ;

                                             DUP 2 ;

                                             DUP 9 ;

                                             GET 5 ;

                                             MUL ;

                                             DUP ;

                                             DUP 3 ;

                                             PAIR ;

                                             DIG 11 ;

                                             SWAP ;

                                             EXEC ;

                                             CAR ;

                                             DIG 3 ;

                                             DIG 2 ;

                                             DIG 3 ;

                                             PAIR ;

                                             DIG 2 ;

                                             PUSH int 5 ;

                                             PAIR ;

                                             PUSH nat 0 ;

                                             DIG 4 ;

                                             DUP 8 ;

                                             MUL ;

                                             PAIR ;

                                             PAIR ;

                                             PAIR ;

                                             DIG 7 ;

                                             SWAP ;

                                             EXEC ;

                                             EDIV ;

                                             IF_NONE

                                               { PUSH string "DIV by 0" ; FAILWITH }

                                               {} ;

                                             CAR ;

                                             DUP 6 ;

                                             GET 29 ;

                                             CDR ;

                                             DUP 2 ;

                                             DUP 8 ;

                                             GET 29 ;

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

                                             GET 5 ;

                                             SUB ;

                                             ISNAT ;

                                             IF_NONE { PUSH nat 19 ; FAILWITH } {} ;

                                             DUP 7 ;

                                             DUP 6 ;

                                             DIG 8 ;

                                             GET 13 ;

                                             ADD ;

                                             UPDATE 13 ;

                                             SWAP ;

                                             UPDATE 5 ;

                                             DIG 4 ;

                                             SELF_ADDRESS ;

                                             DIG 6 ;

                                             DUP 4 ;

                                             DUP ;

                                             GET 9 ;

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

                                             PAIR ;

                                             DIG 6 ;

                                             PAIR ;

                                             CONS ;

                                             DIG 4 ;

                                             PAIR ;

                                             CONS ;

                                             TRANSFER_TOKENS ;

                                             DIG 3 ;

                                             DIG 4 ;

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

                                             DUP 4 ;

                                             GET 25 ;

                                             SELF_ADDRESS ;

                                             DUP 6 ;

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

                                             NIL operation ;

                                             DIG 2 ;

                                             CONS ;

                                             DIG 2 ;

                                             CONS ;

                                             DIG 2 ;

                                             CONS ;

                                             PAIR } } } }

                               { DIG 2 ;

                                 DIG 3 ;

                                 DROP 2 ;

                                 DUP 2 ;

                                 GET 17 ;

                                 SENDER ;

                                 COMPARE ;

                                 NEQ ;

                                 IF

                                   { DROP 2 ; PUSH nat 26 ; FAILWITH }

                                   { UPDATE 29 ; NIL operation ; PAIR } } }

                           { DIG 2 ;

                             DIG 3 ;

                             DROP 2 ;

                             IF_LEFT

                               { SELF %updatePools ;

                                 SELF %fetchLqtTokenPriceInternal ;

                                 SWAP ;

                                 PUSH mutez 0 ;

                                 UNIT ;

                                 TRANSFER_TOKENS ;

                                 SWAP ;

                                 PUSH mutez 0 ;

                                 UNIT ;

                                 LEFT unit ;

                                 DIG 4 ;

                                 PAIR ;

                                 TRANSFER_TOKENS }

                               { SELF %updatePools ;

                                 SELF %fetchLqtTokenPriceInternal ;

                                 SWAP ;

                                 PUSH mutez 0 ;

                                 UNIT ;

                                 TRANSFER_TOKENS ;

                                 SWAP ;

                                 PUSH mutez 0 ;

                                 UNIT ;

                                 RIGHT unit ;

                                 DIG 4 ;

                                 PAIR ;

                                 TRANSFER_TOKENS } ;

                             DIG 2 ;

                             NIL operation ;

                             DIG 2 ;

                             CONS ;

                             DIG 2 ;

                             CONS ;

                             PAIR } } }

                   { IF_LEFT

                       { DIG 2 ;

                         DIG 3 ;

                         DROP 2 ;

                         IF_LEFT

                           { IF_LEFT

                               { UNPAIR ;

                                 SELF_ADDRESS ;

                                 SENDER ;

                                 COMPARE ;

                                 NEQ ;

                                 IF

                                   { DROP 3 ; PUSH nat 39 ; FAILWITH }

                                   { SWAP ;

                                     IF_LEFT

                                       { DROP ;

                                         DUP 2 ;

                                         GET 30 ;

                                         UNIT ;

                                         VIEW "get_token_price_in_cash" nat ;

                                         IF_NONE { PUSH nat 40 ; FAILWITH } {} ;

                                         DUP 3 ;

                                         GET 7 ;

                                         DUP 4 ;

                                         GET 5 ;

                                         MUL ;

                                         MUL ;

                                         PUSH nat 1000000000000 ;

                                         DUP 4 ;

                                         GET 15 ;

                                         DUP 5 ;

                                         GET 13 ;

                                         MUL ;

                                         MUL ;

                                         DUP 4 ;

                                         GET 21 ;

                                         SWAP ;

                                         DIG 2 ;

                                         ADD ;

                                         SWAP ;

                                         INT ;

                                         SWAP ;

                                         NEG ;

                                         EDIV ;

                                         IF_NONE

                                           { PUSH string "DIV by 0" ; FAILWITH }

                                           {} ;

                                         CAR }

                                       { DROP ;

                                         DUP 2 ;

                                         GET 30 ;

                                         UNIT ;

                                         VIEW "get_cash_price_in_token" nat ;

                                         IF_NONE { PUSH nat 40 ; FAILWITH } {} ;

                                         PUSH nat 1000000000000 ;

                                         DUP 4 ;

                                         GET 7 ;

                                         DUP 5 ;

                                         GET 5 ;

                                         MUL ;

                                         MUL ;

                                         SWAP ;

                                         DUP 4 ;

                                         GET 15 ;

                                         DUP 5 ;

                                         GET 13 ;

                                         MUL ;

                                         MUL ;

                                         DUP 4 ;

                                         GET 21 ;

                                         SWAP ;

                                         DIG 2 ;

                                         ADD ;

                                         SWAP ;

                                         INT ;

                                         SWAP ;

                                         NEG ;

                                         EDIV ;

                                         IF_NONE

                                           { PUSH string "DIV by 0" ; FAILWITH }

                                           {} ;

                                         CAR } ;

                                     ABS ;

                                     SWAP ;

                                     PUSH mutez 0 ;

                                     DIG 2 ;

                                     TRANSFER_TOKENS ;

                                     SWAP ;