
(/VERSIONCHECK 2) 

(DEFUN |RSDCMPK;KrullNumber;LLNni;1| (|lp| |lts| $)
  (PROG (#0=#:G1865 |ts| #1=#:G1866 |ln| |n|)
    (RETURN
      (SEQ (LETT |ln|
                 (PROGN
                   (LETT #0# NIL . #2=(|RSDCMPK;KrullNumber;LLNni;1|))
                   (SEQ (LETT |ts| NIL . #2#) (LETT #1# |lts| . #2#)
                        G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN (LETT |ts| (CAR #1#) . #2#) NIL))
                           (GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS
                                     (SPADCALL |ts| (QREFELT $ 12))
                                     #0#) . #2#)))
                        (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                        (EXIT (NREVERSE0 #0#)))) . #2#)
           (EXIT (LETT |n|
                       (+ (LENGTH |lp|)
                          (SPADCALL (ELT $ 13) |ln| (QREFELT $ 16))) . #2#)))))) 

(DEFUN |RSDCMPK;numberOfVariables;LLNni;2| (|lp| |lts| $)
  (PROG (|ts| #0=#:G1870 |lv|)
    (RETURN
      (SEQ (LETT |lv|
                 (SPADCALL (SPADCALL |lp| (QREFELT $ 21))
                     (QREFELT $ 23))
                 . #1=(|RSDCMPK;numberOfVariables;LLNni;2|))
           (SEQ (LETT |ts| NIL . #1#) (LETT #0# |lts| . #1#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |ts| (CAR #0#) . #1#) NIL))
                   (GO G191)))
                (SEQ (EXIT (LETT |lv|
                                 (SPADCALL
                                     (SPADCALL |ts| (QREFELT $ 24))
                                     |lv| (QREFELT $ 25)) . #1#)))
                (LETT #0# (CDR #0#) . #1#) (GO G190) G191 (EXIT NIL))
           (EXIT (LENGTH (SPADCALL |lv| (QREFELT $ 26)))))))) 

(DEFUN |RSDCMPK;algebraicDecompose;PTSBR;3| (|p| |ts| |clos?| $)
  (PROG (|v| |n| |tsv-| |tsv+| #0=#:G1876 |tsv| |lgwt| |gwt| #1=#:G1898
             |g| |us| |lts| |h| |b| |lsfp| |lus| |f| #2=#:G1899 |vs|
             #3=#:G1900 |llpwt|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |p| (QREFELT $ 29))
              (|error| " in algebraicDecompose$REGSET: should never happen !"))
             ('T
              (SEQ (LETT |v| (SPADCALL |p| (QREFELT $ 30))
                         . #4=(|RSDCMPK;algebraicDecompose;PTSBR;3|))
                   (LETT |n| (SPADCALL |ts| (QREFELT $ 12)) . #4#)
                   (LETT |tsv-|
                         (SPADCALL |ts| |v| (QREFELT $ 31)) . #4#)
                   (LETT |tsv+|
                         (SPADCALL |ts| |v| (QREFELT $ 32)) . #4#)
                   (LETT |tsv|
                         (PROG2 (LETT #0#
                                      (SPADCALL |ts| |v|
                                       (QREFELT $ 34)) . #4#)
                                (QCDR #0#)
                           (|check-union| (QEQCAR #0# 0) (QREFELT $ 9)
                               #0#)) . #4#)
                   (COND
                     ((< (SPADCALL |p| (QREFELT $ 35))
                         (SPADCALL |tsv| (QREFELT $ 35)))
                      (LETT |lgwt|
                            (SPADCALL |tsv| |p| |tsv-| 'T 'NIL
                                (QREFELT $ 39)) . #4#))
                     ('T
                      (LETT |lgwt|
                            (SPADCALL |p| |tsv| |tsv-| 'T 'NIL
                                (QREFELT $ 39)) . #4#)))
                   (LETT |lts| NIL . #4#) (LETT |llpwt| NIL . #4#)
                   (SEQ (LETT |gwt| NIL . #4#) (LETT #1# |lgwt| . #4#)
                        G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN
                                 (LETT |gwt| (CAR #1#) . #4#)
                                 NIL))
                           #5=(GO G191)))
                        (SEQ (LETT |g| (QCAR |gwt|) . #4#)
                             (LETT |us| (QCDR |gwt|) . #4#)
                             (EXIT (COND
                                     ((SPADCALL |g| (QREFELT $ 40))
                                      (|error|
                                       " in algebraicDecompose$REGSET: should never happen !!"))
                                     ((SPADCALL |g| (QREFELT $ 29))
                                      "leave")
                                     ('T
                                      (SEQ
                                       (COND
                                         ((SPADCALL
                                           (SPADCALL |g|
                                            (QREFELT $ 30))
                                           |v| (QREFELT $ 41))
                                          (LETT |lts|
                                           (SPADCALL
                                            (SPADCALL
                                             (SPADCALL |tsv+|
                                              (QREFELT $ 42))
                                             (SPADCALL |g| |us|
                                              (QREFELT $ 44))
                                             (QREFELT $ 45))
                                            |lts| (QREFELT $ 46)) . #4#)))
                                       (LETT |h|
                                        (SPADCALL |g| |v|
                                         (QREFELT $ 47)) . #4#)
                                       (LETT |b|
                                        (SPADCALL |us| (QREFELT $ 48)) . #4#)
                                       (LETT |lsfp|
                                        (SPADCALL |h| (QREFELT $ 50)) . #4#)
                                       (LETT |lus|
                                        (SPADCALL
                                         (SPADCALL |tsv+|
                                          (QREFELT $ 42))
                                         (SPADCALL |tsv| |us|
                                          (QREFELT $ 44))
                                         (QREFELT $ 45)) . #4#)
                                       (EXIT
                                        (SEQ (LETT |f| NIL . #4#)
                                         (LETT #2# |lsfp| . #4#) G190
                                         (COND
                                           ((OR (ATOM #2#)
                                             (PROGN
                                               (LETT |f|
                                                (CAR #2#) . #4#)
                                               NIL))
                                            #5#))
                                         (SEQ
                                          (EXIT
                                           (COND
                                             ((SPADCALL |f|
                                               (QREFELT $ 29))
                                              "leave")
                                             ('T
                                              (SEQ
                                               (COND
                                                 (|b|
                                                  (COND
                                                    ((SPADCALL |f| |us|
                                                      (QREFELT $ 51))
                                                     (EXIT "leave")))))
                                               (EXIT
                                                (SEQ
                                                 (LETT |vs| NIL . #4#)
                                                 (LETT #3# |lus| . #4#)
                                                 G190
                                                 (COND
                                                   ((OR (ATOM #3#)
                                                     (PROGN
                                                       (LETT |vs|
                                                        (CAR #3#) . #4#)
                                                       NIL))
                                                    #5#))
                                                 (SEQ
                                                  (EXIT
                                                   (LETT |llpwt|
                                                    (CONS
                                                     (CONS
                                                      (LIST |f| |p|)
                                                      |vs|)
                                                     |llpwt|) . #4#)))
                                                 (LETT #3#
                                                  (CDR #3#) . #4#)
                                                 #6=(GO G190) G191
                                                 (EXIT NIL))))))))
                                         (LETT #2# (CDR #2#) . #4#) #6#
                                         G191 (EXIT NIL))))))))
                        (LETT #1# (CDR #1#) . #4#) #6# G191 (EXIT NIL))
                   (EXIT (CONS |lts| |llpwt|))))))))) 

(DEFUN |RSDCMPK;transcendentalDecompose;PTSNniR;4| (|p| |ts| |bound| $)
  (PROG (|lts| |llpwt|)
    (RETURN
      (SEQ (COND
             ((< (SPADCALL |ts| (QREFELT $ 12)) |bound|)
              (LETT |lts| (SPADCALL |p| |ts| (QREFELT $ 44))
                    . #0=(|RSDCMPK;transcendentalDecompose;PTSNniR;4|)))
             ('T (LETT |lts| NIL . #0#)))
           (LETT |llpwt| NIL . #0#) (EXIT (CONS |lts| |llpwt|)))))) 

(DEFUN |RSDCMPK;transcendentalDecompose;PTSR;5| (|p| |ts| $)
  (PROG (|lts| |llpwt|)
    (RETURN
      (SEQ (LETT |lts| (SPADCALL |p| |ts| (QREFELT $ 44))
                 . #0=(|RSDCMPK;transcendentalDecompose;PTSR;5|))
           (LETT |llpwt| NIL . #0#) (EXIT (CONS |lts| |llpwt|)))))) 

(DEFUN |RSDCMPK;internalDecompose;PTSNniBR;6|
       (|p| |ts| |bound| |clos?| $)
  (COND
    (|clos?| (SPADCALL |p| |ts| |bound| (QREFELT $ 57)))
    ('T (SPADCALL |p| |ts| (QREFELT $ 58))))) 

(DEFUN |RSDCMPK;internalDecompose;PTSNniR;7| (|p| |ts| |bound| $)
  (PROG (|lmp| #0=#:G1918 |ip| |tp| |lbwt| |bwt| #1=#:G1940 |rsl| |riv|
               |lts| |llpwt|)
    (RETURN
      (SEQ (LETT |llpwt| NIL
                 . #2=(|RSDCMPK;internalDecompose;PTSNniR;7|))
           (LETT |lts| NIL . #2#)
           (COND
             ((NULL (SPADCALL (SPADCALL |p| (QREFELT $ 60))
                        (QREFELT $ 40)))
              (COND
                ((NULL (SPADCALL
                           (LETT |lmp|
                                 (SPADCALL |p| (QREFELT $ 61)) . #2#)
                           (QREFELT $ 29)))
                 (SEQ (LETT |llpwt|
                            (CONS (CONS (LIST
                                         (SPADCALL
                                          (SPADCALL |p| (QREFELT $ 30))
                                          (QREFELT $ 62)))
                                        |ts|)
                                  |llpwt|) . #2#)
                      (EXIT (LETT |p|
                                  (PROG2 (LETT #0#
                                          (SPADCALL |p| |lmp|
                                           (QREFELT $ 64)) . #2#)
                                         (QCDR #0#)
                                    (|check-union| (QEQCAR #0# 0)
                                     (QREFELT $ 9) #0#)) . #2#)))))))
           (LETT |ip|
                 (SPADCALL (SPADCALL |p| (QREFELT $ 65))
                     (QREFELT $ 66)) . #2#)
           (LETT |tp| (SPADCALL |p| (QREFELT $ 60)) . #2#)
           (LETT |p| (SPADCALL |p| (QREFELT $ 67)) . #2#)
           (LETT |lbwt| (SPADCALL |ip| |ts| (QREFELT $ 70)) . #2#)
           (SEQ (LETT |bwt| NIL . #2#) (LETT #1# |lbwt| . #2#) G190
                (COND
                  ((OR (ATOM #1#)
                       (PROGN (LETT |bwt| (CAR #1#) . #2#) NIL))
                   (GO G191)))
                (SEQ (EXIT (COND
                             ((QCAR |bwt|)
                              (SEQ (COND
                                     ((SPADCALL
                                       (SPADCALL |p| (QREFELT $ 30))
                                       (QCDR |bwt|) (QREFELT $ 71))
                                      (LETT |rsl|
                                       (SPADCALL |p| (QCDR |bwt|) 'T
                                        (QREFELT $ 54)) . #2#))
                                     ('T
                                      (LETT |rsl|
                                       (SPADCALL |p| (QCDR |bwt|)
                                        |bound| (QREFELT $ 55)) . #2#)))
                                   (LETT |lts|
                                    (SPADCALL (QCAR |rsl|) |lts|
                                     (QREFELT $ 46)) . #2#)
                                   (LETT |llpwt|
                                    (SPADCALL (QCDR |rsl|) |llpwt|
                                     (QREFELT $ 73)) . #2#)
                                   (COND
                                     ((SPADCALL |ip| (QCDR |bwt|)
                                       (QREFELT $ 51))
                                      (COND
                                        ((SPADCALL (QCDR |bwt|)
                                          (QREFELT $ 48))
                                         (EXIT "leave")))))
                                   (EXIT
                                    (COND
                                      ((NULL
                                        (SPADCALL |ip| (QREFELT $ 29)))
                                       (COND
                                         ((SPADCALL |tp|
                                           (QREFELT $ 40))
                                          (LETT |llpwt|
                                           (CONS
                                            (CONS (LIST |ip|)
                                             (QCDR |bwt|))
                                            |llpwt|) . #2#))
                                         ((NULL
                                           (SPADCALL |tp|
                                            (QREFELT $ 29)))
                                          (LETT |llpwt|
                                           (CONS
                                            (CONS (LIST |ip| |tp|)
                                             (QCDR |bwt|))
                                            |llpwt|) . #2#))))))))
                             ('T
                              (SEQ (LETT |riv|
                                    (SPADCALL |ip| (QCDR |bwt|)
                                     (QREFELT $ 74)) . #2#)
                                   (EXIT
                                    (COND
                                      ((SPADCALL |riv| (QREFELT $ 40))
                                       (COND
                                         ((SPADCALL |tp|
                                           (QREFELT $ 40))
                                          (LETT |lts|
                                           (CONS (QCDR |bwt|) |lts|) . #2#))
                                         ((NULL
                                           (SPADCALL |tp|
                                            (QREFELT $ 29)))
                                          (LETT |llpwt|
                                           (CONS
                                            (CONS (LIST |tp|)
                                             (QCDR |bwt|))
                                            |llpwt|) . #2#))))
                                      ('T
                                       (LETT |llpwt|
                                        (CONS
                                         (CONS
                                          (LIST
                                           (SPADCALL
                                            (SPADCALL |riv|
                                             (SPADCALL |p|
                                              (QREFELT $ 75))
                                             (QREFELT $ 76))
                                            |tp| (QREFELT $ 77)))
                                          (QCDR |bwt|))
                                         |llpwt|) . #2#)))))))))
                (LETT #1# (CDR #1#) . #2#) (GO G190) G191 (EXIT NIL))
           (EXIT (CONS |lts| |llpwt|)))))) 

(DEFUN |RSDCMPK;internalDecompose;PTSR;8| (|p| |ts| $)
  (PROG (|lmp| #0=#:G1944 |ip| |tp| |lbwt| |bwt| #1=#:G1963 |rsl| |riv|
               |lts| |llpwt|)
    (RETURN
      (SEQ (LETT |llpwt| NIL . #2=(|RSDCMPK;internalDecompose;PTSR;8|))
           (LETT |lts| NIL . #2#)
           (COND
             ((NULL (SPADCALL (SPADCALL |p| (QREFELT $ 60))
                        (QREFELT $ 40)))
              (COND
                ((NULL (SPADCALL
                           (LETT |lmp|
                                 (SPADCALL |p| (QREFELT $ 61)) . #2#)
                           (QREFELT $ 29)))
                 (SEQ (LETT |llpwt|
                            (CONS (CONS (LIST
                                         (SPADCALL
                                          (SPADCALL |p| (QREFELT $ 30))
                                          (QREFELT $ 62)))
                                        |ts|)
                                  |llpwt|) . #2#)
                      (EXIT (LETT |p|
                                  (PROG2 (LETT #0#
                                          (SPADCALL |p| |lmp|
                                           (QREFELT $ 64)) . #2#)
                                         (QCDR #0#)
                                    (|check-union| (QEQCAR #0# 0)
                                     (QREFELT $ 9) #0#)) . #2#)))))))
           (LETT |ip|
                 (SPADCALL (SPADCALL |p| (QREFELT $ 65))
                     (QREFELT $ 66)) . #2#)
           (LETT |tp| (SPADCALL |p| (QREFELT $ 60)) . #2#)
           (LETT |p| (SPADCALL |p| (QREFELT $ 67)) . #2#)
           (LETT |lbwt| (SPADCALL |ip| |ts| (QREFELT $ 70)) . #2#)
           (SEQ (LETT |bwt| NIL . #2#) (LETT #1# |lbwt| . #2#) G190
                (COND
                  ((OR (ATOM #1#)
                       (PROGN (LETT |bwt| (CAR #1#) . #2#) NIL))
                   (GO G191)))
                (SEQ (EXIT (COND
                             ((QCAR |bwt|)
                              (SEQ (COND
                                     ((SPADCALL
                                       (SPADCALL |p| (QREFELT $ 30))
                                       (QCDR |bwt|) (QREFELT $ 71))
                                      (LETT |rsl|
                                       (SPADCALL |p| (QCDR |bwt|) 'NIL
                                        (QREFELT $ 54)) . #2#))
                                     ('T
                                      (LETT |rsl|
                                       (SPADCALL |p| (QCDR |bwt|)
                                        (QREFELT $ 56)) . #2#)))
                                   (LETT |lts|
                                    (SPADCALL (QCAR |rsl|) |lts|
                                     (QREFELT $ 46)) . #2#)
                                   (LETT |llpwt|
                                    (SPADCALL (QCDR |rsl|) |llpwt|
                                     (QREFELT $ 73)) . #2#)
                                   (COND
                                     ((SPADCALL |ip| (QCDR |bwt|)
                                       (QREFELT $ 51))
                                      (COND
                                        ((SPADCALL (QCDR |bwt|)
                                          (QREFELT $ 48))
                                         (EXIT "leave")))))
                                   (EXIT
                                    (COND
                                      ((NULL
                                        (SPADCALL |ip| (QREFELT $ 29)))
                                       (COND
                                         ((SPADCALL |tp|
                                           (QREFELT $ 40))
                                          (LETT |llpwt|
                                           (CONS
                                            (CONS (LIST |ip|)
                                             (QCDR |bwt|))
                                            |llpwt|) . #2#))
                                         ((NULL
                                           (SPADCALL |tp|
                                            (QREFELT $ 29)))
                                          (LETT |llpwt|
                                           (CONS
                                            (CONS (LIST |ip| |tp|)
                                             (QCDR |bwt|))
                                            |llpwt|) . #2#))))))))
                             ('T
                              (SEQ (LETT |riv|
                                    (SPADCALL |ip| (QCDR |bwt|)
                                     (QREFELT $ 74)) . #2#)
                                   (EXIT
                                    (COND
                                      ((SPADCALL |riv| (QREFELT $ 40))
                                       (COND
                                         ((SPADCALL |tp|
                                           (QREFELT $ 40))
                                          (LETT |lts|
                                           (CONS (QCDR |bwt|) |lts|) . #2#))
                                         ((NULL
                                           (SPADCALL |tp|
                                            (QREFELT $ 29)))
                                          (LETT |llpwt|
                                           (CONS
                                            (CONS (LIST |tp|)
                                             (QCDR |bwt|))
                                            |llpwt|) . #2#))))
                                      ('T
                                       (LETT |llpwt|
                                        (CONS
                                         (CONS
                                          (LIST
                                           (SPADCALL
                                            (SPADCALL |riv|
                                             (SPADCALL |p|
                                              (QREFELT $ 75))
                                             (QREFELT $ 76))
                                            |tp| (QREFELT $ 77)))
                                          (QCDR |bwt|))
                                         |llpwt|) . #2#)))))))))
                (LETT #1# (CDR #1#) . #2#) (GO G190) G191 (EXIT NIL))
           (EXIT (CONS |lts| |llpwt|)))))) 

(DEFUN |RSDCMPK;decompose;LL2BL;9| (|lp| |lts| |clos?| |info?| $)
  (SPADCALL |lp| |lts| 'NIL 'NIL |clos?| 'T |info?| (QREFELT $ 78))) 

(DEFUN |RSDCMPK;convert;RS;10| (|lpwt| $)
  (PROG (|ls|)
    (RETURN
      (SEQ (LETT |ls|
                 (LIST "<" (STRINGIMAGE (LENGTH (QCAR |lpwt|))) ","
                       (STRINGIMAGE
                           (SPADCALL (QCDR |lpwt|) (QREFELT $ 12)))
                       ">")
                 |RSDCMPK;convert;RS;10|)
           (EXIT (SPADCALL |ls| (QREFELT $ 81))))))) 

(DEFUN |RSDCMPK;printInfo;LNniV;11| (|toSee| |n| $)
  (PROG (|lpwt| #0=#:G1974 |m| |s|)
    (RETURN
      (SEQ (LETT |lpwt| (|SPADfirst| |toSee|)
                 . #1=(|RSDCMPK;printInfo;LNniV;11|))
           (LETT |s|
                 (SPADCALL
                     (LIST "[" (STRINGIMAGE (LENGTH |toSee|)) " "
                           (SPADCALL |lpwt| (QREFELT $ 82)))
                     (QREFELT $ 81)) . #1#)
           (LETT |m| (LENGTH (QCAR |lpwt|)) . #1#)
           (LETT |toSee| (CDR |toSee|) . #1#)
           (SEQ (LETT |lpwt| NIL . #1#) (LETT #0# |toSee| . #1#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |lpwt| (CAR #0#) . #1#) NIL))
                   (GO G191)))
                (SEQ (LETT |m| (+ |m| (LENGTH (QCAR |lpwt|))) . #1#)
                     (EXIT (LETT |s|
                                 (SPADCALL
                                     (LIST |s| ","
                                      (SPADCALL |lpwt| (QREFELT $ 82)))
                                     (QREFELT $ 81)) . #1#)))
                (LETT #0# (CDR #0#) . #1#) (GO G190) G191 (EXIT NIL))
           (LETT |s|
                 (SPADCALL
                     (LIST |s| " -> |" (STRINGIMAGE |m|) "|; {"
                           (STRINGIMAGE |n|) "}]")
                     (QREFELT $ 81)) . #1#)
           (SPADCALL |s| (QREFELT $ 85))
           (EXIT (SPADCALL (QREFELT $ 86))))))) 

(DEFUN |RSDCMPK;decompose;LL5BL;12|
       (|lp| |lts| |cleanW?| |sqfr?| |clos?| |rem?| |info?| $)
  (PROG (|branches| #0=#:G1995 |br| #1=#:G1996 |bound| |lpwt| |ts|
            |toSave| |p| |rsl| |toSee|)
    (RETURN
      (SEQ (COND
             ((NULL |lp|) |lts|)
             ('T
              (SEQ (LETT |branches|
                         (SPADCALL |lp| |lts| |cleanW?| |sqfr?|
                             (QREFELT $ 91))
                         . #2=(|RSDCMPK;decompose;LL5BL;12|))
                   (EXIT (COND
                           ((NULL |branches|) NIL)
                           ('T
                            (SEQ (LETT |toSee|
                                       (PROGN
                                         (LETT #0# NIL . #2#)
                                         (SEQ (LETT |br| NIL . #2#)
                                          (LETT #1# |branches| . #2#)
                                          G190
                                          (COND
                                            ((OR (ATOM #1#)
                                              (PROGN
                                                (LETT |br|
                                                 (CAR #1#) . #2#)
                                                NIL))
                                             #3=(GO G191)))
                                          (SEQ
                                           (EXIT
                                            (LETT #0#
                                             (CONS
                                              (CONS (QVELT |br| 0)
                                               (QVELT |br| 1))
                                              #0#) . #2#)))
                                          (LETT #1# (CDR #1#) . #2#)
                                          #4=(GO G190) G191
                                          (EXIT (NREVERSE0 #0#)))) . #2#)
                                 (LETT |toSave| NIL . #2#)
                                 (COND
                                   (|clos?|
                                    (LETT |bound|
                                     (SPADCALL |lp| |lts|
                                      (QREFELT $ 19)) . #2#))
                                   ('T
                                    (LETT |bound|
                                     (SPADCALL |lp| |lts|
                                      (QREFELT $ 27)) . #2#)))
                                 (SEQ G190
                                      (COND
                                        ((NULL
                                          (COND
                                            ((NULL |toSee|) 'NIL)
                                            ('T 'T)))
                                         #3#))
                                      (SEQ
                                       (COND
                                         (|info?|
                                          (SPADCALL |toSee|
                                           (LENGTH |toSave|)
                                           (QREFELT $ 87))))
                                       (LETT |lpwt|
                                        (|SPADfirst| |toSee|) . #2#)
                                       (LETT |toSee|
                                        (CDR |toSee|) . #2#)
                                       (LETT |lp| (QCAR |lpwt|) . #2#)
                                       (LETT |ts| (QCDR |lpwt|) . #2#)
                                       (EXIT
                                        (COND
                                          ((NULL |lp|)
                                           (LETT |toSave|
                                            (CONS |ts| |toSave|) . #2#))
                                          ('T
                                           (SEQ
                                            (LETT |p|
                                             (|SPADfirst| |lp|) . #2#)
                                            (LETT |lp|
                                             (CDR |lp|) . #2#)
                                            (COND
                                              (|rem?|
                                               (COND
                                                 ((NULL
                                                   (SPADCALL |p|
                                                    (QREFELT $ 29)))
                                                  (COND
                                                    ((NULL
                                                      (SPADCALL |ts|
                                                       (QREFELT $ 92)))
                                                     (LETT |p|
                                                      (QVELT
                                                       (SPADCALL |p|
                                                        |ts|
                                                        (QREFELT $ 94))
                                                       1) . #2#)))))))
                                            (LETT |p|
                                             (SPADCALL |p| |ts|
                                              (QREFELT $ 74)) . #2#)
                                            (EXIT
                                             (COND
                                               ((SPADCALL |p|
                                                 (QREFELT $ 40))
                                                (LETT |toSee|
                                                 (CONS (CONS |lp| |ts|)
                                                  |toSee|) . #2#))
                                               ((SPADCALL |p|
                                                 (QREFELT $ 29))
                                                "leave")
                                               ('T
                                                (SEQ
                                                 (LETT |rsl|
                                                  (SPADCALL |p| |ts|
                                                   |bound| |clos?|
                                                   (QREFELT $ 59)) . #2#)
                                                 (EXIT
                                                  (LETT |toSee|
                                                   (SPADCALL |lp|
                                                    |toSave| |toSee|
                                                    |rsl| |bound|
                                                    (QREFELT $ 95)) . #2#)))))))))))
                                      NIL #4# G191 (EXIT NIL))
                                 (EXIT (SPADCALL |toSave|
                                        (QREFELT $ 96)))))))))))))) 

(DEFUN |RSDCMPK;upDateBranches;LLLRNniL;13|
       (|leq| |lts| |current| |wip| |n| $)
  (PROG (|newBranches| |newComponents| |branch| #0=#:G2010 |newleq|
            |branches1| |us| #1=#:G2011 |branches2| |branches|)
    (RETURN
      (SEQ (LETT |newBranches| (QCDR |wip|)
                 . #2=(|RSDCMPK;upDateBranches;LLLRNniL;13|))
           (LETT |newComponents| (QCAR |wip|) . #2#)
           (LETT |branches1| NIL . #2#) (LETT |branches2| NIL . #2#)
           (SEQ (LETT |branch| NIL . #2#)
                (LETT #0# |newBranches| . #2#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |branch| (CAR #0#) . #2#) NIL))
                   #3=(GO G191)))
                (SEQ (LETT |us| (QCDR |branch|) . #2#)
                     (EXIT (COND
                             ((< |n| (SPADCALL |us| (QREFELT $ 12)))
                              "leave")
                             ('T
                              (SEQ (LETT |newleq|
                                    (SPADCALL (ELT $ 98)
                                     (SPADCALL |leq| (QCAR |branch|)
                                      (QREFELT $ 99))
                                     (QREFELT $ 101)) . #2#)
                                   (EXIT
                                    (LETT |branches1|
                                     (CONS (CONS |newleq| |us|)
                                      |branches1|) . #2#)))))))
                (LETT #0# (CDR #0#) . #2#) #4=(GO G190) G191
                (EXIT NIL))
           (SEQ (LETT |us| NIL . #2#) (LETT #1# |newComponents| . #2#)
                G190
                (COND
                  ((OR (ATOM #1#)
                       (PROGN (LETT |us| (CAR #1#) . #2#) NIL))
                   #3#))
                (SEQ (EXIT (COND
                             ((OR (< |n|
                                     (SPADCALL |us| (QREFELT $ 12)))
                                  (SPADCALL |us| |lts| (QREFELT $ 102)))
                              "leave")
                             ('T
                              (LETT |branches2|
                                    (CONS (CONS |leq| |us|)
                                     |branches2|) . #2#)))))
                (LETT #1# (CDR #1#) . #2#) #4# G191 (EXIT NIL))
           (EXIT (COND
                   ((NULL |branches1|)
                    (COND
                      ((NULL |branches2|) |current|)
                      ('T
                       (SPADCALL |branches2| |current| (QREFELT $ 73)))))
                   ('T
                    (SEQ (LETT |branches|
                               (SPADCALL
                                   (LIST |branches2| |branches1|
                                    |current|)
                                   (QREFELT $ 103)) . #2#)
                         (EXIT (SPADCALL |branches| (QREFELT $ 104))))))))))) 

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

(DEFUN |RegularSetDecompositionPackage;| (|#1| |#2| |#3| |#4| |#5|)
  (PROG (DV$1 DV$2 DV$3 DV$4 DV$5 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|)
              . #0=(|RegularSetDecompositionPackage|))
        (LETT DV$2 (|devaluate| |#2|) . #0#)
        (LETT DV$3 (|devaluate| |#3|) . #0#)
        (LETT DV$4 (|devaluate| |#4|) . #0#)
        (LETT DV$5 (|devaluate| |#5|) . #0#)
        (LETT |dv$|
              (LIST '|RegularSetDecompositionPackage| DV$1 DV$2 DV$3
                    DV$4 DV$5) . #0#)
        (LETT $ (GETREFV 105) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|haddProp| |$ConstructorCache|
            '|RegularSetDecompositionPackage|
            (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|)
        $)))) 

(MAKEPROP '|RegularSetDecompositionPackage| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|local| |#3|) (|local| |#4|) (|local| |#5|)
             (|NonNegativeInteger|) (0 . |#|) (5 . |max|)
             (|Mapping| 11 11 11) (|List| 11) (11 . |reduce|)
             (|List| 9) (|List| 10) |RSDCMPK;KrullNumber;LLNni;1|
             (|GeneralPolynomialSet| 6 7 8 9) (17 . |construct|)
             (|List| 8) (22 . |variables|) (27 . |variables|)
             (32 . |concat|) (38 . |removeDuplicates|)
             |RSDCMPK;numberOfVariables;LLNni;2| (|Boolean|)
             (43 . |ground?|) (48 . |mvar|) (53 . |collectUnder|)
             (59 . |collectUpper|) (|Union| 9 '"failed")
             (65 . |select|) (71 . |mdeg|)
             (|Record| (|:| |val| 9) (|:| |tower| 10)) (|List| 36)
             (|RegularTriangularSetGcdPackage| 6 7 8 9 10)
             (76 . |internalLastSubResultant|) (85 . |zero?|) (90 . =)
             (96 . |members|) (|List| $) (101 . |augment|)
             (107 . |augment|) (113 . |concat|)
             (119 . |leadingCoefficient|) (125 . |purelyAlgebraic?|)
             (|PolynomialSetUtilitiesPackage| 6 7 8 9)
             (130 . |squareFreeFactors|) (135 . |purelyAlgebraic?|)
             (|Record| (|:| |val| 17) (|:| |tower| 10))
             (|Record| (|:| |done| 18) (|:| |todo| 72))
             |RSDCMPK;algebraicDecompose;PTSBR;3|
             |RSDCMPK;transcendentalDecompose;PTSNniR;4|
             |RSDCMPK;transcendentalDecompose;PTSR;5|
             |RSDCMPK;internalDecompose;PTSNniR;7|
             |RSDCMPK;internalDecompose;PTSR;8|
             |RSDCMPK;internalDecompose;PTSNniBR;6| (141 . |tail|)
             (146 . |leastMonomial|) (151 . |coerce|)
             (|Union| $ '"failed") (156 . |exquo|) (162 . |init|)
             (167 . |squareFreePart|) (172 . |mainPrimitivePart|)
             (|Record| (|:| |val| 28) (|:| |tower| $)) (|List| 68)
             (177 . |invertible?|) (183 . |algebraic?|) (|List| 52)
             (189 . |concat|) (195 . |removeZero|)
             (201 . |mainMonomial|) (206 . *) (212 . +)
             |RSDCMPK;decompose;LL5BL;12| |RSDCMPK;decompose;LL2BL;9|
             (|String|) (218 . |concat|) |RSDCMPK;convert;RS;10|
             (|Void|) (|InternalPrintPackage|) (223 . |iprint|)
             (228 . |void|) |RSDCMPK;printInfo;LNniV;11|
             (|Record| (|:| |eq| 17) (|:| |tower| 10) (|:| |ineq| 17))
             (|List| 88) (|QuasiComponentPackage| 6 7 8 9 10)
             (232 . |prepareDecompose|) (240 . |empty?|)
             (|Record| (|:| |rnum| 6) (|:| |polnum| 9) (|:| |den| 6))
             (245 . |remainder|) |RSDCMPK;upDateBranches;LLLRNniL;13|
             (251 . |removeSuperfluousQuasiComponents|)
             (256 . |infRittWu?|) (262 . |infRittWu?|) (268 . |concat|)
             (|Mapping| 28 9 9) (274 . |sort|)
             (280 . |subQuasiComponent?|) (286 . |concat|)
             (291 . |removeSuperfluousCases|))
          '#(|upDateBranches| 296 |transcendentalDecompose| 305
             |printInfo| 318 |numberOfVariables| 324
             |internalDecompose| 330 |decompose| 351 |convert| 370
             |algebraicDecompose| 375 |KrullNumber| 382)
          'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 104
                                '(1 10 11 0 12 2 11 0 0 0 13 2 15 11 14
                                  0 16 1 20 0 17 21 1 20 22 0 23 1 10
                                  22 0 24 2 22 0 0 0 25 1 22 0 0 26 1 9
                                  28 0 29 1 9 8 0 30 2 10 0 0 8 31 2 10
                                  0 0 8 32 2 10 33 0 8 34 1 9 11 0 35 5
                                  38 37 9 9 10 28 28 39 1 9 28 0 40 2 8
                                  28 0 0 41 1 10 17 0 42 2 10 43 9 0 44
                                  2 10 43 17 43 45 2 18 0 0 0 46 2 9 0
                                  0 8 47 1 10 28 0 48 1 49 17 9 50 2 10
                                  28 9 0 51 1 9 0 0 60 1 9 0 0 61 1 9 0
                                  8 62 2 9 63 0 0 64 1 9 0 0 65 1 9 0 0
                                  66 1 9 0 0 67 2 10 69 9 0 70 2 10 28
                                  8 0 71 2 72 0 0 0 73 2 10 9 9 0 74 1
                                  9 0 0 75 2 9 0 0 0 76 2 9 0 0 0 77 1
                                  80 0 43 81 1 84 83 80 85 0 83 0 86 4
                                  90 89 17 18 28 28 91 1 10 28 0 92 2
                                  10 93 9 0 94 1 90 18 18 96 2 10 28 0
                                  0 97 2 9 28 0 0 98 2 17 0 0 0 99 2 17
                                  0 100 0 101 2 90 28 10 18 102 1 72 0
                                  43 103 1 90 72 72 104 5 0 72 17 18 72
                                  53 11 95 3 0 53 9 10 11 55 2 0 53 9
                                  10 56 2 0 83 72 11 87 2 0 11 17 18 27
                                  4 0 53 9 10 11 28 59 3 0 53 9 10 11
                                  57 2 0 53 9 10 58 4 0 18 17 18 28 28
                                  79 7 0 18 17 18 28 28 28 28 28 78 1 0
                                  80 52 82 3 0 53 9 10 28 54 2 0 11 17
                                  18 19)))))
          '|lookupComplete|)) 
