
(SDEFUN |JVF;diff;JB$;1| ((|jb| JB) ($ $))
        (CONS (LIST (|spadConstant| $ 14)) (LIST |jb|))) 

(SDEFUN |JVF;diffX;Pi$;2| ((|i| |PositiveInteger|) ($ $))
        (SPADCALL (SPADCALL |i| (QREFELT $ 16)) (QREFELT $ 15))) 

(SDEFUN |JVF;diffU;Pi$;3| ((|i| |PositiveInteger|) ($ $))
        (SPADCALL (SPADCALL |i| (QREFELT $ 18)) (QREFELT $ 15))) 

(SDEFUN |JVF;diffP;PiL$;4|
        ((|i| |PositiveInteger|) (|mu| |List| (|NonNegativeInteger|)) ($ $))
        (SPADCALL (SPADCALL |i| |mu| (QREFELT $ 21)) (QREFELT $ 15))) 

(SDEFUN |JVF;monom| ((|c| D) (|jb| JB) ($ |OutputForm|))
        (COND
         ((SPADCALL |c| (QREFELT $ 24))
          (SPADCALL (SPADCALL "D" (QREFELT $ 27))
                    (SPADCALL |jb| (QREFELT $ 28)) (QREFELT $ 29)))
         ('T
          (SPADCALL (SPADCALL |c| (QREFELT $ 30))
                    (SPADCALL (SPADCALL "D" (QREFELT $ 27))
                              (SPADCALL |jb| (QREFELT $ 28)) (QREFELT $ 29))
                    (QREFELT $ 31))))) 

(SDEFUN |JVF;coerce;$Of;6| ((|v| $) ($ |OutputForm|))
        (SPROG
         ((#1=#:G735 NIL) (|c| NIL) (#2=#:G736 NIL) (|jb| NIL) (#3=#:G734 NIL))
         (SEQ
          (COND
           ((NULL (QCDR |v|)) (SPADCALL (|spadConstant| $ 32) (QREFELT $ 30)))
           ((EQL (LENGTH (QCDR |v|)) 1)
            (|JVF;monom| (|SPADfirst| (QCAR |v|)) (|SPADfirst| (QCDR |v|)) $))
           ('T
            (SPADCALL (ELT $ 33)
                      (PROGN
                       (LETT #3# NIL)
                       (SEQ (LETT |jb| NIL) (LETT #2# (QCDR |v|))
                            (LETT |c| NIL) (LETT #1# (QCAR |v|)) G190
                            (COND
                             ((OR (ATOM #1#) (PROGN (LETT |c| (CAR #1#)) NIL)
                                  (ATOM #2#) (PROGN (LETT |jb| (CAR #2#)) NIL))
                              (GO G191)))
                            (SEQ
                             (EXIT
                              (LETT #3# (CONS (|JVF;monom| |c| |jb| $) #3#))))
                            (LETT #1# (PROG1 (CDR #1#) (LETT #2# (CDR #2#))))
                            (GO G190) G191 (EXIT (NREVERSE #3#))))
                      (QREFELT $ 36))))))) 

(SDEFUN |JVF;coefficients;$L;7| ((|v| $) ($ |List| D))
        (SPADCALL (QCAR |v|) (QREFELT $ 39))) 

(SDEFUN |JVF;directions;$L;8| ((|v| $) ($ |List| JB))
        (SPADCALL (QCDR |v|) (QREFELT $ 42))) 

(SDEFUN |JVF;coefficient;$JBD;9| ((|v| $) (|jb| JB) ($ D))
        (SPROG ((|pos| (|Integer|)))
               (SEQ (LETT |pos| (SPADCALL |jb| (QCDR |v|) (QREFELT $ 45)))
                    (EXIT
                     (COND
                      ((< |pos| (SPADCALL (QCDR |v|) (QREFELT $ 46)))
                       (|spadConstant| $ 32))
                      ('T (SPADCALL (QCAR |v|) |pos| (QREFELT $ 47)))))))) 

(SDEFUN |JVF;copy;2$;10| ((|v| $) ($ $))
        (CONS (SPADCALL (QCAR |v|) (QREFELT $ 39))
              (SPADCALL (QCDR |v|) (QREFELT $ 42)))) 

(PUT '|JVF;Zero;$;11| '|SPADreplace| '(XLAM NIL (CONS NIL NIL))) 

(SDEFUN |JVF;Zero;$;11| (($ $)) (CONS NIL NIL)) 

(SDEFUN |JVF;zero?;$B;12| ((|v| $) ($ |Boolean|)) (NULL (QCDR |v|))) 

(SDEFUN |JVF;-;2$;13| ((|v| $) ($ $))
        (SPROG ((#1=#:G747 NIL) (|c| NIL) (#2=#:G746 NIL))
               (SEQ
                (CONS
                 (PROGN
                  (LETT #2# NIL)
                  (SEQ (LETT |c| NIL) (LETT #1# (QCAR |v|)) G190
                       (COND
                        ((OR (ATOM #1#) (PROGN (LETT |c| (CAR #1#)) NIL))
                         (GO G191)))
                       (SEQ
                        (EXIT
                         (LETT #2# (CONS (SPADCALL |c| (QREFELT $ 53)) #2#))))
                       (LETT #1# (CDR #1#)) (GO G190) G191
                       (EXIT (NREVERSE #2#))))
                 (QCDR |v|))))) 

(SDEFUN |JVF;+;3$;14| ((|v| $) (|w| $) ($ $))
        (SPROG
         ((|lj2| (|List| JB)) (|lc2| (|List| D)) (|resJ| (|List| JB))
          (|resC| (|List| D)) (|sum| (D)) (#1=#:G764 NIL) (|c1| NIL)
          (#2=#:G765 NIL) (|j1| NIL))
         (SEQ
          (COND ((SPADCALL |v| (QREFELT $ 52)) |w|)
                ((SPADCALL |w| (QREFELT $ 52)) |v|)
                ('T
                 (SEQ (LETT |lc2| (SPADCALL (QCAR |w|) (QREFELT $ 39)))
                      (LETT |lj2| (SPADCALL (QCDR |w|) (QREFELT $ 42)))
                      (LETT |resC| NIL) (LETT |resJ| NIL)
                      (SEQ (LETT |j1| NIL) (LETT #2# (QCDR |v|))
                           (LETT |c1| NIL) (LETT #1# (QCAR |v|)) G190
                           (COND
                            ((OR (ATOM #1#) (PROGN (LETT |c1| (CAR #1#)) NIL)
                                 (ATOM #2#) (PROGN (LETT |j1| (CAR #2#)) NIL))
                             (GO G191)))
                           (SEQ
                            (SEQ G190
                                 (COND
                                  ((NULL
                                    (COND ((NULL |lj2|) NIL)
                                          ('T
                                           (SPADCALL (|SPADfirst| |lj2|) |j1|
                                                     (QREFELT $ 55)))))
                                   (GO G191)))
                                 (SEQ
                                  (LETT |resC|
                                        (CONS (|SPADfirst| |lc2|) |resC|))
                                  (LETT |resJ|
                                        (CONS (|SPADfirst| |lj2|) |resJ|))
                                  (LETT |lc2| (CDR |lc2|))
                                  (EXIT (LETT |lj2| (CDR |lj2|))))
                                 NIL (GO G190) G191 (EXIT NIL))
                            (EXIT
                             (COND
                              ((OR (NULL |lj2|)
                                   (NULL
                                    (SPADCALL (|SPADfirst| |lj2|) |j1|
                                              (QREFELT $ 56))))
                               (SEQ (LETT |resC| (CONS |c1| |resC|))
                                    (EXIT (LETT |resJ| (CONS |j1| |resJ|)))))
                              ('T
                               (SEQ
                                (LETT |sum|
                                      (SPADCALL |c1| (|SPADfirst| |lc2|)
                                                (QREFELT $ 57)))
                                (COND
                                 ((NULL (SPADCALL |sum| (QREFELT $ 58)))
                                  (SEQ (LETT |resC| (CONS |sum| |resC|))
                                       (EXIT
                                        (LETT |resJ| (CONS |j1| |resJ|))))))
                                (LETT |lc2| (CDR |lc2|))
                                (EXIT (LETT |lj2| (CDR |lj2|))))))))
                           (LETT #1# (PROG1 (CDR #1#) (LETT #2# (CDR #2#))))
                           (GO G190) G191 (EXIT NIL))
                      (EXIT
                       (CONS (SPADCALL (NREVERSE |resC|) |lc2| (QREFELT $ 59))
                             (SPADCALL (NREVERSE |resJ|) |lj2|
                                       (QREFELT $ 60)))))))))) 

(SDEFUN |JVF;*;D2$;15| ((|f| D) (|v| $) ($ $))
        (SPROG ((#1=#:G770 NIL) (|c| NIL) (#2=#:G769 NIL))
               (SEQ
                (COND ((SPADCALL |f| (QREFELT $ 58)) (|spadConstant| $ 51))
                      ('T
                       (CONS
                        (PROGN
                         (LETT #2# NIL)
                         (SEQ (LETT |c| NIL) (LETT #1# (QCAR |v|)) G190
                              (COND
                               ((OR (ATOM #1#)
                                    (PROGN (LETT |c| (CAR #1#)) NIL))
                                (GO G191)))
                              (SEQ
                               (EXIT
                                (LETT #2#
                                      (CONS (SPADCALL |f| |c| (QREFELT $ 62))
                                            #2#))))
                              (LETT #1# (CDR #1#)) (GO G190) G191
                              (EXIT (NREVERSE #2#))))
                        (QCDR |v|))))))) 

(SDEFUN |JVF;prolong;$Nni$;16| ((|v| $) (|q| |NonNegativeInteger|) ($ $))
        (SPROG
         ((|oldDir| (|List| JB)) (|oldCo| #1=(|List| D)) (|newDir| (|List| JB))
          (|newCo| #1#) (|res| ($)) (|newco| (D))
          (|nu| (|List| (|NonNegativeInteger|))) (#2=#:G839 NIL) (|i| NIL)
          (|j| (|Integer|)) (#3=#:G814 NIL) (|newjv| (JB)) (#4=#:G809 NIL)
          (#5=#:G807 NIL) (#6=#:G838 NIL) (|k| NIL)
          (|mu| (|List| (|NonNegativeInteger|))) (|a| (|PositiveInteger|))
          (|jm| (|SparseEchelonMatrix| JB D)) (#7=#:G836 NIL) (|jv| NIL)
          (#8=#:G837 NIL) (|co| NIL) (#9=#:G835 NIL) (|qq| NIL)
          (#10=#:G798 NIL) (#11=#:G834 NIL) (#12=#:G833 NIL) (#13=#:G832 NIL)
          (#14=#:G830 NIL) (#15=#:G831 NIL) (#16=#:G787 NIL) (#17=#:G829 NIL)
          (#18=#:G828 NIL) (|dxi| (|Matrix| D))
          (|ind2| #19=(|List| (|PositiveInteger|))) (|eta| #1#) (|ind1| #19#)
          (|xi| #1#) (|jt| (|Symbol|)) (#20=#:G826 NIL) (#21=#:G827 NIL)
          (|coeffs| (|List| D)) (|dirs| (|List| JB)))
         (SEQ
          (COND ((ZEROP |q|) |v|)
                ('T
                 (SEQ (LETT |dirs| (SPADCALL |v| (QREFELT $ 43)))
                      (LETT |coeffs| (SPADCALL |v| (QREFELT $ 40)))
                      (LETT |xi| NIL) (LETT |eta| NIL) (LETT |ind1| NIL)
                      (LETT |ind2| NIL)
                      (SEQ (LETT |co| NIL) (LETT #21# |coeffs|) (LETT |jv| NIL)
                           (LETT #20# |dirs|) G190
                           (COND
                            ((OR (ATOM #20#) (PROGN (LETT |jv| (CAR #20#)) NIL)
                                 (ATOM #21#)
                                 (PROGN (LETT |co| (CAR #21#)) NIL))
                             (GO G191)))
                           (SEQ (LETT |jt| (SPADCALL |jv| (QREFELT $ 65)))
                                (EXIT
                                 (COND
                                  ((EQUAL |jt| '|Indep|)
                                   (SEQ (LETT |xi| (CONS |co| |xi|))
                                        (EXIT
                                         (LETT |ind1|
                                               (CONS
                                                (SPADCALL |jv| (QREFELT $ 66))
                                                |ind1|)))))
                                  ((EQUAL |jt| '|Dep|)
                                   (SEQ (LETT |eta| (CONS |co| |eta|))
                                        (EXIT
                                         (LETT |ind2|
                                               (CONS
                                                (SPADCALL |jv| (QREFELT $ 66))
                                                |ind2|)))))
                                  ('T
                                   (|error|
                                    "not base vector field in prolong")))))
                           (LETT #20#
                                 (PROG1 (CDR #20#) (LETT #21# (CDR #21#))))
                           (GO G190) G191 (EXIT NIL))
                      (LETT |dxi|
                            (MAKE_MATRIX1 (LENGTH |xi|) (QREFELT $ 10)
                                          (|spadConstant| $ 32)))
                      (SEQ (LETT |i| 1) (LETT |co| NIL) (LETT #18# |xi|) G190
                           (COND
                            ((OR (ATOM #18#)
                                 (PROGN (LETT |co| (CAR #18#)) NIL))
                             (GO G191)))
                           (SEQ
                            (LETT |jm| (SPADCALL (LIST |co|) (QREFELT $ 69)))
                            (EXIT
                             (SEQ (LETT |j| 1) (LETT #17# (QREFELT $ 10)) G190
                                  (COND ((|greater_SI| |j| #17#) (GO G191)))
                                  (SEQ
                                   (EXIT
                                    (QSETAREF2O |dxi| |i| |j|
                                                (QCAR
                                                 (SPADCALL |co|
                                                           (PROG1
                                                               (LETT #16# |j|)
                                                             (|check_subtype2|
                                                              (> #16# 0)
                                                              '(|PositiveInteger|)
                                                              '(|NonNegativeInteger|)
                                                              #16#))
                                                           |jm|
                                                           (QREFELT $ 71)))
                                                1 1)))
                                  (LETT |j| (|inc_SI| |j|)) (GO G190) G191
                                  (EXIT NIL))))
                           (LETT #18#
                                 (PROG1 (CDR #18#) (LETT |i| (|inc_SI| |i|))))
                           (GO G190) G191 (EXIT NIL))
                      (LETT |j| (QREFELT $ 12)) (LETT |oldCo| NIL)
                      (SEQ (LETT |i| NIL) (LETT #15# |ind2|) (LETT |co| NIL)
                           (LETT #14# |eta|) G190
                           (COND
                            ((OR (ATOM #14#) (PROGN (LETT |co| (CAR #14#)) NIL)
                                 (ATOM #15#) (PROGN (LETT |i| (CAR #15#)) NIL))
                             (GO G191)))
                           (SEQ
                            (SEQ G190 (COND ((NULL (> |j| |i|)) (GO G191)))
                                 (SEQ
                                  (LETT |oldCo|
                                        (CONS (|spadConstant| $ 32) |oldCo|))
                                  (EXIT (LETT |j| (- |j| 1))))
                                 NIL (GO G190) G191 (EXIT NIL))
                            (LETT |oldCo| (CONS |co| |oldCo|))
                            (EXIT (LETT |j| (- |j| 1))))
                           (LETT #14#
                                 (PROG1 (CDR #14#) (LETT #15# (CDR #15#))))
                           (GO G190) G191 (EXIT NIL))
                      (COND
                       ((NULL (ZEROP |j|))
                        (SEQ (LETT |i| 1) (LETT #13# |j|) G190
                             (COND ((|greater_SI| |i| #13#) (GO G191)))
                             (SEQ
                              (EXIT
                               (LETT |oldCo|
                                     (CONS (|spadConstant| $ 32) |oldCo|))))
                             (LETT |i| (|inc_SI| |i|)) (GO G190) G191
                             (EXIT NIL))))
                      (LETT |oldDir|
                            (PROGN
                             (LETT #12# NIL)
                             (SEQ (LETT |i| 1) (LETT #11# (QREFELT $ 12)) G190
                                  (COND ((|greater_SI| |i| #11#) (GO G191)))
                                  (SEQ
                                   (EXIT
                                    (LETT #12#
                                          (CONS
                                           (SPADCALL
                                            (PROG1 (LETT #10# |i|)
                                              (|check_subtype2| (> #10# 0)
                                                                '(|PositiveInteger|)
                                                                '(|NonNegativeInteger|)
                                                                #10#))
                                            (QREFELT $ 18))
                                           #12#))))
                                  (LETT |i| (|inc_SI| |i|)) (GO G190) G191
                                  (EXIT (NREVERSE #12#)))))
                      (LETT |res| |v|)
                      (SEQ (LETT |qq| 1) (LETT #9# |q|) G190
                           (COND ((|greater_SI| |qq| #9#) (GO G191)))
                           (SEQ (LETT |newCo| NIL) (LETT |newDir| NIL)
                                (SEQ (LETT |co| NIL) (LETT #8# |oldCo|)
                                     (LETT |jv| NIL) (LETT #7# |oldDir|) G190
                                     (COND
                                      ((OR (ATOM #7#)
                                           (PROGN (LETT |jv| (CAR #7#)) NIL)
                                           (ATOM #8#)
                                           (PROGN (LETT |co| (CAR #8#)) NIL))
                                       (GO G191)))
                                     (SEQ
                                      (LETT |jm|
                                            (SPADCALL (LIST |co|)
                                                      (QREFELT $ 69)))
                                      (LETT |a| (SPADCALL |jv| (QREFELT $ 66)))
                                      (LETT |mu|
                                            (SPADCALL |jv| (QREFELT $ 73)))
                                      (EXIT
                                       (SEQ
                                        (LETT |k|
                                              (MAX 1
                                                   (SPADCALL |jv|
                                                             (QREFELT $ 75))))
                                        (LETT #6# (QREFELT $ 10)) G190
                                        (COND ((> |k| #6#) (GO G191)))
                                        (SEQ
                                         (LETT |newjv|
                                               (PROG2
                                                   (LETT #4#
                                                         (SPADCALL |jv|
                                                                   (PROG1
                                                                       (LETT
                                                                        #5#
                                                                        |k|)
                                                                     (|check_subtype2|
                                                                      (> #5# 0)
                                                                      '(|PositiveInteger|)
                                                                      '(|NonNegativeInteger|)
                                                                      #5#))
                                                                   (QREFELT $
                                                                            77)))
                                                   (QCDR #4#)
                                                 (|check_union2| (QEQCAR #4# 0)
                                                                 (QREFELT $ 6)
                                                                 (|Union|
                                                                  (QREFELT $ 6)
                                                                  "0")
                                                                 #4#)))
                                         (LETT |newco|
                                               (QCAR
                                                (SPADCALL |co|
                                                          (PROG1 (LETT #3# |k|)
                                                            (|check_subtype2|
                                                             (> #3# 0)
                                                             '(|PositiveInteger|)
                                                             '(|NonNegativeInteger|)
                                                             #3#))
                                                          |jm|
                                                          (QREFELT $ 71))))
                                         (SEQ (LETT |j| 1) (LETT |i| NIL)
                                              (LETT #2# |ind1|) G190
                                              (COND
                                               ((OR (ATOM #2#)
                                                    (PROGN
                                                     (LETT |i| (CAR #2#))
                                                     NIL))
                                                (GO G191)))
                                              (SEQ
                                               (LETT |nu|
                                                     (SPADCALL |mu|
                                                               (QREFELT $ 78)))
                                               (SPADCALL |nu| |i|
                                                         (+
                                                          (SPADCALL |nu| |i|
                                                                    (QREFELT $
                                                                             79))
                                                          1)
                                                         (QREFELT $ 80))
                                               (EXIT
                                                (LETT |newco|
                                                      (SPADCALL |newco|
                                                                (SPADCALL
                                                                 (QAREF2O |dxi|
                                                                          |j|
                                                                          |k| 1
                                                                          1)
                                                                 (SPADCALL
                                                                  (SPADCALL |a|
                                                                            |nu|
                                                                            (QREFELT
                                                                             $
                                                                             81))
                                                                  (QREFELT $
                                                                           82))
                                                                 (QREFELT $
                                                                          62))
                                                                (QREFELT $
                                                                         83)))))
                                              (LETT #2#
                                                    (PROG1 (CDR #2#)
                                                      (LETT |j|
                                                            (|inc_SI| |j|))))
                                              (GO G190) G191 (EXIT NIL))
                                         (LETT |res|
                                               (SPADCALL |res|
                                                         (SPADCALL |newco|
                                                                   (SPADCALL
                                                                    |newjv|
                                                                    (QREFELT $
                                                                             15))
                                                                   (QREFELT $
                                                                            63))
                                                         (QREFELT $ 61)))
                                         (LETT |newCo| (CONS |newco| |newCo|))
                                         (EXIT
                                          (LETT |newDir|
                                                (CONS |newjv| |newDir|))))
                                        (LETT |k| (+ |k| 1)) (GO G190) G191
                                        (EXIT NIL))))
                                     (LETT #7#
                                           (PROG1 (CDR #7#)
                                             (LETT #8# (CDR #8#))))
                                     (GO G190) G191 (EXIT NIL))
                                (LETT |oldCo| |newCo|)
                                (EXIT (LETT |oldDir| |newDir|)))
                           (LETT |qq| (|inc_SI| |qq|)) (GO G190) G191
                           (EXIT NIL))
                      (EXIT |res|))))))) 

(SDEFUN |JVF;eval;$2D;17| ((|v| $) (|f| D) ($ D))
        (SPROG
         ((|res| (D)) (#1=#:G843 NIL) (|c| NIL) (#2=#:G844 NIL) (|jb| NIL))
         (SEQ (LETT |res| (|spadConstant| $ 32))
              (SEQ (LETT |jb| NIL) (LETT #2# (QCDR |v|)) (LETT |c| NIL)
                   (LETT #1# (QCAR |v|)) G190
                   (COND
                    ((OR (ATOM #1#) (PROGN (LETT |c| (CAR #1#)) NIL) (ATOM #2#)
                         (PROGN (LETT |jb| (CAR #2#)) NIL))
                     (GO G191)))
                   (SEQ
                    (EXIT
                     (LETT |res|
                           (SPADCALL |res|
                                     (SPADCALL |c|
                                               (SPADCALL |f| |jb|
                                                         (QREFELT $ 85))
                                               (QREFELT $ 62))
                                     (QREFELT $ 57)))))
                   (LETT #1# (PROG1 (CDR #1#) (LETT #2# (CDR #2#)))) (GO G190)
                   G191 (EXIT NIL))
              (EXIT |res|)))) 

(SDEFUN |JVF;commutator;3$;18| ((|v| $) (|w| $) ($ $))
        (SPROG
         ((|res2| ($)) (|rjb| (|List| JB)) (|rco| (|List| D)) (|sum| (D))
          (#1=#:G861 NIL) (|c1| NIL) (#2=#:G862 NIL) (|j1| NIL) (#3=#:G859 NIL)
          (|c2| NIL) (#4=#:G860 NIL) (|j2| NIL) (|res1| ($)) (#5=#:G857 NIL)
          (#6=#:G858 NIL) (#7=#:G855 NIL) (#8=#:G856 NIL))
         (SEQ (LETT |rco| NIL) (LETT |rjb| NIL)
              (SEQ (LETT |j1| NIL) (LETT #8# (QCDR |v|)) (LETT |c1| NIL)
                   (LETT #7# (QCAR |v|)) G190
                   (COND
                    ((OR (ATOM #7#) (PROGN (LETT |c1| (CAR #7#)) NIL)
                         (ATOM #8#) (PROGN (LETT |j1| (CAR #8#)) NIL))
                     (GO G191)))
                   (SEQ (LETT |sum| (|spadConstant| $ 32))
                        (SEQ (LETT |j2| NIL) (LETT #6# (QCDR |w|))
                             (LETT |c2| NIL) (LETT #5# (QCAR |w|)) G190
                             (COND
                              ((OR (ATOM #5#) (PROGN (LETT |c2| (CAR #5#)) NIL)
                                   (ATOM #6#)
                                   (PROGN (LETT |j2| (CAR #6#)) NIL))
                               (GO G191)))
                             (SEQ
                              (EXIT
                               (LETT |sum|
                                     (SPADCALL |sum|
                                               (SPADCALL |c2|
                                                         (SPADCALL |c1| |j2|
                                                                   (QREFELT $
                                                                            85))
                                                         (QREFELT $ 62))
                                               (QREFELT $ 57)))))
                             (LETT #5# (PROG1 (CDR #5#) (LETT #6# (CDR #6#))))
                             (GO G190) G191 (EXIT NIL))
                        (EXIT
                         (COND
                          ((NULL (SPADCALL |sum| (QREFELT $ 58)))
                           (SEQ (LETT |rco| (CONS |sum| |rco|))
                                (EXIT (LETT |rjb| (CONS |j1| |rjb|))))))))
                   (LETT #7# (PROG1 (CDR #7#) (LETT #8# (CDR #8#)))) (GO G190)
                   G191 (EXIT NIL))
              (LETT |res1| (CONS (NREVERSE |rco|) (NREVERSE |rjb|)))
              (LETT |rco| NIL) (LETT |rjb| NIL)
              (SEQ (LETT |j2| NIL) (LETT #4# (QCDR |w|)) (LETT |c2| NIL)
                   (LETT #3# (QCAR |w|)) G190
                   (COND
                    ((OR (ATOM #3#) (PROGN (LETT |c2| (CAR #3#)) NIL)
                         (ATOM #4#) (PROGN (LETT |j2| (CAR #4#)) NIL))
                     (GO G191)))
                   (SEQ (LETT |sum| (|spadConstant| $ 32))
                        (SEQ (LETT |j1| NIL) (LETT #2# (QCDR |v|))
                             (LETT |c1| NIL) (LETT #1# (QCAR |v|)) G190
                             (COND
                              ((OR (ATOM #1#) (PROGN (LETT |c1| (CAR #1#)) NIL)
                                   (ATOM #2#)
                                   (PROGN (LETT |j1| (CAR #2#)) NIL))
                               (GO G191)))
                             (SEQ
                              (EXIT
                               (LETT |sum|
                                     (SPADCALL |sum|
                                               (SPADCALL |c1|
                                                         (SPADCALL |c2| |j1|
                                                                   (QREFELT $
                                                                            85))
                                                         (QREFELT $ 62))
                                               (QREFELT $ 57)))))
                             (LETT #1# (PROG1 (CDR #1#) (LETT #2# (CDR #2#))))
                             (GO G190) G191 (EXIT NIL))
                        (EXIT
                         (COND
                          ((NULL (SPADCALL |sum| (QREFELT $ 58)))
                           (SEQ (LETT |rco| (CONS |sum| |rco|))
                                (EXIT (LETT |rjb| (CONS |j2| |rjb|))))))))
                   (LETT #3# (PROG1 (CDR #3#) (LETT #4# (CDR #4#)))) (GO G190)
                   G191 (EXIT NIL))
              (LETT |res2| (CONS (NREVERSE |rco|) (NREVERSE |rjb|)))
              (EXIT (SPADCALL |res2| |res1| (QREFELT $ 87)))))) 

(SDEFUN |JVF;table;LTda;19| ((|lv| |List| $) ($ |TwoDimensionalArray| $))
        (SPROG
         ((|c| ($)) (#1=#:G873 NIL) (|v2| NIL) (|j| NIL) (|v1| ($)) (|i| NIL)
          (#2=#:G872 NIL) (|res| (|TwoDimensionalArray| $))
          (|len| (|NonNegativeInteger|)))
         (SEQ (LETT |len| (SPADCALL |lv| (QREFELT $ 90)))
              (EXIT
               (COND ((ZEROP |len|) (|error| "empty list in table"))
                     ('T
                      (SEQ
                       (LETT |res|
                             (SPADCALL |len| |len| (|spadConstant| $ 51)
                                       (QREFELT $ 92)))
                       (SEQ (LETT #2# NIL) (LETT |i| 1) G190
                            (COND (#2# (GO G191)))
                            (SEQ (LETT |v1| (SPADCALL |lv| (QREFELT $ 93)))
                                 (LETT |lv| (SPADCALL |lv| (QREFELT $ 94)))
                                 (EXIT
                                  (SEQ (LETT |j| (+ |i| 1)) (LETT |v2| NIL)
                                       (LETT #1# |lv|) G190
                                       (COND
                                        ((OR (ATOM #1#)
                                             (PROGN (LETT |v2| (CAR #1#)) NIL))
                                         (GO G191)))
                                       (SEQ
                                        (LETT |c|
                                              (SPADCALL |v1| |v2|
                                                        (QREFELT $ 88)))
                                        (SPADCALL |res| |i| |j| |c|
                                                  (QREFELT $ 95))
                                        (EXIT
                                         (SPADCALL |res| |j| |i|
                                                   (SPADCALL |c|
                                                             (QREFELT $ 54))
                                                   (QREFELT $ 95))))
                                       (LETT #1#
                                             (PROG1 (CDR #1#)
                                               (LETT |j| (+ |j| 1))))
                                       (GO G190) G191 (EXIT NIL))))
                            (LETT |i|
                                  (PROG1 (|inc_SI| |i|)
                                    (LETT #2# (SPADCALL |lv| (QREFELT $ 96)))))
                            (GO G190) G191 (EXIT NIL))
                       (EXIT |res|)))))))) 

(SDEFUN |JVF;lie;3$;20| ((|v| $) (|w| $) ($ $))
        (SPADCALL |v| |w| (QREFELT $ 88))) 

(DECLAIM (NOTINLINE |JetVectorField;|)) 

(DEFUN |JetVectorField| (&REST #1=#:G879)
  (SPROG NIL
         (PROG (#2=#:G880)
           (RETURN
            (COND
             ((LETT #2#
                    (|lassocShiftWithFunction| (|devaluateList| #1#)
                                               (HGET |$ConstructorCache|
                                                     '|JetVectorField|)
                                               '|domainEqualList|))
              (|CDRwithIncrement| #2#))
             ('T
              (UNWIND-PROTECT
                  (PROG1 (APPLY (|function| |JetVectorField;|) #1#)
                    (LETT #2# T))
                (COND
                 ((NOT #2#)
                  (HREM |$ConstructorCache| '|JetVectorField|)))))))))) 

(DEFUN |JetVectorField;| (|#1| |#2|)
  (SPROG
   ((|pv$| NIL) (#1=#:G878 NIL) ($ NIL) (|dv$| NIL) (DV$2 NIL) (DV$1 NIL))
   (PROGN
    (LETT DV$1 (|devaluate| |#1|))
    (LETT DV$2 (|devaluate| |#2|))
    (LETT |dv$| (LIST '|JetVectorField| DV$1 DV$2))
    (LETT $ (GETREFV 103))
    (QSETREFV $ 0 |dv$|)
    (QSETREFV $ 3
              (LETT |pv$|
                    (|buildPredVector| 0 0
                                       (LIST
                                        (|HasCategory| |#2| '(|AbelianGroup|))
                                        (LETT #1#
                                              (|HasCategory| |#2|
                                                             '(|AbelianMonoid|)))
                                        (OR
                                         (|HasCategory| |#2| '(|AbelianGroup|))
                                         #1#)))))
    (|haddProp| |$ConstructorCache| '|JetVectorField| (LIST DV$1 DV$2)
                (CONS 1 $))
    (|stuffDomainSlots| $)
    (QSETREFV $ 6 |#1|)
    (QSETREFV $ 7 |#2|)
    (SETF |pv$| (QREFELT $ 3))
    (QSETREFV $ 10 (SPADCALL (QREFELT $ 9)))
    (QSETREFV $ 12 (SPADCALL (QREFELT $ 11)))
    (QSETREFV $ 13
              (|Record| (|:| |Coeff| (|List| |#2|)) (|:| |Dir| (|List| |#1|))))
    $))) 

(MAKEPROP '|JetVectorField| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
              (|PositiveInteger|) (0 . |numIndVar|) '|nn| (4 . |numDepVar|)
              '|mm| '|Rep| (8 . |One|) |JVF;diff;JB$;1| (12 . X)
              |JVF;diffX;Pi$;2| (17 . U) |JVF;diffU;Pi$;3| (|List| 74) (22 . P)
              |JVF;diffP;PiL$;4| (|Boolean|) (28 . |one?|) (|String|)
              (|OutputForm|) (33 . |message|) (38 . |coerce|) (43 . |sub|)
              (49 . |coerce|) (54 . *) (60 . |Zero|) (64 . +)
              (|Mapping| 26 26 26) (|List| 26) (70 . |reduce|)
              |JVF;coerce;$Of;6| (|List| 7) (76 . |copy|)
              |JVF;coefficients;$L;7| (|List| 6) (81 . |copy|)
              |JVF;directions;$L;8| (|Integer|) (86 . |position|)
              (92 . |minIndex|) (97 . |qelt|) |JVF;coefficient;$JBD;9|
              |JVF;copy;2$;10| (103 . |empty|)
              (CONS IDENTITY (FUNCALL (|dispatchFunction| |JVF;Zero;$;11|) $))
              |JVF;zero?;$B;12| (107 . -) |JVF;-;2$;13| (112 . <) (118 . =)
              (124 . +) (130 . |zero?|) (135 . |concat!|) (141 . |concat!|)
              |JVF;+;3$;14| (147 . *) |JVF;*;D2$;15| (|Symbol|) (153 . |type|)
              (158 . |index|) (|SparseEchelonMatrix| 6 $) (|List| $)
              (163 . |jacobiMatrix|) (|Record| (|:| |DPhi| $) (|:| |JVars| 41))
              (168 . |formalDiff2|) (175 . |One|) (179 . |multiIndex|)
              (|NonNegativeInteger|) (184 . |class|) (|Union| $ '"0")
              (189 . |differentiate|) (195 . |copy|) (200 . |qelt|)
              (206 . |qsetelt!|) (213 . |Pm|) (219 . |coerce|) (224 . -)
              |JVF;prolong;$Nni$;16| (230 . |differentiate|) |JVF;eval;$2D;17|
              (236 . -) |JVF;commutator;3$;18| (|List| $$) (242 . |#|)
              (|TwoDimensionalArray| $$) (247 . |new|) (254 . |first|)
              (259 . |rest|) (264 . |qsetelt!|) (272 . |empty?|)
              (|TwoDimensionalArray| $) |JVF;table;LTda;19| |JVF;lie;3$;20|
              (|Union| $ '"failed") (|HashState|) (|SingleInteger|))
           '#(~= 277 |zero?| 283 |table| 288 |subtractIfCan| 293 |sample| 299
              |prolong| 303 |opposite?| 309 |lie| 315 |latex| 321 |hashUpdate!|
              326 |hash| 332 |eval| 337 |directions| 343 |diffX| 348 |diffU|
              353 |diffP| 358 |diff| 364 |copy| 369 |commutator| 374 |coerce|
              380 |coefficients| 385 |coefficient| 390 |Zero| 396 = 400 - 406 +
              417 * 423)
           'NIL
           (CONS (|makeByteWordVec2| 3 '(0 0 0 0 1 1 3 0 0 0 0))
                 (CONS
                  '#(|Module&| NIL NIL NIL |AbelianGroup&| NIL |AbelianMonoid&|
                     |AbelianSemiGroup&| |SetCategory&| |BasicType&| NIL)
                  (CONS
                   '#((|Module| 7) (|BiModule| 7 7) (|LeftModule| 7)
                      (|RightModule| 7) (|AbelianGroup|)
                      (|CancellationAbelianMonoid|) (|AbelianMonoid|)
                      (|AbelianSemiGroup|) (|SetCategory|) (|BasicType|)
                      (|CoercibleTo| 26))
                   (|makeByteWordVec2| 102
                                       '(0 6 8 9 0 6 8 11 0 7 0 14 1 6 0 8 16 1
                                         6 0 8 18 2 6 0 8 20 21 1 7 23 0 24 1
                                         26 0 25 27 1 6 26 0 28 2 26 0 0 0 29 1
                                         7 26 0 30 2 26 0 0 0 31 0 7 0 32 2 26
                                         0 0 0 33 2 35 26 34 0 36 1 38 0 0 39 1
                                         41 0 0 42 2 41 44 6 0 45 1 41 44 0 46
                                         2 38 7 0 44 47 0 26 0 50 1 7 0 0 53 2
                                         6 23 0 0 55 2 6 23 0 0 56 2 7 0 0 0 57
                                         1 7 23 0 58 2 38 0 0 0 59 2 41 0 0 0
                                         60 2 7 0 0 0 62 1 6 64 0 65 1 6 8 0 66
                                         1 7 67 68 69 3 7 70 0 8 67 71 0 6 0 72
                                         1 6 20 0 73 1 6 74 0 75 2 6 76 0 8 77
                                         1 20 0 0 78 2 20 74 0 44 79 3 20 74 0
                                         44 74 80 2 6 0 8 20 81 1 7 0 6 82 2 7
                                         0 0 0 83 2 7 0 0 6 85 2 0 0 0 0 87 1
                                         89 74 0 90 3 91 0 74 74 2 92 1 89 2 0
                                         93 1 89 0 0 94 4 91 2 0 44 44 2 95 1
                                         89 23 0 96 2 0 23 0 0 1 1 2 23 0 52 1
                                         0 97 68 98 2 1 100 0 0 1 0 2 0 1 2 0 0
                                         0 74 84 2 2 23 0 0 1 2 0 0 0 0 99 1 0
                                         25 0 1 2 0 101 101 0 1 1 0 102 0 1 2 0
                                         7 0 7 86 1 0 41 0 43 1 0 0 8 17 1 0 0
                                         8 19 2 0 0 8 20 22 1 0 0 6 15 1 0 0 0
                                         49 2 0 0 0 0 88 1 0 26 0 37 1 0 38 0
                                         40 2 0 7 0 6 48 0 2 0 51 2 0 23 0 0 1
                                         2 1 0 0 0 87 1 1 0 0 54 2 0 0 0 0 61 2
                                         1 0 44 0 1 2 2 0 74 0 1 2 0 0 0 7 1 2
                                         0 0 7 0 63 2 0 0 8 0 1)))))
           '|lookupComplete|)) 
