
(/VERSIONCHECK 2) 

(DEFUN |NLINSOL;solveInField;LL;1| (|l| $)
  (PROG (|p| #0=#:G1825 #1=#:G1823 #2=#:G1821 #3=#:G1822)
    (RETURN
      (SEQ (SPADCALL |l|
               (PROGN
                 (LETT #3# NIL . #4=(|NLINSOL;solveInField;LL;1|))
                 (SEQ (LETT |p| NIL . #4#) (LETT #0# |l| . #4#) G190
                      (COND
                        ((OR (ATOM #0#)
                             (PROGN (LETT |p| (CAR #0#) . #4#) NIL))
                         (GO G191)))
                      (SEQ (EXIT (PROGN
                                   (LETT #1#
                                    (SPADCALL |p| (QREFELT $ 9)) . #4#)
                                   (COND
                                     (#3#
                                      (LETT #2#
                                       (SPADCALL #2# #1#
                                        (QREFELT $ 10)) . #4#))
                                     ('T
                                      (PROGN
                                        (LETT #2# #1# . #4#)
                                        (LETT #3# 'T . #4#)))))))
                      (LETT #0# (CDR #0#) . #4#) (GO G190) G191
                      (EXIT NIL))
                 (COND (#3# #2#) ('T (|IdentityError| '|setUnion|))))
               (QREFELT $ 13)))))) 

(DEFUN |NLINSOL;solve;LL;2| (|l| $)
  (PROG (|p| #0=#:G1830 #1=#:G1828 #2=#:G1826 #3=#:G1827)
    (RETURN
      (SEQ (SPADCALL |l|
               (PROGN
                 (LETT #3# NIL . #4=(|NLINSOL;solve;LL;2|))
                 (SEQ (LETT |p| NIL . #4#) (LETT #0# |l| . #4#) G190
                      (COND
                        ((OR (ATOM #0#)
                             (PROGN (LETT |p| (CAR #0#) . #4#) NIL))
                         (GO G191)))
                      (SEQ (EXIT (PROGN
                                   (LETT #1#
                                    (SPADCALL |p| (QREFELT $ 9)) . #4#)
                                   (COND
                                     (#3#
                                      (LETT #2#
                                       (SPADCALL #2# #1#
                                        (QREFELT $ 10)) . #4#))
                                     ('T
                                      (PROGN
                                        (LETT #2# #1# . #4#)
                                        (LETT #3# 'T . #4#)))))))
                      (LETT #0# (CDR #0#) . #4#) (GO G190) G191
                      (EXIT NIL))
                 (COND (#3# #2#) ('T (|IdentityError| '|setUnion|))))
               (QREFELT $ 15)))))) 

(DEFUN |NLINSOL;solve;LLL;3| (|lp| |lv| $)
  (PROG (#0=#:G1833 |sol| #1=#:G1834)
    (RETURN
      (SEQ (SPADCALL (PROGN
                       (LETT #0# NIL . #2=(|NLINSOL;solve;LLL;3|))
                       (SEQ (LETT |sol| NIL . #2#)
                            (LETT #1#
                                  (SPADCALL |lp| |lv| (QREFELT $ 13)) . #2#)
                            G190
                            (COND
                              ((OR (ATOM #1#)
                                   (PROGN
                                     (LETT |sol| (CAR #1#) . #2#)
                                     NIL))
                               (GO G191)))
                            (SEQ (EXIT (LETT #0#
                                        (CONS
                                         (|NLINSOL;expandSol| |sol| $)
                                         #0#) . #2#)))
                            (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                            (EXIT (NREVERSE0 #0#))))
                     (QREFELT $ 18)))))) 

(DEFUN |NLINSOL;addRoot| (|eq| |l| $)
  (PROG (#0=#:G1837 |sol| #1=#:G1838)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #2=(|NLINSOL;addRoot|))
             (SEQ (LETT |sol| NIL . #2#) (LETT #1# |l| . #2#) G190
                  (COND
                    ((OR (ATOM #1#)
                         (PROGN (LETT |sol| (CAR #1#) . #2#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (LETT #0#
                                   (CONS (CONS |eq| |sol|) #0#) . #2#)))
                  (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                  (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |NLINSOL;evalSol| (|ls| |l| $)
  (PROG (#0=#:G1841 |eq| #1=#:G1842)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #2=(|NLINSOL;evalSol|))
             (SEQ (LETT |eq| NIL . #2#) (LETT #1# |ls| . #2#) G190
                  (COND
                    ((OR (ATOM #1#)
                         (PROGN (LETT |eq| (CAR #1#) . #2#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (LETT #0#
                                   (CONS
                                    (SPADCALL
                                     (SPADCALL |eq| (QREFELT $ 21))
                                     (SPADCALL
                                      (SPADCALL |eq| (QREFELT $ 22))
                                      |l| (QREFELT $ 25))
                                     (QREFELT $ 26))
                                    #0#) . #2#)))
                  (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                  (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |NLINSOL;allRoots| (|l| $)
  (PROG (|z| |p| #0=#:G1847 |s| #1=#:G1853 |a| #2=#:G1854)
    (RETURN
      (SEQ (COND
             ((NULL |l|) (LIST NIL))
             ('T
              (SEQ (LETT |z| (|NLINSOL;allRoots| (CDR |l|) $)
                         . #3=(|NLINSOL;allRoots|))
                   (LETT |s|
                         (SPADCALL
                             (SPADCALL
                                 (PROG2 (LETT #0#
                                         (SPADCALL
                                          (LETT |p|
                                           (|SPADfirst| |l|) . #3#)
                                          (QREFELT $ 28)) . #3#)
                                        (QCDR #0#)
                                   (|check-union| (QEQCAR #0# 0)
                                    (|Symbol|) #0#))
                                 (QREFELT $ 30))
                             (QREFELT $ 31)) . #3#)
                   (EXIT (SPADCALL
                             (PROGN
                               (LETT #1# NIL . #3#)
                               (SEQ (LETT |a| NIL . #3#)
                                    (LETT #2#
                                     (SPADCALL
                                      (SPADCALL |p| (QREFELT $ 33))
                                      (QREFELT $ 35)) . #3#)
                                    G190
                                    (COND
                                      ((OR (ATOM #2#)
                                        (PROGN
                                          (LETT |a| (CAR #2#) . #3#)
                                          NIL))
                                       (GO G191)))
                                    (SEQ
                                     (EXIT
                                      (LETT #1#
                                       (CONS
                                        (|NLINSOL;addRoot|
                                         (SPADCALL |s|
                                          (SPADCALL
                                           (SPADCALL |a|
                                            (QREFELT $ 36))
                                           (QREFELT $ 31))
                                          (QREFELT $ 26))
                                         |z| $)
                                        #1#) . #3#)))
                                    (LETT #2# (CDR #2#) . #3#)
                                    (GO G190) G191
                                    (EXIT (NREVERSE0 #1#))))
                             (QREFELT $ 18)))))))))) 

(DEFUN |NLINSOL;expandSol| (|l| $)
  (PROG (|eq| #0=#:G1876 |lassign| |lsubs| |u| |r| |luniv| #1=#:G1875
              #2=#:G1877 |z| #3=#:G1878)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |lassign|
                            (LETT |lsubs| NIL
                                  . #4=(|NLINSOL;expandSol|)) . #4#)
                      (LETT |luniv| NIL . #4#)
                      (SEQ (LETT |eq| NIL . #4#) (LETT #0# |l| . #4#)
                           G190
                           (COND
                             ((OR (ATOM #0#)
                                  (PROGN
                                    (LETT |eq| (CAR #0#) . #4#)
                                    NIL))
                              #5=(GO G191)))
                           (SEQ (EXIT (COND
                                        ((QEQCAR
                                          (SPADCALL
                                           (SPADCALL |eq|
                                            (QREFELT $ 21))
                                           (QREFELT $ 37))
                                          0)
                                         (COND
                                           ((QEQCAR
                                             (|NLINSOL;RIfCan|
                                              (SPADCALL |eq|
                                               (QREFELT $ 22))
                                              $)
                                             0)
                                            (LETT |lassign|
                                             (CONS |eq| |lassign|) . #4#))
                                           ('T
                                            (LETT |lsubs|
                                             (CONS |eq| |lsubs|) . #4#))))
                                        ('T
                                         (SEQ
                                          (LETT |u|
                                           (SPADCALL
                                            (SPADCALL |eq|
                                             (QREFELT $ 21))
                                            (QREFELT $ 39)) . #4#)
                                          (EXIT
                                           (COND
                                             ((QEQCAR |u| 0)
                                              (COND
                                                ((EQL
                                                  (LENGTH
                                                   (SPADCALL (QCDR |u|)
                                                    (QREFELT $ 9)))
                                                  1)
                                                 (SEQ
                                                  (LETT |r|
                                                   (|NLINSOL;RIfCan|
                                                    (SPADCALL |eq|
                                                     (QREFELT $ 22))
                                                    $) . #4#)
                                                  (EXIT
                                                   (COND
                                                     ((QEQCAR |r| 0)
                                                      (LETT |luniv|
                                                       (CONS
                                                        (SPADCALL
                                                         (QCDR |u|)
                                                         (SPADCALL
                                                          (QCDR |r|)
                                                          (QREFELT $
                                                           36))
                                                         (QREFELT $ 41))
                                                        |luniv|) . #4#))
                                                     ('T
                                                      (PROGN
                                                        (LETT #1#
                                                         (LIST |l|) . #4#)
                                                        (GO #1#)))))))
                                                ('T
                                                 (PROGN
                                                   (LETT #1#
                                                    (LIST |l|) . #4#)
                                                   (GO #1#)))))
                                             ('T
                                              (PROGN
                                                (LETT #1#
                                                 (LIST |l|) . #4#)
                                                (GO #1#))))))))))
                           (LETT #0# (CDR #0#) . #4#) #6=(GO G190) G191
                           (EXIT NIL))
                      (EXIT (COND
                              ((NULL |luniv|) (LIST |l|))
                              ('T
                               (PROGN
                                 (LETT #2# NIL . #4#)
                                 (SEQ (LETT |z| NIL . #4#)
                                      (LETT #3#
                                       (|NLINSOL;allRoots| |luniv| $) . #4#)
                                      G190
                                      (COND
                                        ((OR (ATOM #3#)
                                          (PROGN
                                            (LETT |z| (CAR #3#) . #4#)
                                            NIL))
                                         #5#))
                                      (SEQ
                                       (EXIT
                                        (LETT #2#
                                         (CONS
                                          (SPADCALL |z|
                                           (SPADCALL
                                            (|NLINSOL;evalSol| |lsubs|
                                             |z| $)
                                            |lassign| (QREFELT $ 42))
                                           (QREFELT $ 42))
                                          #2#) . #4#)))
                                      (LETT #3# (CDR #3#) . #4#) #6#
                                      G191 (EXIT (NREVERSE0 #2#)))))))))
           #1# (EXIT #1#))))) 

(DEFUN |NLINSOL;RIfCan| (|f| $)
  (PROG (|n| |d| #0=#:G1887)
    (RETURN
      (SEQ (EXIT (SEQ (SEQ (LETT |n|
                                 (SPADCALL
                                     (SPADCALL |f| (QREFELT $ 43))
                                     (QREFELT $ 45))
                                 . #1=(|NLINSOL;RIfCan|))
                           (EXIT (COND
                                   ((QEQCAR |n| 0)
                                    (SEQ
                                     (LETT |d|
                                      (SPADCALL
                                       (SPADCALL |f| (QREFELT $ 46))
                                       (QREFELT $ 45)) . #1#)
                                     (EXIT
                                      (COND
                                        ((QEQCAR |d| 0)
                                         (PROGN
                                           (LETT #0#
                                            (CONS 0
                                             (SPADCALL (QCDR |n|)
                                              (QCDR |d|)
                                              (QREFELT $ 47))) . #1#)
                                           (GO #0#))))))))))
                      (EXIT (CONS 1 "failed"))))
           #0# (EXIT #0#))))) 

(DEFUN |NLINSOL;solve;LL;9| (|l| $) (SPADCALL |l| (QREFELT $ 14))) 

(DEFUN |NLINSOL;solve;LLL;10| (|lp| |lv| $)
  (SPADCALL |lp| |lv| (QREFELT $ 13))) 

(DEFUN |NLINSOL;solveInField;LLL;11| (|lp| |lv| $)
  (SPADCALL |lp| |lv| (QREFELT $ 49))) 

(DEFUN |NLINSOL;solveInField;LLL;12| (|lp| |lv| $)
  (SPADCALL |lp| |lv| (QREFELT $ 51))) 

(DEFUN |NLINSOL;solveInField;LLL;13| (|lp| |lv| $)
  (PROG (#0=#:G1895 |p| #1=#:G1896)
    (RETURN
      (SEQ (SPADCALL
               (PROGN
                 (LETT #0# NIL . #2=(|NLINSOL;solveInField;LLL;13|))
                 (SEQ (LETT |p| NIL . #2#) (LETT #1# |lp| . #2#) G190
                      (COND
                        ((OR (ATOM #1#)
                             (PROGN (LETT |p| (CAR #1#) . #2#) NIL))
                         (GO G191)))
                      (SEQ (EXIT (LETT #0#
                                       (CONS
                                        (SPADCALL |p| (QREFELT $ 31))
                                        #0#) . #2#)))
                      (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                      (EXIT (NREVERSE0 #0#))))
               |lv| (QREFELT $ 54)))))) 

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

(DEFUN |NonLinearSolvePackage;| (|#1|)
  (PROG (DV$1 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|) . #0=(|NonLinearSolvePackage|))
        (LETT |dv$| (LIST '|NonLinearSolvePackage| DV$1) . #0#)
        (LETT $ (GETREFV 55) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|haddProp| |$ConstructorCache| '|NonLinearSolvePackage|
            (LIST DV$1) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (COND
          ((|HasCategory| |#1| '(|AlgebraicallyClosedField|))
           (PROGN
             (QSETREFV $ 16
                 (CONS (|dispatchFunction| |NLINSOL;solve;LL;2|) $))
             (QSETREFV $ 15
                 (CONS (|dispatchFunction| |NLINSOL;solve;LLL;3|) $))))
          ('T
           (PROGN
             (QSETREFV $ 16
                 (CONS (|dispatchFunction| |NLINSOL;solve;LL;9|) $))
             (QSETREFV $ 15
                 (CONS (|dispatchFunction| |NLINSOL;solve;LLL;10|) $)))))
        (COND
          ((|domainEqual| |#1| (|Fraction| (|Integer|))))
          ((|HasCategory| |#1|
               '(|RetractableTo| (|Fraction| (|Integer|))))
           (QSETREFV $ 13
               (CONS (|dispatchFunction| |NLINSOL;solveInField;LLL;11|)
                     $))))
        (COND
          ((|domainEqual| |#1| (|Integer|)))
          ((|HasCategory| |#1|
               '(|RetractableTo| (|Fraction| (|Integer|)))))
          ((|HasCategory| |#1| '(|RetractableTo| (|Integer|)))
           (QSETREFV $ 13
               (CONS (|dispatchFunction| |NLINSOL;solveInField;LLL;12|)
                     $))))
        (COND
          ((OR (|domainEqual| |#1| (|Integer|))
               (OR (|HasCategory| |#1|
                       '(|RetractableTo| (|Fraction| (|Integer|))))
                   (|HasCategory| |#1| '(|RetractableTo| (|Integer|))))))
          ('T
           (QSETREFV $ 13
               (CONS (|dispatchFunction| |NLINSOL;solveInField;LLL;13|)
                     $))))
        $)))) 

(MAKEPROP '|NonLinearSolvePackage| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|List| 29)
             (|Polynomial| 6) (0 . |variables|) (5 . |setUnion|)
             (|List| 23) (|List| 8) (11 . |solveInField|)
             |NLINSOL;solveInField;LL;1| (17 . |solve|) (23 . |solve|)
             (|List| $) (28 . |concat|) (|Fraction| 8) (|Equation| 19)
             (33 . |lhs|) (38 . |rhs|) (|List| 20)
             (|RationalFunction| 6) (43 . |eval|) (49 . |equation|)
             (|Union| 29 '"failed") (55 . |mainVariable|) (|Symbol|)
             (60 . |coerce|) (65 . |coerce|)
             (|SparseUnivariatePolynomial| 6) (70 . |univariate|)
             (|SparseUnivariatePolynomial| $) (75 . |zerosOf|)
             (80 . |coerce|) (85 . |retractIfCan|)
             (|Union| 8 '"failed") (90 . |retractIfCan|) (95 . |One|)
             (99 . -) (105 . |concat|) (111 . |numer|)
             (|Union| 6 '"failed") (116 . |retractIfCan|)
             (121 . |denom|) (126 . /)
             (|RetractSolvePackage| (|Fraction| (|Integer|)) 6)
             (132 . |solveRetract|)
             (|RetractSolvePackage| (|Integer|) 6)
             (138 . |solveRetract|) (|List| 19)
             (|SystemSolvePackage| 6) (144 . |solve|))
          '#(|solveInField| 150 |solve| 161) 'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 54
                                '(1 8 7 0 9 2 7 0 0 0 10 2 0 11 12 7 13
                                  2 0 11 12 7 15 1 0 11 12 16 1 11 0 17
                                  18 1 20 19 0 21 1 20 19 0 22 2 24 19
                                  19 23 25 2 20 0 19 19 26 1 8 27 0 28
                                  1 8 0 29 30 1 19 0 8 31 1 8 32 0 33 1
                                  6 17 34 35 1 8 0 6 36 1 19 27 0 37 1
                                  19 38 0 39 0 6 0 40 2 8 0 0 0 41 2 23
                                  0 0 0 42 1 19 8 0 43 1 8 44 0 45 1 19
                                  8 0 46 2 6 0 0 0 47 2 48 11 12 7 49 2
                                  50 11 12 7 51 2 53 11 52 7 54 1 0 11
                                  12 14 2 0 11 12 7 13 1 0 11 12 16 2 0
                                  11 12 7 15)))))
          '|lookupComplete|)) 
