;;; -*- Mode: Lisp; Package: Macsyma -*-
;;; Translated code for LMIVAX::MAX$DISK:[SHARE]VECT.MC;14
;;; Written on 10/01/1984 03:48:38, 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:[SHARE]VECT.MC;14")

;;; General declarations required for translated MACSYMA code.

(DECLARE
  (FIXNUM $DIMENSION $DIMENIMBED $TRYLENGTH $BESTLENGTH)
  (SPECIAL
    $POTENTIALZEROLOC $DOTDISTRIB $EXPANDFLAGS $DOTSCRULES $DOTASSOC
    $DOTEXPTSIMP $INFLAG $EXPN $PIECE $JACOBIAN $FIRSTCROSSSCALAR
    $EXPANDCROSSPLUS $EXPANDCROSSCROSS $EXPANDCROSS $EXPANDLAPLACIANPROD
    $EXPANDLAPLACIANTODIVGRAD $EXPANDCURLCURL $EXPANDDIVPROD
    $EXPANDGRADPROD $EXPANDPROD $EXPANDLAPLACIANPLUS $EXPANDLAPLACIAN
    $EXPANDCURLPLUS $EXPANDCURL $EXPANDDIVPLUS $EXPANDDIV $EXPANDGRADPLUS
    $EXPANDPLUS $EXPANDGRAD $EXPANDDOTPLUS $EXPANDDOT $EXPANDALL $SF
    $SFPROD $BESTLENGTH $TRYLENGTH $DIMENIMBED $DIMENSION $COORDINATES
    $TR_BOUND_FUNCTION_APPLYP $VTRUE $TTRUE $ETRUE $LESSP $SCALARM))

(DECLARE (SPECIAL $SCALARM))

(DECLARE (SPECIAL $LESSP))

(DECLARE (SPECIAL $ETRUE))

(DECLARE (SPECIAL $TTRUE))

(DECLARE (SPECIAL $VTRUE))

(DECLARE (SPECIAL $COORDINATES))

(DECLARE (SPECIAL $DIMENSION))

(DECLARE (SPECIAL $DIMENIMBED))

(DECLARE (SPECIAL $TRYLENGTH))

(DECLARE (SPECIAL $BESTLENGTH))

(DECLARE (SPECIAL $SFPROD))

(DECLARE (SPECIAL $SF))

(DECLARE (SPECIAL $EXPANDALL))

(DECLARE (SPECIAL $EXPANDDOT))

(DECLARE (SPECIAL $EXPANDDOTPLUS))

(DECLARE (SPECIAL $EXPANDGRAD))

(DECLARE (SPECIAL $EXPANDPLUS))

(DECLARE (SPECIAL $EXPANDGRADPLUS))

(DECLARE (SPECIAL $EXPANDDIV))

(DECLARE (SPECIAL $EXPANDDIVPLUS))

(DECLARE (SPECIAL $EXPANDCURL))

(DECLARE (SPECIAL $EXPANDCURLPLUS))

(DECLARE (SPECIAL $EXPANDLAPLACIAN))

(DECLARE (SPECIAL $EXPANDLAPLACIANPLUS))

(DECLARE (SPECIAL $EXPANDPROD))

(DECLARE (SPECIAL $EXPANDGRADPROD))

(DECLARE (SPECIAL $EXPANDDIVPROD))

(DECLARE (SPECIAL $EXPANDCURLCURL))

(DECLARE (SPECIAL $EXPANDLAPLACIANTODIVGRAD))

(DECLARE (SPECIAL $EXPANDLAPLACIANPROD))

(DECLARE (SPECIAL $EXPANDCROSS))

(DECLARE (SPECIAL $EXPANDCROSSCROSS))

(DECLARE (SPECIAL $EXPANDCROSSPLUS))

(DECLARE (SPECIAL $FIRSTCROSSSCALAR))

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

(DEF-MTRVAR $JACOBIAN '$JACOBIAN 1)

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

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

(DEF-MTRVAR $PIECE '$PIECE 1)

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

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

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

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

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

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

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

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

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

(DECLARE (SPECIAL $EXPANDFLAGS))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

(DECLARE (SPECIAL $POTENTIALZEROLOC))

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

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

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

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

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

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

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


(SIMPLIFY (MFUNCTION-CALL $HERALD_PACKAGE '$VECT))

(SIMPLIFY (MFUNCTION-CALL $PUT '$VECT T '$VERSION))

((PROGN 'COMPILE
	(PROGN 'COMPILE (MEVAL* '(($MODEDECLARE) $SCALARM $ANY))
	       (MEVAL* '(($DECLARE) $SCALARM $SPECIAL))
	       NIL (DEF-MTRVAR $SCALARM '$SCALARM))
	(PROGN 'COMPILE (MEVAL* '(($MODEDECLARE) $LESSP $ANY))
	       (MEVAL* '(($DECLARE) $LESSP $SPECIAL))
	       NIL (DEF-MTRVAR $LESSP '$LESSP))
	(PROGN 'COMPILE (MEVAL* '(($MODEDECLARE) $ETRUE $ANY))
	       (MEVAL* '(($DECLARE) $ETRUE $SPECIAL))
	       NIL (DEF-MTRVAR $ETRUE '$ETRUE))
	(PROGN 'COMPILE (MEVAL* '(($MODEDECLARE) $TTRUE $ANY))
	       (MEVAL* '(($DECLARE) $TTRUE $SPECIAL))
	       NIL (DEF-MTRVAR $TTRUE '$TTRUE))
	(PROGN 'COMPILE (MEVAL* '(($MODEDECLARE) $VTRUE $ANY))
	       (MEVAL* '(($DECLARE) $VTRUE $SPECIAL))
	       NIL (DEF-MTRVAR $VTRUE '$VTRUE))
	(PROGN 'COMPILE)))

(SETQ $TR_BOUND_FUNCTION_APPLYP NIL)

(MEVAL* '(($INFIX) &~ 134 133 $EXPR $EXPR $EXPR))

(MEVAL*
  '(($DECLARE) ((MLIST) &. $ORDER) $COMMUTATIVE $ORDERN $NARY
    ((MLIST) &GRAD &DIV &CURL &LAPLACIAN) $OUTATIVE &CURL $NONSCALAR))

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

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

(DEF-MTRVAR $COORDINATES '((MLIST) $X $Y $Z))

(MEVAL* '(($MODEDECLARE) $DIMENSION $FIXNUM))

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

(DEFPROP $DIMENSION ASSIGN-MODE-CHECK ASSIGN)

(DEF-MTRVAR $DIMENSION 3)

(MEVAL* '(($MODEDECLARE) $DIMENIMBED $FIXNUM))

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

(DEFPROP $DIMENIMBED ASSIGN-MODE-CHECK ASSIGN)

(DEF-MTRVAR $DIMENIMBED 1)

(MEVAL* '(($MODEDECLARE) $TRYLENGTH $FIXNUM))

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

(DEFPROP $TRYLENGTH ASSIGN-MODE-CHECK ASSIGN)

(DEF-MTRVAR $TRYLENGTH 1)

(MEVAL* '(($MODEDECLARE) $BESTLENGTH $FIXNUM))

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

(DEFPROP $BESTLENGTH ASSIGN-MODE-CHECK ASSIGN)

(DEF-MTRVAR $BESTLENGTH 1)

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

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

(DEF-MTRVAR $SFPROD 1)

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

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

(DEFPROP $SF ASSIGN-MODE-CHECK ASSIGN)

(DEF-MTRVAR $SF (LIST '(MLIST) 1 1 1))

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

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

(DEFPROP $EXPANDALL ASSIGN-MODE-CHECK ASSIGN)

(DEF-MTRVAR $EXPANDALL T)

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

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

(DEFPROP $EXPANDDOT ASSIGN-MODE-CHECK ASSIGN)

(DEF-MTRVAR $EXPANDDOT T)

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

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

(DEFPROP $EXPANDDOTPLUS ASSIGN-MODE-CHECK ASSIGN)

(DEF-MTRVAR $EXPANDDOTPLUS T)

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

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

(DEFPROP $EXPANDGRAD ASSIGN-MODE-CHECK ASSIGN)

(DEF-MTRVAR $EXPANDGRAD T)

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

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

(DEFPROP $EXPANDPLUS ASSIGN-MODE-CHECK ASSIGN)

(DEF-MTRVAR $EXPANDPLUS T)

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

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

(DEFPROP $EXPANDALL ASSIGN-MODE-CHECK ASSIGN)

(DEF-MTRVAR $EXPANDALL T)

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

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

(DEFPROP $EXPANDGRADPLUS ASSIGN-MODE-CHECK ASSIGN)

(DEF-MTRVAR $EXPANDGRADPLUS T)

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

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

(DEFPROP $EXPANDDIV ASSIGN-MODE-CHECK ASSIGN)

(DEF-MTRVAR $EXPANDDIV T)

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

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

(DEFPROP $EXPANDDIVPLUS ASSIGN-MODE-CHECK ASSIGN)

(DEF-MTRVAR $EXPANDDIVPLUS T)

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

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

(DEFPROP $EXPANDCURL ASSIGN-MODE-CHECK ASSIGN)

(DEF-MTRVAR $EXPANDCURL T)

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

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

(DEFPROP $EXPANDCURLPLUS ASSIGN-MODE-CHECK ASSIGN)

(DEF-MTRVAR $EXPANDCURLPLUS T)

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

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

(DEFPROP $EXPANDLAPLACIAN ASSIGN-MODE-CHECK ASSIGN)

(DEF-MTRVAR $EXPANDLAPLACIAN T)

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

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

(DEFPROP $EXPANDLAPLACIANPLUS ASSIGN-MODE-CHECK ASSIGN)

(DEF-MTRVAR $EXPANDLAPLACIANPLUS T)

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

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

(DEFPROP $EXPANDPROD ASSIGN-MODE-CHECK ASSIGN)

(DEF-MTRVAR $EXPANDPROD T)

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

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

(DEFPROP $EXPANDGRADPROD ASSIGN-MODE-CHECK ASSIGN)

(DEF-MTRVAR $EXPANDGRADPROD T)

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

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

(DEFPROP $EXPANDDIVPROD ASSIGN-MODE-CHECK ASSIGN)

(DEF-MTRVAR $EXPANDDIVPROD T)

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

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

(DEFPROP $EXPANDCURLCURL ASSIGN-MODE-CHECK ASSIGN)

(DEF-MTRVAR $EXPANDCURLCURL T)

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

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

(DEFPROP $EXPANDLAPLACIANTODIVGRAD ASSIGN-MODE-CHECK ASSIGN)

(DEF-MTRVAR $EXPANDLAPLACIANTODIVGRAD T)

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

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

(DEFPROP $EXPANDLAPLACIANPROD ASSIGN-MODE-CHECK ASSIGN)

(DEF-MTRVAR $EXPANDLAPLACIANPROD T)

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

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

(DEFPROP $EXPANDCROSS ASSIGN-MODE-CHECK ASSIGN)

(DEF-MTRVAR $EXPANDCROSS T)

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

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

(DEFPROP $EXPANDCROSSCROSS ASSIGN-MODE-CHECK ASSIGN)

(DEF-MTRVAR $EXPANDCROSSCROSS T)

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

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

(DEFPROP $EXPANDCROSSPLUS ASSIGN-MODE-CHECK ASSIGN)

(DEF-MTRVAR $EXPANDCROSSPLUS T)

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

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

(DEFPROP $FIRSTCROSSSCALAR ASSIGN-MODE-CHECK ASSIGN)

(DEF-MTRVAR $FIRSTCROSSSCALAR T)

(DEFPROP $EV_DIFF T TRANSLATED)

(ADD2LNC '$EV_DIFF $PROPS)

(DEFMTRFUN ($EV_DIFF $ANY MDEFINE NIL NIL) ($X) NIL
	   (SIMPLIFY (MFUNCALL '$EV $X '$DIFF)))

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

(DEFPROP $SCALEFACTORS T TRANSLATED)

(ADD2LNC '$SCALEFACTORS $PROPS)

(DEFMTRFUN
 ($SCALEFACTORS $ANY MDEFINE NIL NIL) ($TRANSFORMATION) NIL
 ((LAMBDA ()
   NIL
   (COND
     ((MFUNCTION-CALL $LISTP (SIMPLIFY ($FIRST $TRANSFORMATION)))
	(SETQ
	  $COORDINATES (SIMPLIFY (MFUNCTION-CALL $REST $TRANSFORMATION)))
	(SETQ $TRANSFORMATION (SIMPLIFY ($FIRST $TRANSFORMATION))))
     (T (SETQ $COORDINATES
	      (SIMPLIFY (MFUNCTION-CALL $LISTOFVARS $TRANSFORMATION)))))
   ((LAMBDA (|tr-gensym~16|)
      (PROGN (ASSIGN-MODE-CHECK '$DIMENSION |tr-gensym~16|)
	     (SETQ $DIMENSION |tr-gensym~16|)))
    (MFUNCTION-CALL $LENGTH (TRD-MSYMEVAL $COORDINATES '$COORDINATES)))
   ((LAMBDA (|tr-gensym~17|)
      (PROGN (ASSIGN-MODE-CHECK '$DIMENIMBED |tr-gensym~17|)
	     (SETQ $DIMENIMBED |tr-gensym~17|)))
    (MFUNCTION-CALL $LENGTH $TRANSFORMATION))
   (DO (($ROW 1 (+ 1 $ROW))) ((> $ROW (TRD-MSYMEVAL $DIMENSION 0)) '$DONE)
     (DO (($COL 1 (+ 1 $COL)))
	 ((> $COL (TRD-MSYMEVAL $DIMENIMBED 0)) '$DONE)
       (MARRAYSET
	 (SIMPLIFY
	   (MFUNCTION-CALL
	     $TRIGSIMP
	     (SIMPLIFY
	       (MFUNCTION-CALL
		 $RATSIMP
		 (SIMPLIFY
		   (MFUNCTION-CALL
		     $DIFF (MARRAYREF $TRANSFORMATION $COL)
		     (MARRAYREF (TRD-MSYMEVAL $COORDINATES '$COORDINATES)
				$ROW)))))))
	 (TRD-MSYMEVAL $JACOBIAN '$JACOBIAN) $ROW $COL)))
   (SETQ $SFPROD 1)
   (DO (($ROW 1 (+ 1 $ROW))) ((> $ROW (TRD-MSYMEVAL $DIMENSION 0)) '$DONE)
    (DO (($COL 1 (+ 1 $COL))) ((> $COL (+ $ROW -1)) '$DONE)
     (MARRAYSET (SIMPLIFY (MFUNCTION-CALL $GCOV $ROW $COL))
		(TRD-MSYMEVAL $SF '((MLIST))) $ROW)
     (COND
      ((NOT (LIKE (MARRAYREF (TRD-MSYMEVAL $SF '((MLIST))) $ROW) 0))
       (SIMPLIFY
	(MFUNCTION-CALL
	 $PRINT
	 '|&WARNING: COORDINATE SYSTEM IS NONORTHOGONAL UNLESS FOLLOWING SIMPLIFIES TO ZERO:|
	 (MARRAYREF (TRD-MSYMEVAL $SF '((MLIST))) $ROW))))))
    (MARRAYSET
      (SIMPLIFY
	(MFUNCTION-CALL
	  $RADCAN
	  (SIMPLIFY
	    (LIST '(%SQRT) (SIMPLIFY (MFUNCTION-CALL $GCOV $ROW $ROW))))))
      (TRD-MSYMEVAL $SF '((MLIST))) $ROW)
    (SETQ
      $SFPROD (MUL* (TRD-MSYMEVAL $SFPROD '$SFPROD)
		    (MARRAYREF (TRD-MSYMEVAL $SF '((MLIST))) $ROW)))))))

(DEFPROP $GCOV T TRANSLATED)

(ADD2LNC '$GCOV $PROPS)

(DEFMTRFUN
 ($GCOV $ANY MDEFINE NIL NIL) ($II $JJ) NIL
 (SIMPLIFY
  (MFUNCTION-CALL
    $TRIGSIMP
    (SIMPLIFY
      (MFUNCTION-CALL
	$RATSIMP
	((LAMBDA (|0| N)
	   (COND
	     ((NOT (< N |0|))
		(DO
		  (($KK |0| (1+ $KK))
		   (SUM0009
		     0
		     (ADD*
		       SUM0009
		       (MUL* (MARRAYREF
			       (TRD-MSYMEVAL $JACOBIAN '$JACOBIAN) $II $KK)
			     (MARRAYREF (TRD-MSYMEVAL $JACOBIAN '$JACOBIAN)
					$JJ $KK)))))
		  ((< N $KK) SUM0009)))
	     ((= N (1- |0|)) 0)
	     (T (INTERVAL-ERROR '$SUM |0| N))))
	 1 (TRD-MSYMEVAL $DIMENIMBED 0)))))))

(DEFPROP $EXPRESS1 T TRANSLATED)

(ADD2LNC '$EXPRESS1 $PROPS)

(DEFMTRFUN
 ($EXPRESS1 $ANY MDEFINE NIL NIL) ($EXPN) NIL
 ((LAMBDA ($ANS)
   NIL
   (PROG ()
     (COND
       ((MFUNCTION-CALL $MAPATOM $EXPN)
	  (COND
	    ((MFUNCTION-CALL $NONSCALARP $EXPN)
	       (SETQ $ANS '((MLIST)))
	       (DO (($JJ (TRD-MSYMEVAL $DIMENSION 0) (+ -1 $JJ)))
		   ((< $JJ 1) '$DONE)
		 (SETQ $ANS
		       (SIMPLIFY
			 (MFUNCTION-CALL
			   $CONS
			   (MARRAYREF
			     $EXPN
			     (MARRAYREF
			       (TRD-MSYMEVAL $COORDINATES '$COORDINATES)
			       $JJ))
			   $ANS))))
	       (RETURN $ANS))
	    (T (RETURN $EXPN)))))
     (SETQ $EXPN (SIMPLIFY (MAP1 (GETOPR '$EXPRESS1) $EXPN)))
     (COND ((OR (MFUNCTION-CALL $MAPATOM $EXPN)
		(MFUNCTION-CALL $LISTP $EXPN))
	      (RETURN $EXPN)))
     (COND
       ((LIKE (SIMPLIFY (MFUNCTION-CALL $INPART $EXPN 0)) '&GRAD)
	  (SETQ $ANS '((MLIST)))
	  (SETQ $EXPN (SIMPLIFY (MFUNCTION-CALL $INPART $EXPN 1)))
	  (DO (($JJ (TRD-MSYMEVAL $DIMENSION 0) (+ -1 $JJ)))
	      ((< $JJ 1) '$DONE)
	    (SETQ
	      $ANS
	      (SIMPLIFY
		(MFUNCTION-CALL
		  $CONS
		  (DIV
		    (SIMPLIFY
		      (LIST '(%DERIVATIVE) $EXPN
			    (MARRAYREF
			      (TRD-MSYMEVAL $COORDINATES '$COORDINATES)
			      $JJ)))
		    (MARRAYREF (TRD-MSYMEVAL $SF '((MLIST))) $JJ))
		  $ANS))))
	  (RETURN $ANS)))
     (COND
       ((LIKE (TRD-MSYMEVAL $PIECE '$PIECE) '&DIV)
	 (SETQ $EXPN (SIMPLIFY (MFUNCTION-CALL $INPART $EXPN 1)))
	 (COND
	   ((NOT (MFUNCTION-CALL $LISTP $EXPN))
	      (SIMPLIFY (MFUNCTION-CALL
			  $ERROR '|&DIV CALLED ON SCALAR ARG:| $EXPN))))
	 (RETURN
	   (DIV
	     ((LAMBDA (|0| N)
		(COND
		  ((NOT (< N |0|))
		     (DO
		       (($JJ |0| (1+ $JJ))
			(SUM0010
			  0
			  (ADD*
			    SUM0010
			    (SIMPLIFY
			      (LIST
				'(%DERIVATIVE)
				(DIV
				  (MUL* (TRD-MSYMEVAL $SFPROD '$SFPROD)
					(MARRAYREF $EXPN $JJ))
				  (MARRAYREF (TRD-MSYMEVAL $SF '((MLIST)))
					     $JJ))
				(MARRAYREF (TRD-MSYMEVAL
					     $COORDINATES '$COORDINATES)
					   $JJ))))))
		       ((< N $JJ) SUM0010)))
		  ((= N (1- |0|)) 0)
		  (T (INTERVAL-ERROR '$SUM |0| N))))
	      1 (TRD-MSYMEVAL $DIMENSION 0))
	     (TRD-MSYMEVAL $SFPROD '$SFPROD)))))
     (COND
       ((LIKE (TRD-MSYMEVAL $PIECE '$PIECE) '&LAPLACIAN)
	 (RETURN
	   (DIV
	     ((LAMBDA (|0| N)
		(COND
		  ((NOT (< N |0|))
		     (DO
		       (($JJ |0| (1+ $JJ))
			(SUM0011
			  0
			  (ADD*
			    SUM0011
			    (SIMPLIFY
			      (LIST
				'(%DERIVATIVE)
				(DIV
				  (MUL*
				    (TRD-MSYMEVAL $SFPROD '$SFPROD)
				    (SIMPLIFY
				      (LIST
					'(%DERIVATIVE)
					(SIMPLIFY
					  (MFUNCTION-CALL $INPART $EXPN 1))
					(MARRAYREF
					  (TRD-MSYMEVAL $COORDINATES
							'$COORDINATES)
					  $JJ))))
				  (POWER (MARRAYREF
					   (TRD-MSYMEVAL $SF '((MLIST)))
					   $JJ)
					 2))
				(MARRAYREF (TRD-MSYMEVAL
					     $COORDINATES '$COORDINATES)
					   $JJ))))))
		       ((< N $JJ) SUM0011)))
		  ((= N (1- |0|)) 0)
		  (T (INTERVAL-ERROR '$SUM |0| N))))
	      1 (TRD-MSYMEVAL $DIMENSION 0))
	     (TRD-MSYMEVAL $SFPROD '$SFPROD)))))
     (COND
       ((LIKE (TRD-MSYMEVAL $PIECE '$PIECE) '&CURL)
	 (SETQ $EXPN (SIMPLIFY (MFUNCTION-CALL $INPART $EXPN 1)))
	 (COND
	   ((MFUNCTION-CALL $LISTP $EXPN)
	     (COND
	       ((= (MFUNCTION-CALL $LENGTH $EXPN) 2)
		  (RETURN
		    (DIV
		      (DIV
			(ADD*
			  (SIMPLIFY
			    (LIST
			      '(%DERIVATIVE)
			      (MUL* (MARRAYREF
				      (TRD-MSYMEVAL $SF '((MLIST))) 2)
				    (MARRAYREF $EXPN 2))
			      (MARRAYREF
				(TRD-MSYMEVAL $COORDINATES '$COORDINATES)
				1)))
			  (*MMINUS
			    (SIMPLIFY
			      (LIST
				'(%DERIVATIVE)
				(MUL* (MARRAYREF
					(TRD-MSYMEVAL $SF '((MLIST))) 1)
				      (MARRAYREF $EXPN 1))
				(MARRAYREF (TRD-MSYMEVAL
					     $COORDINATES '$COORDINATES)
					   2)))))
			(MARRAYREF (TRD-MSYMEVAL $SF '((MLIST))) 1))
		      (MARRAYREF (TRD-MSYMEVAL $SF '((MLIST))) 2)))))
	     (COND
	       ((= (TRD-MSYMEVAL $DIMENSION 0) 3)
		  (RETURN
		    (LIST
		      '(MLIST)
		      (DIV
			(DIV
			  (ADD*
			    (SIMPLIFY
			      (LIST
				'(%DERIVATIVE)
				(MUL* (MARRAYREF
					(TRD-MSYMEVAL $SF '((MLIST))) 3)
				      (MARRAYREF $EXPN 3))
				(MARRAYREF (TRD-MSYMEVAL
					     $COORDINATES '$COORDINATES)
					   2)))
			    (*MMINUS
			      (SIMPLIFY
				(LIST
				  '(%DERIVATIVE)
				  (MUL* (MARRAYREF
					  (TRD-MSYMEVAL $SF '((MLIST)))
					  2)
					(MARRAYREF $EXPN 2))
				  (MARRAYREF (TRD-MSYMEVAL
					       $COORDINATES '$COORDINATES)
					     3)))))
			  (MARRAYREF (TRD-MSYMEVAL $SF '((MLIST))) 2))
			(MARRAYREF (TRD-MSYMEVAL $SF '((MLIST))) 3))
		      (DIV
			(DIV
			  (ADD*
			    (SIMPLIFY
			      (LIST
				'(%DERIVATIVE)
				(MUL* (MARRAYREF
					(TRD-MSYMEVAL $SF '((MLIST))) 1)
				      (MARRAYREF $EXPN 1))
				(MARRAYREF (TRD-MSYMEVAL
					     $COORDINATES '$COORDINATES)
					   3)))
			    (*MMINUS
			      (SIMPLIFY
				(LIST
				  '(%DERIVATIVE)
				  (MUL* (MARRAYREF
					  (TRD-MSYMEVAL $SF '((MLIST)))
					  3)
					(MARRAYREF $EXPN 3))
				  (MARRAYREF (TRD-MSYMEVAL
					       $COORDINATES '$COORDINATES)
					     1)))))
			  (MARRAYREF (TRD-MSYMEVAL $SF '((MLIST))) 1))
			(MARRAYREF (TRD-MSYMEVAL $SF '((MLIST))) 3))
		      (DIV
			(DIV
			  (ADD*
			    (SIMPLIFY
			      (LIST
				'(%DERIVATIVE)
				(MUL* (MARRAYREF
					(TRD-MSYMEVAL $SF '((MLIST))) 2)
				      (MARRAYREF $EXPN 2))
				(MARRAYREF (TRD-MSYMEVAL
					     $COORDINATES '$COORDINATES)
					   1)))
			    (*MMINUS
			      (SIMPLIFY
				(LIST
				  '(%DERIVATIVE)
				  (MUL* (MARRAYREF
					  (TRD-MSYMEVAL $SF '((MLIST)))
					  1)
					(MARRAYREF $EXPN 1))
				  (MARRAYREF (TRD-MSYMEVAL
					       $COORDINATES '$COORDINATES)
					     2)))))
			  (MARRAYREF (TRD-MSYMEVAL $SF '((MLIST))) 1))
			(MARRAYREF
			  (TRD-MSYMEVAL $SF '((MLIST))) 2))))))))
	 (SIMPLIFY
	   (MFUNCTION-CALL
	     $ERROR '|&CURL USED IN SPACE OF WRONG DIMENSION|))))
     (COND
       ((LIKE (TRD-MSYMEVAL $PIECE '$PIECE) '&~)
	  (SETQ $ANS (SIMPLIFY (MFUNCTION-CALL $INPART $EXPN 1)))
	  (SETQ $EXPN (SIMPLIFY (MFUNCTION-CALL $INPART $EXPN 2)))
	  (COND
	    ((AND (MFUNCTION-CALL $LISTP $ANS)
		  (MFUNCTION-CALL $LISTP $EXPN)
		  (= (MFUNCTION-CALL $LENGTH $ANS)
		     (MFUNCTION-CALL $LENGTH $EXPN)))
	       (COND
		 ((= (MFUNCTION-CALL $LENGTH $ANS) 2)
		    (RETURN
		      (ADD* (MUL* (MARRAYREF $ANS 1) (MARRAYREF $EXPN 2))
			    (*MMINUS (MUL* (MARRAYREF $ANS 2)
					   (MARRAYREF $EXPN 1)))))))
	       (COND
		 ((= (MFUNCTION-CALL $LENGTH $ANS) 3)
		    (RETURN
		      (LIST
			'(MLIST)
			(ADD*
			  (MUL* (MARRAYREF $ANS 2) (MARRAYREF $EXPN 3))
			  (*MMINUS (MUL* (MARRAYREF $ANS 3)
					 (MARRAYREF $EXPN 2))))
			(ADD*
			  (MUL* (MARRAYREF $ANS 3) (MARRAYREF $EXPN 1))
			  (*MMINUS (MUL* (MARRAYREF $ANS 1)
					 (MARRAYREF $EXPN 3))))
			(ADD*
			  (MUL* (MARRAYREF $ANS 1) (MARRAYREF $EXPN 2))
			  (*MMINUS (MUL* (MARRAYREF $ANS 2)
					 (MARRAYREF $EXPN 1))))))))))
	  (SIMPLIFY
	    (MFUNCTION-CALL $ERROR '|&~ USED WITH IMPROPER ARGUMENTS:|
			    $ANS $EXPN))))
     (RETURN $EXPN)))
  '$ANS))

(DEFPROP $TRIGSIMP T TRANSLATED)

(ADD2LNC '$TRIGSIMP $PROPS)

(DEFMTRFUN
  ($TRIGSIMP $ANY MDEFINE NIL NIL) ($EXPN) NIL
  (SIMPLIFY
    (MFUNCTION-CALL
      $RATSIMP
      (DIV (SIMPLIFY (MFUNCTION-CALL
		       $TRIGSIMP1 (SIMPLIFY (MFUNCTION-CALL $NUM $EXPN))))
	   (SIMPLIFY
	     (MFUNCTION-CALL
	       $TRIGSIMP1 (SIMPLIFY (MFUNCTION-CALL $DENOM $EXPN))))))))

(DEFPROP $TRIGSIMP1 T TRANSLATED)

(ADD2LNC '$TRIGSIMP1 $PROPS)

(DEFMTRFUN
  ($TRIGSIMP1 $ANY MDEFINE NIL NIL) ($EXPN) NIL
  ((LAMBDA ($LISTOFTRIGSQ $BESTLENGTH $TRYLENGTH)
     NIL
     (ASSIGN-MODE-CHECK '$TRYLENGTH $TRYLENGTH)
     (ASSIGN-MODE-CHECK '$BESTLENGTH $BESTLENGTH)
     (PROG ()
	  (SETQ
	    $LISTOFTRIGSQ (SIMPLIFY (MFUNCTION-CALL $LISTOFTRIGSQ $EXPN)))
	  (PROGN (ASSIGN-MODE-CHECK '$BESTLENGTH 999999)
		 (SETQ $BESTLENGTH 999999))
	  (COND
	    ((NOT (LIKE $LISTOFTRIGSQ '((MLIST))))
	       (SIMPLIFY (MFUNCTION-CALL $IMPROVE $EXPN $LISTOFTRIGSQ))))
	  (RETURN $EXPN)))
   '$LISTOFTRIGSQ 0 0))

(DEFPROP $IMPROVE T TRANSLATED)

(ADD2LNC '$IMPROVE $PROPS)

(DEFMTRFUN
 ($IMPROVE $ANY MDEFINE NIL NIL) ($SUBSOFAR $LISTOFTRIGSQ) NIL
 (COND
  ((LIKE $LISTOFTRIGSQ '((MLIST)))
     ((LAMBDA (|tr-gensym~19|)
	(PROGN (ASSIGN-MODE-CHECK '$TRYLENGTH |tr-gensym~19|)
	       (SETQ $TRYLENGTH |tr-gensym~19|)))
      (SIMPLIFY (MFUNCTION-CALL $EXPNLENGTH $SUBSOFAR)))
     (COND ((< (TRD-MSYMEVAL $TRYLENGTH 0) (TRD-MSYMEVAL $BESTLENGTH 0))
	      (SETQ $EXPN $SUBSOFAR)
	      ((LAMBDA (|tr-gensym~20|)
		 (PROGN (ASSIGN-MODE-CHECK '$BESTLENGTH |tr-gensym~20|)
			(SETQ $BESTLENGTH |tr-gensym~20|)))
	       (TRD-MSYMEVAL $TRYLENGTH 0)))))
  (T
   (SIMPLIFY
     (MFUNCTION-CALL $IMPROVE $SUBSOFAR
		     (SIMPLIFY (MFUNCTION-CALL $REST $LISTOFTRIGSQ))))
   (DO (($ALT) (MDO (CDR (SIMPLIFY ($FIRST $LISTOFTRIGSQ))) (CDR MDO)))
       ((NULL MDO) '$DONE)
    (SETQ $ALT (CAR MDO))
    (SIMPLIFY
      (MFUNCTION-CALL
	$IMPROVE
	(SIMPLIFY
	  (MFUNCTION-CALL
	    $RATSUBST
	    (COND
	      ((LIKE (SIMPLIFY (MFUNCTION-CALL $INPART $ALT 0)) '%SIN)
		 (ADD*
		   1
		   (*MMINUS
		     (POWER
		       (SIMPLIFY
			 (LIST '(%COS)
			       (SIMPLIFY (MFUNCTION-CALL $INPART $ALT 1))))
		       2))))
	      ((LIKE (TRD-MSYMEVAL $PIECE '$PIECE) '%COS)
		 (ADD*
		   1
		   (*MMINUS
		     (POWER
		       (SIMPLIFY
			 (LIST '(%SIN)
			       (SIMPLIFY (MFUNCTION-CALL $INPART $ALT 1))))
		       2))))
	      ((LIKE (TRD-MSYMEVAL $PIECE '$PIECE) '%SINH)
		 (ADD*
		   (POWER
		     (SIMPLIFY
		       (LIST '(%COSH)
			     (SIMPLIFY (MFUNCTION-CALL $INPART $ALT 1))))
		     2)
		   -1))
	      (T (ADD*
		   1
		   (POWER
		     (SIMPLIFY
		       (LIST '(%SINH)
			     (SIMPLIFY (MFUNCTION-CALL $INPART $ALT 1))))
		     2))))
	    (POWER $ALT 2) $SUBSOFAR))
	(SIMPLIFY (MFUNCTION-CALL $REST $LISTOFTRIGSQ))))))))

(DEFPROP $LISTOFTRIGSQ T TRANSLATED)

(ADD2LNC '$LISTOFTRIGSQ $PROPS)

(DEFMTRFUN
 ($LISTOFTRIGSQ $ANY MDEFINE NIL NIL) ($EXPN) NIL
 (COND
  ((MFUNCTION-CALL $ATOM $EXPN) '((MLIST)))
  (T
    ((LAMBDA ($INFLAG $ANS)
       NIL
       (PROG ()
	   (COND
	     ((AND
		(LIKE (SIMPLIFY (MFUNCTION-CALL $INPART $EXPN 0)) '&^)
		(MFUNCTION-CALL
		  $INTEGERP (SIMPLIFY (MFUNCTION-CALL $INPART $EXPN 2)))
		(NOT
		  (IS-BOOLE-CHECK (MLSP (TRD-MSYMEVAL $PIECE '$PIECE) 2))))
		(COND
		  ((MFUNCTION-CALL
		     $ATOM
		     (SETQ $EXPN
			   (SIMPLIFY (MFUNCTION-CALL $INPART $EXPN 1))))
		     (RETURN '((MLIST))))
		  ((MFUNCTION-CALL
		     $MEMBER (SIMPLIFY (MFUNCTION-CALL $INPART $EXPN 0))
		     '((MLIST) %SIN %COS %SINH %COSH))
		     (RETURN (LIST '(MLIST) (LIST '(MLIST) $EXPN)))))))
	   (SETQ $INFLAG T)
	   (SETQ $ANS '((MLIST)))
	   (DO (($ARG) (MDO (CDR $EXPN) (CDR MDO))) ((NULL MDO) '$DONE)
	     (SETQ $ARG (CAR MDO))
	     (SETQ
	       $ANS
	       (SIMPLIFY (MFUNCTION-CALL
			   $SPECIALUNION
			   (SIMPLIFY (MFUNCTION-CALL $LISTOFTRIGSQ $ARG))
			   $ANS))))
	   (RETURN $ANS)))
     '$INFLAG '$ANS))))

(DEFPROP $SPECIALUNION T TRANSLATED)

(ADD2LNC '$SPECIALUNION $PROPS)

(DEFMTRFUN
 ($SPECIALUNION $ANY MDEFINE NIL NIL) ($LIST1 $LIST2) NIL
 (COND
  ((LIKE $LIST1 '((MLIST))) $LIST2)
  ((LIKE $LIST2 '((MLIST))) $LIST1)
  (T
    ((LAMBDA ($ALTERNATES)
       NIL
       (PROG ()
	   (SETQ $ALTERNATES (SIMPLIFY ($FIRST $LIST1)))
	   (DO (($ALT) (MDO (CDR $ALTERNATES) (CDR MDO)))
	       ((NULL MDO) '$DONE)
	     (SETQ $ALT (CAR MDO))
	     (SETQ
	       $LIST2
	       (COND
		 ((LIKE (SIMPLIFY (MFUNCTION-CALL $INPART $ALT 0)) '%SIN)
		    (SIMPLIFY (MFUNCTION-CALL $UPDATE $ALT '%COS $LIST2)))
		 ((LIKE (TRD-MSYMEVAL $PIECE '$PIECE) '%COS)
		    (SIMPLIFY (MFUNCTION-CALL $UPDATE $ALT '%SIN $LIST2)))
		 ((LIKE (TRD-MSYMEVAL $PIECE '$PIECE) '%SINH)
		    (SIMPLIFY (MFUNCTION-CALL $UPDATE $ALT '%COSH $LIST2)))
		 (T (SIMPLIFY
		      (MFUNCTION-CALL $UPDATE $ALT '%SINH $LIST2))))))
	   (RETURN
	     (SIMPLIFY
	       (MFUNCTION-CALL
		 $SPECIALUNION
		 (SIMPLIFY (MFUNCTION-CALL $REST $LIST1)) $LIST2)))))
     '$ALTERNATES))))

(DEFPROP $UPDATE T TRANSLATED)

(ADD2LNC '$UPDATE $PROPS)

(DEFMTRFUN
 ($UPDATE $ANY MDEFINE NIL NIL) ($FORM $COMPLEMENT $LIST2) NIL
 ((LAMBDA ($ANS)
    NIL
    (SETQ $COMPLEMENT
	  (SIMPLIFY
	    (MFUNCALL
	      '$COMPLEMENT (SIMPLIFY (MFUNCTION-CALL $INPART $FORM 1)))))
    (SETQ
      $ANS
      (DO (($ELEMENT) (MDO (CDR $LIST2) (CDR MDO))) ((NULL MDO) '$DONE)
	(SETQ $ELEMENT (CAR MDO))
	(COND
	  ((MFUNCTION-CALL $MEMBER $FORM $ELEMENT) (RETURN '$FOUND))
	  ((MFUNCTION-CALL $MEMBER $COMPLEMENT $ELEMENT)
	     (RETURN (SIMPLIFY
		       (MFUNCTION-CALL
			 $CONS (LIST '(MLIST) $FORM $COMPLEMENT)
			 (SIMPLIFY
			   (MFUNCTION-CALL $DELETE $ELEMENT $LIST2)))))))))
    (COND
      ((LIKE $ANS '$FOUND) $LIST2)
      ((LIKE $ANS '$DONE)
	 (SIMPLIFY (MFUNCTION-CALL $CONS (LIST '(MLIST) $FORM) $LIST2)))
      (T $ANS)))
  '$ANS))

(DEFPROP $EXPNLENGTH T TRANSLATED)

(ADD2LNC '$EXPNLENGTH $PROPS)

(DEFMTRFUN
  ($EXPNLENGTH $ANY MDEFINE NIL NIL) ($EXPR) NIL
  (COND
    ((MFUNCTION-CALL $ATOM $EXPR) 1)
    (T (ADD*
	 1
	 (SIMPLIFY
	   (MFUNCTION-CALL
	     $ARGSLENGTH
	     (SIMPLIFY
	       (PART1
		 (LIST (LIST '(MQUOTE SIMP) '&[)
		       (LIST '(MQUOTE SIMP) $EXPR) (LIST '(MQUOTE SIMP) 0))
		 T NIL T))))))))

(DEFPROP $ARGSLENGTH T TRANSLATED)

(ADD2LNC '$ARGSLENGTH $PROPS)

(DEFMTRFUN
  ($ARGSLENGTH $ANY MDEFINE NIL NIL) ($ARGS) NIL
  (COND
    ((LIKE $ARGS '((MLIST))) 0)
    (T (ADD*
	 (SIMPLIFY (MFUNCTION-CALL $EXPNLENGTH (SIMPLIFY ($FIRST $ARGS))))
	 (SIMPLIFY
	   (MFUNCTION-CALL
	     $ARGSLENGTH (SIMPLIFY (MFUNCTION-CALL $REST $ARGS))))))))

((LAMBDA (|tr-gensym~21|)
   (PROGN
     (MSETCHK '$DOTASSOC |tr-gensym~21|) (SETQ $DOTASSOC |tr-gensym~21|)))
 (SETQ $DOTEXPTSIMP NIL))

(SETQ $DOTSCRULES T)

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

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

(DEFPROP $EXPANDFLAGS ASSIGN-MODE-CHECK ASSIGN)

(DEF-MTRVAR
  $EXPANDFLAGS '((MLIST) $EXPANDALL $EXPANDDOT $EXPANDDOTPLUS $EXPANDCROSS
		 $EXPANDCROSSPLUS $EXPANDCROSSCROSS $EXPANDGRAD
		 $EXPANDGRADPLUS $EXPANDGRADPROD $EXPANDDIV $EXPANDDIVPLUS
		 $EXPANDDIVPROD $EXPANDCURL $EXPANDCURLPLUS $EXPANDCURLCURL
		 $EXPANDLAPLACIAN $EXPANDLAPLACIANPLUS $EXPANDLAPLACIANPROD
		 $EXPANDLAPLACIANTODIVGRAD $EXPANDPLUS $EXPANDPROD))

(SIMPLIFY (MFUNCALL '$DECLARE '$EXPANDFLAGS '$EVFLAG))

(DEFPROP $FLAG_RESET T TRANSLATED)

(ADD2LNC '$FLAG_RESET $PROPS)

(DEFMTRFUN
  ($FLAG_RESET $ANY MDEFINE NIL NIL) NIL NIL
  (DO
    (($FLAG) (MDO (CDR (TRD-MSYMEVAL $EXPANDFLAGS '((MLIST)))) (CDR MDO)))
    ((NULL MDO) '$DONE)
    (SETQ $FLAG (CAR MDO)) (SIMPLIFY (MFUNCTION-CALL MSET $FLAG NIL))))

(DEFPROP $VECTORSIMP T TRANSLATED)

(ADD2LNC '$VECTORSIMP $PROPS)

(DEFMTRFUN
  ($VECTORSIMP $ANY MDEFINE NIL NIL) ($EXPN) NIL
  ((LAMBDA ($DOTDISTRIB $DOTSCRULES $INFLAG $FIRSTCROSSSCALAR)
     NIL
     (ASSIGN-MODE-CHECK '$FIRSTCROSSSCALAR $FIRSTCROSSSCALAR)
     (SETQ $INFLAG (PROGN (ASSIGN-MODE-CHECK '$FIRSTCROSSSCALAR T)
			  (SETQ $FIRSTCROSSSCALAR T)))
     (SETQ
       $DOTDISTRIB
       (OR
	 (TRD-MSYMEVAL $EXPANDALL NIL) (TRD-MSYMEVAL $EXPANDDOT NIL)
	 (TRD-MSYMEVAL $EXPANDDOTPLUS NIL) (TRD-MSYMEVAL $EXPANDPLUS NIL)))
     (COND
       ((OR (TRD-MSYMEVAL $EXPANDALL NIL) (TRD-MSYMEVAL $EXPANDGRAD NIL)
	    (TRD-MSYMEVAL $EXPANDGRADPLUS NIL)
	    (TRD-MSYMEVAL $EXPANDPLUS NIL))
	  ($DECLARE &GRAD $ADDITIVE)))
     (COND
       ((OR
	  (TRD-MSYMEVAL $EXPANDALL NIL) (TRD-MSYMEVAL $EXPANDDIV NIL)
	  (TRD-MSYMEVAL $EXPANDDIVPLUS NIL) (TRD-MSYMEVAL $EXPANDPLUS NIL))
	  ($DECLARE &DIV $ADDITIVE)))
     (COND
       ((OR (TRD-MSYMEVAL $EXPANDALL NIL) (TRD-MSYMEVAL $EXPANDCURL NIL)
	    (TRD-MSYMEVAL $EXPANDCURLPLUS NIL)
	    (TRD-MSYMEVAL $EXPANDPLUS NIL))
	  ($DECLARE &CURL $ADDITIVE)))
     (COND
       ((OR
	  (TRD-MSYMEVAL $EXPANDALL NIL) (TRD-MSYMEVAL $EXPANDLAPLACIAN NIL)
	  (TRD-MSYMEVAL $EXPANDLAPLACIANPLUS NIL)
	  (TRD-MSYMEVAL $EXPANDPLUS NIL))
	  ($DECLARE &LAPLACIAN $ADDITIVE)))
     (SETQ $EXPN (SIMPLIFY (MFUNCTION-CALL $VSIMP $EXPN)))
     (COND ((TRD-MSYMEVAL $EXPANDALL NIL)
	      (SETQ $EXPN (SIMPLIFY (MFUNCTION-CALL $RATEXPAND $EXPN)))))
     (COND
       ((OR (TRD-MSYMEVAL $EXPANDALL NIL) (TRD-MSYMEVAL $EXPANDGRAD NIL)
	    (TRD-MSYMEVAL $EXPANDGRADPLUS NIL)
	    (TRD-MSYMEVAL $EXPANDPLUS NIL))
	  (MEVAL '(($REMOVE) &GRAD $ADDITIVE))))
     (COND
       ((OR
	  (TRD-MSYMEVAL $EXPANDALL NIL) (TRD-MSYMEVAL $EXPANDDIV NIL)
	  (TRD-MSYMEVAL $EXPANDDIVPLUS NIL) (TRD-MSYMEVAL $EXPANDPLUS NIL))
	  (MEVAL '(($REMOVE) &DIV $ADDITIVE))))
     (COND
       ((OR (TRD-MSYMEVAL $EXPANDALL NIL) (TRD-MSYMEVAL $EXPANDCURL NIL)
	    (TRD-MSYMEVAL $EXPANDCURLPLUS NIL)
	    (TRD-MSYMEVAL $EXPANDPLUS NIL))
	  (MEVAL '(($REMOVE) &CURL $ADDITIVE))))
     (COND
       ((OR
	  (TRD-MSYMEVAL $EXPANDALL NIL) (TRD-MSYMEVAL $EXPANDLAPLACIAN NIL)
	  (TRD-MSYMEVAL $EXPANDLAPLACIANPLUS NIL)
	  (TRD-MSYMEVAL $EXPANDPLUS NIL))
	  (MEVAL '(($REMOVE) &LAPLACIAN $ADDITIVE))))
     $EXPN)
   '$DOTDISTRIB '$DOTSCRULES '$INFLAG '$FIRSTCROSSSCALAR))

(DEFPROP $BEFORE T TRANSLATED)

(ADD2LNC '$BEFORE $PROPS)

(DEFMTRFUN
  ($BEFORE $ANY MDEFINE NIL NIL) ($ARG) NIL
  (SIMPLIFY
    (LIST
      '(MNOTEQUAL)
      (SIMPLIFY
	(MFUNCTION-CALL
	  $INPART
	  (SIMPLIFY (LIST '($ORDER) (TRD-MSYMEVAL $ETRUE '$ETRUE) $ARG))
	  1))
      (TRD-MSYMEVAL $ETRUE '$ETRUE))))

(DEFPROP $VSCALARP T TRANSLATED)

(ADD2LNC '$VSCALARP $PROPS)

(DEFMTRFUN ($VSCALARP $BOOLEAN MDEFINE NIL NIL) ($ARG)
	   NIL (NOT (MFUNCTION-CALL $NONSCALARP $ARG)))

(DEFPROP $VSIMP T TRANSLATED)

(ADD2LNC '$VSIMP $PROPS)

(DEFMTRFUN
 ($VSIMP $ANY MDEFINE NIL NIL) ($EXPN) NIL
 (COND
  ((MFUNCTION-CALL $MAPATOM $EXPN) $EXPN)
  (T
   ((LAMBDA ($PV $QV $RV $SV)
      NIL
      (PROG ()
	 (SETQ $EXPN (SIMPLIFY (MAP1 (GETOPR '$VSIMP) $EXPN)))
	 (COND ((MFUNCTION-CALL $MAPATOM $EXPN) (RETURN $EXPN)))
	 (COND
	   ((LIKE (SIMPLIFY (MFUNCTION-CALL $INPART $EXPN 0)) '&~)
	      (SETQ
		$EXPN
		(SIMPLIFY
		  (MFUNCTION-CALL $REMOVECROSSSC1 $EXPN $PV $RV $SV))))
	   ((LIKE (TRD-MSYMEVAL $PIECE '$PIECE) '&GRAD)
	      (COND
		((AND
		   (OR (TRD-MSYMEVAL $EXPANDALL NIL)
		       (TRD-MSYMEVAL $EXPANDGRAD NIL)
		       (TRD-MSYMEVAL $EXPANDGRADPROD NIL)
		       (TRD-MSYMEVAL $EXPANDPROD NIL))
		   (NOT
		     (MFUNCTION-CALL
		       $MAPATOM
		       (SETQ
			 $PV
			 (SIMPLIFY (MFUNCTION-CALL $INPART $EXPN 1)))))
		   (LIKE (SIMPLIFY (MFUNCTION-CALL $INPART $PV 0)) '&*))
		   (SETQ
		     $EXPN
		     (SIMPLIFY
		       (MAPPLY-TR
			 '&+
			 (MAPLIST_TR
			   (M-TLAMBDA&ENV
			     (($U) ($PV)) NIL
			     (SIMPLIFY (MFUNCTION-CALL $GRADPROD $U $PV)))
			   $PV)))))))
	   ((LIKE (TRD-MSYMEVAL $PIECE '$PIECE) '&DIV)
	      (COND
		((AND
		   (OR (TRD-MSYMEVAL $EXPANDALL NIL)
		       (TRD-MSYMEVAL $EXPANDDIV NIL)
		       (TRD-MSYMEVAL $EXPANDDIVPROD NIL)
		       (TRD-MSYMEVAL $EXPANDPROD NIL))
		   (NOT
		     (MFUNCTION-CALL
		       $MAPATOM
		       (SETQ
			 $PV
			 (SIMPLIFY (MFUNCTION-CALL $INPART $EXPN 1)))))
		   (LIKE (SIMPLIFY (MFUNCTION-CALL $INPART $PV 0)) '&*))
		   (SETQ
		     $EXPN
		     (SIMPLIFY
		       (MAPPLY-TR
			 '&+
			 (MAPLIST_TR
			   (M-TLAMBDA&ENV
			     (($U) ($PV)) NIL
			     (SIMPLIFY (MFUNCTION-CALL $DIVPROD $U $PV)))
			   $PV)))))))
	   ((LIKE (TRD-MSYMEVAL $PIECE '$PIECE) '&CURL)
	      (COND
		((AND
		   (OR (TRD-MSYMEVAL $EXPANDALL NIL)
		       (TRD-MSYMEVAL $EXPANDCURL NIL)
		       (TRD-MSYMEVAL $EXPANDCURLCURL NIL))
		   (NOT
		     (MFUNCTION-CALL
		       $MAPATOM
		       (SETQ
			 $PV
			 (SIMPLIFY (MFUNCTION-CALL $INPART $EXPN 1)))))
		   (LIKE (SIMPLIFY (MFUNCTION-CALL $INPART $PV 0))
			 '&CURL))
		   (SETQ
		     $EXPN
		     (ADD*
		       (SIMPLIFY
			 (MFUNCTION-CALL
			   $GRAD
			   (SIMPLIFY
			     (LIST
			       '($DIV)
			       (SETQ $PV
				     (SIMPLIFY
				       (MFUNCTION-CALL $INPART $PV 1)))))))
		       (*MMINUS
			 (SIMPLIFY (MFUNCTION-CALL $LAPLACIAN $PV))))))))
	   ((LIKE (TRD-MSYMEVAL $PIECE '$PIECE) '&LAPLACIAN)
	      (COND
		((TRD-MSYMEVAL $EXPANDLAPLACIANTODIVGRAD NIL)
		   (SETQ
		     $EXPN
		     (SIMPLIFY
		       (LIST '($DIV)
			     (SIMPLIFY
			       (MFUNCTION-CALL
				 $GRAD
				 (SIMPLIFY
				   (MFUNCTION-CALL $INPART $EXPN 1))))))))
		((AND
		   (OR (TRD-MSYMEVAL $EXPANDALL NIL)
		       (TRD-MSYMEVAL $EXPANDLAPLACIAN NIL)
		       (TRD-MSYMEVAL $EXPANDLAPLACIANPROD NIL)
		       (TRD-MSYMEVAL $EXPANDPROD NIL))
		   (NOT
		     (MFUNCTION-CALL
		       $MAPATOM
		       (SETQ
			 $PV
			 (SIMPLIFY (MFUNCTION-CALL $INPART $EXPN 1)))))
		   (LIKE (SIMPLIFY (MFUNCTION-CALL $INPART $PV 0)) '&*))
		   (SETQ $QV (SIMPLIFY (MFUNCTION-CALL $INPART $PV 1)))
		   (SETQ $RV (SIMPLIFY (MFUNCTION-CALL $DELETE $QV $PV)))
		   (SETQ
		     $EXPN
		     (ADD*
		       (MUL* $RV
			     (SIMPLIFY (MFUNCTION-CALL $LAPLACIAN $QV)))
		       (MUL* 2 (SIMPLIFY (MFUNCTION-CALL $GRAD $RV))
			     (SIMPLIFY (MFUNCTION-CALL $GRAD $QV)))
		       (MUL*
			 $QV
			 (SIMPLIFY (MFUNCTION-CALL $LAPLACIAN $RV)))))))))
	 (RETURN $EXPN)))
    '$PV '$QV '$RV '$SV))))

(DEFPROP $CROSSSIMP T TRANSLATED)

(ADD2LNC '$CROSSSIMP $PROPS)

(DEFMTRFUN
  ($CROSSSIMP $ANY MDEFINE NIL NIL) ($EX $PV $RV $SV) NIL
  (COND
    ((AND (NOT (MFUNCTION-CALL $MAPATOM $EX))
	  (LIKE (SIMPLIFY (MFUNCTION-CALL $INPART $EX 0)) '&~))
       (COND
	 ((OR (TRD-MSYMEVAL $EXPANDALL NIL) (TRD-MSYMEVAL $EXPANDCROSS NIL)
	      (TRD-MSYMEVAL $EXPANDCROSSCROSS NIL))
	    (SETQ
	      $EX
	      (SIMPLIFY (MFUNCTION-CALL $TRYCROSSCROSS $EX $PV $RV $SV)))))
       (COND
	 ((AND
	    (NOT (MFUNCTION-CALL $MAPATOM $EX))
	    (LIKE (SIMPLIFY (MFUNCTION-CALL $INPART $EX 0)) '&~)
	    (OR
	      (TRD-MSYMEVAL $EXPANDALL NIL) (TRD-MSYMEVAL $EXPANDCROSS NIL)
	      (TRD-MSYMEVAL $EXPANDCROSSPLUS NIL)
	      (TRD-MSYMEVAL $EXPANDPLUS NIL)))
	    (SETQ
	      $EX
	      (SIMPLIFY (MFUNCTION-CALL $TRYCROSSPLUS $EX $PV $RV $SV)))))
       $EX)
    (T $EX)))

(DEFPROP $REMOVECROSSSC T TRANSLATED)

(ADD2LNC '$REMOVECROSSSC $PROPS)

(DEFMTRFUN
  ($REMOVECROSSSC $ANY MDEFINE NIL NIL) ($EXPN $PV $RV $SV) NIL
  (COND ((AND (NOT (MFUNCTION-CALL $MAPATOM $EXPN))
	      (LIKE (SIMPLIFY (MFUNCTION-CALL $INPART $EXPN 0)) '&~))
	   (SIMPLIFY (MFUNCTION-CALL $REMOVECROSSSC1 $EXPN $PV $RV $SV)))
	(T $EXPN)))

(DEFPROP $REMOVECROSSSC1 T TRANSLATED)

(ADD2LNC '$REMOVECROSSSC1 $PROPS)

(DEFMTRFUN
 ($REMOVECROSSSC1 $ANY MDEFINE NIL NIL) ($EXPN $PV $RV $SV) NIL
 ((LAMBDA ($LEFT $RIGHT)
   NIL
   (PROG ()
    (SETQ
      $LEFT
      (SIMPLIFY
	(MFUNCTION-CALL
	  $PARTITIONSC (SIMPLIFY (MFUNCTION-CALL $INPART $EXPN 1)))))
    (SETQ
      $RIGHT
      (SIMPLIFY
	(MFUNCTION-CALL
	  $PARTITIONSC (SIMPLIFY (MFUNCTION-CALL $INPART $EXPN 2)))))
    (COND
     ((AND (TRD-MSYMEVAL $FIRSTCROSSSCALAR NIL)
	   (OR (LIKE (MARRAYREF $LEFT 2) 1)
	       (LIKE (MARRAYREF $RIGHT 2) 1)))
      (SIMPLIFY
       (MFUNCTION-CALL
	$PRINT
	'|&WARNING: DECLARE VECTOR INDETERMINANTS 
NONSCALAR TO AVOID ERRORS & TO GET FULL SIMPLIFICATION|))
      (PROGN (ASSIGN-MODE-CHECK '$FIRSTCROSSSCALAR NIL)
	     (SETQ $FIRSTCROSSSCALAR NIL))
      (RETURN $EXPN)))
    (RETURN
      (MUL*
	(MARRAYREF $LEFT 1) (MARRAYREF $RIGHT 1)
	(SIMPLIFY
	  (MFUNCTION-CALL
	    $CROSSSIMP
	    (SIMPLIFY
	      (LIST '($~) (MARRAYREF $LEFT 2) (MARRAYREF $RIGHT 2)))
	    $PV $RV $SV))))))
  '$LEFT '$RIGHT))

(DEFPROP $PARTITIONSC T TRANSLATED)

(ADD2LNC '$PARTITIONSC $PROPS)

(DEFMTRFUN
  ($PARTITIONSC $ANY MDEFINE NIL NIL) ($EX) NIL
  (COND ((MFUNCTION-CALL $MAPATOM $EX)
	   (COND ((MFUNCTION-CALL $NONSCALARP $EX) (LIST '(MLIST) 1 $EX))
		 (T (LIST '(MLIST) $EX 1))))
	((LIKE (SIMPLIFY (MFUNCTION-CALL $INPART $EX 0)) '&*)
	   ((LAMBDA ($SC $NONSC)
	      NIL
	      (SETQ $SC (SETQ $NONSC 1))
	      (DO (($FACT) (MDO (CDR $EX) (CDR MDO))) ((NULL MDO) '$DONE)
		(SETQ $FACT (CAR MDO))
		(COND ((MFUNCTION-CALL $NONSCALARP $FACT)
			 (SETQ $NONSC (MUL* $NONSC $FACT)))
		      (T (SETQ $SC (MUL* $SC $FACT)))))
	      (LIST '(MLIST) $SC $NONSC))
	    '$SC '$NONSC))
	(T (LIST '(MLIST) 1 $EX))))

(DEFPROP $TRYCROSSPLUS T TRANSLATED)

(ADD2LNC '$TRYCROSSPLUS $PROPS)

(DEFMTRFUN
 ($TRYCROSSPLUS $ANY MDEFINE NIL NIL) ($EXPN $PV $RV $SV) NIL
 (PROGN
   (SETQ $PV (SIMPLIFY (MFUNCTION-CALL $INPART $EXPN 1)))
   (SETQ $RV (SIMPLIFY (MFUNCTION-CALL $INPART $EXPN 2)))
   (COND
     ((AND (NOT (MFUNCTION-CALL $MAPATOM $PV))
	   (LIKE (SIMPLIFY (MFUNCTION-CALL $INPART $PV 0)) '&+))
	(COND
	  ((AND (NOT (MFUNCTION-CALL $MAPATOM $RV))
		(LIKE (SIMPLIFY (MFUNCTION-CALL $INPART $RV 0)) '&+))
	     (SIMPLIFY
	       (MAP1
		 (GETOPR
		   (M-TLAMBDA&ENV
		     (($U) ($PV $RV $SV)) NIL
		     (SIMPLIFY
		       (MFUNCTION-CALL $TRYCROSSPLUS $U $PV $RV $SV))))
		 (SIMPLIFY
		   (MAP1
		     (GETOPR
		       (M-TLAMBDA&ENV
			 (($U) ($RV $SV)) NIL
			 (SIMPLIFY (MFUNCTION-CALL $CROSSRV $U $RV $SV))))
		     $PV)))))
	  (T
	    (SIMPLIFY
	      (MAP1
		(GETOPR (M-TLAMBDA&ENV
			  (($U) ($RV $SV)) NIL
			  (SIMPLIFY (MFUNCTION-CALL $CROSSRV $U $RV $SV))))
		$PV)))))
     ((AND (NOT (MFUNCTION-CALL $MAPATOM $RV))
	   (LIKE (SIMPLIFY (MFUNCTION-CALL $INPART $RV 0)) '&+))
	(SIMPLIFY
	  (MAP1 (GETOPR (M-TLAMBDA&ENV
			  (($U) ($PV $SV)) NIL
			  (SIMPLIFY (MFUNCTION-CALL $PVCROSS $PV $U $SV))))
		$RV)))
     (T $EXPN))))

(DEFPROP $TRYCROSSCROSS T TRANSLATED)

(ADD2LNC '$TRYCROSSCROSS $PROPS)

(DEFMTRFUN
  ($TRYCROSSCROSS $ANY MDEFINE NIL NIL) ($EXPN $PV $RV $SV) NIL
  (PROGN (SETQ $PV (SIMPLIFY (MFUNCTION-CALL $INPART $EXPN 1)))
	 (SETQ $RV (SIMPLIFY (MFUNCTION-CALL $INPART $EXPN 2)))
	 (COND ((AND (NOT (MFUNCTION-CALL $MAPATOM $RV))
		     (LIKE (SIMPLIFY (MFUNCTION-CALL $INPART $RV 0)) '&~))
		  (SETQ $SV (SIMPLIFY (MFUNCTION-CALL $INPART $RV 2)))
		  (SETQ $RV (SIMPLIFY (MFUNCTION-CALL $INPART $RV 1)))
		  (ADD* (MUL* $RV (NCMUL2 $PV $SV))
			(*MMINUS (MUL* $SV (NCMUL2 $PV $RV)))))
	       ((AND (NOT (MFUNCTION-CALL $MAPATOM $PV))
		     (LIKE (SIMPLIFY (MFUNCTION-CALL $INPART $PV 0)) '&~))
		  (SETQ $SV (SIMPLIFY (MFUNCTION-CALL $INPART $PV 2)))
		  (SETQ $PV (SIMPLIFY (MFUNCTION-CALL $INPART $PV 1)))
		  (ADD* (MUL* $SV (NCMUL2 $RV $PV))
			(*MMINUS (MUL* $PV (NCMUL2 $RV $SV)))))
	       (T $EXPN))))

(DEFPROP $PVCROSS T TRANSLATED)

(ADD2LNC '$PVCROSS $PROPS)

(DEFMTRFUN
  ($PVCROSS $ANY MDEFINE NIL NIL) ($PV $RV $SV) NIL
  (SIMPLIFY (MFUNCTION-CALL
	      $REMOVECROSSSC (SIMPLIFY (LIST '($~) $PV $RV)) $PV $RV $SV)))

(DEFPROP $CROSSRV T TRANSLATED)

(ADD2LNC '$CROSSRV $PROPS)

(DEFMTRFUN
  ($CROSSRV $ANY MDEFINE NIL NIL) ($PV $RV $SV) NIL
  (SIMPLIFY (MFUNCTION-CALL
	      $REMOVECROSSSC (SIMPLIFY (LIST '($~) $PV $RV)) $PV $RV $SV)))

(DEFPROP $GRADPROD T TRANSLATED)

(ADD2LNC '$GRADPROD $PROPS)

(DEFMTRFUN ($GRADPROD $ANY MDEFINE NIL NIL) ($UU $PV) NIL
	   (MUL* (SIMPLIFY (MFUNCTION-CALL $DELETE $UU $PV))
		 (SIMPLIFY (MFUNCTION-CALL $GRAD $UU))))

(DEFPROP $DIVPROD T TRANSLATED)

(ADD2LNC '$DIVPROD $PROPS)

(DEFMTRFUN ($DIVPROD $ANY MDEFINE NIL NIL) ($UU $PV) NIL
	   ((LAMBDA ($DOTSCRULES)
	      NIL
	      (SETQ $DOTSCRULES NIL)
	      (COND ((MFUNCTION-CALL $NONSCALARP $UU)
		       (MUL* (SIMPLIFY (MFUNCTION-CALL $DELETE $UU $PV))
			     (SIMPLIFY (LIST '($DIV) $UU))))
		    (T (NCMUL2 (SIMPLIFY (MFUNCTION-CALL $DELETE $UU $PV))
			       (SIMPLIFY (MFUNCTION-CALL $GRAD $UU))))))
	    '$DOTSCRULES))

(DEFPROP $POTENTIAL1 T TRANSLATED)

(ADD2LNC '$POTENTIAL1 $PROPS)

(DEFMTRFUN
 ($POTENTIAL1 $ANY MDEFINE NIL NIL) ($GR) NIL
 ((LAMBDA ($ORIGIN $GRPERM $JJ $RESULT $%DUM)
    (DECLARE (FIXNUM $ORIGIN))
    (COND
      ((OR (NOT (MFUNCTION-CALL $LISTP $GR))
	   (NOT
	     (= (MFUNCTION-CALL $LENGTH $GR) (TRD-MSYMEVAL $DIMENSION 0))))
	 (SIMPLIFY
	   (MFUNCTION-CALL
	     $ERROR
	     '|&1ST ARG OF POTENTIAL MUST BE A LIST OF LENGTH EQUAL TO|
	     '|&THE DIMENSIONALITY OF THE COORDINATE SYSTEM|))))
    (SETQ $ORIGIN (SIMPLIFY (MFUNCTION-CALL $ZEROLOC)))
    (SETQ $RESULT '((MLIST)))
    (DO (($JJ (TRD-MSYMEVAL $DIMENSION 0) (+ -1 $JJ))) ((< $JJ 1) '$DONE)
      (SETQ $RESULT
	    (SIMPLIFY (MFUNCTION-CALL
			$CONS
			(MUL* (MARRAYREF (TRD-MSYMEVAL $SF '((MLIST))) $JJ)
			      (MARRAYREF $GR $JJ))
			$RESULT))))
    (SETQ $GRPERM '((MLIST)))
    (DO (($EQN) (MDO (CDR $ORIGIN) (CDR MDO))) ((NULL MDO) '$DONE)
      (SETQ $EQN (CAR MDO))
      (SETQ $JJ 1)
      (DO ((MDO 1 (+ 1 MDO)))
	  ((LIKE (SIMPLIFY (MFUNCTION-CALL $LHS $EQN))
		 (MARRAYREF (TRD-MSYMEVAL $COORDINATES '$COORDINATES) $JJ))
	     '$DONE)
	(SETQ $JJ (ADD* $JJ 1)))
      (SETQ $GRPERM
	    (SIMPLIFY
	      (MFUNCTION-CALL $ENDCONS (MARRAYREF $RESULT $JJ) $GRPERM))))
    (SETQ
      $RESULT
      ((LAMBDA (|0| N)
	 (COND
	   ((NOT (< N |0|))
	      (DO (($JJ |0| (1+ $JJ))
		   (SUM0012
		     0
		     (ADD*
		       SUM0012
		       (SIMPLIFY
			 (MFUNCTION-CALL
			   $MYINT
			   (SIMPLIFY
			     (MFUNCTION-CALL $SUBLESS $JJ $ORIGIN $GRPERM))
			   $%DUM
			   (SIMPLIFY
			     (MFUNCTION-CALL $RHS (MARRAYREF $ORIGIN $JJ)))
			   (SIMPLIFY (MFUNCTION-CALL
				       $LHS (MARRAYREF $ORIGIN $JJ))))))))
		  ((< N $JJ) SUM0012)))
	   ((= N (1- |0|)) 0)
	   (T (INTERVAL-ERROR '$SUM |0| N))))
       1 (TRD-MSYMEVAL $DIMENSION 0)))
    (SETQ
      $GR
      (ADD*
	$GR (*MMINUS
	      (SIMPLIFY
		(MFUNCTION-CALL
		  $EXPRESS1 (SIMPLIFY (MFUNCTION-CALL $GRAD $RESULT)))))))
    (SETQ $GR (SIMPLIFY (MFUNCTION-CALL $EV_DIFF $GR)))
    (SETQ
      $GR (SIMPLIFY (MFUNCTION-CALL
		      $TRIGSIMP (SIMPLIFY (MFUNCTION-CALL $RADCAN $GR)))))
    (SETQ $ORIGIN 1)
    (DO ((MDO 1 (+ 1 MDO)))
	((NOT
	   (AND
	     (NOT
	       (IS-BOOLE-CHECK (MGRP $ORIGIN (TRD-MSYMEVAL $DIMENSION 0))))
	     (LIKE (MARRAYREF $GR $ORIGIN) 0)))
	   '$DONE)
      NIL (SETQ $ORIGIN (+ $ORIGIN 1)))
    (COND
      ((NOT (> $ORIGIN (TRD-MSYMEVAL $DIMENSION 0)))
	 (SIMPLIFY
	   (MFUNCTION-CALL
	     $PRINT '|&UNABLE TO PROVE THAT THE|
	     '|&FOLLOWING DIFFERENCE BETWEEN THE INPUT AND THE GRADIENT|
	     '|&OF THE RETURNED RESULT IS ZERO| $GR))))
    (SIMPLIFY (MFUNCTION-CALL
		$TRIGSIMP (SIMPLIFY (MFUNCTION-CALL $RADCAN $RESULT)))))
  0 '$GRPERM '$JJ '$RESULT '$%DUM))

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

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

(DEF-MTRVAR $POTENTIALZEROLOC 0)

(DEFPROP $ZEROLOC T TRANSLATED)

(ADD2LNC '$ZEROLOC $PROPS)

(DEFMTRFUN
 ($ZEROLOC $ANY MDEFINE NIL NIL) NIL NIL
 (COND
   ((NOT (MFUNCTION-CALL
	   $LISTP (TRD-MSYMEVAL $POTENTIALZEROLOC '$POTENTIALZEROLOC)))
      (SIMPLIFY
	(MAP1
	  (GETOPR
	    (M-TLAMBDA
	      ($UU) NIL
	      (SIMPLIFY
		(LIST
		  '(MEQUAL) $UU
		  (TRD-MSYMEVAL $POTENTIALZEROLOC '$POTENTIALZEROLOC)))))
	  (TRD-MSYMEVAL $COORDINATES '$COORDINATES))))
   ((NOT
      (LIKE
	(SIMPLIFY
	  (MFUNCTION-CALL
	    $DISJUNCT (TRD-MSYMEVAL $COORDINATES '$COORDINATES)
	    (SIMPLIFY
	      (MAP1 (GETOPR '$LHS)
		    (TRD-MSYMEVAL $POTENTIALZEROLOC '$POTENTIALZEROLOC)))))
	'((MLIST))))
      (SIMPLIFY (MFUNCTION-CALL
		  $ERROR '|&POTENTIALZEROLOC MUST BE A LIST OF LENGTH|
		  '|&EQUALING THE DIMENSIONALITY OF THE COORDINATE SYSTEM|
		  '|&CONTAINING EQUATIONS WITH EACH COORDINATE VARIABLE|
		  '|&ON THE LHS OF EXACTLY 1 EQUATION,|
		  '|&OR ELSE POTENTIALZEROLOC MUST NOT BE A LIST|)))
   (T (TRD-MSYMEVAL $POTENTIALZEROLOC '$POTENTIALZEROLOC))))

(DEFPROP $CYC T TRANSLATED)

(ADD2LNC '$CYC $PROPS)

(DEFMTRFUN
  ($CYC $ANY MDEFMACRO NIL NIL) ($II) NIL
  (MBUILDQ-SUBST (LIST (CONS '$II $II))
		 '((MPLUS) 1 (($REMAINDER) ((MPLUS) $II $SHIFT) 3))))

(DEFPROP $VPOT T TRANSLATED)

(ADD2LNC '$VPOT $PROPS)

(DEFMTRFUN
 ($VPOT $ANY MDEFINE NIL NIL) ($KURL) NIL
 ((LAMBDA ($ORIGIN $SHIFT)
   (DECLARE (FIXNUM $SHIFT))
   NIL
   (COND
     ((OR (NOT (MFUNCTION-CALL $LISTP $KURL))
	  (NOT (= (MFUNCTION-CALL $LENGTH $KURL) 3)))
	(SIMPLIFY
	  (MFUNCTION-CALL
	    $ERROR
	    '|&1ST ARG OF VECTORPOTENTIAL MUST BE A LIST OF LENGTH 3|))))
   (SETQ $ORIGIN (SIMPLIFY (MFUNCTION-CALL $ZEROLOC)))
   (SETQ $SHIFT 1)
   (DO
     ((MDO 1 (+ 1 MDO)))
     ((NOT
	(AND
	  (NOT (> $SHIFT 3))
	  (NOT
	    (LIKE (SIMPLIFY (MFUNCTION-CALL $LHS (MARRAYREF $ORIGIN 1)))
		  (MARRAYREF
		    (TRD-MSYMEVAL $COORDINATES '$COORDINATES) $SHIFT)))))
	'$DONE)
     (SETQ $SHIFT (+ $SHIFT 1)))
   (SETQ $SHIFT (+ $SHIFT 1))
   (COND
     ((OR
	(> $SHIFT 4)
	(NOT (LIKE (SIMPLIFY (MFUNCTION-CALL $LHS (MARRAYREF $ORIGIN 2)))
		   (MARRAYREF (TRD-MSYMEVAL $COORDINATES '$COORDINATES)
			      (+ 1 (REMAINDER (+ 2 $SHIFT) 3)))))
	(NOT (LIKE (SIMPLIFY (MFUNCTION-CALL $LHS (MARRAYREF $ORIGIN 3)))
		   (MARRAYREF (TRD-MSYMEVAL $COORDINATES '$COORDINATES)
			      (+ 1 (REMAINDER (+ 3 $SHIFT) 3))))))
	(SIMPLIFY
	  (MFUNCTION-CALL
	    $ERROR '|&LEFT SIDES OF POTENTIALZEROLOC MUST BE A CYCLIC|
	    '|&PERMUTATION OF COORDINATES|))))
   (SETQ
    $ORIGIN
    (LIST
      '(MLIST)
      (DIV
	(ADD*
	  (SIMPLIFY
	    (MFUNCTION-CALL
	      $MYINT
	      (MUL* (MARRAYREF (TRD-MSYMEVAL $SF '((MLIST)))
			       (+ 1 (REMAINDER (+ 1 $SHIFT) 3)))
		    (MARRAYREF (TRD-MSYMEVAL $SF '((MLIST)))
			       (+ 1 (REMAINDER (+ 3 $SHIFT) 3)))
		    (MARRAYREF $KURL (+ 1 (REMAINDER (+ 2 $SHIFT) 3))))
	      (SIMPLIFY (MFUNCTION-CALL $LHS (MARRAYREF $ORIGIN 3)))
	      (SIMPLIFY (MFUNCTION-CALL $RHS (MARRAYREF $ORIGIN 3)))
	      (SIMPLIFY (MFUNCTION-CALL $LHS (MARRAYREF $ORIGIN 3)))))
	  (*MMINUS
	    (SIMPLIFY
	      (MFUNCTION-CALL
		$MYINT
		(MUL*
		  (MARRAYREF (TRD-MSYMEVAL $SF '((MLIST)))
			     (+ 1 (REMAINDER (+ 1 $SHIFT) 3)))
		  (MARRAYREF (TRD-MSYMEVAL $SF '((MLIST)))
			     (+ 1 (REMAINDER (+ 2 $SHIFT) 3)))
		  (SIMPLIFY
		    (MFUNCTION-CALL
		      $SUBSTITUTE (MARRAYREF $ORIGIN 3)
		      (MARRAYREF $KURL (+ 1 (REMAINDER (+ 3 $SHIFT) 3))))))
		(SIMPLIFY (MFUNCTION-CALL $LHS (MARRAYREF $ORIGIN 2)))
		(SIMPLIFY (MFUNCTION-CALL $RHS (MARRAYREF $ORIGIN 2)))
		(SIMPLIFY (MFUNCTION-CALL $LHS (MARRAYREF $ORIGIN 2)))))))
	(MARRAYREF (TRD-MSYMEVAL $SF '((MLIST)))
		   (+ 1 (REMAINDER (+ 1 $SHIFT) 3))))
      (DIV
	(*MMINUS
	  (SIMPLIFY
	    (MFUNCTION-CALL
	      $MYINT
	      (MUL* (MARRAYREF (TRD-MSYMEVAL $SF '((MLIST)))
			       (+ 1 (REMAINDER (+ 2 $SHIFT) 3)))
		    (MARRAYREF (TRD-MSYMEVAL $SF '((MLIST)))
			       (+ 1 (REMAINDER (+ 3 $SHIFT) 3)))
		    (MARRAYREF $KURL (+ 1 (REMAINDER (+ 1 $SHIFT) 3))))
	      (SIMPLIFY (MFUNCTION-CALL $LHS (MARRAYREF $ORIGIN 3)))
	      (SIMPLIFY (MFUNCTION-CALL $RHS (MARRAYREF $ORIGIN 3)))
	      (SIMPLIFY (MFUNCTION-CALL $LHS (MARRAYREF $ORIGIN 3))))))
	(MARRAYREF (TRD-MSYMEVAL $SF '((MLIST)))
		   (+ 1 (REMAINDER (+ 2 $SHIFT) 3))))
      0))
   (SETQ
     $ORIGIN
     (LIST
       '(MLIST)
       (MARRAYREF
	 $ORIGIN
	 (+ 1 (REMAINDER (+ (+ 1 (REMAINDER (+ 1 $SHIFT) 3)) $SHIFT) 3)))
       (MARRAYREF
	 $ORIGIN
	 (+ 1 (REMAINDER (+ (+ 1 (REMAINDER (+ 2 $SHIFT) 3)) $SHIFT) 3)))
       (MARRAYREF
	 $ORIGIN
	 (+ 1
	    (REMAINDER (+ (+ 1 (REMAINDER (+ 3 $SHIFT) 3)) $SHIFT) 3)))))
   (SETQ
     $KURL
     (ADD* $KURL
	   (*MMINUS
	     (SIMPLIFY (MFUNCTION-CALL
			 $EXPRESS1 (SIMPLIFY (LIST '($CURL) $ORIGIN)))))))
   (SETQ $KURL (SIMPLIFY (MFUNCTION-CALL $EV_DIFF $KURL)))
   (SETQ
     $KURL
     (SIMPLIFY (MFUNCTION-CALL
		 $TRIGSIMP (SIMPLIFY (MFUNCTION-CALL $RADCAN $KURL)))))
   (DO (($JJ 1 (+ 1 $JJ))) ((> $JJ 3) '$DONE)
     (COND
       ((NOT (LIKE (MARRAYREF $KURL $JJ) 0))
	  (SIMPLIFY
	    (MFUNCTION-CALL
	      $PRINT
	      '|&UNABLE TO PROVE THAT THE FOLLOWING DIFFERENCE BETWEEN A|
	      '|&COMPONENT OF THE INPUT AND OF THE CURL OUTPUT IS ZERO|
	      (MARRAYREF $KURL $JJ))))))
   $ORIGIN)
  '$ORIGIN 0))

(DEFPROP $DISJUNCT T TRANSLATED)

(ADD2LNC '$DISJUNCT $PROPS)

(DEFMTRFUN
  ($DISJUNCT $ANY MDEFINE NIL NIL) ($L1 $L2) NIL
  (SIMPLIFY
    (MFUNCTION-CALL $APPEND (SIMPLIFY (MFUNCTION-CALL $SETDIFF $L1 $L2))
		    (SIMPLIFY (MFUNCTION-CALL $SETDIFF $L2 $L1)))))

(DEFPROP $SETDIFF T TRANSLATED)

(ADD2LNC '$SETDIFF $PROPS)

(DEFMTRFUN
  ($SETDIFF $ANY MDEFINE NIL NIL) ($L1 $L2) NIL
  (COND
    ((LIKE $L1 '((MLIST))) '((MLIST)))
    ((MFUNCTION-CALL $MEMBER (SIMPLIFY ($FIRST $L1)) $L2)
       (SIMPLIFY (MFUNCTION-CALL
		   $SETDIFF (SIMPLIFY (MFUNCTION-CALL $REST $L1)) $L2)))
    (T (SIMPLIFY
	 (MFUNCTION-CALL
	   $CONS (SIMPLIFY ($FIRST $L1))
	   (SIMPLIFY
	     (MFUNCTION-CALL
	       $SETDIFF (SIMPLIFY (MFUNCTION-CALL $REST $L1)) $L2)))))))

(DEFPROP $SUBLESS T TRANSLATED)

(ADD2LNC '$SUBLESS $PROPS)

(DEFMTRFUN
  ($SUBLESS $ANY MDEFINE NIL NIL)
  ($KK $ORIGIN $GRPERM) (DECLARE (FIXNUM $KK))
  (PROGN
    NIL
    ((LAMBDA ($ANS $%DUM)
       NIL
       (SETQ
	 $ANS (SIMPLIFY
		(MFUNCTION-CALL
		  $RATSUBST $%DUM
		  (SIMPLIFY (MFUNCTION-CALL $LHS (MARRAYREF $ORIGIN $KK)))
		  (MARRAYREF $GRPERM $KK))))
       (DO (($L1 1 (+ 1 $L1))) ((> $L1 (+ $KK -1)) '$DONE)
	 (SETQ $ANS
	       (SIMPLIFY
		 (MFUNCTION-CALL
		   $RATSUBST
		   (SIMPLIFY (MFUNCTION-CALL $RHS (MARRAYREF $ORIGIN $L1)))
		   (SIMPLIFY (MFUNCTION-CALL $LHS (MARRAYREF $ORIGIN $L1)))
		   $ANS))))
       $ANS)
     '$ANS '$%DUM)))

(DEFPROP $MYINT T TRANSLATED)

(ADD2LNC '$MYINT $PROPS)

(DEFMTRFUN
 ($MYINT $ANY MDEFINE NIL NIL) ($FUN $VAR $LOW $HIGH) NIL
 ((LAMBDA ($RESULT $ATLOW $ATHIGH)
    NIL
    (PROG ()
	(SETQ $RESULT (SIMPLIFY (MFUNCTION-CALL $INTEGRATE $FUN $VAR)))
	(COND
	  ((MFUNCTION-CALL
	     $FREEOF (SIMPLIFY (MFUNCTION-CALL $NOUNIFY '$INTEGRATE))
	     $RESULT)
	     (SETQ $ATLOW
		   (SIMPLIFY (MFUNCTION-CALL $EVLIMIT $RESULT $VAR $LOW)))
	     (COND ((LIKE $ATLOW NIL) (GO $NOGOOD)))
	     (SETQ $ATHIGH
		   (SIMPLIFY (MFUNCTION-CALL $EVLIMIT $RESULT $VAR $HIGH)))
	     (COND ((LIKE $ATHIGH NIL) (GO $NOGOOD)))
	     (RETURN
	       (SIMPLIFY (MFUNCTION-CALL
			   $RADCAN (ADD* $ATHIGH (*MMINUS $ATLOW)))))))
	$NOGOOD
	(RETURN
	  (SIMPLIFY (MFUNCTION-CALL $DEFINT $FUN $VAR $LOW $HIGH)))))
  '$RESULT '$ATLOW '$ATHIGH))

(DEFPROP $EVLIMIT T TRANSLATED)

(ADD2LNC '$EVLIMIT $PROPS)

(DEFMTRFUN
  ($EVLIMIT $ANY MDEFINE NIL NIL) ($EXPR $VAR $LIM) NIL
  ((LAMBDA ($TEMP)
     NIL
     (PROG ()
	  (COND ((OR (LIKE $LIM '$MINF) (LIKE $LIM '$INF)) (GO $USELIMIT)))
	  (SETQ
	    $TEMP
	    ((LAMBDA (ERRCATCH RET)
	       (COND
		 ((NULL
		    (SETQ
		      RET
		      (ERRSET
			(PROGN
			  (SIMPLIFY
			    (MFUNCTION-CALL $SUBSTITUTE $LIM $VAR $EXPR)))
			LISPERRPRINT)))
		    (ERRLFUN1 ERRCATCH)))
	       (CONS '(MLIST) RET))
	     (CONS BINDLIST LOCLIST) NIL))
	  (COND
	    ((NOT (LIKE $TEMP '((MLIST)))) (RETURN (MARRAYREF $TEMP 1))))
	  $USELIMIT
	  (SETQ $TEMP (SIMPLIFY (MFUNCTION-CALL $LIMIT $EXPR $VAR $LIM)))
	  (COND ((MFUNCTION-CALL
		   $MEMBER $TEMP '((MLIST) $INF $MINF $UND $IND $INFINITY))
		   (RETURN NIL)))
	  (RETURN
	    (COND ((MFUNCTION-CALL
		     $FREEOF
		     (SIMPLIFY (MFUNCTION-CALL $NOUNIFY '$LIMIT)) $TEMP)
		     $TEMP)))))
   '$TEMP))

(compile-forms-to-compile-queue)

