{ parameter (or

              (or

                (or

                  (or (unit %acceptAdminProposal)

                      (pair %addLiquidity (address %owner)

                                          (pair (nat %minLqtMinted)

                                                (pair (nat %maxTokensDeposited)

                                                      (pair (nat %cashDeposited)

                                                            (timestamp %deadline))))))

                  (or

                    (pair %cashToToken (address %to)

                                       (pair (nat %minTokensBought)

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

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

                (or

                  (or (address %proposeNewAdmin)

                      (pair %removeLiquidity (address %to)

                                             (pair (nat %lqtBurned)

                                                   (pair (nat %minCashWithdrawn)

                                                         (pair (nat %minTokensWithdrawn)

                                                               (timestamp %deadline))))))

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

              (or

                (or

                  (pair %tokenToCash (address %to)

                                     (pair (nat %tokensSold)

                                           (pair (nat %minCashBought)

                                                 (timestamp %deadline))))

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

                (or (unit %updatePools)

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

  storage (pair (nat %tokenPool)

                (pair (address %tokenAddress)

                      (pair (nat %tokenMultiplier)

                            (pair (nat %tokenId)

                                  (pair (nat %cashPool)

                                        (pair (address %cashAddress)

                                              (pair (nat %cashMultiplier)

                                                    (pair (nat %cashId)

                                                          (pair (address %admin)

                                                                (pair

                                                                  (address %proposedAdmin)

                                                                  (pair (nat %lqtTotal)

                                                                        (pair

                                                                          (address %lqtAddress)

                                                                          (pair

                                                                            (nat %pendingPoolUpdates)

                                                                            (pair

                                                                              (address %rewardRecipient)

                                                                              (pair %feeRatio

                                                                                (nat %numerator)

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

  code { LAMBDA

           (pair nat nat)

           (pair nat nat)

           { UNPAIR ;

             SWAP ;

             DUP ;

             DUG 2 ;

             SWAP ;

             DUP ;

             DUG 2 ;

             ADD ;

             DUG 2 ;

             SUB ;

             SWAP ;

             DUP ;

             DUP ;

             DUG 3 ;

             MUL ;

             DUP ;

             MUL ;

             DUP ;

             MUL ;

             DIG 2 ;

             SWAP ;

             DUP ;

             DUG 2 ;

             EDIV ;

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

             CAR ;

             DIG 2 ;

             DUP ;

             DUP ;

             DUG 4 ;

             MUL ;

             DUP ;

             MUL ;

             DUP ;

             MUL ;

             PUSH int 0 ;

             DUP 5 ;

             COMPARE ;

             EQ ;

             IF

               { DIG 3 ; DROP ; PUSH int 0 }

               { DIG 3 ;

                 SWAP ;

                 DUP ;

                 DUG 2 ;

                 EDIV ;

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

                 CAR } ;

             DIG 2 ;

             ADD ;

             ABS ;

             PUSH nat 8 ;

             MUL ;

             SWAP ;

             DIG 2 ;

             SUB ;

             ABS ;

             PAIR } ;

         DUP ;

         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 ;

                         SWAP ;

                         DUP ;

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

                             SWAP ;

                             DUP ;

                             DUG 2 ;

                             CDR ;

                             CDR ;

                             SUB ;

                             ABS ;

                             SWAP ;

                             DUP ;

                             DUG 2 ;

                             CAR ;

                             CAR ;

                             CAR ;

                             DUP 3 ;

                             CDR ;

                             CAR ;

                             ADD ;

                             PAIR ;

                             DUP 3 ;

                             SWAP ;

                             EXEC ;

                             UNPAIR ;

                             SWAP ;

                             DUP 3 ;

                             CAR ;

                             CDR ;

                             CDR ;

                             DIG 2 ;

                             SUB ;

                             EDIV ;

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

                             CAR ;

                             ABS ;

                             SWAP ;

                             DUP ;

                             DUG 2 ;

                             CAR ;

                             CAR ;

                             CDR ;

                             ADD ;

                             SWAP ;

                             DUP ;

                             DUG 2 ;

                             CDR ;

                             DUP 3 ;

                             CAR ;

                             CDR ;

                             DIG 2 ;

                             DUP 4 ;

                             CAR ;

                             CAR ;

                             CAR ;

                             PAIR ;

                             PAIR ;

                             PAIR ;

                             DUP ;

                             CDR ;

                             SWAP ;

                             DUP ;

                             DUG 2 ;

                             CAR ;

                             CDR ;

                             CDR ;

                             PUSH int 1 ;

                             DIG 4 ;

                             CAR ;

                             CDR ;

                             CAR ;

                             SUB ;

                             PAIR ;

                             DIG 2 ;

                             CAR ;

                             CAR ;

                             PAIR ;

                             PAIR ;

                             LEFT nat } } ;

             SWAP ;

             DROP } ;

         SWAP ;

         APPLY ;

         DIG 2 ;

         UNPAIR ;

         IF_LEFT

           { IF_LEFT

               { IF_LEFT

                   { DIG 2 ;

                     DIG 3 ;

                     DROP 2 ;

                     IF_LEFT

                       { DROP ;

                         DUP ;

                         GET 19 ;

                         SENDER ;

                         COMPARE ;

                         NEQ ;

                         IF

                           { DROP ; PUSH nat 27 ; FAILWITH }

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

                       { UNPAIR 5 ;

                         PUSH nat 0 ;

                         DUP 7 ;

                         GET 25 ;

                         COMPARE ;

                         GT ;

                         IF

                           { DROP 6 ; PUSH nat 2 ; FAILWITH }

                           { DIG 4 ;

                             NOW ;

                             COMPARE ;

                             GE ;

                             IF

                               { DROP 5 ; PUSH nat 3 ; FAILWITH }

                               { DUP 5 ;

                                 GET 9 ;

                                 DUP ;

                                 DUP 7 ;

                                 GET 21 ;

                                 DUP 7 ;

                                 MUL ;

                                 EDIV ;

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

                                 CAR ;

                                 SWAP ;

                                 DUP 7 ;

                                 CAR ;

                                 DUP 7 ;

                                 MUL ;

                                 SWAP ;

                                 INT ;

                                 SWAP ;

                                 NEG ;

                                 EDIV ;

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

                                 CAR ;

                                 ABS ;

                                 DIG 4 ;

                                 SWAP ;

                                 DUP ;

                                 DUG 2 ;

                                 COMPARE ;

                                 GT ;

                                 IF

                                   { DROP 6 ; PUSH nat 4 ; FAILWITH }

                                   { DIG 3 ;

                                     DUP 3 ;

                                     COMPARE ;

                                     LT ;

                                     IF

                                       { DROP 5 ; PUSH nat 5 ; FAILWITH }

                                       { DUP 5 ;

                                         DUP 3 ;

                                         DUP 7 ;

                                         GET 21 ;

                                         ADD ;

                                         UPDATE 21 ;

                                         SWAP ;

                                         DUP ;

                                         DUG 2 ;

                                         DUP 7 ;

                                         CAR ;

                                         ADD ;

                                         UPDATE 1 ;

                                         DUP 5 ;

                                         DIG 6 ;

                                         GET 9 ;

                                         ADD ;

                                         UPDATE 9 ;

                                         SWAP ;

                                         SELF_ADDRESS ;

                                         SENDER ;

                                         DUP 4 ;

                                         PAIR 4 ;

                                         UNPAIR 4 ;

                                         DUP ;

                                         GET 3 ;

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

                                         PAIR ;

                                         DIG 6 ;

                                         PAIR ;

                                         CONS ;

                                         DIG 4 ;

                                         PAIR ;

                                         CONS ;

                                         TRANSFER_TOKENS ;

                                         DIG 4 ;

                                         SELF_ADDRESS ;

                                         SENDER ;

                                         DUP 5 ;

                                         PAIR 4 ;

                                         UNPAIR 4 ;

                                         DUP ;

                                         GET 11 ;

                                         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 ;

                                         DUP 3 ;

                                         GET 23 ;

                                         CONTRACT %mintOrBurn (pair (int %quantity)

                                                                    (address %target)) ;

                                         IF_NONE { PUSH nat 12 ; FAILWITH } {} ;

                                         PUSH mutez 0 ;

                                         DIG 6 ;

                                         DIG 6 ;

                                         INT ;

                                         PAIR ;

                                         TRANSFER_TOKENS ;

                                         DIG 3 ;

                                         NIL operation ;

                                         DIG 2 ;

                                         CONS ;

                                         DIG 2 ;

                                         CONS ;

                                         DIG 2 ;

                                         CONS ;

                                         PAIR } } } } } }

                   { IF_LEFT

                       { UNPAIR 4 ;

                         PUSH nat 0 ;

                         DUP 6 ;

                         GET 25 ;

                         COMPARE ;

                         GT ;

                         IF

                           { DROP 7 ; PUSH nat 2 ; FAILWITH }

                           { DIG 3 ;

                             NOW ;

                             COMPARE ;

                             GE ;

                             IF

                               { DROP 6 ; PUSH nat 3 ; FAILWITH }

                               { DUP 4 ;

                                 GET 13 ;

                                 DUP 5 ;

                                 GET 9 ;

                                 MUL ;

                                 DUP 5 ;

                                 GET 5 ;

                                 DUP 6 ;

                                 CAR ;

                                 MUL ;

                                 DUP ;

                                 DUP 3 ;

                                 PAIR ;

                                 DIG 8 ;

                                 SWAP ;

                                 EXEC ;

                                 CAR ;

                                 DUP 7 ;

                                 GET 5 ;

                                 DIG 2 ;

                                 DIG 3 ;

                                 PAIR ;

                                 DIG 2 ;

                                 PUSH int 5 ;

                                 PAIR ;

                                 PUSH nat 0 ;

                                 DUP 8 ;

                                 GET 13 ;

                                 DUP 8 ;

                                 MUL ;

                                 PAIR ;

                                 PAIR ;

                                 PAIR ;

                                 DIG 6 ;

                                 SWAP ;

                                 EXEC ;

                                 EDIV ;

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

                                 CAR ;

                                 DUP 5 ;

                                 GET 28 ;

                                 CDR ;

                                 SWAP ;

                                 DUP ;

                                 DUG 2 ;

                                 DUP 7 ;

                                 GET 28 ;

                                 CAR ;

                                 MUL ;

                                 EDIV ;

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

                                 CAR ;

                                 DIG 3 ;

                                 SWAP ;

                                 DUP ;

                                 DUG 2 ;

                                 COMPARE ;

                                 LT ;

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

                                 PUSH int 2 ;

                                 SWAP ;

                                 DUP ;

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

                                 CAR ;

                                 SUB ;

                                 ISNAT ;

                                 IF_NONE { PUSH nat 19 ; FAILWITH } {} ;

                                 DUP 6 ;

                                 DUP 6 ;

                                 DIG 7 ;

                                 GET 9 ;

                                 ADD ;

                                 UPDATE 9 ;

                                 SWAP ;

                                 UPDATE 1 ;

                                 DIG 4 ;

                                 SELF_ADDRESS ;

                                 SENDER ;

                                 DUP 4 ;

                                 PAIR 4 ;

                                 UNPAIR 4 ;

                                 DUP ;

                                 GET 11 ;

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

                                 DIG 4 ;

                                 SELF_ADDRESS ;

                                 DUP 5 ;

                                 PAIR 4 ;

                                 UNPAIR 4 ;

                                 DUP ;

                                 GET 3 ;

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

                                 PAIR ;

                                 DIG 6 ;

                                 PAIR ;

                                 CONS ;

                                 DIG 4 ;

                                 PAIR ;

                                 CONS ;

                                 TRANSFER_TOKENS ;

                                 DIG 3 ;

                                 DUP 4 ;

                                 GET 27 ;

                                 SELF_ADDRESS ;

                                 DUP 6 ;

                                 PAIR 4 ;

                                 UNPAIR 4 ;

                                 DUP ;

                                 GET 3 ;

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

                                 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 ;

                         SWAP ;

                         DUP ;

                         DUG 2 ;

                         GET 17 ;

                         SENDER ;

                         COMPARE ;

                         NEQ ;

                         IF

                           { DROP 2 ; PUSH nat 26 ; FAILWITH }

                           { UPDATE 28 ; NIL operation ; PAIR } } } }

               { DIG 2 ;

                 DIG 3 ;

                 DROP 2 ;

                 IF_LEFT

                   { IF_LEFT

                       { SWAP ;

                         DUP ;

                         DUG 2 ;

                         GET 17 ;

                         SENDER ;

                         COMPARE ;

                         NEQ ;

                         IF

                           { DROP 2 ; PUSH nat 26 ; FAILWITH }

                           { UPDATE 19 ; NIL operation ; PAIR } }

                       { UNPAIR 5 ;

                         PUSH nat 0 ;

                         DUP 7 ;

                         GET 25 ;

                         COMPARE ;

                         GT ;

                         IF

                           { DROP 6 ; PUSH nat 2 ; FAILWITH }

                           { DIG 4 ;

                             NOW ;

                             COMPARE ;

                             GE ;

                             IF

                               { DROP 5 ; PUSH nat 3 ; FAILWITH }

                               { DUP 5 ;

                                 GET 21 ;

                                 DUP 6 ;

                                 GET 9 ;

                                 DUP 4 ;

                                 MUL ;

                                 EDIV ;

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

                                 CAR ;

                                 DUP 6 ;

                                 GET 21 ;

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

                                         SUB ;

                                         ISNAT ;

                                         IF_NONE { PUSH nat 14 ; FAILWITH } {} ;

                                         SWAP ;

                                         DUP ;

                                         DUG 2 ;

                                         DUP 7 ;

                                         CAR ;

                                         SUB ;

                                         ISNAT ;

                                         IF_NONE { PUSH nat 15 ; FAILWITH } {} ;

                                         DUP 4 ;

                                         DUP 8 ;

                                         GET 9 ;

                                         SUB ;

                                         ISNAT ;

                                         IF_NONE { PUSH nat 16 ; FAILWITH } {} ;

                                         DIG 6 ;

                                         PUSH int 0 ;

                                         SUB ;

                                         SENDER ;

                                         DUP 9 ;

                                         PAIR 3 ;

                                         UNPAIR 3 ;

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

                                         DUP 7 ;

                                         SELF_ADDRESS ;

                                         DUP 10 ;

                                         PAIR 4 ;

                                         UNPAIR 4 ;

                                         DUP ;

                                         GET 3 ;

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

                                         PAIR ;

                                         DIG 6 ;

                                         PAIR ;

                                         CONS ;

                                         DIG 4 ;

                                         PAIR ;

                                         CONS ;

                                         TRANSFER_TOKENS ;

                                         DIG 5 ;

                                         DIG 6 ;

                                         SELF_ADDRESS ;

                                         DUP 9 ;

                                         PAIR 4 ;

                                         UNPAIR 4 ;

                                         DUP ;

                                         GET 11 ;

                                         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 ;

                                         DIG 4 ;

                                         UPDATE 9 ;

                                         DIG 5 ;

                                         UPDATE 21 ;

                                         DIG 4 ;

                                         UPDATE 1 ;

                                         NIL operation ;

                                         DIG 2 ;

                                         CONS ;

                                         DIG 2 ;

                                         CONS ;

                                         DIG 2 ;

                                         CONS ;

                                         PAIR } } } } } }

                   { IF_LEFT

                       { PUSH nat 0 ;

                         DUP 3 ;

                         GET 25 ;

                         COMPARE ;

                         GT ;

                         IF

                           { DROP 2 ; PUSH nat 2 ; FAILWITH }

                           { PUSH address "tz1Ke2h7sDdakHJQh8WX4Z372du1KChsksyU" ;

                             DUP 3 ;

                             GET 23 ;

                             COMPARE ;

                             NEQ ;

                             IF

                               { DROP 2 ; PUSH nat 24 ; FAILWITH }

                               { UPDATE 23 ; NIL operation ; PAIR } } }

                       { SWAP ;

                         DUP ;

                         DUG 2 ;

                         GET 17 ;

                         SENDER ;

                         COMPARE ;

                         NEQ ;

                         IF

                           { DROP 2 ; PUSH nat 26 ; FAILWITH }

                           { UPDATE 27 ; NIL operation ; PAIR } } } } }

           { IF_LEFT

               { IF_LEFT

                   { UNPAIR 4 ;

                     PUSH nat 0 ;

                     DUP 6 ;

                     GET 25 ;

                     COMPARE ;

                     GT ;

                     IF

                       { DROP 7 ; PUSH nat 2 ; FAILWITH }