{ parameter (or (or (contract %get_price nat) (unit %internal_observe_price))

                (or (unit %observe_price) (pair %set_reserves nat nat))) ;

  storage (pair

            (pair

              (pair (address %dex_contract)

                    (pair (nat %fee_denominator) (nat %fee_numerator)))

              (pair (nat %max_observation_age)

                    (pair (nat %median_price) (nat %min_obeservation_age))))

            (pair

              (pair (map %prices timestamp nat)

                    (pair (nat %required_observation_count) (nat %tmp_price)))

              (pair (pair (address %token_1_address) (nat %token_1_id))

                    (pair (address %token_2_address) (nat %token_2_id))))) ;

  code { LAMBDA

           unit

           unit

           { DROP ; SELF_ADDRESS ; SENDER ; COMPARE ; EQ ; IF {} { PUSH int 400 ; FAILWITH } ; UNIT } ;

         SWAP ;

         UNPAIR ;

         IF_LEFT

           { IF_LEFT

               { DIG 2 ;

                 DROP ;

                 NIL operation ;

                 SWAP ;

                 PUSH mutez 0 ;

                 SELF_ADDRESS ;

                 UNIT ;

                 VIEW "view_price" nat ;

                 IF_NONE { PUSH int 502 ; FAILWITH } {} ;

                 TRANSFER_TOKENS ;

                 CONS }

               { DUP 3 ;

                 UNIT ;

                 EXEC ;

                 NIL timestamp ;

                 DUP 4 ;

                 GET 3 ;

                 CAR ;

                 ITER { CAR ; CONS } ;

                 NIL timestamp ;

                 SWAP ;

                 ITER { CONS } ;

                 NIL timestamp ;

                 SWAP ;

                 ITER { CONS } ;

                 IF_CONS

                   { SWAP ;

                     DROP ;

                     NOW ;

                     DUP 5 ;

                     CAR ;

                     GET 6 ;

                     INT ;

                     DIG 2 ;

                     ADD ;

                     COMPARE ;

                     LT ;

                     IF {} { PUSH int 903 ; FAILWITH } }

                   {} ;

                 DUP 3 ;

                 UNPAIR ;

                 SWAP ;

                 UNPAIR ;

                 UNPAIR ;

                 DIG 6 ;

                 GET 3 ;

                 GET 4 ;

                 SOME ;

                 NOW ;

                 UPDATE ;

                 PAIR ;

                 PAIR ;

                 SWAP ;

                 PAIR ;

                 DUG 2 ;

                 EMPTY_MAP nat nat ;

                 DUP 4 ;

                 GET 3 ;

                 CAR ;

                 ITER { NOW ;

                        DUP 6 ;

                        CAR ;

                        GET 3 ;

                        INT ;

                        DUP 3 ;

                        CAR ;

                        ADD ;

                        COMPARE ;

                        GT ;

                        IF

                          { SWAP ;

                            DUP ;

                            DUG 2 ;

                            SWAP ;

                            DUP ;

                            DUG 2 ;

                            CDR ;

                            MEM ;

                            IF

                              {}

                              { SWAP ; PUSH (option nat) (Some 0) ; DUP 3 ; CDR ; UPDATE ; SWAP } ;

                            SWAP ;

                            DUP ;

                            DIG 2 ;

                            CDR ;

                            DUP ;

                            DUG 2 ;

                            GET ;

                            IF_NONE { PUSH int 98 ; FAILWITH } {} ;

                            PUSH nat 1 ;

                            ADD ;

                            SOME ;

                            SWAP ;

                            UPDATE }

                          { DIG 4 ;

                            UNPAIR ;

                            SWAP ;

                            UNPAIR ;

                            UNPAIR ;

                            NONE nat ;

                            DIG 5 ;

                            CAR ;

                            UPDATE ;

                            PAIR ;

                            PAIR ;

                            SWAP ;

                            PAIR ;

                            DUG 3 } } ;

                 PUSH nat 0 ;

                 PUSH nat 0 ;

                 DUP 6 ;

                 GET 3 ;

                 CAR ;

                 SIZE ;

                 DUP 4 ;

                 ITER { PUSH nat 2 ;

                        DUP 3 ;

                        EDIV ;

                        IF_NONE { PUSH int 107 ; FAILWITH } { CAR } ;

                        DUP 4 ;

                        COMPARE ;

                        LE ;

                        IF

                          { DIG 3 ; DROP ; DUP ; CAR ; DUG 3 ; CDR ; DIG 2 ; ADD ; SWAP }

                          { DROP } } ;

                 SWAP ;

                 DROP ;

                 DUP 6 ;

                 GET 3 ;

                 GET 3 ;

                 SWAP ;

                 COMPARE ;

                 GE ;

                 IF

                   { SWAP ;

                     DROP ;

                     SWAP ;

                     DROP ;

                     SWAP ;

                     DROP ;

                     DIG 2 ;

                     DROP ;

                     SWAP ;

                     UNPAIR ;

                     UNPAIR ;

                     SWAP ;

                     UNPAIR ;

                     SWAP ;

                     CDR ;

                     DIG 4 ;

                     PAIR ;

                     SWAP ;

                     PAIR ;

                     SWAP ;

                     PAIR ;

                     PAIR }

                   { DROP 4 ;

                     SWAP ;

                     DROP ;

                     UNPAIR ;

                     UNPAIR ;

                     SWAP ;

                     UNPAIR ;

                     SWAP ;

                     CDR ;

                     PUSH nat 0 ;

                     PAIR ;

                     SWAP ;

                     PAIR ;

                     SWAP ;

                     PAIR ;

                     PAIR } ;

                 NIL operation } }

           { IF_LEFT

               { DROP ;

                 SWAP ;

                 DROP ;

                 DUP ;

                 CAR ;

                 CAR ;

                 CAR ;

                 CONTRACT %getReserveBalance (pair

                                               (pair (pair address nat)

                                                     (pair address nat))

                                               (contract (pair nat nat))) ;

                 IF_NONE { PUSH int 75 ; FAILWITH } {} ;

                 NIL operation ;

                 SWAP ;

                 PUSH mutez 0 ;

                 SELF_ADDRESS ;

                 CONTRACT %set_reserves (pair nat nat) ;

                 IF_NONE { PUSH int 76 ; FAILWITH } {} ;

                 DIG 4 ;

                 DUP ;

                 GET 8 ;

                 SWAP ;

                 DUP ;

                 DUG 6 ;

                 GET 7 ;

                 PAIR ;

                 DIG 5 ;

                 DUP ;

                 GET 5 ;

                 CDR ;

                 SWAP ;

                 DUP ;

                 DUG 7 ;

                 GET 5 ;

                 CAR ;

                 PAIR ;

                 PAIR ;

                 PAIR ;

                 TRANSFER_TOKENS ;

                 CONS ;

                 SELF %internal_observe_price ;

                 PUSH mutez 0 ;

                 UNIT ;

                 TRANSFER_TOKENS ;

                 CONS }

               { DIG 2 ;

                 DROP ;

                 SWAP ;

                 UNPAIR ;

                 SWAP ;

                 UNPAIR ;

                 UNPAIR ;

                 SWAP ;

                 CAR ;

                 DUP 5 ;

                 CAR ;

                 PUSH nat 1000000 ;

                 DIG 6 ;

                 CDR ;

                 MUL ;

                 EDIV ;

                 IF_NONE { PUSH int 68 ; FAILWITH } { CAR } ;

                 SWAP ;

                 PAIR ;

                 SWAP ;

                 PAIR ;

                 PAIR ;

                 SWAP ;

                 PAIR ;

                 NIL operation } } ;

         NIL operation ;

         SWAP ;

         ITER { CONS } ;

         PAIR } ;

  view "get_min_out" nat nat

        { UNPAIR ;

          PUSH nat 1000000 ;

          DUP 3 ;

          CAR ;

          CAR ;

          GET 3 ;

          MUL ;

          DIG 2 ;

          CAR ;

          CAR ;

          GET 4 ;

          SELF_ADDRESS ;

          UNIT ;

          VIEW "view_price" nat ;

          IF_NONE { PUSH int 502 ; FAILWITH } {} ;

          DIG 3 ;

          MUL ;

          MUL ;

          EDIV ;

          IF_NONE { PUSH int 137 ; FAILWITH } { CAR } } ;

  view "view_price" unit nat

        { CDR ; DUP ; CAR ; GET 5 ; PUSH nat 0 ; COMPARE ; NEQ ; IF {} { PUSH int 501 ; FAILWITH } ; CAR ; GET 5 } }