parameter (or

            (or

              (or

                (or

                  (pair %addLiquidity (address %owner) (nat %minLqtMinted)

                                      (nat %maxTokensDeposited)

                                      (timestamp %deadline))

                  (unit %default))

                (or

                  (pair %removeLiquidity (address %to) (nat %lqtBurned)

                                         (mutez %minXtzWithdrawn)

                                         (nat %minTokensWithdrawn)

                                         (timestamp %deadline))

                  (pair %setBaker (option %baker key_hash) (bool %freezeBaker))))

              (or (or (address %setLqtAddress) (address %setManager))

                  (or

                    (pair %tokenToToken (address %outputDexterContract)

                                        (nat %minTokensBought)

                                        (address %to)

                                        (nat %tokensSold)

                                        (timestamp %deadline))

                    (pair %tokenToXtz (address %to) (nat %tokensSold)

                                      (mutez %minXtzBought)

                                      (timestamp %deadline)))))

            (or (or (address %updateReserve) (unit %updateTokenPool))

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

                    (pair %xtzToToken (address %to) (nat %minTokensBought)

                                      (timestamp %deadline)))));

storage (pair (nat %tokenPool) (mutez %xtzPool) (nat %lqtTotal)

              (bool %selfIsUpdatingTokenPool)

              (bool %freezeBaker)

              (address %manager)

              (address %tokenAddress)

              (nat %tokenId)

              (address %lqtAddress)

              (big_map %history string nat)

              (big_map %user_investments address

                                         (pair

                                           (pair

                                             (or %direction (unit %aDD) (unit %rEMOVE))

                                             (nat %token))

                                           (mutez %xtz)))

              (address %reserve));

code { UNPAIR ;

       IF_LEFT

         { IF_LEFT

             { IF_LEFT

                 { IF_LEFT

                     { UNPAIR 4 ;

                       DUP 5 ;

                       GET 7 ;

                       IF

                         { DROP 5 ; PUSH nat 2 ; FAILWITH }

                         { DIG 3 ;

                           NOW ;

                           COMPARE ;

                           GE ;

                           IF

                             { DROP 4 ; PUSH nat 3 ; FAILWITH }

                             { PUSH mutez 1 ;

                               DUP 5 ;

                               GET 3 ;

                               EDIV ;

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

                               CAR ;

                               AMOUNT ;

                               PUSH mutez 1 ;

                               SWAP ;

                               EDIV ;

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

                               CAR ;

                               SWAP ;

                               DUP ;

                               DUG 2 ;

                               DUP 7 ;

                               GET 5 ;

                               DUP 3 ;

                               MUL ;

                               EDIV ;

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

                               CAR ;

                               DUP 7 ;

                               CAR ;

                               DIG 2 ;

                               MUL ;

                               DIG 2 ;

                               SWAP ;

                               EDIV ;

                               IF_NONE

                                 { PUSH string "DIV by 0" ; FAILWITH }

                                 { UNPAIR ;

                                   PUSH nat 0 ;

                                   DIG 2 ;

                                   COMPARE ;

                                   EQ ;

                                   IF {} { PUSH nat 1 ; ADD } } ;

                               DIG 4 ;

                               SWAP ;

                               DUP ;

                               DUG 2 ;

                               COMPARE ;

                               GT ;

                               IF

                                 { DROP 5 ; PUSH nat 4 ; FAILWITH }

                                 { DIG 3 ;

                                   DUP 3 ;

                                   COMPARE ;

                                   LT ;

                                   IF

                                     { DROP 4 ; PUSH nat 5 ; FAILWITH }

                                     { DUP 4 ;

                                       DUP 3 ;

                                       DUP 6 ;

                                       GET 5 ;

                                       ADD ;

                                       UPDATE 5 ;

                                       SWAP ;

                                       DUP ;

                                       DUG 2 ;

                                       DUP 6 ;

                                       CAR ;

                                       ADD ;

                                       UPDATE 1 ;

                                       AMOUNT ;

                                       DIG 5 ;

                                       GET 3 ;

                                       ADD ;

                                       UPDATE 3 ;

                                       DUP ;

                                       GET 19 ;

                                       SWAP ;

                                       DUP ;

                                       DUG 2 ;

                                       CAR ;

                                       SOME ;

                                       PUSH string "tokenPool" ;

                                       UPDATE ;

                                       PUSH mutez 1 ;

                                       DUP 3 ;

                                       GET 3 ;

                                       EDIV ;

                                       IF_NONE

                                         { PUSH string "DIV by 0" ; FAILWITH }

                                         {} ;

                                       CAR ;

                                       SOME ;

                                       PUSH string "xtzPool" ;

                                       UPDATE ;

                                       SWAP ;

                                       DUP ;

                                       DUG 2 ;

                                       GET 21 ;

                                       AMOUNT ;

                                       DUP 5 ;

                                       PUSH unit Unit ;

                                       LEFT unit ;

                                       PAIR ;

                                       PAIR ;

                                       SOME ;

                                       SENDER ;

                                       UPDATE ;

                                       DUP 3 ;

                                       DIG 2 ;

                                       DIG 3 ;

                                       CAR ;

                                       SOME ;

                                       PUSH string "tokenPool" ;

                                       UPDATE ;

                                       UPDATE 19 ;

                                       SWAP ;

                                       UPDATE 21 ;

                                       DUP ;

                                       SENDER ;

                                       SELF_ADDRESS ;

                                       DIG 4 ;

                                       SWAP ;

                                       PAIR ;

                                       SWAP ;

                                       PAIR ;

                                       SWAP ;

                                       PAIR ;

                                       UNPAIR 4 ;

                                       DUP ;

                                       GET 13 ;

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

                                       PAIR ;

                                       DIG 6 ;

                                       PAIR ;

                                       CONS ;

                                       DIG 4 ;

                                       PAIR ;

                                       CONS ;

                                       TRANSFER_TOKENS ;

                                       SWAP ;

                                       DUP ;

                                       DUG 2 ;

                                       GET 17 ;

                                       CONTRACT %mintOrBurn (pair (int %quantity)

                                                                  (address %target)) ;

                                       IF_NONE { PUSH nat 12 ; FAILWITH } {} ;

                                       PUSH mutez 0 ;

                                       DIG 4 ;

                                       INT ;

                                       DIG 5 ;

                                       SWAP ;

                                       PAIR ;

                                       TRANSFER_TOKENS ;

                                       DIG 2 ;

                                       NIL operation ;

                                       DIG 2 ;

                                       CONS ;

                                       DIG 2 ;

                                       CONS ;

                                       PAIR } } } } }

                     { DROP ;

                       DUP ;

                       GET 7 ;

                       IF

                         { DROP ; PUSH nat 2 ; FAILWITH }

                         { DUP ; AMOUNT ; DIG 2 ; GET 3 ; ADD ; UPDATE 3 ; NIL operation ; PAIR } } }

                 { IF_LEFT

                     { UNPAIR 5 ;

                       DUP 6 ;

                       GET 7 ;

                       IF

                         { DROP 6 ; PUSH nat 2 ; FAILWITH }

                         { DIG 4 ;

                           NOW ;

                           COMPARE ;

                           GE ;

                           IF

                             { DROP 5 ; PUSH nat 3 ; FAILWITH }

                             { PUSH mutez 0 ;

                               AMOUNT ;

                               COMPARE ;

                               GT ;

                               IF

                                 { DROP 5 ; PUSH nat 10 ; FAILWITH }

                                 { DUP 5 ;

                                   GET 5 ;

                                   PUSH mutez 1 ;

                                   DUP 7 ;

                                   GET 3 ;

                                   EDIV ;

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

                                   CAR ;

                                   DUP 4 ;

                                   MUL ;

                                   EDIV ;

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

                                   CAR ;

                                   PUSH mutez 1 ;

                                   SWAP ;

                                   MUL ;

                                   DUP 6 ;

                                   GET 5 ;

                                   DUP 7 ;

                                   CAR ;

                                   DUP 5 ;

                                   MUL ;

                                   EDIV ;

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

                                   CAR ;

                                   DIG 4 ;

                                   DUP 3 ;

                                   COMPARE ;

                                   LT ;

                                   IF

                                     { DROP 6 ; PUSH nat 11 ; FAILWITH }

                                     { DIG 4 ;

                                       SWAP ;

                                       DUP ;

                                       DUG 2 ;

                                       COMPARE ;

                                       LT ;

                                       IF

                                         { DROP 5 ; PUSH nat 13 ; FAILWITH }

                                         { DUP 4 ;

                                           DUP 6 ;

                                           GET 5 ;

                                           SUB ;

                                           ISNAT ;

                                           IF_NONE { PUSH nat 14 ; FAILWITH } {} ;

                                           SWAP ;

                                           DUP ;

                                           DUG 2 ;

                                           DUP 7 ;

                                           CAR ;

                                           SUB ;

                                           ISNAT ;

                                           IF_NONE { PUSH nat 15 ; FAILWITH } {} ;

                                           DUP 7 ;

                                           SENDER ;

                                           DIG 7 ;

                                           PUSH int 0 ;

                                           SUB ;

                                           SWAP ;

                                           PAIR ;

                                           SWAP ;

                                           PAIR ;

                                           UNPAIR 3 ;

                                           GET 17 ;

                                           CONTRACT %mintOrBurn (pair (int %quantity)

                                                                      (address %target)) ;

                                           IF_NONE { PUSH nat 12 ; FAILWITH } {} ;

                                           PUSH mutez 0 ;

                                           DIG 3 ;

                                           DIG 3 ;

                                           SWAP ;

                                           PAIR ;

                                           TRANSFER_TOKENS ;

                                           DUP 7 ;

                                           SELF_ADDRESS ;

                                           DUP 8 ;

                                           DUP 7 ;

                                           SWAP ;

                                           PAIR ;

                                           SWAP ;

                                           PAIR ;

                                           SWAP ;

                                           PAIR ;

                                           UNPAIR 4 ;

                                           DUP ;

                                           GET 13 ;

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

                                           PAIR ;

                                           DIG 6 ;

                                           PAIR ;

                                           CONS ;

                                           DIG 4 ;

                                           PAIR ;

                                           CONS ;

                                           TRANSFER_TOKENS ;

                                           DIG 6 ;

                                           CONTRACT unit ;

                                           IF_NONE { PUSH nat 9 ; FAILWITH } {} ;

                                           DUP 7 ;

                                           PUSH unit Unit ;

                                           TRANSFER_TOKENS ;

                                           DUP 8 ;

                                           DUP 8 ;

                                           DIG 9 ;

                                           GET 3 ;

                                           SUB ;

                                           UPDATE 3 ;

                                           DIG 5 ;

                                           UPDATE 5 ;

                                           DIG 4 ;

                                           UPDATE 1 ;

                                           DUP ;

                                           GET 19 ;

                                           SWAP ;

                                           DUP ;

                                           DUG 2 ;

                                           CAR ;

                                           SOME ;

                                           PUSH string "tokenPool" ;

                                           UPDATE ;

                                           PUSH mutez 1 ;

                                           DUP 3 ;

                                           GET 3 ;

                                           EDIV ;

                                           IF_NONE

                                             { PUSH string "DIV by 0" ; FAILWITH }

                                             {} ;

                                           CAR ;

                                           SOME ;

                                           PUSH string "xtzPool" ;

                                           UPDATE ;

                                           SWAP ;

                                           DUP ;

                                           DUG 2 ;

                                           GET 21 ;

                                           DIG 7 ;

                                           DIG 7 ;

                                           PUSH unit Unit ;

                                           RIGHT unit ;

                                           PAIR ;

                                           PAIR ;

                                           SOME ;

                                           SENDER ;

                                           UPDATE ;

                                           DUG 2 ;

                                           UPDATE 19 ;

                                           SWAP ;

                                           UPDATE 21 ;

                                           NIL operation ;

                                           DIG 2 ;

                                           CONS ;

                                           DIG 2 ;

                                           CONS ;

                                           DIG 2 ;

                                           CONS ;

                                           PAIR } } } } } }

                     { UNPAIR ;

                       DUP 3 ;

                       GET 7 ;

                       IF

                         { DROP 3 ; PUSH nat 2 ; FAILWITH }

                         { PUSH mutez 0 ;

                           AMOUNT ;

                           COMPARE ;

                           GT ;

                           IF

                             { DROP 3 ; PUSH nat 10 ; FAILWITH }

                             { DUP 3 ;

                               GET 11 ;

                               SENDER ;

                               COMPARE ;

                               NEQ ;

                               IF

                                 { DROP 3 ; PUSH nat 20 ; FAILWITH }

                                 { DUP 3 ;

                                   GET 9 ;

                                   IF

                                     { DROP 3 ; PUSH nat 22 ; FAILWITH }

                                     { DUG 2 ;

                                       UPDATE 9 ;

                                       NIL operation ;

                                       DIG 2 ;

                                       SET_DELEGATE ;

                                       CONS ;

                                       PAIR } } } } } } }

             { IF_LEFT

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET 7 ;

                       IF

                         { DROP 2 ; PUSH nat 2 ; FAILWITH }

                         { PUSH mutez 0 ;

                           AMOUNT ;

                           COMPARE ;

                           GT ;

                           IF

                             { DROP 2 ; PUSH nat 10 ; FAILWITH }

                             { SWAP ;

                               DUP ;

                               DUG 2 ;

                               GET 11 ;

                               SENDER ;

                               COMPARE ;

                               NEQ ;

                               IF

                                 { DROP 2 ; PUSH nat 23 ; FAILWITH }

                                 { PUSH address "tz1Ke2h7sDdakHJQh8WX4Z372du1KChsksyU" ;

                                   DUP 3 ;

                                   GET 17 ;

                                   COMPARE ;

                                   NEQ ;

                                   IF

                                     { DROP 2 ; PUSH nat 24 ; FAILWITH }

                                     { UPDATE 17 ; NIL operation ; PAIR } } } } }

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET 7 ;

                       IF

                         { DROP 2 ; PUSH nat 2 ; FAILWITH }

                         { PUSH mutez 0 ;

                           AMOUNT ;

                           COMPARE ;

                           GT ;

                           IF

                             { DROP 2 ; PUSH nat 10 ; FAILWITH }

                             { SWAP ;

                               DUP ;

                               DUG 2 ;

                               GET 11 ;

                               SENDER ;

                               COMPARE ;

                               NEQ ;

                               IF

                                 { DROP 2 ; PUSH nat 21 ; FAILWITH }

                                 { UPDATE 11 ; NIL operation ; PAIR } } } } }

                 { IF_LEFT

                     { UNPAIR 5 ;

                       CONTRACT %xtzToToken (pair (address %to)

                                                  (pair (nat %minTokensBought)

                                                        (timestamp %deadline))) ;

                       IF_NONE { PUSH nat 31 ; FAILWITH } {} ;

                       DUP 6 ;

                       GET 7 ;

                       IF

                         { DROP 6 ; PUSH nat 2 ; FAILWITH }

                         { PUSH mutez 0 ;

                           AMOUNT ;

                           COMPARE ;

                           GT ;

                           IF

                             { DROP 6 ; PUSH nat 10 ; FAILWITH }

                             { DUP 5 ;

                               NOW ;

                               COMPARE ;

                               GE ;

                               IF

                                 { DROP 6 ; PUSH nat 3 ; FAILWITH }

                                 { PUSH nat 9972 ;

                                   DUP 5 ;

                                   MUL ;

                                   PUSH nat 10000 ;

                                   DUP 8 ;

                                   CAR ;

                                   MUL ;

                                   ADD ;

                                   PUSH mutez 1 ;

                                   DUP 8 ;

                                   GET 3 ;

                                   EDIV ;

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

                                   CAR ;

                                   PUSH nat 9972 ;

                                   DUP 7 ;

                                   MUL ;

                                   MUL ;

                                   EDIV ;

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

                                   CAR ;

                                   PUSH mutez 1 ;

                                   SWAP ;

                                   MUL ;

                                   PUSH nat 3 ;

                                   DUP 6 ;

                                   MUL ;

                                   PUSH nat 10000 ;

                                   DUP 9 ;

                                   CAR ;

                                   MUL ;

                                   ADD ;

                                   PUSH mutez 1 ;

                                   DUP 9 ;

                                   GET 3 ;

                                   EDIV ;

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

                                   CAR ;

                                   PUSH nat 3 ;

                                   DUP 8 ;

                                   MUL ;

                                   MUL ;

                                   EDIV ;

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

                                   CAR ;

                                   PUSH mutez 1 ;

                                   SWAP ;

                                   MUL ;

                                   DUP 6 ;

                                   DUP 9 ;

                                   CAR ;

                                   ADD ;

                                   PUSH mutez 1 ;

                                   DUP 10 ;

                                   GET 3 ;

                                   EDIV ;

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

                                   CAR ;

                                   DUP 8 ;

                                   MUL ;

                                   EDIV ;

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

                                   CAR ;

                                   PUSH mutez 1 ;

                                   SWAP ;

                                   MUL ;

                                   DUP 7 ;

                                   DUP 10 ;

                                   CAR ;

                                   ADD ;

                                   DUP 3 ;

                                   DUP 5 ;

                                   DUP 12 ;

                                   GET 3 ;

                                   SUB ;

                                   SUB ;

                                   DUP 11 ;

                                   GET 19 ;

                                   DUP 3 ;

                                   SOME ;

                                   PUSH string "tokenPool" ;

                                   UPDATE ;

                                   PUSH mutez 1 ;

                                   DUP 3 ;

                                   EDIV ;

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

                                   CAR ;

                                   SOME ;

                                   PUSH string "xtzPool" ;

                                   UPDATE ;

                                   PUSH mutez 1 ;

                                   DIG 4 ;

                                   EDIV ;

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

                                   CAR ;

                                   SOME ;

                                   PUSH string "xtzVolume" ;

                                   UPDATE ;

                                   DIG 10 ;

                                   DIG 3 ;

                                   UPDATE 1 ;

                                   DIG 2 ;

                                   UPDATE 3 ;

                                   SWAP ;

                                   UPDATE 19 ;

                                   DUP ;

                                   SENDER ;

                                   SELF_ADDRESS ;

                                   DIG 9 ;

                                   SWAP ;

                                   PAIR ;

                                   SWAP ;

                                   PAIR ;

                                   SWAP ;

                                   PAIR ;

                                   UNPAIR 4 ;

                                   DUP ;

                                   GET 13 ;

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

                                   PAIR ;

                                   DIG 6 ;

                                   PAIR ;

                                   CONS ;

                                   DIG 4 ;

                                   PAIR ;

                                   CONS ;

                                   TRANSFER_TOKENS ;

                                   DIG 4 ;

                                   DIG 4 ;

                                   DIG 6 ;

                                   DIG 6 ;

                                   DIG 7 ;

                                   SWAP ;

                                   PAIR ;

                                   SWAP ;

                                   PAIR ;

                                   TRANSFER_TOKENS ;

                                   DUP 3 ;

                                   GET 22 ;

                                   CONTRACT unit ;

                                   IF_NONE { PUSH nat 9 ; FAILWITH } {} ;

                                   DUP 5 ;

                                   PUSH unit Unit ;

                                   TRANSFER_TOKENS ;

                                   DIG 3 ;

                                   PUSH mutez 0 ;

                                   DIG 5 ;

                                   COMPARE ;

                                   EQ ;

                                   IF

                                     { SWAP ; DROP ; NIL operation ; DIG 2 ; CONS ; DIG 2 ; CONS }

                                     { NIL operation ; DIG 2 ; CONS ; DIG 2 ; CONS ; DIG 2 ; CONS } ;

                                   PAIR } } } }

                     { UNPAIR 4 ;

                       DUP 5 ;

                       GET 7 ;

                       IF

                         { DROP 5 ; PUSH nat 2 ; FAILWITH }

                         { DIG 3 ;

                           NOW ;

                           COMPARE ;

                           GE ;

                           IF

                             { DROP 4 ; PUSH nat 3 ; FAILWITH }

                             { PUSH mutez 0 ;

                               AMOUNT ;

                               COMPARE ;

                               GT ;

                               IF

                                 { DROP 4 ; PUSH nat 10 ; FAILWITH }

                                 { PUSH nat 9972 ;

                                   DUP 3 ;

                                   MUL ;

                                   PUSH nat 10000 ;

                                   DUP 6 ;

                                   CAR ;

                                   MUL ;

                                   ADD ;

                                   PUSH mutez 1 ;

                                   DUP 6 ;

                                   GET 3 ;

                                   EDIV ;

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

                                   CAR ;

                                   PUSH nat 9972 ;

                                   DUP 5 ;

                                   MUL ;

                                   MUL ;

                                   EDIV ;

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

                                   CAR ;

                                   PUSH mutez 1 ;

                                   SWAP ;

                                   MUL ;

                                   DIG 3 ;

                                   SWAP ;

                                   DUP ;

                                   DUG 2 ;

                                   COMPARE ;

                                   LT ;

                                   IF { DROP ; PUSH nat 8 ; FAILWITH } {} ;

                                   PUSH nat 3 ;

                                   DUP 4 ;

                                   MUL ;

                                   PUSH nat 10000 ;

                                   DUP 6 ;

                                   CAR ;

                                   MUL ;

                                   ADD ;

                                   PUSH mutez 1 ;

                                   DUP 6 ;

                                   GET 3 ;

                                   EDIV ;

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

                                   CAR ;

                                   PUSH nat 3 ;

                                   DUP 6 ;

                                   MUL ;

                                   MUL ;

                                   EDIV ;

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

                                   CAR ;

                                   PUSH mutez 1 ;

                                   SWAP ;

                                   MUL ;

                                   DUP 4 ;

                                   DUP 6 ;

                                   CAR ;

                                   ADD ;

                                   PUSH mutez 1 ;

                                   DUP 7 ;

                                   GET 3 ;

                                   EDIV ;

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

                                   CAR ;

                                   DUP 6 ;

                                   MUL ;

                                   EDIV ;

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

                                   CAR ;

                                   PUSH mutez 1 ;

                                   SWAP ;

                                   MUL ;

                                   DUP 6 ;

                                   SENDER ;

                                   SELF_ADDRESS ;

                                   DUP 8 ;

                                   SWAP ;

                                   PAIR ;

                                   SWAP ;

                                   PAIR ;