;;; -*- Mode: Lisp; Package: Macsyma -*-
;;; Translated code for LMIVAX::MAX$DISK:[SHARE1]INTEQN.MC;4
;;; Written on 9/11/1984 04:51:17, from MACSYMA 302
;;; Translated for LPH

;;; TRANSL-AUTOLOAD version NIL
;;; TRANSS version 87 TRANSL version 1157 TRUTIL version 27
;;; TRANS1 version 108 TRANS2 version 39 TRANS3 version 50
;;; TRANS4 version 29 TRANS5 version 26 TRANSF version NIL
;;; TROPER version 15 TRPRED version 6 MTAGS version NIL
;;; MDEFUN version 58 TRANSQ version 88 FCALL version 40
;;; ACALL version 70 TRDATA version 68 MCOMPI version 146
;;; TRMODE version 73 TRHOOK version NIL
(eval-when (compile eval)
      (setq *infile-name-key*
	          (namestring (truename '#.standard-input))))

(eval-when (compile)
   (setq $tr_semicompile 'NIL)
   (setq forms-to-compile-queue ()))

(comment "MAX$DISK:[SHARE1]INTEQN.MC;4")

;;; General declarations required for translated MACSYMA code.

(DECLARE
  (SPECIAL
    $INITIAL $KEEPFLOAT $SOLVERADCAN $DISPFLAG $INFLAG $GUESS
    $GUESSLIST $OPR $XHAT $X $UEQNLIST $EQNO $%C $HIGHLIM $UNKLIST
    $ICLIST $POFX $LOWLIM $INTEQN $EQNLIST $PXLIST $NAPPROX $IESOLN $BX
    $AX $KXU $XVAR $UVAR $FX $EQN $PX $TECH $TECHLIST $IEQNPRINT ^W))

(DECLARE (SPECIAL $IEQNPRINT))

(DECLARE (SPECIAL $TECHLIST))

(DECLARE (SPECIAL $TECH))

(DECLARE (SPECIAL $PX))

(DECLARE (SPECIAL $EQN))

(DECLARE (SPECIAL $FX))

(DECLARE (SPECIAL $UVAR))

(DECLARE (SPECIAL $XVAR))

(DECLARE (SPECIAL $KXU))

(DECLARE (SPECIAL $AX))

(DECLARE (SPECIAL $BX))

(DECLARE (SPECIAL $IESOLN))

(DECLARE (SPECIAL $NAPPROX))

(DECLARE (SPECIAL $PXLIST))

(DECLARE (SPECIAL $EQNLIST))

(DECLARE (SPECIAL $INTEQN))

(DECLARE (SPECIAL $LOWLIM))

(DECLARE (SPECIAL $POFX))

(DECLARE (SPECIAL $ICLIST))

(DECLARE (SPECIAL $UNKLIST))

(DECLARE (SPECIAL $HIGHLIM))

(DECLARE (SPECIAL $%C))

(DECLARE (SPECIAL $EQNO))

(DECLARE (SPECIAL $UEQNLIST))

(DECLARE (SPECIAL $X))

(DECLARE (SPECIAL $XHAT))

(DECLARE (SPECIAL $OPR))

(DECLARE (SPECIAL $GUESSLIST))

(DECLARE (SPECIAL $GUESS))

(DEFMTRFUN-EXTERNAL ($IEQN $ANY MDEFINE T NIL))

(DEFMTRFUN-EXTERNAL ($OPR $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($ARG $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($UNFUN $BOOLEAN MDEFINE NIL NIL))

(PUTPROP 'MAPLIST_TR (OR (GET 'MARRAYREF 'AUTOLOAD) T) 'AUTOLOAD)

(DEFMTRFUN-EXTERNAL ($IEQN1 $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($TRY $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($FIRSTKIND $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($FINDINT $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($PRINTSOLN $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($MYPRINT $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($LIN $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($MYSOLVE $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($SOLVESYS $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($SUMFACTORS $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($FRNK $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($PLUSSPLIT $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($SOLVEANDSUBST $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($TESTSOLN $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($MYPARTITION $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($ZEROINT $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($VLFRNK $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($GETICS $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($VCONVERT $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($TRANSFORM $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($COLLOCATE $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($GETLIMITS $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($APPROX $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($FLFRNK2ND $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($FCONVERT $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($TAILOR $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($GETXHAT $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($FREDSERIES $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($NEUMANN $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($FLFRNK1ST $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($MYDIVIDE $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($ABEL $ANY MDEFINE NIL NIL))

(DEFMTRFUN-EXTERNAL ($FIRSTKINDSERIES $ANY MDEFINE NIL NIL))


(DEFPROP $DV T TRANSLATED)

(ADD2LNC '$DV $PROPS)

(DEFMTRFUN
  ($DV $ANY MDEFMACRO NIL NIL) ($A) NIL
  (MBUILDQ-SUBST
    (LIST (CONS '$A $A)) '(($DEFINE_VARIABLE) $A ((MQUOTE) $A) $ANY)))

(SETQ ^W T)

(MEVAL* '(($MODEDECLARE) $IEQNPRINT $BOOLEAN))

(MEVAL* '(($DECLARE) $IEQNPRINT $SPECIAL))

(DEFPROP $IEQNPRINT ASSIGN-MODE-CHECK ASSIGN)

(DEF-MTRVAR $IEQNPRINT T)

(MEVAL* '(($MODEDECLARE) $TECHLIST $LIST))

(MEVAL* '(($DECLARE) $TECHLIST $SPECIAL))

(DEFPROP $TECHLIST ASSIGN-MODE-CHECK ASSIGN)

(DEF-MTRVAR
  $TECHLIST
  '((MLIST) $FIRST $ALL $VLFRNK $TRANSFORM $COLLOCATE $FLFRNK2ND
    $TAILOR $FREDSERIES $NEUMANN $FLFRNK1ST $ABEL $FIRSTKINDSERIES))

(MEVAL* '(($MODEDECLARE) $TECH $ANY))

(MEVAL* '(($DECLARE) $TECH $SPECIAL))

(DEF-MTRVAR $TECH '$TECH)

(MEVAL* '(($MODEDECLARE) $PX $ANY))

(MEVAL* '(($DECLARE) $PX $SPECIAL))

(DEF-MTRVAR $PX '$PX)

(MEVAL* '(($MODEDECLARE) $EQN $ANY))

(MEVAL* '(($DECLARE) $EQN $SPECIAL))

(DEF-MTRVAR $EQN '$EQN)

(MEVAL* '(($MODEDECLARE) $FX $ANY))

(MEVAL* '(($DECLARE) $FX $SPECIAL))

(DEF-MTRVAR $FX '$FX)

(MEVAL* '(($MODEDECLARE) $UVAR $ANY))

(MEVAL* '(($DECLARE) $UVAR $SPECIAL))

(DEF-MTRVAR $UVAR '$UVAR)

(MEVAL* '(($MODEDECLARE) $XVAR $ANY))

(MEVAL* '(($DECLARE) $XVAR $SPECIAL))

(DEF-MTRVAR $XVAR '$XVAR)

(MEVAL* '(($MODEDECLARE) $KXU $ANY))

(MEVAL* '(($DECLARE) $KXU $SPECIAL))

(DEF-MTRVAR $KXU '$KXU)

(MEVAL* '(($MODEDECLARE) $AX $ANY))

(MEVAL* '(($DECLARE) $AX $SPECIAL))

(DEF-MTRVAR $AX '$AX)

(MEVAL* '(($MODEDECLARE) $BX $ANY))

(MEVAL* '(($DECLARE) $BX $SPECIAL))

(DEF-MTRVAR $BX '$BX)

(MEVAL* '(($MODEDECLARE) $IESOLN $ANY))

(MEVAL* '(($DECLARE) $IESOLN $SPECIAL))

(DEF-MTRVAR $IESOLN '$IESOLN)

(MEVAL* '(($MODEDECLARE) $NAPPROX $ANY))

(MEVAL* '(($DECLARE) $NAPPROX $SPECIAL))

(DEF-MTRVAR $NAPPROX '$NAPPROX)

(MEVAL* '(($MODEDECLARE) $PXLIST $ANY))

(MEVAL* '(($DECLARE) $PXLIST $SPECIAL))

(DEF-MTRVAR $PXLIST '$PXLIST)

(MEVAL* '(($MODEDECLARE) $EQNLIST $ANY))

(MEVAL* '(($DECLARE) $EQNLIST $SPECIAL))

(DEF-MTRVAR $EQNLIST '$EQNLIST)

(MEVAL* '(($MODEDECLARE) $INTEQN $ANY))

(MEVAL* '(($DECLARE) $INTEQN $SPECIAL))

(DEF-MTRVAR $INTEQN '$INTEQN)

(MEVAL* '(($MODEDECLARE) $LOWLIM $ANY))

(MEVAL* '(($DECLARE) $LOWLIM $SPECIAL))

(DEF-MTRVAR $LOWLIM '$LOWLIM)

(MEVAL* '(($MODEDECLARE) $POFX $ANY))

(MEVAL* '(($DECLARE) $POFX $SPECIAL))

(DEF-MTRVAR $POFX '$POFX)

(MEVAL* '(($MODEDECLARE) $ICLIST $ANY))

(MEVAL* '(($DECLARE) $ICLIST $SPECIAL))

(DEF-MTRVAR $ICLIST '$ICLIST)

(MEVAL* '(($MODEDECLARE) $UNKLIST $ANY))

(MEVAL* '(($DECLARE) $UNKLIST $SPECIAL))

(DEF-MTRVAR $UNKLIST '$UNKLIST)

(MEVAL* '(($MODEDECLARE) $HIGHLIM $ANY))

(MEVAL* '(($DECLARE) $HIGHLIM $SPECIAL))

(DEF-MTRVAR $HIGHLIM '$HIGHLIM)

(MEVAL* '(($MODEDECLARE) $%C $ANY))

(MEVAL* '(($DECLARE) $%C $SPECIAL))

(DEF-MTRVAR $%C '$%C)

(MEVAL* '(($MODEDECLARE) $EQNO $ANY))

(MEVAL* '(($DECLARE) $EQNO $SPECIAL))

(DEF-MTRVAR $EQNO '$EQNO)

(MEVAL* '(($MODEDECLARE) $UEQNLIST $ANY))

(MEVAL* '(($DECLARE) $UEQNLIST $SPECIAL))

(DEF-MTRVAR $UEQNLIST '$UEQNLIST)

(MEVAL* '(($MODEDECLARE) $X $ANY))

(MEVAL* '(($DECLARE) $X $SPECIAL))

(DEF-MTRVAR $X '$X)

(MEVAL* '(($MODEDECLARE) $XHAT $ANY))

(MEVAL* '(($DECLARE) $XHAT $SPECIAL))

(DEF-MTRVAR $XHAT '$XHAT)

(MEVAL* '(($MODEDECLARE) $OPR $ANY))

(MEVAL* '(($DECLARE) $OPR $SPECIAL))

(DEF-MTRVAR $OPR '$OPR)

(MEVAL* '(($MODEDECLARE) $GUESSLIST $ANY))

(MEVAL* '(($DECLARE) $GUESSLIST $SPECIAL))

(DEF-MTRVAR $GUESSLIST '$GUESSLIST)

(MEVAL* '(($MODEDECLARE) $GUESS $ANY))

(MEVAL* '(($DECLARE) $GUESS $SPECIAL))

(DEF-MTRVAR $GUESS '$GUESS)

(DEFPROP $IEQN T TRANSLATED)

(ADD2LNC '$IEQN $PROPS)

(DEFMTRFUN
 ($IEQN $ANY MDEFINE T NIL) ($ARGLIST) NIL
 (COND
   ((< (MFUNCTION-CALL $LENGTH $ARGLIST) 2)
      (SIMPLIFY
	(MFUNCTION-CALL $ERROR '|&IEQN requires at least two arguments|)))
   (T
     (SIMPLIFY
       (MFUNCTION-CALL
	 $IEQN1 (MARRAYREF $ARGLIST 1) (MARRAYREF $ARGLIST 2)
	 (COND
	   ((> (MFUNCTION-CALL $LENGTH $ARGLIST) 2) (MARRAYREF $ARGLIST 3))
	   (T '((MLIST))))
	 (COND
	   ((> (MFUNCTION-CALL $LENGTH $ARGLIST) 3) (MARRAYREF $ARGLIST 4))
	   (T '((MLIST))))
	 (COND
	   ((> (MFUNCTION-CALL $LENGTH $ARGLIST) 4) (MARRAYREF $ARGLIST 5))
	   (T '((MLIST)))))))))

(DEFPROP $OPR T TRANSLATED)

(ADD2LNC '$OPR $PROPS)

(DEFMTRFUN ($OPR $ANY MDEFINE NIL NIL) ($E) NIL
	   (COND ((MFUNCTION-CALL $MAPATOM $E) '$NONE)
		 (T (SIMPLIFY (MFUNCTION-CALL $INPART $E 0)))))

(DEFPROP $ARG T TRANSLATED)

(ADD2LNC '$ARG $PROPS)

(DEFMTRFUN ($ARG $ANY MDEFINE NIL NIL) ($E) NIL
	   (SIMPLIFY (MFUNCTION-CALL $INPART $E 1)))

(MEVAL* '(($ALIAS) $EXITFOR MRETURN))

(DEFPROP $UNFUN T TRANSLATED)

(ADD2LNC '$UNFUN $PROPS)

(DEFMTRFUN ($UNFUN $BOOLEAN MDEFINE NIL NIL) ($E) NIL
	   (LIKE (SIMPLIFY (MFUNCTION-CALL GETCHAR $E 1)) '$))

(DEFPROP $IEQN1 T TRANSLATED)

(ADD2LNC '$IEQN1 $PROPS)

(DEFMTRFUN
 ($IEQN1 $ANY MDEFINE NIL NIL)
 ($EQNLIST $PXLIST $TECH $NAPPROX $GUESSLIST) NIL
 ((LAMBDA ($IESOLN $XVAR $UVAR $AX $BX $KXU $FX $EQN $PX $GUESS $SYSTEM
		   $INFLAG $DISPFLAG $SINGSOLVE $SOLVERADCAN $KEEPFLOAT)
   NIL
   (PROG ()
      (SETQ $INFLAG T)
      (SETQ $DISPFLAG NIL)
      (SETQ $SYSTEM NIL)
      (COND
	((NOT (MFUNCTION-CALL $LISTP (TRD-MSYMEVAL $EQNLIST '$EQNLIST)))
	   (SETQ $EQNLIST
		 (LIST '(MLIST) (TRD-MSYMEVAL $EQNLIST '$EQNLIST)))))
      (COND
	((NOT (MFUNCTION-CALL $LISTP (TRD-MSYMEVAL $PXLIST '$PXLIST)))
	   (SETQ
	     $PXLIST (LIST '(MLIST) (TRD-MSYMEVAL $PXLIST '$PXLIST)))))
      (COND
	((NOT
	   (= (MFUNCTION-CALL $LENGTH (TRD-MSYMEVAL $EQNLIST '$EQNLIST))
	      (MFUNCTION-CALL $LENGTH (TRD-MSYMEVAL $PXLIST '$PXLIST))))
	   (SIMPLIFY
	     (MFUNCTION-CALL
	       $ERROR '|&NUMBER OF EQUATIONS # NUMBER OF UNKNOWNS|))))
      (DO (($UNK) (MDO (CDR (TRD-MSYMEVAL $PXLIST '$PXLIST)) (CDR MDO)))
	  ((NULL MDO) '$DONE)
	(SETQ $UNK (CAR MDO))
	(COND
	  ((OR
	     (MFUNCTION-CALL $MAPATOM $UNK)
	     (NOT (= (MFUNCTION-CALL $LENGTH $UNK) 1))
	     (NOT (MFUNCTION-CALL
		    $ATOM
		    (SETQ $XVAR (SIMPLIFY (MFUNCTION-CALL $ARG $UNK)))))
	     (MFUNCTION-CALL $NUMBERP (TRD-MSYMEVAL $XVAR '$XVAR)))
	     (SIMPLIFY
	       (MFUNCTION-CALL
		 $ERROR $UNK '|& IMPROPERLY SPECIFIED UNKNOWN|)))))
      (COND
	((LIKE (TRD-MSYMEVAL $TECH '$TECH) '((MLIST)))
	   (SIMPLIFY
	     (MFUNCTION-CALL $MYPRINT '|&DEFAULT 3RD ARG, TECHNIQUE: |
			     (SETQ $TECH '$FIRST))))
	((NOT (MFUNCTION-CALL $MEMBER (TRD-MSYMEVAL $TECH '$TECH)
			      (TRD-MSYMEVAL $TECHLIST '((MLIST)))))
	   (SIMPLIFY
	     (MFUNCTION-CALL $ERROR (TRD-MSYMEVAL $TECH '$TECH)
			     '|& INVALID TECHNIQUE - SEE TECHLIST|))))
      (COND
	((LIKE (TRD-MSYMEVAL $NAPPROX '$NAPPROX) '((MLIST)))
	   (SIMPLIFY
	     (MFUNCTION-CALL
	       $MYPRINT
	       '|&DEFAULT 4TH ARG, NUMBER OF ITERATIONS OR COLL. PARMS.: |
	       (SETQ $NAPPROX 1))))
	((OR (NOT (MFUNCTION-CALL
		    $INTEGERP (TRD-MSYMEVAL $NAPPROX '$NAPPROX)))
	     (NOT (IS-BOOLE-CHECK
		    (MGRP (TRD-MSYMEVAL $NAPPROX '$NAPPROX) 0))))
	   (SIMPLIFY (MFUNCTION-CALL
		       $ERROR '|&NAPPROX MUST BE A POS. INTEGER|))))
      (COND ((LIKE (TRD-MSYMEVAL $GUESSLIST '$GUESSLIST) '((MLIST)))
	       (SIMPLIFY (MFUNCTION-CALL
			   $MYPRINT '|&DEFAULT 5TH ARG, INITIAL GUESS: |
			   (SETQ $GUESSLIST '$NONE)))))
      (COND
	((LIKE (TRD-MSYMEVAL $GUESSLIST '$GUESSLIST) '$NONE)
	   (SETQ $GUESS '$NONE))
	(T
	  (COND
	    ((NOT (MFUNCTION-CALL
		    $LISTP (TRD-MSYMEVAL $GUESSLIST '$GUESSLIST)))
	       (SETQ
		 $GUESSLIST
		 (LIST
		   '(MLIST)
		   (SETQ $GUESS (TRD-MSYMEVAL $GUESSLIST '$GUESSLIST))))))
	  (COND ((NOT (= (MFUNCTION-CALL
			   $LENGTH (TRD-MSYMEVAL $GUESSLIST '$GUESSLIST))
			 (MFUNCTION-CALL
			   $LENGTH (TRD-MSYMEVAL $PXLIST '$PXLIST))))
		   (SIMPLIFY
		     (MFUNCTION-CALL
		       $ERROR
		       '|&NUMBER OF GUESSES # NUMBER OF UNKNOWNS|))))))
      (SETQ $SINGSOLVE (SETQ $SOLVERADCAN (SETQ $KEEPFLOAT T)))
      (SETQ $IESOLN '((MLIST)))
      (SETQ
	$EQNLIST
	(MAPLIST_TR
	  (M-TLAMBDA
	    ($EQN) NIL
	    (SIMPLIFY
	      (MFUNCTION-CALL
		$NUM
		(SIMPLIFY
		  (MFUNCTION-CALL
		    $RATSIMP
		    (ADD*
		      (SIMPLIFY
			(MFUNCTION-CALL $LHS (TRD-MSYMEVAL $EQN '$EQN)))
		      (*MMINUS
			(SIMPLIFY (MFUNCTION-CALL
				    $RHS (TRD-MSYMEVAL $EQN '$EQN))))))))))
	  (TRD-MSYMEVAL $EQNLIST '$EQNLIST)))
      (COND
	((= (MFUNCTION-CALL $LENGTH (TRD-MSYMEVAL $PXLIST '$PXLIST)) 1)
	   (SETQ $PX (SIMPLIFY ($FIRST (TRD-MSYMEVAL $PXLIST '$PXLIST))))
	   (SETQ $EQN
		 (SIMPLIFY ($FIRST (TRD-MSYMEVAL $EQNLIST '$EQNLIST)))))
	(T (SETQ $SYSTEM T)))
      (COND
	((NOT (IS-BOOLE-CHECK $SYSTEM))
	   (SIMPLIFY (MFUNCTION-CALL $TRY '$VLFRNK))
	   (COND ((LIKE (TRD-MSYMEVAL $TECH '$TECH) '$DONE)
		    (RETURN
		      (SIMPLIFY
			(MFUNCTION-CALL
			  $REVERSE (TRD-MSYMEVAL $IESOLN '$IESOLN))))))))
      (SIMPLIFY (MFUNCTION-CALL $TRY '$TRANSFORM))
      (COND
	((LIKE (TRD-MSYMEVAL $TECH '$TECH) '$DONE)
	   (RETURN
	     (SIMPLIFY (MFUNCTION-CALL
			 $REVERSE (TRD-MSYMEVAL $IESOLN '$IESOLN))))))
      (DO (($EQNLIST)
	   (MDO
	     (CDR (SIMPLIFY (MFUNCTION-CALL
			      $SOLVESYS (TRD-MSYMEVAL $EQNLIST '$EQNLIST)
			      (TRD-MSYMEVAL $PXLIST '$PXLIST))))
	     (CDR MDO)))
	  ((NULL MDO) '$DONE)
	(SETQ $EQNLIST (CAR MDO))
	(SIMPLIFY (MFUNCTION-CALL $TRY '$FLFRNK2ND))
	(SIMPLIFY (MFUNCTION-CALL $TRY '$TAILOR))
	(COND ((NOT (IS-BOOLE-CHECK $SYSTEM))
		 (SIMPLIFY (MFUNCTION-CALL $TRY '$FREDSERIES))))
	(SIMPLIFY (MFUNCTION-CALL $TRY '$NEUMANN)))
      (COND
	((AND (NOT (IS-BOOLE-CHECK $SYSTEM))
	      (IS-BOOLE-CHECK (SIMPLIFY (MFUNCTION-CALL $FIRSTKIND))))
	   (SIMPLIFY (MFUNCTION-CALL $TRY '$FLFRNK1ST))
	   (SIMPLIFY (MFUNCTION-CALL $TRY '$ABEL))
	   (SIMPLIFY (MFUNCTION-CALL $TRY '$FIRSTKINDSERIES))))
      (SIMPLIFY (MFUNCTION-CALL $TRY '$COLLOCATE))
      (RETURN
	(SIMPLIFY
	  (MFUNCTION-CALL $REVERSE (TRD-MSYMEVAL $IESOLN '$IESOLN))))))
  '$IESOLN '$XVAR '$UVAR '$AX '$BX '$KXU '$FX '$EQN '$PX '$GUESS
  '$SYSTEM '$INFLAG '$DISPFLAG '$SINGSOLVE '$SOLVERADCAN '$KEEPFLOAT))

(DEFPROP $TRY T TRANSLATED)

(ADD2LNC '$TRY $PROPS)

(DEFMTRFUN
  ($TRY $ANY MDEFINE NIL NIL) ($ROUTINE) NIL
  (COND
    ((MFUNCTION-CALL $MEMBER (TRD-MSYMEVAL $TECH '$TECH)
		     (LIST '(MLIST) '$ALL '$FIRST $ROUTINE))
       ((LAMBDA ($ATTEMPT)
	  NIL
	  (SETQ
	    $ATTEMPT
	    ((LAMBDA (ERRCATCH RET)
	       (COND
		 ((NULL
		    (SETQ
		      RET
		      (ERRSET
			(PROGN
			  ((LAMBDA ()
			     ((LAMBDA (MCATCH)
				(PROG2
				  NIL
				  (*CATCH
				    'MCATCH
				    (PROGN (SIMPLIFY (MFUNCALL $ROUTINE))))
				  (ERRLFUN1 MCATCH)))
			      (CONS BINDLIST LOCLIST)))))
			LISPERRPRINT)))
		    (ERRLFUN1 ERRCATCH)))
	       (CONS '(MLIST) RET))
	     (CONS BINDLIST LOCLIST) NIL))
	  (COND
	    ((LIKE $ATTEMPT '((MLIST)))
	       (SIMPLIFY (MFUNCTION-CALL PRINC '| IN |))
	       (SIMPLIFY
		 (MFUNCTION-CALL
		   PRINC (SIMPLIFY (MFUNCTION-CALL STRIPDOLLAR $ROUTINE))))
	       (SIMPLIFY (MFUNCTION-CALL TERPRI)))
	    ((AND (IS-BOOLE-CHECK (SIMPLIFY ($FIRST $ATTEMPT)))
		  (LIKE (TRD-MSYMEVAL $TECH '$TECH) '$FIRST))
	       (SETQ $TECH '$DONE))))
	'$ATTEMPT))))

(DEFPROP $FIRSTKIND T TRANSLATED)

(ADD2LNC '$FIRSTKIND $PROPS)

(DEFMTRFUN
 ($FIRSTKIND $ANY MDEFINE NIL NIL) NIL NIL
 ((LAMBDA ($INTEGRAL $XPOINTS $CONSISTENT)
    NIL
    (PROG ()
	(COND ((NOT (MFUNCTION-CALL $FREEOF (TRD-MSYMEVAL $PX '$PX)
				    (TRD-MSYMEVAL $EQN '$EQN)))
		 (RETURN NIL)))
	(SETQ
	  $INTEGRAL
	  ((LAMBDA ()
	     ((LAMBDA (MCATCH)
		(PROG2
		  NIL
		  (*CATCH
		    'MCATCH
		    (PROGN
		      (SIMPLIFY (MFUNCTION-CALL
				  $FINDINT (TRD-MSYMEVAL $EQN '$EQN)))))
		  (ERRLFUN1 MCATCH)))
	      (CONS BINDLIST LOCLIST)))))
	(COND ((LIKE $INTEGRAL NIL) (RETURN NIL)))
	(SETQ
	  $FX
	  (SIMPLIFY
	    (MFUNCTION-CALL $MYSOLVE (TRD-MSYMEVAL $EQN '$EQN) $INTEGRAL)))
	(COND ((LIKE (TRD-MSYMEVAL $FX '$FX) '((MLIST))) (RETURN NIL)))
	(SETQ $FX (SIMPLIFY ($FIRST (TRD-MSYMEVAL $FX '$FX))))
	(SETQ $UVAR (SIMPLIFY (MFUNCTION-CALL $INPART $INTEGRAL 2)))
	(SETQ
	  $KXU
	  (SIMPLIFY
	    (MFUNCTION-CALL
	      $LIN (SIMPLIFY (MFUNCTION-CALL $ARG $INTEGRAL))
	      (SIMPLIFY
		(MFUNCTION-CALL $SUBSTITUTE (TRD-MSYMEVAL $UVAR '$UVAR)
				(TRD-MSYMEVAL $XVAR '$XVAR)
				(TRD-MSYMEVAL $PX '$PX))))))
	(COND ((LIKE (TRD-MSYMEVAL $KXU '$KXU) NIL) (RETURN NIL)))
	(SETQ $AX (SIMPLIFY (MFUNCTION-CALL $INPART $INTEGRAL 3)))
	(SETQ $BX (SIMPLIFY (MFUNCTION-CALL $INPART $INTEGRAL 4)))
	(COND
	  ((NOT (LIKE (MARRAYREF (TRD-MSYMEVAL $KXU '$KXU) 2) 0))
	     (SETQ
	       $FX
	       (SIMPLIFY
		 (MFUNCTION-CALL
		   $RATSIMP
		   (ADD*
		     (TRD-MSYMEVAL $FX '$FX)
		     (*MMINUS
		       (SIMPLIFY
			 (MFUNCTION-CALL
			   $MYINT (MARRAYREF (TRD-MSYMEVAL $KXU '$KXU) 2)
			   (TRD-MSYMEVAL $UVAR '$UVAR)
			   (TRD-MSYMEVAL $AX '$AX)
			   (TRD-MSYMEVAL $BX '$BX))))))))))
	(SETQ $XPOINTS
	      (SIMPLIFY
		(MFUNCTION-CALL $MYSOLVE
				(ADD* (TRD-MSYMEVAL $AX '$AX)
				      (*MMINUS (TRD-MSYMEVAL $BX '$BX)))
				(TRD-MSYMEVAL $XVAR '$XVAR))))
	(SETQ $KXU (MARRAYREF (TRD-MSYMEVAL $KXU '$KXU) 1))
	(COND ((LIKE $XPOINTS '((MLIST))) (RETURN T))
	      (T (SETQ $CONSISTENT NIL)))
	(DO (($XV) (MDO (CDR $XPOINTS) (CDR MDO))) ((NULL MDO) '$DONE)
	  (SETQ $XV (CAR MDO))
	  (COND
	    ((LIKE
	       (SIMPLIFY
		 (MFUNCTION-CALL $RATSUBST $XV (TRD-MSYMEVAL $XVAR '$XVAR)
				 (TRD-MSYMEVAL $FX '$FX)))
	       0)
	       (RETURN (SETQ $CONSISTENT T)))))
	(RETURN $CONSISTENT)))
  '$INTEGRAL '$XPOINTS '$CONSISTENT))

(DEFPROP $FINDINT T TRANSLATED)

(ADD2LNC '$FINDINT $PROPS)

(DEFMTRFUN
  ($FINDINT $ANY MDEFINE NIL NIL) ($EXPR) NIL
  (COND
    ((NOT (MFUNCTION-CALL $MAPATOM $EXPR))
       (COND
	 ((NOT (LIKE (SIMPLIFY (MFUNCTION-CALL $OPR $EXPR)) '%INTEGRATE))
	    (DO (($I) (MDO (CDR $EXPR) (CDR MDO))) ((NULL MDO) '$DONE)
	      (SETQ $I (CAR MDO)) (SIMPLIFY (MFUNCTION-CALL $FINDINT $I)))
	    NIL)
	 (T ((LAMBDA (X)
	       (COND ((NULL MCATCH)
			(DISPLA X) (*MERROR '|THROW not within CATCH|)))
	       (*THROW 'MCATCH X))
	     $EXPR))))))

(DEFPROP $PRINTSOLN T TRANSLATED)

(ADD2LNC '$PRINTSOLN $PROPS)

(DEFMTRFUN
 ($PRINTSOLN $ANY MDEFINE NIL NIL) ($SOLN $TECH $ORDER $KIND) NIL
 ((LAMBDA ($DISPFLAG $DEN)
    NIL
    (PROG ()
	 (SETQ $DISPFLAG (TRD-MSYMEVAL $IEQNPRINT NIL))
	 (COND ((NOT (LIKE $KIND '((MLIST))))
		  (SETQ $KIND (LIST '(MLIST) $KIND))))
	 (COND
	   ((NOT (LIKE $ORDER '((MLIST))))
	      (SETQ $KIND (SIMPLIFY (MFUNCTION-CALL $CONS $ORDER $KIND)))))
	 (COND ((NOT (MFUNCTION-CALL $LISTP $SOLN))
		  (SETQ $SOLN (LIST '(MLIST) $SOLN))))
	 (SETQ $SOLN
	       (MAPLIST_TR
		 (MEVAL '((LAMBDA) ((MLIST) $ELMT)
			  ((MSETQ) $ELMT (($RATSIMP) $ELMT))
			  ((MSETQ) $DEN (($DENOM) $ELMT))
			  ((MCOND)
			   ((MAND) (($NUMBERP) $DEN) ((MNOTEQUAL) $DEN 1)
			    ((MEQUAL) (($OPR) (($NUM) $ELMT)) &+))
			   (($MULTTHRU) $ELMT) T $ELMT)))
		 $SOLN))
	 (COND ((LIKE (SIMPLIFY (MFUNCTION-CALL $REST $SOLN)) '((MLIST)))
		  (SETQ $SOLN (SIMPLIFY ($FIRST $SOLN)))))
	 (SETQ
	   $IESOLN
	   (SIMPLIFY
	     (MFUNCTION-CALL
	       $CONS
	       (SIMPLIFY
		 (MFUNCTION-CALL
		   DISPLINE
		   (SIMPLIFY
		     (MFUNCTION-CALL
		       $CONS $SOLN
		       (SIMPLIFY
			 (MFUNCTION-CALL
			   $CONS (TRD-MSYMEVAL $TECH '$TECH) $KIND))))))
	       (TRD-MSYMEVAL $IESOLN '$IESOLN))))
	 (RETURN T)))
  '$DISPFLAG '$DEN))

(MEVAL* '(($ALIAS) $MYINT $INTEGRATE))

(DEFPROP $MYPRINT T TRANSLATED)

(ADD2LNC '$MYPRINT $PROPS)

(DEFMTRFUN ($MYPRINT $ANY MDEFINE NIL NIL) ($MSG1 $MSG2) NIL
	   (COND ((TRD-MSYMEVAL $IEQNPRINT NIL)
		    (SIMPLIFY (MFUNCTION-CALL $PRINT $MSG1 $MSG2)))))

(DEFPROP $LIN T TRANSLATED)

(ADD2LNC '$LIN $PROPS)

(DEFMTRFUN
  ($LIN $ANY MDEFINE NIL NIL) ($EXPR $VAR) NIL
  ((LAMBDA ($LC)
     NIL
     (SETQ
       $LC
       (SIMPLIFY (MFUNCTION-CALL
		   $RATSIMP (SIMPLIFY (MFUNCTION-CALL $DIFF $EXPR $VAR)))))
     (COND ((MFUNCTION-CALL $FREEOF $VAR $LC)
	      (LIST '(MLIST) $LC
		    (SIMPLIFY (MFUNCTION-CALL $RATSUBST 0 $VAR $EXPR))))))
   '$LC))

(DEFPROP $MYSOLVE T TRANSLATED)

(ADD2LNC '$MYSOLVE $PROPS)

(DEFMTRFUN
 ($MYSOLVE $ANY MDEFINE NIL NIL) ($EQN $UNK) NIL
 ((LAMBDA ($RESULT)
    NIL
    (PROG ()
	(SETQ $RESULT '((MLIST)))
	(SETQ
	  $EQN (SIMPLIFY
		 (MFUNCTION-CALL $SOLVE (TRD-MSYMEVAL $EQN '$EQN) $UNK)))
	(SETQ
	  $EQN
	  (MAPLIST_TR
	    '$RHS (SIMPLIFY (MFUNCALL '$EV (TRD-MSYMEVAL $EQN '$EQN)))))
	(DO (($ANS) (MDO (CDR (TRD-MSYMEVAL $EQN '$EQN)) (CDR MDO)))
	    ((NULL MDO) '$DONE)
	  (SETQ $ANS (CAR MDO))
	  (COND ((MFUNCTION-CALL $FREEOF $UNK $ANS)
		   (SETQ $RESULT
			 (SIMPLIFY (MFUNCTION-CALL $CONS $ANS $RESULT))))))
	(RETURN $RESULT)))
  '$RESULT))

(DEFPROP $SOLVESYS T TRANSLATED)

(ADD2LNC '$SOLVESYS $PROPS)

(DEFMTRFUN
  ($SOLVESYS $ANY MDEFINE NIL NIL) ($EQNS $UNKS) NIL
  (PROGN
    (SETQ $EQNS (SIMPLIFY (MFUNCTION-CALL $SOLVE $EQNS $UNKS)))
    (SETQ $EQNS (SIMPLIFY (MFUNCALL '$EV $EQNS)))
    (MAPLIST_TR
      (M-TLAMBDA
	($EL) NIL
	(COND ((MFUNCTION-CALL $LISTP $EL) (MAPLIST_TR '$RHS $EL))
	      (T (LIST '(MLIST) (SIMPLIFY (MFUNCTION-CALL $RHS $EL))))))
      $EQNS)))

(DEFPROP $SUMFACTORS T TRANSLATED)

(ADD2LNC '$SUMFACTORS $PROPS)

(DEFMTRFUN
 ($SUMFACTORS $ANY MDEFINE NIL NIL) ($EXPR $UVAR) NIL
 ((LAMBDA ($OTHER $REM)
    NIL
    (PROG ()
	(SETQ
	  $EXPR
	  ((LAMBDA ()
	     ((LAMBDA (MCATCH)
		(PROG2
		  NIL
		  (*CATCH 'MCATCH
			  (PROGN (SIMPLIFY (MFUNCTION-CALL $FRNK $EXPR))))
		  (ERRLFUN1 MCATCH)))
	      (CONS BINDLIST LOCLIST)))))
	(COND ((LIKE $EXPR NIL) (RETURN '((MLIST)))))
	(COND ((MFUNCTION-CALL $FREEOF (TRD-MSYMEVAL $UVAR '$UVAR) $EXPR)
		 (RETURN (LIST '(MLIST) (LIST '(MLIST) $EXPR 1)))))
	(COND ((MFUNCTION-CALL $FREEOF (TRD-MSYMEVAL $XVAR '$XVAR) $EXPR)
		 (RETURN (LIST '(MLIST) (LIST '(MLIST) 1 $EXPR)))))
	(SETQ $EXPR (SIMPLIFY (MFUNCTION-CALL $EXPAND $EXPR)))
	(SETQ
	  $OTHER
	  (SIMPLIFY (MFUNCTION-CALL
		      $MYPARTITION $EXPR (TRD-MSYMEVAL $UVAR '$UVAR))))
	(SETQ
	  $EXPR
	  (SIMPLIFY (MFUNCTION-CALL
		      $MYPARTITION $EXPR (TRD-MSYMEVAL $XVAR '$XVAR))))
	(COND
	  ((IS-BOOLE-CHECK (MLSP (MARRAYREF $OTHER 1) (MARRAYREF $EXPR 1)))
	     (SETQ $EXPR $OTHER)))
	(SETQ
	  $REM
	  (COND ((LIKE (MARRAYREF $EXPR 3) 0) '((MLIST)))
		(T (LIST '(MLIST) (LIST '(MLIST) (MARRAYREF $EXPR 3) 1)))))
	(COND
	  ((NOT (LIKE (MARRAYREF $EXPR 4) 0))
	     (SETQ
	       $REM
	       (SIMPLIFY
		 (MFUNCTION-CALL
		   $CONS (LIST '(MLIST) 1 (MARRAYREF $EXPR 4)) $REM)))))
	(COND
	  ((NOT (LIKE (MARRAYREF $EXPR 2) 0))
	     (DO (($FC) (MDO (CDR (MARRAYREF $EXPR 2)) (CDR MDO)))
		 ((NULL MDO) '$DONE)
	       (SETQ $FC (CAR MDO))
	       (SETQ $REM
		     (SIMPLIFY
		       (MFUNCTION-CALL
			 $CONS
			 (SIMPLIFY
			   (MFUNCTION-CALL
			     $PARTITION $FC (TRD-MSYMEVAL $UVAR '$UVAR)))
			 $REM))))))
	(RETURN (SIMPLIFY (MFUNCTION-CALL $REMBOX $REM)))))
  '$OTHER '$REM))

(DEFPROP $FRNK T TRANSLATED)

(ADD2LNC '$FRNK $PROPS)

(DEFMTRFUN
 ($FRNK $ANY MDEFINE NIL NIL) ($E) NIL
 (COND
  ((OR (MFUNCTION-CALL $FREEOF (TRD-MSYMEVAL $XVAR '$XVAR) $E)
       (MFUNCTION-CALL $FREEOF (TRD-MSYMEVAL $UVAR '$UVAR) $E))
     $E)
  (T
    ((LAMBDA ($OP $AR $UP)
       NIL
       (PROG ()
	  (SETQ $OP (SIMPLIFY (MFUNCTION-CALL $OPR $E)))
	  (SETQ $AR (SIMPLIFY (MFUNCTION-CALL $ARG $E)))
	  (COND ((MFUNCTION-CALL $MEMBER $OP (LIST '(MLIST) '&+ '&*))
		   (RETURN (SIMPLIFY (MAP1 (GETOPR '$FRNK) $E)))))
	  (COND
	    ((LIKE $OP '&^)
	       (SETQ $UP (SIMPLIFY (MFUNCTION-CALL $INPART $E 2)))
	       (COND
		 ((MFUNCTION-CALL $INTEGERP $UP)
		    (COND
		      ((IS-BOOLE-CHECK (MGRP $UP 0))
			 (RETURN
			   (POWER (SIMPLIFY (MFUNCTION-CALL $FRNK $AR))
				  $UP)))
		      (T ((LAMBDA (X)
			    (COND ((NULL MCATCH)
				     (DISPLA X)
				     (*MERROR '|THROW not within CATCH|)))
			    (*THROW 'MCATCH X))
			  NIL)))))
	       (SETQ
		 $UP
		 (SIMPLIFY (MFUNCTION-CALL
			     $PLUSSPLIT
			     (SIMPLIFY (MFUNCTION-CALL $EXPAND $UP)))))
	       (COND
		 ((AND (NOT (LIKE $UP '((MLIST))))
		       (MFUNCTION-CALL $FREEOF (TRD-MSYMEVAL $UVAR '$UVAR)
				       (TRD-MSYMEVAL $XVAR '$XVAR) $AR))
		    (RETURN
		      (MUL*
			(SIMPLIFY (MFUNCTION-CALL
				    $BOX (POWER $AR (MARRAYREF $UP 1))))
			(SIMPLIFY (MFUNCTION-CALL
				    $BOX (POWER $AR (MARRAYREF $UP 2)))))))
		 (T ((LAMBDA (X)
		       (COND ((NULL MCATCH)
				(DISPLA X)
				(*MERROR '|THROW not within CATCH|)))
		       (*THROW 'MCATCH X))
		     NIL)))))
	  (COND
	    ((MFUNCTION-CALL $MEMBER (SIMPLIFY (MFUNCTION-CALL $OPR $AR))
			     (LIST '(MLIST) '&* '&+))
	       (SETQ
		 $E
		 (SIMPLIFY (MFUNCTION-CALL
			     $PARTITION $AR (TRD-MSYMEVAL $XVAR '$XVAR))))
	       (COND
		 ((NOT (MFUNCTION-CALL $FREEOF (TRD-MSYMEVAL $UVAR '$UVAR)
				       (MARRAYREF $E 2)))
		    ((LAMBDA (X)
		       (COND ((NULL MCATCH)
				(DISPLA X)
				(*MERROR '|THROW not within CATCH|)))
		       (*THROW 'MCATCH X))
		     NIL)))))
	  (RETURN
	    (COND
	      ((AND (LIKE $OP '%LOG)
		    (LIKE (SIMPLIFY (MFUNCTION-CALL $OPR $AR)) '&*))
		 (ADD* (SIMPLIFY (LIST '(%LOG) (MARRAYREF $E 1)))
		       (SIMPLIFY (LIST '(%LOG) (MARRAYREF $E 2)))))
	      ((LIKE (SIMPLIFY (MFUNCTION-CALL $OPR $AR)) '&+)
		 (COND
		   ((LIKE $OP '%SIN)
		      (ADD*
			(MUL* (SIMPLIFY (LIST '(%SIN) (MARRAYREF $E 1)))
			      (SIMPLIFY (LIST '(%COS) (MARRAYREF $E 2))))
			(MUL* (SIMPLIFY (LIST '(%COS) (MARRAYREF $E 1)))
			      (SIMPLIFY (LIST '(%SIN) (MARRAYREF $E 2))))))
		   ((LIKE $OP '%COS)
		      (ADD*
			(MUL* (SIMPLIFY (LIST '(%COS) (MARRAYREF $E 1)))
			      (SIMPLIFY (LIST '(%COS) (MARRAYREF $E 2))))
			(*MMINUS
			  (MUL*
			    (SIMPLIFY (LIST '(%SIN) (MARRAYREF $E 1)))
			    (SIMPLIFY (LIST '(%SIN) (MARRAYREF $E 2)))))))
		   ((LIKE $OP '%SINH)
		      (ADD*
			(MUL* (SIMPLIFY (LIST '(%SINH) (MARRAYREF $E 1)))
			      (SIMPLIFY (LIST '(%COSH) (MARRAYREF $E 2))))
			(MUL*
			  (SIMPLIFY (LIST '(%COSH) (MARRAYREF $E 1)))
			  (SIMPLIFY (LIST '(%SINH) (MARRAYREF $E 2))))))
		   ((LIKE $OP '%COSH)
		      (ADD*
			(MUL* (SIMPLIFY (LIST '(%COSH) (MARRAYREF $E 1)))
			      (SIMPLIFY (LIST '(%COSH) (MARRAYREF $E 2))))
			(MUL*
			  (SIMPLIFY (LIST '(%SINH) (MARRAYREF $E 1)))
			  (SIMPLIFY (LIST '(%SINH) (MARRAYREF $E 2))))))
		   (T ((LAMBDA (X)
			 (COND ((NULL MCATCH)
				  (DISPLA X)
				  (*MERROR '|THROW not within CATCH|)))
			 (*THROW 'MCATCH X))
		       NIL))))
	      (T
		((LAMBDA (X)
		   (COND
		     ((NULL MCATCH) (DISPLA X)
				    (*MERROR '|THROW not within CATCH|)))
		   (*THROW 'MCATCH X))
		 NIL))))))
     '$OP '$AR '$UP))))

(DEFPROP $PLUSSPLIT T TRANSLATED)

(ADD2LNC '$PLUSSPLIT $PROPS)

(DEFMTRFUN
  ($PLUSSPLIT $ANY MDEFINE NIL NIL) ($E) NIL
  (COND
    ((LIKE (SIMPLIFY (MFUNCTION-CALL $OPR $E)) '&+)
       (SETQ
	 $E (SIMPLIFY
	      (MFUNCTION-CALL $PARTITION $E (TRD-MSYMEVAL $UVAR '$UVAR))))
       (COND ((MFUNCTION-CALL
		$FREEOF (TRD-MSYMEVAL $XVAR '$XVAR) (MARRAYREF $E 2))
		$E)
	     (T '((MLIST)))))
    ((MFUNCTION-CALL $FREEOF (TRD-MSYMEVAL $UVAR '$UVAR) $E)
       (LIST '(MLIST) $E 0))
    ((MFUNCTION-CALL $FREEOF (TRD-MSYMEVAL $XVAR '$XVAR) $E)
       (LIST '(MLIST) 0 $E))
    (T '((MLIST)))))

(DEFPROP $SOLVEANDSUBST T TRANSLATED)

(ADD2LNC '$SOLVEANDSUBST $PROPS)

(DEFMTRFUN
 ($SOLVEANDSUBST $ANY MDEFINE NIL NIL) ($EXS $UNKS $FORM $TECH) NIL
 ((LAMBDA ($SOLN $TRIAL)
   NIL
   (PROG ()
      (COND
	((LIKE (SETQ $SOLN (SIMPLIFY (MFUNCTION-CALL $SOLVE $EXS $UNKS)))
	       '((MLIST)))
	  (SIMPLIFY (MFUNCTION-CALL
		      $PRINT '|&FOR A | (TRD-MSYMEVAL $TECH '$TECH)
		      '|& SOLUTION SUBSTITUTE IN THE EXPRESSION:|))
	  (DISPLAY-FOR-TR T NIL $FORM)
	  (SIMPLIFY
	    (MAPPLY-TR
	      '$PRINT
	      (SIMPLIFY
		(MFUNCTION-CALL $CONS '|&THE VALUES OF | $UNKS))))
	  (SIMPLIFY
	    (MFUNCTION-CALL
	      $PRINT
	      '|&THAT MAKE THE FOLLOWING EXPRESSIONS SIMULTANEOUSLY ZERO|))
	  (SIMPLIFY (MAPPLY-TR '$LDISP $EXS))
	  (RETURN NIL)))
      (DO (($SOL)
	   (MDO (CDR (SIMPLIFY (MFUNCALL '$EV $SOLN))) (CDR MDO)))
	  ((NULL MDO) '$DONE)
	(SETQ $SOL (CAR MDO))
	(SETQ $TRIAL (SIMPLIFY (MFUNCALL '$EV $FORM $SOL)))
	(SIMPLIFY
	  (MAPPLY-TR
	    '$PRINTSOLN
	    (SIMPLIFY
	      (MFUNCTION-CALL
		$APPEND
		(LIST '(MLIST) $TRIAL (TRD-MSYMEVAL $TECH '$TECH))
		(COND
		  ((LIKE (TRD-MSYMEVAL $TECH '$TECH) '$COLLOCATE)
		     (LIST '(MLIST) (TRD-MSYMEVAL $NAPPROX '$NAPPROX)
			   (SIMPLIFY (MFUNCTION-CALL $TESTSOLN $TRIAL))))
		  (T (LIST '(MLIST) '((MLIST)) '((MLIST))))))))))
      (RETURN T)))
  '$SOLN '$TRIAL))

(DEFPROP $TESTSOLN T TRANSLATED)

(ADD2LNC '$TESTSOLN $PROPS)

(DEFMTRFUN
 ($TESTSOLN $ANY MDEFINE NIL NIL) ($RESULTLIST) NIL
 ((LAMBDA ($FLAG)
    NIL
    (PROG ()
	(SIMPLIFY
	  (MAPPLY-TR
	    '$LOCAL (MAPLIST_TR '$OPR (TRD-MSYMEVAL $PXLIST '$PXLIST))))
	(SETQ $FLAG '((MLIST)))
	(MAPLIST_TR '$DEFINE (TRD-MSYMEVAL $PXLIST '$PXLIST) $RESULTLIST)
	(SETQ $RESULTLIST
	      (SIMPLIFY (MFUNCALL '$EV (TRD-MSYMEVAL $EQNLIST '$EQNLIST)
				  '$INTEGRATE '$RATSIMP)))
	(DO (($VAL) (MDO (CDR $RESULTLIST) (CDR MDO))) ((NULL MDO) '$DONE)
	  (SETQ $VAL (CAR MDO))
	  (COND ((NOT (LIKE $VAL 0)) (RETURN (SETQ $FLAG '$APPROXIMATE)))))
	(RETURN $FLAG)))
  '$FLAG))

(DEFPROP $MYPARTITION T TRANSLATED)

(ADD2LNC '$MYPARTITION $PROPS)

(DEFMTRFUN
 ($MYPARTITION $ANY MDEFINE NIL NIL) ($FOUT $VAR) NIL
 ((LAMBDA ($QX $RU $REM $CON)
    NIL
    (PROG ()
	(COND
	  ((OR
	     (NOT (LIKE (SIMPLIFY (MFUNCTION-CALL $OPR $FOUT)) '&+))
	     (NOT
	       (LIKE
		 (SIMPLIFY
		   (MFUNCTION-CALL
		     $OPR
		     (SETQ
		       $FOUT
		       (SIMPLIFY (MFUNCTION-CALL $FACTOROUT $FOUT $VAR)))))
		 '&+)))
	     (RETURN (LIST '(MLIST) 1 (LIST '(MLIST) $FOUT) 0 0))))
	(SETQ $REM (SETQ $CON (SETQ $QX (SETQ $RU 0))))
	(DO (($FC) (MDO (CDR $FOUT) (CDR MDO))) ((NULL MDO) '$DONE)
	  (SETQ $FC (CAR MDO))
	  (COND
	    ((MFUNCTION-CALL $FREEOF (TRD-MSYMEVAL $UVAR '$UVAR) $FC)
	       (COND
		 ((MFUNCTION-CALL $FREEOF (TRD-MSYMEVAL $XVAR '$XVAR) $FC)
		    (SETQ $CON (ADD* $CON $FC)))
		 (T (SETQ $QX (ADD* $QX $FC)))))
	    ((MFUNCTION-CALL $FREEOF (TRD-MSYMEVAL $XVAR '$XVAR) $FC)
	       (SETQ $RU (ADD* $RU $FC)))
	    (T (SETQ $REM (ADD* $REM $FC)))))
	(SETQ
	  $FOUT (COND ((LIKE $REM 0) 0)
		      ((LIKE (SIMPLIFY (MFUNCTION-CALL $OPR $REM)) '&+)
			 (MFUNCTION-CALL $LENGTH $REM))
		      (T (SETQ $REM (LIST '(MLIST) $REM)) 1)))
	(COND ((NOT (LIKE $QX 0)) (SETQ $FOUT (ADD* $FOUT 1))
				  (SETQ $QX (ADD* $QX $CON))
				  (SETQ $CON 0)))
	(COND ((NOT (LIKE $RU 0))
		 (SETQ $FOUT (ADD* $FOUT 1)) (SETQ $RU (ADD* $RU $CON))))
	(RETURN (LIST '(MLIST) $FOUT $REM $QX $RU))))
  '$QX '$RU '$REM '$CON))

(DEFPROP $ZEROINT T TRANSLATED)

(ADD2LNC '$ZEROINT $PROPS)

(DEFMTRFUN
  ($ZEROINT $ANY MDEFINE NIL NIL) ($EX) NIL
  (COND ((MFUNCTION-CALL $MAPATOM $EX) $EX)
	((OR (LIKE (SIMPLIFY (MFUNCTION-CALL $OPR $EX)) '%INTEGRATE)
	     (MFUNCTION-CALL $UNFUN (SIMPLIFY (MFUNCTION-CALL $OPR $EX))))
	   0)
	(T (SIMPLIFY (MAP1 (GETOPR '$ZEROINT) $EX)))))

(DEFPROP $VLFRNK T TRANSLATED)

(ADD2LNC '$VLFRNK $PROPS)

(DEFMTRFUN
 ($VLFRNK $ANY MDEFINE NIL NIL) NIL NIL
 ((LAMBDA
     ($INITIAL
       $LOWLIM $UNKLIST $INTEQN $POFX $KIND $FIRSTKIND $DIFFLIST $ICLIST)
   NIL
   (PROG ()
      (SETQ $POFX (TRD-MSYMEVAL $PX '$PX))
      (SETQ $INITIAL T)
      (SETQ $UNKLIST (SETQ $DIFFLIST '((MLIST))))
      (SETQ $KIND '$INCOMPLETE)
      (SETQ
	$FIRSTKIND
	(MFUNCTION-CALL
	  $FREEOF (TRD-MSYMEVAL $PX '$PX) (TRD-MSYMEVAL $EQN '$EQN)))
      (SETQ
	$INTEQN
	(SIMPLIFY (MFUNCTION-CALL $VCONVERT (TRD-MSYMEVAL $EQN '$EQN))))
      (SETQ $ICLIST
	    (LIST '(MLIST)
		  (SIMPLIFY (LIST '(MEQUAL) (TRD-MSYMEVAL $XVAR '$XVAR)
				  (TRD-MSYMEVAL $LOWLIM '$LOWLIM)))))
      (DO (($COUNT 1 (+ 1 $COUNT)))
	  ((> $COUNT
	      (MFUNCTION-CALL $LENGTH (TRD-MSYMEVAL $UNKLIST '$UNKLIST)))
	     '$DONE)
	(COND
	  ((IS-BOOLE-CHECK $FIRSTKIND) (SETQ $FIRSTKIND NIL))
	  (T
	    (COND ((IS-BOOLE-CHECK $INITIAL)
		     (SIMPLIFY (MFUNCTION-CALL $GETICS))))
	    (SETQ
	      $POFX
	      (SIMPLIFY (MFUNCTION-CALL $DIFF (TRD-MSYMEVAL $POFX '$POFX)
					(TRD-MSYMEVAL $XVAR '$XVAR))))))
	(SETQ
	  $DIFFLIST
	  (SIMPLIFY (MFUNCTION-CALL
		      $CONS (TRD-MSYMEVAL $INTEQN '$INTEQN) $DIFFLIST)))
	(SETQ
	  $INTEQN
	  (SIMPLIFY (MFUNCTION-CALL $DIFF (TRD-MSYMEVAL $INTEQN '$INTEQN)
				    (TRD-MSYMEVAL $XVAR '$XVAR))))
	(COND ((MFUNCTION-CALL
		 $FREEOF '%INTEGRATE (TRD-MSYMEVAL $INTEQN '$INTEQN))
		 (RETURN NIL))))
      (SIMPLIFY
	(MFUNCALL
	  '$REMOVE
	  (SIMPLIFY (MFUNCTION-CALL $OPR (TRD-MSYMEVAL $PX '$PX)))
	  '$ATVALUE))
      (COND
	((NOT (MFUNCTION-CALL
		$FREEOF '%INTEGRATE (TRD-MSYMEVAL $INTEQN '$INTEQN)))
	   (SETQ
	     $DIFFLIST
	     (SIMPLIFY
	       (MFUNCTION-CALL
		 $SOLVE $DIFFLIST (TRD-MSYMEVAL $UNKLIST '$UNKLIST))))
	   (COND
	     ((LIKE $DIFFLIST '((MLIST)))
		((LAMBDA (X)
		   (COND
		     ((NULL MCATCH) (DISPLA X)
				    (*MERROR '|THROW not within CATCH|)))
		   (*THROW 'MCATCH X))
		 NIL)))
	   (SETQ $INTEQN
		 (SIMPLIFY
		   (MFUNCALL
		     '$EV (TRD-MSYMEVAL $INTEQN '$INTEQN) $DIFFLIST)))))
      (SETQ $LOWLIM
	    (SIMPLIFY
	      (MFUNCTION-CALL
		$DERIVDEGREE (TRD-MSYMEVAL $INTEQN '$INTEQN)
		(TRD-MSYMEVAL $PX '$PX) (TRD-MSYMEVAL $XVAR '$XVAR))))
      (SETQ
	$ICLIST
	(SIMPLIFY
	  (MFUNCTION-CALL $REVERSE (TRD-MSYMEVAL $ICLIST '$ICLIST))))
      (COND
	((LIKE (TRD-MSYMEVAL $LOWLIM '$LOWLIM) 0)
	   (SETQ $ICLIST '((MLIST)))
	   (SETQ $LOWLIM 3)
	   (COND
	     ((NOT
		(LIKE
		  (SETQ
		    $POFX
		    (SIMPLIFY (MFUNCTION-CALL
				$MYSOLVE (TRD-MSYMEVAL $INTEQN '$INTEQN)
				(TRD-MSYMEVAL $PX '$PX))))
		  '((MLIST))))
		(SETQ $INTEQN
		      (SIMPLIFY ($FIRST (TRD-MSYMEVAL $POFX '$POFX))))
		(SETQ $KIND '((MLIST)))))))
      (COND
	((OR (IS-BOOLE-CHECK (MGRP (TRD-MSYMEVAL $LOWLIM '$LOWLIM) 2))
	     (LIKE
	       (SETQ
		 $POFX
		 (SIMPLIFY
		   (MFUNCTION-CALL $ODE2 (TRD-MSYMEVAL $INTEQN '$INTEQN)
				   (TRD-MSYMEVAL $PX '$PX)
				   (TRD-MSYMEVAL $XVAR '$XVAR))))
	       NIL))
	   (RETURN
	     (SIMPLIFY
	       (MFUNCTION-CALL
		 $PRINTSOLN (TRD-MSYMEVAL $INTEQN '$INTEQN) '$VLFRNK
		 (TRD-MSYMEVAL $ICLIST '$ICLIST) $KIND)))))
      (SETQ
	$POFX
	(SIMPLIFY (MFUNCTION-CALL $RATSIMP (TRD-MSYMEVAL $POFX '$POFX))))
      (COND
	((AND
	   (IS-BOOLE-CHECK $INITIAL)
	   (LIKE
	     (+ (MFUNCTION-CALL $LENGTH (TRD-MSYMEVAL $ICLIST '$ICLIST))
		-1)
	     (TRD-MSYMEVAL $LOWLIM '$LOWLIM))
	   (NOT
	     (LIKE
	       (SETQ
		 $INTEQN
		 ((LAMBDA (ERRCATCH RET)
		    (COND
		      ((NULL
			 (SETQ
			   RET
			   (ERRSET
			     (PROGN
			       (SIMPLIFY
				 (MAPPLY-TR
				   (COND
				     ((LIKE (TRD-MSYMEVAL $LOWLIM '$LOWLIM)
					    1)
					'$IC1)
				     (T '$IC2))
				   (SIMPLIFY
				     (MFUNCTION-CALL
				       $CONS
				       (TRD-MSYMEVAL $POFX '$POFX)
				       (TRD-MSYMEVAL $ICLIST '$ICLIST))))))
			     LISPERRPRINT)))
			 (ERRLFUN1 ERRCATCH)))
		    (CONS '(MLIST) RET))
		  (CONS BINDLIST LOCLIST) NIL))
	       '((MLIST)))))
	   (SETQ
	     $POFX (SIMPLIFY ($FIRST (TRD-MSYMEVAL $INTEQN '$INTEQN))))
	   (SETQ $ICLIST '((MLIST)))))
      (COND
	((AND
	   (LIKE
	     (SIMPLIFY (MFUNCTION-CALL $OPR (TRD-MSYMEVAL $POFX '$POFX)))
	     '&=)
	   (LIKE
	     (SIMPLIFY (MFUNCTION-CALL $LHS (TRD-MSYMEVAL $POFX '$POFX)))
	     (TRD-MSYMEVAL $PX '$PX)))
	   (SETQ $POFX
		 (SIMPLIFY
		   (MFUNCTION-CALL $RHS (TRD-MSYMEVAL $POFX '$POFX))))
	   (SETQ $KIND '((MLIST)))))
      (COND ((AND (LIKE (TRD-MSYMEVAL $ICLIST '$ICLIST) '((MLIST)))
		  (NOT (LIKE $KIND '((MLIST)))))
	       (SETQ $ICLIST 0)))
      (RETURN
	(SIMPLIFY
	  (MFUNCTION-CALL $PRINTSOLN (TRD-MSYMEVAL $POFX '$POFX) '$VLFRNK
			  (TRD-MSYMEVAL $ICLIST '$ICLIST) $KIND)))))
  '$INITIAL '$LOWLIM '$UNKLIST '$INTEQN '$POFX
  '$KIND '$FIRSTKIND '$DIFFLIST '$ICLIST))

(DEFPROP $GETICS T TRANSLATED)

(ADD2LNC '$GETICS $PROPS)

(DEFMTRFUN
 ($GETICS $ANY MDEFINE NIL NIL) NIL NIL
 ((LAMBDA ($VAL $INIT)
   NIL
   (SETQ
     $VAL
     (SIMPLIFY (MFUNCTION-CALL
		 $AT (TRD-MSYMEVAL $INTEQN '$INTEQN)
		 (SIMPLIFY (LIST '(MEQUAL) (TRD-MSYMEVAL $XVAR '$XVAR)
				 (TRD-MSYMEVAL $LOWLIM '$LOWLIM))))))
   (SETQ
     $INIT
     (SIMPLIFY (MFUNCTION-CALL
		 $AT (TRD-MSYMEVAL $POFX '$POFX)
		 (SIMPLIFY (LIST '(MEQUAL) (TRD-MSYMEVAL $XVAR '$XVAR)
				 (TRD-MSYMEVAL $LOWLIM '$LOWLIM))))))
   (SETQ $INIT (SIMPLIFY (MFUNCTION-CALL $MYSOLVE $VAL $INIT)))
   (COND
     ((NOT (LIKE $INIT '((MLIST))))
	(SETQ $INIT (SIMPLIFY ($FIRST $INIT)))
	(SIMPLIFY (MFUNCTION-CALL
		    $ATVALUE (TRD-MSYMEVAL $POFX '$POFX)
		    (SIMPLIFY (LIST '(MEQUAL) (TRD-MSYMEVAL $XVAR '$XVAR)
				    (TRD-MSYMEVAL $LOWLIM '$LOWLIM)))
		    $INIT))
	(SETQ
	  $ICLIST
	  (SIMPLIFY
	    (MFUNCTION-CALL
	      $CONS
	      (SIMPLIFY (LIST '(MEQUAL) (TRD-MSYMEVAL $POFX '$POFX) $INIT))
	      (TRD-MSYMEVAL $ICLIST '$ICLIST)))))
     (T (SETQ $INITIAL NIL))))
  '$VAL '$INIT))

(DEFPROP $VCONVERT T TRANSLATED)

(ADD2LNC '$VCONVERT $PROPS)

(DEFMTRFUN
 ($VCONVERT $ANY MDEFINE NIL NIL) ($FUN) NIL
 (COND
   ((MFUNCTION-CALL $MAPATOM $FUN) $FUN)
   ((NOT (LIKE (SIMPLIFY (MFUNCTION-CALL $OPR $FUN)) '%INTEGRATE))
      (SIMPLIFY (MAP1 (GETOPR '$VCONVERT) $FUN)))
   ((OR (NOT (MFUNCTION-CALL $FREEOF (TRD-MSYMEVAL $XVAR '$XVAR)
			     (SIMPLIFY (MFUNCTION-CALL $INPART $FUN 3))))
	(NOT (LIKE (SIMPLIFY (MFUNCTION-CALL $INPART $FUN 4))
		   (TRD-MSYMEVAL $XVAR '$XVAR))))
      ((LAMBDA (X)
	 (COND
	   ((NULL MCATCH) (DISPLA X) (*MERROR '|THROW not within CATCH|)))
	 (*THROW 'MCATCH X))
       NIL))
   (T
     ((LAMBDA ($INTGR $NEWFUN $INT)
	NIL
	(PROG ()
	    (COND
	      ((LIKE (TRD-MSYMEVAL $LOWLIM '$LOWLIM) '$LOWLIM)
		 (SETQ $LOWLIM (SIMPLIFY (MFUNCTION-CALL $INPART $FUN 3))))
	      ((NOT (LIKE (TRD-MSYMEVAL $LOWLIM '$LOWLIM)
			  (SIMPLIFY (MFUNCTION-CALL $INPART $FUN 3))))
		 (SETQ $INITIAL NIL)))
	    (SETQ
	      $INTGR
	      (SIMPLIFY (MFUNCTION-CALL
			  $SUMFACTORS (SIMPLIFY (MFUNCTION-CALL $ARG $FUN))
			  (SIMPLIFY (MFUNCTION-CALL $INPART $FUN 2)))))
	    (COND
	      ((LIKE $INTGR '((MLIST)))
		 ((LAMBDA (X)
		    (COND
		      ((NULL MCATCH)
			 (DISPLA X) (*MERROR '|THROW not within CATCH|)))
		    (*THROW 'MCATCH X))
		  NIL)))
	    (SETQ $NEWFUN 0)
	    (DO (($TERM) (MDO (CDR $INTGR) (CDR MDO))) ((NULL MDO) '$DONE)
	      (SETQ $TERM (CAR MDO))
	      (SETQ
		$INT
		(SIMPLIFY
		  (PART1
		    (LIST
		      (LIST '(MQUOTE SIMP) (MARRAYREF $TERM 2))
		      (LIST '(MQUOTE SIMP) $FUN) (LIST '(MQUOTE SIMP) 1))
		    T NIL T)))
	      (COND
		((NOT (MFUNCTION-CALL
			$MEMBER $INT (TRD-MSYMEVAL $UNKLIST '$UNKLIST)))
		   (SETQ $UNKLIST
			 (SIMPLIFY (MFUNCTION-CALL
				     $CONS $INT
				     (TRD-MSYMEVAL $UNKLIST '$UNKLIST))))))
	      (SETQ
		$NEWFUN (ADD* $NEWFUN (MUL* (MARRAYREF $TERM 1) $INT))))
	    (RETURN $NEWFUN)))
      '$INTGR '$NEWFUN '$INT))))

(DEFPROP $TRANSFORM T TRANSLATED)

(ADD2LNC '$TRANSFORM $PROPS)

(DEFMTRFUN
 ($TRANSFORM $ANY MDEFINE NIL NIL) NIL NIL
 ((LAMBDA ($TEQNLIST $TRANSLIST $%S $PS $FLAG)
    NIL
    (PROG ()
	 (SETQ
	   $PS
	   (M-TLAMBDA&ENV
	     (($FUN) ($%S)) NIL
	     (SIMPLIFY (MFUNCTION-CALL
			 $LAPLACE $FUN (TRD-MSYMEVAL $XVAR '$XVAR) $%S))))
	 (SETQ $FLAG NIL)
	 (SETQ
	   $TEQNLIST (MAPLIST_TR '$PS (TRD-MSYMEVAL $EQNLIST '$EQNLIST)))
	 (SETQ
	   $TRANSLIST (MAPLIST_TR '$PS (TRD-MSYMEVAL $PXLIST '$PXLIST)))
	 (DO
	   (($SOLN)
	    (MDO
	      (CDR
		(SIMPLIFY (MFUNCTION-CALL $SOLVESYS $TEQNLIST $TRANSLIST)))
	      (CDR MDO)))
	   ((NULL MDO) '$DONE)
	   (SETQ $SOLN (CAR MDO))
	   (COND
	     ((MFUNCTION-CALL $FREEOF '%INTEGRATE '%LAPLACE $SOLN)
		(SETQ $SOLN
		      (MAPLIST_TR
			(M-TLAMBDA&ENV
			  (($FUN) ($%S)) NIL
			  (SIMPLIFY
			    (MFUNCTION-CALL
			      $ILT $FUN $%S (TRD-MSYMEVAL $XVAR '$XVAR))))
			$SOLN))
		(SETQ $PS (MFUNCTION-CALL $FREEOF '%ILT $SOLN))
		(SIMPLIFY (MFUNCTION-CALL
			    $PRINTSOLN $SOLN '$TRANSFORM
			    (COND ((IS-BOOLE-CHECK $PS) '((MLIST))) (T 0))
			    (COND ((IS-BOOLE-CHECK $PS) '((MLIST)))
				  (T '$INCOMPLETE))))
		(SETQ $FLAG
		      (OR (IS-BOOLE-CHECK $FLAG) (IS-BOOLE-CHECK $PS))))))
	 (RETURN $FLAG)))
  '$TEQNLIST '$TRANSLIST '$%S '$PS '$FLAG))

(DEFPROP $COLLOCATE T TRANSLATED)

(ADD2LNC '$COLLOCATE $PROPS)

(DEFMTRFUN
 ($COLLOCATE $ANY MDEFINE NIL NIL) NIL NIL
 ((LAMBDA ($LOWLIM $HIGHLIM $UNKLIST $%C $ELIST $FORM
		   $INCR $POINT $NAME $LISTEQNS $SOLNLIST)
    NIL
    (SIMPLIFY
      (MAPPLY-TR
	'$LOCAL
	(SIMPLIFY (MFUNCTION-CALL
		    $CONS '$%C
		    (MAPLIST_TR '$OPR (TRD-MSYMEVAL $PXLIST '$PXLIST))))))
    (SETQ $LOWLIM '$MINF)
    (SETQ $HIGHLIM '$INF)
    (SIMPLIFY
      (MAP1 (GETOPR '$GETLIMITS) (TRD-MSYMEVAL $EQNLIST '$EQNLIST)))
    (COND ((NOT (IS-BOOLE-CHECK (MGRP (TRD-MSYMEVAL $HIGHLIM '$HIGHLIM)
				      (TRD-MSYMEVAL $LOWLIM '$LOWLIM))))
	     ((LAMBDA (X)
		(COND ((NULL MCATCH)
			 (DISPLA X) (*MERROR '|THROW not within CATCH|)))
		(*THROW 'MCATCH X))
	      NIL)))
    (SETQ $SOLNLIST (SETQ $LISTEQNS (SETQ $UNKLIST '((MLIST)))))
    (DO (($UNK) (MDO (CDR (TRD-MSYMEVAL $PXLIST '$PXLIST)) (CDR MDO)))
	((NULL MDO) '$DONE)
      (SETQ $UNK (CAR MDO))
      (SETQ $NAME (SIMPLIFY (MFUNCTION-CALL $OPR $UNK)))
      (SETQ
	$FORM
	(SIMPLIFY
	  (MFUNCTION-CALL $APPROX $NAME (TRD-MSYMEVAL $NAPPROX '$NAPPROX)
			  (TRD-MSYMEVAL $XVAR '$XVAR))))
      (SIMPLIFY (MFUNCALL '$DEFINE $UNK $FORM))
      (SETQ $SOLNLIST (SIMPLIFY (MFUNCTION-CALL $CONS $FORM $SOLNLIST)))
      (DO (($PARM 0 (+ 1 $PARM)))
	  ((IS-BOOLE-CHECK
	     (MGRP $PARM (ADD* (TRD-MSYMEVAL $NAPPROX '$NAPPROX) -1)))
	     '$DONE)
	(SETQ
	  $UNKLIST
	  (SIMPLIFY (MFUNCTION-CALL
		      $CONS (MARRAYREF (TRD-MSYMEVAL $%C '$%C) $NAME $PARM)
		      (TRD-MSYMEVAL $UNKLIST '$UNKLIST))))))
    (SETQ
      $ELIST
      (SIMPLIFY
	(MFUNCALL
	  '$EV (TRD-MSYMEVAL $EQNLIST '$EQNLIST) '$INTEGRATE '$EXPAND)))
    (COND ((NOT (MFUNCTION-CALL $FREEOF '%INTEGRATE $ELIST))
	     ((LAMBDA (X)
		(COND ((NULL MCATCH)
			 (DISPLA X) (*MERROR '|THROW not within CATCH|)))
		(*THROW 'MCATCH X))
	      NIL)))
    (COND
      ((MFUNCTION-CALL $FREEOF (TRD-MSYMEVAL $XVAR '$XVAR) $ELIST)
	 (SETQ $LISTEQNS $ELIST))
      (T (SETQ $POINT (TRD-MSYMEVAL $LOWLIM '$LOWLIM))
	 (SETQ
	   $INCR
	   (COND
	     ((IS-BOOLE-CHECK (MGRP (TRD-MSYMEVAL $NAPPROX '$NAPPROX) 1))
		(DIV (ADD* (TRD-MSYMEVAL $HIGHLIM '$HIGHLIM)
			   (*MMINUS (TRD-MSYMEVAL $LOWLIM '$LOWLIM)))
		     (ADD* (TRD-MSYMEVAL $NAPPROX '$NAPPROX) -1)))
	     (T 0)))
	 (DO (($I 1 (+ 1 $I)))
	     ((IS-BOOLE-CHECK (MGRP $I (TRD-MSYMEVAL $NAPPROX '$NAPPROX)))
		'$DONE)
	   (SETQ $LISTEQNS
		 (SIMPLIFY
		   (MFUNCTION-CALL
		     $APPEND
		     (SIMPLIFY
		       (MFUNCTION-CALL $SUBSTITUTE $POINT
				       (TRD-MSYMEVAL $XVAR '$XVAR) $ELIST))
		     $LISTEQNS)))
	   (SETQ $POINT (ADD* $POINT $INCR)))))
    (SIMPLIFY
      (MFUNCTION-CALL
	$SOLVEANDSUBST $LISTEQNS (TRD-MSYMEVAL $UNKLIST '$UNKLIST)
	(SIMPLIFY (MFUNCTION-CALL $REVERSE $SOLNLIST)) '$COLLOCATE)))
  '$LOWLIM '$HIGHLIM '$UNKLIST '$%C '$ELIST '$FORM
  '$INCR '$POINT '$NAME '$LISTEQNS '$SOLNLIST))

(DEFPROP $GETLIMITS T TRANSLATED)

(ADD2LNC '$GETLIMITS $PROPS)

(DEFMTRFUN
 ($GETLIMITS $ANY MDEFINE NIL NIL) ($EXPR) NIL
 (COND
   ((NOT (MFUNCTION-CALL $MAPATOM $EXPR))
      (COND
	((NOT (LIKE (SIMPLIFY (MFUNCTION-CALL $OPR $EXPR)) '%INTEGRATE))
	   (DO (($SUB) (MDO (CDR $EXPR) (CDR MDO))) ((NULL MDO) '$DONE)
	     (SETQ $SUB (CAR MDO))
	     (SIMPLIFY (MFUNCTION-CALL $GETLIMITS $SUB))))
	(T ((LAMBDA ($LOW $HIGH)
	      NIL
	      (SETQ $LOW (SIMPLIFY (MFUNCTION-CALL $INPART $EXPR 3)))
	      (SETQ $HIGH (SIMPLIFY (MFUNCTION-CALL $INPART $EXPR 4)))
	      (COND
		((OR (NOT (MFUNCTION-CALL $NUMBERP $LOW))
		     (NOT (MFUNCTION-CALL $NUMBERP $HIGH)))
		   ((LAMBDA (X)
		      (COND
			((NULL MCATCH)
			   (DISPLA X) (*MERROR '|THROW not within CATCH|)))
		      (*THROW 'MCATCH X))
		    NIL)))
	      (SETQ $LOWLIM
		    (MAXIMUM (LIST $LOW (TRD-MSYMEVAL $LOWLIM '$LOWLIM))))
	      (SETQ
		$HIGHLIM
		(MINIMUM (LIST $HIGH (TRD-MSYMEVAL $HIGHLIM '$HIGHLIM)))))
	    '$LOW '$HIGH))))))

(DEFPROP $APPROX T TRANSLATED)

(ADD2LNC '$APPROX $PROPS)

(DEFMTRFUN
  ($APPROX $ANY MDEFINE NIL NIL) ($FUN $NPARMS $VAR) NIL
  (DOSUM (FUNGEN&ENV-FOR-MEVALSUMARG
	   ($FUN $VAR) ($I)
	   (MUL* (MARRAYREF (TRD-MSYMEVAL $%C '$%C) $FUN (ADD* $I -1))
		 (POWER $VAR (ADD* $I -1)))
	   ((MTIMES) (($%C ARRAY) $FUN ((MPLUS) $I ((MMINUS) 1)))
	    ((MEXPT) $VAR ((MPLUS) $I ((MMINUS) 1)))))
	 '$I 1 $NPARMS T))

(DEFPROP $FLFRNK2ND T TRANSLATED)

(ADD2LNC '$FLFRNK2ND $PROPS)

(DEFMTRFUN
  ($FLFRNK2ND $ANY MDEFINE NIL NIL) NIL NIL
  ((LAMBDA ($FRLIST $UNKLIST $UEQNLIST $EQNO $%C)
     NIL
     (SIMPLIFY
       (MAPPLY-TR
	 '$LOCAL
	 (SIMPLIFY (MFUNCTION-CALL
		     $CONS '$%C
		     (MAPLIST_TR '$OPR (TRD-MSYMEVAL $PXLIST '$PXLIST))))))
     (SETQ $UNKLIST (SETQ $UEQNLIST '((MLIST))))
     (SETQ $EQNO 0)
     (SETQ
       $FRLIST (MAPLIST_TR '$FCONVERT (TRD-MSYMEVAL $EQNLIST '$EQNLIST)))
     (MAPLIST_TR '$DEFINE (TRD-MSYMEVAL $PXLIST '$PXLIST) $FRLIST)
     (SETQ
       $UEQNLIST
       (SIMPLIFY
	 (MFUNCALL '$EV (TRD-MSYMEVAL $UEQNLIST '$UEQNLIST) '$INTEGRATE)))
     (SIMPLIFY (MFUNCTION-CALL
		 $SOLVEANDSUBST (TRD-MSYMEVAL $UEQNLIST '$UEQNLIST)
		 (TRD-MSYMEVAL $UNKLIST '$UNKLIST) $FRLIST '$FLFRNK2ND)))
   '$FRLIST '$UNKLIST '$UEQNLIST '$EQNO '$%C))

(DEFPROP $FCONVERT T TRANSLATED)

(ADD2LNC '$FCONVERT $PROPS)

(DEFMTRFUN
 ($FCONVERT $ANY MDEFINE NIL NIL) ($FUN) NIL
 (COND
   ((MFUNCTION-CALL $MAPATOM $FUN) $FUN)
   ((NOT (LIKE (SIMPLIFY (MFUNCTION-CALL $OPR $FUN)) '%INTEGRATE))
      (SIMPLIFY (MAP1 (GETOPR '$FCONVERT) $FUN)))
   ((OR (NOT (MFUNCTION-CALL $FREEOF (TRD-MSYMEVAL $XVAR '$XVAR)
			     (SIMPLIFY (MFUNCTION-CALL $INPART $FUN 3))))
	(NOT (MFUNCTION-CALL $FREEOF (TRD-MSYMEVAL $XVAR '$XVAR)
			     (SIMPLIFY (MFUNCTION-CALL $INPART $FUN 4)))))
      ((LAMBDA (X)
	 (COND
	   ((NULL MCATCH) (DISPLA X) (*MERROR '|THROW not within CATCH|)))
	 (*THROW 'MCATCH X))
       NIL))
   (T
     ((LAMBDA ($NEWFUN $INTGRND)
	NIL
	(PROG ()
	    (SETQ
	      $INTGRND
	      (SIMPLIFY (MFUNCTION-CALL
			  $SUMFACTORS (SIMPLIFY (MFUNCTION-CALL $ARG $FUN))
			  (SIMPLIFY (MFUNCTION-CALL $INPART $FUN 2)))))
	    (COND
	      ((LIKE $INTGRND '((MLIST)))
		 ((LAMBDA (X)
		    (COND
		      ((NULL MCATCH)
			 (DISPLA X) (*MERROR '|THROW not within CATCH|)))
		    (*THROW 'MCATCH X))
		  NIL)))
	    (SETQ $NEWFUN 0)
	    (DO (($TERM) (MDO (CDR $INTGRND) (CDR MDO)))
		((NULL MDO) '$DONE)
	      (SETQ $TERM (CAR MDO))
	      (SETQ $EQNO (ADD* (TRD-MSYMEVAL $EQNO '$EQNO) 1))
	      (SETQ
		$NEWFUN
		(ADD* $NEWFUN (MUL* (MARRAYREF (TRD-MSYMEVAL $%C '$%C)
					       (TRD-MSYMEVAL $EQNO '$EQNO))
				    (MARRAYREF $TERM 1))))
	      (SETQ
		$UEQNLIST
		(SIMPLIFY
		  (MFUNCTION-CALL
		    $CONS
		    (ADD*
		      (MARRAYREF (TRD-MSYMEVAL $%C '$%C)
				 (TRD-MSYMEVAL $EQNO '$EQNO))
		      (*MMINUS
			(SIMPLIFY
			  (PART1
			    (LIST (LIST '(MQUOTE SIMP) (MARRAYREF $TERM 2))
				  (LIST '(MQUOTE SIMP) $FUN)
				  (LIST '(MQUOTE SIMP) 1))
			    T NIL T))))
		    (TRD-MSYMEVAL $UEQNLIST '$UEQNLIST))))
	      (SETQ
		$UNKLIST
		(SIMPLIFY
		  (MFUNCTION-CALL $CONS
				  (MARRAYREF (TRD-MSYMEVAL $%C '$%C)
					     (TRD-MSYMEVAL $EQNO '$EQNO))
				  (TRD-MSYMEVAL $UNKLIST '$UNKLIST)))))
	    (RETURN $NEWFUN)))
      '$NEWFUN '$INTGRND))))

(DEFPROP $TAILOR T TRANSLATED)

(ADD2LNC '$TAILOR $PROPS)

(DEFMTRFUN
 ($TAILOR $ANY MDEFINE NIL NIL) NIL NIL
 ((LAMBDA ($XHAT $UFUN $EQTN $TFUN $NEQNS $VLIST $ORDER $VALUE $FACT)
   NIL
   (SIMPLIFY
     (MAPPLY-TR
       '$LOCAL
       (SIMPLIFY (MFUNCTION-CALL
		   $APPEND (LIST '(MLIST) $UFUN $EQTN $TFUN)
		   (MAPLIST_TR '$OPR (TRD-MSYMEVAL $PXLIST '$PXLIST))))))
   (SIMPLIFY (MAP1 (GETOPR '$GETXHAT) (TRD-MSYMEVAL $EQNLIST '$EQNLIST)))
   (SETQ $NEQNS 0)
   (SETQ $VLIST (TRD-MSYMEVAL $PXLIST '$PXLIST))
   (DO (($EXPR) (MDO (CDR (TRD-MSYMEVAL $EQNLIST '$EQNLIST)) (CDR MDO)))
       ((NULL MDO) '$DONE)
     (SETQ $EXPR (CAR MDO))
     (SETQ $NEQNS (ADD* $NEQNS 1))
     (MARRAYSET $EXPR $EQTN $NEQNS)
     (MARRAYSET (SIMPLIFY ($FIRST $VLIST)) $UFUN $NEQNS)
     (SETQ $VLIST (SIMPLIFY (MFUNCTION-CALL $REST $VLIST)))
     (MARRAYSET
       (SETQ
	 $VALUE
	 (SIMPLIFY (MFUNCTION-CALL $SUBSTITUTE (TRD-MSYMEVAL $XHAT '$XHAT)
				   (TRD-MSYMEVAL $XVAR '$XVAR) $EXPR)))
       $TFUN $NEQNS)
     (SIMPLIFY (MFUNCTION-CALL
		 $ATVALUE (MARRAYREF $UFUN $NEQNS)
		 (SIMPLIFY (LIST '(MEQUAL) (TRD-MSYMEVAL $XVAR '$XVAR)
				 (TRD-MSYMEVAL $XHAT '$XHAT)))
		 $VALUE)))
   (SETQ $FACT 1)
   (SETQ $ORDER (TRD-MSYMEVAL $NAPPROX '$NAPPROX))
   (DO (($I 1 (+ 1 $I)))
       ((IS-BOOLE-CHECK (MGRP $I (TRD-MSYMEVAL $NAPPROX '$NAPPROX)))
	  '$DONE)
    (SETQ $FACT (MUL* $FACT $I))
    (DO (($J 1 (+ 1 $J))) ((IS-BOOLE-CHECK (MGRP $J $NEQNS)) '$DONE)
      (SETQ
	$VALUE
	((LAMBDA (ERRCATCH RET)
	   (COND
	     ((NULL
		(SETQ
		  RET
		  (ERRSET
		    (PROGN
		      (SIMPLIFY (MFUNCTION-CALL $DIFF (MARRAYREF $EQTN $J)
						(TRD-MSYMEVAL $X '$X))))
		    LISPERRPRINT)))
		(ERRLFUN1 ERRCATCH)))
	   (CONS '(MLIST) RET))
	 (CONS BINDLIST LOCLIST) NIL))
      (COND ((LIKE $VALUE '((MLIST))) (RETURN (SETQ $ORDER (+ $I -1)))))
      (MARRAYSET (SIMPLIFY ($FIRST $VALUE)) $EQTN $J)
      (SETQ
	$VALUE
	((LAMBDA (ERRCATCH RET)
	   (COND
	     ((NULL
		(SETQ
		  RET
		  (ERRSET
		    (PROGN
		      (SIMPLIFY
			(MFUNCTION-CALL
			  $RATSIMP
			  (SIMPLIFY
			    (MFUNCTION-CALL
			      $AT (MARRAYREF $EQTN $J)
			      (SIMPLIFY
				(LIST '(MEQUAL) (TRD-MSYMEVAL $XVAR '$XVAR)
				      (TRD-MSYMEVAL $XHAT '$XHAT))))))))
		    LISPERRPRINT)))
		(ERRLFUN1 ERRCATCH)))
	   (CONS '(MLIST) RET))
	 (CONS BINDLIST LOCLIST) NIL))
      (COND ((LIKE $VALUE '((MLIST))) (RETURN (SETQ $ORDER (+ $I -1)))))
      (MARRAYSET
	(SIMPLIFY (MFUNCTION-CALL
		    $DIFF (MARRAYREF $UFUN $J) (TRD-MSYMEVAL $X '$X)))
	$UFUN $J)
      (SETQ $VALUE (SIMPLIFY ($FIRST $VALUE)))
      (SIMPLIFY (MFUNCTION-CALL
		  $ATVALUE (MARRAYREF $UFUN $J)
		  (SIMPLIFY (LIST '(MEQUAL) (TRD-MSYMEVAL $XVAR '$XVAR)
				  (TRD-MSYMEVAL $XHAT '$XHAT)))
		  $VALUE))
      (MARRAYSET
	(ADD*
	  (MARRAYREF $TFUN $J)
	  (DIV
	    (MUL*
	      $VALUE (POWER (ADD* (TRD-MSYMEVAL $X '$X)
				  (*MMINUS (TRD-MSYMEVAL $XHAT '$XHAT)))
			    $I))
	    $FACT))
	$TFUN $J))
    (COND ((NOT (LIKE $ORDER (TRD-MSYMEVAL $NAPPROX '$NAPPROX)))
	     (RETURN NIL))))
   (DO (($I $NEQNS (ADD* -1 $I))) ((IS-BOOLE-CHECK (MLSP $I 1)) '$DONE)
     (SETQ $VLIST
	   (SIMPLIFY (MFUNCTION-CALL $CONS (MARRAYREF $TFUN $I) $VLIST))))
   (SIMPLIFY
     (MFUNCTION-CALL $PRINTSOLN $VLIST '$TAILOR $ORDER
		     (SIMPLIFY (MFUNCTION-CALL $TESTSOLN $VLIST)))))
  '$XHAT '$UFUN '$EQTN '$TFUN '$NEQNS '$VLIST '$ORDER '$VALUE '$FACT))

(DEFPROP $GETXHAT T TRANSLATED)

(ADD2LNC '$GETXHAT $PROPS)

(DEFMTRFUN
 ($GETXHAT $ANY MDEFINE NIL NIL) ($EXPR) NIL
 (COND
   ((MFUNCTION-CALL $MAPATOM $EXPR) NIL)
   ((NOT (LIKE (SIMPLIFY (MFUNCTION-CALL $OPR $EXPR)) '%INTEGRATE))
      (DO (($SUB) (MDO (CDR $EXPR) (CDR MDO))) ((NULL MDO) '$DONE)
	(SETQ $SUB (CAR MDO)) (SIMPLIFY (MFUNCTION-CALL $GETXHAT $SUB))))
   ((LIKE (TRD-MSYMEVAL $XHAT '$XHAT) '$XHAT)
     (SETQ
       $XHAT
       (SIMPLIFY
	 (MFUNCTION-CALL
	   $MYSOLVE
	   (ADD* (SIMPLIFY (MFUNCTION-CALL $INPART $EXPR 3))
		 (*MMINUS (SIMPLIFY (MFUNCTION-CALL $INPART $EXPR 4))))
	   (TRD-MSYMEVAL $XVAR '$XVAR))))
     (COND
       ((LIKE (TRD-MSYMEVAL $XHAT '$XHAT) '((MLIST)))
	  ((LAMBDA (X)
	     (COND ((NULL MCATCH)
		      (DISPLA X) (*MERROR '|THROW not within CATCH|)))
	     (*THROW 'MCATCH X))
	   NIL))
       (T (SETQ $XHAT (SIMPLIFY ($FIRST (TRD-MSYMEVAL $XHAT '$XHAT))))))
     (COND
       ((NOT
	  (LIKE
	    (SIMPLIFY
	      (MFUNCTION-CALL $RATSUBST (TRD-MSYMEVAL $XHAT '$XHAT)
			      (TRD-MSYMEVAL $XVAR '$XVAR)
			      (SIMPLIFY (MFUNCTION-CALL $INPART $EXPR 3))))
	    (TRD-MSYMEVAL $XHAT '$XHAT)))
	  ((LAMBDA (X)
	     (COND ((NULL MCATCH)
		      (DISPLA X) (*MERROR '|THROW not within CATCH|)))
	     (*THROW 'MCATCH X))
	   NIL))))
   ((NOT
      (LIKE
	(SIMPLIFY (MFUNCTION-CALL $SUBSTITUTE (TRD-MSYMEVAL $XHAT '$XHAT)
				  (TRD-MSYMEVAL $XVAR '$XVAR) $EXPR))
	0))
      ((LAMBDA (X)
	 (COND
	   ((NULL MCATCH) (DISPLA X) (*MERROR '|THROW not within CATCH|)))
	 (*THROW 'MCATCH X))
       NIL))))

(MEVAL*
  '((MDEFINE) (($FREDSERIES))
    ((MPROG) ((MLIST) $ORDER $ALPHA $BTA $TOP $BOT $KIND $TVAR $EQTN $KXT)
     ((MSETQ) $EQTN (($FIRST) $EQNLIST))
     ((MSETQ) $ALPHA (($CATCH) (($FINDINT) $EQTN)))
     ((MCOND) ((MEQUAL) $ALPHA NIL) ((MRETURN) NIL) T $FALSE)
     ((MSETQ) $UVAR (($INPART) $ALPHA 2))
     ((MSETQ) $BTA (($LIN) $EQTN $ALPHA))
     ((MCOND) ((MEQUAL) $BTA NIL) ((MRETURN) NIL) T $FALSE)
     ((MSETQ) $KXU
      (($LIN) (($ARG) $ALPHA) (($SUBSTITUTE) $UVAR $XVAR $PX)))
     ((MCOND) ((MEQUAL) $KXU NIL) ((MRETURN) NIL) T $FALSE)
     ((MSETQ) $AX (($INPART) $ALPHA 3))
     ((MSETQ) $BX (($INPART) $ALPHA 4)) ((MSETQ) $FX (($BTA ARRAY) 2))
     ((MCOND) ((MNOTEQUAL) (($KXU ARRAY) 2) 0)
      ((MSETQ) $FX
       ((MPLUS) $FX
	(($INTEGRATE) ((MTIMES) (($BTA ARRAY) 1) (($KXU ARRAY) 2))
	 $UVAR $AX $BX)))
      T $FALSE)
     ((MSETQ) $KXU ((MTIMES) (($KXU ARRAY) 1) (($BTA ARRAY) 1)))
     ((MSETQ) $ORDER $NAPPROX) ((MSETQ) $KIND ((MQUOTE) $APPROXIMATE))
     ((MSETQ) $KXT (($SUBSTITUTE) $TVAR $UVAR $KXU))
     ((MSETQ) $BOT ((MSETQ) $BTA 1))
     ((MSETQ) $TOP ((MSETQ) $ALPHA (($RAT) $KXU $UVAR $XVAR)))
     ((MDO) $I NIL NIL NIL $NAPPROX NIL
      ((MPROGN)
       ((MSETQ) $BTA
	((MQUOTIENT)
	 ((MMINUS)
	  (($INTEGRATE) (($RATSUBST) $UVAR $XVAR $ALPHA) $UVAR $AX $BX))
	 $I))
       ((MSETQ) $ALPHA
	((MPLUS) ((MTIMES) $BTA $KXU)
	 (($INTEGRATE) ((MTIMES) $KXT (($RATSUBST) $TVAR $XVAR $ALPHA))
	  $TVAR $AX $BX)))
       ((MSETQ) $BOT ((MPLUS) $BOT $BTA))
       ((MCOND) ((MEQUAL) $ALPHA 0)
	((MRETURN) ((MSETQ) $KIND ((MLIST)))) T $FALSE)
       ((MSETQ) $TOP ((MPLUS) $TOP $ALPHA))))
     ((MSETQ) $KXT
      ((MPLUS) $FX
       ((MQUOTIENT)
	(($INTEGRATE) ((MTIMES) (($SUBSTITUTE) $UVAR $XVAR $FX) $TOP)
	 $UVAR $AX $BX)
	(($RATDISREP) $BOT))))
     (($PRINTSOLN) $KXT ((MQUOTE) $FREDSERIES) $ORDER $KIND))))

(DEFPROP $NEUMANN T TRANSLATED)

(ADD2LNC '$NEUMANN $PROPS)

(DEFMTRFUN
  ($NEUMANN $ANY MDEFINE NIL NIL) NIL NIL
  ((LAMBDA ($ORDER $NEWGUESS)
     NIL
     (SIMPLIFY
       (MAPPLY-TR
	 '$LOCAL (MAPLIST_TR '$OPR (TRD-MSYMEVAL $PXLIST '$PXLIST))))
     (SETQ $ORDER (TRD-MSYMEVAL $NAPPROX '$NAPPROX))
     (COND
       ((LIKE (TRD-MSYMEVAL $GUESSLIST '$GUESSLIST) '$NONE)
	  (SETQ $GUESSLIST
		(MAPLIST_TR '$ZEROINT (TRD-MSYMEVAL $EQNLIST '$EQNLIST)))))
     (DO (($COUNT 1 (+ 1 $COUNT)))
	 ((IS-BOOLE-CHECK (MGRP $COUNT (TRD-MSYMEVAL $NAPPROX '$NAPPROX)))
	    '$DONE)
       (MAPLIST_TR '$DEFINE (TRD-MSYMEVAL $PXLIST '$PXLIST)
		   (TRD-MSYMEVAL $GUESSLIST '$GUESSLIST))
       (SETQ
	 $NEWGUESS
	 (SIMPLIFY
	   (MFUNCALL '$EV (TRD-MSYMEVAL $EQNLIST '$EQNLIST) '$INTEGRATE)))
       (COND ((NOT (MFUNCTION-CALL $FREEOF '%INTEGRATE $NEWGUESS))
		(RETURN (SETQ $ORDER (+ $COUNT -1)))))
       (SETQ $GUESSLIST (MAPLIST_TR '$RATSIMP $NEWGUESS)))
     (SIMPLIFY
       (MFUNCTION-CALL
	 $PRINTSOLN (TRD-MSYMEVAL $GUESSLIST '$GUESSLIST) '$NEUMANN $ORDER
	 (SIMPLIFY (MFUNCTION-CALL
		     $TESTSOLN (TRD-MSYMEVAL $GUESSLIST '$GUESSLIST))))))
   '$ORDER '$NEWGUESS))

(DEFPROP $FLFRNK1ST T TRANSLATED)

(ADD2LNC '$FLFRNK1ST $PROPS)

(DEFMTRFUN
 ($FLFRNK1ST $ANY MDEFINE NIL NIL) NIL NIL
 ((LAMBDA ($SF $CNT $INTG $FORM $%C $UNKLIST $EQLIST $RES)
    NIL
    (PROG ()
       (MLOCAL $%C)
       (SETQ $CNT (SETQ $FORM 0))
       (SETQ $UNKLIST '((MLIST)))
       (COND ((NOT (MFUNCTION-CALL $FREEOF (TRD-MSYMEVAL $XVAR '$XVAR)
				   (LIST '(MLIST) (TRD-MSYMEVAL $AX '$AX)
					 (TRD-MSYMEVAL $BX '$BX))))
		(RETURN NIL)))
       (SETQ
	 $INTG
	 (SIMPLIFY (MFUNCTION-CALL $SUMFACTORS (TRD-MSYMEVAL $KXU '$KXU)
				   (TRD-MSYMEVAL $UVAR '$UVAR))))
       (DO (($TERM) (MDO (CDR $INTG) (CDR MDO))) ((NULL MDO) '$DONE)
	 (SETQ $TERM (CAR MDO))
	 (SETQ $CNT (ADD* $CNT 1))
	 (SETQ
	   $FORM
	   (ADD* $FORM (MUL* (MARRAYREF $TERM 2)
			     (MARRAYREF (TRD-MSYMEVAL $%C '$%C) $CNT))))
	 (SETQ $UNKLIST
	       (SIMPLIFY (MFUNCTION-CALL
			   $CONS (MARRAYREF (TRD-MSYMEVAL $%C '$%C) $CNT)
			   (TRD-MSYMEVAL $UNKLIST '$UNKLIST)))))
       (SETQ $EQLIST '((MLIST)))
       (SETQ
	 $SF
	 (SIMPLIFY
	   (MFUNCTION-CALL
	     $NUM
	     (SIMPLIFY
	       (MFUNCTION-CALL
		 $RATSIMP
		 (ADD*
		   (SIMPLIFY
		     (MFUNCTION-CALL
		       $INTEGRATE (MUL* (TRD-MSYMEVAL $KXU '$KXU) $FORM)
		       (TRD-MSYMEVAL $UVAR '$UVAR)
		       (TRD-MSYMEVAL $AX '$AX) (TRD-MSYMEVAL $BX '$BX)))
		   (*MMINUS (TRD-MSYMEVAL $FX '$FX)))
		 (TRD-MSYMEVAL $XVAR '$XVAR))))))
       (SETQ $RES 0)
       (COND ((NOT (LIKE (SIMPLIFY (MFUNCTION-CALL $OPR $SF)) '&+))
		(SETQ $SF (LIST '(MLIST) $SF))))
       (DO (($TERM) (MDO (CDR $SF) (CDR MDO))) ((NULL MDO) '$DONE)
	 (SETQ $TERM (CAR MDO))
	 (COND
	   ((LIKE (SIMPLIFY (MFUNCTION-CALL $OPR $TERM)) '&*)
	      (SETQ
		$INTG
		(SIMPLIFY (MFUNCTION-CALL
			    $PARTITION $TERM (TRD-MSYMEVAL $XVAR '$XVAR))))
	      (COND
		((LIKE (MARRAYREF $INTG 2) 1)
		   (SETQ $RES (ADD* $RES $TERM)))
		(T
		  (SETQ $EQLIST
			(SIMPLIFY (MFUNCTION-CALL
				    $CONS (MARRAYREF $INTG 1) $EQLIST))))))
	   ((MFUNCTION-CALL $FREEOF (TRD-MSYMEVAL $XVAR '$XVAR) $TERM)
	      (SETQ $RES (ADD* $RES $TERM)))
	   (T (SIMPLIFY (MFUNCTION-CALL $ERROR '|&ERROR 1|)))))
       (COND
	 ((NOT (LIKE $RES 0))
	    (SETQ
	      $EQLIST (SIMPLIFY (MFUNCTION-CALL $CONS $RES $EQLIST)))))
       (COND ((NOT (LIKE (MFUNCTION-CALL $LENGTH $EQLIST) $CNT))
		(SIMPLIFY (MFUNCTION-CALL $ERROR '|&ERROR 2|))))
       (RETURN
	 (SIMPLIFY
	   (MFUNCTION-CALL
	     $SOLVEANDSUBST $EQLIST (TRD-MSYMEVAL $UNKLIST '$UNKLIST)
	     (SIMPLIFY
	       (MFUNCTION-CALL $SUBSTITUTE (TRD-MSYMEVAL $XVAR '$XVAR)
			       (TRD-MSYMEVAL $UVAR '$UVAR) $FORM))
	     '$FLFRNK1ST)))))
  '$SF '$CNT '$INTG '$FORM '$%C '$UNKLIST '$EQLIST '$RES))

(DEFPROP $MYDIVIDE T TRANSLATED)

(ADD2LNC '$MYDIVIDE $PROPS)

(DEFMTRFUN
  ($MYDIVIDE $ANY MDEFINE NIL NIL) ($SOME $PEACE $VAR) NIL
  ((LAMBDA ($RES $ONE $TWO)
     NIL
     (PROG ()
	  (SETQ $ONE (SETQ $TWO 0))
	  (COND ((NOT (LIKE (SIMPLIFY (MFUNCTION-CALL $OPR $SOME)) '&+))
		   (SETQ $SOME (LIST '(MLIST) $SOME))))
	  (DO (($PRT) (MDO (CDR $SOME) (CDR MDO))) ((NULL MDO) '$DONE)
	    (SETQ $PRT (CAR MDO))
	    (SETQ $RES (SIMPLIFY (MFUNCTION-CALL $QUOTIENT $PRT $PEACE)))
	    (COND
	      ((AND (NOT (LIKE $RES 0)) (MFUNCTION-CALL $FREEOF $VAR $RES))
		 (SETQ $ONE (ADD* $ONE $RES)))
	      (T (SETQ $TWO (ADD* $TWO $PRT)))))
	  (RETURN (LIST '(MLIST) $ONE $TWO))))
   '$RES '$ONE '$TWO))

(DEFPROP $ABEL T TRANSLATED)

(ADD2LNC '$ABEL $PROPS)

(DEFMTRFUN
 ($ABEL $ANY MDEFINE NIL NIL) NIL NIL
 ((LAMBDA ($POWER $DEN $FUN)
    NIL
    (COND
      ((OR
	 (NOT
	   (MFUNCTION-CALL
	     $FREEOF (TRD-MSYMEVAL $XVAR '$XVAR) (TRD-MSYMEVAL $AX '$AX)))
	 (NOT (LIKE (TRD-MSYMEVAL $BX '$BX) (TRD-MSYMEVAL $XVAR '$XVAR)))
	 (NOT
	   (LIKE (SIMPLIFY (MFUNCTION-CALL $OPR (TRD-MSYMEVAL $KXU '$KXU)))
		 '&^)))
	 ((LAMBDA (X)
	    (COND ((NULL MCATCH)
		     (DISPLA X) (*MERROR '|THROW not within CATCH|)))
	    (*THROW 'MCATCH X))
	  NIL)))
    (SETQ
      $POWER
      (*MMINUS
	(SIMPLIFY (MFUNCTION-CALL $INPART (TRD-MSYMEVAL $KXU '$KXU) 2))))
    (SETQ $DEN
	  (SIMPLIFY (MFUNCTION-CALL $INPART (TRD-MSYMEVAL $KXU '$KXU) 1)))
    (COND
      ((OR
	 (NOT (MFUNCTION-CALL $FREEOF (TRD-MSYMEVAL $UVAR '$UVAR) $POWER))
	 (NOT (LIKE (SIMPLIFY (MFUNCTION-CALL $OPR $DEN)) '&+)))
	 ((LAMBDA (X)
	    (COND ((NULL MCATCH)
		     (DISPLA X) (*MERROR '|THROW not within CATCH|)))
	    (*THROW 'MCATCH X))
	  NIL)))
    (SETQ $FUN
	  (SIMPLIFY
	    (MFUNCTION-CALL $PARTITION $DEN (TRD-MSYMEVAL $UVAR '$UVAR))))
    (COND
      ((OR
	 (NOT (MFUNCTION-CALL
		$FREEOF (TRD-MSYMEVAL $XVAR '$XVAR) (MARRAYREF $FUN 2)))
	 (NOT
	   (LIKE
	     (SIMPLIFY
	       (MFUNCTION-CALL
		 $RATSIMP
		 (ADD* (SIMPLIFY
			 (MFUNCTION-CALL
			   $SUBSTITUTE (TRD-MSYMEVAL $UVAR '$UVAR)
			   (TRD-MSYMEVAL $XVAR '$XVAR) (MARRAYREF $FUN 1)))
		       (MARRAYREF $FUN 2))))
	     0)))
	 ((LAMBDA (X)
	    (COND ((NULL MCATCH)
		     (DISPLA X) (*MERROR '|THROW not within CATCH|)))
	    (*THROW 'MCATCH X))
	  NIL)))
    (COND
      ((OR
	 (NOT (LIKE (SIMPLIFY (MFUNCTION-CALL $SIGN $POWER)) '$POS))
	 (NOT (LIKE
		(SIMPLIFY (MFUNCTION-CALL $SIGN (ADD* $POWER -1))) '$NEG)))
	 ((LAMBDA (X)
	    (COND ((NULL MCATCH)
		     (DISPLA X) (*MERROR '|THROW not within CATCH|)))
	    (*THROW 'MCATCH X))
	  NIL)))
    (SETQ
      $FUN
      (SIMPLIFY
	(MFUNCTION-CALL
	  $INTEGRATE
	  (MUL*
	    (SIMPLIFY (MFUNCTION-CALL $DIFF (*MMINUS (MARRAYREF $FUN 2))
				      (TRD-MSYMEVAL $UVAR '$UVAR)))
	    (SIMPLIFY
	      (MFUNCTION-CALL
		$SUBSTITUTE (TRD-MSYMEVAL $UVAR '$UVAR)
		(TRD-MSYMEVAL $XVAR '$XVAR) (TRD-MSYMEVAL $FX '$FX)))
	    (POWER $DEN (ADD* $POWER -1)))
	  (TRD-MSYMEVAL $UVAR '$UVAR)
	  (TRD-MSYMEVAL $AX '$AX) (TRD-MSYMEVAL $BX '$BX))))
    (SETQ
      $FUN
      (MUL* (DIV (SIMPLIFY (LIST '(%SIN) (MUL* '$%PI $POWER))) '$%PI)
	    (SIMPLIFY
	      (MFUNCTION-CALL $DIFF $FUN (TRD-MSYMEVAL $XVAR '$XVAR)))))
    (SIMPLIFY
      (MFUNCTION-CALL $PRINTSOLN $FUN '$ABEL '((MLIST)) '((MLIST)))))
  '$POWER '$DEN '$FUN))

(DEFPROP $FIRSTKINDSERIES T TRANSLATED)

(ADD2LNC '$FIRSTKINDSERIES $PROPS)

(DEFMTRFUN
  ($FIRSTKINDSERIES $ANY MDEFINE NIL NIL) NIL NIL
  ((LAMBDA ($KIND $ORDER $CORRECTION $TRIAL)
     NIL
     (SIMPLIFY
       (MFUNCALL
	 '$LOCAL (SIMPLIFY (MFUNCTION-CALL $OPR (TRD-MSYMEVAL $PX '$PX)))))
     (SETQ $KIND '$APPROXIMATE)
     (SETQ $ORDER (TRD-MSYMEVAL $NAPPROX '$NAPPROX))
     (SETQ
       $TRIAL
       (COND
	 ((LIKE (TRD-MSYMEVAL $GUESS '$GUESS) '$NONE)
	    (SIMPLIFY (MFUNCTION-CALL $ZEROINT (TRD-MSYMEVAL $EQN '$EQN))))
	 (T (TRD-MSYMEVAL $GUESS '$GUESS))))
     (DO (($I 1 (+ 1 $I)))
	 ((IS-BOOLE-CHECK (MGRP $I (TRD-MSYMEVAL $NAPPROX '$NAPPROX)))
	    '$DONE)
       (SIMPLIFY (MFUNCALL '$DEFINE (TRD-MSYMEVAL $PX '$PX) $TRIAL))
       (SETQ
	 $CORRECTION
	 (SIMPLIFY (MFUNCALL '$EV (TRD-MSYMEVAL $EQN '$EQN) '$INTEGRATE)))
       (COND ((NOT (MFUNCTION-CALL $FREEOF '%INTEGRATE $CORRECTION))
		(RETURN (SETQ $ORDER (+ $I -1)))))
       (COND
	 ((LIKE
	    (SETQ
	      $CORRECTION (SIMPLIFY (MFUNCTION-CALL $RATSIMP $CORRECTION)))
	    0)
	    (RETURN (SETQ $KIND '((MLIST))))))
       (SETQ
	 $TRIAL
	 (SIMPLIFY
	   (MFUNCTION-CALL $RATSIMP (ADD* $TRIAL (*MMINUS $CORRECTION))))))
     (SIMPLIFY
       (MFUNCTION-CALL $PRINTSOLN $TRIAL '$FIRSTKINDSERIES $ORDER $KIND)))
   '$KIND '$ORDER '$CORRECTION '$TRIAL))

(SETQ ^W NIL)

(compile-forms-to-compile-queue)

