
(/VERSIONCHECK 2) 

(DEFUN |MODOP;One;$;1| ($)
  (SPADCALL (|spadConstant| $ 16) (|spadConstant| $ 18) (QREFELT $ 19))) 

(DEFUN |MODOP;coerce;I$;2| (|n| $)
  (SPADCALL (SPADCALL |n| (QREFELT $ 21)) (QREFELT $ 22))) 

(DEFUN |MODOP;coerce;R$;3| (|r| $)
  (COND
    ((SPADCALL |r| (QREFELT $ 25)) (|spadConstant| $ 26))
    ('T (SPADCALL |r| (|spadConstant| $ 18) (QREFELT $ 19))))) 

(DEFUN |MODOP;coerce;Bo$;4| (|op| $)
  (|MODOP;nocopy| (SPADCALL |op| (QREFELT $ 28)) $)) 

(DEFUN |MODOP;nocopy| (|op| $)
  (SPADCALL (|spadConstant| $ 16) (SPADCALL |op| (QREFELT $ 30))
      (QREFELT $ 19))) 

(DEFUN |MODOP;elt;$2M;6| (|x| |r| $)
  (PROG (|t| #0=#:G1847 #1=#:G1844 #2=#:G1842 #3=#:G1843)
    (RETURN
      (SEQ (PROGN
             (LETT #3# NIL . #4=(|MODOP;elt;$2M;6|))
             (SEQ (LETT |t| NIL . #4#)
                  (LETT #0# (SPADCALL |x| (QREFELT $ 34)) . #4#) G190
                  (COND
                    ((OR (ATOM #0#)
                         (PROGN (LETT |t| (CAR #0#) . #4#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (PROGN
                               (LETT #1#
                                     (SPADCALL (QCDR |t|)
                                      (|MODOP;termeval| (QCAR |t|) |r|
                                       $)
                                      (QREFELT $ 35)) . #4#)
                               (COND
                                 (#3# (LETT #2#
                                       (SPADCALL #2# #1#
                                        (QREFELT $ 36)) . #4#))
                                 ('T
                                  (PROGN
                                    (LETT #2# #1# . #4#)
                                    (LETT #3# 'T . #4#)))))))
                  (LETT #0# (CDR #0#) . #4#) (GO G190) G191 (EXIT NIL))
             (COND (#3# #2#) ('T (|spadConstant| $ 37)))))))) 

(DEFUN |MODOP;rmeval| (|t| |r| $)
  (SPADCALL (QCAR |t|) (|MODOP;monomeval| (QCDR |t|) |r| $)
      (QREFELT $ 39))) 

(DEFUN |MODOP;termcopy| (|t| $)
  (PROG (#0=#:G1853 |rm| #1=#:G1854)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #2=(|MODOP;termcopy|))
             (SEQ (LETT |rm| NIL . #2#) (LETT #1# |t| . #2#) G190
                  (COND
                    ((OR (ATOM #1#)
                         (PROGN (LETT |rm| (CAR #1#) . #2#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (LETT #0#
                                   (CONS (CONS (QCAR |rm|) (QCDR |rm|))
                                    #0#) . #2#)))
                  (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                  (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |MODOP;characteristic;Nni;9| ($) (SPADCALL (QREFELT $ 41))) 

(DEFUN |MODOP;mkop| (|r| |fg| $)
  (SPADCALL (LIST (CONS |r| |fg|)) (QREFELT $ 44))) 

(DEFUN |MODOP;evaluate;$M$;11| (|f| |g| $)
  (|MODOP;nocopy|
      (SPADCALL (SPADCALL |f| (QREFELT $ 45)) (QREFELT $ 13) |g|
          (QREFELT $ 47))
      $)) 

(DEFUN |MODOP;makeop;RFg$;12| (|r| |fg| $)
  (COND
    ((SPADCALL |r| (|spadConstant| $ 50) (QREFELT $ 51))
     (SPADCALL (|MODOP;mkop| (SPADCALL |r| (QREFELT $ 52)) |fg| $)
         (QREFELT $ 53)))
    ('T (|MODOP;mkop| |r| |fg| $)))) 

(DEFUN |MODOP;makeop;RFg$;13| (|r| |fg| $) (|MODOP;mkop| |r| |fg| $)) 

(DEFUN |MODOP;inv| (|t| $)
  (PROG (|c| |m| #0=#:G1868)
    (RETURN
      (SEQ (COND
             ((NULL |t|) (|spadConstant| $ 15))
             ('T
              (SEQ (LETT |c| (QCAR (|SPADfirst| |t|))
                         . #1=(|MODOP;inv|))
                   (LETT |m| (QCDR (|SPADfirst| |t|)) . #1#)
                   (EXIT (SPADCALL
                             (SPADCALL (|MODOP;inv| (CDR |t|) $)
                                 (SPADCALL (|spadConstant| $ 16)
                                     (SPADCALL |m| (QREFELT $ 54))
                                     (QREFELT $ 19))
                                 (QREFELT $ 55))
                             (SPADCALL
                                 (PROG2 (LETT #0#
                                         (SPADCALL |c| (QREFELT $ 57)) . #1#)
                                        (QCDR #0#)
                                   (|check-union| (QEQCAR #0# 0)
                                    (QREFELT $ 6) #0#))
                                 (QREFELT $ 22))
                             (QREFELT $ 55)))))))))) 

(DEFUN |MODOP;**;$I$;15| (|x| |i| $)
  (COND
    ((EQL |i| 0) (|spadConstant| $ 15))
    ((< 0 |i|) (SPADCALL |x| |i| (QREFELT $ 62)))
    ('T
     (SPADCALL (|MODOP;inv| (SPADCALL |x| (QREFELT $ 63)) $) (- |i|)
         (QREFELT $ 64))))) 

(DEFUN |MODOP;evaluateInverse;$M$;16| (|f| |g| $)
  (|MODOP;nocopy|
      (SPADCALL (SPADCALL |f| (QREFELT $ 45)) (QREFELT $ 14) |g|
          (QREFELT $ 47))
      $)) 

(DEFUN |MODOP;coerce;$Of;17| (|x| $)
  (PROG (#0=#:G1882 |t| #1=#:G1883)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (QREFELT $ 66))
              (SPADCALL (|spadConstant| $ 50) (QREFELT $ 68)))
             ('T
              (SPADCALL (ELT $ 69)
                  (PROGN
                    (LETT #0# NIL . #2=(|MODOP;coerce;$Of;17|))
                    (SEQ (LETT |t| NIL . #2#)
                         (LETT #1# (SPADCALL |x| (QREFELT $ 34)) . #2#)
                         G190
                         (COND
                           ((OR (ATOM #1#)
                                (PROGN (LETT |t| (CAR #1#) . #2#) NIL))
                            (GO G191)))
                         (SEQ (EXIT (LETT #0#
                                     (CONS
                                      (|MODOP;trm2O| (QCDR |t|)
                                       (QCAR |t|) $)
                                      #0#) . #2#)))
                         (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                         (EXIT (NREVERSE0 #0#))))
                  (QREFELT $ 72)))))))) 

(DEFUN |MODOP;trm2O| (|c| |t| $)
  (COND
    ((EQL |c| 1) (|MODOP;term2O| |t| $))
    ((EQL |c| -1) (SPADCALL (|MODOP;term2O| |t| $) (QREFELT $ 74)))
    ('T
     (SPADCALL (SPADCALL |c| (QREFELT $ 75)) (|MODOP;term2O| |t| $)
         (QREFELT $ 76))))) 

(DEFUN |MODOP;term2O| (|t| $)
  (PROG (#0=#:G1890 |rm| #1=#:G1891)
    (RETURN
      (SEQ (SPADCALL (ELT $ 76)
               (PROGN
                 (LETT #0# NIL . #2=(|MODOP;term2O|))
                 (SEQ (LETT |rm| NIL . #2#) (LETT #1# |t| . #2#) G190
                      (COND
                        ((OR (ATOM #1#)
                             (PROGN (LETT |rm| (CAR #1#) . #2#) NIL))
                         (GO G191)))
                      (SEQ (EXIT (LETT #0#
                                       (CONS
                                        (|MODOP;rm2O| (QCAR |rm|)
                                         (QCDR |rm|) $)
                                        #0#) . #2#)))
                      (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                      (EXIT (NREVERSE0 #0#))))
               (QREFELT $ 72)))))) 

(DEFUN |MODOP;rm2O| (|c| |m| $)
  (COND
    ((SPADCALL |c| (|spadConstant| $ 16) (QREFELT $ 77))
     (SPADCALL |m| (QREFELT $ 78)))
    ((SPADCALL |m| (|spadConstant| $ 18) (QREFELT $ 79))
     (SPADCALL |c| (QREFELT $ 68)))
    ('T
     (SPADCALL (SPADCALL |c| (QREFELT $ 68))
         (SPADCALL |m| (QREFELT $ 78)) (QREFELT $ 76))))) 

(DEFUN |MODOP;*;3$;21| (|x| |y| $)
  (PROG (|t| #0=#:G1902 |s| #1=#:G1903 #2=#:G1899 #3=#:G1897 #4=#:G1898
             #5=#:G1896 #6=#:G1894 #7=#:G1895)
    (RETURN
      (SEQ (PROGN
             (LETT #7# NIL . #8=(|MODOP;*;3$;21|))
             (SEQ (LETT |t| NIL . #8#)
                  (LETT #0# (SPADCALL |x| (QREFELT $ 34)) . #8#) G190
                  (COND
                    ((OR (ATOM #0#)
                         (PROGN (LETT |t| (CAR #0#) . #8#) NIL))
                     #9=(GO G191)))
                  (SEQ (EXIT (PROGN
                               (LETT #5#
                                     (PROGN
                                       (LETT #4# NIL . #8#)
                                       (SEQ (LETT |s| NIL . #8#)
                                        (LETT #1#
                                         (SPADCALL |y| (QREFELT $ 34)) . #8#)
                                        G190
                                        (COND
                                          ((OR (ATOM #1#)
                                            (PROGN
                                              (LETT |s|
                                               (CAR #1#) . #8#)
                                              NIL))
                                           #9#))
                                        (SEQ
                                         (EXIT
                                          (PROGN
                                            (LETT #2#
                                             (|MODOP;termprod0|
                                              (* (QCDR |t|) (QCDR |s|))
                                              (QCAR |t|) (QCAR |s|) $) . #8#)
                                            (COND
                                              (#4#
                                               (LETT #3#
                                                (SPADCALL #3# #2#
                                                 (QREFELT $ 80)) . #8#))
                                              ('T
                                               (PROGN
                                                 (LETT #3# #2# . #8#)
                                                 (LETT #4# 'T . #8#)))))))
                                        (LETT #1# (CDR #1#) . #8#)
                                        #10=(GO G190) G191 (EXIT NIL))
                                       (COND
                                         (#4# #3#)
                                         ('T (|spadConstant| $ 26)))) . #8#)
                               (COND
                                 (#7# (LETT #6#
                                       (SPADCALL #6# #5#
                                        (QREFELT $ 80)) . #8#))
                                 ('T
                                  (PROGN
                                    (LETT #6# #5# . #8#)
                                    (LETT #7# 'T . #8#)))))))
                  (LETT #0# (CDR #0#) . #8#) #10# G191 (EXIT NIL))
             (COND (#7# #6#) ('T (|spadConstant| $ 26)))))))) 

(DEFUN |MODOP;termprod0| (|n| |x| |y| $)
  (COND
    ((< |n| 0)
     (SPADCALL
         (SPADCALL (|MODOP;termprod| (- |n|) |x| |y| $) (QREFELT $ 44))
         (QREFELT $ 53)))
    ('T (SPADCALL (|MODOP;termprod| |n| |x| |y| $) (QREFELT $ 44))))) 

(DEFUN |MODOP;termprod| (|n| |x| |y| $)
  (PROG (|xx| |lc| |rm|)
    (RETURN
      (SEQ (LETT |lc|
                 (|SPADfirst|
                     (LETT |xx| (|MODOP;termcopy| |x| $)
                           . #0=(|MODOP;termprod|))) . #0#)
           (PROGN
             (RPLACA |lc| (SPADCALL |n| (QCAR |lc|) (QREFELT $ 81)))
             (QCAR |lc|))
           (LETT |rm| (SPADCALL |xx| (QREFELT $ 82)) . #0#)
           (EXIT (COND
                   ((SPADCALL (QCAR (|SPADfirst| |y|))
                        (|spadConstant| $ 16) (QREFELT $ 77))
                    (SEQ (PROGN
                           (RPLACD |rm|
                                   (SPADCALL (QCDR |rm|)
                                    (QCDR (|SPADfirst| |y|))
                                    (QREFELT $ 83)))
                           (QCDR |rm|))
                         (EXIT (SPADCALL |xx|
                                   (|MODOP;termcopy| (CDR |y|) $)
                                   (QREFELT $ 84)))))
                   ((SPADCALL (QCDR |rm|) (|spadConstant| $ 18)
                        (QREFELT $ 79))
                    (SEQ (PROGN
                           (RPLACA |rm|
                                   (SPADCALL (QCAR |rm|)
                                    (QCAR (|SPADfirst| |y|))
                                    (QREFELT $ 85)))
                           (QCAR |rm|))
                         (PROGN
                           (RPLACD |rm| (QCDR (|SPADfirst| |y|)))
                           (QCDR |rm|))
                         (EXIT (SPADCALL |xx|
                                   (|MODOP;termcopy| (CDR |y|) $)
                                   (QREFELT $ 84)))))
                   ('T
                    (SPADCALL |xx| (|MODOP;termcopy| |y| $)
                        (QREFELT $ 84))))))))) 

(DEFUN |MODOP;opeval;Bo2M;24| (|op| |r| $)
  (PROG (|func|)
    (RETURN
      (SEQ (LETT |func| (SPADCALL |op| (QREFELT $ 13) (QREFELT $ 87))
                 |MODOP;opeval;Bo2M;24|)
           (EXIT (COND
                   ((QEQCAR |func| 1)
                    (SPADCALL |op| |r| (QREFELT $ 88)))
                   ('T (SPADCALL |r| (QCDR |func|))))))))) 

(DEFUN |MODOP;opeval;Bo2M;25| (|op| |r| $)
  (PROG (|func|)
    (RETURN
      (SEQ (LETT |func| (SPADCALL |op| (QREFELT $ 13) (QREFELT $ 87))
                 |MODOP;opeval;Bo2M;25|)
           (EXIT (COND
                   ((QEQCAR |func| 1)
                    (|error| "eval: operator has no evaluation function"))
                   ('T (SPADCALL |r| (QCDR |func|))))))))) 

(DEFUN |MODOP;opInvEval| (|op| |r| $)
  (PROG (|func|)
    (RETURN
      (SEQ (LETT |func| (SPADCALL |op| (QREFELT $ 14) (QREFELT $ 87))
                 |MODOP;opInvEval|)
           (EXIT (COND
                   ((QEQCAR |func| 1)
                    (|error| "eval: operator has no inverse evaluation function"))
                   ('T (SPADCALL |r| (QCDR |func|))))))))) 

(DEFUN |MODOP;termeval| (|t| |r| $)
  (PROG (|rm| #0=#:G1934)
    (RETURN
      (SEQ (SEQ (LETT |rm| NIL . #1=(|MODOP;termeval|))
                (LETT #0# (REVERSE |t|) . #1#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |rm| (CAR #0#) . #1#) NIL))
                   (GO G191)))
                (SEQ (EXIT (LETT |r| (|MODOP;rmeval| |rm| |r| $) . #1#)))
                (LETT #0# (CDR #0#) . #1#) (GO G190) G191 (EXIT NIL))
           (EXIT |r|))))) 

(DEFUN |MODOP;monomeval| (|m| |r| $)
  (PROG (|rec| #0=#:G1945 |e| |g| |i| #1=#:G1946)
    (RETURN
      (SEQ (SEQ (LETT |rec| NIL . #2=(|MODOP;monomeval|))
                (LETT #0#
                      (NREVERSE (SPADCALL |m| (QREFELT $ 92))) . #2#)
                G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |rec| (CAR #0#) . #2#) NIL))
                   #3=(GO G191)))
                (SEQ (LETT |e| (QCDR |rec|) . #2#)
                     (LETT |g| (QCAR |rec|) . #2#)
                     (EXIT (COND
                             ((< 0 |e|)
                              (SEQ (LETT |i| 1 . #2#) G190
                                   (COND ((QSGREATERP |i| |e|) #3#))
                                   (SEQ
                                    (EXIT
                                     (LETT |r|
                                      (SPADCALL |g| |r| (QREFELT $ 89)) . #2#)))
                                   (LETT |i| (QSADD1 |i|) . #2#)
                                   #4=(GO G190) G191 (EXIT NIL)))
                             ((< |e| 0)
                              (SEQ (LETT |i| 1 . #2#)
                                   (LETT #1# (- |e|) . #2#) G190
                                   (COND ((QSGREATERP |i| #1#) #3#))
                                   (SEQ
                                    (EXIT
                                     (LETT |r|
                                      (|MODOP;opInvEval| |g| |r| $) . #2#)))
                                   (LETT |i| (QSADD1 |i|) . #2#) #4#
                                   G191 (EXIT NIL))))))
                (LETT #0# (CDR #0#) . #2#) #4# G191 (EXIT NIL))
           (EXIT |r|))))) 

(DEFUN |MODOP;recip;$U;29| (|x| $)
  (PROG (|r| |r1|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 94))
                 . #0=(|MODOP;recip;$U;29|))
           (EXIT (COND
                   ((QEQCAR |r| 1) (CONS 1 "failed"))
                   (#1='T
                    (SEQ (LETT |r1|
                               (SPADCALL (QCDR |r|) (QREFELT $ 57)) . #0#)
                         (EXIT (COND
                                 ((QEQCAR |r1| 1) (CONS 1 "failed"))
                                 (#1#
                                  (CONS 0
                                        (SPADCALL (QCDR |r1|)
                                         (QREFELT $ 22)))))))))))))) 

(DEFUN |MODOP;retractIfCan;$U;30| (|x| $)
  (PROG (|r| |t| |rm|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 97))
                 . #0=(|MODOP;retractIfCan;$U;30|))
           (EXIT (COND
                   ((QEQCAR |r| 1) (CONS 1 "failed"))
                   ((NULL (LETT |t| (QCDR |r|) . #0#))
                    (CONS 0 (|spadConstant| $ 50)))
                   ((NULL (CDR |t|))
                    (SEQ (LETT |rm| (|SPADfirst| |t|) . #0#)
                         (EXIT (COND
                                 ((SPADCALL (QCDR |rm|)
                                      (|spadConstant| $ 18)
                                      (QREFELT $ 79))
                                  (CONS 0 (QCAR |rm|)))
                                 ('T (CONS 1 "failed"))))))
                   ('T (CONS 1 "failed")))))))) 

(DEFUN |MODOP;retractIfCan;$U;31| (|x| $)
  (PROG (|r| |t| |rm|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 97))
                 . #0=(|MODOP;retractIfCan;$U;31|))
           (EXIT (COND
                   ((OR (QEQCAR |r| 1)
                        (OR (NULL (LETT |t| (QCDR |r|) . #0#))
                            (NULL (NULL (CDR |t|)))))
                    (CONS 1 "failed"))
                   ('T
                    (SEQ (LETT |rm| (|SPADfirst| |t|) . #0#)
                         (EXIT (COND
                                 ((SPADCALL (QCAR |rm|)
                                      (|spadConstant| $ 16)
                                      (QREFELT $ 77))
                                  (SPADCALL (QCDR |rm|) (QREFELT $ 99)))
                                 ('T (CONS 1 "failed")))))))))))) 

(DEFUN |MODOP;*;R2$;32| (|r| |x| $)
  (SPADCALL (SPADCALL |r| (QREFELT $ 22)) |x| (QREFELT $ 55))) 

(DEFUN |MODOP;*;$R$;33| (|x| |r| $)
  (SPADCALL |x| (SPADCALL |r| (QREFELT $ 22)) (QREFELT $ 55))) 

(DEFUN |MODOP;adjoint;2$;34| (|x| $)
  (PROG (|t| #0=#:G1997 #1=#:G1994 #2=#:G1992 #3=#:G1993)
    (RETURN
      (SEQ (PROGN
             (LETT #3# NIL . #4=(|MODOP;adjoint;2$;34|))
             (SEQ (LETT |t| NIL . #4#)
                  (LETT #0# (SPADCALL |x| (QREFELT $ 34)) . #4#) G190
                  (COND
                    ((OR (ATOM #0#)
                         (PROGN (LETT |t| (CAR #0#) . #4#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (PROGN
                               (LETT #1#
                                     (SPADCALL (QCDR |t|)
                                      (|MODOP;termadj| (QCAR |t|) $)
                                      (QREFELT $ 103)) . #4#)
                               (COND
                                 (#3# (LETT #2#
                                       (SPADCALL #2# #1#
                                        (QREFELT $ 80)) . #4#))
                                 ('T
                                  (PROGN
                                    (LETT #2# #1# . #4#)
                                    (LETT #3# 'T . #4#)))))))
                  (LETT #0# (CDR #0#) . #4#) (GO G190) G191 (EXIT NIL))
             (COND (#3# #2#) ('T (|spadConstant| $ 26)))))))) 

(DEFUN |MODOP;rmadj| (|t| $)
  (SPADCALL (SPADCALL (QCAR |t|) (QREFELT $ 105))
      (|MODOP;monomadj| (QCDR |t|) $) (QREFELT $ 101))) 

(DEFUN |MODOP;adjoint;3$;36| (|op| |adj| $)
  (|MODOP;nocopy|
      (SPADCALL (SPADCALL |op| (QREFELT $ 45)) (QREFELT $ 12)
          (SPADCALL |adj| (QREFELT $ 107)) (QREFELT $ 47))
      $)) 

(DEFUN |MODOP;termadj| (|t| $)
  (PROG (|rm| #0=#:G2005 |ans|)
    (RETURN
      (SEQ (LETT |ans| (|spadConstant| $ 15) . #1=(|MODOP;termadj|))
           (SEQ (LETT |rm| NIL . #1#) (LETT #0# |t| . #1#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |rm| (CAR #0#) . #1#) NIL))
                   (GO G191)))
                (SEQ (EXIT (LETT |ans|
                                 (SPADCALL (|MODOP;rmadj| |rm| $) |ans|
                                     (QREFELT $ 55)) . #1#)))
                (LETT #0# (CDR #0#) . #1#) (GO G190) G191 (EXIT NIL))
           (EXIT |ans|))))) 

(DEFUN |MODOP;monomadj| (|m| $)
  (PROG (|rec| #0=#:G2010 |ans|)
    (RETURN
      (SEQ (LETT |ans| (|spadConstant| $ 15) . #1=(|MODOP;monomadj|))
           (SEQ (LETT |rec| NIL . #1#)
                (LETT #0# (SPADCALL |m| (QREFELT $ 92)) . #1#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |rec| (CAR #0#) . #1#) NIL))
                   (GO G191)))
                (SEQ (EXIT (LETT |ans|
                                 (SPADCALL
                                     (SPADCALL
                                      (|MODOP;opadj| (QCAR |rec|) $)
                                      (QCDR |rec|) (QREFELT $ 64))
                                     |ans| (QREFELT $ 55)) . #1#)))
                (LETT #0# (CDR #0#) . #1#) (GO G190) G191 (EXIT NIL))
           (EXIT |ans|))))) 

(DEFUN |MODOP;opadj| (|op| $)
  (PROG (|adj|)
    (RETURN
      (SEQ (LETT |adj| (SPADCALL |op| (QREFELT $ 12) (QREFELT $ 87))
                 |MODOP;opadj|)
           (EXIT (COND
                   ((QEQCAR |adj| 1)
                    (|error| "adjoint: operator does not have a defined adjoint"))
                   ('T (QCDR |adj|)))))))) 

(DEFUN |MODOP;conjug;2R;40| (|r| $) (SPADCALL |r| (QREFELT $ 109))) 

(PUT '|MODOP;conjug;2R;41| '|SPADreplace| '(XLAM (|r|) |r|)) 

(DEFUN |MODOP;conjug;2R;41| (|r| $) |r|) 

(DEFUN |ModuleOperator| (&REST #0=#:G2018)
  (PROG ()
    (RETURN
      (PROG (#1=#:G2019)
        (RETURN
          (COND
            ((LETT #1#
                   (|lassocShiftWithFunction| (|devaluateList| #0#)
                       (HGET |$ConstructorCache| '|ModuleOperator|)
                       '|domainEqualList|)
                   . #2=(|ModuleOperator|))
             (|CDRwithIncrement| #1#))
            ('T
             (UNWIND-PROTECT
               (PROG1 (APPLY (|function| |ModuleOperator;|) #0#)
                 (LETT #1# T . #2#))
               (COND
                 ((NOT #1#)
                  (HREM |$ConstructorCache| '|ModuleOperator|))))))))))) 

(DEFUN |ModuleOperator;| (|#1| |#2|)
  (PROG (DV$1 DV$2 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|) . #0=(|ModuleOperator|))
        (LETT DV$2 (|devaluate| |#2|) . #0#)
        (LETT |dv$| (LIST '|ModuleOperator| DV$1 DV$2) . #0#)
        (LETT $ (GETREFV 111) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3
            (LETT |pv$|
                  (|buildPredVector| 0 0
                      (LIST (|HasCategory| |#1| '(|CommutativeRing|))
                            (|HasCategory| |#1|
                                '(|CharacteristicNonZero|))
                            (|HasCategory| |#1|
                                '(|CharacteristicZero|)))) . #0#))
        (|haddProp| |$ConstructorCache| '|ModuleOperator|
            (LIST DV$1 DV$2) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7 |#2|)
        (QSETREFV $ 8
            (|FreeAbelianGroup|
                (|List| (|Record| (|:| |coef| |#1|)
                            (|:| |monom|
                                 (|FreeGroup| (|BasicOperator|)))))))
        (QSETREFV $ 12 (SPADCALL "%opAdjoint" (QREFELT $ 11)))
        (QSETREFV $ 13 (SPADCALL "%opEval" (QREFELT $ 11)))
        (QSETREFV $ 14 (SPADCALL "%invEval" (QREFELT $ 11)))
        (COND
          ((|HasCategory| |#1| '(|OrderedSet|))
           (QSETREFV $ 19
               (CONS (|dispatchFunction| |MODOP;makeop;RFg$;12|) $)))
          ('T
           (QSETREFV $ 19
               (CONS (|dispatchFunction| |MODOP;makeop;RFg$;13|) $))))
        (COND
          ((|HasCategory| |#2| '(|ExpressionSpace|))
           (QSETREFV $ 89
               (CONS (|dispatchFunction| |MODOP;opeval;Bo2M;24|) $)))
          ('T
           (QSETREFV $ 89
               (CONS (|dispatchFunction| |MODOP;opeval;Bo2M;25|) $))))
        (COND
          ((|testBitVector| |pv$| 1)
           (PROGN
             (QSETREFV $ 101
                 (CONS (|dispatchFunction| |MODOP;*;R2$;32|) $))
             (QSETREFV $ 102
                 (CONS (|dispatchFunction| |MODOP;*;$R$;33|) $))
             (QSETREFV $ 104
                 (CONS (|dispatchFunction| |MODOP;adjoint;2$;34|) $))
             (QSETREFV $ 108
                 (CONS (|dispatchFunction| |MODOP;adjoint;3$;36|) $))
             (COND
               ((|HasSignature| |#1|
                    (LIST '|conjugate|
                          (LIST (|devaluate| |#1|) (|devaluate| |#1|))))
                (QSETREFV $ 105
                    (CONS (|dispatchFunction| |MODOP;conjug;2R;40|) $)))
               ('T
                (QSETREFV $ 105
                    (CONS (|dispatchFunction| |MODOP;conjug;2R;41|) $)))))))
        $)))) 

(MAKEPROP '|ModuleOperator| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL (|FreeAbelianGroup| 43) (|local| |#1|)
             (|local| |#2|) '|Rep| (|String|) (|Symbol|) (0 . |coerce|)
             'OPADJ 'OPEVAL 'INVEVAL
             (CONS IDENTITY
                   (FUNCALL (|dispatchFunction| |MODOP;One;$;1|) $))
             (5 . |One|) (|FreeGroup| 27) (9 . |One|) (13 . |makeop|)
             (|Integer|) (19 . |coerce|) |MODOP;coerce;R$;3|
             |MODOP;coerce;I$;2| (|Boolean|) (24 . |zero?|)
             (29 . |Zero|) (|BasicOperator|) (33 . |copy|)
             |MODOP;coerce;Bo$;4| (38 . |coerce|)
             (|Record| (|:| |coef| 6) (|:| |monom| 17))
             (|Record| (|:| |gen| 43) (|:| |exp| 20)) (|List| 32)
             (43 . |terms|) (48 . *) (54 . +) (60 . |Zero|)
             |MODOP;elt;$2M;6| (64 . *) (|NonNegativeInteger|)
             (70 . |characteristic|) |MODOP;characteristic;Nni;9|
             (|List| 31) (74 . |coerce|) (79 . |retract|) (|None|)
             (84 . |setProperty|) (|Mapping| 7 7)
             |MODOP;evaluate;$M$;11| (91 . |Zero|) (95 . <) (101 . -)
             (106 . -) (111 . |inv|) |MODOP;*;3$;21|
             (|Union| $ '"failed") (116 . |recip|) (121 . |Zero|)
             (125 . |Zero|) (|PositiveInteger|) (|RepeatedSquaring| $$)
             (129 . |expt|) (135 . |retract|) |MODOP;**;$I$;15|
             |MODOP;evaluateInverse;$M$;16| (140 . |zero?|)
             (|OutputForm|) (145 . |coerce|) (150 . +)
             (|Mapping| 67 67 67) (|List| 67) (156 . |reduce|)
             |MODOP;coerce;$Of;17| (162 . -) (167 . |coerce|) (172 . *)
             (178 . =) (184 . |coerce|) (189 . =) (195 . +) (201 . *)
             (207 . |last|) (212 . *) (218 . |concat!|) (224 . *)
             (|Union| 46 '"failed") (230 . |property|) (236 . |kernel|)
             (242 . |opeval|) (|Record| (|:| |gen| 27) (|:| |exp| 20))
             (|List| 90) (248 . |factors|) (|Union| 6 '"failed")
             |MODOP;retractIfCan;$U;30| |MODOP;recip;$U;29|
             (|Union| 43 '"failed") (253 . |retractIfCan|)
             (|Union| 27 '"failed") (258 . |retractIfCan|)
             |MODOP;retractIfCan;$U;31| (263 . *) (269 . *) (275 . *)
             (281 . |adjoint|) (286 . |conjug|) (|NoneFunctions1| $$)
             (291 . |coerce|) (296 . |adjoint|) (302 . |conjugate|)
             (|SingleInteger|))
          '#(~= 307 |zero?| 313 |subtractIfCan| 318 |sample| 324
             |retractIfCan| 328 |retract| 338 |recip| 348 |opeval| 353
             |one?| 359 |makeop| 364 |latex| 370 |hash| 375
             |evaluateInverse| 380 |evaluate| 386 |elt| 392 |conjug|
             398 |coerce| 403 |charthRoot| 423 |characteristic| 428
             |adjoint| 432 ^ 443 |Zero| 455 |One| 459 = 463 - 469 + 480
             ** 486 * 510)
          'NIL
          (CONS (|makeByteWordVec2| 3
                    '(1 1 2 3 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
                      0))
                (CONS '#(|Algebra&| |Module&| NIL NIL |Ring&| NIL NIL
                         NIL NIL NIL |AbelianGroup&| NIL NIL
                         |AbelianMonoid&| |Monoid&| NIL |SemiGroup&|
                         |AbelianSemiGroup&| |SetCategory&| NIL
                         |RetractableTo&| |RetractableTo&| NIL
                         |BasicType&| NIL)
                      (CONS '#((|Algebra| 6) (|Module| 6)
                               (|CharacteristicNonZero|)
                               (|CharacteristicZero|) (|Ring|)
                               (|BiModule| 6 6) (|Rng|)
                               (|LeftModule| $$) (|LeftModule| 6)
                               (|RightModule| 6) (|AbelianGroup|)
                               (|CancellationAbelianMonoid|)
                               (|SemiRing|) (|AbelianMonoid|)
                               (|Monoid|) (|SemiRng|) (|SemiGroup|)
                               (|AbelianSemiGroup|) (|SetCategory|)
                               (|Eltable| 7 7) (|RetractableTo| 27)
                               (|RetractableTo| 6) (|unitsKnown|)
                               (|BasicType|) (|CoercibleTo| 67))
                            (|makeByteWordVec2| 110
                                '(1 10 0 9 11 0 6 0 16 0 17 0 18 2 0 0
                                  6 17 19 1 6 0 20 21 1 6 24 0 25 0 0 0
                                  26 1 27 0 0 28 1 17 0 27 30 1 8 33 0
                                  34 2 7 0 20 0 35 2 7 0 0 0 36 0 7 0
                                  37 2 7 0 6 0 39 0 6 40 41 1 8 0 43 44
                                  1 0 27 0 45 3 27 0 0 10 46 47 0 6 0
                                  50 2 6 24 0 0 51 1 6 0 0 52 1 0 0 0
                                  53 1 17 0 0 54 1 6 56 0 57 0 8 0 58 0
                                  5 0 59 2 61 2 2 60 62 1 8 43 0 63 1 0
                                  24 0 66 1 6 67 0 68 2 67 0 0 0 69 2
                                  71 67 70 0 72 1 67 0 0 74 1 20 67 0
                                  75 2 67 0 0 0 76 2 6 24 0 0 77 1 17
                                  67 0 78 2 17 24 0 0 79 2 0 0 0 0 80 2
                                  6 0 20 0 81 1 43 31 0 82 2 17 0 0 0
                                  83 2 43 0 0 0 84 2 6 0 0 0 85 2 27 86
                                  0 10 87 2 7 0 27 0 88 2 0 7 27 7 89 1
                                  17 91 0 92 1 8 96 0 97 1 17 98 0 99 2
                                  0 0 6 0 101 2 0 0 0 6 102 2 0 0 20 0
                                  103 1 0 0 0 104 1 0 6 6 105 1 106 46
                                  2 107 2 0 0 0 0 108 1 6 0 0 109 2 0
                                  24 0 0 1 1 0 24 0 66 2 0 56 0 0 1 0 0
                                  0 1 1 0 98 0 100 1 0 93 0 94 1 0 27 0
                                  45 1 0 6 0 1 1 0 56 0 95 2 0 7 27 7
                                  89 1 0 24 0 1 2 0 0 6 17 19 1 0 9 0 1
                                  1 0 110 0 1 2 0 0 0 48 65 2 0 0 0 48
                                  49 2 0 7 0 7 38 1 1 6 6 105 1 0 0 27
                                  29 1 0 0 6 22 1 0 0 20 23 1 0 67 0 73
                                  1 2 56 0 1 0 0 40 42 2 1 0 0 0 108 1
                                  1 0 0 104 2 0 0 0 40 1 2 0 0 0 60 1 0
                                  0 0 26 0 0 0 15 2 0 24 0 0 1 2 0 0 0
                                  0 1 1 0 0 0 53 2 0 0 0 0 80 2 0 0 0
                                  20 64 2 0 0 27 20 1 2 0 0 0 40 1 2 0
                                  0 0 60 1 2 1 0 0 6 102 2 1 0 6 0 101
                                  2 0 0 20 0 103 2 0 0 0 0 55 2 0 0 40
                                  0 1 2 0 0 60 0 1)))))
          '|lookupComplete|)) 
