parameter (or

            (or

              (or

                (or

                  (or %call_fa2

                    (pair %balance_of

                      (list %requests (pair (address %owner) (nat %token_id)))

                      (contract %callback (list (pair

                                                (pair %request (address %owner)

                                                               (nat %token_id))

                                                (nat %balance)))))

                    (or

                      (list %transfer (pair (address %from_)

                                           (list %txs (pair (address %to_)

                                                           (nat %token_id)

                                                           (nat %amount)))))

                      (list %update_operators (or

                                               (pair %add_operator (address %owner)

                                                                   (address %operator)

                                                                   (nat %token_id))

                                               (pair %remove_operator (address %owner)

                                                                      (address %operator)

                                                                      (nat %token_id))))))

                  (address %claim_dev_fee))

                (or

                  (pair %get_position_info (nat %position_id)

                                           (contract %callback (pair

                                                                (pair (nat %liquidity)

                                                                      (int %lower_tick_index))

                                                                (address %owner)

                                                                (int %upper_tick_index))))

                  (nat %increase_observation_count)))

              (or

                (or

                  (pair %observe (list %times timestamp)

                                 (contract %callback (list (pair

                                                           (nat %seconds_per_liquidity_cumulative)

                                                           (int %tick_cumulative)))))

                  (pair %set_position (int %lower_tick_index) (int %upper_tick_index)

                                      (int %lower_tick_witness)

                                      (int %upper_tick_witness)

                                      (nat %liquidity)

                                      (timestamp %deadline)

                                      (pair %maximum_tokens_contributed (nat %x)

                                                                        (nat %y))

                                      (option %referral_code nat)))

                (or

                  (pair %snapshot_cumulatives_inside

                    (pair

                      (contract %callback (pair

                                           (pair (int %seconds_inside)

                                                 (int %seconds_per_liquidity_inside))

                                           (int %tick_cumulative_inside)))

                      (int %lower_tick_index))

                    (int %upper_tick_index))

                  (pair %update_position (nat %position_id) (int %liquidity_delta)

                                         (address %to_x)

                                         (address %to_y)

                                         (timestamp %deadline)

                                         (pair %maximum_tokens_contributed (int %x)

                                                                           (int %y))

                                         (option %referral_code nat)))))

            (or

              (pair %x_to_y (nat %dx) (timestamp %deadline) (nat %min_dy)

                            (address %to_dy)

                            (option %referral_code nat))

              (pair %y_to_x (nat %dy) (timestamp %deadline) (nat %min_dx)

                            (address %to_dx)

                            (option %referral_code nat))));

storage (pair

          (pair

            (pair

              (pair

                (pair %constants

                  (pair (pair (address %factory_address) (nat %fee_bps))

                        (nat %tick_spacing)

                        (or %token_x (address %fa12)

                                     (pair %fa2 (nat %token_id) (address %token_address))))

                  (or %token_y (address %fa12)

                               (pair %fa2 (nat %token_id) (address %token_address))))

                (pair %cumulatives_buffer (pair (nat %first) (nat %last))

                                          (big_map %map nat

                                                        (pair

                                                          (pair

                                                            (pair %spl

                                                              (nat %block_start_liquidity_value)

                                                              (nat %sum))

                                                            (pair %tick

                                                              (int %block_start_value)

                                                              (int %sum)))

                                                          (timestamp %time)))

                                          (nat %reserved_length)))

              (int %cur_tick_index)

              (int %cur_tick_witness))

            (pair (pair %dev_fee (nat %x) (nat %y)) (pair %fee_growth (nat %x) (nat %y)))

            (big_map %ladder (pair (nat %exp) (bool %positive))

                             (pair (int %offset) (nat %v)))

            (nat %liquidity))

          (pair (pair (big_map %metadata string bytes) (nat %new_position_id))

                (big_map %operators

                  (pair (address %owner) (address %operator) (nat %token_id))

                  unit)

                (big_map %position_ids address (set nat)))

          (pair

            (big_map %positions nat

                                (pair

                                  (pair

                                    (pair

                                      (pair %fee_growth_inside_last (int %x) (int %y))

                                      (nat %liquidity))

                                    (int %lower_tick_index)

                                    (address %owner))

                                  (int %upper_tick_index)))

            (nat %sqrt_price))

          (big_map %ticks int

                          (pair

                            (pair

                              (pair

                                (pair (pair %fee_growth_outside (nat %x) (nat %y))

                                      (int %liquidity_net))

                                (nat %n_positions)

                                (int %next))

                              (pair (int %prev) (nat %seconds_outside))

                              (nat %seconds_per_liquidity_outside)

                              (nat %sqrt_price))

                            (int %tick_cumulative_outside)))

          (big_map %token_metadata nat

                                   (pair (nat %token_id) (map %token_info string bytes))));

code { LAMBDA

         (pair nat nat)

         nat

         { UNPAIR ;

           SWAP ;

           INT ;

           SWAP ;

           NEG ;

           EDIV ;

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

           CAR ;

           ABS } ;

       LAMBDA

         (pair int int)

         int

         { UNPAIR ; NEG ; EDIV ; IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; CAR ; NEG } ;

       LAMBDA

         (pair nat nat)

         nat

         { UNPAIR ; EDIV ; IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; CAR } ;

       LAMBDA

         (pair int nat)

         nat

         { UNPAIR ; ISNAT ; IF_NONE { FAILWITH } { SWAP ; DROP } } ;

       LAMBDA

         (pair int (big_map (pair nat bool) (pair int nat)))

         nat

         { UNPAIR ;

           SWAP ;

           PUSH int 0 ;

           DUP 3 ;

           COMPARE ;

           GT ;

           PUSH nat 0 ;

           PAIR ;

           PAIR ;

           PUSH nat 1 ;

           PUSH int 0 ;

           PAIR ;

           DIG 2 ;

           ABS ;

           PAIR ;

           PAIR ;

           LEFT (pair int nat) ;

           LOOP_LEFT { UNPAIR ;

                       UNPAIR ;

                       DIG 2 ;

                       UNPAIR ;

                       PUSH nat 0 ;

                       DUP 4 ;

                       COMPARE ;

                       EQ ;

                       IF

                         { DROP 3 ;

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

                                       (big_map (pair nat bool) (pair int nat))) }

                         { PUSH nat 2 ;

                           DIG 3 ;

                           EDIV ;

                           IF_NONE { PUSH nat 300 ; FAILWITH } {} ;

                           UNPAIR ;

                           DUP 4 ;

                           DUP 4 ;

                           GET ;

                           IF_NONE { PUSH nat 102 ; FAILWITH } {} ;

                           PUSH nat 0 ;

                           DIG 3 ;

                           COMPARE ;

                           EQ ;

                           IF

                             { DROP ; DIG 3 }

                             { DUP 5 ; CDR ; DUP 2 ; CDR ; MUL ; DIG 5 ; CAR ; DIG 2 ; CAR ; ADD ; PAIR } ;

                           DUP 3 ;

                           CDR ;

                           PUSH nat 1 ;

                           DIG 4 ;

                           CAR ;

                           ADD ;

                           PAIR ;

                           DIG 3 ;

                           SWAP ;

                           PAIR ;

                           SWAP ;

                           DIG 2 ;

                           PAIR ;

                           PAIR ;

                           LEFT (pair int nat) } } ;

           DUP ;

           CAR ;

           PUSH int 80 ;

           NEG ;

           SUB ;

           PUSH int 0 ;

           DUP 2 ;

           COMPARE ;

           GT ;

           IF

             { ABS ;

               SWAP ;

               CDR ;

               PAIR ;

               LEFT nat ;

               LOOP_LEFT { UNPAIR ;

                           PUSH nat 256 ;

                           DUP ;

                           DUP 4 ;

                           COMPARE ;

                           LE ;

                           IF

                             { DROP ; LSR ; RIGHT (pair nat nat) }

                             { DUP ; DIG 2 ; LSR ; SWAP ; DIG 2 ; SUB ; ABS ; SWAP ; PAIR ; LEFT nat } } }

             { ABS ;

               SWAP ;

               CDR ;

               PAIR ;

               LEFT nat ;

               LOOP_LEFT { UNPAIR ;

                           PUSH nat 256 ;

                           DUP ;

                           DUP 4 ;

                           COMPARE ;

                           LE ;

                           IF

                             { DROP ; LSL ; RIGHT (pair nat nat) }

                             { DUP ; DIG 2 ; LSL ; SWAP ; DIG 2 ; SUB ; ABS ; SWAP ; PAIR ; LEFT nat } } } } ;

       LAMBDA

         (pair address address nat (or address (pair nat address)))

         operation

         { UNPAIR 4 ;

           DIG 3 ;

           IF_LEFT

             { CONTRACT %transfer (pair address address nat) ;

               IF_NONE { PUSH nat 200 ; FAILWITH } {} ;

               PUSH mutez 0 ;

               DIG 4 ;

               DIG 4 ;

               PAIR ;

               DIG 3 ;

               PAIR ;

               TRANSFER_TOKENS }

             { DUP ;

               CDR ;

               CONTRACT %transfer (list (pair (address %from_)

                                             (list %txs (pair (address %to_)

                                                             (nat %token_id)

                                                             (nat %amount))))) ;

               IF_NONE { PUSH nat 200 ; FAILWITH } {} ;

               PUSH mutez 0 ;

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

               NIL (pair address nat nat) ;

               DIG 7 ;

               DIG 5 ;

               CAR ;

               DIG 7 ;

               PAIR 3 ;

               CONS ;

               DIG 4 ;

               PAIR ;

               CONS ;

               TRANSFER_TOKENS } } ;

       LAMBDA

         (pair (lambda (pair int (big_map (pair nat bool) (pair int nat))) nat)

               (pair

                 (pair

                   (pair

                     (big_map int

                              (pair

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

                                      (pair int nat)

                                      nat

                                      nat)

                                int))

                     int)

                   int

                   int)

                 (pair (pair nat nat) nat)

                 nat

                 (big_map (pair nat bool) (pair int nat))))

         (big_map int

                  (pair

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

                          nat)

                    int))

         { UNPAIR ;

           SWAP ;

           LEFT (big_map int

                         (pair

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

                                 nat

                                 nat)

                           int)) ;

           LOOP_LEFT { UNPAIR ;

                       UNPAIR ;

                       UNPAIR ;

                       DIG 2 ;

                       UNPAIR ;

                       DIG 4 ;

                       UNPAIR ;

                       UNPAIR ;

                       DIG 2 ;

                       UNPAIR ;

                       DUP 7 ;

                       DUP 9 ;

                       MEM ;

                       IF

                         { SWAP ;

                           DIG 2 ;

                           DIG 3 ;

                           DIG 4 ;

                           DIG 5 ;

                           DIG 7 ;

                           DROP 7 ;

                           RIGHT (pair

                                   (pair

                                     (pair

                                       (big_map int

                                                (pair

                                                  (pair

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

                                                          int)

                                                    (pair int nat)

                                                    nat

                                                    nat)

                                                  int))

                                       int)

                                     int

                                     int)

                                   (pair (pair nat nat) nat)

                                   nat

                                   (big_map (pair nat bool) (pair int nat))) }

                         { DUP 8 ;

                           DUP 6 ;

                           COMPARE ;

                           GT ;

                           IF

                             { DROP 8 ; PUSH nat 100 ; FAILWITH }

                             { DUP 7 ;

                               DUP 6 ;

                               GET ;

                               IF_NONE { PUSH nat 105 ; FAILWITH } {} ;

                               DUP ;

                               CAR ;

                               CAR ;

                               CDR ;

                               CDR ;

                               DUP 10 ;

                               DUP 2 ;

                               COMPARE ;

                               GT ;

                               IF

                                 { DUP 9 ;

                                   DUP 2 ;

                                   GET ;

                                   IF_NONE { PUSH nat 301 ; FAILWITH } {} ;

                                   DIG 9 ;

                                   DUP 4 ;

                                   CDR ;

                                   DUP 5 ;

                                   CAR ;

                                   CDR ;

                                   DUP 13 ;

                                   DUP 7 ;

                                   CAR ;

                                   CAR ;

                                   CDR ;

                                   CAR ;

                                   PAIR ;

                                   DIG 6 ;

                                   CAR ;

                                   CAR ;

                                   CAR ;

                                   PAIR ;

                                   PAIR ;

                                   PAIR ;

                                   DUP 9 ;

                                   SWAP ;

                                   SOME ;

                                   SWAP ;

                                   UPDATE ;

                                   DUP 2 ;

                                   CDR ;

                                   DUP 3 ;

                                   CAR ;

                                   CDR ;

                                   CDR ;

                                   DUP 4 ;

                                   CAR ;

                                   CDR ;

                                   CAR ;

                                   CDR ;

                                   DUP 13 ;

                                   PAIR ;

                                   PAIR ;

                                   DIG 3 ;

                                   CAR ;

                                   CAR ;

                                   PAIR ;

                                   PAIR ;

                                   DUP 3 ;

                                   SWAP ;

                                   SOME ;

                                   SWAP ;

                                   UPDATE ;

                                   DIG 7 ;

                                   DIG 4 ;

                                   DUP 9 ;

                                   PAIR ;

                                   DUP 10 ;

                                   SWAP ;

                                   EXEC ;

                                   DIG 4 ;

                                   PAIR ;

                                   DIG 5 ;

                                   DIG 6 ;

                                   PAIR ;

                                   PAIR ;

                                   DIG 3 ;

                                   PUSH nat 0 ;

                                   PAIR ;

                                   PUSH int 0 ;

                                   DIG 5 ;

                                   PAIR ;

                                   PAIR ;

                                   PAIR ;

                                   PAIR ;

                                   DIG 2 ;

                                   SWAP ;

                                   SOME ;

                                   SWAP ;

                                   UPDATE ;

                                   RIGHT (pair

                                           (pair

                                             (pair

                                               (big_map int

                                                        (pair

                                                          (pair

                                                            (pair

                                                              (pair (pair nat nat) int)

                                                              nat

                                                              int)

                                                            (pair int nat)

                                                            nat

                                                            nat)

                                                          int))

                                               int)

                                             int

                                             int)

                                           (pair (pair nat nat) nat)

                                           nat

                                           (big_map (pair nat bool) (pair int nat))) }

                                 { SWAP ;

                                   DIG 6 ;

                                   DROP 2 ;

                                   DUG 2 ;

                                   PAIR ;

                                   DIG 3 ;

                                   DIG 3 ;

                                   PAIR ;

                                   PAIR ;

                                   DUG 2 ;

                                   PAIR ;

                                   DIG 3 ;

                                   DIG 3 ;

                                   PAIR ;

                                   PAIR ;

                                   PAIR ;

                                   LEFT (big_map int

                                                 (pair

                                                   (pair

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

                                                           int)

                                                     (pair int nat)

                                                     nat

                                                     nat)

                                                   int)) } } } } ;

           SWAP ;

           DROP } ;

       DUP 3 ;

       APPLY ;

       LAMBDA

         (pair (lambda (pair int nat) nat)

               (pair

                 (big_map int

                          (pair

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

                                  (pair int nat)

                                  nat

                                  nat)

                            int))

                 int

                 int

                 int))

         (big_map int

                  (pair

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

                          nat)

                    int))

         { UNPAIR ;

           SWAP ;

           UNPAIR 4 ;

           DUP ;

           DUP 3 ;

           GET ;

           IF_NONE { PUSH nat 301 ; FAILWITH } {} ;

           PUSH nat 313 ;

           DIG 4 ;

           DUP 3 ;

           CAR ;

           CAR ;

           CDR ;

           CAR ;

           ADD ;

           PAIR ;

           DIG 5 ;

           SWAP ;

           EXEC ;

           DIG 4 ;

           DUP 3 ;

           CAR ;

           CAR ;

           CAR ;

           CDR ;

           ADD ;

           DUP 3 ;

           CDR ;

           DUP 4 ;

           CAR ;

           CDR ;

           DUP 5 ;

           CAR ;

           CAR ;

           CDR ;

           CDR ;

           DIG 4 ;

           PAIR ;

           DIG 4 ;

           CAR ;

           CAR ;

           CAR ;

           PAIR ;

           PAIR ;

           PAIR ;

           DIG 2 ;

           DUP 2 ;

           CDR ;

           DUP 3 ;

           CAR ;

           CDR ;

           DUP 4 ;

           CAR ;

           CAR ;

           CDR ;

           DIG 5 ;

           DIG 5 ;

           CAR ;

           CAR ;

           CAR ;

           CAR ;

           PAIR ;

           PAIR ;

           PAIR ;

           PAIR ;

           DIG 2 ;

           SWAP ;

           SOME ;

           SWAP ;

           UPDATE } ;

       DUP 5 ;

       APPLY ;

       LAMBDA

         (pair

           (pair

             (pair

               (pair

                 (pair

                   (pair (pair (pair address nat) nat (or address (pair nat address)))

                         (or address (pair nat address)))

                   (pair (pair nat nat)

                         (big_map nat

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

                         nat))

                 int

                 int)

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

               (big_map (pair nat bool) (pair int nat))

               nat)

             (pair (pair (big_map string bytes) nat)

                   (big_map (pair address address nat) unit)

                   (big_map address (set nat)))

             (pair (big_map nat (pair (pair (pair (pair int int) nat) int address) int))

                   nat)

             (big_map int

                      (pair

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

                              nat

                              nat)

                        int))

             (big_map nat (pair nat (map string bytes))))

           int)

         (pair

           (pair

             (pair

               (pair

                 (pair (pair (pair address nat) nat (or address (pair nat address)))

                       (or address (pair nat address)))

                 (pair (pair nat nat)

                       (big_map nat

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

                       nat))

               int

               int)

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

             (big_map (pair nat bool) (pair int nat))

             nat)

           (pair (pair (big_map string bytes) nat)

                 (big_map (pair address address nat) unit)

                 (big_map address (set nat)))

           (pair (big_map nat (pair (pair (pair (pair int int) nat) int address) int))

                 nat)

           (big_map int

                    (pair

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

                            nat)

                      int))

           (big_map nat (pair nat (map string bytes))))

         { UNPAIR ;

           DUP ;

           CDR ;

           CDR ;

           CDR ;

           CAR ;

           DUP 3 ;

           GET ;

           IF_NONE { PUSH nat 301 ; FAILWITH } {} ;

           PUSH nat 0 ;

           DUP 2 ;

           CAR ;

           CAR ;

           CDR ;

           CAR ;

           COMPARE ;

           EQ ;

           IF

             { DUP 2 ;

               CDR ;

               CDR ;

               CDR ;

               CAR ;

               DUP ;

               DUP 3 ;

               CAR ;

               CDR ;

               CAR ;

               CAR ;

               GET ;

               IF_NONE { PUSH nat 301 ; FAILWITH } {} ;

               DUP 2 ;

               DUP 4 ;

               CAR ;

               CAR ;

               CDR ;

               CDR ;

               GET ;

               IF_NONE { PUSH nat 301 ; FAILWITH } {} ;

               DUP 5 ;

               CDR ;

               CDR ;

               CDR ;

               CDR ;

               DIG 3 ;

               DUP 7 ;

               NONE (pair

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

                            nat)

                      int) ;

               SWAP ;

               UPDATE ;

               DUP 4 ;

               CDR ;

               DUP 5 ;

               CAR ;

               CDR ;

               DUP 7 ;

               CAR ;

               CAR ;

               CDR ;

               CDR ;

               DUP 7 ;

               CAR ;

               CAR ;

               CDR ;

               CAR ;

               PAIR ;

               DIG 6 ;

               CAR ;

               CAR ;

               CAR ;

               PAIR ;

               PAIR ;

               PAIR ;

               SOME ;

               DUP 5 ;

               CAR ;

               CDR ;

               CAR ;

               CAR ;

               UPDATE ;

               DUP 3 ;

               CDR ;

               DUP 4 ;

               CAR ;

               CDR ;

               CDR ;

               DUP 5 ;

               CAR ;

               CDR ;

               CAR ;

               CDR ;

               DUP 7 ;

               CAR ;

               CDR ;

               CAR ;

               CAR ;

               PAIR ;

               PAIR ;

               DIG 4 ;

               CAR ;

               CAR ;

               PAIR ;

               PAIR ;

               SOME ;

               DUP 4 ;

               CAR ;

               CAR ;

               CDR ;

               CDR ;

               UPDATE ;

               PAIR ;

               DUP 3 ;

               CDR ;

               CDR ;