diff --git a/ansi-tests/load-numbers.lsp b/ansi-tests/load-numbers.lsp
index 6d603b6c47342160fcb6c022baa5d2e37b336d2f..b668ae920edf7afb89d88a5f01941c4a420fa6e6 100644
--- a/ansi-tests/load-numbers.lsp
+++ b/ansi-tests/load-numbers.lsp
@@ -7,3 +7,4 @@
 
 (compile-and-load "numbers-aux.lsp")
 (load "number-comparison.lsp")
+(load "max.lsp")
diff --git a/ansi-tests/max.lsp b/ansi-tests/max.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..76ebdb9d5a07c974e8bb674c1da9ddbd869f093a
--- /dev/null
+++ b/ansi-tests/max.lsp
@@ -0,0 +1,36 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Sun Aug  3 15:55:17 2003
+;;;; Contains: Tests of MAX
+
+(in-package :cl-test)
+
+(compile-and-load "numbers-aux.lsp")
+
+(deftest max.error.1
+  (classify-error (max))
+  program-error)
+
+(deftest max.error.2
+  (loop for x in *mini-universe*
+	unless (or (realp x)
+		   (eq (classify-error** `(classify-error (max ',x)))
+		       'type-error))
+	collect x)
+  nil)
+
+(deftest max.1
+  (loop for n in *reals*
+	when (or (not (eql (max n) n))
+		 (not (eql (max n n) n))
+		 (not (eql (max n n n) n))
+		 (not (eql (apply #'max (make-list
+					 (min 256 call-arguments-limit)
+					 :initial-element n))
+			   n)))
+	collect n)
+  nil)
+
+(deftest max.2
+  (max.2-fn)
+  nil)
diff --git a/ansi-tests/number-comparison.lsp b/ansi-tests/number-comparison.lsp
index f7dada5bec63df2cd28124497d31abb165aa9a52..e773f16a3530910fa7cd91cd641cdd44e6597bfe 100644
--- a/ansi-tests/number-comparison.lsp
+++ b/ansi-tests/number-comparison.lsp
@@ -157,6 +157,36 @@
 	  collect (list a b c d)))
   nil)
 
+(deftest =.order.1
+  (let ((i 0) x y)
+    (values
+     (= (progn (setf x (incf i)) 1)
+	(progn (setf y (incf i)) 2))
+     i x y))
+  nil 2 1 2)
+
+(deftest =.order.2
+  (let ((i 0) x y z)
+    (values
+     (= (progn (setf x (incf i)) 1)
+	(progn (setf y (incf i)) 2)
+	(progn (setf z (incf i)) 3))
+     i x y z))
+  nil 3 1 2 3)
+
+(deftest =.order.3
+  (let ((i 0) u v w x y z)
+    (values
+     (=
+      (progn (setf u (incf i)) 1)
+      (progn (setf v (incf i)) 2)
+      (progn (setf w (incf i)) 3)
+      (progn (setf x (incf i)) 4)
+      (progn (setf y (incf i)) 5)
+      (progn (setf z (incf i)) 6))
+     i u v w x y z))
+  nil 6 1 2 3 4 5 6)
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (deftest /=.1
@@ -270,6 +300,37 @@
 		collect (list x y))))
   nil)
 
+(deftest /=.order.1
+  (let ((i 0) x y)
+    (values
+     (notnot (/= (progn (setf x (incf i)) 1)
+		 (progn (setf y (incf i)) 2)))
+     i x y))
+  t 2 1 2)
+
+(deftest /=.order.2
+  (let ((i 0) x y z)
+    (values
+     (notnot (/= (progn (setf x (incf i)) 1)
+		 (progn (setf y (incf i)) 2)
+		 (progn (setf z (incf i)) 3)))
+     i x y z))
+  t 3 1 2 3)
+
+(deftest /=.order.3
+  (let ((i 0) u v w x y z)
+    (values
+     (notnot
+      (/=
+       (progn (setf u (incf i)) 1)
+       (progn (setf v (incf i)) 2)
+       (progn (setf w (incf i)) 3)
+       (progn (setf x (incf i)) 4)
+       (progn (setf y (incf i)) 5)
+       (progn (setf z (incf i)) 6)))
+     i u v w x y z))
+  t 6 1 2 3 4 5 6)
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (deftest <.1
@@ -409,6 +470,37 @@
   (<.10-fn)
   nil)
 
+(deftest <.order.1
+  (let ((i 0) x y)
+    (values
+     (notnot (< (progn (setf x (incf i)) 1)
+		 (progn (setf y (incf i)) 2)))
+     i x y))
+  t 2 1 2)
+
+(deftest <.order.2
+  (let ((i 0) x y z)
+    (values
+     (notnot (< (progn (setf x (incf i)) 1)
+		 (progn (setf y (incf i)) 2)
+		 (progn (setf z (incf i)) 3)))
+     i x y z))
+  t 3 1 2 3)
+
+(deftest <.order.3
+  (let ((i 0) u v w x y z)
+    (values
+     (notnot
+      (<
+       (progn (setf u (incf i)) 1)
+       (progn (setf v (incf i)) 2)
+       (progn (setf w (incf i)) 3)
+       (progn (setf x (incf i)) 4)
+       (progn (setf y (incf i)) 5)
+       (progn (setf z (incf i)) 6)))
+     i u v w x y z))
+  t 6 1 2 3 4 5 6)
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (deftest <=.1
@@ -545,6 +637,38 @@
   (<=.9-fn)
   nil)
 
+(deftest <=.order.1
+  (let ((i 0) x y)
+    (values
+     (notnot (<= (progn (setf x (incf i)) 1)
+		 (progn (setf y (incf i)) 2)))
+     i x y))
+  t 2 1 2)
+
+(deftest <=.order.2
+  (let ((i 0) x y z)
+    (values
+     (notnot (<= (progn (setf x (incf i)) 1)
+		 (progn (setf y (incf i)) 2)
+		 (progn (setf z (incf i)) 3)))
+     i x y z))
+  t 3 1 2 3)
+
+(deftest <=.order.3
+  (let ((i 0) u v w x y z)
+    (values
+     (notnot
+      (<=
+       (progn (setf u (incf i)) 1)
+       (progn (setf v (incf i)) 2)
+       (progn (setf w (incf i)) 3)
+       (progn (setf x (incf i)) 4)
+       (progn (setf y (incf i)) 5)
+       (progn (setf z (incf i)) 6)))
+     i u v w x y z))
+  t 6 1 2 3 4 5 6)
+
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (deftest >.1
@@ -597,6 +721,37 @@
   (>.8-fn)
   nil)
 
+(deftest >.order.1
+  (let ((i 0) x y)
+    (values
+     (notnot (> (progn (setf x (incf i)) 2)
+		(progn (setf y (incf i)) 1)))
+     i x y))
+  t 2 1 2)
+
+(deftest >.order.2
+  (let ((i 0) x y z)
+    (values
+     (notnot (> (progn (setf x (incf i)) 3)
+		 (progn (setf y (incf i)) 2)
+		 (progn (setf z (incf i)) 1)))
+     i x y z))
+  t 3 1 2 3)
+
+(deftest >.order.3
+  (let ((i 0) u v w x y z)
+    (values
+     (notnot
+      (>
+       (progn (setf u (incf i)) 6)
+       (progn (setf v (incf i)) 5)
+       (progn (setf w (incf i)) 4)
+       (progn (setf x (incf i)) 3)
+       (progn (setf y (incf i)) 2)
+       (progn (setf z (incf i)) 1)))
+     i u v w x y z))
+  t 6 1 2 3 4 5 6)
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (deftest >=.1
@@ -652,6 +807,37 @@
   (>=.8-fn)
   nil)
 
+(deftest >=.order.1
+  (let ((i 0) x y)
+    (values
+     (notnot (>= (progn (setf x (incf i)) 2)
+		(progn (setf y (incf i)) 1)))
+     i x y))
+  t 2 1 2)
+
+(deftest >=.order.2
+  (let ((i 0) x y z)
+    (values
+     (notnot (>= (progn (setf x (incf i)) 3)
+		 (progn (setf y (incf i)) 2)
+		 (progn (setf z (incf i)) 1)))
+     i x y z))
+  t 3 1 2 3)
+
+(deftest >=.order.3
+  (let ((i 0) u v w x y z)
+    (values
+     (notnot
+      (>=
+       (progn (setf u (incf i)) 6)
+       (progn (setf v (incf i)) 5)
+       (progn (setf w (incf i)) 4)
+       (progn (setf x (incf i)) 3)
+       (progn (setf y (incf i)) 2)
+       (progn (setf z (incf i)) 1)))
+     i u v w x y z))
+  t 6 1 2 3 4 5 6)
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;;; Comparison of rationals
diff --git a/ansi-tests/numbers-aux.lsp b/ansi-tests/numbers-aux.lsp
index a7d52d8c72e370cfd74afda29022ec1100438132..22db26fe269bfb7ffaa4965be3d323153c6bfc8b 100644
--- a/ansi-tests/numbers-aux.lsp
+++ b/ansi-tests/numbers-aux.lsp
@@ -29,70 +29,58 @@
 	      collect (list x y))))
 
 (defun <.8-fn ()
-  (loop for x in *numbers*
-	when (realp x)
+  (loop for x in *reals*
 	nconc
-	(loop for y in *numbers*
-	      when (and (realp y) (and (< x y) (> x y)))
+	(loop for y in *reals*
+	      when (and (< x y) (> x y))
 	      collect (list x y))))
 
 (defun <.9-fn ()
-  (loop for x in *numbers*
-	when (realp x)
+  (loop for x in *reals*
 	nconc
-	(loop for y in *numbers*
-	      when (and (realp y) (if (< x y)
-				      (not (> y x))
-				    (> y x)))
+	(loop for y in *reals*
+	      when (if (< x y) (not (> y x))
+		     (> y x))
 	      collect (list x y))))
 
 (defun <.10-fn ()
-  (loop for x in *numbers*
-	when (realp x)
+  (loop for x in *reals*
 	nconc
-	(loop for y in *numbers*
-	      when (and (realp y) (if (< x y)
-				      (>= x y)
-				    (not (>= x y))))
+	(loop for y in *reals*
+	      when (if (< x y) (>= x y)
+		     (not (>= x y)))
 	      collect (list x y))))
 
 (defun <=.8-fn ()
-  (loop for x in *numbers*
-	when (realp x)
+  (loop for x in *reals*
 	nconc
-	(loop for y in *numbers*
-	      when (and (realp y) (if (<= x y) (not (>= y x))
-				    (>= y x)))
+	(loop for y in *reals*
+	      when (if (<= x y) (not (>= y x))
+		     (>= y x))
 	      collect (list x y))))
  
 (defun <=.9-fn ()
-  (loop for x in *numbers*
-	when (realp x)
+  (loop for x in *reals*
 	nconc
-	(loop for y in *numbers*
-	      when (and (realp y)
-			(if (<= x y) (not (or (= x y) (< x y)))
-			  (or (= x y) (< x y))))
+	(loop for y in *reals*
+	      when (if (<= x y) (not (or (= x y) (< x y)))
+		     (or (= x y) (< x y)))
 	      collect (list x y))))
 
 (defun >.8-fn ()
-  (loop for x in *numbers*
-	when (realp x)
+  (loop for x in *reals*
 	nconc
-	(loop for y in *numbers*
-	      when (and (realp y) (if (> x y)
-				      (<= x y)
-				    (not (<= x y))))
+	(loop for y in *reals*
+	      when (if (> x y) (<= x y)
+		     (not (<= x y)))
 	      collect (list x y))))
 
 (defun >=.8-fn ()
-  (loop for x in *numbers*
-	when (realp x)
+  (loop for x in *reals*
 	nconc
-	(loop for y in *numbers*
-	      when (and (realp y)
-			(if (>= x y) (not (or (= x y) (> x y)))
-			  (or (= x y) (> x y))))
+	(loop for y in *reals*
+	      when (if (>= x y) (not (or (= x y) (> x y)))
+		     (or (= x y) (> x y)))
 	      collect (list x y))))
 
 ;;; Comparison of rationsls
@@ -121,5 +109,11 @@
 		   (if (/= q1 q2) (not (/= ad bc)) (/= ad bc)))))
 	collect (list a b c d)))
 
-		   
-	
+(defun max.2-fn ()
+  (loop for x in *reals*
+	nconc
+	(loop for y in *reals*
+	      for m = (max x y)
+	      unless (and (>= m x) (>= m y)
+			  (or (= m x) (= m y)))
+	      collect (list x y m))))
diff --git a/ansi-tests/universe.lsp b/ansi-tests/universe.lsp
index 6faba599be61359007da67798d7bcfbb656c81aa..b153a6238f334a9a9b53f89c2348fb8bf448f53a 100644
--- a/ansi-tests/universe.lsp
+++ b/ansi-tests/universe.lsp
@@ -134,6 +134,8 @@
 	    *ratios*
 	    *complexes*))
 
+(defvar *reals* (append *integers* *floats* *ratios*))
+
 (defun try-to-read-chars (&rest namelist)
   (loop
     for name in namelist append