
(/VERSIONCHECK 2) 

(DEFUN |SFQCMPK;squareFreeFactors| (|lp| $)
  (PROG (|lsflp| |lsfp| #1=#:G730 |p|)
    (RETURN
     (SEQ (LETT |lsflp| NIL . #2=(|SFQCMPK;squareFreeFactors|))
          (SEQ (LETT |p| NIL . #2#) (LETT #1# |lp| . #2#) G190
               (COND
                ((OR (ATOM #1#) (PROGN (LETT |p| (CAR #1#) . #2#) NIL))
                 (GO G191)))
               (SEQ (LETT |lsfp| (SPADCALL |p| (QREFELT $ 13)) . #2#)
                    (EXIT
                     (LETT |lsflp| (SPADCALL |lsfp| |lsflp| (QREFELT $ 14))
                           . #2#)))
               (LETT #1# (CDR #1#) . #2#) (GO G190) G191 (EXIT NIL))
          (EXIT
           (SPADCALL (ELT $ 16) (SPADCALL |lsflp| (QREFELT $ 17))
                     (QREFELT $ 19))))))) 

(DEFUN |SFQCMPK;startTable!;3SV;2| (|ok| |ko| |domainName| $)
  (SEQ (SPADCALL (QREFELT $ 23))
       (COND
        ((NULL (SPADCALL |ok| (QREFELT $ 25)))
         (COND
          ((NULL (SPADCALL |ko| (QREFELT $ 25)))
           (SPADCALL |ok| |ko| (QREFELT $ 26))))))
       (COND
        ((NULL (SPADCALL |domainName| (QREFELT $ 25)))
         (SPADCALL |domainName| (QREFELT $ 27))))
       (EXIT (SPADCALL (QREFELT $ 28))))) 

(DEFUN |SFQCMPK;stopTable!;V;3| ($)
  (SEQ (COND ((SPADCALL (QREFELT $ 30)) (SPADCALL (QREFELT $ 31))))
       (EXIT (SPADCALL (QREFELT $ 32))))) 

(DEFUN |SFQCMPK;supDimElseRittWu?;2TSB;4| (|ts| |us| $)
  (PROG (|lp2| |lp1|)
    (RETURN
     (SEQ
      (COND
       ((< (SPADCALL |ts| (QREFELT $ 35)) (SPADCALL |us| (QREFELT $ 35))) 'T)
       ((< (SPADCALL |us| (QREFELT $ 35)) (SPADCALL |ts| (QREFELT $ 35))) 'NIL)
       (#1='T
        (SEQ
         (LETT |lp1| (SPADCALL |ts| (QREFELT $ 36))
               . #2=(|SFQCMPK;supDimElseRittWu?;2TSB;4|))
         (LETT |lp2| (SPADCALL |us| (QREFELT $ 36)) . #2#)
         (SEQ G190
              (COND
               ((NULL
                 (COND
                  ((OR (NULL |lp1|)
                       (SPADCALL (|SPADfirst| |lp2|) (|SPADfirst| |lp1|)
                                 (QREFELT $ 16)))
                   'NIL)
                  ('T 'T)))
                (GO G191)))
              (SEQ (LETT |lp1| (CDR |lp1|) . #2#)
                   (EXIT (LETT |lp2| (CDR |lp2|) . #2#)))
              NIL (GO G190) G191 (EXIT NIL))
         (EXIT (COND ((NULL |lp1|) 'NIL) (#1# 'T)))))))))) 

(DEFUN |SFQCMPK;algebraicSort;2L;5| (|lts| $)
  (SEQ
   (LETT |lts| (SPADCALL |lts| (QREFELT $ 39)) |SFQCMPK;algebraicSort;2L;5|)
   (EXIT (SPADCALL (ELT $ 37) |lts| (QREFELT $ 41))))) 

(DEFUN |SFQCMPK;moreAlgebraic?;2TSB;6| (|ts| |us| $)
  (PROG (#1=#:G752 #2=#:G757 #3=#:G758 |p|)
    (RETURN
     (SEQ
      (EXIT
       (COND ((SPADCALL |ts| (QREFELT $ 43)) (SPADCALL |us| (QREFELT $ 43)))
             ((SPADCALL |us| (QREFELT $ 43)) 'T)
             ((< (SPADCALL |ts| (QREFELT $ 35)) (SPADCALL |us| (QREFELT $ 35)))
              'NIL)
             ('T
              (SEQ
               (SEQ
                (EXIT
                 (SEQ (LETT |p| NIL . #4=(|SFQCMPK;moreAlgebraic?;2TSB;6|))
                      (LETT #3# (SPADCALL |us| (QREFELT $ 36)) . #4#) G190
                      (COND
                       ((OR (ATOM #3#) (PROGN (LETT |p| (CAR #3#) . #4#) NIL))
                        (GO G191)))
                      (SEQ
                       (EXIT
                        (COND
                         ((NULL
                           (SPADCALL (SPADCALL |p| (QREFELT $ 44)) |ts|
                                     (QREFELT $ 45)))
                          (PROGN
                           (LETT #1# (PROGN (LETT #2# 'NIL . #4#) (GO #2#))
                                 . #4#)
                           (GO #1#))))))
                      (LETT #3# (CDR #3#) . #4#) (GO G190) G191 (EXIT NIL)))
                #1# (EXIT #1#))
               (EXIT 'T)))))
      #2# (EXIT #2#))))) 

(DEFUN |SFQCMPK;subTriSet?;2TSB;7| (|ts| |us| $)
  (PROG (#1=#:G763 #2=#:G769)
    (RETURN
     (COND ((SPADCALL |ts| (QREFELT $ 43)) 'T)
           ((OR (SPADCALL |us| (QREFELT $ 43))
                (SPADCALL (SPADCALL |us| (QREFELT $ 47))
                          (SPADCALL |ts| (QREFELT $ 47)) (QREFELT $ 48)))
            'NIL)
           ((SPADCALL (SPADCALL |ts| (QREFELT $ 47))
                      (SPADCALL |us| (QREFELT $ 47)) (QREFELT $ 48))
            (SPADCALL |ts|
                      (PROG2
                          (LETT #1# (SPADCALL |us| (QREFELT $ 50))
                                . #3=(|SFQCMPK;subTriSet?;2TSB;7|))
                          (QCDR #1#)
                        (|check-union| (QEQCAR #1# 0) (QREFELT $ 10) #1#))
                      (QREFELT $ 51)))
           ((SPADCALL
             (PROG2
                 (LETT #2# (SPADCALL |ts| (QREFELT $ 53)) . #3#)
                 (QCDR #2#)
               (|check-union| (QEQCAR #2# 0) (QREFELT $ 9) #2#))
             (PROG2
                 (LETT #2# (SPADCALL |us| (QREFELT $ 53)) . #3#)
                 (QCDR #2#)
               (|check-union| (QEQCAR #2# 0) (QREFELT $ 9) #2#))
             (QREFELT $ 54))
            (SPADCALL
             (PROG2
                 (LETT #1# (SPADCALL |ts| (QREFELT $ 50)) . #3#)
                 (QCDR #1#)
               (|check-union| (QEQCAR #1# 0) (QREFELT $ 10) #1#))
             (PROG2
                 (LETT #1# (SPADCALL |us| (QREFELT $ 50)) . #3#)
                 (QCDR #1#)
               (|check-union| (QEQCAR #1# 0) (QREFELT $ 10) #1#))
             (QREFELT $ 51)))
           ('T 'NIL))))) 

(DEFUN |SFQCMPK;internalSubPolSet?;2LB;8| (|lp1| |lp2| $)
  (COND ((NULL |lp1|) 'T) ((NULL |lp2|) 'NIL)
        ((SPADCALL (|SPADfirst| |lp1|) (|SPADfirst| |lp2|) (QREFELT $ 55))
         (SPADCALL (CDR |lp1|) (CDR |lp2|) (QREFELT $ 56)))
        ((SPADCALL (|SPADfirst| |lp1|) (|SPADfirst| |lp2|) (QREFELT $ 16))
         'NIL)
        ('T (SPADCALL |lp1| (CDR |lp2|) (QREFELT $ 56))))) 

(DEFUN |SFQCMPK;subPolSet?;2LB;9| (|lp1| |lp2| $)
  (SEQ
   (LETT |lp1| (SPADCALL (ELT $ 16) |lp1| (QREFELT $ 19))
         . #1=(|SFQCMPK;subPolSet?;2LB;9|))
   (LETT |lp2| (SPADCALL (ELT $ 16) |lp2| (QREFELT $ 19)) . #1#)
   (EXIT (SPADCALL |lp1| |lp2| (QREFELT $ 56))))) 

(DEFUN |SFQCMPK;infRittWu?;2LB;10| (|lp1| |lp2| $)
  (SEQ
   (LETT |lp1| (SPADCALL (ELT $ 16) |lp1| (QREFELT $ 19))
         . #1=(|SFQCMPK;infRittWu?;2LB;10|))
   (LETT |lp2| (SPADCALL (ELT $ 16) |lp2| (QREFELT $ 19)) . #1#)
   (EXIT (SPADCALL |lp1| |lp2| (QREFELT $ 58))))) 

(DEFUN |SFQCMPK;internalInfRittWu?;2LB;11| (|lp1| |lp2| $)
  (COND ((NULL |lp1|) (COND ((NULL |lp2|) 'NIL) (#1='T 'T)))
        ((NULL |lp2|) 'NIL)
        ((SPADCALL (|SPADfirst| |lp1|) (|SPADfirst| |lp2|) (QREFELT $ 16)) 'T)
        ((SPADCALL (|SPADfirst| |lp2|) (|SPADfirst| |lp1|) (QREFELT $ 16))
         'NIL)
        (#1# (SPADCALL (CDR |lp1|) (CDR |lp2|) (QREFELT $ 59))))) 

(DEFUN |SFQCMPK;subCase?;2RB;12| (|lpwt1| |lpwt2| $)
  (COND ((NULL (SPADCALL (QCAR |lpwt2|) (QCAR |lpwt1|) (QREFELT $ 56))) 'NIL)
        ('T (SPADCALL (QCDR |lpwt1|) (QCDR |lpwt2|) (QREFELT $ 60))))) 

(DEFUN |SFQCMPK;internalSubQuasiComponent?;2TSU;13| (|ts| |us| $)
  (PROG (#1=#:G815 |b| #2=#:G818 |p| |lsfp| #3=#:G807 #4=#:G817 #5=#:G805
         #6=#:G802 #7=#:G816)
    (RETURN
     (SEQ
      (EXIT
       (COND ((SPADCALL |us| |ts| (QREFELT $ 51)) (CONS 0 'T))
             ((NULL (SPADCALL |ts| |us| (QREFELT $ 46))) (CONS 0 'NIL))
             ('T
              (SEQ
               (SEQ
                (EXIT
                 (SEQ
                  (LETT |p| NIL
                        . #8=(|SFQCMPK;internalSubQuasiComponent?;2TSU;13|))
                  (LETT #7# (SPADCALL |us| (QREFELT $ 36)) . #8#) G190
                  (COND
                   ((OR (ATOM #7#) (PROGN (LETT |p| (CAR #7#) . #8#) NIL))
                    #9=(GO G191)))
                  (SEQ
                   (EXIT
                    (COND
                     ((< (SPADCALL |p| (QREFELT $ 63))
                         (SPADCALL
                          (PROG2
                              (LETT #6#
                                    (SPADCALL |ts|
                                              (SPADCALL |p| (QREFELT $ 44))
                                              (QREFELT $ 64))
                                    . #8#)
                              (QCDR #6#)
                            (|check-union| (QEQCAR #6# 0) (QREFELT $ 9) #6#))
                          (QREFELT $ 63)))
                      (PROGN
                       (LETT #5#
                             (PROGN
                              (LETT #1# (CONS 1 "failed") . #8#)
                              (GO #1#))
                             . #8#)
                       (GO #5#))))))
                  (LETT #7# (CDR #7#) . #8#) #10=(GO G190) G191 (EXIT NIL)))
                #5# (EXIT #5#))
               (SEQ
                (EXIT
                 (SEQ (LETT |p| NIL . #8#)
                      (LETT #4# (SPADCALL |us| (QREFELT $ 36)) . #8#) G190
                      (COND
                       ((OR (ATOM #4#) (PROGN (LETT |p| (CAR #4#) . #8#) NIL))
                        #9#))
                      (SEQ
                       (EXIT
                        (COND
                         ((NULL
                           (SPADCALL (SPADCALL |p| |ts| (QREFELT $ 65))
                                     (QREFELT $ 66)))
                          (PROGN
                           (LETT #3#
                                 (PROGN
                                  (LETT #1# (CONS 1 "failed") . #8#)
                                  (GO #1#))
                                 . #8#)
                           (GO #3#))))))
                      (LETT #4# (CDR #4#) . #8#) #10# G191 (EXIT NIL)))
                #3# (EXIT #3#))
               (LETT |lsfp|
                     (|SFQCMPK;squareFreeFactors|
                      (SPADCALL |us| (QREFELT $ 67)) $)
                     . #8#)
               (SEQ (LETT |p| NIL . #8#) (LETT #2# |lsfp| . #8#) G190
                    (COND
                     ((OR (ATOM #2#) (PROGN (LETT |p| (CAR #2#) . #8#) NIL))
                      #9#))
                    (SEQ (LETT |b| (SPADCALL |p| |ts| (QREFELT $ 68)) . #8#)
                         (EXIT
                          (COND
                           ((NULL |b|)
                            (PROGN (LETT #1# (CONS 0 'NIL) . #8#) (GO #1#))))))
                    (LETT #2# (CDR #2#) . #8#) #10# G191 (EXIT NIL))
               (EXIT (CONS 0 'T))))))
      #1# (EXIT #1#))))) 

(DEFUN |SFQCMPK;internalSubQuasiComponent?;2TSU;14| (|ts| |us| $)
  (PROG (#1=#:G829 #2=#:G832 #3=#:G834 |p| #4=#:G827 #5=#:G824 #6=#:G833)
    (RETURN
     (SEQ
      (EXIT
       (COND ((SPADCALL |us| |ts| (QREFELT $ 51)) (CONS 0 'T))
             ((NULL (SPADCALL |ts| |us| (QREFELT $ 46))) (CONS 0 'NIL))
             ('T
              (SEQ
               (SEQ
                (EXIT
                 (SEQ
                  (LETT |p| NIL
                        . #7=(|SFQCMPK;internalSubQuasiComponent?;2TSU;14|))
                  (LETT #6# (SPADCALL |us| (QREFELT $ 36)) . #7#) G190
                  (COND
                   ((OR (ATOM #6#) (PROGN (LETT |p| (CAR #6#) . #7#) NIL))
                    #8=(GO G191)))
                  (SEQ
                   (EXIT
                    (COND
                     ((< (SPADCALL |p| (QREFELT $ 63))
                         (SPADCALL
                          (PROG2
                              (LETT #5#
                                    (SPADCALL |ts|
                                              (SPADCALL |p| (QREFELT $ 44))
                                              (QREFELT $ 64))
                                    . #7#)
                              (QCDR #5#)
                            (|check-union| (QEQCAR #5# 0) (QREFELT $ 9) #5#))
                          (QREFELT $ 63)))
                      (PROGN
                       (LETT #4#
                             (PROGN
                              (LETT #2# (CONS 1 "failed") . #7#)
                              (GO #2#))
                             . #7#)
                       (GO #4#))))))
                  (LETT #6# (CDR #6#) . #7#) #9=(GO G190) G191 (EXIT NIL)))
                #4# (EXIT #4#))
               (SEQ
                (EXIT
                 (SEQ (LETT |p| NIL . #7#)
                      (LETT #3# (SPADCALL |us| (QREFELT $ 36)) . #7#) G190
                      (COND
                       ((OR (ATOM #3#) (PROGN (LETT |p| (CAR #3#) . #7#) NIL))
                        #8#))
                      (SEQ
                       (EXIT
                        (COND
                         ((NULL
                           (SPADCALL (SPADCALL |p| |ts| (QREFELT $ 71))
                                     (QREFELT $ 66)))
                          (PROGN
                           (LETT #1#
                                 (PROGN
                                  (LETT #2# (CONS 1 "failed") . #7#)
                                  (GO #2#))
                                 . #7#)
                           (GO #1#))))))
                      (LETT #3# (CDR #3#) . #7#) #9# G191 (EXIT NIL)))
                #1# (EXIT #1#))
               (EXIT (CONS 0 'T))))))
      #2# (EXIT #2#))))) 

(DEFUN |SFQCMPK;subQuasiComponent?;2TSB;15| (|ts| |us| $)
  (PROG (|b| |ubf| |e| |k|)
    (RETURN
     (SEQ
      (LETT |k| (CONS |ts| |us|) . #1=(|SFQCMPK;subQuasiComponent?;2TSB;15|))
      (LETT |e| (SPADCALL |k| (QREFELT $ 72)) . #1#)
      (EXIT
       (COND ((QEQCAR |e| 0) (QCDR |e|))
             (#2='T
              (SEQ (LETT |ubf| (SPADCALL |ts| |us| (QREFELT $ 70)) . #1#)
                   (LETT |b| (COND ((QEQCAR |ubf| 0) (QCDR |ubf|)) (#2# 'NIL))
                         . #1#)
                   (SPADCALL |k| |b| (QREFELT $ 73)) (EXIT |b|))))))))) 

(DEFUN |SFQCMPK;subQuasiComponent?;TSLB;16| (|ts| |lus| $)
  (PROG (#1=#:G843 #2=#:G845 #3=#:G846 |us|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (SEQ
         (EXIT
          (SEQ (LETT |us| NIL . #4=(|SFQCMPK;subQuasiComponent?;TSLB;16|))
               (LETT #3# |lus| . #4#) G190
               (COND
                ((OR (ATOM #3#) (PROGN (LETT |us| (CAR #3#) . #4#) NIL))
                 (GO G191)))
               (SEQ
                (EXIT
                 (COND
                  ((SPADCALL |ts| |us| (QREFELT $ 60))
                   (PROGN
                    (LETT #1# (PROGN (LETT #2# 'T . #4#) (GO #2#)) . #4#)
                    (GO #1#))))))
               (LETT #3# (CDR #3#) . #4#) (GO G190) G191 (EXIT NIL)))
         #1# (EXIT #1#))
        (EXIT 'NIL)))
      #2# (EXIT #2#))))) 

(DEFUN |SFQCMPK;removeSuperfluousCases;2L;17| (|cases| $)
  (PROG (|toSee| |headmaxcases| |copymaxcases| |maxcases| |toSave| |lpwt1|
         #1=#:G869 |lpwt2|)
    (RETURN
     (SEQ
      (COND ((< (LENGTH |cases|) 2) |cases|)
            ('T
             (SEQ
              (LETT |toSee|
                    (SPADCALL
                     (CONS #'|SFQCMPK;removeSuperfluousCases;2L;17!0| $)
                     |cases| (QREFELT $ 77))
                    . #2=(|SFQCMPK;removeSuperfluousCases;2L;17|))
              (SEQ G190
                   (COND
                    ((NULL (COND ((NULL |toSee|) 'NIL) ('T 'T))) #3=(GO G191)))
                   (SEQ (LETT |lpwt1| (|SPADfirst| |toSee|) . #2#)
                        (LETT |toSee| (CDR |toSee|) . #2#)
                        (LETT |toSave| NIL . #2#)
                        (SEQ (LETT |lpwt2| NIL . #2#) (LETT #1# |toSee| . #2#)
                             G190
                             (COND
                              ((OR (ATOM #1#)
                                   (PROGN (LETT |lpwt2| (CAR #1#) . #2#) NIL))
                               #3#))
                             (SEQ
                              (EXIT
                               (COND
                                ((SPADCALL |lpwt1| |lpwt2| (QREFELT $ 62))
                                 (LETT |lpwt1| |lpwt2| . #2#))
                                ((NULL
                                  (SPADCALL |lpwt2| |lpwt1| (QREFELT $ 62)))
                                 (LETT |toSave| (CONS |lpwt2| |toSave|)
                                       . #2#)))))
                             (LETT #1# (CDR #1#) . #2#) #4=(GO G190) G191
                             (EXIT NIL))
                        (COND
                         ((NULL |maxcases|)
                          (SEQ (LETT |headmaxcases| (LIST |lpwt1|) . #2#)
                               (EXIT (LETT |maxcases| |headmaxcases| . #2#))))
                         ('T
                          (SEQ (LETT |copymaxcases| |maxcases| . #2#)
                               (SEQ G190
                                    (COND
                                     ((NULL
                                       (COND
                                        ((OR (NULL |copymaxcases|)
                                             (SPADCALL |lpwt1|
                                                       (|SPADfirst|
                                                        |copymaxcases|)
                                                       (QREFELT $ 62)))
                                         'NIL)
                                        ('T 'T)))
                                      #3#))
                                    (SEQ
                                     (EXIT
                                      (LETT |copymaxcases| (CDR |copymaxcases|)
                                            . #2#)))
                                    NIL #4# G191 (EXIT NIL))
                               (EXIT
                                (COND
                                 ((NULL |copymaxcases|)
                                  (SEQ
                                   (SPADCALL |headmaxcases| (LIST |lpwt1|)
                                             (QREFELT $ 78))
                                   (EXIT
                                    (LETT |headmaxcases| (CDR |headmaxcases|)
                                          . #2#)))))))))
                        (EXIT (LETT |toSee| (REVERSE |toSave|) . #2#)))
                   NIL #4# G191 (EXIT NIL))
              (EXIT |maxcases|)))))))) 

(DEFUN |SFQCMPK;removeSuperfluousCases;2L;17!0| (|x| |y| $)
  (SPADCALL (QCDR |x|) (QCDR |y|) (QREFELT $ 37))) 

(DEFUN |SFQCMPK;removeSuperfluousQuasiComponents;2L;18| (|lts| $)
  (PROG (|toSee| |headmaxlts| |copymaxlts| |maxlts| |toSave| |ts| #1=#:G886
         |us|)
    (RETURN
     (SEQ
      (LETT |lts| (SPADCALL |lts| (QREFELT $ 39))
            . #2=(|SFQCMPK;removeSuperfluousQuasiComponents;2L;18|))
      (EXIT
       (COND ((< (LENGTH |lts|) 2) |lts|)
             ('T
              (SEQ (LETT |toSee| (SPADCALL |lts| (QREFELT $ 42)) . #2#)
                   (SEQ G190
                        (COND
                         ((NULL (COND ((NULL |toSee|) 'NIL) ('T 'T)))
                          #3=(GO G191)))
                        (SEQ (LETT |ts| (|SPADfirst| |toSee|) . #2#)
                             (LETT |toSee| (CDR |toSee|) . #2#)
                             (LETT |toSave| NIL . #2#)
                             (SEQ (LETT |us| NIL . #2#)
                                  (LETT #1# |toSee| . #2#) G190
                                  (COND
                                   ((OR (ATOM #1#)
                                        (PROGN
                                         (LETT |us| (CAR #1#) . #2#)
                                         NIL))
                                    #3#))
                                  (SEQ
                                   (EXIT
                                    (COND
                                     ((SPADCALL |ts| |us| (QREFELT $ 60))
                                      (LETT |ts| |us| . #2#))
                                     ((NULL
                                       (SPADCALL |us| |ts| (QREFELT $ 60)))
                                      (LETT |toSave| (CONS |us| |toSave|)
                                            . #2#)))))
                                  (LETT #1# (CDR #1#) . #2#) #4=(GO G190) G191
                                  (EXIT NIL))
                             (COND
                              ((NULL |maxlts|)
                               (SEQ (LETT |headmaxlts| (LIST |ts|) . #2#)
                                    (EXIT (LETT |maxlts| |headmaxlts| . #2#))))
                              ('T
                               (SEQ (LETT |copymaxlts| |maxlts| . #2#)
                                    (SEQ G190
                                         (COND
                                          ((NULL
                                            (COND
                                             ((OR (NULL |copymaxlts|)
                                                  (SPADCALL |ts|
                                                            (|SPADfirst|
                                                             |copymaxlts|)
                                                            (QREFELT $ 60)))
                                              'NIL)
                                             ('T 'T)))
                                           #3#))
                                         (SEQ
                                          (EXIT
                                           (LETT |copymaxlts|
                                                 (CDR |copymaxlts|) . #2#)))
                                         NIL #4# G191 (EXIT NIL))
                                    (EXIT
                                     (COND
                                      ((NULL |copymaxlts|)
                                       (SEQ
                                        (SPADCALL |headmaxlts| (LIST |ts|)
                                                  (QREFELT $ 80))
                                        (EXIT
                                         (LETT |headmaxlts| (CDR |headmaxlts|)
                                               . #2#)))))))))
                             (EXIT (LETT |toSee| (REVERSE |toSave|) . #2#)))
                        NIL #4# G191 (EXIT NIL))
                   (EXIT (SPADCALL |maxlts| (QREFELT $ 42))))))))))) 

(DEFUN |SFQCMPK;removeAssociates| (|lp| $)
  (PROG (#1=#:G890 |p| #2=#:G889)
    (RETURN
     (SEQ
      (SPADCALL
       (PROGN
        (LETT #2# NIL . #3=(|SFQCMPK;removeAssociates|))
        (SEQ (LETT |p| NIL . #3#) (LETT #1# |lp| . #3#) G190
             (COND
              ((OR (ATOM #1#) (PROGN (LETT |p| (CAR #1#) . #3#) NIL))
               (GO G191)))
             (SEQ
              (EXIT (LETT #2# (CONS (SPADCALL |p| (QREFELT $ 82)) #2#) . #3#)))
             (LETT #1# (CDR #1#) . #3#) (GO G190) G191 (EXIT (NREVERSE0 #2#))))
       (QREFELT $ 17)))))) 

(DEFUN |SFQCMPK;branchIfCan;LTSL5BU;20|
       (|leq| |ts| |lineq| |b1| |b2| |b3| |b4| |b5| $)
  (PROG (|newleq| #1=#:G920 |newp| #2=#:G908 |g| #3=#:G924 |q| #4=#:G923 |p|
         #5=#:G906 #6=#:G922 #7=#:G901 #8=#:G921 |ps| #9=#:G896)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (COND
         (|b1|
          (SEQ
           (EXIT
            (SEQ
             (LETT |leq| (|SFQCMPK;removeAssociates| |leq| $)
                   . #10=(|SFQCMPK;branchIfCan;LTSL5BU;20|))
             (LETT |leq| (SPADCALL (ELT $ 66) |leq| (QREFELT $ 84)) . #10#)
             (EXIT
              (COND
               ((SPADCALL (ELT $ 85) |leq| (QREFELT $ 86))
                (PROGN
                 (LETT #9# (PROGN (LETT #1# (CONS 1 "failed") . #10#) (GO #1#))
                       . #10#)
                 (GO #9#)))))))
           #9# (EXIT #9#))))
        (COND
         (|b2|
          (COND
           ((SPADCALL (ELT $ 66) |lineq| (QREFELT $ 86))
            (PROGN (LETT #1# (CONS 1 "failed") . #10#) (GO #1#)))
           ('T (LETT |lineq| (SPADCALL |lineq| (QREFELT $ 87)) . #10#)))))
        (COND
         (|b3|
          (SEQ (LETT |ps| (SPADCALL |leq| (QREFELT $ 89)) . #10#)
               (EXIT
                (SEQ
                 (EXIT
                  (SEQ (LETT |q| NIL . #10#) (LETT #8# |lineq| . #10#) G190
                       (COND
                        ((OR (ATOM #8#)
                             (PROGN (LETT |q| (CAR #8#) . #10#) NIL))
                         #11=(GO G191)))
                       (SEQ
                        (EXIT
                         (COND
                          ((SPADCALL
                            (QVELT (SPADCALL |q| |ps| (QREFELT $ 91)) 1)
                            (QREFELT $ 66))
                           (PROGN
                            (LETT #7#
                                  (PROGN
                                   (LETT #1# (CONS 1 "failed") . #10#)
                                   (GO #1#))
                                  . #10#)
                            (GO #7#))))))
                       (LETT #8# (CDR #8#) . #10#) #12=(GO G190) G191
                       (EXIT NIL)))
                 #7# (EXIT #7#))))))
        (COND
         ((OR (NULL |leq|) (NULL |lineq|))
          (EXIT (CONS 0 (VECTOR |leq| |ts| |lineq|)))))
        (COND
         (|b4|
          (SEQ
           (EXIT
            (SEQ (LETT |q| NIL . #10#) (LETT #6# |lineq| . #10#) G190
                 (COND
                  ((OR (ATOM #6#) (PROGN (LETT |q| (CAR #6#) . #10#) NIL))
                   #11#))
                 (SEQ
                  (EXIT
                   (COND
                    ((SPADCALL (SPADCALL |q| |ts| (QREFELT $ 65))
                               (QREFELT $ 66))
                     (PROGN
                      (LETT #5#
                            (PROGN
                             (LETT #1# (CONS 1 "failed") . #10#)
                             (GO #1#))
                            . #10#)
                      (GO #5#))))))
                 (LETT #6# (CDR #6#) . #10#) #12# G191 (EXIT NIL)))
           #5# (EXIT #5#))))
        (COND
         (|b5|
          (SEQ (LETT |newleq| NIL . #10#)
               (SEQ (LETT |p| NIL . #10#) (LETT #4# |leq| . #10#) G190
                    (COND
                     ((OR (ATOM #4#) (PROGN (LETT |p| (CAR #4#) . #10#) NIL))
                      #11#))
                    (SEQ
                     (EXIT
                      (SEQ (LETT |q| NIL . #10#) (LETT #3# |lineq| . #10#) G190
                           (COND
                            ((OR (ATOM #3#)
                                 (PROGN (LETT |q| (CAR #3#) . #10#) NIL))
                             #11#))
                           (SEQ
                            (EXIT
                             (COND
                              ((SPADCALL (SPADCALL |p| (QREFELT $ 44))
                                         (SPADCALL |q| (QREFELT $ 44))
                                         (QREFELT $ 92))
                               (SEQ
                                (LETT |g| (SPADCALL |p| |q| (QREFELT $ 93))
                                      . #10#)
                                (LETT |newp|
                                      (PROG2
                                          (LETT #2#
                                                (SPADCALL |p| |g|
                                                          (QREFELT $ 94))
                                                . #10#)
                                          (QCDR #2#)
                                        (|check-union| (QEQCAR #2# 0)
                                                       (QREFELT $ 9) #2#))
                                      . #10#)
                                (EXIT
                                 (COND
                                  ((SPADCALL |newp| (QREFELT $ 85))
                                   (PROGN
                                    (LETT #1# (CONS 1 "failed") . #10#)
                                    (GO #1#)))
                                  ('T
                                   (LETT |newleq| (CONS |newp| |newleq|)
                                         . #10#))))))
                              ('T
                               (LETT |newleq| (CONS |p| |newleq|) . #10#)))))
                           (LETT #3# (CDR #3#) . #10#) #12# G191 (EXIT NIL))))
                    (LETT #4# (CDR #4#) . #10#) #12# G191 (EXIT NIL))
               (EXIT (LETT |leq| |newleq| . #10#)))))
        (LETT |leq|
              (SPADCALL (ELT $ 16) (SPADCALL |leq| (QREFELT $ 17))
                        (QREFELT $ 19))
              . #10#)
        (EXIT (CONS 0 (VECTOR |leq| |ts| |lineq|)))))
      #1# (EXIT #1#))))) 

(DEFUN |SFQCMPK;prepareDecompose;LL2BL;21| (|lp| |lts| |b1| |b2| $)
  (PROG (#1=#:G953 |ts| #2=#:G952 |toSee| |lq| |branches| #3=#:G928 |newBranch|
         |lineq| |leq| |ubf2| |ubf1| #4=#:G951 |branch| #5=#:G950 |f| |lsfp|
         #6=#:G949 |p| #7=#:G948 #8=#:G947)
    (RETURN
     (SEQ
      (LETT |lp|
            (SPADCALL (ELT $ 16)
                      (SPADCALL (ELT $ 66) (|SFQCMPK;removeAssociates| |lp| $)
                                (QREFELT $ 84))
                      (QREFELT $ 19))
            . #9=(|SFQCMPK;prepareDecompose;LL2BL;21|))
      (EXIT
       (COND ((OR (SPADCALL (ELT $ 85) |lp| (QREFELT $ 86)) (NULL |lts|)) NIL)
             ('T
              (SEQ
               (COND (|b1| (LETT |lts| (SPADCALL |lts| (QREFELT $ 81)) . #9#)))
               (EXIT
                (COND
                 (|b2|
                  (SEQ (LETT |lq| NIL . #9#)
                       (LETT |toSee|
                             (PROGN
                              (LETT #8# NIL . #9#)
                              (SEQ (LETT |ts| NIL . #9#) (LETT #7# |lts| . #9#)
                                   G190
                                   (COND
                                    ((OR (ATOM #7#)
                                         (PROGN
                                          (LETT |ts| (CAR #7#) . #9#)
                                          NIL))
                                     #10=(GO G191)))
                                   (SEQ
                                    (EXIT
                                     (LETT #8#
                                           (CONS
                                            (VECTOR |lq| |ts|
                                                    (|SFQCMPK;squareFreeFactors|
                                                     (SPADCALL |ts|
                                                               (QREFELT $ 67))
                                                     $))
                                            #8#)
                                           . #9#)))
                                   (LETT #7# (CDR #7#) . #9#) #11=(GO G190)
                                   G191 (EXIT (NREVERSE0 #8#))))
                             . #9#)
                       (EXIT
                        (COND ((NULL |lp|) |toSee|)
                              (#12='T
                               (SEQ
                                (SEQ (LETT |p| NIL . #9#) (LETT #6# |lp| . #9#)
                                     G190
                                     (COND
                                      ((OR (ATOM #6#)
                                           (PROGN
                                            (LETT |p| (CAR #6#) . #9#)
                                            NIL))
                                       #10#))
                                     (SEQ
                                      (LETT |lsfp|
                                            (SPADCALL |p| (QREFELT $ 13))
                                            . #9#)
                                      (LETT |branches| NIL . #9#)
                                      (LETT |lq| NIL . #9#)
                                      (SEQ (LETT |f| NIL . #9#)
                                           (LETT #5# |lsfp| . #9#) G190
                                           (COND
                                            ((OR (ATOM #5#)
                                                 (PROGN
                                                  (LETT |f| (CAR #5#) . #9#)
                                                  NIL))
                                             #10#))
                                           (SEQ
                                            (SEQ (LETT |branch| NIL . #9#)
                                                 (LETT #4# |toSee| . #9#) G190
                                                 (COND
                                                  ((OR (ATOM #4#)
                                                       (PROGN
                                                        (LETT |branch|
                                                              (CAR #4#) . #9#)
                                                        NIL))
                                                   #10#))
                                                 (SEQ
                                                  (LETT |leq|
                                                        (QVELT |branch| 0)
                                                        . #9#)
                                                  (LETT |ts| (QVELT |branch| 1)
                                                        . #9#)
                                                  (LETT |lineq|
                                                        (QVELT |branch| 2)
                                                        . #9#)
                                                  (LETT |ubf1|
                                                        (SPADCALL |leq| |ts|
                                                                  |lq| 'NIL
                                                                  'NIL 'T 'T 'T
                                                                  (QREFELT $
                                                                           97))
                                                        . #9#)
                                                  (EXIT
                                                   (COND
                                                    ((QEQCAR |ubf1| 1) "leave")
                                                    ('T
                                                     (SEQ
                                                      (LETT |ubf2|
                                                            (SPADCALL
                                                             (LIST |f|) |ts|
                                                             |lineq| 'NIL 'NIL
                                                             'T 'T 'T
                                                             (QREFELT $ 97))
                                                            . #9#)
                                                      (EXIT
                                                       (COND
                                                        ((QEQCAR |ubf2| 1)
                                                         "leave")
                                                        ('T
                                                         (SEQ
                                                          (LETT |leq|
                                                                (SPADCALL
                                                                 (ELT $ 16)
                                                                 (SPADCALL
                                                                  (SPADCALL
                                                                   (QVELT
                                                                    (QCDR
                                                                     |ubf1|)
                                                                    0)
                                                                   (QVELT
                                                                    (QCDR
                                                                     |ubf2|)
                                                                    0)
                                                                   (QREFELT $
                                                                            14))
                                                                  (QREFELT $
                                                                           17))
                                                                 (QREFELT $
                                                                          19))
                                                                . #9#)
                                                          (LETT |lineq|
                                                                (SPADCALL
                                                                 (ELT $ 16)
                                                                 (SPADCALL
                                                                  (SPADCALL
                                                                   (QVELT
                                                                    (QCDR
                                                                     |ubf1|)
                                                                    2)
                                                                   (QVELT
                                                                    (QCDR
                                                                     |ubf2|)
                                                                    2)
                                                                   (QREFELT $
                                                                            14))
                                                                  (QREFELT $
                                                                           17))
                                                                 (QREFELT $
                                                                          19))
                                                                . #9#)
                                                          (LETT |newBranch|
                                                                (SPADCALL |leq|
                                                                          |ts|
                                                                          |lineq|
                                                                          'NIL
                                                                          'NIL
                                                                          'NIL
                                                                          'NIL
                                                                          'NIL
                                                                          (QREFELT
                                                                           $
                                                                           97))
                                                                . #9#)
                                                          (EXIT
                                                           (LETT |branches|
                                                                 (CONS
                                                                  (PROG2
                                                                      (LETT #3#
                                                                            |newBranch|
                                                                            . #9#)
                                                                      (QCDR
                                                                       #3#)
                                                                    (|check-union|
                                                                     (QEQCAR
                                                                      #3# 0)
                                                                     (|Record|
                                                                      (|:| |eq|
                                                                           (|List|
                                                                            (QREFELT
                                                                             $
                                                                             9)))
                                                                      (|:|
                                                                       |tower|
                                                                       (QREFELT
                                                                        $ 10))
                                                                      (|:|
                                                                       |ineq|
                                                                       (|List|
                                                                        (QREFELT
                                                                         $
                                                                         9))))
                                                                     #3#))
                                                                  |branches|)
                                                                 . #9#)))))))))))
                                                 (LETT #4# (CDR #4#) . #9#)
                                                 #11# G191 (EXIT NIL))
                                            (EXIT
                                             (LETT |lq| (CONS |f| |lq|)
                                                   . #9#)))
                                           (LETT #5# (CDR #5#) . #9#) #11# G191
                                           (EXIT NIL))
                                      (EXIT (LETT |toSee| |branches| . #9#)))
                                     (LETT #6# (CDR #6#) . #9#) #11# G191
                                     (EXIT NIL))
                                (EXIT
                                 (SPADCALL
                                  (CONS #'|SFQCMPK;prepareDecompose;LL2BL;21!0|
                                        $)
                                  |toSee| (QREFELT $ 100)))))))))
                 (#12#
                  (PROGN
                   (LETT #2# NIL . #9#)
                   (SEQ (LETT |ts| NIL . #9#) (LETT #1# |lts| . #9#) G190
                        (COND
                         ((OR (ATOM #1#)
                              (PROGN (LETT |ts| (CAR #1#) . #9#) NIL))
                          #10#))
                        (SEQ
                         (EXIT
                          (LETT #2#
                                (CONS
                                 (VECTOR |lp| |ts|
                                         (|SFQCMPK;squareFreeFactors|
                                          (SPADCALL |ts| (QREFELT $ 67)) $))
                                 #2#)
                                . #9#)))
                        (LETT #1# (CDR #1#) . #9#) #11# G191
                        (EXIT (NREVERSE0 #2#))))))))))))))) 

(DEFUN |SFQCMPK;prepareDecompose;LL2BL;21!0| (|x| |y| $)
  (SPADCALL (QVELT |x| 1) (QVELT |y| 1) (QREFELT $ 37))) 

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

(DEFUN |SquareFreeQuasiComponentPackage;| (|#1| |#2| |#3| |#4| |#5|)
  (PROG (|pv$| $ |dv$| DV$5 DV$4 DV$3 DV$2 DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|) . #1=(|SquareFreeQuasiComponentPackage|))
      (LETT DV$2 (|devaluate| |#2|) . #1#)
      (LETT DV$3 (|devaluate| |#3|) . #1#)
      (LETT DV$4 (|devaluate| |#4|) . #1#)
      (LETT DV$5 (|devaluate| |#5|) . #1#)
      (LETT |dv$|
            (LIST '|SquareFreeQuasiComponentPackage| DV$1 DV$2 DV$3 DV$4 DV$5)
            . #1#)
      (LETT $ (GETREFV 102) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#))
      (|haddProp| |$ConstructorCache| '|SquareFreeQuasiComponentPackage|
                  (LIST DV$1 DV$2 DV$3 DV$4 DV$5) (CONS 1 $))
      (|stuffDomainSlots| $)
      (QSETREFV $ 6 |#1|)
      (QSETREFV $ 7 |#2|)
      (QSETREFV $ 8 |#3|)
      (QSETREFV $ 9 |#4|)
      (QSETREFV $ 10 |#5|)
      (COND
       ((|HasCategory| |#5|
                       (LIST '|SquareFreeRegularTriangularSetCategory|
                             (|devaluate| |#1|) (|devaluate| |#2|)
                             (|devaluate| |#3|) (|devaluate| |#4|)))
        (QSETREFV $ 70
                  (CONS
                   (|dispatchFunction|
                    |SFQCMPK;internalSubQuasiComponent?;2TSU;13|)
                   $)))
       ('T
        (QSETREFV $ 70
                  (CONS
                   (|dispatchFunction|
                    |SFQCMPK;internalSubQuasiComponent?;2TSU;14|)
                   $))))
      $)))) 

(MAKEPROP '|SquareFreeQuasiComponentPackage| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
              (|local| |#3|) (|local| |#4|) (|local| |#5|) (|List| 9)
              (|PolynomialSetUtilitiesPackage| 6 7 8 9)
              (0 . |squareFreeFactors|) (5 . |concat|) (|Boolean|)
              (11 . |infRittWu?|) (17 . |removeDuplicates|) (|Mapping| 15 9 9)
              (22 . |sort|) (|Void|)
              (|Record| (|:| |left| 10) (|:| |right| 10))
              (|TabulatedComputationPackage| 21 15) (28 . |initTable!|)
              (|String|) (32 . |empty?|) (37 . |printInfo!|)
              (43 . |startStats!|) (48 . |void|) |SFQCMPK;startTable!;3SV;2|
              (52 . |makingStats?|) (56 . |printStats!|) (60 . |clearTable!|)
              |SFQCMPK;stopTable!;V;3| (|NonNegativeInteger|) (64 . |#|)
              (69 . |members|) |SFQCMPK;supDimElseRittWu?;2TSB;4| (|List| 10)
              (74 . |removeDuplicates|) (|Mapping| 15 10 10) (79 . |sort|)
              |SFQCMPK;algebraicSort;2L;5| (85 . |empty?|) (90 . |mvar|)
              (95 . |algebraic?|) |SFQCMPK;moreAlgebraic?;2TSB;6|
              (101 . |mvar|) (106 . <) (|Union| $ '#1="failed") (112 . |rest|)
              |SFQCMPK;subTriSet?;2TSB;7| (|Union| 9 '#1#) (117 . |first|)
              (122 . =) (128 . |associates?|)
              |SFQCMPK;internalSubPolSet?;2LB;8| |SFQCMPK;subPolSet?;2LB;9|
              |SFQCMPK;internalInfRittWu?;2LB;11| |SFQCMPK;infRittWu?;2LB;10|
              |SFQCMPK;subQuasiComponent?;2TSB;15|
              (|Record| (|:| |val| 11) (|:| |tower| 10))
              |SFQCMPK;subCase?;2RB;12| (134 . |mdeg|) (139 . |select|)
              (145 . |initiallyReduce|) (151 . |zero?|) (156 . |initials|)
              (161 . |invertible?|) (|Union| 15 '"failed")
              (167 . |internalSubQuasiComponent?|) (173 . |reduceByQuasiMonic|)
              (179 . |extractIfCan|) (184 . |insert!|)
              |SFQCMPK;subQuasiComponent?;TSLB;16| (|Mapping| 15 61 61)
              (|List| 61) (190 . |sort|) (196 . |setrest!|)
              |SFQCMPK;removeSuperfluousCases;2L;17| (202 . |setrest!|)
              |SFQCMPK;removeSuperfluousQuasiComponents;2L;18|
              (208 . |primitivePart|) (|Mapping| 15 9) (213 . |remove|)
              (219 . |ground?|) (224 . |any?|) (230 . |removeRedundantFactors|)
              (|GeneralPolynomialSet| 6 7 8 9) (235 . |construct|)
              (|Record| (|:| |rnum| 6) (|:| |polnum| 9) (|:| |den| 6))
              (240 . |remainder|) (246 . =) (252 . |gcd|) (258 . |exquo|)
              (|Record| (|:| |eq| 11) (|:| |tower| 10) (|:| |ineq| 11))
              (|Union| 95 '"failed") |SFQCMPK;branchIfCan;LTSL5BU;20|
              (|Mapping| 15 95 95) (|List| 95) (264 . |sort|)
              |SFQCMPK;prepareDecompose;LL2BL;21|)
           '#(|supDimElseRittWu?| 270 |subTriSet?| 276 |subQuasiComponent?| 282
              |subPolSet?| 294 |subCase?| 300 |stopTable!| 306 |startTable!|
              310 |removeSuperfluousQuasiComponents| 317
              |removeSuperfluousCases| 322 |prepareDecompose| 327
              |moreAlgebraic?| 335 |internalSubQuasiComponent?| 341
              |internalSubPolSet?| 347 |internalInfRittWu?| 353 |infRittWu?|
              359 |branchIfCan| 365 |algebraicSort| 377)
           'NIL
           (CONS (|makeByteWordVec2| 1 'NIL)
                 (CONS '#()
                       (CONS '#()
                             (|makeByteWordVec2| 101
                                                 '(1 12 11 9 13 2 11 0 0 0 14 2
                                                   9 15 0 0 16 1 11 0 0 17 2 11
                                                   0 18 0 19 0 22 20 23 1 24 15
                                                   0 25 2 22 20 24 24 26 1 22
                                                   20 24 27 0 20 0 28 0 22 15
                                                   30 0 22 20 31 0 22 20 32 1
                                                   10 34 0 35 1 10 11 0 36 1 38
                                                   0 0 39 2 38 0 40 0 41 1 10
                                                   15 0 43 1 9 8 0 44 2 10 15 8
                                                   0 45 1 10 8 0 47 2 8 15 0 0
                                                   48 1 10 49 0 50 1 10 52 0 53
                                                   2 9 15 0 0 54 2 9 15 0 0 55
                                                   1 9 34 0 63 2 10 52 0 8 64 2
                                                   10 9 9 0 65 1 9 15 0 66 1 10
                                                   11 0 67 2 10 15 9 0 68 2 0
                                                   69 10 10 70 2 10 9 9 0 71 1
                                                   22 69 21 72 2 22 20 21 15 73
                                                   2 76 0 75 0 77 2 76 0 0 0 78
                                                   2 38 0 0 0 80 1 9 0 0 82 2
                                                   11 0 83 0 84 1 9 15 0 85 2
                                                   11 15 83 0 86 1 12 11 11 87
                                                   1 88 0 11 89 2 88 90 9 0 91
                                                   2 8 15 0 0 92 2 9 0 0 0 93 2
                                                   9 49 0 0 94 2 99 0 98 0 100
                                                   2 0 15 10 10 37 2 0 15 10 10
                                                   51 2 0 15 10 38 74 2 0 15 10
                                                   10 60 2 0 15 11 11 57 2 0 15
                                                   61 61 62 0 0 20 33 3 0 20 24
                                                   24 24 29 1 0 38 38 81 1 0 76
                                                   76 79 4 0 99 11 38 15 15 101
                                                   2 0 15 10 10 46 2 0 69 10 10
                                                   70 2 0 15 11 11 56 2 0 15 11
                                                   11 58 2 0 15 11 11 59 8 0 96
                                                   11 10 11 15 15 15 15 15 97 1
                                                   0 38 38 42)))))
           '|lookupComplete|)) 
