
(/VERSIONCHECK 2) 

(DEFUN |RETSOL;PQ2P| (|p| $)
  (SPADCALL (CONS #'|RETSOL;PQ2P!0| $) |p| (QREFELT $ 13))) 

(DEFUN |RETSOL;PQ2P!0| (|#1| $) (SPADCALL |#1| (QREFELT $ 8))) 

(DEFUN |RETSOL;FQ2F| (|f| $)
  (SPADCALL (|RETSOL;PQ2P| (SPADCALL |f| (QREFELT $ 15)) $)
      (|RETSOL;PQ2P| (SPADCALL |f| (QREFELT $ 16)) $) (QREFELT $ 18))) 

(DEFUN |RETSOL;LEQQ2F| (|l| $)
  (PROG (#0=#:G1821 |eq| #1=#:G1822)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #2=(|RETSOL;LEQQ2F|))
             (SEQ (LETT |eq| NIL . #2#) (LETT #1# |l| . #2#) G190
                  (COND
                    ((OR (ATOM #1#)
                         (PROGN (LETT |eq| (CAR #1#) . #2#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (LETT #0#
                                   (CONS
                                    (SPADCALL
                                     (|RETSOL;FQ2F|
                                      (SPADCALL |eq| (QREFELT $ 20)) $)
                                     (|RETSOL;FQ2F|
                                      (SPADCALL |eq| (QREFELT $ 21)) $)
                                     (QREFELT $ 23))
                                    #0#) . #2#)))
                  (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                  (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |RETSOL;solveRetract;LLL;4| (|lp| |lv| $)
  (PROG (|u| #0=#:G1830 |p| #1=#:G1831 #2=#:G1832 |l| #3=#:G1833)
    (RETURN
      (SEQ (LETT |u| (|RETSOL;QIfCan| |lp| $)
                 . #4=(|RETSOL;solveRetract;LLL;4|))
           (EXIT (COND
                   ((QEQCAR |u| 1)
                    (SPADCALL
                        (PROGN
                          (LETT #0# NIL . #4#)
                          (SEQ (LETT |p| NIL . #4#)
                               (LETT #1# |lp| . #4#) G190
                               (COND
                                 ((OR (ATOM #1#)
                                      (PROGN
                                        (LETT |p| (CAR #1#) . #4#)
                                        NIL))
                                  #5=(GO G191)))
                               (SEQ (EXIT
                                     (LETT #0#
                                      (CONS
                                       (SPADCALL |p| (QREFELT $ 24))
                                       #0#) . #4#)))
                               (LETT #1# (CDR #1#) . #4#) #6=(GO G190)
                               G191 (EXIT (NREVERSE0 #0#))))
                        |lv| (QREFELT $ 29)))
                   ('T
                    (PROGN
                      (LETT #2# NIL . #4#)
                      (SEQ (LETT |l| NIL . #4#)
                           (LETT #3#
                                 (SPADCALL (QCDR |u|) |lv|
                                     (QREFELT $ 33)) . #4#)
                           G190
                           (COND
                             ((OR (ATOM #3#)
                                  (PROGN
                                    (LETT |l| (CAR #3#) . #4#)
                                    NIL))
                              #5#))
                           (SEQ (EXIT (LETT #2#
                                       (CONS (|RETSOL;LEQQ2F| |l| $)
                                        #2#) . #4#)))
                           (LETT #3# (CDR #3#) . #4#) #6# G191
                           (EXIT (NREVERSE0 #2#))))))))))) 

(DEFUN |RETSOL;QIfCan| (|l| $)
  (PROG (|p| #0=#:G1844 |u| #1=#:G1843 |ans|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |ans| NIL . #2=(|RETSOL;QIfCan|))
                      (SEQ (LETT |p| NIL . #2#) (LETT #0# |l| . #2#)
                           G190
                           (COND
                             ((OR (ATOM #0#)
                                  (PROGN
                                    (LETT |p| (CAR #0#) . #2#)
                                    NIL))
                              (GO G191)))
                           (SEQ (LETT |u|
                                      (|RETSOL;PQIfCan| |p| $) . #2#)
                                (EXIT (COND
                                        ((QEQCAR |u| 1)
                                         (PROGN
                                           (LETT #1#
                                            (CONS 1 "failed") . #2#)
                                           (GO #1#)))
                                        ('T
                                         (LETT |ans|
                                          (CONS (QCDR |u|) |ans|) . #2#)))))
                           (LETT #0# (CDR #0#) . #2#) (GO G190) G191
                           (EXIT NIL))
                      (EXIT (CONS 0 |ans|))))
           #1# (EXIT #1#))))) 

(DEFUN |RETSOL;PQIfCan| (|p| $)
  (PROG (|u| |r| |s| |v| #0=#:G1866 |ans| |up|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |u| (SPADCALL |p| (QREFELT $ 37))
                            . #1=(|RETSOL;PQIfCan|))
                      (EXIT (COND
                              ((QEQCAR |u| 1)
                               (SEQ (LETT |r|
                                     (SPADCALL
                                      (SPADCALL |p| (QREFELT $ 38))
                                      (QREFELT $ 40)) . #1#)
                                    (EXIT
                                     (COND
                                       ((QEQCAR |r| 0)
                                        (CONS 0
                                         (SPADCALL
                                          (SPADCALL (QCDR |r|)
                                           (QREFELT $ 41))
                                          (QREFELT $ 42))))
                                       (#2='T (CONS 1 "failed"))))))
                              (#2#
                               (SEQ (LETT |up|
                                     (SPADCALL |p|
                                      (LETT |s| (QCDR |u|) . #1#)
                                      (QREFELT $ 45)) . #1#)
                                    (LETT |ans|
                                     (|spadConstant| $ 46) . #1#)
                                    (SEQ G190
                                     (COND
                                       ((NULL
                                         (COND
                                           ((SPADCALL |up|
                                             (|spadConstant| $ 50)
                                             (QREFELT $ 52))
                                            'NIL)
                                           ('T 'T)))
                                        (GO G191)))
                                     (SEQ
                                      (LETT |v|
                                       (|RETSOL;PQIfCan|
                                        (SPADCALL |up| (QREFELT $ 53))
                                        $) . #1#)
                                      (EXIT
                                       (COND
                                         ((QEQCAR |v| 1)
                                          (PROGN
                                            (LETT #0#
                                             (CONS 1 "failed") . #1#)
                                            (GO #0#)))
                                         ('T
                                          (SEQ
                                           (LETT |ans|
                                            (SPADCALL |ans|
                                             (SPADCALL
                                              (SPADCALL
                                               (|spadConstant| $ 58)
                                               |s|
                                               (SPADCALL |up|
                                                (QREFELT $ 57))
                                               (QREFELT $ 59))
                                              (QCDR |v|)
                                              (QREFELT $ 60))
                                             (QREFELT $ 61)) . #1#)
                                           (EXIT
                                            (LETT |up|
                                             (SPADCALL |up|
                                              (QREFELT $ 62)) . #1#)))))))
                                     NIL (GO G190) G191 (EXIT NIL))
                                    (EXIT (CONS 0 |ans|))))))))
           #0# (EXIT #0#))))) 

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

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

(MAKEPROP '|RetractSolvePackage| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (0 . |coerce|) (|Polynomial| 7) (|Mapping| 7 6)
             (|Polynomial| 6) (|PolynomialFunctions2| 6 7) (5 . |map|)
             (|Fraction| 11) (11 . |numer|) (16 . |denom|)
             (|Fraction| 9) (21 . /) (|Equation| 14) (27 . |lhs|)
             (32 . |rhs|) (|Equation| 17) (37 . |equation|)
             (43 . |coerce|) (|List| (|List| 22)) (|List| 17)
             (|List| 44) (|SystemSolvePackage| 7) (48 . |solve|)
             (|List| (|List| 19)) (|List| 14) (|SystemSolvePackage| 6)
             (54 . |solve|) (|List| 9) |RETSOL;solveRetract;LLL;4|
             (|Union| 44 '"failed") (60 . |mainVariable|)
             (65 . |ground|) (|Union| 6 '"failed")
             (70 . |retractIfCan|) (75 . |coerce|) (80 . |coerce|)
             (|SparseUnivariatePolynomial| $) (|Symbol|)
             (85 . |univariate|) (91 . |Zero|) (95 . |Zero|)
             (99 . |Zero|) (|SparseUnivariatePolynomial| 9)
             (103 . |Zero|) (|Boolean|) (107 . =)
             (113 . |leadingCoefficient|) (118 . |One|) (122 . |One|)
             (|NonNegativeInteger|) (126 . |degree|) (131 . |One|)
             (135 . |monomial|) (142 . *) (148 . +) (154 . |reductum|))
          '#(|solveRetract| 159) 'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 62
                                '(1 7 0 6 8 2 12 9 10 11 13 1 14 11 0
                                  15 1 14 11 0 16 2 17 0 9 9 18 1 19 14
                                  0 20 1 19 14 0 21 2 22 0 17 17 23 1
                                  17 0 9 24 2 28 25 26 27 29 2 32 30 31
                                  27 33 1 9 36 0 37 1 9 7 0 38 1 7 39 0
                                  40 1 11 0 6 41 1 14 0 11 42 2 9 43 0
                                  44 45 0 14 0 46 0 6 0 47 0 7 0 48 0
                                  49 0 50 2 49 51 0 0 52 1 49 9 0 53 0
                                  6 0 54 0 7 0 55 1 49 56 0 57 0 11 0
                                  58 3 11 0 0 44 56 59 2 14 0 11 0 60 2
                                  14 0 0 0 61 1 49 0 0 62 2 0 25 34 27
                                  35)))))
          '|lookupComplete|)) 
