
(/VERSIONCHECK 2) 

(DEFUN |IDECOMP;convertQF| (|a| $)
  (SPADCALL (SPADCALL (SPADCALL |a| (QREFELT $ 10)) (QREFELT $ 12))
      (SPADCALL (SPADCALL |a| (QREFELT $ 13)) (QREFELT $ 12))
      (QREFELT $ 14))) 

(DEFUN |IDECOMP;convertFQ| (|a| $)
  (SPADCALL (SPADCALL (SPADCALL |a| (QREFELT $ 16)) (QREFELT $ 17))
      (SPADCALL (SPADCALL |a| (QREFELT $ 18)) (QREFELT $ 17))
      (QREFELT $ 19))) 

(DEFUN |IDECOMP;internalForm| (I $)
  (PROG (|Id| #0=#:G1855 |poly| #1=#:G1856 |nId|)
    (RETURN
      (SEQ (LETT |Id| (SPADCALL I (QREFELT $ 22))
                 . #2=(|IDECOMP;internalForm|))
           (LETT |nId|
                 (PROGN
                   (LETT #0# NIL . #2#)
                   (SEQ (LETT |poly| NIL . #2#) (LETT #1# |Id| . #2#)
                        G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN
                                 (LETT |poly| (CAR #1#) . #2#)
                                 NIL))
                           (GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS
                                     (SPADCALL
                                      (CONS
                                       (|function| |IDECOMP;convertQF|)
                                       $)
                                      |poly| (QREFELT $ 27))
                                     #0#) . #2#)))
                        (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                        (EXIT (NREVERSE0 #0#)))) . #2#)
           (EXIT (COND
                   ((SPADCALL I (QREFELT $ 29))
                    (SPADCALL |nId| (QREFELT $ 32)))
                   ('T (SPADCALL |nId| (QREFELT $ 33))))))))) 

(DEFUN |IDECOMP;externalForm| (I $)
  (PROG (|Id| #0=#:G1861 |poly| #1=#:G1862 |nId|)
    (RETURN
      (SEQ (LETT |Id| (SPADCALL I (QREFELT $ 34))
                 . #2=(|IDECOMP;externalForm|))
           (LETT |nId|
                 (PROGN
                   (LETT #0# NIL . #2#)
                   (SEQ (LETT |poly| NIL . #2#) (LETT #1# |Id| . #2#)
                        G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN
                                 (LETT |poly| (CAR #1#) . #2#)
                                 NIL))
                           (GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS
                                     (SPADCALL
                                      (CONS
                                       (|function| |IDECOMP;convertFQ|)
                                       $)
                                      |poly| (QREFELT $ 37))
                                     #0#) . #2#)))
                        (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                        (EXIT (NREVERSE0 #0#)))) . #2#)
           (EXIT (COND
                   ((SPADCALL I (QREFELT $ 38))
                    (SPADCALL |nId| (QREFELT $ 39)))
                   ('T (SPADCALL |nId| (QREFELT $ 40))))))))) 

(DEFUN |IDECOMP;deleteunit| (|lI| $)
  (PROG (#0=#:G1874 I #1=#:G1875)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #2=(|IDECOMP;deleteunit|))
             (SEQ (LETT I NIL . #2#) (LETT #1# |lI| . #2#) G190
                  (COND
                    ((OR (ATOM #1#)
                         (PROGN (LETT I (CAR #1#) . #2#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (COND
                               ((COND
                                  ((SPADCALL (|spadConstant| $ 47) I
                                    (QREFELT $ 48))
                                   'NIL)
                                  ('T 'T))
                                (LETT #0# (CONS I #0#) . #2#)))))
                  (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                  (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |IDECOMP;rearrange| (|vlist| $)
  (COND
    ((SPADCALL |vlist| NIL (QREFELT $ 50)) |vlist|)
    ('T
     (SPADCALL (CONS #'|IDECOMP;rearrange!0| $)
         (SPADCALL (QREFELT $ 45)
             (SPADCALL (QREFELT $ 45) |vlist| (QREFELT $ 52))
             (QREFELT $ 52))
         (QREFELT $ 54))))) 

(DEFUN |IDECOMP;rearrange!0| (|#1| |#2| $)
  (SPADCALL |#2| |#1| (QREFELT $ 51))) 

(DEFUN |IDECOMP;zeroRadComp| (I |truelist| $)
  (PROG (|x| |y| |px| |py| |f| #0=#:G1879 |g| |val| |pv| |pw|
             #1=#:G1890 #2=#:G1891 |Id| |lf| #3=#:G1892 |h| #4=#:G1893
             |ris|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |truelist| NIL (QREFELT $ 50)) I)
             ('T
              (SEQ (LETT |Id| (SPADCALL I (QREFELT $ 34))
                         . #5=(|IDECOMP;zeroRadComp|))
                   (LETT |x|
                         (SPADCALL |truelist| '|last| (QREFELT $ 56)) . #5#)
                   (EXIT (COND
                           ((EQL (LENGTH |Id|) 1)
                            (SEQ (LETT |f| (|SPADfirst| |Id|) . #5#)
                                 (LETT |g|
                                       (PROG2
                                        (LETT #0#
                                         (SPADCALL |f|
                                          (SPADCALL |f|
                                           (SPADCALL |f| |x|
                                            (QREFELT $ 57))
                                           (QREFELT $ 58))
                                          (QREFELT $ 59)) . #5#)
                                        (QCDR #0#)
                                         (|check-union| (QEQCAR #0# 0)
                                          (|DistributedMultivariatePolynomial|
                                           (QREFELT $ 6)
                                           (|Fraction|
                                            (|Polynomial| (|Integer|))))
                                          #0#)) . #5#)
                                 (EXIT (SPADCALL (LIST |g|)
                                        (QREFELT $ 32)))))
                           ('T
                            (SEQ (LETT |y|
                                       (|SPADfirst| |truelist|) . #5#)
                                 (LETT |px|
                                       (SPADCALL |x| (QREFELT $ 60)) . #5#)
                                 (LETT |py|
                                       (SPADCALL |y| (QREFELT $ 60)) . #5#)
                                 (LETT |f|
                                       (SPADCALL |Id| '|last|
                                        (QREFELT $ 61)) . #5#)
                                 (LETT |g|
                                       (PROG2
                                        (LETT #0#
                                         (SPADCALL |f|
                                          (SPADCALL |f|
                                           (SPADCALL |f| |x|
                                            (QREFELT $ 57))
                                           (QREFELT $ 58))
                                          (QREFELT $ 59)) . #5#)
                                        (QCDR #0#)
                                         (|check-union| (QEQCAR #0# 0)
                                          (|DistributedMultivariatePolynomial|
                                           (QREFELT $ 6)
                                           (|Fraction|
                                            (|Polynomial| (|Integer|))))
                                          #0#)) . #5#)
                                 (LETT |Id|
                                       (SPADCALL
                                        (CONS |g|
                                         (SPADCALL |f| |Id|
                                          (QREFELT $ 62)))
                                        (QREFELT $ 64)) . #5#)
                                 (LETT |lf| (|SPADfirst| |Id|) . #5#)
                                 (LETT |pv|
                                       (|spadConstant| $ 65) . #5#)
                                 (LETT |pw|
                                       (|spadConstant| $ 65) . #5#)
                                 (SEQ G190
                                      (COND
                                        ((NULL
                                          (COND
                                            ((EQL
                                              (SPADCALL |lf| |y|
                                               (QREFELT $ 67))
                                              1)
                                             'NIL)
                                            ('T 'T)))
                                         #6=(GO G191)))
                                      (SEQ
                                       (LETT |val| (RANDOM 23) . #5#)
                                       (LETT |pv|
                                        (SPADCALL |px|
                                         (SPADCALL |val| |py|
                                          (QREFELT $ 68))
                                         (QREFELT $ 69)) . #5#)
                                       (LETT |pw|
                                        (SPADCALL |px|
                                         (SPADCALL |val| |py|
                                          (QREFELT $ 68))
                                         (QREFELT $ 70)) . #5#)
                                       (LETT |Id|
                                        (SPADCALL
                                         (PROGN
                                           (LETT #1# NIL . #5#)
                                           (SEQ (LETT |h| NIL . #5#)
                                            (LETT #2# |Id| . #5#) G190
                                            (COND
                                              ((OR (ATOM #2#)
                                                (PROGN
                                                  (LETT |h|
                                                   (CAR #2#) . #5#)
                                                  NIL))
                                               #6#))
                                            (SEQ
                                             (EXIT
                                              (LETT #1#
                                               (CONS
                                                (SPADCALL
                                                 (SPADCALL |h| |x|
                                                  (QREFELT $ 72))
                                                 |pv| (QREFELT $ 74))
                                                #1#) . #5#)))
                                            (LETT #2# (CDR #2#) . #5#)
                                            #7=(GO G190) G191
                                            (EXIT (NREVERSE0 #1#))))
                                         (QREFELT $ 64)) . #5#)
                                       (EXIT
                                        (LETT |lf|
                                         (|SPADfirst| |Id|) . #5#)))
                                      NIL #7# G191 (EXIT NIL))
                                 (LETT |ris|
                                       (SPADCALL
                                        (|IDECOMP;zeroRadComp|
                                         (SPADCALL (CDR |Id|)
                                          (QREFELT $ 32))
                                         (CDR |truelist|) $)
                                        (QREFELT $ 34)) . #5#)
                                 (LETT |ris| (CONS |lf| |ris|) . #5#)
                                 (COND
                                   ((NULL
                                     (SPADCALL |pv|
                                      (|spadConstant| $ 65)
                                      (QREFELT $ 75)))
                                    (LETT |ris|
                                     (PROGN
                                       (LETT #3# NIL . #5#)
                                       (SEQ (LETT |h| NIL . #5#)
                                        (LETT #4# |ris| . #5#) G190
                                        (COND
                                          ((OR (ATOM #4#)
                                            (PROGN
                                              (LETT |h|
                                               (CAR #4#) . #5#)
                                              NIL))
                                           #6#))
                                        (SEQ
                                         (EXIT
                                          (LETT #3#
                                           (CONS
                                            (SPADCALL
                                             (SPADCALL |h| |x|
                                              (QREFELT $ 72))
                                             |pw| (QREFELT $ 74))
                                            #3#) . #5#)))
                                        (LETT #4# (CDR #4#) . #5#) #7#
                                        G191 (EXIT (NREVERSE0 #3#)))) . #5#)))
                                 (EXIT (SPADCALL
                                        (SPADCALL |ris| (QREFELT $ 64))
                                        (QREFELT $ 32)))))))))))))) 

(DEFUN |IDECOMP;goodPower| (|s| I $)
  (PROG (JJ J #0=#:G1900 |g| #1=#:G1901 |f|)
    (RETURN
      (SEQ (LETT |f| |s| . #2=(|IDECOMP;goodPower|))
           (LETT I (SPADCALL I (QREFELT $ 76)) . #2#)
           (LETT J
                 (SPADCALL
                     (LETT JJ (SPADCALL I |s| (QREFELT $ 77)) . #2#)
                     (QREFELT $ 34)) . #2#)
           (SEQ G190
                (COND
                  ((NULL (COND
                           ((SPADCALL
                                (SPADCALL
                                    (PROGN
                                      (LETT #0# NIL . #2#)
                                      (SEQ (LETT |g| NIL . #2#)
                                       (LETT #1# J . #2#) G190
                                       (COND
                                         ((OR (ATOM #1#)
                                           (PROGN
                                             (LETT |g| (CAR #1#) . #2#)
                                             NIL))
                                          #3=(GO G191)))
                                       (SEQ
                                        (EXIT
                                         (LETT #0#
                                          (CONS
                                           (SPADCALL |f| |g|
                                            (QREFELT $ 78))
                                           #0#) . #2#)))
                                       (LETT #1# (CDR #1#) . #2#)
                                       #4=(GO G190) G191
                                       (EXIT (NREVERSE0 #0#))))
                                    (QREFELT $ 33))
                                I (QREFELT $ 79))
                            'NIL)
                           ('T 'T)))
                   #3#))
                (SEQ (EXIT (LETT |f|
                                 (SPADCALL |s| |f| (QREFELT $ 78)) . #2#)))
                NIL #4# G191 (EXIT NIL))
           (EXIT (CONS |f| JJ)))))) 

(DEFUN |IDECOMP;zerodimcase| (J |truelist| $)
  (PROG (|n| |x| #0=#:G1914 |f| |y| #1=#:G1867 |Jd| #2=#:G1913)
    (RETURN
      (SEQ (EXIT (COND
                   ((OR (SPADCALL (|spadConstant| $ 47) J
                            (QREFELT $ 48))
                        (SPADCALL |truelist| NIL (QREFELT $ 50)))
                    'T)
                   ('T
                    (SEQ (LETT |n| (LENGTH |truelist|)
                               . #3=(|IDECOMP;zerodimcase|))
                         (LETT |Jd|
                               (SPADCALL (SPADCALL J (QREFELT $ 34))
                                   (QREFELT $ 64)) . #3#)
                         (SEQ (LETT |x| NIL . #3#)
                              (LETT #0# |truelist| . #3#) G190
                              (COND
                                ((OR (ATOM #0#)
                                     (PROGN
                                       (LETT |x| (CAR #0#) . #3#)
                                       NIL)
                                     (NULL
                                      (COND
                                        ((SPADCALL |Jd| NIL
                                          (QREFELT $ 80))
                                         'NIL)
                                        ('T 'T))))
                                 #4=(GO G191)))
                              (SEQ (LETT |f| (|SPADfirst| |Jd|) . #3#)
                                   (LETT |Jd| (CDR |Jd|) . #3#)
                                   (SEQ
                                    (LETT |y|
                                     (SPADCALL |f| (QREFELT $ 82)) . #3#)
                                    (EXIT
                                     (COND
                                       ((OR
                                         (OR (QEQCAR |y| 1)
                                          (NULL
                                           (SPADCALL (QCDR |y|) |x|
                                            (QREFELT $ 83))))
                                         (NULL
                                          (|IDECOMP;ismonic| |f| |x| $)))
                                        (PROGN
                                          (LETT #2# 'NIL . #3#)
                                          (GO #2#))))))
                                   (SEQ G190
                                    (COND
                                      ((NULL
                                        (COND
                                          ((SPADCALL |Jd| NIL
                                            (QREFELT $ 80))
                                           'NIL)
                                          ('T
                                           (SPADCALL
                                            (PROG2
                                             (LETT #1#
                                              (SPADCALL
                                               (|SPADfirst| |Jd|)
                                               (QREFELT $ 82)) . #3#)
                                             (QCDR #1#)
                                              (|check-union|
                                               (QEQCAR #1# 0)
                                               (|OrderedVariableList|
                                                (QREFELT $ 6))
                                               #1#))
                                            |x| (QREFELT $ 83)))))
                                       #4#))
                                    (SEQ
                                     (EXIT
                                      (LETT |Jd| (CDR |Jd|) . #3#)))
                                    NIL #5=(GO G190) G191 (EXIT NIL))
                                   (EXIT
                                    (COND
                                      ((SPADCALL |Jd| NIL
                                        (QREFELT $ 80))
                                       (COND
                                         ((<
                                           (SPADCALL |x| |truelist|
                                            (QREFELT $ 84))
                                           |n|)
                                          (PROGN
                                            (LETT #2# 'NIL . #3#)
                                            (GO #2#))))))))
                              (LETT #0# (CDR #0#) . #3#) #5# G191
                              (EXIT NIL))
                         (EXIT 'T)))))
           #2# (EXIT #2#))))) 

(DEFUN |IDECOMP;findvar| (J |truelist| $)
  (PROG (|f| #0=#:G1919 |t| |vt| |lmonicvar| |badvar|)
    (RETURN
      (SEQ (LETT |lmonicvar| NIL . #1=(|IDECOMP;findvar|))
           (SEQ (LETT |f| NIL . #1#)
                (LETT #0# (SPADCALL J (QREFELT $ 34)) . #1#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |f| (CAR #0#) . #1#) NIL))
                   (GO G191)))
                (SEQ (LETT |t|
                           (SPADCALL |f| (SPADCALL |f| (QREFELT $ 85))
                               (QREFELT $ 70)) . #1#)
                     (LETT |vt| (SPADCALL |t| (QREFELT $ 86)) . #1#)
                     (EXIT (COND
                             ((EQL (LENGTH |vt|) 1)
                              (LETT |lmonicvar|
                                    (SPADCALL |vt| |lmonicvar|
                                     (QREFELT $ 87)) . #1#)))))
                (LETT #0# (CDR #0#) . #1#) (GO G190) G191 (EXIT NIL))
           (LETT |badvar|
                 (SPADCALL |truelist| |lmonicvar| (QREFELT $ 52)) . #1#)
           (EXIT (|SPADfirst| |badvar|)))))) 

(DEFUN |IDECOMP;reduceDim| (|flag| J |truelist| $)
  (PROG (|x| #0=#:G1941 #1=#:G1942 |Jnew| |Jc| #2=#:G1943 |idp|
             #3=#:G1944 #4=#:G1945 #5=#:G1946 |f| #6=#:G1947 #7=#:G1931
             #8=#:G1929 #9=#:G1930 |s| #10=#:G1948 II #11=#:G1949
             |good| |sideal| |sresult| JJ #12=#:G1950 |res1|)
    (RETURN
      (SEQ (COND
             ((SPADCALL (|spadConstant| $ 47) J (QREFELT $ 48))
              (LIST J))
             ((|IDECOMP;zerodimcase| J |truelist| $)
              (COND
                ((QEQCAR |flag| 0)
                 (|IDECOMP;zeroPrimDecomp| J |truelist| $))
                ((QEQCAR |flag| 1)
                 (LIST (|IDECOMP;zeroRadComp| J |truelist| $)))))
             ('T
              (SEQ (LETT |x| (|IDECOMP;findvar| J |truelist| $)
                         . #13=(|IDECOMP;reduceDim|))
                   (LETT |Jnew|
                         (PROGN
                           (LETT #0# NIL . #13#)
                           (SEQ (LETT |f| NIL . #13#)
                                (LETT #1#
                                      (SPADCALL J (QREFELT $ 34)) . #13#)
                                G190
                                (COND
                                  ((OR (ATOM #1#)
                                    (PROGN
                                      (LETT |f| (CAR #1#) . #13#)
                                      NIL))
                                   #14=(GO G191)))
                                (SEQ (EXIT
                                      (LETT #0#
                                       (CONS
                                        (|IDECOMP;pushdown| |f| |x| $)
                                        #0#) . #13#)))
                                (LETT #1# (CDR #1#) . #13#)
                                #15=(GO G190) G191
                                (EXIT (NREVERSE0 #0#)))) . #13#)
                   (LETT |Jc| NIL . #13#)
                   (LETT |Jc|
                         (|IDECOMP;reduceDim| |flag|
                             (SPADCALL |Jnew| (QREFELT $ 32))
                             (SPADCALL |x| |truelist| (QREFELT $ 88))
                             $) . #13#)
                   (LETT |res1|
                         (PROGN
                           (LETT #2# NIL . #13#)
                           (SEQ (LETT |idp| NIL . #13#)
                                (LETT #3# |Jc| . #13#) G190
                                (COND
                                  ((OR (ATOM #3#)
                                    (PROGN
                                      (LETT |idp| (CAR #3#) . #13#)
                                      NIL))
                                   #14#))
                                (SEQ (EXIT
                                      (LETT #2#
                                       (CONS
                                        (SPADCALL
                                         (PROGN
                                           (LETT #4# NIL . #13#)
                                           (SEQ (LETT |f| NIL . #13#)
                                            (LETT #5#
                                             (SPADCALL |idp|
                                              (QREFELT $ 34)) . #13#)
                                            G190
                                            (COND
                                              ((OR (ATOM #5#)
                                                (PROGN
                                                  (LETT |f|
                                                   (CAR #5#) . #13#)
                                                  NIL))
                                               #14#))
                                            (SEQ
                                             (EXIT
                                              (LETT #4#
                                               (CONS
                                                (|IDECOMP;pushup| |f|
                                                 |x| $)
                                                #4#) . #13#)))
                                            (LETT #5# (CDR #5#) . #13#)
                                            #15# G191
                                            (EXIT (NREVERSE0 #4#))))
                                         (QREFELT $ 33))
                                        #2#) . #13#)))
                                (LETT #3# (CDR #3#) . #13#) #15# G191
                                (EXIT (NREVERSE0 #2#)))) . #13#)
                   (LETT |s|
                         (|IDECOMP;pushup|
                             (SPADCALL
                                 (PROGN
                                   (LETT #9# NIL . #13#)
                                   (SEQ (LETT |f| NIL . #13#)
                                    (LETT #6# |Jnew| . #13#) G190
                                    (COND
                                      ((OR (ATOM #6#)
                                        (PROGN
                                          (LETT |f| (CAR #6#) . #13#)
                                          NIL))
                                       #14#))
                                    (SEQ
                                     (EXIT
                                      (PROGN
                                        (LETT #7#
                                         (SPADCALL |f| (QREFELT $ 89)) . #13#)
                                        (COND
                                          (#9#
                                           (LETT #8#
                                            (SPADCALL #8# #7#
                                             (QREFELT $ 90)) . #13#))
                                          ('T
                                           (PROGN
                                             (LETT #8# #7# . #13#)
                                             (LETT #9# 'T . #13#)))))))
                                    (LETT #6# (CDR #6#) . #13#) #15#
                                    G191 (EXIT NIL))
                                   (COND
                                     (#9# #8#)
                                     ('T (|spadConstant| $ 91))))
                                 (QREFELT $ 92))
                             |x| $) . #13#)
                   (EXIT (COND
                           ((EQL (SPADCALL |s| |x| (QREFELT $ 67)) 0)
                            |res1|)
                           ('T
                            (SEQ (LETT |res1|
                                       (PROGN
                                         (LETT #10# NIL . #13#)
                                         (SEQ (LETT II NIL . #13#)
                                          (LETT #11# |res1| . #13#)
                                          G190
                                          (COND
                                            ((OR (ATOM #11#)
                                              (PROGN
                                                (LETT II
                                                 (CAR #11#) . #13#)
                                                NIL))
                                             #14#))
                                          (SEQ
                                           (EXIT
                                            (LETT #10#
                                             (CONS
                                              (SPADCALL II |s|
                                               (QREFELT $ 77))
                                              #10#) . #13#)))
                                          (LETT #11# (CDR #11#) . #13#)
                                          #15# G191
                                          (EXIT (NREVERSE0 #10#)))) . #13#)
                                 (LETT |good|
                                       (|IDECOMP;goodPower| |s| J $) . #13#)
                                 (LETT |sideal|
                                       (SPADCALL
                                        (SPADCALL
                                         (CONS (QCAR |good|)
                                          (SPADCALL J (QREFELT $ 34)))
                                         (QREFELT $ 64))
                                        (QREFELT $ 32)) . #13#)
                                 (EXIT (COND
                                         ((SPADCALL (QCDR |good|)
                                           |sideal| (QREFELT $ 79))
                                          |res1|)
                                         ('T
                                          (SEQ
                                           (LETT |sresult|
                                            (|IDECOMP;reduceDim| |flag|
                                             |sideal| |truelist| $) . #13#)
                                           (SEQ (LETT JJ NIL . #13#)
                                            (LETT #12#
                                             |sresult| . #13#)
                                            G190
                                            (COND
                                              ((OR (ATOM #12#)
                                                (PROGN
                                                  (LETT JJ
                                                   (CAR #12#) . #13#)
                                                  NIL))
                                               #14#))
                                            (SEQ
                                             (EXIT
                                              (COND
                                                ((NULL
                                                  (SPADCALL
                                                   (QCDR |good|) JJ
                                                   (QREFELT $ 79)))
                                                 (LETT |res1|
                                                  (CONS JJ |res1|) . #13#)))))
                                            (LETT #12#
                                             (CDR #12#) . #13#)
                                            #15# G191 (EXIT NIL))
                                           (EXIT |res1|)))))))))))))))) 

(DEFUN |IDECOMP;zeroPrimDecomp| (I |truelist| $)
  (PROG (|newJ| |lval| J |x| |Jd| |lfact| |ef| #0=#:G1961 #1=#:G1955
                |g| J1 #2=#:G1960 |ris|)
    (RETURN
      (SEQ (EXIT (COND
                   ((SPADCALL |truelist| NIL (QREFELT $ 50))
                    (SPADCALL I (QREFELT $ 94)))
                   ('T
                    (SEQ (LETT |newJ|
                               (|IDECOMP;genPosLastVar| I |truelist| $)
                               . #3=(|IDECOMP;zeroPrimDecomp|))
                         (LETT |lval| (QCAR |newJ|) . #3#)
                         (LETT J
                               (SPADCALL (QCDR |newJ|) (QREFELT $ 76)) . #3#)
                         (LETT |x|
                               (SPADCALL |truelist| '|last|
                                   (QREFELT $ 56)) . #3#)
                         (LETT |Jd| (SPADCALL J (QREFELT $ 34)) . #3#)
                         (LETT |g|
                               (SPADCALL |Jd| '|last| (QREFELT $ 61)) . #3#)
                         (LETT |lfact|
                               (SPADCALL (SPADCALL |g| (QREFELT $ 97))
                                   (QREFELT $ 100)) . #3#)
                         (LETT |ris| NIL . #3#)
                         (SEQ (LETT |ef| NIL . #3#)
                              (LETT #0# |lfact| . #3#) G190
                              (COND
                                ((OR (ATOM #0#)
                                     (PROGN
                                       (LETT |ef| (CAR #0#) . #3#)
                                       NIL))
                                 (GO G191)))
                              (SEQ (LETT |g|
                                    (SPADCALL (QCAR |ef|)
                                     (PROG1
                                      (LETT #1# (QCDR |ef|) . #3#)
                                       (|check-subtype| (>= #1# 0)
                                        '(|NonNegativeInteger|) #1#))
                                     (QREFELT $ 101)) . #3#)
                                   (LETT J1
                                    (SPADCALL
                                     (SPADCALL (CONS |g| |Jd|)
                                      (QREFELT $ 64))
                                     (QREFELT $ 32)) . #3#)
                                   (COND
                                     ((NULL
                                       (|IDECOMP;is0dimprimary| J1
                                        |truelist| $))
                                      (PROGN
                                        (LETT #2#
                                         (|IDECOMP;zeroPrimDecomp| I
                                          |truelist| $) . #3#)
                                        (GO #2#))))
                                   (EXIT
                                    (LETT |ris|
                                     (CONS
                                      (SPADCALL
                                       (|IDECOMP;backGenPos| J1 |lval|
                                        |truelist| $)
                                       (QREFELT $ 76))
                                      |ris|) . #3#)))
                              (LETT #0# (CDR #0#) . #3#) (GO G190) G191
                              (EXIT NIL))
                         (EXIT |ris|)))))
           #2# (EXIT #2#))))) 

(DEFUN |IDECOMP;radical;2Pi;13| (I $)
  (PROG (J |f| #0=#:G1973 #1=#:G1964 #2=#:G1962 #3=#:G1963 |truelist|
           #4=#:G1815 #5=#:G1974 #6=#:G1970 #7=#:G1968 #8=#:G1969)
    (RETURN
      (SEQ (LETT J
                 (SPADCALL (|IDECOMP;internalForm| I $) (QREFELT $ 76))
                 . #9=(|IDECOMP;radical;2Pi;13|))
           (LETT |truelist|
                 (|IDECOMP;rearrange|
                     (PROGN
                       (LETT #3# NIL . #9#)
                       (SEQ (LETT |f| NIL . #9#)
                            (LETT #0#
                                  (SPADCALL J (QREFELT $ 34)) . #9#)
                            G190
                            (COND
                              ((OR (ATOM #0#)
                                   (PROGN
                                     (LETT |f| (CAR #0#) . #9#)
                                     NIL))
                               #10=(GO G191)))
                            (SEQ (EXIT (PROGN
                                         (LETT #1#
                                          (SPADCALL |f| (QREFELT $ 86)) . #9#)
                                         (COND
                                           (#3#
                                            (LETT #2#
                                             (SPADCALL #2# #1#
                                              (QREFELT $ 87)) . #9#))
                                           ('T
                                            (PROGN
                                              (LETT #2# #1# . #9#)
                                              (LETT #3# 'T . #9#)))))))
                            (LETT #0# (CDR #0#) . #9#) #11=(GO G190)
                            G191 (EXIT NIL))
                       (COND
                         (#3# #2#)
                         (#12='T (|IdentityError| '|setUnion|))))
                     $) . #9#)
           (EXIT (COND
                   ((SPADCALL |truelist| NIL (QREFELT $ 50))
                    (|IDECOMP;externalForm| J $))
                   (#12#
                    (|IDECOMP;externalForm|
                        (PROGN
                          (LETT #8# NIL . #9#)
                          (SEQ (LETT #4# NIL . #9#)
                               (LETT #5#
                                     (|IDECOMP;reduceDim|
                                      (CONS 1 "zeroRadComp") J
                                      |truelist| $) . #9#)
                               G190
                               (COND
                                 ((OR (ATOM #5#)
                                      (PROGN
                                        (LETT #4# (CAR #5#) . #9#)
                                        NIL))
                                  #10#))
                               (SEQ (EXIT
                                     (PROGN
                                       (LETT #6# #4# . #9#)
                                       (COND
                                         (#8#
                                          (LETT #7#
                                           (SPADCALL #7# #6#
                                            (QREFELT $ 102)) . #9#))
                                         ('T
                                          (PROGN
                                            (LETT #7# #6# . #9#)
                                            (LETT #8# 'T . #9#)))))))
                               (LETT #5# (CDR #5#) . #9#) #11# G191
                               (EXIT NIL))
                          (COND
                            (#8# #7#)
                            (#12# (|IdentityError| '|intersect|))))
                        $)))))))) 

(DEFUN |IDECOMP;pushdown| (|g| |x| $)
  (PROG (|i| |g1| |rf|)
    (RETURN
      (SEQ (LETT |rf| (|spadConstant| $ 65) . #0=(|IDECOMP;pushdown|))
           (LETT |i|
                 (SPADCALL |x| (QREFELT $ 45) (QREFELT $ 84)) . #0#)
           (SEQ G190
                (COND
                  ((NULL (COND
                           ((SPADCALL |g| (|spadConstant| $ 65)
                                (QREFELT $ 75))
                            'NIL)
                           ('T 'T)))
                   (GO G191)))
                (SEQ (LETT |g1| (SPADCALL |g| (QREFELT $ 85)) . #0#)
                     (LETT |rf|
                           (SPADCALL |rf|
                               (|IDECOMP;pushdterm|
                                   (SPADCALL |g| |g1| (QREFELT $ 70))
                                   |x| |i| $)
                               (QREFELT $ 69)) . #0#)
                     (EXIT (LETT |g| |g1| . #0#)))
                NIL (GO G190) G191 (EXIT NIL))
           (EXIT |rf|))))) 

(DEFUN |IDECOMP;pushdterm| (|t| |x| |i| $)
  (PROG (|n| |xp| |cf| |newt| #0=#:G1980)
    (RETURN
      (SEQ (LETT |n| (SPADCALL |t| |x| (QREFELT $ 67))
                 . #1=(|IDECOMP;pushdterm|))
           (LETT |xp| (SPADCALL |x| (QREFELT $ 104)) . #1#)
           (LETT |cf|
                 (SPADCALL
                     (SPADCALL (|spadConstant| $ 105) |xp| |n|
                         (QREFELT $ 106))
                     (QREFELT $ 107)) . #1#)
           (LETT |newt|
                 (SPADCALL |t|
                     (SPADCALL (|spadConstant| $ 47) |x| |n|
                         (QREFELT $ 108))
                     (QREFELT $ 59)) . #1#)
           (EXIT (SPADCALL |cf|
                     (PROG2 (LETT #0# |newt| . #1#) (QCDR #0#)
                       (|check-union| (QEQCAR #0# 0)
                           (|DistributedMultivariatePolynomial|
                               (QREFELT $ 6)
                               (|Fraction| (|Polynomial| (|Integer|))))
                           #0#))
                     (QREFELT $ 109))))))) 

(DEFUN |IDECOMP;pushup| (|f| |x| $)
  (PROG (|xp| |h| |g| |rf|)
    (RETURN
      (SEQ (LETT |h| (|spadConstant| $ 105) . #0=(|IDECOMP;pushup|))
           (LETT |rf| (|spadConstant| $ 65) . #0#) (LETT |g| |f| . #0#)
           (LETT |xp| (SPADCALL |x| (QREFELT $ 104)) . #0#)
           (SEQ G190
                (COND
                  ((NULL (COND
                           ((SPADCALL |g| (|spadConstant| $ 65)
                                (QREFELT $ 75))
                            'NIL)
                           ('T 'T)))
                   #1=(GO G191)))
                (SEQ (LETT |h|
                           (SPADCALL
                               (|IDECOMP;trueden|
                                   (SPADCALL
                                    (SPADCALL |g| (QREFELT $ 89))
                                    (QREFELT $ 18))
                                   |xp| $)
                               |h| (QREFELT $ 110)) . #0#)
                     (EXIT (LETT |g|
                                 (SPADCALL |g| (QREFELT $ 85)) . #0#)))
                NIL #2=(GO G190) G191 (EXIT NIL))
           (LETT |f|
                 (SPADCALL (SPADCALL |h| (QREFELT $ 107)) |f|
                     (QREFELT $ 109)) . #0#)
           (SEQ G190
                (COND
                  ((NULL (COND
                           ((SPADCALL |f| (|spadConstant| $ 65)
                                (QREFELT $ 75))
                            'NIL)
                           ('T 'T)))
                   #1#))
                (SEQ (LETT |g| (SPADCALL |f| (QREFELT $ 85)) . #0#)
                     (LETT |rf|
                           (SPADCALL |rf|
                               (|IDECOMP;pushuterm|
                                   (SPADCALL |f| |g| (QREFELT $ 70))
                                   |xp| |x| $)
                               (QREFELT $ 69)) . #0#)
                     (EXIT (LETT |f| |g| . #0#)))
                NIL #2# G191 (EXIT NIL))
           (EXIT |rf|))))) 

(DEFUN |IDECOMP;trueden| (|c| |x| $)
  (COND
    ((EQL (SPADCALL |c| |x| (QREFELT $ 111)) 0) (|spadConstant| $ 105))
    ('T |c|))) 

(DEFUN |IDECOMP;pushuterm| (|t| |xp| |x| $)
  (SPADCALL
      (|IDECOMP;pushucoef|
          (SPADCALL
              (SPADCALL (SPADCALL |t| (QREFELT $ 89)) (QREFELT $ 16))
              |xp| (QREFELT $ 112))
          |x| $)
      (SPADCALL
          (SPADCALL
              (SPADCALL
                  (SPADCALL (SPADCALL |t| (QREFELT $ 89))
                      (QREFELT $ 18))
                  (QREFELT $ 107))
              (QREFELT $ 113))
          (SPADCALL |t| (QREFELT $ 115)) (QREFELT $ 116))
      (QREFELT $ 78))) 

(DEFUN |IDECOMP;pushucoef| (|c| |x| $)
  (COND
    ((SPADCALL |c| (|spadConstant| $ 118) (QREFELT $ 119))
     (|spadConstant| $ 65))
    ('T
     (SPADCALL
         (SPADCALL
             (SPADCALL
                 (SPADCALL (SPADCALL |c| (QREFELT $ 120))
                     (QREFELT $ 107))
                 (QREFELT $ 92))
             |x| (SPADCALL |c| (QREFELT $ 121)) (QREFELT $ 108))
         (|IDECOMP;pushucoef| (SPADCALL |c| (QREFELT $ 122)) |x| $)
         (QREFELT $ 69))))) 

(DEFUN |IDECOMP;is0dimprimary| (J |truelist| $)
  (PROG (|Jd| JR |f| #0=#:G2011 |x| #1=#:G2000 |i| JM #2=#:G2010 JP)
    (RETURN
      (SEQ (EXIT (COND
                   ((SPADCALL (|spadConstant| $ 47) J (QREFELT $ 48))
                    'T)
                   ('T
                    (SEQ (LETT |Jd|
                               (SPADCALL (SPADCALL J (QREFELT $ 76))
                                   (QREFELT $ 34))
                               . #3=(|IDECOMP;is0dimprimary|))
                         (COND
                           ((NULL (EQL (LENGTH
                                        (SPADCALL
                                         (SPADCALL
                                          (SPADCALL |Jd| '|last|
                                           (QREFELT $ 61))
                                          (QREFELT $ 97))
                                         (QREFELT $ 100)))
                                       1))
                            (EXIT (PROGN
                                    (LETT #2# 'NIL . #3#)
                                    (GO #2#)))))
                         (LETT |i|
                               (SPADCALL (LENGTH |truelist|) 1
                                   (QREFELT $ 123)) . #3#)
                         (EXIT (COND
                                 ((QEQCAR |i| 1)
                                  (PROGN (LETT #2# 'T . #3#) (GO #2#)))
                                 ('T
                                  (SEQ (LETT JR (REVERSE |Jd|) . #3#)
                                       (LETT JM
                                        (SPADCALL
                                         (LIST (|SPADfirst| JR))
                                         (QREFELT $ 32)) . #3#)
                                       (LETT JP NIL . #3#)
                                       (SEQ (LETT |f| NIL . #3#)
                                        (LETT #0# (CDR JR) . #3#) G190
                                        (COND
                                          ((OR (ATOM #0#)
                                            (PROGN
                                              (LETT |f|
                                               (CAR #0#) . #3#)
                                              NIL))
                                           (GO G191)))
                                        (SEQ
                                         (EXIT
                                          (COND
                                            ((|IDECOMP;ismonic| |f|
                                              (SPADCALL |truelist|
                                               (QCDR |i|)
                                               (QREFELT $ 124))
                                              $)
                                             (SEQ
                                              (LETT |x|
                                               (SPADCALL |truelist|
                                                (QCDR |i|)
                                                (QREFELT $ 124)) . #3#)
                                              (LETT |i|
                                               (CONS 0
                                                (PROG1
                                                 (LETT #1#
                                                  (- (QCDR |i|) 1) . #3#)
                                                  (|check-subtype|
                                                   (>= #1# 0)
                                                   '(|NonNegativeInteger|)
                                                   #1#))) . #3#)
                                              (COND
                                                ((NULL
                                                  (|IDECOMP;testPower|
                                                   (SPADCALL |f| |x|
                                                    (QREFELT $ 72))
                                                   |x| JM $))
                                                 (PROGN
                                                   (LETT #2#
                                                    'NIL . #3#)
                                                   (GO #2#))))
                                              (EXIT
                                               (LETT JM
                                                (SPADCALL
                                                 (APPEND (CONS |f| JP)
                                                  (SPADCALL JM
                                                   (QREFELT $ 34)))
                                                 (QREFELT $ 32)) . #3#))))
                                            ('T
                                             (SEQ
                                              (COND
                                                ((NULL
                                                  (SPADCALL |f| JM
                                                   (QREFELT $ 125)))
                                                 (PROGN
                                                   (LETT #2#
                                                    'NIL . #3#)
                                                   (GO #2#))))
                                              (EXIT
                                               (LETT JP
                                                (CONS |f| JP) . #3#)))))))
                                        (LETT #0# (CDR #0#) . #3#)
                                        (GO G190) G191 (EXIT NIL))
                                       (EXIT 'T)))))))))
           #2# (EXIT #2#))))) 

(DEFUN |IDECOMP;genPosLastVar| (J |truelist| $)
  (PROG (|x| |lv1| #0=#:G2020 #1=#:G2021 |ranvals| |rv| #2=#:G2023 |vv|
             #3=#:G2022 #4=#:G2016 #5=#:G2014 #6=#:G2015 |val|
             #7=#:G2024 |p| #8=#:G2025)
    (RETURN
      (SEQ (LETT |x| (SPADCALL |truelist| (QREFELT $ 126))
                 . #9=(|IDECOMP;genPosLastVar|))
           (LETT |lv1| (SPADCALL |x| |truelist| (QREFELT $ 88)) . #9#)
           (LETT |ranvals|
                 (PROGN
                   (LETT #0# NIL . #9#)
                   (SEQ (LETT |vv| NIL . #9#) (LETT #1# |lv1| . #9#)
                        G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN (LETT |vv| (CAR #1#) . #9#) NIL))
                           #10=(GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS (RANDOM 23) #0#) . #9#)))
                        (LETT #1# (CDR #1#) . #9#) #11=(GO G190) G191
                        (EXIT (NREVERSE0 #0#)))) . #9#)
           (LETT |val|
                 (PROGN
                   (LETT #6# NIL . #9#)
                   (SEQ (LETT |rv| NIL . #9#)
                        (LETT #2# |ranvals| . #9#)
                        (LETT |vv| NIL . #9#) (LETT #3# |lv1| . #9#)
                        G190
                        (COND
                          ((OR (ATOM #3#)
                               (PROGN (LETT |vv| (CAR #3#) . #9#) NIL)
                               (ATOM #2#)
                               (PROGN (LETT |rv| (CAR #2#) . #9#) NIL))
                           #10#))
                        (SEQ (EXIT (PROGN
                                     (LETT #4#
                                      (SPADCALL |rv|
                                       (SPADCALL |vv| (QREFELT $ 60))
                                       (QREFELT $ 68)) . #9#)
                                     (COND
                                       (#6#
                                        (LETT #5#
                                         (SPADCALL #5# #4#
                                          (QREFELT $ 69)) . #9#))
                                       ('T
                                        (PROGN
                                          (LETT #5# #4# . #9#)
                                          (LETT #6# 'T . #9#)))))))
                        (LETT #3#
                              (PROG1 (CDR #3#)
                                (LETT #2# (CDR #2#) . #9#)) . #9#)
                        #11# G191 (EXIT NIL))
                   (COND (#6# #5#) ('T (|spadConstant| $ 65)))) . #9#)
           (LETT |val|
                 (SPADCALL |val| (SPADCALL |x| (QREFELT $ 60))
                     (QREFELT $ 69)) . #9#)
           (EXIT (CONS |ranvals|
                       (SPADCALL
                           (SPADCALL
                               (PROGN
                                 (LETT #7# NIL . #9#)
                                 (SEQ (LETT |p| NIL . #9#)
                                      (LETT #8#
                                       (SPADCALL J (QREFELT $ 34)) . #9#)
                                      G190
                                      (COND
                                        ((OR (ATOM #8#)
                                          (PROGN
                                            (LETT |p| (CAR #8#) . #9#)
                                            NIL))
                                         #10#))
                                      (SEQ
                                       (EXIT
                                        (LETT #7#
                                         (CONS
                                          (SPADCALL
                                           (SPADCALL |p| |x|
                                            (QREFELT $ 72))
                                           |val| (QREFELT $ 74))
                                          #7#) . #9#)))
                                      (LETT #8# (CDR #8#) . #9#) #11#
                                      G191 (EXIT (NREVERSE0 #7#))))
                               (QREFELT $ 64))
                           (QREFELT $ 32)))))))) 

(DEFUN |IDECOMP;backGenPos| (I |lval| |truelist| $)
  (PROG (|x| |lv1| |rv| #0=#:G2042 |vv| #1=#:G2041 #2=#:G2037
             #3=#:G2035 #4=#:G2036 |val| #5=#:G2043 |p| #6=#:G2044)
    (RETURN
      (SEQ (COND
             ((SPADCALL |lval| NIL (QREFELT $ 128)) I)
             (#7='T
              (SEQ (LETT |x| (SPADCALL |truelist| (QREFELT $ 126))
                         . #8=(|IDECOMP;backGenPos|))
                   (LETT |lv1|
                         (SPADCALL |x| |truelist| (QREFELT $ 88)) . #8#)
                   (LETT |val|
                         (SPADCALL
                             (PROGN
                               (LETT #4# NIL . #8#)
                               (SEQ (LETT |rv| NIL . #8#)
                                    (LETT #0# |lval| . #8#)
                                    (LETT |vv| NIL . #8#)
                                    (LETT #1# |lv1| . #8#) G190
                                    (COND
                                      ((OR (ATOM #1#)
                                        (PROGN
                                          (LETT |vv| (CAR #1#) . #8#)
                                          NIL)
                                        (ATOM #0#)
                                        (PROGN
                                          (LETT |rv| (CAR #0#) . #8#)
                                          NIL))
                                       #9=(GO G191)))
                                    (SEQ
                                     (EXIT
                                      (PROGN
                                        (LETT #2#
                                         (SPADCALL |rv|
                                          (SPADCALL |vv|
                                           (QREFELT $ 60))
                                          (QREFELT $ 68)) . #8#)
                                        (COND
                                          (#4#
                                           (LETT #3#
                                            (SPADCALL #3# #2#
                                             (QREFELT $ 69)) . #8#))
                                          ('T
                                           (PROGN
                                             (LETT #3# #2# . #8#)
                                             (LETT #4# 'T . #8#)))))))
                                    (LETT #1#
                                     (PROG1 (CDR #1#)
                                       (LETT #0# (CDR #0#) . #8#)) . #8#)
                                    #10=(GO G190) G191 (EXIT NIL))
                               (COND
                                 (#4# #3#)
                                 (#7# (|spadConstant| $ 65))))
                             (QREFELT $ 129)) . #8#)
                   (LETT |val|
                         (SPADCALL |val| (SPADCALL |x| (QREFELT $ 60))
                             (QREFELT $ 69)) . #8#)
                   (EXIT (SPADCALL
                             (SPADCALL
                                 (PROGN
                                   (LETT #5# NIL . #8#)
                                   (SEQ (LETT |p| NIL . #8#)
                                    (LETT #6#
                                     (SPADCALL I (QREFELT $ 34)) . #8#)
                                    G190
                                    (COND
                                      ((OR (ATOM #6#)
                                        (PROGN
                                          (LETT |p| (CAR #6#) . #8#)
                                          NIL))
                                       #9#))
                                    (SEQ
                                     (EXIT
                                      (LETT #5#
                                       (CONS
                                        (SPADCALL
                                         (SPADCALL |p| |x|
                                          (QREFELT $ 72))
                                         |val| (QREFELT $ 74))
                                        #5#) . #8#)))
                                    (LETT #6# (CDR #6#) . #8#) #10#
                                    G191 (EXIT (NREVERSE0 #5#))))
                                 (QREFELT $ 64))
                             (QREFELT $ 32)))))))))) 

(DEFUN |IDECOMP;ismonic| (|f| |x| $)
  (SPADCALL
      (SPADCALL (SPADCALL |f| |x| (QREFELT $ 72)) (QREFELT $ 130))
      (QREFELT $ 131))) 

(DEFUN |IDECOMP;testPower| (|uf| |x| J $)
  (PROG (#0=#:G2046 |df| #1=#:G2047 |trailp| |linp| |g|)
    (RETURN
      (SEQ (LETT |df|
                 (PROG1 (LETT #0# (SPADCALL |uf| (QREFELT $ 132))
                              . #2=(|IDECOMP;testPower|))
                   (|check-subtype| (> #0# 0) '(|PositiveInteger|) #0#)) . #2#)
           (LETT |trailp|
                 (SPADCALL
                     (SPADCALL (SPADCALL |df| (QREFELT $ 12))
                         (QREFELT $ 113))
                     (SPADCALL |uf|
                         (PROG1 (LETT #1# (- |df| 1) . #2#)
                           (|check-subtype| (>= #1# 0)
                               '(|NonNegativeInteger|) #1#))
                         (QREFELT $ 133))
                     (QREFELT $ 109)) . #2#)
           (LETT |linp|
                 (SPADCALL
                     (SPADCALL
                         (SPADCALL (|spadConstant| $ 47) 1
                             (QREFELT $ 134))
                         (SPADCALL |trailp| 0 (QREFELT $ 134))
                         (QREFELT $ 135))
                     |df| (QREFELT $ 136)) . #2#)
           (LETT |g|
                 (SPADCALL (SPADCALL |uf| |linp| (QREFELT $ 137)) |x|
                     (QREFELT $ 138)) . #2#)
           (EXIT (SPADCALL |g| J (QREFELT $ 125))))))) 

(DEFUN |IDECOMP;zeroDimPrime?;PiB;25| (I $)
  (PROG (J |n| |Jd| |f| #0=#:G2060 #1=#:G2059 |i| |g| |lfact|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT J
                            (SPADCALL
                                (QCDR (|IDECOMP;genPosLastVar|
                                       (|IDECOMP;internalForm| I $)
                                       (QREFELT $ 45) $))
                                (QREFELT $ 76))
                            . #2=(|IDECOMP;zeroDimPrime?;PiB;25|))
                      (EXIT (COND
                              ((SPADCALL (|spadConstant| $ 47) J
                                   (QREFELT $ 48))
                               'T)
                              ('T
                               (SEQ (LETT |n|
                                     (LENGTH (QREFELT $ 6)) . #2#)
                                    (LETT |i| 1 . #2#)
                                    (LETT |Jd|
                                     (SPADCALL J (QREFELT $ 34)) . #2#)
                                    (COND
                                      ((NULL (EQL (LENGTH |Jd|) |n|))
                                       (EXIT 'NIL)))
                                    (SEQ (LETT |f| NIL . #2#)
                                     (LETT #0# |Jd| . #2#) G190
                                     (COND
                                       ((OR (ATOM #0#)
                                         (PROGN
                                           (LETT |f| (CAR #0#) . #2#)
                                           NIL))
                                        (GO G191)))
                                     (SEQ
                                      (COND
                                        ((NULL
                                          (|IDECOMP;ismonic| |f|
                                           (SPADCALL (QREFELT $ 45) |i|
                                            (QREFELT $ 124))
                                           $))
                                         (PROGN
                                           (LETT #1# 'NIL . #2#)
                                           (GO #1#))))
                                      (COND
                                        ((< |i| |n|)
                                         (COND
                                           ((NULL
                                             (EQL
                                              (SPADCALL
                                               (SPADCALL |f|
                                                (SPADCALL
                                                 (QREFELT $ 45) |i|
                                                 (QREFELT $ 124))
                                                (QREFELT $ 72))
                                               (QREFELT $ 132))
                                              1))
                                            (PROGN
                                              (LETT #1# 'NIL . #2#)
                                              (GO #1#))))))
                                      (EXIT (LETT |i| (+ |i| 1) . #2#)))
                                     (LETT #0# (CDR #0#) . #2#)
                                     (GO G190) G191 (EXIT NIL))
                                    (LETT |g|
                                     (SPADCALL |Jd| |n|
                                      (QREFELT $ 139)) . #2#)
                                    (EXIT
                                     (COND
                                       ((< 1
                                         (LENGTH
                                          (LETT |lfact|
                                           (SPADCALL
                                            (SPADCALL |g|
                                             (QREFELT $ 97))
                                            (QREFELT $ 100)) . #2#)))
                                        'NIL)
                                       ('T
                                        (EQL
                                         (QCDR
                                          (SPADCALL |lfact| 1
                                           (QREFELT $ 143)))
                                         1))))))))))
           #1# (EXIT #1#))))) 

(DEFUN |IDECOMP;zeroDimPrimary?;PiB;26| (J $)
  (|IDECOMP;is0dimprimary| (|IDECOMP;internalForm| J $) (QREFELT $ 45)
      $)) 

(DEFUN |IDECOMP;primaryDecomp;PiL;27| (I $)
  (PROG (J |f| #0=#:G2071 #1=#:G2064 #2=#:G2062 #3=#:G2063 |truelist|
           #4=#:G2072 II #5=#:G2073)
    (RETURN
      (SEQ (LETT J
                 (SPADCALL (|IDECOMP;internalForm| I $) (QREFELT $ 76))
                 . #6=(|IDECOMP;primaryDecomp;PiL;27|))
           (LETT |truelist|
                 (|IDECOMP;rearrange|
                     (PROGN
                       (LETT #3# NIL . #6#)
                       (SEQ (LETT |f| NIL . #6#)
                            (LETT #0#
                                  (SPADCALL J (QREFELT $ 34)) . #6#)
                            G190
                            (COND
                              ((OR (ATOM #0#)
                                   (PROGN
                                     (LETT |f| (CAR #0#) . #6#)
                                     NIL))
                               #7=(GO G191)))
                            (SEQ (EXIT (PROGN
                                         (LETT #1#
                                          (SPADCALL |f| (QREFELT $ 86)) . #6#)
                                         (COND
                                           (#3#
                                            (LETT #2#
                                             (SPADCALL #2# #1#
                                              (QREFELT $ 87)) . #6#))
                                           ('T
                                            (PROGN
                                              (LETT #2# #1# . #6#)
                                              (LETT #3# 'T . #6#)))))))
                            (LETT #0# (CDR #0#) . #6#) #8=(GO G190)
                            G191 (EXIT NIL))
                       (COND
                         (#3# #2#)
                         (#9='T (|IdentityError| '|setUnion|))))
                     $) . #6#)
           (EXIT (COND
                   ((SPADCALL |truelist| NIL (QREFELT $ 50))
                    (LIST (|IDECOMP;externalForm| J $)))
                   (#9#
                    (PROGN
                      (LETT #4# NIL . #6#)
                      (SEQ (LETT II NIL . #6#)
                           (LETT #5#
                                 (|IDECOMP;reduceDim|
                                     (CONS 0 "zeroPrimDecomp") J
                                     |truelist| $) . #6#)
                           G190
                           (COND
                             ((OR (ATOM #5#)
                                  (PROGN
                                    (LETT II (CAR #5#) . #6#)
                                    NIL))
                              #7#))
                           (SEQ (EXIT (LETT #4#
                                       (CONS
                                        (|IDECOMP;externalForm| II $)
                                        #4#) . #6#)))
                           (LETT #5# (CDR #5#) . #6#) #8# G191
                           (EXIT (NREVERSE0 #4#))))))))))) 

(DEFUN |IDECOMP;contract;PiLPi;28| (I |lvar| $)
  (PROG (|Id| #0=#:G2091 #1=#:G2076 #2=#:G2074 #3=#:G2075 |fullVars|
              |n| #4=#:G2092 #5=#:G2093 |newVars| #6=#:G2094 #7=#:G2095
              |subsVars| #8=#:G2096 |g| #9=#:G2097 |lJ| #10=#:G2098 |f|
              #11=#:G2099 #12=#:G1867 J #13=#:G2100 |vv| #14=#:G2101
              |fullPol| #15=#:G2102 |gg| #16=#:G2103)
    (RETURN
      (SEQ (LETT |Id|
                 (SPADCALL (SPADCALL I (QREFELT $ 148)) (QREFELT $ 22))
                 . #17=(|IDECOMP;contract;PiLPi;28|))
           (EXIT (COND
                   ((NULL |Id|) I)
                   ('T
                    (SEQ (LETT |fullVars|
                               (PROGN
                                 (LETT #3# NIL . #17#)
                                 (SEQ (LETT |g| NIL . #17#)
                                      (LETT #0# |Id| . #17#) G190
                                      (COND
                                        ((OR (ATOM #0#)
                                          (PROGN
                                            (LETT |g| (CAR #0#) . #17#)
                                            NIL))
                                         #18=(GO G191)))
                                      (SEQ
                                       (EXIT
                                        (PROGN
                                          (LETT #1#
                                           (SPADCALL |g|
                                            (QREFELT $ 149)) . #17#)
                                          (COND
                                            (#3#
                                             (LETT #2#
                                              (SPADCALL #2# #1#
                                               (QREFELT $ 87)) . #17#))
                                            ('T
                                             (PROGN
                                               (LETT #2# #1# . #17#)
                                               (LETT #3# 'T . #17#)))))))
                                      (LETT #0# (CDR #0#) . #17#)
                                      #19=(GO G190) G191 (EXIT NIL))
                                 (COND
                                   (#3# #2#)
                                   ('T (|IdentityError| '|setUnion|)))) . #17#)
                         (EXIT (COND
                                 ((SPADCALL |fullVars| |lvar|
                                      (QREFELT $ 50))
                                  I)
                                 ('T
                                  (SEQ (LETT |n|
                                        (LENGTH |lvar|) . #17#)
                                       (EXIT
                                        (COND
                                          ((< (LENGTH |fullVars|) |n|)
                                           (|error| "wrong vars"))
                                          ((EQL |n| 0) I)
                                          ('T
                                           (SEQ
                                            (LETT |newVars|
                                             (APPEND
                                              (PROGN
                                                (LETT #4# NIL . #17#)
                                                (SEQ
                                                 (LETT |vv| NIL . #17#)
                                                 (LETT #5#
                                                  |fullVars| . #17#)
                                                 G190
                                                 (COND
                                                   ((OR (ATOM #5#)
                                                     (PROGN
                                                       (LETT |vv|
                                                        (CAR #5#) . #17#)
                                                       NIL))
                                                    #18#))
                                                 (SEQ
                                                  (EXIT
                                                   (COND
                                                     ((COND
                                                        ((SPADCALL |vv|
                                                          |lvar|
                                                          (QREFELT $
                                                           150))
                                                         'NIL)
                                                        ('T 'T))
                                                      (LETT #4#
                                                       (CONS |vv| #4#) . #17#)))))
                                                 (LETT #5#
                                                  (CDR #5#) . #17#)
                                                 #19# G191
                                                 (EXIT (NREVERSE0 #4#))))
                                              |lvar|) . #17#)
                                            (LETT |subsVars|
                                             (PROGN
                                               (LETT #6# NIL . #17#)
                                               (SEQ
                                                (LETT |vv| NIL . #17#)
                                                (LETT #7#
                                                 |newVars| . #17#)
                                                G190
                                                (COND
                                                  ((OR (ATOM #7#)
                                                    (PROGN
                                                      (LETT |vv|
                                                       (CAR #7#) . #17#)
                                                      NIL))
                                                   #18#))
                                                (SEQ
                                                 (EXIT
                                                  (LETT #6#
                                                   (CONS
                                                    (SPADCALL
                                                     (|spadConstant| $
                                                      141)
                                                     |vv| 1
                                                     (QREFELT $ 151))
                                                    #6#) . #17#)))
                                                (LETT #7#
                                                 (CDR #7#) . #17#)
                                                #19# G191
                                                (EXIT (NREVERSE0 #6#)))) . #17#)
                                            (LETT |lJ|
                                             (PROGN
                                               (LETT #8# NIL . #17#)
                                               (SEQ
                                                (LETT |g| NIL . #17#)
                                                (LETT #9# |Id| . #17#)
                                                G190
                                                (COND
                                                  ((OR (ATOM #9#)
                                                    (PROGN
                                                      (LETT |g|
                                                       (CAR #9#) . #17#)
                                                      NIL))
                                                   #18#))
                                                (SEQ
                                                 (EXIT
                                                  (LETT #8#
                                                   (CONS
                                                    (SPADCALL |g|
                                                     |fullVars|
                                                     |subsVars|
                                                     (QREFELT $ 153))
                                                    #8#) . #17#)))
                                                (LETT #9#
                                                 (CDR #9#) . #17#)
                                                #19# G191
                                                (EXIT (NREVERSE0 #8#)))) . #17#)
                                            (LETT J
                                             (SPADCALL |lJ|
                                              (QREFELT $ 155)) . #17#)
                                            (EXIT
                                             (COND
                                               ((SPADCALL J
                                                 (LIST
                                                  (|spadConstant| $
                                                   141))
                                                 (QREFELT $ 156))
                                                (SPADCALL J
                                                 (QREFELT $ 39)))
                                               ((SPADCALL J
                                                 (LIST
                                                  (|spadConstant| $
                                                   157))
                                                 (QREFELT $ 156))
                                                (SPADCALL NIL
                                                 (QREFELT $ 39)))
                                               ('T
                                                (SEQ
                                                 (LETT J
                                                  (PROGN
                                                    (LETT #10#
                                                     NIL . #17#)
                                                    (SEQ
                                                     (LETT |f|
                                                      NIL . #17#)
                                                     (LETT #11#
                                                      J . #17#)
                                                     G190
                                                     (COND
                                                       ((OR (ATOM #11#)
                                                         (PROGN
                                                           (LETT |f|
                                                            (CAR #11#) . #17#)
                                                           NIL))
                                                        #18#))
                                                     (SEQ
                                                      (EXIT
                                                       (COND
                                                         ((SPADCALL
                                                           (PROG2
                                                            (LETT #12#
                                                             (SPADCALL
                                                              |f|
                                                              (QREFELT
                                                               $ 158)) . #17#)
                                                            (QCDR #12#)
                                                             (|check-union|
                                                              (QEQCAR
                                                               #12# 0)
                                                              (|OrderedVariableList|
                                                               (QREFELT
                                                                $ 6))
                                                              #12#))
                                                           |newVars|
                                                           (QREFELT $
                                                            150))
                                                          (LETT #10#
                                                           (CONS |f|
                                                            #10#) . #17#)))))
                                                     (LETT #11#
                                                      (CDR #11#) . #17#)
                                                     #19# G191
                                                     (EXIT
                                                      (NREVERSE0 #10#)))) . #17#)
                                                 (LETT |fullPol|
                                                  (PROGN
                                                    (LETT #13#
                                                     NIL . #17#)
                                                    (SEQ
                                                     (LETT |vv|
                                                      NIL . #17#)
                                                     (LETT #14#
                                                      |fullVars| . #17#)
                                                     G190
                                                     (COND
                                                       ((OR (ATOM #14#)
                                                         (PROGN
                                                           (LETT |vv|
                                                            (CAR #14#) . #17#)
                                                           NIL))
                                                        #18#))
                                                     (SEQ
                                                      (EXIT
                                                       (LETT #13#
                                                        (CONS
                                                         (SPADCALL
                                                          (|spadConstant|
                                                           $ 141)
                                                          |vv| 1
                                                          (QREFELT $
                                                           151))
                                                         #13#) . #17#)))
                                                     (LETT #14#
                                                      (CDR #14#) . #17#)
                                                     #19# G191
                                                     (EXIT
                                                      (NREVERSE0 #13#)))) . #17#)
                                                 (EXIT
                                                  (SPADCALL
                                                   (PROGN
                                                     (LETT #15#
                                                      NIL . #17#)
                                                     (SEQ
                                                      (LETT |gg|
                                                       NIL . #17#)
                                                      (LETT #16#
                                                       J . #17#)
                                                      G190
                                                      (COND
                                                        ((OR
                                                          (ATOM #16#)
                                                          (PROGN
                                                            (LETT |gg|
                                                             (CAR #16#) . #17#)
                                                            NIL))
                                                         #18#))
                                                      (SEQ
                                                       (EXIT
                                                        (LETT #15#
                                                         (CONS
                                                          (SPADCALL
                                                           |gg|
                                                           |newVars|
                                                           |fullPol|
                                                           (QREFELT $
                                                            153))
                                                          #15#) . #17#)))
                                                      (LETT #16#
                                                       (CDR #16#) . #17#)
                                                      #19# G191
                                                      (EXIT
                                                       (NREVERSE0 #15#))))
                                                   (QREFELT $ 39))))))))))))))))))))))) 

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

(DEFUN |IdealDecompositionPackage;| (|#1| |#2|)
  (PROG (DV$1 DV$2 |dv$| $ |pv$| #0=#:G2104 |xx| #1=#:G2105 #2=#:G1867
              #3=#:G1870)
    (RETURN
      (SEQ (PROGN
             (LETT DV$1 (|devaluate| |#1|)
                   . #4=(|IdealDecompositionPackage|))
             (LETT DV$2 (|devaluate| |#2|) . #4#)
             (LETT |dv$|
                   (LIST '|IdealDecompositionPackage| DV$1 DV$2) . #4#)
             (LETT $ (GETREFV 160) . #4#)
             (QSETREFV $ 0 |dv$|)
             (QSETREFV $ 3
                 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #4#))
             (|haddProp| |$ConstructorCache|
                 '|IdealDecompositionPackage| (LIST DV$1 DV$2)
                 (CONS 1 $))
             (|stuffDomainSlots| $)
             (QSETREFV $ 6 |#1|)
             (QSETREFV $ 7 |#2|)
             (QSETREFV $ 45
                 (PROGN
                   (LETT #0# NIL . #4#)
                   (SEQ (LETT |xx| NIL . #4#) (LETT #1# |#1| . #4#)
                        G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN (LETT |xx| (CAR #1#) . #4#) NIL))
                           (GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS
                                     (PROG2
                                      (LETT #2#
                                       (SPADCALL |xx| (QREFELT $ 44)) . #4#)
                                      (QCDR #2#)
                                       (|check-union| (QEQCAR #2# 0)
                                        (|OrderedVariableList|
                                         (SPADCALL |xx| (QREFELT $ 44)))
                                        #2#))
                                     #0#) . #4#)))
                        (LETT #1# (CDR #1#) . #4#) (GO G190) G191
                        (EXIT (NREVERSE0 #0#)))))
             (QSETREFV $ 46
                 (PROG1 (LETT #3# (- (LENGTH (QREFELT $ 45)) 1) . #4#)
                   (|check-subtype| (>= #3# 0) '(|NonNegativeInteger|)
                       #3#)))
             $))))) 

(MAKEPROP '|IdealDecompositionPackage| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|Integer|) (|Fraction| 8) (0 . |numer|) (|Fraction| 15)
             (5 . |coerce|) (10 . |denom|) (15 . /) (|Polynomial| 8)
             (21 . |numer|) (26 . |ground|) (31 . |denom|) (36 . /)
             (|List| 25)
             (|PolynomialIdeals| 9 (|DirectProduct| 7 66) 43 25)
             (42 . |generators|)
             (|DistributedMultivariatePolynomial| 6 11)
             (|Mapping| 11 9) (|DistributedMultivariatePolynomial| 6 9)
             (|MPolyCatFunctions2| 43 (|DirectProduct| 7 66)
                 (|DirectProduct| 7 66) 9 11 25 23)
             (47 . |map|) (|Boolean|) (53 . |groebner?|) (|List| 23)
             (|PolynomialIdeals| 11 (|DirectProduct| 7 66) 43 23)
             (58 . |groebnerIdeal|) (63 . |ideal|) (68 . |generators|)
             (|Mapping| 9 11)
             (|MPolyCatFunctions2| 43 (|DirectProduct| 7 66)
                 (|DirectProduct| 7 66) 11 9 23 25)
             (73 . |map|) (79 . |groebner?|) (84 . |groebnerIdeal|)
             (89 . |ideal|) (|Union| $ '"failed") (|Symbol|)
             (|OrderedVariableList| 6) (94 . |variable|) '|lvint|
             '|nvint1| (99 . |One|) (103 . |element?|) (|List| 43)
             (109 . =) (115 . <) (121 . |setDifference|)
             (|Mapping| 28 43 43) (127 . |sort|) '"last" (133 . |elt|)
             (139 . |differentiate|) (145 . |gcd|) (151 . |exquo|)
             (157 . |coerce|) (162 . |elt|) (168 . |remove|)
             (|GroebnerPackage| 11 (|DirectProduct| 7 66) 43 23)
             (174 . |groebner|) (179 . |Zero|) (|NonNegativeInteger|)
             (183 . |degree|) (189 . *) (195 . +) (201 . -)
             (|SparseUnivariatePolynomial| $) (207 . |univariate|)
             (|SparseUnivariatePolynomial| 23) (213 . |elt|) (219 . =)
             (225 . |groebner|) (230 . |saturate|) (236 . *)
             (242 . |in?|) (248 . =) (|Union| 43 '"failed")
             (254 . |mainVariable|) (259 . =) (265 . |position|)
             (271 . |reductum|) (276 . |variables|) (281 . |setUnion|)
             (287 . |remove|) (293 . |leadingCoefficient|) (298 . *)
             (304 . |One|) (308 . |coerce|) (|List| 31) (313 . |list|)
             (|Factored| 23)
             (|MPolyCatRationalFunctionFactorizer|
                 (|DirectProduct| 7 66) 43 8 23)
             (318 . |factor|)
             (|Record| (|:| |factor| 23) (|:| |exponent| 8))
             (|List| 98) (323 . |factors|) (328 . **)
             (334 . |intersect|) |IDECOMP;radical;2Pi;13|
             (340 . |convert|) (345 . |One|) (349 . |monomial|)
             (356 . |coerce|) (361 . |monomial|) (368 . *)
             (374 . |lcm|) (380 . |degree|) (386 . |univariate|)
             (392 . |inv|)
             (|DirectProduct| (NRTEVAL (LENGTH (QREFELT $ 6))) 66)
             (397 . |degree|) (402 . |monomial|)
             (|SparseUnivariatePolynomial| 15) (408 . |Zero|) (412 . =)
             (418 . |leadingCoefficient|) (423 . |degree|)
             (428 . |reductum|) (433 . |subtractIfCan|) (439 . |elt|)
             (445 . |inRadical?|) (451 . |last|) (|List| 8) (456 . =)
             (462 . -) (467 . |leadingCoefficient|) (472 . |ground?|)
             (477 . |degree|) (482 . |coefficient|) (488 . |monomial|)
             (494 . +) (500 . **) (506 . -) (512 . |multivariate|)
             (518 . |elt|) (524 . |One|) (528 . |One|) (532 . |One|)
             (536 . |elt|) |IDECOMP;zeroDimPrime?;PiB;25|
             |IDECOMP;zeroDimPrimary?;PiB;26| (|List| 21)
             |IDECOMP;primaryDecomp;PiL;27| (542 . |groebner|)
             (547 . |variables|) (552 . |member?|) (558 . |monomial|)
             (|List| $) (565 . |eval|)
             (|GroebnerPackage| 9 (|DirectProduct| 7 66) 43 25)
             (572 . |groebner|) (577 . =) (583 . |Zero|)
             (587 . |mainVariable|) |IDECOMP;contract;PiLPi;28|)
          '#(|zeroDimPrime?| 592 |zeroDimPrimary?| 597 |radical| 602
             |prime?| 607 |primaryDecomp| 612 |contract| 617)
          'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 159
                                '(1 9 8 0 10 1 11 0 8 12 1 9 8 0 13 2
                                  11 0 0 0 14 1 11 15 0 16 1 15 8 0 17
                                  1 11 15 0 18 2 9 0 8 8 19 1 21 20 0
                                  22 2 26 23 24 25 27 1 21 28 0 29 1 31
                                  0 30 32 1 31 0 30 33 1 31 30 0 34 2
                                  36 25 35 23 37 1 31 28 0 38 1 21 0 20
                                  39 1 21 0 20 40 1 43 41 42 44 0 23 0
                                  47 2 31 28 23 0 48 2 49 28 0 0 50 2
                                  43 28 0 0 51 2 49 0 0 0 52 2 49 0 53
                                  0 54 2 49 43 0 55 56 2 23 0 0 43 57 2
                                  23 0 0 0 58 2 23 41 0 0 59 1 23 0 43
                                  60 2 30 23 0 55 61 2 30 0 23 0 62 1
                                  63 30 30 64 0 23 0 65 2 23 66 0 43 67
                                  2 23 0 8 0 68 2 23 0 0 0 69 2 23 0 0
                                  0 70 2 23 71 0 43 72 2 73 23 0 23 74
                                  2 23 28 0 0 75 1 31 0 0 76 2 31 0 0
                                  23 77 2 23 0 0 0 78 2 31 28 0 0 79 2
                                  30 28 0 0 80 1 23 81 0 82 2 43 28 0 0
                                  83 2 49 8 43 0 84 1 23 0 0 85 1 23 49
                                  0 86 2 49 0 0 0 87 2 49 0 43 0 88 1
                                  23 11 0 89 2 11 0 0 0 90 0 11 0 91 1
                                  23 0 11 92 1 93 0 31 94 1 96 95 23 97
                                  1 95 99 0 100 2 23 0 0 66 101 2 31 0
                                  0 0 102 1 43 42 0 104 0 15 0 105 3 15
                                  0 0 42 66 106 1 11 0 15 107 3 23 0 0
                                  43 66 108 2 23 0 11 0 109 2 15 0 0 0
                                  110 2 15 66 0 42 111 2 15 71 0 42 112
                                  1 11 0 0 113 1 23 114 0 115 2 23 0 11
                                  114 116 0 117 0 118 2 117 28 0 0 119
                                  1 117 15 0 120 1 117 66 0 121 1 117 0
                                  0 122 2 66 41 0 0 123 2 49 43 0 8 124
                                  2 31 28 23 0 125 1 49 43 0 126 2 127
                                  28 0 0 128 1 23 0 0 129 1 73 23 0 130
                                  1 23 28 0 131 1 73 66 0 132 2 73 23 0
                                  66 133 2 73 0 23 66 134 2 73 0 0 0
                                  135 2 73 0 0 66 136 2 73 0 0 0 137 2
                                  23 0 71 43 138 2 30 23 0 8 139 0 9 0
                                  140 0 25 0 141 0 73 0 142 2 99 98 0 8
                                  143 1 21 0 0 148 1 25 49 0 149 2 49
                                  28 43 0 150 3 25 0 0 43 66 151 3 25 0
                                  0 49 152 153 1 154 20 20 155 2 20 28
                                  0 0 156 0 25 0 157 1 25 81 0 158 1 0
                                  28 21 144 1 0 28 21 145 1 0 21 21 103
                                  1 0 28 21 1 1 0 146 21 147 2 0 21 21
                                  49 159)))))
          '|lookupComplete|)) 
