{ parameter (or

              (or

                (or

                  (or

                    (or (unit %acceptAdminProposal)

                        (pair %addLiquidity (address %owner)

                                            (pair (nat %minLqtMinted)

                                                  (pair (nat %maxTokensDeposited)

                                                        (timestamp %deadline)))))

                    (or

                      (pair %addLiquidityInternal

                        (pair (address %owner)

                              (pair (nat %minLqtMinted)

                                    (pair (nat %maxTokensDeposited)

                                          (timestamp %deadline))))

                        address)

                      (pair %cashToToken (address %to)

                                         (pair (nat %minTokensBought)

                                               (timestamp %deadline)))))

                  (or

                    (or

                      (pair %cashToTokenInternal

                        (pair (address %to)

                              (pair (nat %minTokensBought) (timestamp %deadline)))

                        address)

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

                    (or (unit %default) (contract %fetchLqtTokenPriceInCash nat))))

                (or

                  (or

                    (or (contract %fetchLqtTokenPriceInToken nat)

                        (pair %fetchLqtTokenPriceInternal (contract nat)

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

                    (or (address %proposeNewAdmin)

                        (pair %removeLiquidity (address %to)

                                               (pair (nat %lqtBurned)

                                                     (pair (nat %minCashWithdrawn)

                                                           (pair

                                                             (nat %minTokensWithdrawn)

                                                             (timestamp %deadline)))))))

                  (or

                    (or

                      (pair %removeLiquidityInternal

                        (pair (address %to)

                              (pair (nat %lqtBurned)

                                    (pair (nat %minCashWithdrawn)

                                          (pair (nat %minTokensWithdrawn)

                                                (timestamp %deadline)))))

                        address)

                      (option %setDelegate key_hash))

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

              (or

                (or

                  (pair %tokenToCash (address %to)

                                     (pair (nat %tokensSold)

                                           (pair (nat %minCashBought)

                                                 (timestamp %deadline))))

                  (pair %tokenToCashInternal

                    (pair (address %to)

                          (pair (nat %tokensSold)

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

                    address))

                (or (unit %updatePools)

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

  storage (pair (address %tokenAddress)

                (pair (nat %tokenId)

                      (pair (nat %tokenPool)

                            (pair (nat %tokenMultiplier)

                                  (pair (nat %cashPool)

                                        (pair (nat %cashMultiplier)

                                              (pair (address %admin)

                                                    (pair (address %proposedAdmin)

                                                          (pair (nat %lqtTotal)

                                                                (pair

                                                                  (address %lqtAddress)

                                                                  (pair

                                                                    (address %rewardRecipient)

                                                                    (pair

                                                                      (nat %pendingPoolUpdates)

                                                                      (pair

                                                                        (pair %feeRatio

                                                                          (nat %numerator)

                                                                          (nat %denominator))

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

  code { LAMBDA

           (pair nat nat)

           (pair nat nat)

           { UNPAIR ;

             DUP 2 ;

             DUP 2 ;

             ADD ;

             DUG 2 ;

             SUB ;

             DUP 2 ;

             DUP 3 ;

             MUL ;

             DUP ;

             MUL ;

             DUP ;

             MUL ;

             DIG 2 ;

             DUP 2 ;

             EDIV ;

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

             CAR ;

             DUP 3 ;

             DUP 4 ;

             MUL ;

             DUP ;

             MUL ;

             DUP ;

             MUL ;

             PUSH int 0 ;

             DUP 5 ;

             COMPARE ;

             EQ ;

             IF

               { DIG 3 ; DROP ; PUSH int 0 }

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

             SWAP ;

             DIG 3 ;

             SUB ;

             ISNAT ;

             IF_NONE { PUSH nat 2 ; FAILWITH } {} ;

             DUG 2 ;

             ADD ;

             ISNAT ;

             IF_NONE { PUSH nat 2 ; FAILWITH } {} ;

             PUSH nat 8 ;

             MUL ;

             SWAP ;

             PAIR } ;

         LAMBDA

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

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

           nat

           { UNPAIR ;

             SWAP ;

             LEFT nat ;

             LOOP_LEFT { PUSH int 0 ;

                         DUP 2 ;

                         CAR ;

                         CDR ;

                         CAR ;

                         COMPARE ;

                         EQ ;

                         IF

                           { CAR ;

                             CAR ;

                             CDR ;

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

                                         (pair nat nat)) }

                           { DUP ;

                             CAR ;

                             CAR ;

                             CDR ;

                             DUP 2 ;

                             CDR ;

                             CDR ;

                             SUB ;

                             ISNAT ;

                             IF_NONE { PUSH nat 2 ; FAILWITH } {} ;

                             DUP 2 ;

                             CAR ;

                             CAR ;

                             CAR ;

                             DUP 3 ;

                             CDR ;

                             CAR ;

                             ADD ;

                             PAIR ;

                             DUP 3 ;

                             SWAP ;

                             EXEC ;

                             UNPAIR ;

                             DUP 3 ;

                             CAR ;

                             CDR ;

                             CDR ;

                             SWAP ;

                             SUB ;

                             ISNAT ;

                             IF_NONE

                               { DROP ; PUSH nat 2 ; FAILWITH }

                               { EDIV ;

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

                                 CAR ;

                                 DUP 2 ;

                                 CAR ;

                                 CAR ;

                                 CDR ;

                                 ADD } ;

                             DUP 2 ;

                             CDR ;

                             DUP 3 ;

                             CAR ;

                             CDR ;

                             DIG 2 ;

                             DUP 4 ;

                             CAR ;

                             CAR ;

                             CAR ;

                             PAIR ;

                             PAIR ;

                             PAIR ;

                             DUP ;

                             CDR ;

                             DUP 2 ;

                             CAR ;

                             CDR ;

                             CDR ;

                             PUSH int 1 ;

                             DIG 4 ;

                             CAR ;

                             CDR ;

                             CAR ;

                             SUB ;

                             PAIR ;

                             DIG 2 ;

                             CAR ;

                             CAR ;

                             PAIR ;

                             PAIR ;

                             LEFT nat } } ;

             SWAP ;

             DROP } ;

         DUP 2 ;

         APPLY ;

         DIG 2 ;

         UNPAIR ;

         IF_LEFT

           { IF_LEFT

               { IF_LEFT

                   { DIG 2 ;

                     DIG 3 ;

                     DROP 2 ;

                     IF_LEFT

                       { IF_LEFT

                           { DROP ;

                             DUP ;

                             GET 15 ;

                             SENDER ;

                             COMPARE ;

                             NEQ ;

                             IF

                               { DROP ; PUSH nat 27 ; FAILWITH }

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

                           { SELF %updatePools ;

                             SELF %addLiquidityInternal ;

                             SWAP ;

                             PUSH mutez 0 ;

                             UNIT ;

                             TRANSFER_TOKENS ;

                             SENDER ;

                             DIG 3 ;

                             PAIR ;

                             AMOUNT ;

                             DIG 3 ;

                             SWAP ;

                             DIG 2 ;

                             TRANSFER_TOKENS ;

                             DIG 2 ;

                             NIL operation ;

                             DIG 2 ;

                             CONS ;

                             DIG 2 ;

                             CONS ;

                             PAIR } }

                       { IF_LEFT

                           { UNPAIR ;

                             UNPAIR 4 ;

                             AMOUNT ;

                             PUSH mutez 1 ;

                             SWAP ;

                             EDIV ;

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

                             CAR ;

                             PUSH nat 0 ;

                             DUP 8 ;

                             GET 23 ;

                             COMPARE ;

                             GT ;

                             IF

                               { DROP 7 ; PUSH nat 6 ; FAILWITH }

                               { DIG 4 ;

                                 NOW ;

                                 COMPARE ;

                                 GE ;

                                 IF

                                   { DROP 6 ; PUSH nat 3 ; FAILWITH }

                                   { SELF_ADDRESS ;

                                     SENDER ;

                                     COMPARE ;

                                     NEQ ;

                                     IF

                                       { DROP 6 ; PUSH nat 36 ; FAILWITH }

                                       { DUP ;

                                         DUP 7 ;

                                         GET 9 ;

                                         SUB ;

                                         ISNAT ;

                                         IF_NONE { PUSH nat 2 ; FAILWITH } {} ;

                                         DUP ;

                                         DUP 8 ;

                                         GET 17 ;

                                         DUP 4 ;

                                         MUL ;

                                         EDIV ;

                                         IF_NONE

                                           { PUSH string "DIV by 0" ; FAILWITH }

                                           {} ;

                                         CAR ;

                                         SWAP ;

                                         DUP 8 ;

                                         GET 5 ;

                                         DIG 3 ;

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

                                                 ADD ;

                                                 UPDATE 17 ;

                                                 DUP 2 ;

                                                 DIG 6 ;

                                                 GET 5 ;

                                                 ADD ;

                                                 UPDATE 5 ;

                                                 SWAP ;

                                                 SELF_ADDRESS ;

                                                 DIG 5 ;

                                                 DUP 4 ;

                                                 DUP ;

                                                 CAR ;

                                                 CONTRACT %transfer (list (pair address

                                                                               (list (pair

                                                                                      address

                                                                                      (pair

                                                                                        nat

                                                                                        nat))))) ;

                                                 IF_NONE { PUSH nat 0 ; FAILWITH } {} ;

                                                 PUSH mutez 0 ;

                                                 NIL (pair address

                                                           (list (pair address

                                                                      (pair nat nat)))) ;

                                                 NIL (pair address (pair nat nat)) ;

                                                 DIG 7 ;

                                                 DIG 5 ;

                                                 GET 3 ;

                                                 PAIR ;

                                                 DIG 6 ;

                                                 PAIR ;

                                                 CONS ;

                                                 DIG 4 ;

                                                 PAIR ;

                                                 CONS ;

                                                 TRANSFER_TOKENS ;

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

                           { SELF %updatePools ;

                             SELF %cashToTokenInternal ;

                             SWAP ;

                             PUSH mutez 0 ;

                             UNIT ;

                             TRANSFER_TOKENS ;

                             SENDER ;

                             DIG 3 ;

                             PAIR ;

                             AMOUNT ;

                             DIG 3 ;

                             SWAP ;

                             DIG 2 ;

                             TRANSFER_TOKENS ;

                             DIG 2 ;

                             NIL operation ;

                             DIG 2 ;

                             CONS ;

                             DIG 2 ;

                             CONS ;

                             PAIR } } }

                   { IF_LEFT

                       { IF_LEFT

                           { CAR ;

                             UNPAIR 3 ;

                             AMOUNT ;

                             PUSH mutez 1 ;

                             SWAP ;

                             EDIV ;

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

                             CAR ;

                             PUSH nat 0 ;

                             DUP 6 ;

                             GET 23 ;

                             COMPARE ;

                             GT ;

                             IF

                               { DROP 7 ; PUSH nat 6 ; FAILWITH }

                               { DIG 3 ;

                                 NOW ;

                                 COMPARE ;

                                 GE ;

                                 IF

                                   { DROP 6 ; PUSH nat 3 ; FAILWITH }

                                   { SELF_ADDRESS ;

                                     SENDER ;

                                     COMPARE ;

                                     NEQ ;

                                     IF

                                       { DROP 6 ; PUSH nat 36 ; FAILWITH }

                                       { DUP ;

                                         DUP 5 ;

                                         GET 9 ;

                                         SUB ;

                                         ISNAT ;

                                         IF_NONE { PUSH nat 2 ; FAILWITH } {} ;

                                         DUP 5 ;

                                         GET 26 ;

                                         UNIT ;

                                         VIEW "get_token_price_in_cash" nat ;

                                         IF_NONE { PUSH nat 37 ; FAILWITH } {} ;

                                         PUSH nat 1000000 ;

                                         DUP 7 ;

                                         GET 11 ;

                                         MUL ;

                                         SWAP ;

                                         DUP 7 ;

                                         GET 7 ;

                                         MUL ;

                                         DUP 2 ;

                                         DIG 3 ;

                                         MUL ;

                                         DUP 2 ;

                                         DUP 8 ;

                                         GET 5 ;

                                         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 ;

                                         DIG 5 ;

                                         MUL ;

                                         PAIR ;

                                         PAIR ;

                                         PAIR ;

                                         DIG 5 ;

                                         SWAP ;

                                         EXEC ;

                                         EDIV ;

                                         IF_NONE

                                           { PUSH string "DIV by 0" ; FAILWITH }

                                           {} ;

                                         CAR ;

                                         DUP 4 ;

                                         GET 25 ;

                                         CDR ;

                                         DUP 2 ;

                                         DUP 6 ;

                                         GET 25 ;

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

                                         GET 5 ;

                                         SUB ;

                                         ISNAT ;

                                         IF_NONE { PUSH nat 19 ; FAILWITH } {} ;

                                         DIG 4 ;

                                         SWAP ;

                                         UPDATE 5 ;

                                         DIG 2 ;

                                         DIG 3 ;

                                         SELF_ADDRESS ;

                                         DUP 4 ;

                                         DUP ;

                                         CAR ;

                                         CONTRACT %transfer (list (pair address

                                                                       (list (pair

                                                                              address

                                                                              (pair nat

                                                                                    nat))))) ;

                                         IF_NONE { PUSH nat 0 ; FAILWITH } {} ;

                                         PUSH mutez 0 ;

                                         NIL (pair address

                                                   (list (pair address (pair nat nat)))) ;

                                         NIL (pair address (pair nat nat)) ;

                                         DIG 7 ;

                                         DIG 5 ;

                                         GET 3 ;

                                         PAIR ;

                                         DIG 6 ;

                                         PAIR ;

                                         CONS ;

                                         DIG 4 ;

                                         PAIR ;

                                         CONS ;

                                         TRANSFER_TOKENS ;

                                         DIG 2 ;

                                         DUP 3 ;

                                         GET 21 ;

                                         SELF_ADDRESS ;

                                         DUP 5 ;

                                         DUP ;

                                         CAR ;

                                         CONTRACT %transfer (list (pair address

                                                                       (list (pair

                                                                              address

                                                                              (pair nat

                                                                                    nat))))) ;

                                         IF_NONE { PUSH nat 0 ; FAILWITH } {} ;

                                         PUSH mutez 0 ;

                                         NIL (pair address

                                                   (list (pair address (pair nat nat)))) ;

                                         NIL (pair address (pair nat nat)) ;

                                         DIG 7 ;

                                         DIG 5 ;

                                         GET 3 ;

                                         PAIR ;

                                         DIG 6 ;

                                         PAIR ;

                                         CONS ;

                                         DIG 4 ;

                                         PAIR ;

                                         CONS ;

                                         TRANSFER_TOKENS ;

                                         DIG 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 25 ; NIL operation ; PAIR } } }

                       { DIG 2 ;

                         DIG 3 ;

                         DROP 2 ;

                         IF_LEFT

                           { DROP ; NIL operation ; PAIR }

                           { PUSH mutez 0 ;

                             AMOUNT ;

                             COMPARE ;

                             GT ;

                             IF

                               { DROP 2 ; PUSH nat 10 ; FAILWITH }

                               { SELF %updatePools ;

                                 SELF %fetchLqtTokenPriceInternal ;

                                 SWAP ;

                                 PUSH mutez 0 ;

                                 UNIT ;

                                 TRANSFER_TOKENS ;

                                 SWAP ;

                                 PUSH mutez 0 ;

                                 UNIT ;

                                 LEFT unit ;

                                 DIG 4 ;

                                 PAIR ;

                                 TRANSFER_TOKENS ;

                                 DIG 2 ;

                                 NIL operation ;

                                 DIG 2 ;

                                 CONS ;

                                 DIG 2 ;

                                 CONS ;

                                 PAIR } } } } }

               { DIG 2 ;

                 DIG 3 ;

                 DROP 2 ;

                 IF_LEFT

                   { IF_LEFT

                       { IF_LEFT

                           { PUSH mutez 0 ;

                             AMOUNT ;

                             COMPARE ;

                             GT ;

                             IF

                               { DROP 2 ; PUSH nat 10 ; FAILWITH }

                               { SELF %updatePools ;

                                 SELF %fetchLqtTokenPriceInternal ;

                                 SWAP ;

                                 PUSH mutez 0 ;

                                 UNIT ;

                                 TRANSFER_TOKENS ;

                                 SWAP ;

                                 PUSH mutez 0 ;

                                 UNIT ;

                                 RIGHT unit ;

                                 DIG 4 ;

                                 PAIR ;

                                 TRANSFER_TOKENS ;

                                 DIG 2 ;

                                 NIL operation ;

                                 DIG 2 ;

                                 CONS ;

                                 DIG 2 ;

                                 CONS ;

                                 PAIR } }

                           { UNPAIR ;

                             SELF_ADDRESS ;

                             SENDER ;

                             COMPARE ;

                             NEQ ;

                             IF

                               { DROP 3 ; PUSH nat 36 ; FAILWITH }

                               { SWAP ;

                                 IF_LEFT

                                   { DROP ;

                                     DUP 2 ;

                                     GET 26 ;

                                     UNIT ;

                                     VIEW "get_token_price_in_cash" nat ;

                                     IF_NONE { PUSH nat 37 ; FAILWITH } {} ;

                                     DUP 3 ;

                                     GET 7 ;

                                     DUP 4 ;

                                     GET 5 ;

                                     MUL ;

                                     MUL ;

                                     PUSH nat 1000000 ;

                                     DUP 4 ;

                                     GET 11 ;

                                     DUP 5 ;

                                     GET 9 ;

                                     MUL ;

                                     MUL ;

                                     DUP 4 ;

                                     GET 17 ;

                                     SWAP ;

                                     DIG 2 ;

                                     ADD ;

                                     SWAP ;

                                     INT ;

                                     SWAP ;

                                     NEG ;

                                     EDIV ;

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

                                     CAR }

                                   { DROP ;

                                     DUP 2 ;

                                     GET 26 ;

                                     UNIT ;

                                     VIEW "get_cash_price_in_token" nat ;

                                     IF_NONE { PUSH nat 37 ; FAILWITH } {} ;

                                     PUSH nat 1000000 ;

                                     DUP 4 ;

                                     GET 7 ;

                                     DUP 5 ;

                                     GET 5 ;

                                     MUL ;

                                     MUL ;

                                     SWAP ;

                                     DUP 4 ;

                                     GET 11 ;

                                     DUP 5 ;

                                     GET 9 ;

                                     MUL ;

                                     MUL ;

                                     DUP 4 ;

                                     GET 17 ;

                                     SWAP ;

                                     DIG 2 ;

                                     ADD ;

                                     SWAP ;

                                     INT ;

                                     SWAP ;

                                     NEG ;

                                     EDIV ;

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

                                     CAR } ;

                                 ABS ;

                                 SWAP ;

                                 PUSH mutez 0 ;

                                 DIG 2 ;

                                 TRANSFER_TOKENS ;

                                 SWAP ;

                                 NIL operation ;

                                 DIG 2 ;

                                 CONS ;

                                 PAIR } } }

                       { IF_LEFT

                           { DUP 2 ;

                             GET 13 ;

                             SENDER ;

                             COMPARE ;

                             NEQ ;

                             IF

                               { DROP 2 ; PUSH nat 26 ; FAILWITH }

                               { UPDATE 15 ; NIL operation ; PAIR } }

                           { PUSH mutez 0 ;

                             AMOUNT ;

                             COMPARE ;

                             GT ;

                             IF

                               { DROP 2 ; PUSH nat 10 ; FAILWITH }

                               { SELF %updatePools ;

                                 SELF %removeLiquidityInternal ;

                                 SWAP ;

                                 PUSH mutez 0 ;

                                 UNIT ;

                                 TRANSFER_TOKENS ;

                                 SENDER ;

                                 DIG 3 ;

                                 PAIR ;

                                 DIG 2 ;

                                 PUSH mutez 0 ;

                                 DIG 2 ;

                                 TRANSFER_TOKENS ;

                                 DIG 2 ;

                                 NIL operation ;

                                 DIG 2 ;

                                 CONS ;

                                 DIG 2 ;

                                 CONS ;

                                 PAIR } } } }

                   { IF_LEFT

                       { IF_LEFT

                           { UNPAIR ;

                             UNPAIR 5 ;

                             PUSH nat 0 ;

                             DUP 8 ;

                             GET 23 ;

                             COMPARE ;

                             GT ;

                             IF

                               { DROP 7 ; PUSH nat 6 ; FAILWITH }