{ parameter (or

              (or

                (or

                  (or (unit %acceptAdminProposal)

                      (pair %addLiquidity (address %owner)

                                          (pair (nat %minLqtMinted)

                                                (pair (nat %maxTokensDeposited)

                                                      (timestamp %deadline)))))

                  (or

                    (pair %cashToToken (address %to)

                                       (pair (nat %minTokensBought)

                                             (timestamp %deadline)))

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

                (or (or (unit %default) (address %proposeNewAdmin))

                    (or

                      (pair %removeLiquidity (address %to)

                                             (pair (nat %lqtBurned)

                                                   (pair (nat %minCashWithdrawn)

                                                         (pair (nat %minTokensWithdrawn)

                                                               (timestamp %deadline)))))

                      (address %setBakingRewardRecipient))))

              (or (or (option %setDelegate key_hash) (address %setLqtAddress))

                  (or (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 (nat %cashMultiplier)

                                              (pair (address %admin)

                                                    (pair (address %proposedAdmin)

                                                          (pair (nat %lqtTotal)

                                                                (pair

                                                                  (address %lqtAddress)

                                                                  (pair

                                                                    (address %rewardRecipient)

                                                                    (pair

                                                                      (address %bakingRewardRecipient)

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

         IF_LEFT

           { IF_LEFT

               { IF_LEFT

                   { DIG 2 ;

                     DIG 3 ;

                     DROP 2 ;

                     IF_LEFT

                       { DROP ;

                         DUP ;

                         GET 15 ;

                         SENDER ;

                         COMPARE ;

                         NEQ ;

                         IF

                           { DROP ; PUSH nat 27 ; FAILWITH }

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

                       { UNPAIR 4 ;

                         AMOUNT ;

                         PUSH mutez 1 ;

                         SWAP ;

                         EDIV ;

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

                         CAR ;

                         DIG 4 ;

                         NOW ;

                         COMPARE ;

                         GE ;

                         IF

                           { DROP 5 ; PUSH nat 3 ; FAILWITH }

                           { DUP 5 ;

                             GET 9 ;

                             DUP ;

                             DUP 7 ;

                             GET 17 ;

                             DUP 4 ;

                             MUL ;

                             EDIV ;

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

                             CAR ;

                             SWAP ;

                             DUP 7 ;

                             CAR ;

                             DUP 4 ;

                             MUL ;

                             SWAP ;

                             INT ;

                             SWAP ;

                             NEG ;

                             EDIV ;

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

                             CAR ;

                             ABS ;

                             DIG 5 ;

                             DUP 2 ;

                             COMPARE ;

                             GT ;

                             IF

                               { DROP 6 ; PUSH nat 4 ; FAILWITH }

                               { DIG 4 ;

                                 DUP 3 ;

                                 COMPARE ;

                                 LT ;

                                 IF

                                   { DROP 5 ; PUSH nat 5 ; FAILWITH }

                                   { DUP 5 ;

                                     DUP 3 ;

                                     DUP 7 ;

                                     GET 17 ;

                                     ADD ;

                                     UPDATE 17 ;

                                     DUP 2 ;

                                     DUP 7 ;

                                     CAR ;

                                     ADD ;

                                     UPDATE 1 ;

                                     DIG 3 ;

                                     DIG 5 ;

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

                                     INT ;

                                     DIG 3 ;

                                     DUP 4 ;

                                     GET 19 ;

                                     CONTRACT %mintOrBurn (pair (int %quantity)

                                                                (address %target)) ;

                                     IF_NONE { PUSH nat 12 ; FAILWITH } {} ;

                                     PUSH mutez 0 ;

                                     DIG 2 ;

                                     DIG 3 ;

                                     PAIR ;

                                     TRANSFER_TOKENS ;

                                     DIG 2 ;

                                     NIL operation ;

                                     DIG 2 ;

                                     CONS ;

                                     DIG 2 ;

                                     CONS ;

                                     PAIR } } } } }

                   { IF_LEFT

                       { UNPAIR 3 ;

                         AMOUNT ;

                         PUSH mutez 1 ;

                         SWAP ;

                         EDIV ;

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

                         CAR ;

                         DIG 3 ;

                         NOW ;

                         COMPARE ;

                         GE ;

                         IF

                           { DROP 6 ; PUSH nat 3 ; FAILWITH }

                           { DUP 4 ;

                             GET 11 ;

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

                             MUL ;

                             PAIR ;

                             PAIR ;

                             PAIR ;

                             DIG 6 ;

                             SWAP ;

                             EXEC ;

                             EDIV ;

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

                             CAR ;

                             DUP 5 ;

                             GET 24 ;

                             CDR ;

                             DUP 2 ;

                             DUP 7 ;

                             GET 24 ;

                             CAR ;

                             MUL ;

                             EDIV ;

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

                             CAR ;

                             DIG 4 ;

                             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 ;

                             DIG 4 ;

                             DIG 6 ;

                             GET 9 ;

                             ADD ;

                             UPDATE 9 ;

                             SWAP ;

                             UPDATE 1 ;

                             DIG 2 ;

                             DIG 3 ;

                             SELF_ADDRESS ;

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

                             DUP 3 ;

                             GET 21 ;

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

                             NIL operation ;

                             DIG 2 ;

                             CONS ;

                             DIG 2 ;

                             CONS ;

                             PAIR } }

                       { DIG 2 ;

                         DIG 3 ;

                         DROP 2 ;

                         DUP 2 ;

                         GET 13 ;

                         SENDER ;

                         COMPARE ;

                         NEQ ;

                         IF

                           { DROP 2 ; PUSH nat 26 ; FAILWITH }

                           { UPDATE 24 ; NIL operation ; PAIR } } } }

               { DIG 2 ;

                 DIG 3 ;

                 DROP 2 ;

                 IF_LEFT

                   { IF_LEFT

                       { DROP ;

                         DUP ;

                         GET 23 ;

                         CONTRACT unit ;

                         IF_NONE { PUSH nat 35 ; FAILWITH } {} ;

                         AMOUNT ;

                         UNIT ;

                         TRANSFER_TOKENS ;

                         SWAP ;

                         NIL operation ;

                         DIG 2 ;

                         CONS ;

                         PAIR }

                       { DUP 2 ;

                         GET 13 ;

                         SENDER ;

                         COMPARE ;

                         NEQ ;

                         IF

                           { DROP 2 ; PUSH nat 26 ; FAILWITH }

                           { UPDATE 15 ; NIL operation ; PAIR } } }

                   { IF_LEFT

                       { UNPAIR 5 ;

                         DIG 4 ;

                         NOW ;

                         COMPARE ;

                         GE ;

                         IF

                           { DROP 5 ; PUSH nat 3 ; FAILWITH }

                           { DUP 5 ;

                             GET 17 ;

                             DUP 6 ;

                             GET 9 ;

                             DUP 4 ;

                             MUL ;

                             EDIV ;

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

                             CAR ;

                             DUP 6 ;

                             GET 17 ;

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

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

                                     CONTRACT %mintOrBurn (pair (int %quantity)

                                                                (address %target)) ;

                                     IF_NONE { PUSH nat 12 ; FAILWITH } {} ;

                                     PUSH mutez 0 ;

                                     DIG 2 ;

                                     DIG 3 ;

                                     PAIR ;

                                     TRANSFER_TOKENS ;

                                     DIG 4 ;

                                     DUP 7 ;

                                     SELF_ADDRESS ;

                                     DUP 10 ;

                                     DUP ;

                                     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 ;

                                     PUSH mutez 1 ;

                                     DIG 6 ;

                                     MUL ;

                                     DIG 6 ;

                                     CONTRACT unit ;

                                     IF_NONE { PUSH nat 35 ; FAILWITH } {} ;

                                     SWAP ;

                                     UNIT ;

                                     TRANSFER_TOKENS ;

                                     DIG 6 ;

                                     DIG 4 ;

                                     UPDATE 9 ;

                                     DIG 5 ;

                                     UPDATE 17 ;

                                     DIG 4 ;

                                     UPDATE 1 ;

                                     NIL operation ;

                                     DIG 2 ;

                                     CONS ;

                                     DIG 2 ;

                                     CONS ;

                                     DIG 2 ;

                                     CONS ;

                                     PAIR } } } }

                       { DUP 2 ;

                         GET 13 ;

                         SENDER ;

                         COMPARE ;

                         NEQ ;

                         IF

                           { DROP 2 ; PUSH nat 26 ; FAILWITH }

                           { UPDATE 23 ; NIL operation ; PAIR } } } } }

           { IF_LEFT

               { DIG 2 ;

                 DIG 3 ;

                 DROP 2 ;

                 IF_LEFT

                   { DUP 2 ;

                     GET 13 ;

                     SENDER ;

                     COMPARE ;

                     NEQ ;

                     IF

                       { DROP 2 ; PUSH nat 26 ; FAILWITH }

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

                   { PUSH address "tz1Ke2h7sDdakHJQh8WX4Z372du1KChsksyU" ;

                     DUP 3 ;

                     GET 19 ;

                     COMPARE ;

                     NEQ ;

                     IF

                       { DROP 2 ; PUSH nat 24 ; FAILWITH }

                       { UPDATE 19 ; NIL operation ; PAIR } } }

               { IF_LEFT

                   { DIG 2 ;

                     DIG 3 ;

                     DROP 2 ;

                     DUP 2 ;

                     GET 13 ;

                     SENDER ;

                     COMPARE ;

                     NEQ ;

                     IF

                       { DROP 2 ; PUSH nat 26 ; FAILWITH }

                       { UPDATE 21 ; NIL operation ; PAIR } }

                   { UNPAIR 4 ;

                     DIG 3 ;

                     NOW ;

                     COMPARE ;

                     GE ;

                     IF

                       { DROP 6 ; PUSH nat 3 ; FAILWITH }

                       { DUP 4 ;

                         GET 5 ;

                         DUP 5 ;

                         GET 11 ;

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

                         CDR ;

                         DUP 2 ;

                         DUP 7 ;

                         GET 24 ;

                         CAR ;

                         MUL ;

                         EDIV ;

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

                         CAR ;

                         DIG 4 ;

                         DUP 2 ;

                         COMPARE ;

                         LT ;

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

                         PUSH int 2 ;

                         DUP 2 ;

                         DIG 3 ;

                         SUB ;

                         EDIV ;

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

                         CAR ;

                         ISNAT ;

                         IF_NONE { PUSH nat 1 ; FAILWITH } {} ;

                         PUSH mutez 1 ;

                         DUP 3 ;

                         MUL ;

                         PUSH mutez 1 ;

                         DUP 3 ;

                         MUL ;

                         DUP 6 ;

                         SELF_ADDRESS ;

                         SENDER ;

                         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 ;

                         CONTRACT unit ;

                         IF_NONE { PUSH nat 35 ; FAILWITH } {} ;

                         DUP 8 ;

                         GET 21 ;

                         CONTRACT unit ;

                         IF_NONE { PUSH nat 35 ; FAILWITH } {} ;

                         SWAP ;

                         DIG 4 ;

                         UNIT ;

                         TRANSFER_TOKENS ;

                         SWAP ;

                         DIG 3 ;

                         UNIT ;

                         TRANSFER_TOKENS ;

                         DIG 3 ;

                         DIG 4 ;

                         ADD ;