{ 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))))

              (pair %tokenToCash (address %to)

                                 (pair (nat %tokensSold)

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

  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

                                                                            (address %rewardRecipient)

                                                                            (pair %feeRatio

                                                                              (nat %numerator)

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

  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 { PUSH string "DontSendTez" ; FAILWITH } {} ;

         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 ;

                         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 ;

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

                                     DUP 2 ;

                                     DUP 7 ;

                                     CAR ;

                                     ADD ;

                                     UPDATE 1 ;

                                     DUP 5 ;

                                     DIG 6 ;

                                     GET 9 ;

                                     ADD ;

                                     UPDATE 9 ;

                                     SWAP ;

                                     SELF_ADDRESS ;

                                     SENDER ;

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

                                     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 ;

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

                   { IF_LEFT

                       { UNPAIR 4 ;

                         DIG 3 ;

                         NOW ;

                         COMPARE ;

                         GE ;

                         IF

                           { DROP 6 ; PUSH nat 3 ; FAILWITH }

                           { DUP 4 ;

                             GET 13 ;

                             DUP ;

                             DUP 6 ;

                             GET 9 ;

                             MUL ;

                             DUP 6 ;

                             GET 5 ;

                             DUP 7 ;

                             CAR ;

                             MUL ;

                             DUP ;

                             DUP 3 ;

                             PAIR ;

                             DIG 9 ;

                             SWAP ;

                             EXEC ;

                             CAR ;

                             DUP 8 ;

                             GET 5 ;

                             DIG 2 ;

                             DIG 3 ;

                             PAIR ;

                             DIG 2 ;

                             PUSH int 5 ;

                             PAIR ;

                             PUSH nat 0 ;

                             DIG 4 ;

                             DUP 8 ;

                             MUL ;

                             PAIR ;

                             PAIR ;

                             PAIR ;

                             DIG 6 ;

                             SWAP ;

                             EXEC ;

                             EDIV ;

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

                             CAR ;

                             DUP 5 ;

                             GET 26 ;

                             CDR ;

                             DUP 2 ;

                             DUP 7 ;

                             GET 26 ;

                             CAR ;

                             MUL ;

                             EDIV ;

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

                             CAR ;

                             DIG 3 ;

                             DUP 2 ;

                             COMPARE ;

                             LT ;

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

                             PUSH int 2 ;

                             DUP 2 ;

                             DIG 3 ;

                             SUB ;

                             EDIV ;

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

                             CAR ;

                             ISNAT ;

                             IF_NONE { PUSH nat 19 ; FAILWITH } {} ;

                             DUP ;

                             DUP 3 ;

                             ADD ;

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

                             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 ;

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

                             SELF_ADDRESS ;

                             DUP 6 ;

                             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 ;

                         DUP 2 ;

                         GET 17 ;

                         SENDER ;

                         COMPARE ;

                         NEQ ;

                         IF

                           { DROP 2 ; PUSH nat 26 ; FAILWITH }

                           { UPDATE 26 ; NIL operation ; PAIR } } } }

               { DIG 2 ;

                 DIG 3 ;

                 DROP 2 ;

                 IF_LEFT

                   { IF_LEFT

                       { DUP 2 ;

                         GET 17 ;

                         SENDER ;

                         COMPARE ;

                         NEQ ;

                         IF

                           { DROP 2 ; PUSH nat 26 ; FAILWITH }

                           { UPDATE 19 ; NIL operation ; PAIR } }

                       { UNPAIR 5 ;

                         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 ;

                                 DUP 2 ;

                                 COMPARE ;

                                 LT ;

                                 IF

                                   { DROP 5 ; PUSH nat 13 ; FAILWITH }

                                   { DUP 4 ;

                                     DUP 6 ;

                                     GET 21 ;

                                     SUB ;

                                     ISNAT ;

                                     IF_NONE { PUSH nat 14 ; FAILWITH } {} ;

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

                                     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 ;

                                     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 ;

                                     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 address "tz1Ke2h7sDdakHJQh8WX4Z372du1KChsksyU" ;

                         DUP 3 ;

                         GET 23 ;

                         COMPARE ;

                         NEQ ;

                         IF

                           { DROP 2 ; PUSH nat 24 ; FAILWITH }

                           { UPDATE 23 ; NIL operation ; PAIR } }

                       { DUP 2 ;

                         GET 17 ;

                         SENDER ;

                         COMPARE ;

                         NEQ ;

                         IF

                           { DROP 2 ; PUSH nat 26 ; FAILWITH }

                           { UPDATE 25 ; NIL operation ; PAIR } } } } }

           { UNPAIR 4 ;

             DIG 3 ;

             NOW ;

             COMPARE ;

             GE ;

             IF

               { DROP 6 ; PUSH nat 3 ; FAILWITH }

               { DUP 4 ;

                 GET 5 ;

                 DUP 5 ;

                 GET 13 ;

                 DUP 2 ;

                 DUP 7 ;

                 CAR ;

                 MUL ;

                 DUP 2 ;

                 DUP 8 ;

                 GET 9 ;

                 MUL ;

                 DUP ;

                 DUP 3 ;

                 PAIR ;

                 DIG 10 ;

                 SWAP ;

                 EXEC ;

                 CAR ;

                 DIG 3 ;

                 DIG 2 ;

                 DIG 3 ;

                 PAIR ;

                 DIG 2 ;

                 PUSH int 5 ;

                 PAIR ;

                 PUSH nat 0 ;

                 DIG 4 ;

                 DUP 7 ;

                 MUL ;

                 PAIR ;

                 PAIR ;

                 PAIR ;

                 DIG 6 ;

                 SWAP ;

                 EXEC ;

                 EDIV ;

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

                 CAR ;

                 DUP 5 ;

                 GET 26 ;

                 CDR ;

                 DUP 2 ;

                 DUP 7 ;

                 GET 26 ;

                 CAR ;

                 MUL ;

                 EDIV ;

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

                 CAR ;

                 DIG 4 ;

                 DUP 2 ;

                 COMPARE ;

                 LT ;

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

                 PUSH int 2 ;

                 DUP 2 ;

                 DIG 3 ;

                 SUB ;

                 EDIV ;

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

                 CAR ;

                 ISNAT ;

                 IF_NONE { PUSH nat 1 ; FAILWITH } {} ;

                 DUP 4 ;

                 SELF_ADDRESS ;

                 SENDER ;

                 DUP 8 ;

                 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 ;