
(/VERSIONCHECK 2) 

(DEFUN |SOLVERAD;New| (|s| $)
  (PROG (S)
    (RETURN
      (SEQ (COND
             ((SPADCALL |s| (|spadConstant| $ 13) (QREFELT $ 15))
              (|spadConstant| $ 13))
             ('T
              (SEQ (LETT S
                         (SPADCALL
                             (SPADCALL
                                 (SPADCALL (SPADCALL (QREFELT $ 17))
                                     (QREFELT $ 19))
                                 (QREFELT $ 21))
                             (QREFELT $ 22))
                         |SOLVERAD;New|)
                   (SETELT $ 7
                           (APPEND (LIST
                                    (SPADCALL S |s| (QREFELT $ 23)))
                                   (QREFELT $ 7)))
                   (EXIT S)))))))) 

(DEFUN |SOLVERAD;linear| (|u| $)
  (LIST (SPADCALL
            (SPADCALL
                (SPADCALL (SPADCALL |u| 0 (QREFELT $ 26))
                    (QREFELT $ 27))
                (QREFELT $ 28))
            (SPADCALL (SPADCALL |u| 1 (QREFELT $ 26)) (QREFELT $ 28))
            (QREFELT $ 31)))) 

(DEFUN |SOLVERAD;quadratic| (|u| $)
  (SPADCALL (SPADCALL (ELT $ 28) |u| (QREFELT $ 35)) (QREFELT $ 38))) 

(DEFUN |SOLVERAD;cubic| (|u| $)
  (SPADCALL (SPADCALL (ELT $ 28) |u| (QREFELT $ 35)) (QREFELT $ 39))) 

(DEFUN |SOLVERAD;quartic| (|u| $)
  (SPADCALL (SPADCALL (ELT $ 28) |u| (QREFELT $ 35)) (QREFELT $ 40))) 

(DEFUN |SOLVERAD;rad| (|n| $) (SPADCALL |n| (QREFELT $ 42))) 

(DEFUN |SOLVERAD;wrap| (|s| $)
  (COND ((QREFELT $ 8) (|SOLVERAD;New| |s| $)) ('T |s|))) 

(DEFUN |SOLVERAD;findGenZeros| (|rlp| |rlv| $)
  (PROG (|pp| |v| #0=#:G1835 |r| #1=#:G1836 #2=#:G1837 |p| #3=#:G1839
              |vv| #4=#:G1838 |res|)
    (RETURN
      (SEQ (LETT |pp| (|SPADfirst| |rlp|)
                 . #5=(|SOLVERAD;findGenZeros|))
           (LETT |v| (|SPADfirst| |rlv|) . #5#)
           (LETT |rlv| (CDR |rlv|) . #5#) (LETT |res| NIL . #5#)
           (LETT |res|
                 (APPEND (PROGN
                           (LETT #0# NIL . #5#)
                           (SEQ (LETT |r| NIL . #5#)
                                (LETT #1#
                                      (SPADCALL
                                       (SPADCALL |pp| (QREFELT $ 21))
                                       |v| (QREFELT $ 43)) . #5#)
                                G190
                                (COND
                                  ((OR (ATOM #1#)
                                    (PROGN
                                      (LETT |r| (CAR #1#) . #5#)
                                      NIL))
                                   #6=(GO G191)))
                                (SEQ (EXIT
                                      (LETT #0#
                                       (CONS
                                        (REVERSE
                                         (CONS |r|
                                          (PROGN
                                            (LETT #2# NIL . #5#)
                                            (SEQ (LETT |p| NIL . #5#)
                                             (LETT #3#
                                              (CDR |rlp|) . #5#)
                                             (LETT |vv| NIL . #5#)
                                             (LETT #4# |rlv| . #5#)
                                             G190
                                             (COND
                                               ((OR (ATOM #4#)
                                                 (PROGN
                                                   (LETT |vv|
                                                    (CAR #4#) . #5#)
                                                   NIL)
                                                 (ATOM #3#)
                                                 (PROGN
                                                   (LETT |p|
                                                    (CAR #3#) . #5#)
                                                   NIL))
                                                #6#))
                                             (SEQ
                                              (EXIT
                                               (LETT #2#
                                                (CONS
                                                 (SPADCALL
                                                  (SPADCALL
                                                   (SPADCALL
                                                    (SPADCALL
                                                     (SPADCALL
                                                      (SPADCALL |p|
                                                       |vv|
                                                       (QREFELT $ 45))
                                                      0 (QREFELT $ 26))
                                                     (QREFELT $ 28))
                                                    (QREFELT $ 46))
                                                   (SPADCALL
                                                    (SPADCALL
                                                     (SPADCALL |p| |vv|
                                                      (QREFELT $ 45))
                                                     (QREFELT $ 47))
                                                    (QREFELT $ 28))
                                                   (QREFELT $ 31))
                                                  (SPADCALL |v|
                                                   (QREFELT $ 49))
                                                  |r| (QREFELT $ 51))
                                                 #2#) . #5#)))
                                             (LETT #4#
                                              (PROG1 (CDR #4#)
                                                (LETT #3#
                                                 (CDR #3#) . #5#)) . #5#)
                                             #7=(GO G190) G191
                                             (EXIT (NREVERSE0 #2#))))))
                                        #0#) . #5#)))
                                (LETT #1# (CDR #1#) . #5#) #7# G191
                                (EXIT (NREVERSE0 #0#))))
                         |res|) . #5#)
           (EXIT |res|))))) 

(DEFUN |SOLVERAD;findZeros| (|rlp| |rlv| $)
  (PROG (#0=#:G1847 |v| #1=#:G1849 |p| #2=#:G1848 |parRes| |par|
            #3=#:G1850 |res1| |p1| |lv1| |rlv1| |res|)
    (RETURN
      (SEQ (LETT |parRes|
                 (PROGN
                   (LETT #0# NIL . #4=(|SOLVERAD;findZeros|))
                   (SEQ (LETT |v| NIL . #4#) (LETT #1# |rlv| . #4#)
                        (LETT |p| NIL . #4#) (LETT #2# |rlp| . #4#)
                        G190
                        (COND
                          ((OR (ATOM #2#)
                               (PROGN (LETT |p| (CAR #2#) . #4#) NIL)
                               (ATOM #1#)
                               (PROGN (LETT |v| (CAR #1#) . #4#) NIL))
                           #5=(GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS
                                     (SPADCALL
                                      (SPADCALL |p| (QREFELT $ 21)) |v|
                                      (QREFELT $ 43))
                                     #0#) . #4#)))
                        (LETT #2#
                              (PROG1 (CDR #2#)
                                (LETT #1# (CDR #1#) . #4#)) . #4#)
                        #6=(GO G190) G191 (EXIT (NREVERSE0 #0#)))) . #4#)
           (LETT |parRes| (|SOLVERAD;select| |parRes| $) . #4#)
           (LETT |res| NIL . #4#)
           (SEQ (LETT |par| NIL . #4#) (LETT #3# |parRes| . #4#) G190
                (COND
                  ((OR (ATOM #3#)
                       (PROGN (LETT |par| (CAR #3#) . #4#) NIL))
                   #5#))
                (SEQ (LETT |res1| (LIST (|SPADfirst| |par|)) . #4#)
                     (LETT |lv1|
                           (LIST (SPADCALL (|SPADfirst| |rlv|)
                                     (QREFELT $ 49))) . #4#)
                     (LETT |rlv1| (CDR |rlv|) . #4#)
                     (LETT |p1| (CDR |par|) . #4#)
                     (SEQ G190
                          (COND
                            ((NULL (COND
                                     ((SPADCALL |p1| NIL
                                       (QREFELT $ 52))
                                      'NIL)
                                     ('T 'T)))
                             #5#))
                          (SEQ (LETT |res1|
                                     (CONS
                                      (SPADCALL (|SPADfirst| |p1|)
                                       |lv1| |res1| (QREFELT $ 55))
                                      |res1|) . #4#)
                               (LETT |p1| (CDR |p1|) . #4#)
                               (LETT |lv1|
                                     (CONS
                                      (SPADCALL (|SPADfirst| |rlv1|)
                                       (QREFELT $ 49))
                                      |lv1|) . #4#)
                               (EXIT (LETT |rlv1| (CDR |rlv1|) . #4#)))
                          NIL #6# G191 (EXIT NIL))
                     (EXIT (LETT |res| (CONS |res1| |res|) . #4#)))
                (LETT #3# (CDR #3#) . #4#) #6# G191 (EXIT NIL))
           (EXIT |res|))))) 

(DEFUN |SOLVERAD;radicalSolve;FSL;10| (|pol| |v| $)
  (PROG (#0=#:G1853 |r| #1=#:G1854)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #2=(|SOLVERAD;radicalSolve;FSL;10|))
             (SEQ (LETT |r| NIL . #2#)
                  (LETT #1# (SPADCALL |pol| |v| (QREFELT $ 43)) . #2#)
                  G190
                  (COND
                    ((OR (ATOM #1#)
                         (PROGN (LETT |r| (CAR #1#) . #2#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (LETT #0#
                                   (CONS
                                    (SPADCALL
                                     (SPADCALL |v| (QREFELT $ 56)) |r|
                                     (QREFELT $ 57))
                                    #0#) . #2#)))
                  (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                  (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |SOLVERAD;radicalSolve;FL;11| (|p| $)
  (PROG (|lv|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |p| (QREFELT $ 60))
              (|error| "equation is always satisfied"))
             ('T
              (SEQ (LETT |lv|
                         (SPADCALL
                             (SPADCALL
                                 (SPADCALL
                                     (SPADCALL |p| (QREFELT $ 61))
                                     (QREFELT $ 63))
                                 (SPADCALL
                                     (SPADCALL |p| (QREFELT $ 64))
                                     (QREFELT $ 63))
                                 (QREFELT $ 65))
                             (QREFELT $ 66))
                         |SOLVERAD;radicalSolve;FL;11|)
                   (EXIT (COND
                           ((NULL |lv|)
                            (|error| "inconsistent equation"))
                           ((< 1 (LENGTH |lv|))
                            (|error| "too many variables"))
                           ('T
                            (SPADCALL |p| (|SPADfirst| |lv|)
                                (QREFELT $ 59)))))))))))) 

(DEFUN |SOLVERAD;radicalSolve;EL;12| (|eq| $)
  (SPADCALL
      (SPADCALL (SPADCALL |eq| (QREFELT $ 72))
          (SPADCALL |eq| (QREFELT $ 73)) (QREFELT $ 74))
      (QREFELT $ 70))) 

(DEFUN |SOLVERAD;radicalSolve;ESL;13| (|eq| |v| $)
  (SPADCALL
      (SPADCALL (SPADCALL |eq| (QREFELT $ 72))
          (SPADCALL |eq| (QREFELT $ 73)) (QREFELT $ 74))
      |v| (QREFELT $ 59))) 

(DEFUN |SOLVERAD;radicalRoots;LLL;14| (|lp| |lv| $)
  (PROG (|parRes| |rlv| #0=#:G1874 #1=#:G1875 #2=#:G1876 #3=#:G1877
            |listGen| #4=#:G1878 #5=#:G1865 #6=#:G1863 #7=#:G1864
            |result| #8=#:G1879 |rpRes| |res| #9=#:G1880 #10=#:G1870
            #11=#:G1868 #12=#:G1869)
    (RETURN
      (SEQ (LETT |parRes| (SPADCALL |lp| |lv| (QREFELT $ 80))
                 . #13=(|SOLVERAD;radicalRoots;LLL;14|))
           (EXIT (COND
                   ((SPADCALL |parRes| (SPADCALL NIL (QREFELT $ 82))
                        (QREFELT $ 83))
                    NIL)
                   ('T
                    (SEQ (LETT |rlv| (REVERSE |lv|) . #13#)
                         (LETT |rpRes|
                               (PROGN
                                 (LETT #0# NIL . #13#)
                                 (SEQ (LETT |res| NIL . #13#)
                                      (LETT #1# |parRes| . #13#) G190
                                      (COND
                                        ((OR (ATOM #1#)
                                          (PROGN
                                            (LETT |res|
                                             (CAR #1#) . #13#)
                                            NIL))
                                         #14=(GO G191)))
                                      (SEQ
                                       (EXIT
                                        (LETT #0#
                                         (CONS (REVERSE |res|) #0#) . #13#)))
                                      (LETT #1# (CDR #1#) . #13#)
                                      #15=(GO G190) G191
                                      (EXIT (NREVERSE0 #0#)))) . #13#)
                         (LETT |listGen|
                               (PROGN
                                 (LETT #2# NIL . #13#)
                                 (SEQ (LETT |res| NIL . #13#)
                                      (LETT #3# |rpRes| . #13#) G190
                                      (COND
                                        ((OR (ATOM #3#)
                                          (PROGN
                                            (LETT |res|
                                             (CAR #3#) . #13#)
                                            NIL))
                                         #14#))
                                      (SEQ
                                       (EXIT
                                        (COND
                                          ((|SOLVERAD;isGeneric?| |res|
                                            |rlv| $)
                                           (LETT #2#
                                            (CONS |res| #2#) . #13#)))))
                                      (LETT #3# (CDR #3#) . #13#) #15#
                                      G191 (EXIT (NREVERSE0 #2#)))) . #13#)
                         (LETT |result| NIL . #13#)
                         (COND
                           ((NULL (SPADCALL |listGen| NIL
                                      (QREFELT $ 83)))
                            (SEQ (LETT |result|
                                       (PROGN
                                         (LETT #7# NIL . #13#)
                                         (SEQ (LETT |res| NIL . #13#)
                                          (LETT #4# |listGen| . #13#)
                                          G190
                                          (COND
                                            ((OR (ATOM #4#)
                                              (PROGN
                                                (LETT |res|
                                                 (CAR #4#) . #13#)
                                                NIL))
                                             #14#))
                                          (SEQ
                                           (EXIT
                                            (PROGN
                                              (LETT #5#
                                               (|SOLVERAD;findGenZeros|
                                                |res| |rlv| $) . #13#)
                                              (COND
                                                (#7#
                                                 (LETT #6#
                                                  (APPEND #6# #5#) . #13#))
                                                ('T
                                                 (PROGN
                                                   (LETT #6#
                                                    #5# . #13#)
                                                   (LETT #7# 'T . #13#)))))))
                                          (LETT #4# (CDR #4#) . #13#)
                                          #15# G191 (EXIT NIL))
                                         (COND (#7# #6#) ('T NIL))) . #13#)
                                 (EXIT (SEQ (LETT |res| NIL . #13#)
                                        (LETT #8# |listGen| . #13#)
                                        G190
                                        (COND
                                          ((OR (ATOM #8#)
                                            (PROGN
                                              (LETT |res|
                                               (CAR #8#) . #13#)
                                              NIL))
                                           #14#))
                                        (SEQ
                                         (EXIT
                                          (LETT |rpRes|
                                           (SPADCALL |rpRes|
                                            (SPADCALL |res| |rpRes|
                                             (QREFELT $ 84))
                                            (QREFELT $ 85)) . #13#)))
                                        (LETT #8# (CDR #8#) . #13#)
                                        #15# G191 (EXIT NIL))))))
                         (EXIT (COND
                                 ((SPADCALL |rpRes| NIL (QREFELT $ 83))
                                  |result|)
                                 ('T
                                  (APPEND (PROGN
                                            (LETT #12# NIL . #13#)
                                            (SEQ
                                             (LETT |res| NIL . #13#)
                                             (LETT #9# |rpRes| . #13#)
                                             G190
                                             (COND
                                               ((OR (ATOM #9#)
                                                 (PROGN
                                                   (LETT |res|
                                                    (CAR #9#) . #13#)
                                                   NIL))
                                                #14#))
                                             (SEQ
                                              (EXIT
                                               (PROGN
                                                 (LETT #10#
                                                  (|SOLVERAD;findZeros|
                                                   |res| |rlv| $) . #13#)
                                                 (COND
                                                   (#12#
                                                    (LETT #11#
                                                     (APPEND #11# #10#) . #13#))
                                                   ('T
                                                    (PROGN
                                                      (LETT #11#
                                                       #10# . #13#)
                                                      (LETT #12#
                                                       'T . #13#)))))))
                                             (LETT #9#
                                              (CDR #9#) . #13#)
                                             #15# G191 (EXIT NIL))
                                            (COND
                                              (#12# #11#)
                                              ('T NIL)))
                                          |result|)))))))))))) 

(DEFUN |SOLVERAD;radicalSolve;LLL;15| (|lp| |lv| $)
  (PROG (#0=#:G1883 |lres| #1=#:G1884)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #2=(|SOLVERAD;radicalSolve;LLL;15|))
             (SEQ (LETT |lres| NIL . #2#)
                  (LETT #1# (SPADCALL |lp| |lv| (QREFELT $ 87)) . #2#)
                  G190
                  (COND
                    ((OR (ATOM #1#)
                         (PROGN (LETT |lres| (CAR #1#) . #2#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (LETT #0#
                                   (CONS
                                    (|SOLVERAD;makeEq| |lres| |lv| $)
                                    #0#) . #2#)))
                  (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                  (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |SOLVERAD;radicalSolve;LL;16| (|lp| $)
  (PROG (|p| #0=#:G1891 #1=#:G1887 #2=#:G1885 #3=#:G1886 |lv|
             #4=#:G1892 |lres| #5=#:G1893)
    (RETURN
      (SEQ (LETT |lv|
                 (PROGN
                   (LETT #3# NIL . #6=(|SOLVERAD;radicalSolve;LL;16|))
                   (SEQ (LETT |p| NIL . #6#) (LETT #0# |lp| . #6#) G190
                        (COND
                          ((OR (ATOM #0#)
                               (PROGN (LETT |p| (CAR #0#) . #6#) NIL))
                           #7=(GO G191)))
                        (SEQ (EXIT (PROGN
                                     (LETT #1#
                                      (SPADCALL
                                       (SPADCALL
                                        (SPADCALL |p| (QREFELT $ 61))
                                        (QREFELT $ 63))
                                       (SPADCALL
                                        (SPADCALL |p| (QREFELT $ 64))
                                        (QREFELT $ 63))
                                       (QREFELT $ 90)) . #6#)
                                     (COND
                                       (#3#
                                        (LETT #2#
                                         (SPADCALL #2# #1#
                                          (QREFELT $ 90)) . #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#) ('T (|IdentityError| '|setUnion|)))) . #6#)
           (EXIT (PROGN
                   (LETT #4# NIL . #6#)
                   (SEQ (LETT |lres| NIL . #6#)
                        (LETT #5#
                              (SPADCALL |lp| |lv| (QREFELT $ 87)) . #6#)
                        G190
                        (COND
                          ((OR (ATOM #5#)
                               (PROGN
                                 (LETT |lres| (CAR #5#) . #6#)
                                 NIL))
                           #7#))
                        (SEQ (EXIT (LETT #4#
                                    (CONS
                                     (|SOLVERAD;makeEq| |lres| |lv| $)
                                     #4#) . #6#)))
                        (LETT #5# (CDR #5#) . #6#) #8# G191
                        (EXIT (NREVERSE0 #4#))))))))) 

(DEFUN |SOLVERAD;radicalSolve;LLL;17| (|le| |lv| $)
  (PROG (#0=#:G1898 |p| #1=#:G1899 |lp| #2=#:G1900 |lres| #3=#:G1901)
    (RETURN
      (SEQ (LETT |lp|
                 (PROGN
                   (LETT #0# NIL . #4=(|SOLVERAD;radicalSolve;LLL;17|))
                   (SEQ (LETT |p| NIL . #4#) (LETT #1# |le| . #4#) G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN (LETT |p| (CAR #1#) . #4#) NIL))
                           #5=(GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS
                                     (SPADCALL
                                      (SPADCALL |p| (QREFELT $ 73))
                                      (SPADCALL |p| (QREFELT $ 72))
                                      (QREFELT $ 74))
                                     #0#) . #4#)))
                        (LETT #1# (CDR #1#) . #4#) #6=(GO G190) G191
                        (EXIT (NREVERSE0 #0#)))) . #4#)
           (EXIT (PROGN
                   (LETT #2# NIL . #4#)
                   (SEQ (LETT |lres| NIL . #4#)
                        (LETT #3#
                              (SPADCALL |lp| |lv| (QREFELT $ 87)) . #4#)
                        G190
                        (COND
                          ((OR (ATOM #3#)
                               (PROGN
                                 (LETT |lres| (CAR #3#) . #4#)
                                 NIL))
                           #5#))
                        (SEQ (EXIT (LETT #2#
                                    (CONS
                                     (|SOLVERAD;makeEq| |lres| |lv| $)
                                     #2#) . #4#)))
                        (LETT #3# (CDR #3#) . #4#) #6# G191
                        (EXIT (NREVERSE0 #2#))))))))) 

(DEFUN |SOLVERAD;radicalSolve;LL;18| (|le| $)
  (PROG (#0=#:G1909 #1=#:G1910 |lp| |p| #2=#:G1911 #3=#:G1905
            #4=#:G1903 #5=#:G1904 |lv| #6=#:G1912 |lres| #7=#:G1913)
    (RETURN
      (SEQ (LETT |lp|
                 (PROGN
                   (LETT #0# NIL . #8=(|SOLVERAD;radicalSolve;LL;18|))
                   (SEQ (LETT |p| NIL . #8#) (LETT #1# |le| . #8#) G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN (LETT |p| (CAR #1#) . #8#) NIL))
                           #9=(GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS
                                     (SPADCALL
                                      (SPADCALL |p| (QREFELT $ 73))
                                      (SPADCALL |p| (QREFELT $ 72))
                                      (QREFELT $ 74))
                                     #0#) . #8#)))
                        (LETT #1# (CDR #1#) . #8#) #10=(GO G190) G191
                        (EXIT (NREVERSE0 #0#)))) . #8#)
           (LETT |lv|
                 (PROGN
                   (LETT #5# NIL . #8#)
                   (SEQ (LETT |p| NIL . #8#) (LETT #2# |lp| . #8#) G190
                        (COND
                          ((OR (ATOM #2#)
                               (PROGN (LETT |p| (CAR #2#) . #8#) NIL))
                           #9#))
                        (SEQ (EXIT (PROGN
                                     (LETT #3#
                                      (SPADCALL
                                       (SPADCALL
                                        (SPADCALL |p| (QREFELT $ 61))
                                        (QREFELT $ 63))
                                       (SPADCALL
                                        (SPADCALL |p| (QREFELT $ 64))
                                        (QREFELT $ 63))
                                       (QREFELT $ 90)) . #8#)
                                     (COND
                                       (#5#
                                        (LETT #4#
                                         (SPADCALL #4# #3#
                                          (QREFELT $ 90)) . #8#))
                                       ('T
                                        (PROGN
                                          (LETT #4# #3# . #8#)
                                          (LETT #5# 'T . #8#)))))))
                        (LETT #2# (CDR #2#) . #8#) #10# G191
                        (EXIT NIL))
                   (COND (#5# #4#) ('T (|IdentityError| '|setUnion|)))) . #8#)
           (EXIT (PROGN
                   (LETT #6# NIL . #8#)
                   (SEQ (LETT |lres| NIL . #8#)
                        (LETT #7#
                              (SPADCALL |lp| |lv| (QREFELT $ 87)) . #8#)
                        G190
                        (COND
                          ((OR (ATOM #7#)
                               (PROGN
                                 (LETT |lres| (CAR #7#) . #8#)
                                 NIL))
                           #9#))
                        (SEQ (EXIT (LETT #6#
                                    (CONS
                                     (|SOLVERAD;makeEq| |lres| |lv| $)
                                     #6#) . #8#)))
                        (LETT #7# (CDR #7#) . #8#) #10# G191
                        (EXIT (NREVERSE0 #6#))))))))) 

(DEFUN |SOLVERAD;contractSolve;ESSt;19| (|eq| |v| $)
  (|SOLVERAD;solveInner|
      (SPADCALL
          (SPADCALL (SPADCALL |eq| (QREFELT $ 72))
              (SPADCALL |eq| (QREFELT $ 73)) (QREFELT $ 74))
          (QREFELT $ 61))
      |v| 'T $)) 

(DEFUN |SOLVERAD;contractSolve;FSSt;20| (|pq| |v| $)
  (|SOLVERAD;solveInner| (SPADCALL |pq| (QREFELT $ 61)) |v| 'T $)) 

(DEFUN |SOLVERAD;radicalRoots;FSL;21| (|pq| |v| $)
  (SPADCALL
      (|SOLVERAD;solveInner| (SPADCALL |pq| (QREFELT $ 61)) |v| 'NIL $)
      (QREFELT $ 98))) 

(DEFUN |SOLVERAD;isGeneric?| (|rlp| |rlv| $)
  (PROG (|x| #0=#:G1922 |f| #1=#:G1921 #2=#:G1919 #3=#:G1917
             #4=#:G1918)
    (RETURN
      (SEQ (PROGN
             (LETT #4# NIL . #5=(|SOLVERAD;isGeneric?|))
             (SEQ (LETT |x| NIL . #5#) (LETT #0# (CDR |rlv|) . #5#)
                  (LETT |f| NIL . #5#) (LETT #1# (CDR |rlp|) . #5#)
                  G190
                  (COND
                    ((OR (ATOM #1#)
                         (PROGN (LETT |f| (CAR #1#) . #5#) NIL)
                         (ATOM #0#)
                         (PROGN (LETT |x| (CAR #0#) . #5#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (PROGN
                               (LETT #2#
                                     (EQL
                                      (SPADCALL |f| |x| (QREFELT $ 99))
                                      1) . #5#)
                               (COND
                                 (#4# (LETT #3#
                                       (COND (#3# #2#) ('T 'NIL)) . #5#))
                                 ('T
                                  (PROGN
                                    (LETT #3# #2# . #5#)
                                    (LETT #4# 'T . #5#)))))))
                  (LETT #1#
                        (PROG1 (CDR #1#) (LETT #0# (CDR #0#) . #5#)) . #5#)
                  (GO G190) G191 (EXIT NIL))
             (COND (#4# #3#) ('T 'T))))))) 

(DEFUN |SOLVERAD;select| (|lp| $)
  (PROG (|f| #0=#:G1928 #1=#:G1929 |lsel| #2=#:G1930 #3=#:G1925
             #4=#:G1923 #5=#:G1924)
    (RETURN
      (SEQ (COND
             ((SPADCALL |lp| NIL (QREFELT $ 100))
              (SPADCALL NIL (QREFELT $ 101)))
             (#6='T
              (PROGN
                (LETT #5# NIL . #7=(|SOLVERAD;select|))
                (SEQ (LETT |f| NIL . #7#)
                     (LETT #0# (|SPADfirst| |lp|) . #7#) G190
                     (COND
                       ((OR (ATOM #0#)
                            (PROGN (LETT |f| (CAR #0#) . #7#) NIL))
                        #8=(GO G191)))
                     (SEQ (EXIT (PROGN
                                  (LETT #3#
                                        (PROGN
                                          (LETT #1# NIL . #7#)
                                          (SEQ (LETT |lsel| NIL . #7#)
                                           (LETT #2#
                                            (|SOLVERAD;select|
                                             (CDR |lp|) $) . #7#)
                                           G190
                                           (COND
                                             ((OR (ATOM #2#)
                                               (PROGN
                                                 (LETT |lsel|
                                                  (CAR #2#) . #7#)
                                                 NIL))
                                              #8#))
                                           (SEQ
                                            (EXIT
                                             (LETT #1#
                                              (CONS (CONS |f| |lsel|)
                                               #1#) . #7#)))
                                           (LETT #2# (CDR #2#) . #7#)
                                           #9=(GO G190) G191
                                           (EXIT (NREVERSE0 #1#)))) . #7#)
                                  (COND
                                    (#5#
                                     (LETT #4# (APPEND #4# #3#) . #7#))
                                    ('T
                                     (PROGN
                                       (LETT #4# #3# . #7#)
                                       (LETT #5# 'T . #7#)))))))
                     (LETT #0# (CDR #0#) . #7#) #9# G191 (EXIT NIL))
                (COND (#5# #4#) (#6# NIL))))))))) 

(DEFUN |SOLVERAD;makeEq| (|nres| |lv| $)
  (PROG (#0=#:G1933 |r| #1=#:G1935 |x| #2=#:G1934)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #3=(|SOLVERAD;makeEq|))
             (SEQ (LETT |r| NIL . #3#) (LETT #1# |nres| . #3#)
                  (LETT |x| NIL . #3#) (LETT #2# |lv| . #3#) G190
                  (COND
                    ((OR (ATOM #2#)
                         (PROGN (LETT |x| (CAR #2#) . #3#) NIL)
                         (ATOM #1#)
                         (PROGN (LETT |r| (CAR #1#) . #3#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (LETT #0#
                                   (CONS
                                    (SPADCALL
                                     (SPADCALL |x| (QREFELT $ 56)) |r|
                                     (QREFELT $ 57))
                                    #0#) . #3#)))
                  (LETT #2#
                        (PROG1 (CDR #2#) (LETT #1# (CDR #1#) . #3#)) . #3#)
                  (GO G190) G191 (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |SOLVERAD;solveInner| (|pq| |v| |contractFlag| $)
  (PROG (|factors| |f| #0=#:G1951 |ff| |constants| |t| |u| |n|
            |unsolved| |l| #1=#:G1952 |s| T0 |i| #2=#:G1953 |solutions|
            |re|)
    (RETURN
      (SEQ (SETELT $ 7 NIL) (SETELT $ 8 |contractFlag|)
           (LETT |factors|
                 (SPADCALL (SPADCALL |pq| (QREFELT $ 104))
                     (QREFELT $ 107))
                 . #3=(|SOLVERAD;solveInner|))
           (LETT |constants| NIL . #3#) (LETT |unsolved| NIL . #3#)
           (LETT |solutions| NIL . #3#)
           (SEQ (LETT |f| NIL . #3#) (LETT #0# |factors| . #3#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |f| (CAR #0#) . #3#) NIL))
                   #4=(GO G191)))
                (SEQ (LETT |ff| (QCAR |f|) . #3#)
                     (COND
                       ((NULL (SPADCALL |v|
                                  (SPADCALL |ff| (QREFELT $ 63))
                                  (QREFELT $ 108)))
                        (EXIT (LETT |constants|
                                    (CONS |ff| |constants|) . #3#))))
                     (LETT |u|
                           (SPADCALL |ff| |v| (QREFELT $ 45)) . #3#)
                     (LETT |t| (SPADCALL |u| (QREFELT $ 111)) . #3#)
                     (LETT |u| (QCAR |t|) . #3#)
                     (LETT |n| (SPADCALL |u| (QREFELT $ 112)) . #3#)
                     (LETT |l|
                           (COND
                             ((EQL |n| 1) (|SOLVERAD;linear| |u| $))
                             ((EQL |n| 2) (|SOLVERAD;quadratic| |u| $))
                             ((EQL |n| 3) (|SOLVERAD;cubic| |u| $))
                             ((EQL |n| 4) (|SOLVERAD;quartic| |u| $))
                             ('T
                              (SEQ (LETT |unsolved|
                                    (CONS |ff| |unsolved|) . #3#)
                                   (EXIT NIL)))) . #3#)
                     (EXIT (SEQ (LETT |s| NIL . #3#)
                                (LETT #1# |l| . #3#) G190
                                (COND
                                  ((OR (ATOM #1#)
                                    (PROGN
                                      (LETT |s| (CAR #1#) . #3#)
                                      NIL))
                                   #4#))
                                (SEQ (COND
                                       ((< 1 (QCDR |t|))
                                        (LETT |s|
                                         (|SOLVERAD;wrap| |s| $) . #3#)))
                                     (LETT T0
                                      (SPADCALL |s| (QCDR |t|)
                                       (QREFELT $ 116)) . #3#)
                                     (SEQ (LETT |i| 1 . #3#)
                                      (LETT #2# (QCDR |f|) . #3#) G190
                                      (COND
                                        ((QSGREATERP |i| #2#) #4#))
                                      (SEQ
                                       (EXIT
                                        (LETT |solutions|
                                         (APPEND T0 |solutions|) . #3#)))
                                      (LETT |i| (QSADD1 |i|) . #3#)
                                      #5=(GO G190) G191 (EXIT NIL))
                                     (EXIT
                                      (LETT |re| (QREFELT $ 7) . #3#)))
                                (LETT #1# (CDR #1#) . #3#) #5# G191
                                (EXIT NIL))))
                (LETT #0# (CDR #0#) . #3#) #5# G191 (EXIT NIL))
           (EXIT (SPADCALL |solutions| (QREFELT $ 7) (QREFELT $ 117))))))) 

(DEFUN |RadicalSolvePackage| (#0=#:G1954)
  (PROG ()
    (RETURN
      (PROG (#1=#:G1955)
        (RETURN
          (COND
            ((LETT #1#
                   (|lassocShiftWithFunction| (LIST (|devaluate| #0#))
                       (HGET |$ConstructorCache|
                             '|RadicalSolvePackage|)
                       '|domainEqualList|)
                   . #2=(|RadicalSolvePackage|))
             (|CDRwithIncrement| #1#))
            ('T
             (UNWIND-PROTECT
               (PROG1 (|RadicalSolvePackage;| #0#) (LETT #1# T . #2#))
               (COND
                 ((NOT #1#)
                  (HREM |$ConstructorCache| '|RadicalSolvePackage|))))))))))) 

(DEFUN |RadicalSolvePackage;| (|#1|)
  (PROG (DV$1 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|) . #0=(|RadicalSolvePackage|))
        (LETT |dv$| (LIST '|RadicalSolvePackage| DV$1) . #0#)
        (LETT $ (GETREFV 118) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|haddProp| |$ConstructorCache| '|RadicalSolvePackage|
            (LIST DV$1) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7 NIL)
        (QSETREFV $ 8 'NIL)
        $)))) 

(MAKEPROP '|RadicalSolvePackage| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) '|SideEquations|
             '|ContractSoln| (0 . |Zero|) (|Equation| 12) (4 . |Zero|)
             (|Expression| 6) (8 . |Zero|) (|Boolean|) (12 . =)
             (|Symbol|) (18 . |new|) (|Polynomial| 6) (22 . |coerce|)
             (|Fraction| 18) (27 . |coerce|) (32 . |coerce|) (37 . =)
             (|NonNegativeInteger|) (|SparseUnivariatePolynomial| 18)
             (43 . |coefficient|) (49 . -) (54 . |coerce|) (59 . |One|)
             (63 . |One|) (67 . /) (|SparseUnivariatePolynomial| 12)
             (|Mapping| 12 18)
             (|SparseUnivariatePolynomialFunctions2| 18 12)
             (73 . |map|) (|List| 12)
             (|PolynomialSolveByFormulas| 32 12) (79 . |quadratic|)
             (84 . |cubic|) (89 . |quartic|) (|Integer|)
             (94 . |coerce|) |SOLVERAD;radicalRoots;FSL;21|
             (|SparseUnivariatePolynomial| $) (99 . |univariate|)
             (105 . -) (110 . |leadingCoefficient|) (|Kernel| 12)
             (115 . |kernel|) (|Kernel| $) (120 . |eval|) (127 . =)
             (|List| 50) (|List| $) (133 . |eval|) (140 . |coerce|)
             (145 . |equation|) (|List| 10)
             |SOLVERAD;radicalSolve;FSL;10| (151 . |zero?|)
             (156 . |numer|) (|List| 16) (161 . |variables|)
             (166 . |denom|) (171 . |concat|)
             (177 . |removeDuplicates|) (182 . |One|) (186 . |One|)
             (190 . |One|) |SOLVERAD;radicalSolve;FL;11|
             (|Equation| 20) (194 . |lhs|) (199 . |rhs|) (204 . -)
             |SOLVERAD;radicalSolve;EL;12|
             |SOLVERAD;radicalSolve;ESL;13| (|List| 81) (|List| 20)
             (|SystemSolvePackage| 6) (210 . |triangularSystems|)
             (|List| 18) (216 . |list|) (221 . =) (227 . |position|)
             (233 . |delete|) (|List| 36)
             |SOLVERAD;radicalRoots;LLL;14| (|List| 58)
             |SOLVERAD;radicalSolve;LLL;15| (239 . |setUnion|)
             |SOLVERAD;radicalSolve;LL;16| (|List| 71)
             |SOLVERAD;radicalSolve;LLL;17|
             |SOLVERAD;radicalSolve;LL;18| (|SuchThat| 36 58)
             |SOLVERAD;contractSolve;ESSt;19|
             |SOLVERAD;contractSolve;FSSt;20| (245 . |lhs|)
             (250 . |degree|) (256 . =) (262 . |list|) (|Factored| 18)
             (|MultivariateFactorize| 16 (|IndexedExponents| 16) 6 18)
             (267 . |factor|)
             (|Record| (|:| |factor| 18) (|:| |exponent| 41))
             (|List| 105) (272 . |factors|) (277 . |member?|)
             (|Record| (|:| |pol| 25) (|:| |deg| 115))
             (|DegreeReductionPackage| 18 6) (283 . |reduce|)
             (288 . |degree|) (293 . |One|) (297 . |One|)
             (|PositiveInteger|) (301 . |expand|) (307 . |construct|))
          '#(|radicalSolve| 313 |radicalRoots| 357 |contractSolve| 369)
          'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 117
                                '(0 6 0 9 0 10 0 11 0 12 0 13 2 12 14 0
                                  0 15 0 16 0 17 1 18 0 16 19 1 20 0 18
                                  21 1 12 0 20 22 2 10 0 12 12 23 2 25
                                  18 0 24 26 1 18 0 0 27 1 12 0 18 28 0
                                  6 0 29 0 10 0 30 2 12 0 0 0 31 2 34
                                  32 33 25 35 1 37 36 32 38 1 37 36 32
                                  39 1 37 36 32 40 1 12 0 41 42 2 18 44
                                  0 16 45 1 12 0 0 46 1 25 18 0 47 1 48
                                  0 16 49 3 12 0 0 50 0 51 2 36 14 0 0
                                  52 3 12 0 0 53 54 55 1 12 0 16 56 2
                                  10 0 12 12 57 1 20 14 0 60 1 20 18 0
                                  61 1 18 62 0 63 1 20 18 0 64 2 62 0 0
                                  0 65 1 62 0 0 66 0 12 0 67 0 20 0 68
                                  0 18 0 69 1 71 20 0 72 1 71 20 0 73 2
                                  20 0 0 0 74 2 79 77 78 62 80 1 77 0
                                  81 82 2 77 14 0 0 83 2 77 41 81 0 84
                                  2 77 0 0 41 85 2 62 0 0 0 90 1 95 36
                                  0 98 2 18 24 0 16 99 2 86 14 0 0 100
                                  1 86 0 36 101 1 103 102 18 104 1 102
                                  106 0 107 2 62 14 16 0 108 1 110 109
                                  25 111 1 25 24 0 112 0 102 0 113 0 25
                                  0 114 2 110 36 12 115 116 2 95 0 36
                                  58 117 2 0 58 20 16 59 2 0 58 71 16
                                  76 1 0 58 20 70 1 0 58 71 75 1 0 88
                                  78 91 2 0 88 78 62 89 2 0 88 92 62 93
                                  1 0 88 92 94 2 0 36 20 16 43 2 0 86
                                  78 62 87 2 0 95 20 16 97 2 0 95 71 16
                                  96)))))
          '|lookupComplete|)) 
