diff --git a/ansi-tests/TODO b/ansi-tests/TODO
index c350862861fbf7564a84fd2e09a94b5c0232e6b3..ab5744dcd72a3604ad997f5a2c0ef83a2901b26f 100644
--- a/ansi-tests/TODO
+++ b/ansi-tests/TODO
@@ -90,3 +90,6 @@ Got:      0
   a collection of random test harnesses.
 
 27. Be sure the various string operations work on non-simple strings.
+
+28. Add tests for reading/printing with packages with weird names (lower case letters,
+  digits, etc.)
diff --git a/ansi-tests/ansi-aux.lsp b/ansi-tests/ansi-aux.lsp
index 79edb25bb2063308efbec961e4882d822784198f..4b702a6e040382c18009109f5deb4c73cd569aaf 100644
--- a/ansi-tests/ansi-aux.lsp
+++ b/ansi-tests/ansi-aux.lsp
@@ -944,6 +944,3 @@ the condition to go uncaught if it cannot be classified."
 	 (*read-suppress* nil)
 	 (*readtable* (copy-readtable nil)))
      ,@body))
-
-	 
-	 
\ No newline at end of file
diff --git a/ansi-tests/format-a.lsp b/ansi-tests/format-a.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..4f35888a5f9c8d8566e71fc05cbf74b3f6b5c1cd
--- /dev/null
+++ b/ansi-tests/format-a.lsp
@@ -0,0 +1,393 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Mon Aug  2 01:42:35 2004
+;;;; Contains: Tests of printing using the ~A directive
+
+(in-package :cl-test)
+
+(deftest format.a.1
+  (with-standard-io-syntax
+   (format nil "~a" nil))
+  "NIL")
+
+(deftest format.a.2
+  (with-standard-io-syntax
+   (let ((*print-case* :downcase))
+     (format nil "~A" nil)))
+  "nil")
+
+(deftest format.a.3
+  (with-standard-io-syntax
+   (let ((*print-case* :capitalize))
+     (format nil "~a" nil)))
+  "Nil")
+
+(deftest format.a.4
+  (format nil "~:a" nil)
+  "()")
+
+(deftest format.a.5
+  (with-standard-io-syntax
+   (format nil "~:A" '(nil)))
+  "(NIL)")
+
+(deftest format.a.6
+  (with-standard-io-syntax
+   (format nil "~:A" #(nil)))
+  "#(NIL)")
+
+(deftest format.a.7
+  (loop for c across +standard-chars+
+	for s1 = (string c)
+	for s2 = (format nil "~a" s1)
+	unless (string= s1 s2)
+	collect (list c s1 s2))
+  nil)
+
+(deftest format.a.8
+  (loop with count = 0
+	for i from 0 below (min #x10000 char-code-limit)
+	for c = (code-char i)
+	for s1 = (and c (string c))
+	for s2 = (and c (format nil "~A" s1))
+	unless (or (null c) (string= s1 s2))
+	do (incf count) and collect (list c s1 s2)
+	when (> count 100) collect "count limit exceeded" and do (loop-finish))
+  nil)
+
+(deftest format.a.9
+  (with-standard-io-syntax
+   (apply
+    #'values
+    (loop for i from 1 to 10
+	  for s1 = (format nil "~~~d@a" i)
+	  for s2 = (format nil s1 nil)
+	  collect s2)))
+  "NIL"
+  "NIL"
+  "NIL"
+  " NIL"
+  "  NIL"
+  "   NIL"
+  "    NIL"
+  "     NIL"
+  "      NIL"
+  "       NIL")
+
+(deftest format.a.10
+  (with-standard-io-syntax
+   (apply
+    #'values
+    (loop for i from 1 to 10
+	  for s1 = (format nil "~~~da" i)
+	  for s2 = (format nil s1 nil)
+	  collect s2)))
+  "NIL"
+  "NIL"
+  "NIL"
+  "NIL "
+  "NIL  "
+  "NIL   "
+  "NIL    "
+  "NIL     "
+  "NIL      "
+  "NIL       ")
+
+(deftest format.a.11
+  (with-standard-io-syntax
+   (apply
+    #'values
+    (loop for i from 1 to 10
+	  for s1 = (format nil "~~~d@:A" i)
+	  for s2 = (format nil s1 nil)
+	  collect s2)))
+  "()"
+  "()"
+  " ()"
+  "  ()"
+  "   ()"
+  "    ()"
+  "     ()"
+  "      ()"
+  "       ()"
+  "        ()")
+
+(deftest format.a.12
+  (with-standard-io-syntax
+   (apply
+    #'values
+    (loop for i from 1 to 10
+	  for s1 = (format nil "~~~d:a" i)
+	  for s2 = (format nil s1 nil)
+	  collect s2)))
+  "()"
+  "()"
+  "() "
+  "()  "
+  "()   "
+  "()    "
+  "()     "
+  "()      "
+  "()       "
+  "()        ")
+
+(deftest format.a.13
+  (with-standard-io-syntax
+   (apply
+    #'values
+    (loop for i from 1 to 10
+	  for s2 = (format nil "~v:A" i nil)
+	  collect s2)))
+  "()"
+  "()"
+  "() "
+  "()  "
+  "()   "
+  "()    "
+  "()     "
+  "()      "
+  "()       "
+  "()        ")
+
+(deftest format.a.14
+  (with-standard-io-syntax
+   (apply
+    #'values
+    (loop for i from 1 to 10
+	  for s2 = (format nil "~v:@a" i nil)
+	  collect s2)))
+  "()"
+  "()"
+  " ()"
+  "  ()"
+  "   ()"
+  "    ()"
+  "     ()"
+  "      ()"
+  "       ()"
+  "        ()")
+
+(deftest format.a.15
+  (with-standard-io-syntax
+   (format nil "~vA" nil nil))
+  "NIL")
+
+(deftest format.a.16
+  (with-standard-io-syntax
+   (format nil "~v:A" nil nil))
+  "()")
+
+(deftest format.a.17
+  (with-standard-io-syntax
+   (format nil "~@A" nil))
+  "NIL")
+
+(deftest format.a.18
+  (with-standard-io-syntax
+   (format nil "~v@A" nil nil))
+  "NIL")
+
+(deftest format.a.19
+  (with-standard-io-syntax
+   (format nil "~v:@a" nil nil))
+  "()")
+
+(deftest format.a.20
+  (with-standard-io-syntax
+   (format nil "~v@:a" nil nil))
+  "()")
+
+;;; With colinc specified
+
+(deftest format.a.21
+  (format nil "~3,1a" nil)
+  "NIL")
+
+(deftest format.a.22
+  (format nil "~4,3a" nil)
+  "NIL   ")
+
+(deftest format.a.23
+  (format nil "~3,3@a" nil)
+  "NIL")
+
+(deftest format.a.24
+  (format nil "~4,4@a" nil)
+  "    NIL")
+
+(deftest format.a.25
+  (format nil "~5,3@a" nil)
+  "   NIL")
+
+(deftest format.a.26
+  (format nil "~5,3A" nil)
+  "NIL   ")
+
+(deftest format.a.27
+  (format nil "~7,3@a" nil)
+  "      NIL")
+
+(deftest format.a.28
+  (format nil "~7,3A" nil)
+  "NIL      ")
+
+;;; With minpad
+
+(deftest format.a.29
+  (loop for i from -4 to 10
+	collect (format nil "~v,,2A" i "ABC"))
+  ("ABC  "
+   "ABC  "
+   "ABC  "
+   "ABC  "
+   "ABC  "
+   "ABC  "
+   "ABC  "
+   "ABC  "
+   "ABC  "
+   "ABC  "
+   "ABC   "
+   "ABC    "
+   "ABC     "
+   "ABC      "
+   "ABC       "))
+
+(deftest format.a.30
+  (format nil "~3,,+2A" "ABC")
+  "ABC  ")
+
+(deftest format.a.31
+  (format nil "~3,,0A" "ABC")
+  "ABC")
+
+(deftest format.a.32
+  (format nil "~3,,-1A" "ABC")
+  "ABC")
+
+(deftest format.a.33
+  (format nil "~3,,0A" "ABCD")
+  "ABCD")
+
+(deftest format.a.34
+  (format nil "~3,,-1A" "ABCD")
+  "ABCD")
+
+;;; With padchar
+
+(deftest format.a.35
+  (format nil "~4,,,'XA" "AB")
+  "ABXX")
+
+(deftest format.a.36
+  (format nil "~4,,,a" "AB")
+  "AB  ")
+
+(deftest format.a.37
+  (format nil "~4,,,'X@a" "AB")
+  "XXAB")
+
+(deftest format.a.38
+  (format nil "~4,,,@A" "AB")
+  "  AB")
+
+(deftest format.a.39
+  (format nil "~10,,,vA" nil "abcde")
+  "abcde     ")
+
+(deftest format.a.40
+  (format nil "~10,,,v@A" nil "abcde")
+  "     abcde")
+
+(deftest format.a.41
+  (format nil "~10,,,va" #\* "abcde")
+  "abcde*****")
+
+(deftest format.a.42
+  (format nil "~10,,,v@a" #\* "abcde")
+  "*****abcde")
+
+;;; Other tests
+
+(deftest format.a.43
+  (format nil "~3,,vA" nil "ABC")
+  "ABC")
+
+(deftest format.a.44
+  (loop for i from 0 to 6
+	collect (format nil "~3,,vA" i "ABC"))
+  ("ABC"
+   "ABC "
+   "ABC  "
+   "ABC   "
+   "ABC    "
+   "ABC     "
+   "ABC      "))
+
+(deftest format.a.44a
+  (loop for i from 0 to 6
+	collect (format nil "~3,,v@A" i "ABC"))
+  ("ABC"
+   " ABC"
+   "  ABC"
+   "   ABC"
+   "    ABC"
+   "     ABC"
+   "      ABC"))
+
+(deftest format.a.45
+  (format nil "~4,,va" -1 "abcd")
+  "abcd")
+
+(deftest format.a.46
+  (format nil "~5,vA" nil "abc")
+  "abc  ")
+
+(deftest format.a.47
+  (format nil "~5,vA" 3 "abc")
+  "abc   ")
+
+(deftest format.a.48
+  (format nil "~5,v@A" 3 "abc")
+  "   abc")
+
+;;; # parameters
+
+(deftest format.a.49
+  (format nil "~#A" "abc" nil nil nil)
+  "abc ")
+
+(deftest format.a.50
+  (format nil "~#@a" "abc" nil nil nil nil nil)
+  "   abc")
+
+(deftest format.a.51
+  (format nil "~5,#a" "abc" nil nil nil)
+  "abc    ")
+
+(deftest format.a.52
+  (format nil "~5,#@A" "abc" nil nil nil)
+  "    abc")
+
+(deftest format.a.53
+  (format nil "~4,#A" "abc" nil nil)
+  "abc   ")
+
+(deftest format.a.54
+  (format nil "~4,#@A" "abc" nil nil)
+  "   abc")
+
+(deftest format.a.55
+  (format nil "~#,#A" "abc" nil nil nil)
+  "abc    ")
+
+(deftest format.a.56
+  (format nil "~#,#@A" "abc" nil nil nil)
+  "    abc")
+
+(deftest format.a.57
+  (format nil "~-100A" "xyz")
+  "xyz")
+
+(deftest format.a.58
+  (format nil "~-100000000000000000000a" "xyz")
+  "xyz")
diff --git a/ansi-tests/format-ampersand.lsp b/ansi-tests/format-ampersand.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..865536231c1298dec5f6a8f469e159c087383f2d
--- /dev/null
+++ b/ansi-tests/format-ampersand.lsp
@@ -0,0 +1,94 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Tue Jul 27 23:52:20 2004
+;;;; Contains: Tests of format with ~& directive
+
+(in-package :cl-test)
+
+(deftest format.&.1
+  (format nil "~0&")
+  "")
+
+(deftest format.&.2
+  (format nil "~&")
+  "")
+
+(deftest format.&.3
+  (format nil "X~&")
+  "X
+")
+
+(deftest format.&.4
+  (format nil "X~%~&")
+  "X
+")
+
+(deftest format.&.5
+  (loop for i from 1 to 100
+	for s1 = (make-string (1- i) :initial-element #\Newline)
+	for s2 = (format nil (format nil "~~~D&" i))
+	unless (string= s1 s2)
+	collect i)
+  nil)
+
+(deftest format.&.6
+  (loop for i from 1 to 100
+	for s1 = (concatenate 'string
+			      "X"
+			      (make-string i :initial-element #\Newline))
+	for s2 = (format nil (format nil "X~~~D&" i))
+	unless (string= s1 s2)
+	collect i)
+  nil)
+
+(deftest format.&.7
+  (format nil "~v&" nil)
+  "")
+
+(deftest format.&.8
+  (format nil "X~v&" nil)
+  "X
+")
+
+(deftest format.&.9
+  (loop for i from 1 to 100
+	for s1 = (make-string (1- i) :initial-element #\Newline)
+	for s2 = (format nil "~V&" i)
+	unless (string= s1 s2)
+	collect i)
+  nil)
+
+(deftest format.&.10
+  (loop for i from 1 to (min (- call-arguments-limit 3) 100)
+	for s1 = (make-string (1- i) :initial-element #\Newline)
+	for args = (make-list i)
+	for s2 = (apply #'format nil "~#&" args)
+	unless (string= s1 s2)
+	collect i)
+  nil)
+
+(deftest format.&.11
+  (format nil "X~V%" 0)
+  "X")
+
+(deftest format.&.12
+  (format nil "X~#%")
+  "X")
+
+(deftest format.&.13
+  (format nil "X~#%" 'a 'b 'c)
+  "X
+
+
+")
+
+
+
+
+
+
+
+
+
+
+
diff --git a/ansi-tests/format-b.lsp b/ansi-tests/format-b.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..90f610108e8fb1fd30ef7d0abe37255d97d3eea9
--- /dev/null
+++ b/ansi-tests/format-b.lsp
@@ -0,0 +1,404 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Sun Aug  1 05:10:10 2004
+;;;; Contains: Tests of the ~B format directive
+
+(in-package :cl-test)
+
+(compile-and-load "printer-aux.lsp")
+
+(deftest format.b.1
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for i = (- (random (+ x x)) x)
+	 for s1 = (format nil "~B" i)
+	 for j = (let ((*read-base* 2)) (read-from-string s1))
+	 repeat 1000
+	 when (or (/= i j)
+		  (find #\+ s1)
+		  (loop for c across s1 thereis (not (find c "-01"))))
+	 collect (list i s1 j)))
+  nil)
+
+(deftest format.b.2
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for i = (- (random (+ x x)) x)
+	 for s1 = (format nil "~@b" i)
+	 for j = (let ((*read-base* 2)) (read-from-string s1))
+	 repeat 1000
+	 when (or (/= i j)
+		  (loop for c across s1 thereis (not (find c "-+01"))))
+	 collect (list i s1 j)))
+  nil)
+
+(deftest format.b.3
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for mincol = (random 30)
+	 for i = (- (random (+ x x)) x)
+	 for s1 = (format nil "~b" i)
+	 for s2 = (format nil (format nil "~~~db" mincol) i)
+	 for pos = (search s1 s2)
+	 repeat 1000
+	 when (or (null pos)
+		  (and (> mincol (length s1))
+		       (or (/= (length s2) mincol)
+			   (not (eql (position #\Space s2 :test-not #'eql)
+				     (- (length s2) (length s1)))))))
+	 collect (list i mincol s1 s2 pos)))
+  nil)
+
+(deftest format.b.4
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for mincol = (random 30)
+	 for i = (- (random (+ x x)) x)
+	 for s1 = (format nil "~@B" i)
+	 for s2 = (format nil (format nil "~~~d@b" mincol) i)
+	 for pos = (search s1 s2)
+	 repeat 1000
+	 when (or (null pos)
+		  (and (>= i 0) (not (eql (elt s1 0) #\+)))
+		  (and (> mincol (length s1))
+		       (or (/= (length s2) mincol)
+			   (not (eql (position #\Space s2 :test-not #'eql)
+				     (- (length s2) (length s1)))))))
+	 collect (list i mincol s1 s2 pos)))
+  nil)
+
+(deftest format.b.5
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for mincol = (random 30)
+	 for padchar = (random-from-seq +standard-chars+)
+	 for i = (- (random (+ x x)) x)
+	 for s1 = (format nil "~b" i)
+	 for s2 = (format nil (format nil "~~~d,'~c~c" mincol padchar
+				      (random-from-seq "bB"))
+			  i)
+	 for pos = (search s1 s2)
+	 repeat 1000
+	 when (or (null pos)
+		  (and (> mincol (length s1))
+		       (or (/= (length s2) mincol)
+			   (find padchar s2 :end (- (length s2) (length s1))
+				 :test-not #'eql))))
+	 collect (list i mincol s1 s2 pos)))
+  nil)
+
+(deftest format.b.6
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for mincol = (random 30)
+	 for padchar = (random-from-seq +standard-chars+)
+	 for i = (- (random (+ x x)) x)
+	 for s1 = (format nil "~b" i)
+	 for s2 = (format nil "~v,vb" mincol padchar i)
+	 for pos = (search s1 s2)
+	 repeat 1000
+	 when (or (null pos)
+		  (and (> mincol (length s1))
+		       (or (/= (length s2) mincol)
+			   (find padchar s2 :end (- (length s2) (length s1))
+				 :test-not #'eql))))
+	 collect (list i mincol s1 s2 pos)))
+  nil)
+
+(deftest format.b.7
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for mincol = (random 30)
+	 for padchar = (random-from-seq +standard-chars+)
+	 for i = (- (random (+ x x)) x)
+	 for s1 = (format nil "~@B" i)
+	 for s2 = (format nil "~v,v@b" mincol padchar i)
+	 for pos = (search s1 s2)
+	 repeat 1000
+	 when (or (null pos)
+		  (and (>= i 0) (not (eql (elt s1 0) #\+)))
+		  (and (> mincol (length s1))
+		       (or (/= (length s2) mincol)
+			   (find padchar s2 :end (- (length s2) (length s1))
+				 :test-not #'eql))))
+	 collect (list i mincol s1 s2 pos)))
+  nil)
+
+;;; Comma tests
+
+(deftest format.b.8
+  (loop for i from -7 to 7
+	for s1 = (format nil "~b" i)
+	for s2 = (format nil "~:b" i)
+	unless (string= s1 s2)
+	collect (list i s1 s2))
+  nil)
+
+(deftest format.b.9
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for i = (- (random (+ x x)) x)
+	 for commachar = #\,
+	 for s1 = (format nil "~b" i)
+	 for s2 = (format nil "~:B" i)
+	 repeat 1000
+	 unless (and (string= s1 (remove commachar s2))
+		     (not (eql (elt s2 0) commachar))
+		     (or (>= i 0) (not (eql (elt s2 1) commachar)))
+		     (let ((len (length s2))
+			   (ci+1 4))
+		       (loop for i from (if (< i 0) 2 1) below len
+			     always (if (= (mod (- len i) ci+1) 0)
+					(eql (elt s2 i) commachar)
+				      (find (elt s2 i) "01")))))
+	 collect (list x i commachar s1 s2)))
+  nil)
+
+(deftest format.b.10
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for i = (- (random (+ x x)) x)
+	 for commachar = (random-from-seq +standard-chars+)
+	 for s1 = (format nil "~b" i)
+	 for s2 = (format nil "~,,v:b" commachar i)
+	 repeat 1000
+	 unless (and
+		 (eql (elt s1 0) (elt s2 0))
+		 (if (< i 0) (eql (elt s1 1) (elt s2 1)) t)
+		 (let ((len (length s2))
+		      (ci+1 4)
+		      (j (if (< i 0) 1 0)))
+		  (loop for i from (if (< i 0) 2 1) below len
+			always (if (= (mod (- len i) ci+1) 0)
+				   (eql (elt s2 i) commachar)
+				 (eql (elt s1 (incf j)) (elt s2 i))))))
+	 collect (list x i commachar s1 s2)))
+  nil)
+
+(deftest format.b.11
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for i = (- (random (+ x x)) x)
+	 for commachar = (random-from-seq +standard-chars+)
+	 for s1 = (format nil "~b" i)
+	 for s2 = (format nil (format nil "~~,,'~c:~c" commachar
+				      (random-from-seq "bB"))
+			  i)
+	 repeat 1000
+	 unless (and
+		 (eql (elt s1 0) (elt s2 0))
+		 (if (< i 0) (eql (elt s1 1) (elt s2 1)) t)
+		 (let ((len (length s2))
+		      (ci+1 4)
+		      (j (if (< i 0) 1 0)))
+		  (loop for i from (if (< i 0) 2 1) below len
+			always (if (= (mod (- len i) ci+1) 0)
+				   (eql (elt s2 i) commachar)
+				 (eql (elt s1 (incf j)) (elt s2 i))))))
+	 collect (list x i commachar s1 s2)))
+  nil)
+
+(deftest format.b.12
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for i = (- (random (+ x x)) x)
+	 for commachar = (random-from-seq +standard-chars+)
+	 for commaint = (1+ (random 20))
+	 for s1 = (format nil "~b" i)
+	 for s2 = (format nil "~,,v,v:B" commachar commaint i)
+	 repeat 1000
+	 unless (and
+		 (eql (elt s1 0) (elt s2 0))
+		 (if (< i 0) (eql (elt s1 1) (elt s2 1)) t)
+		 (let ((len (length s2))
+		       (ci+1 (1+ commaint))
+		       (j (if (< i 0) 1 0)))
+		   (loop for i from (if (< i 0) 2 1) below len
+			 always (if (= (mod (- len i) ci+1) 0)
+				    (eql (elt s2 i) commachar)
+				  (eql (elt s1 (incf j)) (elt s2 i))))))
+	 collect (list x i commachar s1 s2)))
+  nil)
+
+(deftest format.b.13
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for i = (- (random (+ x x)) x)
+	 for commachar = (random-from-seq +standard-chars+)
+	 for commaint = (1+ (random 20))
+	 for s1 = (format nil "~@B" i)
+	 for s2 = (format nil "~,,v,v:@b" commachar commaint i)
+	 repeat 1000
+	 unless (and
+		 (eql (elt s1 0) (elt s2 0))
+		 (eql (elt s1 1) (elt s2 1))
+		 (let ((len (length s2))
+		       (ci+1 (1+ commaint))
+		       (j 1))
+		   (loop for i from 2 below len
+			 always (if (= (mod (- len i) ci+1) 0)
+				    (eql (elt s2 i) commachar)
+				  (eql (elt s1 (incf j)) (elt s2 i))))))
+	 collect (list x i commachar s1 s2)))
+  nil)
+
+;;; NIL arguments
+
+(deftest format.b.14
+  (format nil "~vb" nil #b110100)
+  "110100")
+
+(deftest format.b.15
+  (format nil "~6,vB" nil #b100)
+  "   100")
+
+(deftest format.b.16
+  (format nil "~,,v:b" nil #b10011)
+  "10,011")
+
+(deftest format.b.17
+  (format nil "~,,'*,v:B" nil #b10110)
+  "10*110")
+
+;;; When the argument is not an integer, print as if using ~A and base 10
+
+(deftest format.b.18
+  (loop for x in *mini-universe*
+	for s1 = (format nil "~b" x)
+	for s2 = (let ((*print-base* 2)) (format nil "~A" x))
+	unless (or (integerp x) (string= s1 s2))
+	collect (list x s1 s2))
+  nil)
+
+(deftest format.b.19
+  (loop for x in *mini-universe*
+	for s1 = (format nil "~:B" x)
+	for s2 = (let ((*print-base* 2)) (format nil "~A" x))
+	unless (or (integerp x) (string= s1 s2))
+	collect (list x s1 s2))
+  nil)
+
+(deftest format.b.20
+  (loop for x in *mini-universe*
+	for s1 = (format nil "~@b" x)
+	for s2 = (let ((*print-base* 2)) (format nil "~A" x))
+	unless (or (integerp x) (string= s1 s2))
+	collect (list x s1 s2))
+  nil)
+
+(deftest format.b.21
+  (loop for x in *mini-universe*
+	for s1 = (format nil "~@:B" x)
+	for s2 = (let ((*print-base* 2)) (format nil "~A" x))
+	unless (or (integerp x) (string= s1 s2))
+	collect (list x s1 s2))
+  nil)
+
+;;; Must add tests for non-integers when the parameters
+;;; are specified, but it's not clear what the meaning is.
+;;; Does mincol apply to the ~A equivalent?  What about padchar?
+;;; Are comma-char and comma-interval always ignored?
+
+;;; # arguments
+
+(deftest format.b.22
+  (apply
+   #'values
+   (loop for i from 0 to 10
+	 for args = (make-list i)
+	 for s = (apply #'format nil "~#b" #b11001 args)
+	 collect s))
+  "11001"
+  "11001"
+  "11001"
+  "11001"
+  "11001"
+  " 11001"
+  "  11001"
+  "   11001"
+  "    11001"
+  "     11001"
+  "      11001")
+
+(deftest format.b.23
+  (apply
+   #'values
+   (loop for i from 0 to 10
+	 for args = (make-list i)
+	 for s = (apply #'format nil "~,,,#:B" #b1100100010 args)
+	 collect s))
+  "1,1,0,0,1,0,0,0,1,0"
+  "11,00,10,00,10"
+  "1,100,100,010"
+  "11,0010,0010"
+  "11001,00010"
+  "1100,100010"
+  "110,0100010"
+  "11,00100010"
+  "1,100100010"
+  "1100100010"
+  "1100100010")
+
+(deftest format.b.24
+  (apply
+   #'values
+   (loop for i from 0 to 10
+	 for args = (make-list i)
+	 for s = (apply #'format nil "~,,,#@:B" #b1100100010 args)
+	 collect s))
+  "+1,1,0,0,1,0,0,0,1,0"
+  "+11,00,10,00,10"
+  "+1,100,100,010"
+  "+11,0010,0010"
+  "+11001,00010"
+  "+1100,100010"
+  "+110,0100010"
+  "+11,00100010"
+  "+1,100100010"
+  "+1100100010"
+  "+1100100010")
+
+(deftest format.b.25
+  (format nil "~+10b" #b1101)
+  "      1101")
+
+(deftest format.b.26
+  (format nil "~+10@B" #b1101)
+  "     +1101")
+
+(deftest format.b.27
+  (format nil "~-1b" #b1101)
+  "1101")
+
+(deftest format.b.28
+  (format nil "~-1000000000000000000B" #b1101)
+  "1101")
+
+(deftest format.b.29
+  (format nil "~vb" (1- most-negative-fixnum) #b1101)
+  "1101")
+
+;;; Randomized test
+
+(deftest format.b.30
+  (loop
+   for mincol = (and (coin) (random 50))
+   for padchar = (and (coin)
+		      (random-from-seq +standard-chars+))
+   for commachar = (and (coin)
+			(random-from-seq +standard-chars+))
+   for commaint = (and (coin) (1+ (random 10)))
+   for k = (ash 1 (+ 2 (random 30)))
+   for x = (- (random (+ k k)) k)
+   for fmt = (concatenate
+	      'string
+	      (if mincol (format nil "~~~d," mincol) "~,")
+	      (if padchar (format nil "'~c," padchar) ",")
+	      (if commachar (format nil "'~c," commachar) ",")
+	      (if commaint (format nil "~db" commaint) "b"))
+   for s1 = (format nil fmt x)
+   for s2 = (format nil "~v,v,v,vb" mincol padchar commachar commaint x)
+   repeat 2000
+   unless (string= s1 s2)
+   collect (list mincol padchar commachar commaint fmt x s1 s2))
+  nil)
\ No newline at end of file
diff --git a/ansi-tests/format-c.lsp b/ansi-tests/format-c.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..8f3fa8e4a73002e740a820cab7811e21f7e812e0
--- /dev/null
+++ b/ansi-tests/format-c.lsp
@@ -0,0 +1,118 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Tue Jul 27 23:07:16 2004
+;;;; Contains: Tests of formatted output, ~C directive
+
+(in-package :cl-test)
+
+(compile-and-load "printer-aux.lsp")
+
+;;; Test of the ~C directive
+
+(deftest format.c.1
+  (loop for c across +standard-chars+
+	for s = (format nil "~C" c)
+	unless (string= s (string c))
+	collect (list c s))
+  nil)
+
+(deftest format.c.1a
+  (loop with count = 0
+	for i from 0 below (min #x10000 char-code-limit)
+	for c = (code-char i)
+	for s = (and c (format nil "~c" c))
+	unless (or (not c)
+		   (not (eql (char-code c) (char-int c)))
+		   (string= s (string c)))
+	do (incf count) and collect (list i c s)
+	when (> count 100) collect "count limit exceeded" and do (loop-finish))
+  nil)
+
+(deftest format.c.2
+  (loop for c across +standard-chars+
+	for s = (format nil "~:c" c)
+	unless (or (not (graphic-char-p c))
+		   (eql c #\Space)
+		   (string= s (string c)))
+	collect (list c s))
+  nil)
+
+(deftest format.c.2a
+  (loop with count = 0
+	for i from 0 below (min #x10000 char-code-limit)
+	for c = (code-char i)
+	for s = (and c (format nil "~:C" c))
+	unless (or (not c)
+		   (not (eql (char-code c) (char-int c)))
+		   (not (graphic-char-p c))
+		   (eql c #\Space)
+		   (string= s (string c)))
+	do (incf count) and collect (list i c s)
+	when (> count 100) collect "count limit exceeded" and do (loop-finish))
+  nil)
+
+(deftest format.c.3
+  (format nil "~:C" #\Space)
+  #.(char-name #\Space))
+
+(deftest format.c.4
+  (loop for c across +standard-chars+
+	for s = (format nil "~:C" c)
+	unless (or (graphic-char-p c)
+		   (string= s (char-name c)))
+	collect (list c (char-name c) s))
+  nil)
+
+(deftest format.c.4a
+  (loop with count = 0
+	for i from 0 below (min #x10000 char-code-limit)
+	for c = (code-char i)
+	for s = (and c (format nil "~:c" c))
+	unless (or (not c)
+		   (not (eql (char-code c) (char-int c)))
+		   (graphic-char-p c)
+		   (string= s (char-name c)))
+	do (incf count) and collect (print (list i c s))
+	when (> count 100) collect "count limit exceeded" and do (loop-finish))
+  nil)
+
+(deftest format.c.5
+  (loop for c across +standard-chars+
+	for s = (format nil "~@c" c)
+	for c2 = (read-from-string s)
+	unless (eql c c2)
+	collect (list c s c2))
+  nil)
+
+(deftest format.c.5a
+  (loop with count = 0
+	for i from 0 below (min #x10000 char-code-limit)
+	for c = (code-char i)
+	for s = (and c (format nil "~@C" c))
+	for c2 = (and c (read-from-string s))
+	unless (eql c c2)
+	do (incf count) and collect (list c s c2)
+	when (> count 100) collect "count limit exceeded" and do (loop-finish))
+  nil)
+
+(deftest format.c.6
+  (loop for c across +standard-chars+
+	for s1 = (format nil "~:C" c)
+	for s2 = (format nil "~:@C" c)
+	unless (eql (search s1 s2) 0)
+	collect (list c s1 s2))
+  nil)
+
+(deftest format.c.6a
+  (loop with count = 0
+	for i from 0 below (min #x10000 char-code-limit)
+	for c = (code-char i)
+	for s1 = (and c (format nil "~:C" c))
+	for s2 = (and c (format nil "~@:C" c))
+	unless (or (not c) (eql (search s1 s2) 0))
+	do (incf count) and collect (list c s1 s2)
+	when (> count 100) collect "count limit exceeded" and do (loop-finish))
+  nil)
+
+
+
diff --git a/ansi-tests/format-d.lsp b/ansi-tests/format-d.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..562189c571647691164436e1effb76dd2b2e9354
--- /dev/null
+++ b/ansi-tests/format-d.lsp
@@ -0,0 +1,403 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Sat Jul 31 05:19:39 2004
+;;;; Contains: Tests of the ~D format directive
+
+(in-package :cl-test)
+
+(compile-and-load "printer-aux.lsp")
+
+(deftest format.d.1
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for i = (- (random (+ x x)) x)
+	 for s1 = (format nil "~D" i)
+	 for j = (read-from-string s1)
+	 repeat 1000
+	 when (or (/= i j)
+		  (find #\. s1)
+		  (find #\+ s1)
+		  (find-if #'alpha-char-p s1))
+	 collect (list i s1 j)))
+  nil)
+
+(deftest format.d.2
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for i = (- (random (+ x x)) x)
+	 for s1 = (format nil "~@d" i)
+	 for j = (read-from-string s1)
+	 repeat 1000
+	 when (or (/= i j)
+		  (find #\. s1)
+		  ;; (find #\+ s1)
+		  (find-if #'alpha-char-p s1))
+	 collect (list i s1 j)))
+  nil)
+
+(deftest format.d.3
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for mincol = (random 30)
+	 for i = (- (random (+ x x)) x)
+	 for s1 = (format nil "~d" i)
+	 for s2 = (format nil (format nil "~~~dd" mincol) i)
+	 for pos = (search s1 s2)
+	 repeat 1000
+	 when (or (null pos)
+		  (and (> mincol (length s1))
+		       (or (/= (length s2) mincol)
+			   (not (eql (position #\Space s2 :test-not #'eql)
+				     (- (length s2) (length s1)))))))
+	 collect (list i mincol s1 s2 pos)))
+  nil)
+
+(deftest format.d.4
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for mincol = (random 30)
+	 for i = (- (random (+ x x)) x)
+	 for s1 = (format nil "~@D" i)
+	 for s2 = (format nil (format nil "~~~d@d" mincol) i)
+	 for pos = (search s1 s2)
+	 repeat 1000
+	 when (or (null pos)
+		  (and (>= i 0) (not (eql (elt s1 0) #\+)))
+		  (and (> mincol (length s1))
+		       (or (/= (length s2) mincol)
+			   (not (eql (position #\Space s2 :test-not #'eql)
+				     (- (length s2) (length s1)))))))
+	 collect (list i mincol s1 s2 pos)))
+  nil)
+
+(deftest format.d.5
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for mincol = (random 30)
+	 for padchar = (random-from-seq +standard-chars+)
+	 for i = (- (random (+ x x)) x)
+	 for s1 = (format nil "~d" i)
+	 for s2 = (format nil (format nil "~~~d,'~cd" mincol padchar) i)
+	 for pos = (search s1 s2)
+	 repeat 1000
+	 when (or (null pos)
+		  (and (> mincol (length s1))
+		       (or (/= (length s2) mincol)
+			   (find padchar s2 :end (- (length s2) (length s1))
+				 :test-not #'eql))))
+	 collect (list i mincol s1 s2 pos)))
+  nil)
+
+(deftest format.d.6
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for mincol = (random 30)
+	 for padchar = (random-from-seq +standard-chars+)
+	 for i = (- (random (+ x x)) x)
+	 for s1 = (format nil "~d" i)
+	 for s2 = (format nil "~v,vD" mincol padchar i)
+	 for pos = (search s1 s2)
+	 repeat 1000
+	 when (or (null pos)
+		  (and (> mincol (length s1))
+		       (or (/= (length s2) mincol)
+			   (find padchar s2 :end (- (length s2) (length s1))
+				 :test-not #'eql))))
+	 collect (list i mincol s1 s2 pos)))
+  nil)
+
+(deftest format.d.7
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for mincol = (random 30)
+	 for padchar = (random-from-seq +standard-chars+)
+	 for i = (- (random (+ x x)) x)
+	 for s1 = (format nil "~@d" i)
+	 for s2 = (format nil "~v,v@d" mincol padchar i)
+	 for pos = (search s1 s2)
+	 repeat 1000
+	 when (or (null pos)
+		  (and (>= i 0) (not (eql (elt s1 0) #\+)))
+		  (and (> mincol (length s1))
+		       (or (/= (length s2) mincol)
+			   (find padchar s2 :end (- (length s2) (length s1))
+				 :test-not #'eql))))
+	 collect (list i mincol s1 s2 pos)))
+  nil)
+
+;;; Comma tests
+
+(deftest format.d.8
+  (loop for i from -999 to 999
+	for s1 = (format nil "~d" i)
+	for s2 = (format nil "~:d" i)
+	unless (string= s1 s2)
+	collect (list i s1 s2))
+  nil)
+
+(deftest format.d.9
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for i = (- (random (+ x x)) x)
+	 for commachar = #\,
+	 for s1 = (format nil "~d" i)
+	 for s2 = (format nil "~:d" i)
+	 repeat 1000
+	 unless (and (string= s1 (remove commachar s2))
+		     (not (eql (elt s2 0) commachar))
+		     (or (>= i 0) (not (eql (elt s2 1) commachar)))
+		     (let ((len (length s2))
+			   (ci+1 4))
+		       (loop for i from (if (< i 0) 2 1) below len
+			     always (if (= (mod (- len i) ci+1) 0)
+					(eql (elt s2 i) commachar)
+				      (find (elt s2 i) "0123456789")))))
+	 collect (list x i commachar s1 s2)))
+  nil)
+
+(deftest format.d.10
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for i = (- (random (+ x x)) x)
+	 for commachar = (random-from-seq +standard-chars+)
+	 for s1 = (format nil "~d" i)
+	 for s2 = (format nil "~,,v:d" commachar i)
+	 repeat 1000
+	 unless (and
+		 (eql (elt s1 0) (elt s2 0))
+		 (if (< i 0) (eql (elt s1 1) (elt s2 1)) t)
+		 (let ((len (length s2))
+		      (ci+1 4)
+		      (j (if (< i 0) 1 0)))
+		  (loop for i from (if (< i 0) 2 1) below len
+			always (if (= (mod (- len i) ci+1) 0)
+				   (eql (elt s2 i) commachar)
+				 (eql (elt s1 (incf j)) (elt s2 i))))))
+	 collect (list x i commachar s1 s2)))
+  nil)
+
+(deftest format.d.11
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for i = (- (random (+ x x)) x)
+	 for commachar = (random-from-seq +standard-chars+)
+	 for s1 = (format nil "~d" i)
+	 for s2 = (format nil (format nil "~~,,'~c:d" commachar) i)
+	 repeat 1000
+	 unless (and
+		 (eql (elt s1 0) (elt s2 0))
+		 (if (< i 0) (eql (elt s1 1) (elt s2 1)) t)
+		 (let ((len (length s2))
+		      (ci+1 4)
+		      (j (if (< i 0) 1 0)))
+		  (loop for i from (if (< i 0) 2 1) below len
+			always (if (= (mod (- len i) ci+1) 0)
+				   (eql (elt s2 i) commachar)
+				 (eql (elt s1 (incf j)) (elt s2 i))))))
+	 collect (list x i commachar s1 s2)))
+  nil)
+
+(deftest format.d.12
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for i = (- (random (+ x x)) x)
+	 for commachar = (random-from-seq +standard-chars+)
+	 for commaint = (1+ (random 20))
+	 for s1 = (format nil "~d" i)
+	 for s2 = (format nil "~,,v,v:D" commachar commaint i)
+	 repeat 1000
+	 unless (and
+		 (eql (elt s1 0) (elt s2 0))
+		 (if (< i 0) (eql (elt s1 1) (elt s2 1)) t)
+		 (let ((len (length s2))
+		       (ci+1 (1+ commaint))
+		       (j (if (< i 0) 1 0)))
+		   (loop for i from (if (< i 0) 2 1) below len
+			 always (if (= (mod (- len i) ci+1) 0)
+				    (eql (elt s2 i) commachar)
+				  (eql (elt s1 (incf j)) (elt s2 i))))))
+	 collect (list x i commachar s1 s2)))
+  nil)
+
+(deftest format.d.13
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for i = (- (random (+ x x)) x)
+	 for commachar = (random-from-seq +standard-chars+)
+	 for commaint = (1+ (random 20))
+	 for s1 = (format nil "~@d" i)
+	 for s2 = (format nil "~,,v,v:@d" commachar commaint i)
+	 repeat 1000
+	 unless (and
+		 (eql (elt s1 0) (elt s2 0))
+		 (eql (elt s1 1) (elt s2 1))
+		 (let ((len (length s2))
+		       (ci+1 (1+ commaint))
+		       (j 1))
+		   (loop for i from 2 below len
+			 always (if (= (mod (- len i) ci+1) 0)
+				    (eql (elt s2 i) commachar)
+				  (eql (elt s1 (incf j)) (elt s2 i))))))
+	 collect (list x i commachar s1 s2)))
+  nil)
+
+;;; NIL arguments
+
+(deftest format.d.14
+  (format nil "~vD" nil 100)
+  "100")
+
+(deftest format.d.15
+  (format nil "~6,vD" nil 100)
+  "   100")
+
+(deftest format.d.16
+  (format nil "~,,v:d" nil 12345)
+  "12,345")
+
+(deftest format.d.17
+  (format nil "~,,'*,v:d" nil 12345)
+  "12*345")
+
+;;; When the argument is not an integer, print as if using ~A and base 10
+
+(deftest format.d.18
+  (loop for x in *mini-universe*
+	for s1 = (format nil "~d" x)
+	for s2 = (format nil "~A" x)
+	unless (or (integerp x) (string= s1 s2))
+	collect (list x s1 s2))
+  nil)
+
+(deftest format.d.19
+  (loop for x in *mini-universe*
+	for s1 = (format nil "~:d" x)
+	for s2 = (format nil "~A" x)
+	unless (or (integerp x) (string= s1 s2))
+	collect (list x s1 s2))
+  nil)
+
+(deftest format.d.20
+  (loop for x in *mini-universe*
+	for s1 = (format nil "~@d" x)
+	for s2 = (format nil "~A" x)
+	unless (or (integerp x) (string= s1 s2))
+	collect (list x s1 s2))
+  nil)
+
+(deftest format.d.21
+  (loop for x in *mini-universe*
+	for s1 = (format nil "~@:d" x)
+	for s2 = (format nil "~A" x)
+	unless (or (integerp x) (string= s1 s2))
+	collect (list x s1 s2))
+  nil)
+
+;;; Must add tests for non-integers when the parameters
+;;; are specified, but it's not clear what the meaning is.
+;;; Does mincol apply to the ~A equivalent?  What about padchar?
+;;; Are comma-char and comma-interval always ignored?
+
+;;; # arguments
+
+(deftest format.d.22
+  (apply
+   #'values
+   (loop for i from 0 to 10
+	 for args = (make-list i)
+	 for s = (apply #'format nil "~#d" 12345 args)
+	 collect s))
+  "12345"
+  "12345"
+  "12345"
+  "12345"
+  "12345"
+  " 12345"
+  "  12345"
+  "   12345"
+  "    12345"
+  "     12345"
+  "      12345")
+
+(deftest format.d.23
+  (apply
+   #'values
+   (loop for i from 0 to 10
+	 for args = (make-list i)
+	 for s = (apply #'format nil "~,,,#:d" 1234567890 args)
+	 collect s))
+  "1,2,3,4,5,6,7,8,9,0"
+  "12,34,56,78,90"
+  "1,234,567,890"
+  "12,3456,7890"
+  "12345,67890"
+  "1234,567890"
+  "123,4567890"
+  "12,34567890"
+  "1,234567890"
+  "1234567890"
+  "1234567890")
+
+(deftest format.d.24
+  (apply
+   #'values
+   (loop for i from 0 to 10
+	 for args = (make-list i)
+	 for s = (apply #'format nil "~,,,#@:D" 1234567890 args)
+	 collect s))
+  "+1,2,3,4,5,6,7,8,9,0"
+  "+12,34,56,78,90"
+  "+1,234,567,890"
+  "+12,3456,7890"
+  "+12345,67890"
+  "+1234,567890"
+  "+123,4567890"
+  "+12,34567890"
+  "+1,234567890"
+  "+1234567890"
+  "+1234567890")
+
+(deftest format.d.25
+  (format nil "~+10d" 1234)
+  "      1234")
+
+(deftest format.d.26
+  (format nil "~+10@d" 1234)
+  "     +1234")
+
+(deftest format.d.27
+  (format nil "~-1d" 1234)
+  "1234")
+
+(deftest format.d.28
+  (format nil "~-1000000000000000000d" 1234)
+  "1234")
+
+(deftest format.d.29
+  (format nil "~vd" (1- most-negative-fixnum) 1234)
+  "1234")
+
+;;; Randomized test
+
+(deftest format.d.30
+  (loop
+   for mincol = (and (coin) (random 50))
+   for padchar = (and (coin)
+		      (random-from-seq +standard-chars+))
+   for commachar = (and (coin)
+			(random-from-seq +standard-chars+))
+   for commaint = (and (coin) (1+ (random 10)))
+   for k = (ash 1 (+ 2 (random 30)))
+   for x = (- (random (+ k k)) k)
+   for fmt = (concatenate
+	      'string
+	      (if mincol (format nil "~~~d," mincol) "~,")
+	      (if padchar (format nil "'~c," padchar) ",")
+	      (if commachar (format nil "'~c," commachar) ",")
+	      (if commaint (format nil "~dd" commaint) "d"))
+   for s1 = (format nil fmt x)
+   for s2 = (format nil "~v,v,v,vd" mincol padchar commachar commaint x)
+   repeat 2000
+   unless (string= s1 s2)
+   collect (list mincol padchar commachar commaint fmt x s1 s2))
+  nil)
diff --git a/ansi-tests/format-f.lsp b/ansi-tests/format-f.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..5c8331c7e9a4bccf251921cccad7cde97bbca84d
--- /dev/null
+++ b/ansi-tests/format-f.lsp
@@ -0,0 +1,461 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Sun Aug  1 07:14:17 2004
+;;;; Contains: Tests of the ~f format directive
+
+(in-package :cl-test)
+
+(compile-and-load "printer-aux.lsp")
+
+;;; Equivalent to PRIN1 for 0 or (abs x) in range [10^-3,10^7).
+
+(deftest format.f.1
+  (let ((*print-readably* nil))
+    (loop for x in (remove-duplicates '(0.0s0 0.0f0 0.0d0 0.0l0
+				       -0.0s0 -0.0f0 -0.0d0 -0.0l0))
+	  for s1 = (format nil "~f" x)
+	  for s2 = (prin1-to-string x)
+	  unless (string=t s1 s2)
+	  collect (list x s1 s2)))
+  nil)
+
+(deftest format.f.2
+  (let ((*print-readably* nil))
+    (loop
+     for x = (expt (random-from-seq #(10.s0 10.f0 10.d0 10.0l0))
+		   (- (random 10.0s0) 3))
+     for s1 = (format nil "~f" x)
+     for s2 = (prin1-to-string x)
+     repeat 1000
+     when (and (<= 1/1000 x)
+	       (< x 10000000)
+	       (not (string= s1 s2)))
+     collect (list x s1 s2)))
+  nil)
+
+(deftest format.f.3
+  (let ((*print-readably* nil))
+    (loop
+     for x = (- (expt (random-from-seq #(10.s0 10.f0 10.d0 10.0l0))
+		      (- (random 10.0s0) 3)))
+     for s1 = (format nil "~f" x)
+     for s2 = (prin1-to-string x)
+     repeat 1000
+     when (and (>= -1/1000 x)
+	       (> x -10000000)
+	       (not (string= s1 s2)))
+     collect (list x s1 s2)))
+  nil)
+
+(deftest format.f.4
+  (loop for x in (remove-duplicates '(1 1.0s0 1.0f0 1.0d0 1.0l0))
+	for s = (format nil "~3f" x)
+	unless (string= s "1.0")
+	collect (list x s))
+  nil)
+
+(deftest format.f.5
+  (loop for x in (remove-duplicates '(1 1.0s0 1.0f0 1.0d0 1.0l0))
+	for s = (format nil "~2f" x)
+	unless (string= s "1.")
+	collect (list x s))
+  nil)
+
+(deftest format.f.6
+  (loop for x in (remove-duplicates '(1 1.0s0 1.0f0 1.0d0 1.0l0))
+	for s = (format nil "~4F" x)
+	unless (string= s " 1.0")
+	collect (list x s))
+  nil)
+
+(deftest format.f.7
+  (loop for x in (remove-duplicates '(1 1.0s0 1.0f0 1.0d0 1.0l0))
+	for s = (format nil "~4@f" x)
+	unless (string= s "+1.0")
+	collect (list x s))
+  nil)
+
+(deftest format.f.8
+  (loop for x in (remove-duplicates '(1 1.0s0 1.0f0 1.0d0 1.0l0))
+	for s = (format nil "~3@F" x)
+	unless (string= s "+1.")
+	collect (list x s))
+  nil)
+
+(deftest format.f.9
+  (loop for x in (remove-duplicates '(1 1.0s0 1.0f0 1.0d0 1.0l0))
+	for s = (format nil "~4f" (- x))
+	unless (string= s "-1.0")
+	collect (list (- x) s))
+  nil)
+
+(deftest format.f.10
+  (loop for x in (remove-duplicates '(1/2 0.5s0 0.5f0 0.5d0 0.5l0))
+	for s = (format nil "~3f" x)
+	unless (string= s "0.5")
+	collect (list x s))
+  nil)
+
+(deftest format.f.11
+  (loop for x in (remove-duplicates '(1/2 0.5s0 0.5f0 0.5d0 0.5l0))
+	for s = (format nil "~4f" x)
+	unless (string= s " 0.5")
+	collect (list x s))
+  nil)
+
+(deftest format.f.12
+  (loop for x in (remove-duplicates '(1/2 0.5s0 0.5f0 0.5d0 0.5l0))
+	for s = (format nil "~4,2f" x)
+	unless (string= s "0.50")
+	collect (list x s))
+  nil)
+
+(deftest format.f.13
+  (loop for x in (remove-duplicates '(1/2 0.5s0 0.5f0 0.5d0 0.5l0))
+	for s = (format nil "~3,2f" x)
+	unless (string= s ".50")
+	collect (list x s))
+  nil)
+
+(deftest format.f.14
+  (loop for x in (remove-duplicates '(1/2 0.5s0 0.5f0 0.5d0 0.5l0))
+	for s = (format nil "~2,1f" x)
+	unless (string= s ".5")
+	collect (list x s))
+  nil)
+
+(deftest format.f.15
+  (loop for x in (remove-duplicates '(1/2 0.5s0 0.5f0 0.5d0 0.5l0))
+	for s = (format nil "~4,2@f" x)
+	unless (string= s "+.50")
+	collect (list x s))
+  nil)
+
+(deftest format.f.16
+  (loop for x in (remove-duplicates '(1/2 0.5s0 0.5f0 0.5d0 0.5l0))
+	for s = (format nil "~2,2f" x)
+	unless (string= s ".50")
+	collect (list x s))
+  nil)
+
+(deftest format.f.17
+  (loop for x in (remove-duplicates '(1/2 0.5s0 0.5f0 0.5d0 0.5l0))
+	for s = (format nil "~,2f" x)
+	unless (string= s "0.50")
+	collect (list x s))
+  nil)
+
+(deftest format.f.18
+  (loop for xn in (remove-duplicates '(1/2 0.5s0 0.5f0 0.5d0 0.5l0))
+	for x = (- xn)
+	for s = (format nil "~,2f" x)
+	unless (string= s "-0.50")
+	collect (list x s))
+  nil)
+
+(deftest format.f.19
+  (loop for x in (remove-duplicates '(5 5.0s0 5.0f0 5.0d0 5.0l0))
+	for s = (format nil "~4,2,-1f" x)
+	unless (string= s "0.50")
+	collect (list x s))
+  nil)
+
+(deftest format.f.20
+  (loop for x in (remove-duplicates '(1/2 0.5s0 0.5f0 0.5d0 0.5l0))
+	for s = (format nil "~4,2,0f" x)
+	unless (string= s "0.50")
+	collect (list x s))
+  nil)
+
+(deftest format.f.21
+  (loop for x in (remove-duplicates '(1/20 0.05s0 0.05f0 0.05d0 0.05l0))
+	for s = (format nil "~4,2,1f" x)
+	unless (string= s "0.50")
+	collect (list x s))
+  nil)
+
+;;; overflow
+
+(deftest format.f.22
+  (loop for x in (remove-duplicates
+		  '(1000 1000.0s0 1000.0f0 1000.0d0 1000.0l0))
+	for s = (format nil "~5,1,,'*f" x)
+	unless (string= s "*****")
+	collect (list x s))
+  nil)
+
+(deftest format.f.23
+  (loop for x in (remove-duplicates
+		  '(100 100.0s0 100.0f0 100.0d0 100.0l0))
+	for s = (format nil "~5,1,,'*f" x)
+	unless (string= s "100.0")
+	collect (list x s))
+  nil)
+
+(deftest format.f.24
+  (loop for x in (remove-duplicates
+		  '(100 100.0s0 100.0f0 100.0d0 100.0l0))
+	for s = (format nil "~4,0,,'*f" x)
+	unless (string= s "100.")
+	collect (list x s))
+  nil)
+
+(deftest format.f.25
+  (loop for x in (remove-duplicates
+		  '(100 100.0s0 100.0f0 100.0d0 100.0l0))
+	for s = (format nil "~1,1,,f" x)
+	unless (string= s "100.0")
+	collect (list x s))
+  nil)
+
+;;; padchar
+
+(deftest format.f.26
+  (loop for x in (remove-duplicates
+		  '(100 100.0s0 100.0f0 100.0d0 100.0l0))
+	for s = (format nil "~10,1,,f" x)
+	unless (string= s "     100.0")
+	collect (list x s))
+  nil)
+
+(deftest format.f.27
+  (loop for x in (remove-duplicates
+		  '(100 100.0s0 100.0f0 100.0d0 100.0l0))
+	for s = (format nil "~10,1,,,'*f" x)
+	unless (string= s "*****100.0")
+	collect (list x s))
+  nil)
+
+;;; v parameters
+
+(deftest format.f.28
+  (loop for x = (random 100.0)
+	for s1 = (format nil "~f" x)
+	for s2 = (format nil "~vf" nil x)
+	repeat 100
+	unless (string= s1 s2)
+	collect (list x s1 s2))
+  nil)
+
+(deftest format.f.29
+  (loop for x = (random 100.0)
+	for s1 = (format nil "~f" x)
+	for s2 = (format nil "~,vf" nil x)
+	repeat 100
+	unless (string= s1 s2)
+	collect (list x s1 s2))
+  nil)
+
+(deftest format.f.30
+  (loop for x = (random 100.0)
+	for s1 = (format nil "~f" x)
+	for s2 = (format nil "~,,vf" nil x)
+	repeat 100
+	unless (string= s1 s2)
+	collect (list x s1 s2))
+  nil)
+
+(deftest format.f.31
+  (loop for x = (random 100.0)
+	for s1 = (format nil "~f" x)
+	for s2 = (format nil "~,,,vf" nil x)
+	repeat 100
+	unless (string= s1 s2)
+	collect (list x s1 s2))
+  nil)
+
+(deftest format.f.32
+  (loop for x = (random 100.0)
+	for s1 = (format nil "~f" x)
+	for s2 = (format nil "~,,,,vf" nil x)
+	repeat 100
+	unless (string= s1 s2)
+	collect (list x s1 s2))
+  nil)
+
+;;; Randomized tests
+
+#|
+(deftest format.f.33
+  (let ((bound (if (> 10000000 most-positive-short-float)
+		   most-positive-short-float
+		 (coerce 10000000 'short-float))))
+    (loop for d = (random 10)
+	  for w = (+ 1 d (random 10))
+	  for x = (random bound)
+	  for xr = (rational x)
+	  for s = (format nil "~v,vf" w d x)
+	  for sr = (decode-fixed-decimal-string s)
+	  for eps = (expt 1/10 d)
+	  for abs-xr-sr = (abs (- xr sr))
+	  for abs-xr-sr-hi = (abs (- xr (+ sr eps)))
+	  for abs-xr-sr-lo = (abs (- xr (- sr eps)))
+	  repeat 100
+	  unless (and (<= abs-xr-sr abs-xr-sr-hi)
+		      (<= abs-xr-sr abs-xr-sr-lo))
+	  collect (list d w x xr s sr eps abs-xr-sr abs-xr-sr-hi abs-xr-sr-lo)))
+  nil)
+|#
+
+(deftest format.f.34
+  (with-standard-io-syntax
+   (let ((*read-default-float-format* 'short-float))
+     (loop for i from (- 1 (ash 1 13)) below (ash 1 13)
+	   for sf = (coerce i 'short-float)
+	   for s = (format nil "~f" sf)
+	   for i2 = (floor (read-from-string s))
+	   unless (or (zerop i) (eql i i2))
+	   collect (list i sf s i2))))
+  nil)
+
+(deftest format.f.35
+  (with-standard-io-syntax
+   (let ((*read-default-float-format* 'single-float))
+     (loop for i = (- (random (1- (ash 1 25))) -1 (ash 1 24))
+	   for sf = (coerce i 'single-float)
+	   for s = (format nil "~f" sf)
+	   for i2 = (floor (read-from-string s))
+	   repeat 2000
+	   unless (or (zerop i) (eql i i2))
+	   collect (list i sf s i2))))
+  nil)
+
+(deftest format.f.36
+  (with-standard-io-syntax
+   (let ((*read-default-float-format* 'double-float))
+     (loop for i = (- (random (1- (ash 1 51))) -1 (ash 1 50))
+	   for sf = (coerce i 'double-float)
+	   for s = (format nil "~f" sf)
+	   for i2 = (floor (read-from-string s))
+	   repeat 2000
+	   unless (or (zerop i) (eql i i2))
+	   collect (list i sf s i2))))
+  nil)
+
+(deftest format.f.37
+  (with-standard-io-syntax
+   (let ((*read-default-float-format* 'long-float))
+     (loop for i = (- (random (1- (ash 1 51))) -1 (ash 1 50))
+	   for sf = (coerce i 'long-float)
+	   for s = (format nil "~f" sf)
+	   for i2 = (floor (read-from-string s))
+	   repeat 2000
+	   unless (or (zerop i) (eql i i2))
+	   collect (list i sf s i2))))
+  nil)
+
+(deftest format.f.38
+  (funcall
+   (compile
+    nil
+    '(lambda ()
+       (with-standard-io-syntax
+	(let ((*read-default-float-format* 'short-float)
+	      (total 0)
+	      (len 0))
+	  (loop for i from (- 1 (ash 1 13)) below (ash 1 13)
+		unless (zerop i)
+		nconc
+		(loop for sf = (coerce i 'short-float)
+		      for w = (random 8)
+		      for d = (random 4)
+		      for s = (format nil "~v,vf" w d sf)
+		      for i2 = (ignore-errors (floor (read-from-string s)))
+		      repeat 5
+		      ; do (print (list w d s i i2))
+		      unless (eql i i2)
+		      do (incf total)
+		      and collect (list i sf w d s i2))
+		when (> total 100) collect "count limit exceeded"
+		and do (loop-finish)))))))
+  nil)
+
+(deftest format.f.39
+  (with-standard-io-syntax
+   (let ((*read-default-float-format* 'single-float))
+     (loop for i = (- (random (1- (ash 1 25))) -1 (ash 1 24))
+	   for sf = (coerce i 'single-float)
+	   for w = (and (coin) (random 16))
+	   for d = (random 4)
+	   for s = (format nil "~v,vf" w d sf)
+	   for i2 = (floor (read-from-string s))
+	   repeat 2000
+	   unless (or (zerop i) (eql i i2))
+	   collect (list i sf w d s i2))))
+  nil)
+
+(deftest format.f.40
+  (with-standard-io-syntax
+   (let ((*read-default-float-format* 'double-float))
+     (loop for i = (- (random (1- (ash 1 51))) -1 (ash 1 50))
+	   for sf = (coerce i 'double-float)
+	   for w = (and (coin) (random 30))
+	   for d = (random 6)
+	   for s = (format nil "~v,vf" w d sf)
+	   for i2 = (floor (read-from-string s))
+	   repeat 2000
+	   unless (or (zerop i) (eql i i2))
+	   collect (list i sf w d s i2))))
+  nil)
+
+(deftest format.f.41
+  (with-standard-io-syntax
+   (let ((*read-default-float-format* 'long-float))
+     (loop for i = (- (random (1- (ash 1 51))) -1 (ash 1 50))
+	   for sf = (coerce i 'long-float)
+	   for w = (and (coin) (random 30))
+	   for d = (random 6)
+	   for s = (format nil "~v,vf" w d sf)
+	   for i2 = (floor (read-from-string s))
+	   repeat 2000
+	   unless (or (zerop i) (eql i i2))
+	   collect (list i sf w d s i2))))
+  nil)
+
+(deftest format.f.42
+  (let ((chars +standard-chars+))
+    (loop
+     for k = (and (coin) (random 6))
+     for x = (random (/ (random-from-seq #(#.(coerce (* 32 (1- (ash 1 13))) 'short-float)
+					     #.(coerce (* 256 (1- (ash 1 24))) 'single-float)
+					     #.(coerce (* 256 (1- (ash 1 50))) 'double-float)
+					     #.(coerce (* 256 (1- (ash 1 50))) 'long-float)))
+			(if k (expt 10 k) 1)))
+     for w = (and (coin) (random 30))
+     for d = (and (coin) (random 10))
+     for overflowchar = (and (coin) (random-from-seq chars))
+     for padchar = (and (coin) (random-from-seq chars))
+     for f1 = (concatenate 'string
+			   "~"
+			   (if w (format nil "~d" w) "")
+			   ","
+			   (if d (format nil "~d" d) "")
+			   ","
+			   (if k (format nil "~d" k) "")
+			   ","
+			   (if overflowchar (format nil "'~c" overflowchar) "")
+			   ","
+			   (if padchar (format nil "'~c" padchar) "")
+			   (string (random-from-seq "fF")))
+     for s1 = (format nil f1 x)
+     for s2 = (format nil "~v,v,v,v,vf" w d k overflowchar padchar x)
+     repeat 2000
+     unless (string= s1 s2)
+     collect (list x w d k overflowchar padchar f1 s1 s2)))
+  nil)
+
+;;; This failed in sbcl 0.8.12.25
+(deftest format.f.43
+  (format nil "~,,,,',f" 0.0)
+  "0.0")
+
+(deftest format.f.44
+  (loop for i from 0 below (min #x10000 char-code-limit)
+	for x = 2312.9817
+	for c = (code-char i)
+	for f1 = (and c (format nil "~~,,,,'~cf" c))
+	for s1 = (and c (ignore-errors (format nil f1 x)))
+	for s2 = (and c (format nil "~,,,,vf" c x))
+	unless (equal s1 s2)
+	collect (list i c f1 s1 s2))
+  nil)
diff --git a/ansi-tests/format-o.lsp b/ansi-tests/format-o.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..72fcb237b1a60c42f4f691512d6b55f934a90a7f
--- /dev/null
+++ b/ansi-tests/format-o.lsp
@@ -0,0 +1,407 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Sun Aug  1 06:36:30 2004
+;;;; Contains: Tests of format directive ~O
+
+(in-package :cl-test)
+
+(compile-and-load "printer-aux.lsp")
+
+(deftest format.o.1
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for i = (- (random (+ x x)) x)
+	 for s1 = (format nil "~O" i)
+	 for j = (let ((*read-base* 8)) (read-from-string s1))
+	 repeat 1000
+	 when (or (/= i j)
+		  (find #\. s1)
+		  (find #\+ s1)
+		  (find-if #'alpha-char-p s1))
+	 collect (list i s1 j)))
+  nil)
+
+(deftest format.o.2
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for i = (- (random (+ x x)) x)
+	 for s1 = (format nil "~@o" i)
+	 for j = (let ((*read-base* 8)) (read-from-string s1))
+	 repeat 1000
+	 when (or (/= i j)
+		  (find #\. s1)
+		  ;; (find #\+ s1)
+		  (find-if #'alpha-char-p s1))
+	 collect (list i s1 j)))
+  nil)
+
+(deftest format.o.3
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for mincol = (random 30)
+	 for i = (- (random (+ x x)) x)
+	 for s1 = (format nil "~o" i)
+	 for s2 = (format nil (format nil "~~~do" mincol) i)
+	 for pos = (search s1 s2)
+	 repeat 1000
+	 when (or (null pos)
+		  (and (> mincol (length s1))
+		       (or (/= (length s2) mincol)
+			   (not (eql (position #\Space s2 :test-not #'eql)
+				     (- (length s2) (length s1)))))))
+	 collect (list i mincol s1 s2 pos)))
+  nil)
+
+(deftest format.o.4
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for mincol = (random 30)
+	 for i = (- (random (+ x x)) x)
+	 for s1 = (format nil "~@O" i)
+	 for s2 = (format nil (format nil "~~~d@o" mincol) i)
+	 for pos = (search s1 s2)
+	 repeat 1000
+	 when (or (null pos)
+		  (and (>= i 0) (not (eql (elt s1 0) #\+)))
+		  (and (> mincol (length s1))
+		       (or (/= (length s2) mincol)
+			   (not (eql (position #\Space s2 :test-not #'eql)
+				     (- (length s2) (length s1)))))))
+	 collect (list i mincol s1 s2 pos)))
+  nil)
+
+(deftest format.o.5
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for mincol = (random 30)
+	 for padchar = (random-from-seq +standard-chars+)
+	 for i = (- (random (+ x x)) x)
+	 for s1 = (format nil "~o" i)
+	 for s2 = (format nil (format nil "~~~d,'~c~c" mincol padchar
+				      (random-from-seq "oO"))
+			  i)
+	 for pos = (search s1 s2)
+	 repeat 1000
+	 when (or (null pos)
+		  (and (> mincol (length s1))
+		       (or (/= (length s2) mincol)
+			   (find padchar s2 :end (- (length s2) (length s1))
+				 :test-not #'eql))))
+	 collect (list i mincol s1 s2 pos)))
+  nil)
+
+(deftest format.o.6
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for mincol = (random 30)
+	 for padchar = (random-from-seq +standard-chars+)
+	 for i = (- (random (+ x x)) x)
+	 for s1 = (format nil "~o" i)
+	 for s2 = (format nil "~v,vO" mincol padchar i)
+	 for pos = (search s1 s2)
+	 repeat 1000
+	 when (or (null pos)
+		  (and (> mincol (length s1))
+		       (or (/= (length s2) mincol)
+			   (find padchar s2 :end (- (length s2) (length s1))
+				 :test-not #'eql))))
+	 collect (list i mincol s1 s2 pos)))
+  nil)
+
+(deftest format.o.7
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for mincol = (random 30)
+	 for padchar = (random-from-seq +standard-chars+)
+	 for i = (- (random (+ x x)) x)
+	 for s1 = (format nil "~@o" i)
+	 for s2 = (format nil "~v,v@o" mincol padchar i)
+	 for pos = (search s1 s2)
+	 repeat 1000
+	 when (or (null pos)
+		  (and (>= i 0) (not (eql (elt s1 0) #\+)))
+		  (and (> mincol (length s1))
+		       (or (/= (length s2) mincol)
+			   (find padchar s2 :end (- (length s2) (length s1))
+				 :test-not #'eql))))
+	 collect (list i mincol s1 s2 pos)))
+  nil)
+
+;;; Comma tests
+
+(deftest format.o.8
+  (loop for i from #o-777 to #o777
+	for s1 = (format nil "~o" i)
+	for s2 = (format nil "~:o" i)
+	unless (string= s1 s2)
+	collect (list i s1 s2))
+  nil)
+
+(deftest format.o.9
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for i = (- (random (+ x x)) x)
+	 for commachar = #\,
+	 for s1 = (format nil "~o" i)
+	 for s2 = (format nil "~:o" i)
+	 repeat 1000
+	 unless (and (string= s1 (remove commachar s2))
+		     (not (eql (elt s2 0) commachar))
+		     (or (>= i 0) (not (eql (elt s2 1) commachar)))
+		     (let ((len (length s2))
+			   (ci+1 4))
+		       (loop for i from (if (< i 0) 2 1) below len
+			     always (if (= (mod (- len i) ci+1) 0)
+					(eql (elt s2 i) commachar)
+				      (find (elt s2 i) "01234567")))))
+	 collect (list x i commachar s1 s2)))
+  nil)
+
+(deftest format.o.10
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for i = (- (random (+ x x)) x)
+	 for commachar = (random-from-seq +standard-chars+)
+	 for s1 = (format nil "~o" i)
+	 for s2 = (format nil "~,,v:o" commachar i)
+	 repeat 1000
+	 unless (and
+		 (eql (elt s1 0) (elt s2 0))
+		 (if (< i 0) (eql (elt s1 1) (elt s2 1)) t)
+		 (let ((len (length s2))
+		      (ci+1 4)
+		      (j (if (< i 0) 1 0)))
+		  (loop for i from (if (< i 0) 2 1) below len
+			always (if (= (mod (- len i) ci+1) 0)
+				   (eql (elt s2 i) commachar)
+				 (eql (elt s1 (incf j)) (elt s2 i))))))
+	 collect (list x i commachar s1 s2)))
+  nil)
+
+(deftest format.o.11
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for i = (- (random (+ x x)) x)
+	 for commachar = (random-from-seq +standard-chars+)
+	 for s1 = (format nil "~o" i)
+	 for s2 = (format nil (format nil "~~,,'~c:~c" commachar
+				      (random-from-seq "oO"))
+			  i)
+	 repeat 1000
+	 unless (and
+		 (eql (elt s1 0) (elt s2 0))
+		 (if (< i 0) (eql (elt s1 1) (elt s2 1)) t)
+		 (let ((len (length s2))
+		      (ci+1 4)
+		      (j (if (< i 0) 1 0)))
+		  (loop for i from (if (< i 0) 2 1) below len
+			always (if (= (mod (- len i) ci+1) 0)
+				   (eql (elt s2 i) commachar)
+				 (eql (elt s1 (incf j)) (elt s2 i))))))
+	 collect (list x i commachar s1 s2)))
+  nil)
+
+(deftest format.o.12
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for i = (- (random (+ x x)) x)
+	 for commachar = (random-from-seq +standard-chars+)
+	 for commaint = (1+ (random 20))
+	 for s1 = (format nil "~o" i)
+	 for s2 = (format nil "~,,v,v:O" commachar commaint i)
+	 repeat 1000
+	 unless (and
+		 (eql (elt s1 0) (elt s2 0))
+		 (if (< i 0) (eql (elt s1 1) (elt s2 1)) t)
+		 (let ((len (length s2))
+		       (ci+1 (1+ commaint))
+		       (j (if (< i 0) 1 0)))
+		   (loop for i from (if (< i 0) 2 1) below len
+			 always (if (= (mod (- len i) ci+1) 0)
+				    (eql (elt s2 i) commachar)
+				  (eql (elt s1 (incf j)) (elt s2 i))))))
+	 collect (list x i commachar s1 s2)))
+  nil)
+
+(deftest format.o.13
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for i = (- (random (+ x x)) x)
+	 for commachar = (random-from-seq +standard-chars+)
+	 for commaint = (1+ (random 20))
+	 for s1 = (format nil "~@o" i)
+	 for s2 = (format nil "~,,v,v:@o" commachar commaint i)
+	 repeat 1000
+	 unless (and
+		 (eql (elt s1 0) (elt s2 0))
+		 (eql (elt s1 1) (elt s2 1))
+		 (let ((len (length s2))
+		       (ci+1 (1+ commaint))
+		       (j 1))
+		   (loop for i from 2 below len
+			 always (if (= (mod (- len i) ci+1) 0)
+				    (eql (elt s2 i) commachar)
+				  (eql (elt s1 (incf j)) (elt s2 i))))))
+	 collect (list x i commachar s1 s2)))
+  nil)
+
+;;; NIL arguments
+
+(deftest format.o.14
+  (format nil "~vO" nil #o100)
+  "100")
+
+(deftest format.o.15
+  (format nil "~6,vO" nil #o100)
+  "   100")
+
+(deftest format.o.16
+  (format nil "~,,v:o" nil #o12345)
+  "12,345")
+
+(deftest format.o.17
+  (format nil "~,,'*,v:o" nil #o12345)
+  "12*345")
+
+;;; When the argument is not an integer, print as if using ~A and base 10
+
+(deftest format.o.18
+  (loop for x in *mini-universe*
+	for s1 = (format nil "~o" x)
+	for s2 = (let ((*print-base* 8)) (format nil "~A" x))
+	unless (or (integerp x) (string= s1 s2))
+	collect (list x s1 s2))
+  nil)
+
+(deftest format.o.19
+  (loop for x in *mini-universe*
+	for s1 = (format nil "~:o" x)
+	for s2 = (let ((*print-base* 8)) (format nil "~A" x))
+	unless (or (integerp x) (string= s1 s2))
+	collect (list x s1 s2))
+  nil)
+
+(deftest format.o.20
+  (loop for x in *mini-universe*
+	for s1 = (format nil "~@o" x)
+	for s2 = (let ((*print-base* 8)) (format nil "~A" x))
+	unless (or (integerp x) (string= s1 s2))
+	collect (list x s1 s2))
+  nil)
+
+(deftest format.o.21
+  (loop for x in *mini-universe*
+	for s1 = (format nil "~@:o" x)
+	for s2 = (let ((*print-base* 8)) (format nil "~A" x))
+	unless (or (integerp x) (string= s1 s2))
+	collect (list x s1 s2))
+  nil)
+
+;;; Must add tests for non-integers when the parameters
+;;; are specified, but it's not clear what the meaning is.
+;;; Does mincol apply to the ~A equivalent?  What about padchar?
+;;; Are comma-char and comma-interval always ignored?
+
+;;; # arguments
+
+(deftest format.o.22
+  (apply
+   #'values
+   (loop for i from 0 to 10
+	 for args = (make-list i)
+	 for s = (apply #'format nil "~#o" #o12345 args)
+	 collect s))
+  "12345"
+  "12345"
+  "12345"
+  "12345"
+  "12345"
+  " 12345"
+  "  12345"
+  "   12345"
+  "    12345"
+  "     12345"
+  "      12345")
+
+(deftest format.o.23
+  (apply
+   #'values
+   (loop for i from 0 to 10
+	 for args = (make-list i)
+	 for s = (apply #'format nil "~,,,#:o" #o1234567012 args)
+	 collect s))
+  "1,2,3,4,5,6,7,0,1,2"
+  "12,34,56,70,12"
+  "1,234,567,012"
+  "12,3456,7012"
+  "12345,67012"
+  "1234,567012"
+  "123,4567012"
+  "12,34567012"
+  "1,234567012"
+  "1234567012"
+  "1234567012")
+
+(deftest format.o.24
+  (apply
+   #'values
+   (loop for i from 0 to 10
+	 for args = (make-list i)
+	 for s = (apply #'format nil "~,,,#@:O" #o1234567012 args)
+	 collect s))
+  "+1,2,3,4,5,6,7,0,1,2"
+  "+12,34,56,70,12"
+  "+1,234,567,012"
+  "+12,3456,7012"
+  "+12345,67012"
+  "+1234,567012"
+  "+123,4567012"
+  "+12,34567012"
+  "+1,234567012"
+  "+1234567012"
+  "+1234567012")
+
+(deftest format.o.25
+  (format nil "~+10o" #o1234)
+  "      1234")
+
+(deftest format.o.26
+  (format nil "~+10@O" #o1234)
+  "     +1234")
+
+(deftest format.o.27
+  (format nil "~-1O" #o1234)
+  "1234")
+
+(deftest format.o.28
+  (format nil "~-1000000000000000000o" #o1234)
+  "1234")
+
+(deftest format.o.29
+  (format nil "~vo" (1- most-negative-fixnum) #o1234)
+  "1234")
+
+;;; Randomized test
+
+(deftest format.o.30
+  (loop
+   for mincol = (and (coin) (random 50))
+   for padchar = (and (coin)
+		      (random-from-seq +standard-chars+))
+   for commachar = (and (coin)
+			(random-from-seq +standard-chars+))
+   for commaint = (and (coin) (1+ (random 10)))
+   for k = (ash 1 (+ 2 (random 30)))
+   for x = (- (random (+ k k)) k)
+   for fmt = (concatenate
+	      'string
+	      (if mincol (format nil "~~~d," mincol) "~,")
+	      (if padchar (format nil "'~c," padchar) ",")
+	      (if commachar (format nil "'~c," commachar) ",")
+	      (if commaint (format nil "~do" commaint) "o"))
+   for s1 = (format nil fmt x)
+   for s2 = (format nil "~v,v,v,vo" mincol padchar commachar commaint x)
+   repeat 2000
+   unless (string= s1 s2)
+   collect (list mincol padchar commachar commaint fmt x s1 s2))
+  nil)
\ No newline at end of file
diff --git a/ansi-tests/format-page.lsp b/ansi-tests/format-page.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..65dc376f3decf0c737cb73cc503985f45033f70a
--- /dev/null
+++ b/ansi-tests/format-page.lsp
@@ -0,0 +1,50 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Wed Jul 28 00:20:46 2004
+;;;; Contains: Tests of format with ~| directive
+
+(in-package :cl-test)
+
+(deftest format.page.1
+  (format nil "~0|")
+  "")
+
+(deftest format.page.2
+  (let ((s (format nil "~|")))
+    (cond
+     ((string= s "") nil)
+     ((> (length s) 1) (values s :too-long))
+     (t
+      (let ((c (elt s 0)))
+	(loop for i from 2 to 100
+	      for s = (format nil (format nil "~~~D|" i))
+	      unless (and (= (length s) i)
+			  (every #'(lambda (c2) (char= c c2)) s))
+	      collect i)))))
+  nil)
+
+(deftest format.page.3
+  (let ((s (format nil "~|")))
+    (cond
+     ((string= s "") nil)
+     ((> (length s) 1) (values s :too-long))
+     (t
+      (let ((c (elt s 0)))
+	(loop for i from 2 to 100
+	      for s = (format nil "~v|" i)
+	      unless (and (= (length s) i)
+			  (every #'(lambda (c2) (char= c c2)) s))
+	      collect i)))))
+  nil)
+
+(deftest format.page.4
+  (format nil "~V|" 0)
+  "")
+
+(deftest format.page.5
+  (string=t (format nil "~v|" nil)
+	    (format nil "~|"))
+  t)
+
+  
+	
diff --git a/ansi-tests/format-percent.lsp b/ansi-tests/format-percent.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..b04e283ec24885d8fc7fe0238fcb2da644b2140e
--- /dev/null
+++ b/ansi-tests/format-percent.lsp
@@ -0,0 +1,45 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Tue Jul 27 23:47:44 2004
+;;;; Contains: Tests of format with ~% directive
+
+(in-package :cl-test)
+
+(deftest format.%.1
+  (format nil "~%")
+  #.(string #\Newline))
+
+(deftest format.%.2
+  (loop for i from 0 to 100
+	for s1 = (make-string i :initial-element #\Newline)
+	for s2 = (format nil (format nil "~~~D%" i))
+	unless (string= s1 s2)
+	collect i)
+  nil)
+
+(deftest format.%.3
+  (format nil "~v%" nil)
+  "
+")
+
+(deftest format.%.4
+  (format nil "~V%" 1)
+  #.(string #\Newline))
+
+(deftest format.%.5
+  (loop for i from 0 to 100
+	for s1 = (make-string i :initial-element #\Newline)
+	for s2 = (format nil "~v%" i)
+	unless (string= s1 s2)
+	collect i)
+  nil)
+
+(deftest format.%.6
+  (loop for i from 0 to (min (- call-arguments-limit 3) 100)
+	for args = (make-list i)
+	for s1 = (make-string i :initial-element #\Newline)
+	for s2 = (apply #'format nil "~#%" args)
+	unless (string= s1 s2)
+	collect i)
+  nil)
+
diff --git a/ansi-tests/format-r.lsp b/ansi-tests/format-r.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..a364b99ed08f308d59a4f8cabb4c7897ce9d4a7e
--- /dev/null
+++ b/ansi-tests/format-r.lsp
@@ -0,0 +1,375 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Wed Jul 28 00:33:02 2004
+;;;; Contains: Tests of the format directive ~R
+
+(in-package :cl-test)
+
+;;; Test of various radixes
+
+(compile-and-load "roman-numerals.lsp")
+
+(deftest format.r.1
+  (loop
+   for i from 2 to 36
+   for s = (format nil "~~~dR" i)
+   nconc
+   (loop for x = (let ((bound (ash 1 (+ 2 (random 40)))))
+		   (- (random (* bound 2)) bound))
+	 for s1 = (format nil s x)
+	 for s2 = (with-standard-io-syntax
+		   (write-to-string x :base i :readably nil))
+	 repeat 100
+	 unless (string= s1 s2)
+	 collect (list i x s1 s2)))
+  nil)
+
+(deftest format.r.2
+  (format nil "~2r" 14)
+  "1110")
+
+(deftest format.r.3
+  (format nil "~3r" 29)
+  "1002")
+
+(deftest format.r.4
+  (loop for base from 2 to 36
+	nconc
+	(loop for mincol from 0 to 20
+	      for fmt = (format nil "~~~D,~DR" base mincol)
+	      for s = (format nil fmt base)
+	      unless (if (<= mincol 2)
+			 (string= s "10")
+		       (string= (concatenate
+				 'string
+				 (make-string (- mincol 2)
+					      :initial-element #\Space)
+				 "10")
+				s))
+	      collect (list base mincol s)))
+  nil)
+
+(deftest format.r.5
+  (loop for base from 2 to 36
+	nconc
+	(loop for mincol from 0 to 20
+	      for fmt = (format nil "~~~D,~D,'*r" base mincol)
+	      for s = (format nil fmt base)
+	      unless (if (<= mincol 2)
+			 (string= s "10")
+		       (string= (concatenate
+				 'string
+				 (make-string (- mincol 2)
+					      :initial-element #\*)
+				 "10")
+				s))
+	      collect (list base mincol s)))
+  nil)
+
+(deftest format.r.6
+  (loop for base from 2 to 36
+	for s = (format nil "~vr" base (1+ base))
+	unless (string= s "11")
+	collect (list base s))
+  nil)
+
+(defparameter *english-number-names*
+  '("zero"
+   "one" "two" "three" "four" "five" "six" "seven" "eight" "nine" "ten"
+   "eleven" "twelve" "thirteen" "fourteen" "fifteen" "sixteen"
+   "seventeen" "eighteen" "nineteen" "twenty"
+   "twenty-one" "twenty-two" "twenty-three" "twenty-four" "twenty-five"
+   "twenty-six" "twenty-seven" "twenty-eight" "twenty-nine" "thirty"
+   "thirty-one" "thirty-two" "thirty-three" "thirty-four" "thirty-five"
+   "thirty-six" "thirty-seven" "thirty-eight" "thirty-nine" "forty"
+   "forty-one" "forty-two" "forty-three" "forty-four" "forty-five"
+   "forty-six" "forty-seven" "forty-eight" "forty-nine" "fifty"
+   "fifty-one" "fifty-two" "fifty-three" "fifty-four" "fifty-five"
+   "fifty-six" "fifty-seven" "fifty-eight" "fifty-nine" "sixty"
+   "sixty-one" "sixty-two" "sixty-three" "sixty-four" "sixty-five"
+   "sixty-six" "sixty-seven" "sixty-eight" "sixty-nine" "seventy"
+   "seventy-one" "seventy-two" "seventy-three" "seventy-four" "seventy-five"
+   "seventy-six" "seventy-seven" "seventy-eight" "seventy-nine" "eighty"
+   "eighty-one" "eighty-two" "eighty-three" "eighty-four" "eighty-five"
+   "eighty-six" "eighty-seven" "eighty-eight" "eighty-nine" "ninety"
+   "ninety-one" "ninety-two" "ninety-three" "ninety-four" "ninety-five"
+   "ninety-six" "ninety-seven" "ninety-eight" "ninety-nine" "one hundred"))
+
+(deftest format.r.7
+  (loop for i from 0 to 100
+	for s1 = (format nil "~r" i)
+	for s2 in *english-number-names*
+	unless (string= s1 s2)
+	collect (list i s1 s2))
+  nil)
+
+(deftest format.r.7a
+  (loop for i from 1 to 100
+	for s1 = (format nil "~r" (- i))
+	for s2 in (cdr *english-number-names*)
+	for s3 = (concatenate 'string "negative " s2)
+	for s4 = (concatenate 'string "minus " s2)
+	unless (or (string= s1 s3) (string= s1 s4))
+	collect (list i s1 s3 s4))
+  nil)
+
+(deftest format.r.8
+  (format nil "~vr" nil 5)
+  "five")
+
+(deftest format.r.9
+  (format nil "~#r" 4 nil nil)
+  "11")
+
+(deftest format.r.10
+  (with-standard-io-syntax
+   (let ((*print-radix* t))
+     (format nil "~10r" 123)))
+  "123")
+
+(deftest format.r.11
+  (format nil "~8@R" 65)
+  "+101")
+
+(deftest format.r.12
+  (format nil "~2:r" 126)
+  "1,111,110")
+
+(deftest format.r.13
+  (format nil "~3@:r" #3r2120012102)
+  "+2,120,012,102")
+
+(deftest format.r.14
+  (loop
+   for i from 2 to 36
+   for s = (format nil "~~~d:R" i)
+   nconc
+   (loop for x = (let ((bound (ash 1 (+ 2 (random 40)))))
+		   (- (random (* bound 2)) bound))
+	 for s1 = (remove #\, (format nil s x))
+	 for y = (let ((*read-base* i)) (read-from-string s1))
+	 repeat 100
+	 unless (= x y)
+	 collect (list i x s1 y)))
+  nil)
+
+(deftest format.r.15
+  (loop
+   for i = (+ 2 (random 35))
+   for interval = (1+ (random 20))
+   for comma = (loop for c = (random-from-seq +standard-chars+)
+		     unless (alphanumericp c)
+		     return c)
+   for s = (format nil "~~~d,,,'~c,~d:R" i comma interval)
+   for x = (let ((bound (ash 1 (+ 2 (random 40)))))
+	     (- (random (* bound 2)) bound))
+   for s1 = (remove comma (format nil s x))
+   for y = (let ((*read-base* i)) (read-from-string s1))
+   repeat 1000
+   unless (or (and (eql comma #\-) (< x 0))
+	      (= x y))
+   collect (list i interval comma x s1 y))
+  nil)
+
+(deftest format.r.16
+  (format nil "~2,,,,1000000000000000000r" 17)
+  "10001")
+
+(deftest format.r.17
+  (format nil "~8,10:@r" #o526104)
+  "  +526,104")
+
+(defparameter *english-ordinal-names*
+  '("zeroth"
+   "first" "second" "third" "fourth" "fifth" "sixth" "seventh" "eighth" "ninth" "tenth"
+   "eleventh" "twelfth" "thirteenth" "fourteenth" "fifteenth" "sixteenth"
+   "seventeenth" "eighteenth" "nineteenth" "twentieth"
+   "twenty-first" "twenty-second" "twenty-third" "twenty-fourth" "twenty-fifth"
+   "twenty-sixth" "twenty-seventh" "twenty-eighth" "twenty-ninth" "thirtieth"
+   "thirty-first" "thirty-second" "thirty-third" "thirty-fourth" "thirty-fifth"
+   "thirty-sixth" "thirty-seventh" "thirty-eighth" "thirty-ninth" "fortieth"
+   "forty-first" "forty-second" "forty-third" "forty-fourth" "forty-fifth"
+   "forty-sixth" "forty-seventh" "forty-eighth" "forty-ninth" "fiftieth"
+   "fifty-first" "fifty-second" "fifty-third" "fifty-fourth" "fifty-fifth"
+   "fifty-sixth" "fifty-seventh" "fifty-eighth" "fifty-ninth" "sixtieth"
+   "sixty-first" "sixty-second" "sixty-third" "sixty-fourth" "sixty-fifth"
+   "sixty-sixth" "sixty-seventh" "sixty-eighth" "sixty-ninth" "seventieth"
+   "seventy-first" "seventy-second" "seventy-third" "seventy-fourth" "seventy-fifth"
+   "seventy-sixth" "seventy-seventh" "seventy-eighth" "seventy-ninth" "eightieth"
+   "eighty-first" "eighty-second" "eighty-third" "eighty-fourth" "eighty-fifth"
+   "eighty-sixth" "eighty-seventh" "eighty-eighth" "eighty-ninth" "ninetieth"
+   "ninety-first" "ninety-second" "ninety-third" "ninety-fourth" "ninety-fifth"
+   "ninety-sixth" "ninety-seventh" "ninety-eighth" "ninety-ninth" "one hundredth"))
+
+(deftest format.r.18
+  (loop for i from 0 to 100
+	for s1 = (format nil "~:r" i)
+	for s2 in *english-ordinal-names*
+	unless (string= s1 s2)
+	collect (list i s1 s2))
+  nil)
+
+(deftest format.r.18a
+  (loop for i from 1 to 100
+	for s1 = (format nil "~:r" (- i))
+	for s2 in (cdr *english-ordinal-names*)
+	for s3 = (concatenate 'string "negative " s2)
+	for s4 = (concatenate 'string "minus " s2)
+	unless (or (string= s1 s3) (string= s1 s4))
+	collect (list i s1 s3 s4))
+  nil)
+
+(deftest format.r.19
+  (loop for i from 1
+	for s1 in *roman-numerals*
+	for s2 = (format nil "~@R" i)
+	unless (string= s1 s2)
+	collect (list i s1 s2))
+  nil)
+
+;;; Old roman numerals
+
+(defun old-roman-numeral (x)
+  (assert (typep x '(integer (0))))
+  (let ((n-m 0)
+	(n-d 0)
+	(n-c 0)
+	(n-l 0)
+	(n-x 0)
+	(n-v 0)
+	)
+    (loop while (>= x 1000) do (incf n-m) (decf x 1000))
+    (when (>= x 500) (incf n-d) (decf x 500))
+    (loop while (>= x 100) do (incf n-c) (decf x 100))
+    (when (>= x 50) (incf n-l) (decf x 50))
+    (loop while (>= x 10) do (incf n-x) (decf x 10))
+    (when (>= x 5) (incf n-v) (decf x 5))
+    (concatenate 'string
+		 (make-string n-m :initial-element #\M)
+		 (make-string n-d :initial-element #\D)
+		 (make-string n-c :initial-element #\C)
+		 (make-string n-l :initial-element #\L)
+		 (make-string n-x :initial-element #\X)
+		 (make-string n-v :initial-element #\V)
+		 (make-string x   :initial-element #\I))))
+
+(deftest format.r.20
+  (loop for i from 1 to 4999
+	for s1 = (format nil "~:@r" i)
+	for s2 = (old-roman-numeral i)
+	unless (string= s1 s2)
+	collect (list i s1 s2))
+  nil)
+
+(deftest format.r.21
+  (loop for i from 1 to 4999
+	for s1 = (format nil "~:@r" i)
+	for s2 = (format nil "~@:R" i)
+	unless (string= s1 s2)
+	collect (list i s1 s2))
+  nil)
+
+;; Combinations of mincol and comma chars
+
+(deftest format.r.22
+  (format nil "~2,12,,'*:r" #b1011101)
+  "   1*011*101")
+
+(deftest format.r.23
+  (format nil "~3,14,'X,',:R" #3r1021101)
+  "XXXXX1,021,101")
+
+;; v directive in various positions
+
+(deftest format.r.24
+  (format nil "~10,vr" nil 12345)
+  "12345")
+
+(deftest format.r.25
+  (loop for i from 0 to 5
+	for s = (format nil "~10,vr" i 12345)
+	unless (string= s "12345")
+	collect (list i s))
+  nil)
+
+(deftest format.r.26
+  (format nil "~10,#r" 12345 nil nil nil nil nil)
+  " 12345")
+
+(deftest format.r.27
+  (format nil "~10,12,vr" #\/ 123456789)
+  "///123456789")
+
+(deftest format.r.28
+  (format nil "~10,,,v:r" #\/ 123456789)
+  "123/456/789")
+
+(deftest format.r.29
+  (format nil "~10,,,v:r" nil 123456789)
+  "123,456,789")
+
+(deftest format.r.30
+  (format nil "~8,,,,v:R" nil #o12345670)
+  "12,345,670")
+
+(deftest format.r.31
+  (format nil "~8,,,,v:R" 2 #o12345670)
+  "12,34,56,70")
+
+(deftest format.r.32
+  (format nil "~16,,,,#:r" #x12345670 nil nil nil)
+  "1234,5670")
+
+(deftest format.r.33
+  (format nil "~16,,,,1:r" #x12345670)
+  "1,2,3,4,5,6,7,0")
+
+;;; Explicit signs
+
+(deftest format.r.34
+  (format nil "~+10r" 12345)
+  "12345")
+
+(deftest format.r.35
+  (format nil "~10,+8r" 12345)
+  "   12345")
+
+(deftest format.r.36
+  (format nil "~10,0r" 12345)
+  "12345")
+
+(deftest format.r.37
+  (format nil "~10,-1r" 12345)
+  "12345")
+
+(deftest format.r.38
+  (format nil "~10,-1000000000000000r" 12345)
+  "12345")
+
+;;; Randomized test
+
+(deftest format.r.39
+  (loop
+   for radix = (+ 2 (random 35))
+   for mincol = (and (coin) (random 50))
+   for padchar = (and (coin)
+		      (random-from-seq +standard-chars+))
+   for commachar = (and (coin)
+			(random-from-seq +standard-chars+))
+   for commaint = (and (coin) (1+ (random 10)))
+   for k = (ash 1 (+ 2 (random 30)))
+   for x = (- (random (+ k k)) k)
+   for fmt = (concatenate
+	      'string
+	      (format nil "~~~d," radix)
+	      (if mincol (format nil "~d," mincol) ",")
+	      (if padchar (format nil "'~c," padchar) ",")
+	      (if commachar (format nil "'~c," commachar) ",")
+	      (if commaint (format nil "~dr" commaint) "r"))
+   for s1 = (format nil fmt x)
+   for s2 = (format nil "~v,v,v,v,vr" radix mincol padchar commachar commaint x)
+   repeat 2000
+   unless (string= s1 s2)
+   collect (list radix mincol padchar commachar commaint fmt x s1 s2))
+  nil)
+	      
\ No newline at end of file
diff --git a/ansi-tests/format-s.lsp b/ansi-tests/format-s.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..e61db541a2bd59c0080b95b5c5e6545c9856e341
--- /dev/null
+++ b/ansi-tests/format-s.lsp
@@ -0,0 +1,445 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Tue Aug  3 11:55:07 2004
+;;;; Contains: Test of the ~S format directive
+
+(in-package :cl-test)
+
+(deftest format.s.1
+  (let ((*print-readably* nil)
+	(*print-case* :upcase))
+    (format nil "~s" nil))
+  "NIL")
+
+(deftest format.s.2
+  (let ((*print-readably* nil))
+    (format nil "~:s" nil))
+  "()")
+
+(deftest format.s.3
+  (let ((*print-readably* nil)
+	(*print-case* :upcase))
+    (format nil "~:s" '(nil)))
+  "(NIL)")
+
+(deftest format.s.4
+  (let ((*print-readably* nil)
+	(*print-case* :downcase))
+    (format nil "~s" 'nil))
+  "nil")
+
+(deftest format.s.5
+  (let ((*print-readably* nil)
+	(*print-case* :capitalize))
+    (format nil "~s" 'nil))
+  "Nil")
+
+(deftest format.s.6
+  (with-standard-io-syntax
+   (let ((*print-readably* nil))
+     (format nil "~:s" #(nil))))
+  "#(NIL)")
+
+(deftest format.s.7
+  (with-standard-io-syntax
+   (let ((*print-readably* nil))
+     (loop for c across +standard-chars+
+	   for s = (format nil "~S" c)
+	   for c2 = (read-from-string s)
+	   unless (eql c c2)
+	   collect (list c s c2))))
+  nil)
+
+(deftest format.s.8
+  (with-standard-io-syntax
+   (let ((*print-readably* nil))
+     (loop with count = 0
+	   for i from 0 below (min #x10000 char-code-limit)
+	   for c = (code-char i)
+	   for s1 = (and c (format nil "#\\~:c" c))
+	   for s2 = (and c (format nil "~S" c))
+	   unless (or (null c) (eql c #\Space) (string= s1 s2))
+	   do (incf count) and collect (list c s1 s2)
+	   when (> count 100) collect "count limit exceeded" and do (loop-finish))))
+  nil)
+
+(deftest format.s.9
+  (with-standard-io-syntax
+   (let ((*print-readably* nil))
+     (apply
+      #'values
+      (loop for i from 1 to 10
+	    for s1 = (format nil "~~~d@s" i)
+	    for s2 = (format nil s1 nil)
+	    collect s2))))
+  "NIL"
+  "NIL"
+  "NIL"
+  " NIL"
+  "  NIL"
+  "   NIL"
+  "    NIL"
+  "     NIL"
+  "      NIL"
+  "       NIL")
+
+(deftest format.s.10
+  (with-standard-io-syntax
+   (let ((*print-readably* nil))
+     (apply
+      #'values
+      (loop for i from 1 to 10
+	    for s1 = (format nil "~~~dS" i)
+	    for s2 = (format nil s1 nil)
+	    collect s2))))
+  "NIL"
+  "NIL"
+  "NIL"
+  "NIL "
+  "NIL  "
+  "NIL   "
+  "NIL    "
+  "NIL     "
+  "NIL      "
+  "NIL       ")
+
+(deftest format.s.11
+  (with-standard-io-syntax
+   (let ((*print-readably* nil))
+     (apply
+      #'values
+      (loop for i from 1 to 10
+	    for s1 = (format nil "~~~d@:S" i)
+	    for s2 = (format nil s1 nil)
+	    collect s2))))
+  "()"
+  "()"
+  " ()"
+  "  ()"
+  "   ()"
+  "    ()"
+  "     ()"
+  "      ()"
+  "       ()"
+  "        ()")
+
+(deftest format.s.12
+  (with-standard-io-syntax
+   (let ((*print-readably* nil))
+     (apply
+      #'values
+      (loop for i from 1 to 10
+	    for s1 = (format nil "~~~d:s" i)
+	    for s2 = (format nil s1 nil)
+	    collect s2))))
+  "()"
+  "()"
+  "() "
+  "()  "
+  "()   "
+  "()    "
+  "()     "
+  "()      "
+  "()       "
+  "()        ")
+
+(deftest format.s.13
+  (with-standard-io-syntax
+   (let ((*print-readably* nil))
+     (apply
+      #'values
+      (loop for i from 1 to 10
+	    for s2 = (format nil "~v:S" i nil)
+	    collect s2))))
+  "()"
+  "()"
+  "() "
+  "()  "
+  "()   "
+  "()    "
+  "()     "
+  "()      "
+  "()       "
+  "()        ")
+
+(deftest format.s.14
+  (with-standard-io-syntax
+   (let ((*print-readably* nil))
+     (apply
+      #'values
+      (loop for i from 1 to 10
+	    for s2 = (format nil "~v:@s" i nil)
+	    collect s2))))
+  "()"
+  "()"
+  " ()"
+  "  ()"
+  "   ()"
+  "    ()"
+  "     ()"
+  "      ()"
+  "       ()"
+  "        ()")
+
+(deftest format.s.15
+  (with-standard-io-syntax
+   (let ((*print-readably* nil))
+     (format nil "~vS" nil nil)))
+  "NIL")
+
+(deftest format.s.16
+  (with-standard-io-syntax
+   (let ((*print-readably* nil))
+     (format nil "~v:S" nil nil)))
+  "()")
+
+(deftest format.s.17
+  (with-standard-io-syntax
+   (let ((*print-readably* nil))
+     (format nil "~@S" nil)))
+  "NIL")
+
+(deftest format.s.18
+  (with-standard-io-syntax
+   (let ((*print-readably* nil))
+     (format nil "~v@S" nil nil)))
+  "NIL")
+
+(deftest format.s.19
+  (with-standard-io-syntax
+   (let ((*print-readably* nil))
+     (format nil "~v:@s" nil nil)))
+  "()")
+
+(deftest format.s.20
+  (with-standard-io-syntax
+   (let ((*print-readably* nil))
+     (format nil "~v@:s" nil nil)))
+  "()")
+
+;;; With colinc specified
+
+(deftest format.s.21
+  (with-standard-io-syntax
+   (let ((*print-readably* nil))
+     (format nil "~3,1s" nil)))
+  "NIL")
+
+(deftest format.s.22
+  (with-standard-io-syntax
+   (let ((*print-readably* nil))
+     (format nil "~4,3s" nil)))
+  "NIL   ")
+
+(deftest format.s.23
+  (with-standard-io-syntax
+   (let ((*print-readably* nil))
+     (format nil "~3,3@s" nil)))
+  "NIL")
+
+(deftest format.s.24
+  (with-standard-io-syntax
+   (let ((*print-readably* nil))
+     (format nil "~4,4@s" nil)))
+  "    NIL")
+
+(deftest format.s.25
+  (with-standard-io-syntax
+   (let ((*print-readably* nil))
+     (format nil "~5,3@s" nil)))
+  "   NIL")
+
+(deftest format.s.26
+  (with-standard-io-syntax
+   (let ((*print-readably* nil))
+     (format nil "~5,3S" nil)))
+  "NIL   ")
+
+(deftest format.s.27
+  (with-standard-io-syntax
+   (let ((*print-readably* nil))
+     (format nil "~7,3@s" nil)))
+  "      NIL")
+
+(deftest format.s.28
+  (with-standard-io-syntax
+   (let ((*print-readably* nil))
+     (format nil "~7,3S" nil)))
+  "NIL      ")
+
+;;; With minpad
+
+(deftest format.s.29
+  (with-standard-io-syntax
+   (let ((*print-readably* nil)
+	 (*package* (find-package :cl-test)))
+     (loop for i from -4 to 10
+	   collect (format nil "~v,,2S" i 'ABC))))
+  ("ABC  "
+   "ABC  "
+   "ABC  "
+   "ABC  "
+   "ABC  "
+   "ABC  "
+   "ABC  "
+   "ABC  "
+   "ABC  "
+   "ABC  "
+   "ABC   "
+   "ABC    "
+   "ABC     "
+   "ABC      "
+   "ABC       "))
+
+(deftest format.s.30
+  (with-standard-io-syntax
+   (let ((*print-readably* nil)
+	 (*package* (find-package :cl-test)))
+     (format nil "~3,,+2S" 'ABC)))
+  "ABC  ")
+
+(deftest format.s.31
+  (with-standard-io-syntax
+   (let ((*print-readably* nil)
+	 (*package* (find-package :cl-test)))
+     (format nil "~3,,0S" 'ABC)))
+  "ABC")
+
+(deftest format.s.32
+  (with-standard-io-syntax
+   (let ((*print-readably* nil)
+	 (*package* (find-package :cl-test)))
+     (format nil "~3,,-1S" 'ABC)))
+  "ABC")
+
+(deftest format.s.33
+  (with-standard-io-syntax
+   (let ((*print-readably* nil)
+	 (*package* (find-package :cl-test)))
+     (format nil "~3,,0S" 'ABCD)))
+  "ABCD")
+
+(deftest format.s.34
+  (with-standard-io-syntax
+   (let ((*print-readably* nil)
+	 (*package* (find-package :cl-test)))
+     (format nil "~3,,-1S" 'ABCD)))
+  "ABCD")
+
+;;; With padchar
+
+(deftest format.s.35
+  (with-standard-io-syntax
+   (let ((*print-readably* nil)
+	 (*package* (find-package :cl-test)))
+     (format nil "~4,,,'XS" 'AB)))
+  "ABXX")
+
+(deftest format.s.36
+  (with-standard-io-syntax
+   (let ((*print-readably* nil)
+	 (*package* (find-package :cl-test)))
+     (format nil "~4,,,s" 'AB)))
+  "AB  ")
+
+(deftest format.s.37
+  (with-standard-io-syntax
+   (let ((*print-readably* nil)
+	 (*package* (find-package :cl-test)))
+     (format nil "~4,,,'X@s" 'AB)))
+  "XXAB")
+
+(deftest format.s.38
+  (with-standard-io-syntax
+   (let ((*print-readably* nil)
+	 (*package* (find-package :cl-test)))
+     (format nil "~4,,,@S" 'AB)))
+  "  AB")
+
+(deftest format.s.39
+  (with-standard-io-syntax
+   (let ((*print-readably* nil)
+	 (*package* (find-package :cl-test)))
+     (format nil "~10,,,vS" nil 'ABCDE)))
+  "ABCDE     ")
+
+(deftest format.s.40
+  (with-standard-io-syntax
+   (let ((*print-readably* nil)
+	 (*package* (find-package :cl-test)))
+     (format nil "~10,,,v@S" nil 'ABCDE)))
+  "     ABCDE")
+
+(deftest format.s.41
+  (with-standard-io-syntax
+   (let ((*print-readably* nil)
+	 (*package* (find-package :cl-test)))
+     (format nil "~10,,,vs" #\* 'ABCDE)))
+  "ABCDE*****")
+
+(deftest format.s.42
+  (with-standard-io-syntax
+   (let ((*print-readably* nil)
+	 (*package* (find-package :cl-test)))
+     (format nil "~10,,,v@s" #\* 'ABCDE)))
+  "*****ABCDE")
+
+;;; Other tests
+
+(deftest format.s.43
+  (with-standard-io-syntax
+   (let ((*print-readably* nil))
+     (format nil "~3,,vS" nil 246)))
+  "246")
+
+(deftest format.s.44
+  (with-standard-io-syntax
+   (let ((*print-readably* nil)
+	 (*package* (find-package :cl-test)))
+     (loop for i from 0 to 6
+	   collect (format nil "~3,,vS" i 'ABC))))
+  ("ABC"
+   "ABC "
+   "ABC  "
+   "ABC   "
+   "ABC    "
+   "ABC     "
+   "ABC      "))
+
+(deftest format.s.44a
+  (with-standard-io-syntax
+   (let ((*print-readably* nil)
+	 (*package* (find-package :cl-test)))
+     (loop for i from 0 to 6
+	   collect (format nil "~3,,v@S" i 'ABC))))
+  ("ABC"
+   " ABC"
+   "  ABC"
+   "   ABC"
+   "    ABC"
+   "     ABC"
+   "      ABC"))
+
+(deftest format.s.45
+  (with-standard-io-syntax
+   (let ((*print-readably* nil))
+     (format nil "~4,,vs" -1 1234)))
+  "1234")
+
+(deftest format.s.46
+  (with-standard-io-syntax
+   (let ((*print-readably* nil))
+     (format nil "~5,vS" nil 123)))
+  "123  ")
+
+(deftest format.s.47
+  (with-standard-io-syntax
+   (let ((*print-readably* nil))
+     (format nil "~5,vS" 3 456)))
+  "456   ")
+
+(deftest format.s.48
+  (with-standard-io-syntax
+   (let ((*print-readably* nil))
+     (format nil "~5,v@S" 3 789)))
+  "   789")
diff --git a/ansi-tests/format-tilde.lsp b/ansi-tests/format-tilde.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..b68780d068a1d8112024c1ceaccc058f0c82077f
--- /dev/null
+++ b/ansi-tests/format-tilde.lsp
@@ -0,0 +1,40 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Wed Jul 28 00:27:00 2004
+;;;; Contains: Tests of format directive ~~
+
+(in-package :cl-test)
+
+(deftest format.~.1
+  (format nil "~~")
+  "~")
+
+(deftest format.~.2
+  (loop for i from 0 to 100
+	for s = (make-string i :initial-element #\~)
+	for s2 = (format nil (format nil "~~~D~~" i))
+	unless (string= s s2)
+	collect (list i s s2))
+  nil)
+
+(deftest format.~.3
+  (format nil "~v~" 0)
+  "")
+
+(deftest format.~.4
+  (loop for i from 0 to 100
+	for s = (make-string i :initial-element #\~)
+	for s2 = (format nil "~V~" i)
+	unless (string= s s2)
+	collect (list i s s2))
+  nil)
+
+(deftest format.~.5
+  (loop for i from 0 to (min (- call-arguments-limit 3) 100)
+	for s = (make-string i :initial-element #\~)
+	for args = (make-list i)
+	for s2 = (apply #'format nil "~#~" args)
+	unless (string= s s2)
+	collect (list i s s2))
+  nil)
+
diff --git a/ansi-tests/format-underscore.lsp b/ansi-tests/format-underscore.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..992ff4c1b27d26a2e97221d4f110ccec1a91a812
--- /dev/null
+++ b/ansi-tests/format-underscore.lsp
@@ -0,0 +1,293 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Wed Aug  4 03:36:50 2004
+;;;; Contains: Tests of the ~_ format directive
+
+(in-package :cl-test)
+
+(compile-and-load "printer-aux.lsp")
+
+(def-ppblock-test format._.1
+  (progn
+    (dotimes (i 2) (write "A ") (pprint-newline :fill))
+    ;; (write "B ") (pprint-newline :linear)
+    (format t "B ~_")
+    (dotimes (i 3) (write "A ") (pprint-newline :fill)))
+  "A A B
+A A A "
+  :margin 10)
+
+(def-ppblock-test format._.2
+  (progn
+   (dotimes (i 2) (write "A ") (pprint-newline :fill))
+   ;; (write "B ") (pprint-newline :linear)
+   (format t "B ~_")
+   (dotimes (i 2) (write "C ") (pprint-newline :fill))
+   (format t "D ~_")
+   (dotimes (i 3) (write "A ") (pprint-newline :fill)))
+  "A A B
+C C D
+A A A "
+  :margin 10)
+
+(def-ppblock-test format._.3
+  (format t "A ~_A ~_A ~_A ~_")
+  "A A A A "
+  :margin 10)
+
+(def-ppblock-test format._.4
+  (format t "A ~_A ~_A ~_A ~_")
+  "A A A A "
+  :margin 10
+  :miser 10)
+
+(def-ppblock-test format._.5
+  (format t "A ~_A ~_A ~_A ~_A ~_A ~_A ~_A ~_A ~_A ~_")
+  "A A A A A A A A A A "
+  :margin 10
+  :pretty nil)
+
+(def-ppblock-test format._.6
+  (dotimes (i 4) (format t "A             ~_"))
+  "A
+A
+A
+A
+"
+  :margin 10)
+
+(def-ppblock-test format._.7
+  (format t "A ~_A ~_A ~_A ~_~%A ~_A ~_A ~_A ~_")
+  "A
+A
+A
+A
+
+A
+A
+A
+A
+"
+  :margin 10)
+
+(def-ppblock-test format._.8
+  (progn
+    (pprint-logical-block (*standard-output* nil)
+			  (format t "A ~_A ~_A ~_A ~_"))
+    (format t "~_")
+    (pprint-logical-block (*standard-output* nil)
+			  (format t "A ~_A ~_A ~_A ~_")))
+  "A A A A
+A A A A "
+  :margin 10)
+
+(deftest format._.9
+  (with-standard-io-syntax
+   (let ((*print-readably* nil)
+	 (*print-escape* nil)
+	 (*print-pretty* t)
+	 (*print-right-margin* 4)
+	 (*print-miser-width* nil))
+     (format nil "A ~_A ~_A ~_A ~_A ~_")))
+  "A A A A A ")
+
+;;; miser
+
+(def-ppblock-test format.@_.1
+  (format t "A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_")
+  "A A A A A A A A A A "
+  :margin 10)
+
+(def-ppblock-test format.@_.2
+  (format t "A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_")
+  "A A A A A A A A A A "
+  :margin 10
+  :miser 0)
+
+(def-ppblock-test format.@_.3
+  (format t "A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_")
+  "A A A A A A A A A A "
+  :margin 10
+  :miser 9)
+
+(def-ppblock-test format.@_.4
+  (format t "A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_")
+  "A
+A
+A
+A
+A
+A
+A
+A
+A
+A
+"
+  :margin 10
+  :miser 10)
+
+(def-ppblock-test format.@_.5
+  (format t "A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_")
+  "A A A A A A A A A A "
+  :margin 10
+  :miser 10
+  :pretty nil)
+
+(def-ppblock-test format.@_.6
+  (format t "~%A~@_")
+  "
+A
+"
+  :margin 20
+  :miser 20)
+
+(def-ppblock-test format.@_.7
+  (format t "~@_A~%")
+  "
+A
+"
+  :margin 20
+  :miser 20)
+
+(def-ppblock-test format.@_.8
+  (progn
+    (format t "AAAA ~_")
+    (pprint-logical-block
+     (*standard-output* nil)
+     (format t "A ~@_A ~@_A ~@_A ~@_")))
+  "AAAA
+A A A A "
+  :margin 10
+  :miser 8)
+
+(def-ppblock-test format.@_.9
+  (progn
+    (format t "AAAA ~:@_")
+    (pprint-logical-block
+     (*standard-output* nil)
+     (format t "A ~@_A ~@_A ~@_A ~@_")))
+  "AAAA
+A A A A "
+  :margin 10
+  :miser 8)
+
+(deftest format.@_.10
+  (with-standard-io-syntax
+   (let ((*print-readably* nil)
+	 (*print-escape* nil)
+	 (*print-pretty* t)
+	 (*print-right-margin* 4)
+	 (*print-miser-width* 4))
+     (format nil "A ~@_A ~@_A ~@_A ~@_A ~@_")))
+  "A A A A A ")
+
+;;; fill
+
+(def-ppblock-test format.\:_.1
+  (format t "A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_")
+  "A A A A A
+A A A A A "
+  :margin 10)
+
+(def-ppblock-test format.\:_.2
+  (format t "A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_")
+  "A A A
+A A A
+A A A
+A "
+  :margin 6)
+
+(def-ppblock-test format.\:_.3
+  (format t "A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_")
+  "A A A
+A A A
+A A A
+A "
+  :margin 7)
+
+(def-ppblock-test format.\:_.4
+  (format t "A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_")
+  "A A A A A
+A A A A A "
+  :margin 10
+  :miser 9)
+
+(def-ppblock-test format.\:_.5
+  (format t "A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_")
+  "A
+A
+A
+A
+A
+A
+A
+A
+A
+A
+"
+  :margin 10
+  :miser 10)
+
+(def-ppblock-test format.\:_.6
+  (format t "~W~W~:_~W~W~:_~W~W~:_~W~W~:_~W~W~:_"
+	  '(A B) #\Space
+	  '(A B) #\Space
+	  '(A B) #\Space
+	  '(A B) #\Space
+	  '(A B) #\Space)
+  "(A B) (A B)
+(A B) (A B)
+(A B) "
+  :margin 12)
+
+(deftest format.\:_.7
+  (with-standard-io-syntax
+   (let ((*print-readably* nil)
+	 (*print-escape* nil)
+	 (*print-right-margin* 4)
+	 (*print-pretty* t)
+	 (*print-miser-width* nil))
+     (format nil "A ~:_A ~:_A ~:_A ~:_A ~:_")))
+  "A A A A A ")
+
+;;; mandatory
+
+(def-ppblock-test format.\:@.1
+  (format t "A ~:@_A ~:@_A ~:@_A ~:@_")
+  "A
+A
+A
+A
+")
+
+(def-ppblock-test format.\:@.2
+  (format t "A ~@:_A ~@:_A ~@:_A ~@:_")
+  "A
+A
+A
+A
+"
+  :margin 10)
+
+(def-ppblock-test format.\:@.3
+  (format t "A ~@:_A ")
+  "A
+A "
+  :margin 1)
+
+(def-ppblock-test format.\:@.4
+  (format t "A ~@:_A ~@:_A ~@:_A ~@:_")
+  "A A A A "
+  :pretty nil)
+
+(deftest format.\:@.5
+  (with-standard-io-syntax
+   (let ((*print-readably* nil)
+	 (*print-escape* nil)
+	 (*print-pretty* t)
+	 (*print-right-margin* 4)
+	 (*print-miser-width* nil))
+     (format nil "A ~:@_A ~:@_A ~:@_A ~:@_A ~:@_")))
+  "A A A A A ")
+
+
diff --git a/ansi-tests/format-x.lsp b/ansi-tests/format-x.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..51d4f8adfa964029f0ed80162c8cabd74ef361eb
--- /dev/null
+++ b/ansi-tests/format-x.lsp
@@ -0,0 +1,416 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Sun Aug  1 06:51:34 2004
+;;;; Contains: Tests of ~X format directive
+
+(in-package :cl-test)
+
+(compile-and-load "printer-aux.lsp")
+
+(deftest format.x.1
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for i = (- (random (+ x x)) x)
+	 for s1 = (format nil "~X" i)
+	 for j = (let ((*read-base* 16)) (read-from-string s1))
+	 repeat 1000
+	 when (or (/= i j)
+		  (find #\. s1)
+		  (find #\+ s1)
+		  (loop for c across s1
+			thereis (and (not (eql c #\-))
+				     (not (digit-char-p c 16)))))
+	 collect (list i s1 j)))
+  nil)
+
+(deftest format.x.2
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for i = (- (random (+ x x)) x)
+	 for s1 = (format nil "~@x" i)
+	 for j = (let ((*read-base* 16)) (read-from-string s1))
+	 repeat 1000
+	 when (or (/= i j)
+		  (find #\. s1)
+		  ;; (find #\+ s1)
+		  (loop for c across s1
+			thereis (and
+				 (not (find c "-+"))
+				 (not (digit-char-p c 16)))))
+	 collect (list i s1 j)))
+  nil)
+
+(deftest format.x.3
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for mincol = (random 30)
+	 for i = (- (random (+ x x)) x)
+	 for s1 = (format nil "~x" i)
+	 for s2 = (format nil (format nil "~~~d~c"
+				      mincol (random-from-seq "xX"))
+			  i)
+	 for pos = (search s1 s2)
+	 repeat 1000
+	 when (or (null pos)
+		  (and (> mincol (length s1))
+		       (or (/= (length s2) mincol)
+			   (not (eql (position #\Space s2 :test-not #'eql)
+				     (- (length s2) (length s1)))))))
+	 collect (list i mincol s1 s2 pos)))
+  nil)
+
+(deftest format.x.4
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for mincol = (random 30)
+	 for i = (- (random (+ x x)) x)
+	 for s1 = (format nil "~@X" i)
+	 for s2 = (format nil (format nil "~~~d@~c" mincol
+				      (random-from-seq "xX"))
+			  i)
+	 for pos = (search s1 s2)
+	 repeat 1000
+	 when (or (null pos)
+		  (and (>= i 0) (not (eql (elt s1 0) #\+)))
+		  (and (> mincol (length s1))
+		       (or (/= (length s2) mincol)
+			   (not (eql (position #\Space s2 :test-not #'eql)
+				     (- (length s2) (length s1)))))))
+	 collect (list i mincol s1 s2 pos)))
+  nil)
+
+(deftest format.x.5
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for mincol = (random 30)
+	 for padchar = (random-from-seq +standard-chars+)
+	 for i = (- (random (+ x x)) x)
+	 for s1 = (format nil "~x" i)
+	 for s2 = (format nil (format nil "~~~d,'~c~c" mincol padchar
+				     (random-from-seq "xX"))
+			  i)
+	 for pos = (search s1 s2)
+	 repeat 1000
+	 when (or (null pos)
+		  (and (> mincol (length s1))
+		       (or (/= (length s2) mincol)
+			   (find padchar s2 :end (- (length s2) (length s1))
+				 :test-not #'eql))))
+	 collect (list i mincol s1 s2 pos)))
+  nil)
+
+(deftest format.x.6
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for mincol = (random 30)
+	 for padchar = (random-from-seq +standard-chars+)
+	 for i = (- (random (+ x x)) x)
+	 for s1 = (format nil "~x" i)
+	 for s2 = (format nil "~v,vX" mincol padchar i)
+	 for pos = (search s1 s2)
+	 repeat 1000
+	 when (or (null pos)
+		  (and (> mincol (length s1))
+		       (or (/= (length s2) mincol)
+			   (find padchar s2 :end (- (length s2) (length s1))
+				 :test-not #'eql))))
+	 collect (list i mincol s1 s2 pos)))
+  nil)
+
+(deftest format.x.7
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for mincol = (random 30)
+	 for padchar = (random-from-seq +standard-chars+)
+	 for i = (- (random (+ x x)) x)
+	 for s1 = (format nil "~@x" i)
+	 for s2 = (format nil "~v,v@x" mincol padchar i)
+	 for pos = (search s1 s2)
+	 repeat 1000
+	 when (or (null pos)
+		  (and (>= i 0) (not (eql (elt s1 0) #\+)))
+		  (and (> mincol (length s1))
+		       (or (/= (length s2) mincol)
+			   (find padchar s2 :end (- (length s2) (length s1))
+				 :test-not #'eql))))
+	 collect (list i mincol s1 s2 pos)))
+  nil)
+
+;;; Comma tests
+
+(deftest format.x.8
+  (loop for i from -999 to 999
+	for s1 = (format nil "~x" i)
+	for s2 = (format nil "~:x" i)
+	unless (string= s1 s2)
+	collect (list i s1 s2))
+  nil)
+
+(deftest format.x.9
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for i = (- (random (+ x x)) x)
+	 for commachar = #\,
+	 for s1 = (format nil "~x" i)
+	 for s2 = (format nil "~:X" i)
+	 repeat 1000
+	 unless (and (string= s1 (remove commachar s2))
+		     (not (eql (elt s2 0) commachar))
+		     (or (>= i 0) (not (eql (elt s2 1) commachar)))
+		     (let ((len (length s2))
+			   (ci+1 4))
+		       (loop for i from (if (< i 0) 2 1) below len
+			     always (if (= (mod (- len i) ci+1) 0)
+					(eql (elt s2 i) commachar)
+				      (find (elt s2 i) "0123456789ABCDEF")))))
+	 collect (list x i commachar s1 s2)))
+  nil)
+
+(deftest format.x.10
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for i = (- (random (+ x x)) x)
+	 for commachar = (random-from-seq +standard-chars+)
+	 for s1 = (format nil "~x" i)
+	 for s2 = (format nil "~,,v:X" commachar i)
+	 repeat 1000
+	 unless (and
+		 (eql (elt s1 0) (elt s2 0))
+		 (if (< i 0) (eql (elt s1 1) (elt s2 1)) t)
+		 (let ((len (length s2))
+		      (ci+1 4)
+		      (j (if (< i 0) 1 0)))
+		  (loop for i from (if (< i 0) 2 1) below len
+			always (if (= (mod (- len i) ci+1) 0)
+				   (eql (elt s2 i) commachar)
+				 (eql (elt s1 (incf j)) (elt s2 i))))))
+	 collect (list x i commachar s1 s2)))
+  nil)
+
+(deftest format.x.11
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for i = (- (random (+ x x)) x)
+	 for commachar = (random-from-seq +standard-chars+)
+	 for s1 = (format nil "~x" i)
+	 for s2 = (format nil (format nil "~~,,'~c:~c" commachar
+				      (random-from-seq "xX"))
+			  i)
+	 repeat 1000
+	 unless (and
+		 (eql (elt s1 0) (elt s2 0))
+		 (if (< i 0) (eql (elt s1 1) (elt s2 1)) t)
+		 (let ((len (length s2))
+		      (ci+1 4)
+		      (j (if (< i 0) 1 0)))
+		  (loop for i from (if (< i 0) 2 1) below len
+			always (if (= (mod (- len i) ci+1) 0)
+				   (eql (elt s2 i) commachar)
+				 (eql (elt s1 (incf j)) (elt s2 i))))))
+	 collect (list x i commachar s1 s2)))
+  nil)
+
+(deftest format.x.12
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for i = (- (random (+ x x)) x)
+	 for commachar = (random-from-seq +standard-chars+)
+	 for commaint = (1+ (random 20))
+	 for s1 = (format nil "~x" i)
+	 for s2 = (format nil "~,,v,v:X" commachar commaint i)
+	 repeat 1000
+	 unless (and
+		 (eql (elt s1 0) (elt s2 0))
+		 (if (< i 0) (eql (elt s1 1) (elt s2 1)) t)
+		 (let ((len (length s2))
+		       (ci+1 (1+ commaint))
+		       (j (if (< i 0) 1 0)))
+		   (loop for i from (if (< i 0) 2 1) below len
+			 always (if (= (mod (- len i) ci+1) 0)
+				    (eql (elt s2 i) commachar)
+				  (eql (elt s1 (incf j)) (elt s2 i))))))
+	 collect (list x i commachar s1 s2)))
+  nil)
+
+(deftest format.x.13
+  (with-standard-io-syntax
+   (loop for x = (ash 1 (+ 2 (random 80)))
+	 for i = (- (random (+ x x)) x)
+	 for commachar = (random-from-seq +standard-chars+)
+	 for commaint = (1+ (random 20))
+	 for s1 = (format nil "~@x" i)
+	 for s2 = (format nil "~,,v,v:@x" commachar commaint i)
+	 repeat 1000
+	 unless (and
+		 (eql (elt s1 0) (elt s2 0))
+		 (eql (elt s1 1) (elt s2 1))
+		 (let ((len (length s2))
+		       (ci+1 (1+ commaint))
+		       (j 1))
+		   (loop for i from 2 below len
+			 always (if (= (mod (- len i) ci+1) 0)
+				    (eql (elt s2 i) commachar)
+				  (eql (elt s1 (incf j)) (elt s2 i))))))
+	 collect (list x i commachar s1 s2)))
+  nil)
+
+;;; NIL arguments
+
+(deftest format.x.14
+  (format nil "~vx" nil #x100)
+  "100")
+
+(deftest format.x.15
+  (format nil "~6,vX" nil #x100)
+  "   100")
+
+(deftest format.x.16
+  (format nil "~,,v:x" nil #x12345)
+  "12,345")
+
+(deftest format.x.17
+  (format nil "~,,'*,v:x" nil #x12345)
+  "12*345")
+
+;;; When the argument is not an integer, print as if using ~A and base 10
+
+(deftest format.x.18
+  (loop for x in *mini-universe*
+	for s1 = (format nil "~x" x)
+	for s2 = (let ((*print-base* 16)) (format nil "~A" x))
+	unless (or (integerp x) (string= s1 s2))
+	collect (list x s1 s2))
+  nil)
+
+(deftest format.x.19
+  (loop for x in *mini-universe*
+	for s1 = (format nil "~:d" x)
+	for s2 = (format nil "~A" x)
+	unless (or (integerp x) (string= s1 s2))
+	collect (list x s1 s2))
+  nil)
+
+(deftest format.x.20
+  (loop for x in *mini-universe*
+	for s1 = (format nil "~@x" x)
+	for s2 = (let ((*print-base* 16)) (format nil "~A" x))
+	unless (or (integerp x) (string= s1 s2))
+	collect (list x s1 s2))
+  nil)
+
+(deftest format.x.21
+  (loop for x in *mini-universe*
+	for s1 = (format nil "~@:x" x)
+	for s2 = (let ((*print-base* 16)) (format nil "~A" x))
+	unless (or (integerp x) (string= s1 s2))
+	collect (list x s1 s2))
+  nil)
+
+;;; Must add tests for non-integers when the parameters
+;;; are specified, but it's not clear what the meaning is.
+;;; Does mincol apply to the ~A equivalent?  What about padchar?
+;;; Are comma-char and comma-interval always ignored?
+
+;;; # arguments
+
+(deftest format.x.22
+  (apply
+   #'values
+   (loop for i from 0 to 10
+	 for args = (make-list i)
+	 for s = (apply #'format nil "~#x" #x1b3fe args)
+	 collect s))
+  "1B3FE"
+  "1B3FE"
+  "1B3FE"
+  "1B3FE"
+  "1B3FE"
+  " 1B3FE"
+  "  1B3FE"
+  "   1B3FE"
+  "    1B3FE"
+  "     1B3FE"
+  "      1B3FE")
+
+(deftest format.x.23
+  (apply
+   #'values
+   (loop for i from 0 to 10
+	 for args = (make-list i)
+	 for s = (apply #'format nil "~,,,#:x" #x1234567890 args)
+	 collect s))
+  "1,2,3,4,5,6,7,8,9,0"
+  "12,34,56,78,90"
+  "1,234,567,890"
+  "12,3456,7890"
+  "12345,67890"
+  "1234,567890"
+  "123,4567890"
+  "12,34567890"
+  "1,234567890"
+  "1234567890"
+  "1234567890")
+
+(deftest format.x.24
+  (apply
+   #'values
+   (loop for i from 0 to 10
+	 for args = (make-list i)
+	 for s = (apply #'format nil "~,,,#@:X" #x1234567890 args)
+	 collect s))
+  "+1,2,3,4,5,6,7,8,9,0"
+  "+12,34,56,78,90"
+  "+1,234,567,890"
+  "+12,3456,7890"
+  "+12345,67890"
+  "+1234,567890"
+  "+123,4567890"
+  "+12,34567890"
+  "+1,234567890"
+  "+1234567890"
+  "+1234567890")
+
+(deftest format.x.25
+  (format nil "~+10x" #x1234)
+  "      1234")
+
+(deftest format.x.26
+  (format nil "~+10@X" #x1234)
+  "     +1234")
+
+(deftest format.x.27
+  (format nil "~-1X" #x1234)
+  "1234")
+
+(deftest format.x.28
+  (format nil "~-1000000000000000000x" #x1234)
+  "1234")
+
+(deftest format.x.29
+  (format nil "~vx" (1- most-negative-fixnum) #x1234)
+  "1234")
+
+;;; Randomized test
+
+(deftest format.x.30
+  (loop
+   for mincol = (and (coin) (random 50))
+   for padchar = (and (coin)
+		      (random-from-seq +standard-chars+))
+   for commachar = (and (coin)
+			(random-from-seq +standard-chars+))
+   for commaint = (and (coin) (1+ (random 10)))
+   for k = (ash 1 (+ 2 (random 30)))
+   for x = (- (random (+ k k)) k)
+   for fmt = (concatenate
+	      'string
+	      (if mincol (format nil "~~~d," mincol) "~,")
+	      (if padchar (format nil "'~c," padchar) ",")
+	      (if commachar (format nil "'~c," commachar) ",")
+	      (if commaint (format nil "~dx" commaint) "x"))
+   for s1 = (format nil fmt x)
+   for s2 = (format nil "~v,v,v,vx" mincol padchar commachar commaint x)
+   repeat 2000
+   unless (string= s1 s2)
+   collect (list mincol padchar commachar commaint fmt x s1 s2))
+  nil)
\ No newline at end of file
diff --git a/ansi-tests/load-format.lsp b/ansi-tests/load-format.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..351225ca945abd8be8edb229a943847e397d9f4c
--- /dev/null
+++ b/ansi-tests/load-format.lsp
@@ -0,0 +1,34 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Mon Aug  2 21:47:02 2004
+;;;; Contains: Load format-related tests
+
+(in-package :cl-test)
+
+;;; Format tests
+
+;;; 22.3.1
+(load "format-c.lsp")
+(load "format-percent.lsp")
+(load "format-ampersand.lsp")
+(load "format-page.lsp")
+(load "format-tilde.lsp")
+
+;;; 22.3.2
+(load "format-r.lsp")
+(load "format-d.lsp")
+(load "format-b.lsp")
+(load "format-o.lsp")
+(load "format-x.lsp")
+
+;;; 22.3.3
+(load "format-f.lsp")
+
+;;; 22.3.4
+(load "format-a.lsp")
+(load "format-s.lsp")
+
+;;; 22.3.5
+(load "format-underscore.lsp")
+
+
diff --git a/ansi-tests/load-printer.lsp b/ansi-tests/load-printer.lsp
index f48610b8e30ec5a55d97485e14a9adadd643da77..c5bae7e90bafde300e1fd529354d93928b6c98f5 100644
--- a/ansi-tests/load-printer.lsp
+++ b/ansi-tests/load-printer.lsp
@@ -35,3 +35,15 @@
 (load "pprint-newline.lsp")
 (load "pprint-tab.lsp")
 (load "print-unreadable-object.lsp")
+(load "write.lsp")
+(load "print.lsp")
+(load "pprint.lsp")
+(load "prin1.lsp")
+(load "princ.lsp")
+(load "write-to-string.lsp")
+(load "prin1-to-string.lsp")
+(load "princ-to-string.lsp")
+(load "print-level.lsp")
+(load "print-length.lsp")
+
+(load "load-format.lsp")
diff --git a/ansi-tests/makefile b/ansi-tests/makefile
index 1ca8f077ab69402a785e4836eb42005b1ec6fb76..844c9a895a0901e6fbc4f11176d11b171abd77c2 100644
--- a/ansi-tests/makefile
+++ b/ansi-tests/makefile
@@ -18,7 +18,7 @@ random-test:
 		(load \"gclload1.lsp\") \
 		(funcall (symbol-function 'compile-and-load) \"random-int-form.lsp\")))  \
 	      (in-package :cl-test) \
-	      (let ((x (cl-test::test-random-integer-forms 1000 10 100 :random-size t :random-nvars t))) \
+	      (let ((x (cl-test::test-random-integer-forms 100 10 1000 :random-size t :random-nvars t))) \
 		(setq x (cl-test::prune-results x)) \
 		(with-open-file (*standard-output* \"failures.lsp\" \
 		   :direction :output \
diff --git a/ansi-tests/pprint.lsp b/ansi-tests/pprint.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..de8462629c47553c2ad63f10565118b1a71467f0
--- /dev/null
+++ b/ansi-tests/pprint.lsp
@@ -0,0 +1,49 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Sun Jul 25 11:42:48 2004
+;;;; Contains: Tests of PPRINT
+
+(in-package :cl-test)
+
+(compile-and-load "printer-aux.lsp")
+
+;;; This function is mostly tested elsewhere
+
+(deftest pprint.1
+  (random-pprint-test 1000)
+  nil)
+
+(deftest pprint.2
+  (with-standard-io-syntax
+   (with-output-to-string
+     (os)
+     (with-input-from-string
+      (is "")
+      (with-open-stream (*terminal-io* (make-two-way-stream is os))
+			(pprint 2 t)))))
+  "
+2")
+
+(deftest pprint.3
+  (with-standard-io-syntax
+   (with-output-to-string
+     (*standard-output*)
+     (pprint 3 nil)))
+  "
+3")
+
+;;; Error tests
+
+(deftest pprint.error.1
+  (signals-error
+   (with-output-to-string (*standard-output*) (pprint))
+   program-error)
+  t)
+
+(deftest pprint.error.2
+  (signals-error
+   (with-output-to-string (s) (pprint nil s nil))
+   program-error)
+  t)
+
+
diff --git a/ansi-tests/prin1-to-string.lsp b/ansi-tests/prin1-to-string.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..6e950f7ac8f77e0fb2ce802a87fd5bca8f73d437
--- /dev/null
+++ b/ansi-tests/prin1-to-string.lsp
@@ -0,0 +1,26 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Mon Jul 26 12:18:22 2004
+;;;; Contains: Tests of PRIN1-TO-STRING
+
+(in-package :cl-test)
+
+(compile-and-load "printer-aux.lsp")
+
+(deftest prin1-to-string.1
+  (random-prin1-to-string-test 5)
+  nil)
+
+(deftest prin1-to-string.2
+  (with-standard-io-syntax (prin1-to-string 2))
+  "2")
+
+;;; Error tests
+
+(deftest prin1-to-string.error.1
+  (signals-error (prin1-to-string) program-error)
+  t)
+
+(deftest prin1-to-string.error.2
+  (signals-error (prin1-to-string nil nil) program-error)
+  t)
diff --git a/ansi-tests/prin1.lsp b/ansi-tests/prin1.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..6811ec6253e00395ea02b58efa01236625e5202c
--- /dev/null
+++ b/ansi-tests/prin1.lsp
@@ -0,0 +1,45 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Sun Jul 25 11:33:40 2004
+;;;; Contains: Tests of PRIN1
+
+(in-package :cl-test)
+
+(compile-and-load "printer-aux.lsp")
+
+;;; This function is mostly tested elsewhere
+
+(deftest prin1.1
+  (random-prin1-test 1000)
+  nil)
+
+(deftest prin1.2
+  (with-standard-io-syntax
+   (with-output-to-string
+     (os)
+     (with-input-from-string
+      (is "")
+      (with-open-stream (*terminal-io* (make-two-way-stream is os))
+			(prin1 2 t)))))
+  "2")
+
+(deftest prin1.3
+  (with-standard-io-syntax
+   (with-output-to-string
+     (*standard-output*)
+     (prin1 3 nil)))
+  "3")
+
+;;; Error tests
+
+(deftest prin1.error.1
+  (signals-error
+   (with-output-to-string (*standard-output*) (prin1))
+   program-error)
+  t)
+
+(deftest prin1.error.2
+  (signals-error
+   (with-output-to-string (s) (prin1 nil s nil))
+   program-error)
+  t)
diff --git a/ansi-tests/princ-to-string.lsp b/ansi-tests/princ-to-string.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..3a3171737186fb4ec3261289470635e84bd9819e
--- /dev/null
+++ b/ansi-tests/princ-to-string.lsp
@@ -0,0 +1,27 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Mon Jul 26 12:19:32 2004
+;;;; Contains: Tests of PRINC-TO-STRING
+
+(in-package :cl-test)
+
+(compile-and-load "printer-aux.lsp")
+
+(deftest princ-to-string.1
+  (random-princ-to-string-test 1000)
+  nil)
+
+(deftest princ-to-string.2
+  (with-standard-io-syntax (princ-to-string 2))
+  "2")
+
+;;; Error tests
+
+(deftest princ-to-string.error.1
+  (signals-error (princ-to-string) program-error)
+  t)
+
+(deftest princ-to-string.error.2
+  (signals-error (princ-to-string nil nil) program-error)
+  t)
+
diff --git a/ansi-tests/princ.lsp b/ansi-tests/princ.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..4446123b406c2bd884be64f1977b4143c744c933
--- /dev/null
+++ b/ansi-tests/princ.lsp
@@ -0,0 +1,45 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Sun Jul 25 11:40:37 2004
+;;;; Contains: Tests of PRINC
+
+(in-package :cl-test)
+
+(compile-and-load "printer-aux.lsp")
+
+;;; This function is mostly tested elsewhere
+
+(deftest princ.1
+  (random-princ-test 5)
+  nil)
+
+(deftest princ.2
+  (with-standard-io-syntax
+   (with-output-to-string
+     (os)
+     (with-input-from-string
+      (is "")
+      (with-open-stream (*terminal-io* (make-two-way-stream is os))
+			(princ 2 t)))))
+  "2")
+
+(deftest princ.3
+  (with-standard-io-syntax
+   (with-output-to-string
+     (*standard-output*)
+     (princ 3 nil)))
+  "3")
+
+;;; Error tests
+
+(deftest princ.error.1
+  (signals-error
+   (with-output-to-string (*standard-output*) (princ))
+   program-error)
+  t)
+
+(deftest princ.error.2
+  (signals-error
+   (with-output-to-string (s) (princ nil s nil))
+   program-error)
+  t)
diff --git a/ansi-tests/print-array.lsp b/ansi-tests/print-array.lsp
index 5f74ff67b1ffeafb98de28d4eb703bb8f63dd201..8b2d58961464739aa152e023472e3ec899fe0f1b 100644
--- a/ansi-tests/print-array.lsp
+++ b/ansi-tests/print-array.lsp
@@ -24,9 +24,12 @@
   "#0AA")
 
 (deftest print.array.0.3
-  (let ((a (make-array nil :initial-element 0)))
-    (subseq (write-to-string a :readably nil :array nil) 0 2))
-  "#<")
+  (let* ((a (make-array nil :initial-element 0))
+	 (result (write-to-string a :readably nil :array nil)))
+    (values
+     (subseq result 0 2)
+     (subseq result (1- (length result)))))
+  "#<" ">")
 
 (deftest print.array.0.4
    (let ((a (make-array nil :initial-element 0 :adjustable t)))
@@ -96,17 +99,20 @@
   nil)
 
 (deftest print.array.0.13
-  (subseq (write-to-string (make-array nil :initial-element 0)
-			   :readably nil :array nil)
-	  0 2)
-  "#<")
+  (let ((result (write-to-string (make-array nil :initial-element 0)
+				 :readably nil :array nil)))
+    (values
+     (subseq result 0 2)
+     (subseq result (1- (length result)))))
+  "#<" ">")
 
 (deftest print.array.0.14
   (loop for i from 1 to 64
 	for type = `(unsigned-byte ,i)
 	for a = (make-array nil :element-type type :initial-element 1)
 	for result = (write-to-string a :readably nil :array nil)
-	unless (string= (subseq result 0 2) "#<")
+	unless (and (string= (subseq result 0 2) "#<")
+		    (string= (subseq result (1- (length result))) ">"))
 	collect (list i result))
   nil)
 
@@ -115,7 +121,8 @@
 	for type = `(signed-byte ,i)
 	for a = (make-array nil :element-type type :initial-element -1)
 	for result = (write-to-string a :readably nil :array nil)
-	unless (string= (subseq result 0 2) "#<")
+	unless (and (string= (subseq result 0 2) "#<")
+		    (string= (subseq result (1- (length result))) ">"))
 	collect (list i result))
   nil)
 
@@ -124,7 +131,8 @@
 	for a = (make-array nil :element-type type
 			    :initial-element (coerce 17 type))
 	for result = (write-to-string a :readably nil :array nil)
-	unless (string= (subseq result 0 2) "#<")
+	unless (and (string= (subseq result 0 2) "#<")
+		    (string= (subseq result (1- (length result))) ">"))
 	collect (list type result))
   nil)
 
@@ -135,7 +143,8 @@
 	for a = (make-array nil :element-type type
 			    :initial-element (complex 0 (coerce 3 type0)))
 	for result = (write-to-string a :readably nil :array nil)
-	unless (string= (subseq result 0 2) "#<")
+	unless (and (string= (subseq result 0 2) "#<")
+		    (string= (subseq result (1- (length result))) ">"))
 	collect (list type result))
   nil)
 
@@ -354,17 +363,18 @@
 
 
 (deftest print.array.2.27
-  (subseq (write-to-string (make-array '(2 3) :initial-element 0)
-			   :readably nil :array nil)
-	  0 2)
-  "#<")
+  (let ((str (write-to-string (make-array '(2 3) :initial-element 0)
+			      :readably nil :array nil)))
+    (values (subseq str 0 2) (subseq str (1- (length str)))))
+  "#<" ">")
 
 (deftest print.array.2.28
   (loop for i from 1 to 64
 	for type = `(unsigned-byte ,i)
 	for a = (make-array '(4 3) :element-type type :initial-element 1)
 	for result = (write-to-string a :readably nil :array nil)
-	unless (string= (subseq result 0 2) "#<")
+	unless (and (string= (subseq result 0 2) "#<")
+		    (string= (subseq result (1- (length result))) ">"))
 	collect (list i result))
   nil)
 
@@ -373,7 +383,8 @@
 	for type = `(signed-byte ,i)
 	for a = (make-array '(4 8) :element-type type :initial-element -1)
 	for result = (write-to-string a :readably nil :array nil)
-	unless (string= (subseq result 0 2) "#<")
+	unless (and (string= (subseq result 0 2) "#<")
+		    (string= (subseq result (1- (length result))) ">"))
 	collect (list i result))
   nil)
 
@@ -382,7 +393,8 @@
 	for a = (make-array '(5 7) :element-type type
 			    :initial-element (coerce 17 type))
 	for result = (write-to-string a :readably nil :array nil)
-	unless (string= (subseq result 0 2) "#<")
+	unless (and (string= (subseq result 0 2) "#<")
+		    (string= (subseq result (1- (length result))) ">"))
 	collect (list type result))
   nil)
 
@@ -393,7 +405,8 @@
 	for a = (make-array '(13 5) :element-type type
 			    :initial-element (complex 0 (coerce 3 type0)))
 	for result = (write-to-string a :readably nil :array nil)
-	unless (string= (subseq result 0 2) "#<")
+	unless (and (string= (subseq result 0 2) "#<")
+		    (string= (subseq result (1- (length result))) ">"))
 	collect (list type result))
   nil)
 
diff --git a/ansi-tests/print-level.lsp b/ansi-tests/print-level.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..6d5b1a732dc5245a6a6bdad935829f6a7247746a
--- /dev/null
+++ b/ansi-tests/print-level.lsp
@@ -0,0 +1,121 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Mon Jul 26 13:07:51 2004
+;;;; Contains: Tests of binding the *PRINT-LEVEL* variable
+
+(in-package :cl-test)
+
+(compile-and-load "printer-aux.lsp")
+
+(deftest print-level.1
+  (with-standard-io-syntax
+   (let ((*print-readably* nil))
+     (loop for x in *mini-universe*
+	   for s1 = (write-to-string x)
+	   for s2 = (let ((*print-level* 0)) (write-to-string x))
+	   when (and (or (consp x)
+			 (and (arrayp x)
+			      (not (stringp x))
+			      (not (typep x 'bit-vector)))
+			 (typep (class-of x) 'structure-class))
+		      (not (string= s2 "#")))
+	   collect (list x s1 s2))))
+  nil)
+
+(defclass print-level-test-class nil (a b c))
+
+(deftest print-level.2
+  (with-standard-io-syntax
+   (write-to-string (make-instance 'print-level-test-class)
+		    :level 0
+		    :readably nil))
+  "#")
+
+(deftest print-level.3
+  (with-standard-io-syntax
+   (write-to-string (make-array '(4) :initial-contents '(a b c d))
+		    :readably nil
+		    :array t
+		    :level 0))
+  "#")
+
+(deftest print-level.4
+  (with-standard-io-syntax
+   (write-to-string (make-array '(4) :initial-contents '(1 1 0 1)
+				:element-type 'bit)
+		    :readably nil
+		    :array t
+		    :level 0))
+  "#*1101")
+
+(deftest print-level.5
+  (with-standard-io-syntax
+   (write-to-string "abcd"
+		    :readably nil
+		    :array t
+		    :level 0))
+  "\"abcd\"")
+
+(define-condition print-level-condition (condition) (a b c))
+
+(deftest print-level.6
+  (with-standard-io-syntax
+   (write-to-string (make-condition 'print-level-condition)
+		    :level 0 :pretty nil :readably nil))
+  "#")
+
+(deftest print-level.7
+  (with-standard-io-syntax
+   (write-to-string (make-condition 'print-level-condition)
+		    :level 0 :pretty t :readably nil))
+  "#")
+
+(defstruct print-level-struct)
+
+(deftest print-level.8
+  (with-standard-io-syntax
+   (let* ((*package* (find-package "CL-TEST"))
+	  (*print-pretty* nil)
+	  (s (make-print-level-struct)))
+     (values
+      (write-to-string s :level 0   :readably nil)
+      (write-to-string s :level 1   :readably nil)
+      (write-to-string s :level nil :readably nil))))
+  "#S(PRINT-LEVEL-STRUCT)"
+  "#S(PRINT-LEVEL-STRUCT)"
+  "#S(PRINT-LEVEL-STRUCT)")
+
+(deftest print-level.9
+  (with-standard-io-syntax
+   (let* ((*package* (find-package "CL-TEST"))
+	  (*print-pretty* t)
+	  (s (make-print-level-struct)))
+     (values
+      (write-to-string s :level 0   :readably nil)
+      (write-to-string s :level 1   :readably nil)
+      (write-to-string s :level nil :readably nil))))
+  "#S(PRINT-LEVEL-STRUCT)"
+  "#S(PRINT-LEVEL-STRUCT)"
+  "#S(PRINT-LEVEL-STRUCT)")
+
+(defstruct print-level-struct2 a b c)
+
+(deftest print-level.10
+  (with-standard-io-syntax
+   (let ((*package* (find-package "CL-TEST")))
+     (write-to-string (make-print-level-struct2)
+		      :level 0 :pretty nil :readably nil)))
+  "#")
+
+(deftest print-level.11
+  (with-standard-io-syntax
+   (let ((*package* (find-package "CL-TEST")))
+     (write-to-string (make-print-level-struct2)
+		      :level 0 :pretty t :readably nil)))
+  "#")
+
+(deftest print-level.12
+  (with-standard-io-syntax
+   (let ((*print-level* (1+ most-positive-fixnum)))
+     (write-to-string '((1 2) (3 4)) :pretty nil :readably nil)))
+  "((1 2) (3 4))")
diff --git a/ansi-tests/print-lines.lsp b/ansi-tests/print-lines.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..211e95bf03a9382053efbfdff385fee4c637baa6
--- /dev/null
+++ b/ansi-tests/print-lines.lsp
@@ -0,0 +1,42 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Tue Jul 27 09:32:46 2004
+;;;; Contains: Tests involving PRINT-LINES
+
+(in-package :cl-test)
+
+(compile-and-load "printer-aux.lsp")
+
+(deftest print-lines.1
+  *print-lines*
+  nil)
+
+(deftest print-lines.2
+  (with-standard-io-syntax
+   (let ((*print-lines* 1)
+	 (*print-readably* nil)
+	 (*print-miser-width* nil)
+	 (*print-pprint-dispatch* (copy-pprint-dispatch)))
+     (set-pprint-dispatch '(cons (eql 1) t) 'pprint-fill)
+     (apply
+      #'values
+      (loop for i from 1 to 10
+	    collect
+	    (let ((*print-right-margin* i))
+	      (subseq
+	       (with-output-to-string
+		 (*standard-output*)
+		 (terpri)
+		 (pprint '(1 2 3 4 5 6 7 8 9)))
+	       2))))))
+  "(1 ..)"
+  "(1 ..)"
+  "(1 ..)"
+  "(1 ..)"
+  "(1 ..)"
+  "(1 ..)"
+  "(1 ..)"
+  "(1 2 ..)"
+  "(1 2 ..)"
+  "(1 2 3 ..)")
+
diff --git a/ansi-tests/print.lsp b/ansi-tests/print.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..55121b842a39c4b4ae204bd1063a255398cb5e87
--- /dev/null
+++ b/ansi-tests/print.lsp
@@ -0,0 +1,48 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Sun Jul 25 11:41:16 2004
+;;;; Contains: Tests of PRINT
+
+(in-package :cl-test)
+
+(compile-and-load "printer-aux.lsp")
+
+;;; This function is mostly tested elsewhere
+
+(deftest print.1
+  (random-print-test 1000)
+  nil)
+
+(deftest print.2
+  (with-standard-io-syntax
+   (with-output-to-string
+     (os)
+     (with-input-from-string
+      (is "")
+      (with-open-stream (*terminal-io* (make-two-way-stream is os))
+			(print 2 t)))))
+  "
+2 ")
+
+(deftest print.3
+  (with-standard-io-syntax
+   (with-output-to-string
+     (*standard-output*)
+     (print 3 nil)))
+  "
+3 ")
+
+;;; Error tests
+
+(deftest print.error.1
+  (signals-error
+   (with-output-to-string (*standard-output*) (print))
+   program-error)
+  t)
+
+(deftest print.error.2
+  (signals-error
+   (with-output-to-string (s) (print nil s nil))
+   program-error)
+  t)
+
diff --git a/ansi-tests/printer-aux.lsp b/ansi-tests/printer-aux.lsp
index 821c0a24bb0e9c106e6beb8580d65d62c11cff2e..e105ddec1061bb5ebbca9a424ed6b3ef6c193963 100644
--- a/ansi-tests/printer-aux.lsp
+++ b/ansi-tests/printer-aux.lsp
@@ -5,14 +5,18 @@
 
 (in-package :cl-test)
 
+(eval-when (load eval compile) (compile-and-load "random-aux.lsp"))
+
 (defmacro def-print-test (name form result &rest bindings)
   `(deftest ,name
-     (equalpt
-      (my-with-standard-io-syntax
-	(let ((*print-readably* nil))
-	  (let ,bindings
-	    (with-output-to-string (*standard-output*) (prin1 ,form)))))
-      ,result)
+     (if (equalpt
+	  (my-with-standard-io-syntax
+	   (let ((*print-readably* nil))
+	     (let ,bindings
+	       (with-output-to-string (*standard-output*) (prin1 ,form)))))
+	  ,result)
+	 t
+       ,result)
      t))
 
 (defmacro def-pprint-test
@@ -112,7 +116,7 @@
 	   (with-standard-io-syntax (format *debug-io* "~%~A~%" params)))
 	 (finish-output *debug-io*))
        
-       (setf (readtable-case *readtable*) readcase)
+       #-gcl (setf (readtable-case *readtable*) readcase)
        (let* ((str (handler-case
 		    (with-output-to-string (s) (write obj :stream s))
 		    (print-not-readable
@@ -218,3 +222,155 @@
      (1 (- (random 2001) 1000))
      (1 (random 1000.0))
      )))
+
+;;; Random printing test for WRITE and related functions
+
+(defun funcall-with-print-bindings
+  (fun &key
+       ((:array *print-array*)                     *print-array*)
+       ((:base *print-base*)                       *print-base*)
+       ((:case *print-case*)                       *print-case*)
+       ((:circle *print-circle*)                   *print-circle*)
+       ((:escape *print-escape*)                   *print-escape*)
+       ((:gensym *print-gensym*)                   *print-gensym*)
+       ((:length *print-length*)                   *print-length*)
+       ((:level *print-level*)                     *print-level*)
+       ((:lines *print-lines*)                     *print-lines*)
+       ((:miser-width *print-miser-width*)         *print-miser-width*)
+       ((:pprint-dispatch *print-pprint-dispatch*) *print-pprint-dispatch*)
+       ((:pretty *print-pretty*)                   *print-pretty*)
+       ((:radix *print-radix*)                     *print-radix*)
+       ((:readably *print-readably*)               *print-readably*)
+       ((:right-margin *print-right-margin*)       *print-right-margin*)
+       ((:stream *standard-output*)                *standard-output*))
+  (funcall fun))
+  
+(defun output-test
+  (obj &key
+       (fun #'write)
+       ((:array *print-array*)                     *print-array*)
+       ((:base *print-base*)                       *print-base*)
+       ((:case *print-case*)                       *print-case*)
+       ((:circle *print-circle*)                   *print-circle*)
+       ((:escape *print-escape*)                   *print-escape*)
+       ((:gensym *print-gensym*)                   *print-gensym*)
+       ((:length *print-length*)                   *print-length*)
+       ((:level *print-level*)                     *print-level*)
+       ((:lines *print-lines*)                     *print-lines*)
+       ((:miser-width *print-miser-width*)         *print-miser-width*)
+       ((:pprint-dispatch *print-pprint-dispatch*) *print-pprint-dispatch*)
+       ((:pretty *print-pretty*)                   *print-pretty*)
+       ((:radix *print-radix*)                     *print-radix*)
+       ((:readably *print-readably*)               *print-readably*)
+       ((:right-margin *print-right-margin*)       *print-right-margin*)
+       ((:stream *standard-output*)                *standard-output*))
+  (let ((results (multiple-value-list (apply fun obj))))
+    (assert (= (length results) 1))
+    (assert (eql (car results) obj))
+    obj))
+
+(defun make-random-key-param (name)
+  (rcase (1 nil)
+	 (1 `(,name nil))
+	 (1 `(,name t))))
+
+(defun make-random-key-integer-or-nil-param (name bound)
+  (rcase (1 nil)
+	 (1 `(,name nil))
+	 (1 `(,name ,(random bound)))))
+
+(defun make-random-write-args ()
+  (let* ((arg-lists `(,@(mapcar #'make-random-key-param
+					    '(:array :circle :escape :gensym :pretty :radix :readably))
+				    ,(rcase (1 nil)
+					    (1 `(:base ,(+ 2 (random 35)))))
+				    ,(and (coin)
+					  `(:case ,(random-from-seq #(:upcase :downcase :capitalize))))
+				    ,@(mapcar #'make-random-key-integer-or-nil-param
+					      '(:length :level :lines :miser-width :right-margin)
+					      '(100 20 50 200 200)))))
+		(reduce #'append (random-permute arg-lists) :from-end t)))
+
+(defmacro def-random-write-test-fun (name write-args test-fn
+					  &key
+					  (prefix "")
+					  (suffix ""))
+  `(defun ,name (n)
+     (loop
+      for args = (make-random-write-args)
+      for package = (find-package (random-from-seq #("CL-TEST" "CL-USER" "KEYWORD")))
+      for obj = (random-thing (random 1))
+      for s1 = (let ((*package* package))
+		 (with-output-to-string (s) (apply #'write obj :stream s ,@write-args args)))
+      for s2 = (let ((*package* package))
+		 (with-output-to-string
+		   (*standard-output*)
+		   (apply #'output-test obj :fun ,test-fn args)))
+      repeat n
+      unless (string= (concatenate 'string ,prefix s1 ,suffix) s2)
+      collect (list obj s1 s2))))
+
+(def-random-write-test-fun random-write-test nil #'write)
+(def-random-write-test-fun random-prin1-test (:escape t) #'prin1)
+(def-random-write-test-fun random-princ-test (:escape nil :readably nil) #'princ)
+(def-random-write-test-fun random-print-test (:escape t) #'print :prefix (string #\Newline) :suffix " ")
+(def-random-write-test-fun random-pprint-test (:escape t :pretty t)
+  #'(lambda (obj) (assert (null (multiple-value-list (pprint obj)))) obj)
+  :prefix (string #\Newline))
+
+(defmacro def-random-write-to-string-test-fun (name write-args test-fn
+					  &key
+					  (prefix "")
+					  (suffix ""))
+  `(defun ,name (n)
+     (loop
+      for args = (make-random-write-args)
+      for package = (find-package (random-from-seq #("CL-TEST" "CL-USER" "KEYWORD")))
+      for obj = (random-thing (random 1))
+      for s1 = (let ((*package* package))
+		 (with-output-to-string (s) (apply #'write obj :stream s ,@write-args args)))
+      for s2 = (let ((*package* package))
+		 (apply ,test-fn obj args))
+      repeat n
+      unless (string= (concatenate 'string ,prefix s1 ,suffix) s2)
+      collect (list obj s1 s2))))
+
+(def-random-write-to-string-test-fun random-write-to-string-test nil #'write-to-string)
+(def-random-write-to-string-test-fun random-prin1-to-string-test (:escape t)
+  #'(lambda (obj &rest args)
+      (apply #'funcall-with-print-bindings #'(lambda () (prin1-to-string obj)) args)))
+(def-random-write-to-string-test-fun random-princ-to-string-test (:escape nil :readably nil)
+  #'(lambda (obj &rest args)
+      (apply #'funcall-with-print-bindings #'(lambda () (princ-to-string obj)) args)))
+
+;;; Routines for testing floating point printing
+
+(defun decode-fixed-decimal-string (s)
+  "Return a rational equal to the number represented by a decimal floating
+   (without exponent).  Trim off leading/trailing spaces."
+
+  (setq s (string-trim " " s))
+  (assert (> (length s) 0))
+  (let (neg)
+    (when (eql (elt s 0) #\-)
+      (setq s (subseq s 1))
+      (setq neg t))
+    ;; Check it's of the form {digits}.{digits}
+    (let ((dot-pos (position #\. s)))
+      (assert dot-pos)
+      (let ((prefix (subseq s 0 dot-pos))
+	    (suffix (subseq s (1+ dot-pos))))
+	(assert (every #'digit-char-p prefix))
+	(assert (every #'digit-char-p suffix))
+	(let* ((prefix-len (length prefix))
+	       (prefix-integer (if (eql prefix-len 0)
+				   0
+				 (parse-integer prefix)))
+	       (suffix-len (length suffix))
+	       (suffix-integer (if (eql suffix-len 0)
+				   0
+				 (parse-integer suffix)))
+	       (magnitude (+ prefix-integer
+			     (* suffix-integer (expt 1/10 suffix-len)))))
+	  (if neg (- magnitude) magnitude))))))
+
diff --git a/ansi-tests/random-aux.lsp b/ansi-tests/random-aux.lsp
index 56895a90a2d55235d4ddb2147a83f07999e9080d..7d3d970e2a20525e38811b47259d7cd96ce0367b 100644
--- a/ansi-tests/random-aux.lsp
+++ b/ansi-tests/random-aux.lsp
@@ -61,6 +61,36 @@
   (+ (random (1+ (- most-positive-fixnum most-negative-fixnum)))
      most-negative-fixnum))
 
+(defun random-thing (n)
+  (if (<= n 1)
+      (random-leaf)
+    (rcase
+     (1 (apply #'cons (mapcar #'random-thing (random-partition (1- n) 2))))
+     (1 (apply #'vector (mapcar #'random-thing
+				(random-partition (1- n) (max 10 (1- n))))))
+     )))
+
+(declaim (special +standard-chars+ *cl-symbols-vector*))
+
+(defun make-random-string (n)
+  (make-array n
+	      :initial-contents
+	      (loop repeat n collect
+		    (random-from-seq +standard-chars+))
+	      :element-type (random-from-seq
+			     #(character standard-char base-char))))
+
+(defun random-leaf ()
+  (rcase
+   (1 (let ((k (ash 1 (1+ (random 40)))))
+	(random-from-interval k (- k))))
+   (1 (random-from-seq +standard-chars+))
+   (1 (random-real))
+   (1 (make-random-string (random 20)))
+   (1 (gensym))
+   (1 (make-symbol (make-random-string (random 20))))
+   (1 (random-from-seq *cl-symbols-vector*))))
+
 (defun random-from-interval (upper &optional (lower (- upper)))
   (+ (random (- upper lower)) lower))
 
diff --git a/ansi-tests/random-int-form.lsp b/ansi-tests/random-int-form.lsp
index 23500bece16657052c42bced706298686db80948..5475da0290e34013311afb3acefa818cbf8d6c47 100644
--- a/ansi-tests/random-int-form.lsp
+++ b/ansi-tests/random-int-form.lsp
@@ -317,7 +317,7 @@
     (rcase
 
      ;; flet call
-     #-(or armedbear)
+     ;; #-(or armedbear)
      (30 ;; 5
       (make-random-integer-flet-call-form size))
 
@@ -549,7 +549,7 @@
 	;; No blocks -- try again
 	(make-random-integer-form size)))
 
-     #-(or armedbear)
+     ; #-(or armedbear)
      (20
       (make-random-flet-form size))
 
diff --git a/ansi-tests/roman-numerals.lsp b/ansi-tests/roman-numerals.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..28300abe3da98e32cd5569d001b6916057d4a965
--- /dev/null
+++ b/ansi-tests/roman-numerals.lsp
@@ -0,0 +1,484 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Thu Jul 29 08:44:15 2004
+;;;; Contains: The roman numbers from 1 to 3999
+
+(in-package :cl-test)
+
+(defparameter *roman-numerals*
+  '("I" "II" "III" "IV" "V" "VI" "VII" "VIII" "IX" "X" "XI" "XII" "XIII" "XIV" "XV" "XVI" "XVII"
+    "XVIII" "XIX" "XX" "XXI" "XXII" "XXIII" "XXIV" "XXV" "XXVI" "XXVII" "XXVIII" "XXIX" "XXX"
+    "XXXI" "XXXII" "XXXIII" "XXXIV" "XXXV" "XXXVI" "XXXVII" "XXXVIII" "XXXIX" "XL" "XLI" "XLII"
+    "XLIII" "XLIV" "XLV" "XLVI" "XLVII" "XLVIII" "XLIX" "L" "LI" "LII" "LIII" "LIV" "LV" "LVI"
+    "LVII" "LVIII" "LIX" "LX" "LXI" "LXII" "LXIII" "LXIV" "LXV" "LXVI" "LXVII" "LXVIII" "LXIX"
+    "LXX" "LXXI" "LXXII" "LXXIII" "LXXIV" "LXXV" "LXXVI" "LXXVII" "LXXVIII" "LXXIX" "LXXX"
+    "LXXXI" "LXXXII" "LXXXIII" "LXXXIV" "LXXXV" "LXXXVI" "LXXXVII" "LXXXVIII" "LXXXIX" "XC"
+    "XCI" "XCII" "XCIII" "XCIV" "XCV" "XCVI" "XCVII" "XCVIII" "XCIX" "C" "CI" "CII" "CIII" "CIV"
+    "CV" "CVI" "CVII" "CVIII" "CIX" "CX" "CXI" "CXII" "CXIII" "CXIV" "CXV" "CXVI" "CXVII"
+    "CXVIII" "CXIX" "CXX" "CXXI" "CXXII" "CXXIII" "CXXIV" "CXXV" "CXXVI" "CXXVII" "CXXVIII"
+    "CXXIX" "CXXX" "CXXXI" "CXXXII" "CXXXIII" "CXXXIV" "CXXXV" "CXXXVI" "CXXXVII" "CXXXVIII"
+    "CXXXIX" "CXL" "CXLI" "CXLII" "CXLIII" "CXLIV" "CXLV" "CXLVI" "CXLVII" "CXLVIII" "CXLIX"
+    "CL" "CLI" "CLII" "CLIII" "CLIV" "CLV" "CLVI" "CLVII" "CLVIII" "CLIX" "CLX" "CLXI" "CLXII"
+    "CLXIII" "CLXIV" "CLXV" "CLXVI" "CLXVII" "CLXVIII" "CLXIX" "CLXX" "CLXXI" "CLXXII" "CLXXIII"
+    "CLXXIV" "CLXXV" "CLXXVI" "CLXXVII" "CLXXVIII" "CLXXIX" "CLXXX" "CLXXXI" "CLXXXII"
+    "CLXXXIII" "CLXXXIV" "CLXXXV" "CLXXXVI" "CLXXXVII" "CLXXXVIII" "CLXXXIX" "CXC" "CXCI"
+    "CXCII" "CXCIII" "CXCIV" "CXCV" "CXCVI" "CXCVII" "CXCVIII" "CXCIX" "CC" "CCI" "CCII" "CCIII"
+    "CCIV" "CCV" "CCVI" "CCVII" "CCVIII" "CCIX" "CCX" "CCXI" "CCXII" "CCXIII" "CCXIV" "CCXV"
+    "CCXVI" "CCXVII" "CCXVIII" "CCXIX" "CCXX" "CCXXI" "CCXXII" "CCXXIII" "CCXXIV" "CCXXV"
+    "CCXXVI" "CCXXVII" "CCXXVIII" "CCXXIX" "CCXXX" "CCXXXI" "CCXXXII" "CCXXXIII" "CCXXXIV"
+    "CCXXXV" "CCXXXVI" "CCXXXVII" "CCXXXVIII" "CCXXXIX" "CCXL" "CCXLI" "CCXLII" "CCXLIII"
+    "CCXLIV" "CCXLV" "CCXLVI" "CCXLVII" "CCXLVIII" "CCXLIX" "CCL" "CCLI" "CCLII" "CCLIII"
+    "CCLIV" "CCLV" "CCLVI" "CCLVII" "CCLVIII" "CCLIX" "CCLX" "CCLXI" "CCLXII" "CCLXIII" "CCLXIV"
+    "CCLXV" "CCLXVI" "CCLXVII" "CCLXVIII" "CCLXIX" "CCLXX" "CCLXXI" "CCLXXII" "CCLXXIII"
+    "CCLXXIV" "CCLXXV" "CCLXXVI" "CCLXXVII" "CCLXXVIII" "CCLXXIX" "CCLXXX" "CCLXXXI" "CCLXXXII"
+    "CCLXXXIII" "CCLXXXIV" "CCLXXXV" "CCLXXXVI" "CCLXXXVII" "CCLXXXVIII" "CCLXXXIX" "CCXC"
+    "CCXCI" "CCXCII" "CCXCIII" "CCXCIV" "CCXCV" "CCXCVI" "CCXCVII" "CCXCVIII" "CCXCIX" "CCC"
+    "CCCI" "CCCII" "CCCIII" "CCCIV" "CCCV" "CCCVI" "CCCVII" "CCCVIII" "CCCIX" "CCCX" "CCCXI"
+    "CCCXII" "CCCXIII" "CCCXIV" "CCCXV" "CCCXVI" "CCCXVII" "CCCXVIII" "CCCXIX" "CCCXX" "CCCXXI"
+    "CCCXXII" "CCCXXIII" "CCCXXIV" "CCCXXV" "CCCXXVI" "CCCXXVII" "CCCXXVIII" "CCCXXIX" "CCCXXX"
+    "CCCXXXI" "CCCXXXII" "CCCXXXIII" "CCCXXXIV" "CCCXXXV" "CCCXXXVI" "CCCXXXVII" "CCCXXXVIII"
+    "CCCXXXIX" "CCCXL" "CCCXLI" "CCCXLII" "CCCXLIII" "CCCXLIV" "CCCXLV" "CCCXLVI" "CCCXLVII"
+    "CCCXLVIII" "CCCXLIX" "CCCL" "CCCLI" "CCCLII" "CCCLIII" "CCCLIV" "CCCLV" "CCCLVI" "CCCLVII"
+    "CCCLVIII" "CCCLIX" "CCCLX" "CCCLXI" "CCCLXII" "CCCLXIII" "CCCLXIV" "CCCLXV" "CCCLXVI"
+    "CCCLXVII" "CCCLXVIII" "CCCLXIX" "CCCLXX" "CCCLXXI" "CCCLXXII" "CCCLXXIII" "CCCLXXIV"
+    "CCCLXXV" "CCCLXXVI" "CCCLXXVII" "CCCLXXVIII" "CCCLXXIX" "CCCLXXX" "CCCLXXXI" "CCCLXXXII"
+    "CCCLXXXIII" "CCCLXXXIV" "CCCLXXXV" "CCCLXXXVI" "CCCLXXXVII" "CCCLXXXVIII" "CCCLXXXIX"
+    "CCCXC" "CCCXCI" "CCCXCII" "CCCXCIII" "CCCXCIV" "CCCXCV" "CCCXCVI" "CCCXCVII" "CCCXCVIII"
+    "CCCXCIX" "CD" "CDI" "CDII" "CDIII" "CDIV" "CDV" "CDVI" "CDVII" "CDVIII" "CDIX" "CDX" "CDXI"
+    "CDXII" "CDXIII" "CDXIV" "CDXV" "CDXVI" "CDXVII" "CDXVIII" "CDXIX" "CDXX" "CDXXI" "CDXXII"
+    "CDXXIII" "CDXXIV" "CDXXV" "CDXXVI" "CDXXVII" "CDXXVIII" "CDXXIX" "CDXXX" "CDXXXI" "CDXXXII"
+    "CDXXXIII" "CDXXXIV" "CDXXXV" "CDXXXVI" "CDXXXVII" "CDXXXVIII" "CDXXXIX" "CDXL" "CDXLI"
+    "CDXLII" "CDXLIII" "CDXLIV" "CDXLV" "CDXLVI" "CDXLVII" "CDXLVIII" "CDXLIX" "CDL" "CDLI"
+    "CDLII" "CDLIII" "CDLIV" "CDLV" "CDLVI" "CDLVII" "CDLVIII" "CDLIX" "CDLX" "CDLXI" "CDLXII"
+    "CDLXIII" "CDLXIV" "CDLXV" "CDLXVI" "CDLXVII" "CDLXVIII" "CDLXIX" "CDLXX" "CDLXXI" "CDLXXII"
+    "CDLXXIII" "CDLXXIV" "CDLXXV" "CDLXXVI" "CDLXXVII" "CDLXXVIII" "CDLXXIX" "CDLXXX" "CDLXXXI"
+    "CDLXXXII" "CDLXXXIII" "CDLXXXIV" "CDLXXXV" "CDLXXXVI" "CDLXXXVII" "CDLXXXVIII" "CDLXXXIX"
+    "CDXC" "CDXCI" "CDXCII" "CDXCIII" "CDXCIV" "CDXCV" "CDXCVI" "CDXCVII" "CDXCVIII" "CDXCIX"
+    "D" "DI" "DII" "DIII" "DIV" "DV" "DVI" "DVII" "DVIII" "DIX" "DX" "DXI" "DXII" "DXIII" "DXIV"
+    "DXV" "DXVI" "DXVII" "DXVIII" "DXIX" "DXX" "DXXI" "DXXII" "DXXIII" "DXXIV" "DXXV" "DXXVI"
+    "DXXVII" "DXXVIII" "DXXIX" "DXXX" "DXXXI" "DXXXII" "DXXXIII" "DXXXIV" "DXXXV" "DXXXVI"
+    "DXXXVII" "DXXXVIII" "DXXXIX" "DXL" "DXLI" "DXLII" "DXLIII" "DXLIV" "DXLV" "DXLVI" "DXLVII"
+    "DXLVIII" "DXLIX" "DL" "DLI" "DLII" "DLIII" "DLIV" "DLV" "DLVI" "DLVII" "DLVIII" "DLIX"
+    "DLX" "DLXI" "DLXII" "DLXIII" "DLXIV" "DLXV" "DLXVI" "DLXVII" "DLXVIII" "DLXIX" "DLXX"
+    "DLXXI" "DLXXII" "DLXXIII" "DLXXIV" "DLXXV" "DLXXVI" "DLXXVII" "DLXXVIII" "DLXXIX" "DLXXX"
+    "DLXXXI" "DLXXXII" "DLXXXIII" "DLXXXIV" "DLXXXV" "DLXXXVI" "DLXXXVII" "DLXXXVIII" "DLXXXIX"
+    "DXC" "DXCI" "DXCII" "DXCIII" "DXCIV" "DXCV" "DXCVI" "DXCVII" "DXCVIII" "DXCIX" "DC" "DCI"
+    "DCII" "DCIII" "DCIV" "DCV" "DCVI" "DCVII" "DCVIII" "DCIX" "DCX" "DCXI" "DCXII" "DCXIII"
+    "DCXIV" "DCXV" "DCXVI" "DCXVII" "DCXVIII" "DCXIX" "DCXX" "DCXXI" "DCXXII" "DCXXIII" "DCXXIV"
+    "DCXXV" "DCXXVI" "DCXXVII" "DCXXVIII" "DCXXIX" "DCXXX" "DCXXXI" "DCXXXII" "DCXXXIII"
+    "DCXXXIV" "DCXXXV" "DCXXXVI" "DCXXXVII" "DCXXXVIII" "DCXXXIX" "DCXL" "DCXLI" "DCXLII"
+    "DCXLIII" "DCXLIV" "DCXLV" "DCXLVI" "DCXLVII" "DCXLVIII" "DCXLIX" "DCL" "DCLI" "DCLII"
+    "DCLIII" "DCLIV" "DCLV" "DCLVI" "DCLVII" "DCLVIII" "DCLIX" "DCLX" "DCLXI" "DCLXII" "DCLXIII"
+    "DCLXIV" "DCLXV" "DCLXVI" "DCLXVII" "DCLXVIII" "DCLXIX" "DCLXX" "DCLXXI" "DCLXXII"
+    "DCLXXIII" "DCLXXIV" "DCLXXV" "DCLXXVI" "DCLXXVII" "DCLXXVIII" "DCLXXIX" "DCLXXX" "DCLXXXI"
+    "DCLXXXII" "DCLXXXIII" "DCLXXXIV" "DCLXXXV" "DCLXXXVI" "DCLXXXVII" "DCLXXXVIII" "DCLXXXIX"
+    "DCXC" "DCXCI" "DCXCII" "DCXCIII" "DCXCIV" "DCXCV" "DCXCVI" "DCXCVII" "DCXCVIII" "DCXCIX"
+    "DCC" "DCCI" "DCCII" "DCCIII" "DCCIV" "DCCV" "DCCVI" "DCCVII" "DCCVIII" "DCCIX" "DCCX"
+    "DCCXI" "DCCXII" "DCCXIII" "DCCXIV" "DCCXV" "DCCXVI" "DCCXVII" "DCCXVIII" "DCCXIX" "DCCXX"
+    "DCCXXI" "DCCXXII" "DCCXXIII" "DCCXXIV" "DCCXXV" "DCCXXVI" "DCCXXVII" "DCCXXVIII" "DCCXXIX"
+    "DCCXXX" "DCCXXXI" "DCCXXXII" "DCCXXXIII" "DCCXXXIV" "DCCXXXV" "DCCXXXVI" "DCCXXXVII"
+    "DCCXXXVIII" "DCCXXXIX" "DCCXL" "DCCXLI" "DCCXLII" "DCCXLIII" "DCCXLIV" "DCCXLV" "DCCXLVI"
+    "DCCXLVII" "DCCXLVIII" "DCCXLIX" "DCCL" "DCCLI" "DCCLII" "DCCLIII" "DCCLIV" "DCCLV" "DCCLVI"
+    "DCCLVII" "DCCLVIII" "DCCLIX" "DCCLX" "DCCLXI" "DCCLXII" "DCCLXIII" "DCCLXIV" "DCCLXV"
+    "DCCLXVI" "DCCLXVII" "DCCLXVIII" "DCCLXIX" "DCCLXX" "DCCLXXI" "DCCLXXII" "DCCLXXIII"
+    "DCCLXXIV" "DCCLXXV" "DCCLXXVI" "DCCLXXVII" "DCCLXXVIII" "DCCLXXIX" "DCCLXXX" "DCCLXXXI"
+    "DCCLXXXII" "DCCLXXXIII" "DCCLXXXIV" "DCCLXXXV" "DCCLXXXVI" "DCCLXXXVII" "DCCLXXXVIII"
+    "DCCLXXXIX" "DCCXC" "DCCXCI" "DCCXCII" "DCCXCIII" "DCCXCIV" "DCCXCV" "DCCXCVI" "DCCXCVII"
+    "DCCXCVIII" "DCCXCIX" "DCCC" "DCCCI" "DCCCII" "DCCCIII" "DCCCIV" "DCCCV" "DCCCVI" "DCCCVII"
+    "DCCCVIII" "DCCCIX" "DCCCX" "DCCCXI" "DCCCXII" "DCCCXIII" "DCCCXIV" "DCCCXV" "DCCCXVI"
+    "DCCCXVII" "DCCCXVIII" "DCCCXIX" "DCCCXX" "DCCCXXI" "DCCCXXII" "DCCCXXIII" "DCCCXXIV"
+    "DCCCXXV" "DCCCXXVI" "DCCCXXVII" "DCCCXXVIII" "DCCCXXIX" "DCCCXXX" "DCCCXXXI" "DCCCXXXII"
+    "DCCCXXXIII" "DCCCXXXIV" "DCCCXXXV" "DCCCXXXVI" "DCCCXXXVII" "DCCCXXXVIII" "DCCCXXXIX"
+    "DCCCXL" "DCCCXLI" "DCCCXLII" "DCCCXLIII" "DCCCXLIV" "DCCCXLV" "DCCCXLVI" "DCCCXLVII"
+    "DCCCXLVIII" "DCCCXLIX" "DCCCL" "DCCCLI" "DCCCLII" "DCCCLIII" "DCCCLIV" "DCCCLV" "DCCCLVI"
+    "DCCCLVII" "DCCCLVIII" "DCCCLIX" "DCCCLX" "DCCCLXI" "DCCCLXII" "DCCCLXIII" "DCCCLXIV"
+    "DCCCLXV" "DCCCLXVI" "DCCCLXVII" "DCCCLXVIII" "DCCCLXIX" "DCCCLXX" "DCCCLXXI" "DCCCLXXII"
+    "DCCCLXXIII" "DCCCLXXIV" "DCCCLXXV" "DCCCLXXVI" "DCCCLXXVII" "DCCCLXXVIII" "DCCCLXXIX"
+    "DCCCLXXX" "DCCCLXXXI" "DCCCLXXXII" "DCCCLXXXIII" "DCCCLXXXIV" "DCCCLXXXV" "DCCCLXXXVI"
+    "DCCCLXXXVII" "DCCCLXXXVIII" "DCCCLXXXIX" "DCCCXC" "DCCCXCI" "DCCCXCII" "DCCCXCIII"
+    "DCCCXCIV" "DCCCXCV" "DCCCXCVI" "DCCCXCVII" "DCCCXCVIII" "DCCCXCIX" "CM" "CMI" "CMII"
+    "CMIII" "CMIV" "CMV" "CMVI" "CMVII" "CMVIII" "CMIX" "CMX" "CMXI" "CMXII" "CMXIII" "CMXIV"
+    "CMXV" "CMXVI" "CMXVII" "CMXVIII" "CMXIX" "CMXX" "CMXXI" "CMXXII" "CMXXIII" "CMXXIV" "CMXXV"
+    "CMXXVI" "CMXXVII" "CMXXVIII" "CMXXIX" "CMXXX" "CMXXXI" "CMXXXII" "CMXXXIII" "CMXXXIV"
+    "CMXXXV" "CMXXXVI" "CMXXXVII" "CMXXXVIII" "CMXXXIX" "CMXL" "CMXLI" "CMXLII" "CMXLIII"
+    "CMXLIV" "CMXLV" "CMXLVI" "CMXLVII" "CMXLVIII" "CMXLIX" "CML" "CMLI" "CMLII" "CMLIII"
+    "CMLIV" "CMLV" "CMLVI" "CMLVII" "CMLVIII" "CMLIX" "CMLX" "CMLXI" "CMLXII" "CMLXIII" "CMLXIV"
+    "CMLXV" "CMLXVI" "CMLXVII" "CMLXVIII" "CMLXIX" "CMLXX" "CMLXXI" "CMLXXII" "CMLXXIII"
+    "CMLXXIV" "CMLXXV" "CMLXXVI" "CMLXXVII" "CMLXXVIII" "CMLXXIX" "CMLXXX" "CMLXXXI" "CMLXXXII"
+    "CMLXXXIII" "CMLXXXIV" "CMLXXXV" "CMLXXXVI" "CMLXXXVII" "CMLXXXVIII" "CMLXXXIX" "CMXC"
+    "CMXCI" "CMXCII" "CMXCIII" "CMXCIV" "CMXCV" "CMXCVI" "CMXCVII" "CMXCVIII" "CMXCIX" "M" "MI"
+    "MII" "MIII" "MIV" "MV" "MVI" "MVII" "MVIII" "MIX" "MX" "MXI" "MXII" "MXIII" "MXIV" "MXV"
+    "MXVI" "MXVII" "MXVIII" "MXIX" "MXX" "MXXI" "MXXII" "MXXIII" "MXXIV" "MXXV" "MXXVI" "MXXVII"
+    "MXXVIII" "MXXIX" "MXXX" "MXXXI" "MXXXII" "MXXXIII" "MXXXIV" "MXXXV" "MXXXVI" "MXXXVII"
+    "MXXXVIII" "MXXXIX" "MXL" "MXLI" "MXLII" "MXLIII" "MXLIV" "MXLV" "MXLVI" "MXLVII" "MXLVIII"
+    "MXLIX" "ML" "MLI" "MLII" "MLIII" "MLIV" "MLV" "MLVI" "MLVII" "MLVIII" "MLIX" "MLX" "MLXI"
+    "MLXII" "MLXIII" "MLXIV" "MLXV" "MLXVI" "MLXVII" "MLXVIII" "MLXIX" "MLXX" "MLXXI" "MLXXII"
+    "MLXXIII" "MLXXIV" "MLXXV" "MLXXVI" "MLXXVII" "MLXXVIII" "MLXXIX" "MLXXX" "MLXXXI" "MLXXXII"
+    "MLXXXIII" "MLXXXIV" "MLXXXV" "MLXXXVI" "MLXXXVII" "MLXXXVIII" "MLXXXIX" "MXC" "MXCI"
+    "MXCII" "MXCIII" "MXCIV" "MXCV" "MXCVI" "MXCVII" "MXCVIII" "MXCIX" "MC" "MCI" "MCII" "MCIII"
+    "MCIV" "MCV" "MCVI" "MCVII" "MCVIII" "MCIX" "MCX" "MCXI" "MCXII" "MCXIII" "MCXIV" "MCXV"
+    "MCXVI" "MCXVII" "MCXVIII" "MCXIX" "MCXX" "MCXXI" "MCXXII" "MCXXIII" "MCXXIV" "MCXXV"
+    "MCXXVI" "MCXXVII" "MCXXVIII" "MCXXIX" "MCXXX" "MCXXXI" "MCXXXII" "MCXXXIII" "MCXXXIV"
+    "MCXXXV" "MCXXXVI" "MCXXXVII" "MCXXXVIII" "MCXXXIX" "MCXL" "MCXLI" "MCXLII" "MCXLIII"
+    "MCXLIV" "MCXLV" "MCXLVI" "MCXLVII" "MCXLVIII" "MCXLIX" "MCL" "MCLI" "MCLII" "MCLIII"
+    "MCLIV" "MCLV" "MCLVI" "MCLVII" "MCLVIII" "MCLIX" "MCLX" "MCLXI" "MCLXII" "MCLXIII" "MCLXIV"
+    "MCLXV" "MCLXVI" "MCLXVII" "MCLXVIII" "MCLXIX" "MCLXX" "MCLXXI" "MCLXXII" "MCLXXIII"
+    "MCLXXIV" "MCLXXV" "MCLXXVI" "MCLXXVII" "MCLXXVIII" "MCLXXIX" "MCLXXX" "MCLXXXI" "MCLXXXII"
+    "MCLXXXIII" "MCLXXXIV" "MCLXXXV" "MCLXXXVI" "MCLXXXVII" "MCLXXXVIII" "MCLXXXIX" "MCXC"
+    "MCXCI" "MCXCII" "MCXCIII" "MCXCIV" "MCXCV" "MCXCVI" "MCXCVII" "MCXCVIII" "MCXCIX" "MCC"
+    "MCCI" "MCCII" "MCCIII" "MCCIV" "MCCV" "MCCVI" "MCCVII" "MCCVIII" "MCCIX" "MCCX" "MCCXI"
+    "MCCXII" "MCCXIII" "MCCXIV" "MCCXV" "MCCXVI" "MCCXVII" "MCCXVIII" "MCCXIX" "MCCXX" "MCCXXI"
+    "MCCXXII" "MCCXXIII" "MCCXXIV" "MCCXXV" "MCCXXVI" "MCCXXVII" "MCCXXVIII" "MCCXXIX" "MCCXXX"
+    "MCCXXXI" "MCCXXXII" "MCCXXXIII" "MCCXXXIV" "MCCXXXV" "MCCXXXVI" "MCCXXXVII" "MCCXXXVIII"
+    "MCCXXXIX" "MCCXL" "MCCXLI" "MCCXLII" "MCCXLIII" "MCCXLIV" "MCCXLV" "MCCXLVI" "MCCXLVII"
+    "MCCXLVIII" "MCCXLIX" "MCCL" "MCCLI" "MCCLII" "MCCLIII" "MCCLIV" "MCCLV" "MCCLVI" "MCCLVII"
+    "MCCLVIII" "MCCLIX" "MCCLX" "MCCLXI" "MCCLXII" "MCCLXIII" "MCCLXIV" "MCCLXV" "MCCLXVI"
+    "MCCLXVII" "MCCLXVIII" "MCCLXIX" "MCCLXX" "MCCLXXI" "MCCLXXII" "MCCLXXIII" "MCCLXXIV"
+    "MCCLXXV" "MCCLXXVI" "MCCLXXVII" "MCCLXXVIII" "MCCLXXIX" "MCCLXXX" "MCCLXXXI" "MCCLXXXII"
+    "MCCLXXXIII" "MCCLXXXIV" "MCCLXXXV" "MCCLXXXVI" "MCCLXXXVII" "MCCLXXXVIII" "MCCLXXXIX"
+    "MCCXC" "MCCXCI" "MCCXCII" "MCCXCIII" "MCCXCIV" "MCCXCV" "MCCXCVI" "MCCXCVII" "MCCXCVIII"
+    "MCCXCIX" "MCCC" "MCCCI" "MCCCII" "MCCCIII" "MCCCIV" "MCCCV" "MCCCVI" "MCCCVII" "MCCCVIII"
+    "MCCCIX" "MCCCX" "MCCCXI" "MCCCXII" "MCCCXIII" "MCCCXIV" "MCCCXV" "MCCCXVI" "MCCCXVII"
+    "MCCCXVIII" "MCCCXIX" "MCCCXX" "MCCCXXI" "MCCCXXII" "MCCCXXIII" "MCCCXXIV" "MCCCXXV"
+    "MCCCXXVI" "MCCCXXVII" "MCCCXXVIII" "MCCCXXIX" "MCCCXXX" "MCCCXXXI" "MCCCXXXII" "MCCCXXXIII"
+    "MCCCXXXIV" "MCCCXXXV" "MCCCXXXVI" "MCCCXXXVII" "MCCCXXXVIII" "MCCCXXXIX" "MCCCXL" "MCCCXLI"
+    "MCCCXLII" "MCCCXLIII" "MCCCXLIV" "MCCCXLV" "MCCCXLVI" "MCCCXLVII" "MCCCXLVIII" "MCCCXLIX"
+    "MCCCL" "MCCCLI" "MCCCLII" "MCCCLIII" "MCCCLIV" "MCCCLV" "MCCCLVI" "MCCCLVII" "MCCCLVIII"
+    "MCCCLIX" "MCCCLX" "MCCCLXI" "MCCCLXII" "MCCCLXIII" "MCCCLXIV" "MCCCLXV" "MCCCLXVI"
+    "MCCCLXVII" "MCCCLXVIII" "MCCCLXIX" "MCCCLXX" "MCCCLXXI" "MCCCLXXII" "MCCCLXXIII"
+    "MCCCLXXIV" "MCCCLXXV" "MCCCLXXVI" "MCCCLXXVII" "MCCCLXXVIII" "MCCCLXXIX" "MCCCLXXX"
+    "MCCCLXXXI" "MCCCLXXXII" "MCCCLXXXIII" "MCCCLXXXIV" "MCCCLXXXV" "MCCCLXXXVI" "MCCCLXXXVII"
+    "MCCCLXXXVIII" "MCCCLXXXIX" "MCCCXC" "MCCCXCI" "MCCCXCII" "MCCCXCIII" "MCCCXCIV" "MCCCXCV"
+    "MCCCXCVI" "MCCCXCVII" "MCCCXCVIII" "MCCCXCIX" "MCD" "MCDI" "MCDII" "MCDIII" "MCDIV" "MCDV"
+    "MCDVI" "MCDVII" "MCDVIII" "MCDIX" "MCDX" "MCDXI" "MCDXII" "MCDXIII" "MCDXIV" "MCDXV"
+    "MCDXVI" "MCDXVII" "MCDXVIII" "MCDXIX" "MCDXX" "MCDXXI" "MCDXXII" "MCDXXIII" "MCDXXIV"
+    "MCDXXV" "MCDXXVI" "MCDXXVII" "MCDXXVIII" "MCDXXIX" "MCDXXX" "MCDXXXI" "MCDXXXII"
+    "MCDXXXIII" "MCDXXXIV" "MCDXXXV" "MCDXXXVI" "MCDXXXVII" "MCDXXXVIII" "MCDXXXIX" "MCDXL"
+    "MCDXLI" "MCDXLII" "MCDXLIII" "MCDXLIV" "MCDXLV" "MCDXLVI" "MCDXLVII" "MCDXLVIII" "MCDXLIX"
+    "MCDL" "MCDLI" "MCDLII" "MCDLIII" "MCDLIV" "MCDLV" "MCDLVI" "MCDLVII" "MCDLVIII" "MCDLIX"
+    "MCDLX" "MCDLXI" "MCDLXII" "MCDLXIII" "MCDLXIV" "MCDLXV" "MCDLXVI" "MCDLXVII" "MCDLXVIII"
+    "MCDLXIX" "MCDLXX" "MCDLXXI" "MCDLXXII" "MCDLXXIII" "MCDLXXIV" "MCDLXXV" "MCDLXXVI"
+    "MCDLXXVII" "MCDLXXVIII" "MCDLXXIX" "MCDLXXX" "MCDLXXXI" "MCDLXXXII" "MCDLXXXIII"
+    "MCDLXXXIV" "MCDLXXXV" "MCDLXXXVI" "MCDLXXXVII" "MCDLXXXVIII" "MCDLXXXIX" "MCDXC" "MCDXCI"
+    "MCDXCII" "MCDXCIII" "MCDXCIV" "MCDXCV" "MCDXCVI" "MCDXCVII" "MCDXCVIII" "MCDXCIX" "MD"
+    "MDI" "MDII" "MDIII" "MDIV" "MDV" "MDVI" "MDVII" "MDVIII" "MDIX" "MDX" "MDXI" "MDXII"
+    "MDXIII" "MDXIV" "MDXV" "MDXVI" "MDXVII" "MDXVIII" "MDXIX" "MDXX" "MDXXI" "MDXXII" "MDXXIII"
+    "MDXXIV" "MDXXV" "MDXXVI" "MDXXVII" "MDXXVIII" "MDXXIX" "MDXXX" "MDXXXI" "MDXXXII"
+    "MDXXXIII" "MDXXXIV" "MDXXXV" "MDXXXVI" "MDXXXVII" "MDXXXVIII" "MDXXXIX" "MDXL" "MDXLI"
+    "MDXLII" "MDXLIII" "MDXLIV" "MDXLV" "MDXLVI" "MDXLVII" "MDXLVIII" "MDXLIX" "MDL" "MDLI"
+    "MDLII" "MDLIII" "MDLIV" "MDLV" "MDLVI" "MDLVII" "MDLVIII" "MDLIX" "MDLX" "MDLXI" "MDLXII"
+    "MDLXIII" "MDLXIV" "MDLXV" "MDLXVI" "MDLXVII" "MDLXVIII" "MDLXIX" "MDLXX" "MDLXXI" "MDLXXII"
+    "MDLXXIII" "MDLXXIV" "MDLXXV" "MDLXXVI" "MDLXXVII" "MDLXXVIII" "MDLXXIX" "MDLXXX" "MDLXXXI"
+    "MDLXXXII" "MDLXXXIII" "MDLXXXIV" "MDLXXXV" "MDLXXXVI" "MDLXXXVII" "MDLXXXVIII" "MDLXXXIX"
+    "MDXC" "MDXCI" "MDXCII" "MDXCIII" "MDXCIV" "MDXCV" "MDXCVI" "MDXCVII" "MDXCVIII" "MDXCIX"
+    "MDC" "MDCI" "MDCII" "MDCIII" "MDCIV" "MDCV" "MDCVI" "MDCVII" "MDCVIII" "MDCIX" "MDCX"
+    "MDCXI" "MDCXII" "MDCXIII" "MDCXIV" "MDCXV" "MDCXVI" "MDCXVII" "MDCXVIII" "MDCXIX" "MDCXX"
+    "MDCXXI" "MDCXXII" "MDCXXIII" "MDCXXIV" "MDCXXV" "MDCXXVI" "MDCXXVII" "MDCXXVIII" "MDCXXIX"
+    "MDCXXX" "MDCXXXI" "MDCXXXII" "MDCXXXIII" "MDCXXXIV" "MDCXXXV" "MDCXXXVI" "MDCXXXVII"
+    "MDCXXXVIII" "MDCXXXIX" "MDCXL" "MDCXLI" "MDCXLII" "MDCXLIII" "MDCXLIV" "MDCXLV" "MDCXLVI"
+    "MDCXLVII" "MDCXLVIII" "MDCXLIX" "MDCL" "MDCLI" "MDCLII" "MDCLIII" "MDCLIV" "MDCLV" "MDCLVI"
+    "MDCLVII" "MDCLVIII" "MDCLIX" "MDCLX" "MDCLXI" "MDCLXII" "MDCLXIII" "MDCLXIV" "MDCLXV"
+    "MDCLXVI" "MDCLXVII" "MDCLXVIII" "MDCLXIX" "MDCLXX" "MDCLXXI" "MDCLXXII" "MDCLXXIII"
+    "MDCLXXIV" "MDCLXXV" "MDCLXXVI" "MDCLXXVII" "MDCLXXVIII" "MDCLXXIX" "MDCLXXX" "MDCLXXXI"
+    "MDCLXXXII" "MDCLXXXIII" "MDCLXXXIV" "MDCLXXXV" "MDCLXXXVI" "MDCLXXXVII" "MDCLXXXVIII"
+    "MDCLXXXIX" "MDCXC" "MDCXCI" "MDCXCII" "MDCXCIII" "MDCXCIV" "MDCXCV" "MDCXCVI" "MDCXCVII"
+    "MDCXCVIII" "MDCXCIX" "MDCC" "MDCCI" "MDCCII" "MDCCIII" "MDCCIV" "MDCCV" "MDCCVI" "MDCCVII"
+    "MDCCVIII" "MDCCIX" "MDCCX" "MDCCXI" "MDCCXII" "MDCCXIII" "MDCCXIV" "MDCCXV" "MDCCXVI"
+    "MDCCXVII" "MDCCXVIII" "MDCCXIX" "MDCCXX" "MDCCXXI" "MDCCXXII" "MDCCXXIII" "MDCCXXIV"
+    "MDCCXXV" "MDCCXXVI" "MDCCXXVII" "MDCCXXVIII" "MDCCXXIX" "MDCCXXX" "MDCCXXXI" "MDCCXXXII"
+    "MDCCXXXIII" "MDCCXXXIV" "MDCCXXXV" "MDCCXXXVI" "MDCCXXXVII" "MDCCXXXVIII" "MDCCXXXIX"
+    "MDCCXL" "MDCCXLI" "MDCCXLII" "MDCCXLIII" "MDCCXLIV" "MDCCXLV" "MDCCXLVI" "MDCCXLVII"
+    "MDCCXLVIII" "MDCCXLIX" "MDCCL" "MDCCLI" "MDCCLII" "MDCCLIII" "MDCCLIV" "MDCCLV" "MDCCLVI"
+    "MDCCLVII" "MDCCLVIII" "MDCCLIX" "MDCCLX" "MDCCLXI" "MDCCLXII" "MDCCLXIII" "MDCCLXIV"
+    "MDCCLXV" "MDCCLXVI" "MDCCLXVII" "MDCCLXVIII" "MDCCLXIX" "MDCCLXX" "MDCCLXXI" "MDCCLXXII"
+    "MDCCLXXIII" "MDCCLXXIV" "MDCCLXXV" "MDCCLXXVI" "MDCCLXXVII" "MDCCLXXVIII" "MDCCLXXIX"
+    "MDCCLXXX" "MDCCLXXXI" "MDCCLXXXII" "MDCCLXXXIII" "MDCCLXXXIV" "MDCCLXXXV" "MDCCLXXXVI"
+    "MDCCLXXXVII" "MDCCLXXXVIII" "MDCCLXXXIX" "MDCCXC" "MDCCXCI" "MDCCXCII" "MDCCXCIII"
+    "MDCCXCIV" "MDCCXCV" "MDCCXCVI" "MDCCXCVII" "MDCCXCVIII" "MDCCXCIX" "MDCCC" "MDCCCI"
+    "MDCCCII" "MDCCCIII" "MDCCCIV" "MDCCCV" "MDCCCVI" "MDCCCVII" "MDCCCVIII" "MDCCCIX" "MDCCCX"
+    "MDCCCXI" "MDCCCXII" "MDCCCXIII" "MDCCCXIV" "MDCCCXV" "MDCCCXVI" "MDCCCXVII" "MDCCCXVIII"
+    "MDCCCXIX" "MDCCCXX" "MDCCCXXI" "MDCCCXXII" "MDCCCXXIII" "MDCCCXXIV" "MDCCCXXV" "MDCCCXXVI"
+    "MDCCCXXVII" "MDCCCXXVIII" "MDCCCXXIX" "MDCCCXXX" "MDCCCXXXI" "MDCCCXXXII" "MDCCCXXXIII"
+    "MDCCCXXXIV" "MDCCCXXXV" "MDCCCXXXVI" "MDCCCXXXVII" "MDCCCXXXVIII" "MDCCCXXXIX" "MDCCCXL"
+    "MDCCCXLI" "MDCCCXLII" "MDCCCXLIII" "MDCCCXLIV" "MDCCCXLV" "MDCCCXLVI" "MDCCCXLVII"
+    "MDCCCXLVIII" "MDCCCXLIX" "MDCCCL" "MDCCCLI" "MDCCCLII" "MDCCCLIII" "MDCCCLIV" "MDCCCLV"
+    "MDCCCLVI" "MDCCCLVII" "MDCCCLVIII" "MDCCCLIX" "MDCCCLX" "MDCCCLXI" "MDCCCLXII" "MDCCCLXIII"
+    "MDCCCLXIV" "MDCCCLXV" "MDCCCLXVI" "MDCCCLXVII" "MDCCCLXVIII" "MDCCCLXIX" "MDCCCLXX"
+    "MDCCCLXXI" "MDCCCLXXII" "MDCCCLXXIII" "MDCCCLXXIV" "MDCCCLXXV" "MDCCCLXXVI" "MDCCCLXXVII"
+    "MDCCCLXXVIII" "MDCCCLXXIX" "MDCCCLXXX" "MDCCCLXXXI" "MDCCCLXXXII" "MDCCCLXXXIII"
+    "MDCCCLXXXIV" "MDCCCLXXXV" "MDCCCLXXXVI" "MDCCCLXXXVII" "MDCCCLXXXVIII" "MDCCCLXXXIX"
+    "MDCCCXC" "MDCCCXCI" "MDCCCXCII" "MDCCCXCIII" "MDCCCXCIV" "MDCCCXCV" "MDCCCXCVI"
+    "MDCCCXCVII" "MDCCCXCVIII" "MDCCCXCIX" "MCM" "MCMI" "MCMII" "MCMIII" "MCMIV" "MCMV" "MCMVI"
+    "MCMVII" "MCMVIII" "MCMIX" "MCMX" "MCMXI" "MCMXII" "MCMXIII" "MCMXIV" "MCMXV" "MCMXVI"
+    "MCMXVII" "MCMXVIII" "MCMXIX" "MCMXX" "MCMXXI" "MCMXXII" "MCMXXIII" "MCMXXIV" "MCMXXV"
+    "MCMXXVI" "MCMXXVII" "MCMXXVIII" "MCMXXIX" "MCMXXX" "MCMXXXI" "MCMXXXII" "MCMXXXIII"
+    "MCMXXXIV" "MCMXXXV" "MCMXXXVI" "MCMXXXVII" "MCMXXXVIII" "MCMXXXIX" "MCMXL" "MCMXLI"
+    "MCMXLII" "MCMXLIII" "MCMXLIV" "MCMXLV" "MCMXLVI" "MCMXLVII" "MCMXLVIII" "MCMXLIX" "MCML"
+    "MCMLI" "MCMLII" "MCMLIII" "MCMLIV" "MCMLV" "MCMLVI" "MCMLVII" "MCMLVIII" "MCMLIX" "MCMLX"
+    "MCMLXI" "MCMLXII" "MCMLXIII" "MCMLXIV" "MCMLXV" "MCMLXVI" "MCMLXVII" "MCMLXVIII" "MCMLXIX"
+    "MCMLXX" "MCMLXXI" "MCMLXXII" "MCMLXXIII" "MCMLXXIV" "MCMLXXV" "MCMLXXVI" "MCMLXXVII"
+    "MCMLXXVIII" "MCMLXXIX" "MCMLXXX" "MCMLXXXI" "MCMLXXXII" "MCMLXXXIII" "MCMLXXXIV" "MCMLXXXV"
+    "MCMLXXXVI" "MCMLXXXVII" "MCMLXXXVIII" "MCMLXXXIX" "MCMXC" "MCMXCI" "MCMXCII" "MCMXCIII"
+    "MCMXCIV" "MCMXCV" "MCMXCVI" "MCMXCVII" "MCMXCVIII" "MCMXCIX" "MM" "MMI" "MMII" "MMIII"
+    "MMIV" "MMV" "MMVI" "MMVII" "MMVIII" "MMIX" "MMX" "MMXI" "MMXII" "MMXIII" "MMXIV" "MMXV"
+    "MMXVI" "MMXVII" "MMXVIII" "MMXIX" "MMXX" "MMXXI" "MMXXII" "MMXXIII" "MMXXIV" "MMXXV"
+    "MMXXVI" "MMXXVII" "MMXXVIII" "MMXXIX" "MMXXX" "MMXXXI" "MMXXXII" "MMXXXIII" "MMXXXIV"
+    "MMXXXV" "MMXXXVI" "MMXXXVII" "MMXXXVIII" "MMXXXIX" "MMXL" "MMXLI" "MMXLII" "MMXLIII"
+    "MMXLIV" "MMXLV" "MMXLVI" "MMXLVII" "MMXLVIII" "MMXLIX" "MML" "MMLI" "MMLII" "MMLIII"
+    "MMLIV" "MMLV" "MMLVI" "MMLVII" "MMLVIII" "MMLIX" "MMLX" "MMLXI" "MMLXII" "MMLXIII" "MMLXIV"
+    "MMLXV" "MMLXVI" "MMLXVII" "MMLXVIII" "MMLXIX" "MMLXX" "MMLXXI" "MMLXXII" "MMLXXIII"
+    "MMLXXIV" "MMLXXV" "MMLXXVI" "MMLXXVII" "MMLXXVIII" "MMLXXIX" "MMLXXX" "MMLXXXI" "MMLXXXII"
+    "MMLXXXIII" "MMLXXXIV" "MMLXXXV" "MMLXXXVI" "MMLXXXVII" "MMLXXXVIII" "MMLXXXIX" "MMXC"
+    "MMXCI" "MMXCII" "MMXCIII" "MMXCIV" "MMXCV" "MMXCVI" "MMXCVII" "MMXCVIII" "MMXCIX" "MMC"
+    "MMCI" "MMCII" "MMCIII" "MMCIV" "MMCV" "MMCVI" "MMCVII" "MMCVIII" "MMCIX" "MMCX" "MMCXI"
+    "MMCXII" "MMCXIII" "MMCXIV" "MMCXV" "MMCXVI" "MMCXVII" "MMCXVIII" "MMCXIX" "MMCXX" "MMCXXI"
+    "MMCXXII" "MMCXXIII" "MMCXXIV" "MMCXXV" "MMCXXVI" "MMCXXVII" "MMCXXVIII" "MMCXXIX" "MMCXXX"
+    "MMCXXXI" "MMCXXXII" "MMCXXXIII" "MMCXXXIV" "MMCXXXV" "MMCXXXVI" "MMCXXXVII" "MMCXXXVIII"
+    "MMCXXXIX" "MMCXL" "MMCXLI" "MMCXLII" "MMCXLIII" "MMCXLIV" "MMCXLV" "MMCXLVI" "MMCXLVII"
+    "MMCXLVIII" "MMCXLIX" "MMCL" "MMCLI" "MMCLII" "MMCLIII" "MMCLIV" "MMCLV" "MMCLVI" "MMCLVII"
+    "MMCLVIII" "MMCLIX" "MMCLX" "MMCLXI" "MMCLXII" "MMCLXIII" "MMCLXIV" "MMCLXV" "MMCLXVI"
+    "MMCLXVII" "MMCLXVIII" "MMCLXIX" "MMCLXX" "MMCLXXI" "MMCLXXII" "MMCLXXIII" "MMCLXXIV"
+    "MMCLXXV" "MMCLXXVI" "MMCLXXVII" "MMCLXXVIII" "MMCLXXIX" "MMCLXXX" "MMCLXXXI" "MMCLXXXII"
+    "MMCLXXXIII" "MMCLXXXIV" "MMCLXXXV" "MMCLXXXVI" "MMCLXXXVII" "MMCLXXXVIII" "MMCLXXXIX"
+    "MMCXC" "MMCXCI" "MMCXCII" "MMCXCIII" "MMCXCIV" "MMCXCV" "MMCXCVI" "MMCXCVII" "MMCXCVIII"
+    "MMCXCIX" "MMCC" "MMCCI" "MMCCII" "MMCCIII" "MMCCIV" "MMCCV" "MMCCVI" "MMCCVII" "MMCCVIII"
+    "MMCCIX" "MMCCX" "MMCCXI" "MMCCXII" "MMCCXIII" "MMCCXIV" "MMCCXV" "MMCCXVI" "MMCCXVII"
+    "MMCCXVIII" "MMCCXIX" "MMCCXX" "MMCCXXI" "MMCCXXII" "MMCCXXIII" "MMCCXXIV" "MMCCXXV"
+    "MMCCXXVI" "MMCCXXVII" "MMCCXXVIII" "MMCCXXIX" "MMCCXXX" "MMCCXXXI" "MMCCXXXII" "MMCCXXXIII"
+    "MMCCXXXIV" "MMCCXXXV" "MMCCXXXVI" "MMCCXXXVII" "MMCCXXXVIII" "MMCCXXXIX" "MMCCXL" "MMCCXLI"
+    "MMCCXLII" "MMCCXLIII" "MMCCXLIV" "MMCCXLV" "MMCCXLVI" "MMCCXLVII" "MMCCXLVIII" "MMCCXLIX"
+    "MMCCL" "MMCCLI" "MMCCLII" "MMCCLIII" "MMCCLIV" "MMCCLV" "MMCCLVI" "MMCCLVII" "MMCCLVIII"
+    "MMCCLIX" "MMCCLX" "MMCCLXI" "MMCCLXII" "MMCCLXIII" "MMCCLXIV" "MMCCLXV" "MMCCLXVI"
+    "MMCCLXVII" "MMCCLXVIII" "MMCCLXIX" "MMCCLXX" "MMCCLXXI" "MMCCLXXII" "MMCCLXXIII"
+    "MMCCLXXIV" "MMCCLXXV" "MMCCLXXVI" "MMCCLXXVII" "MMCCLXXVIII" "MMCCLXXIX" "MMCCLXXX"
+    "MMCCLXXXI" "MMCCLXXXII" "MMCCLXXXIII" "MMCCLXXXIV" "MMCCLXXXV" "MMCCLXXXVI" "MMCCLXXXVII"
+    "MMCCLXXXVIII" "MMCCLXXXIX" "MMCCXC" "MMCCXCI" "MMCCXCII" "MMCCXCIII" "MMCCXCIV" "MMCCXCV"
+    "MMCCXCVI" "MMCCXCVII" "MMCCXCVIII" "MMCCXCIX" "MMCCC" "MMCCCI" "MMCCCII" "MMCCCIII"
+    "MMCCCIV" "MMCCCV" "MMCCCVI" "MMCCCVII" "MMCCCVIII" "MMCCCIX" "MMCCCX" "MMCCCXI" "MMCCCXII"
+    "MMCCCXIII" "MMCCCXIV" "MMCCCXV" "MMCCCXVI" "MMCCCXVII" "MMCCCXVIII" "MMCCCXIX" "MMCCCXX"
+    "MMCCCXXI" "MMCCCXXII" "MMCCCXXIII" "MMCCCXXIV" "MMCCCXXV" "MMCCCXXVI" "MMCCCXXVII"
+    "MMCCCXXVIII" "MMCCCXXIX" "MMCCCXXX" "MMCCCXXXI" "MMCCCXXXII" "MMCCCXXXIII" "MMCCCXXXIV"
+    "MMCCCXXXV" "MMCCCXXXVI" "MMCCCXXXVII" "MMCCCXXXVIII" "MMCCCXXXIX" "MMCCCXL" "MMCCCXLI"
+    "MMCCCXLII" "MMCCCXLIII" "MMCCCXLIV" "MMCCCXLV" "MMCCCXLVI" "MMCCCXLVII" "MMCCCXLVIII"
+    "MMCCCXLIX" "MMCCCL" "MMCCCLI" "MMCCCLII" "MMCCCLIII" "MMCCCLIV" "MMCCCLV" "MMCCCLVI"
+    "MMCCCLVII" "MMCCCLVIII" "MMCCCLIX" "MMCCCLX" "MMCCCLXI" "MMCCCLXII" "MMCCCLXIII"
+    "MMCCCLXIV" "MMCCCLXV" "MMCCCLXVI" "MMCCCLXVII" "MMCCCLXVIII" "MMCCCLXIX" "MMCCCLXX"
+    "MMCCCLXXI" "MMCCCLXXII" "MMCCCLXXIII" "MMCCCLXXIV" "MMCCCLXXV" "MMCCCLXXVI" "MMCCCLXXVII"
+    "MMCCCLXXVIII" "MMCCCLXXIX" "MMCCCLXXX" "MMCCCLXXXI" "MMCCCLXXXII" "MMCCCLXXXIII"
+    "MMCCCLXXXIV" "MMCCCLXXXV" "MMCCCLXXXVI" "MMCCCLXXXVII" "MMCCCLXXXVIII" "MMCCCLXXXIX"
+    "MMCCCXC" "MMCCCXCI" "MMCCCXCII" "MMCCCXCIII" "MMCCCXCIV" "MMCCCXCV" "MMCCCXCVI"
+    "MMCCCXCVII" "MMCCCXCVIII" "MMCCCXCIX" "MMCD" "MMCDI" "MMCDII" "MMCDIII" "MMCDIV" "MMCDV"
+    "MMCDVI" "MMCDVII" "MMCDVIII" "MMCDIX" "MMCDX" "MMCDXI" "MMCDXII" "MMCDXIII" "MMCDXIV"
+    "MMCDXV" "MMCDXVI" "MMCDXVII" "MMCDXVIII" "MMCDXIX" "MMCDXX" "MMCDXXI" "MMCDXXII"
+    "MMCDXXIII" "MMCDXXIV" "MMCDXXV" "MMCDXXVI" "MMCDXXVII" "MMCDXXVIII" "MMCDXXIX" "MMCDXXX"
+    "MMCDXXXI" "MMCDXXXII" "MMCDXXXIII" "MMCDXXXIV" "MMCDXXXV" "MMCDXXXVI" "MMCDXXXVII"
+    "MMCDXXXVIII" "MMCDXXXIX" "MMCDXL" "MMCDXLI" "MMCDXLII" "MMCDXLIII" "MMCDXLIV" "MMCDXLV"
+    "MMCDXLVI" "MMCDXLVII" "MMCDXLVIII" "MMCDXLIX" "MMCDL" "MMCDLI" "MMCDLII" "MMCDLIII"
+    "MMCDLIV" "MMCDLV" "MMCDLVI" "MMCDLVII" "MMCDLVIII" "MMCDLIX" "MMCDLX" "MMCDLXI" "MMCDLXII"
+    "MMCDLXIII" "MMCDLXIV" "MMCDLXV" "MMCDLXVI" "MMCDLXVII" "MMCDLXVIII" "MMCDLXIX" "MMCDLXX"
+    "MMCDLXXI" "MMCDLXXII" "MMCDLXXIII" "MMCDLXXIV" "MMCDLXXV" "MMCDLXXVI" "MMCDLXXVII"
+    "MMCDLXXVIII" "MMCDLXXIX" "MMCDLXXX" "MMCDLXXXI" "MMCDLXXXII" "MMCDLXXXIII" "MMCDLXXXIV"
+    "MMCDLXXXV" "MMCDLXXXVI" "MMCDLXXXVII" "MMCDLXXXVIII" "MMCDLXXXIX" "MMCDXC" "MMCDXCI"
+    "MMCDXCII" "MMCDXCIII" "MMCDXCIV" "MMCDXCV" "MMCDXCVI" "MMCDXCVII" "MMCDXCVIII" "MMCDXCIX"
+    "MMD" "MMDI" "MMDII" "MMDIII" "MMDIV" "MMDV" "MMDVI" "MMDVII" "MMDVIII" "MMDIX" "MMDX"
+    "MMDXI" "MMDXII" "MMDXIII" "MMDXIV" "MMDXV" "MMDXVI" "MMDXVII" "MMDXVIII" "MMDXIX" "MMDXX"
+    "MMDXXI" "MMDXXII" "MMDXXIII" "MMDXXIV" "MMDXXV" "MMDXXVI" "MMDXXVII" "MMDXXVIII" "MMDXXIX"
+    "MMDXXX" "MMDXXXI" "MMDXXXII" "MMDXXXIII" "MMDXXXIV" "MMDXXXV" "MMDXXXVI" "MMDXXXVII"
+    "MMDXXXVIII" "MMDXXXIX" "MMDXL" "MMDXLI" "MMDXLII" "MMDXLIII" "MMDXLIV" "MMDXLV" "MMDXLVI"
+    "MMDXLVII" "MMDXLVIII" "MMDXLIX" "MMDL" "MMDLI" "MMDLII" "MMDLIII" "MMDLIV" "MMDLV" "MMDLVI"
+    "MMDLVII" "MMDLVIII" "MMDLIX" "MMDLX" "MMDLXI" "MMDLXII" "MMDLXIII" "MMDLXIV" "MMDLXV"
+    "MMDLXVI" "MMDLXVII" "MMDLXVIII" "MMDLXIX" "MMDLXX" "MMDLXXI" "MMDLXXII" "MMDLXXIII"
+    "MMDLXXIV" "MMDLXXV" "MMDLXXVI" "MMDLXXVII" "MMDLXXVIII" "MMDLXXIX" "MMDLXXX" "MMDLXXXI"
+    "MMDLXXXII" "MMDLXXXIII" "MMDLXXXIV" "MMDLXXXV" "MMDLXXXVI" "MMDLXXXVII" "MMDLXXXVIII"
+    "MMDLXXXIX" "MMDXC" "MMDXCI" "MMDXCII" "MMDXCIII" "MMDXCIV" "MMDXCV" "MMDXCVI" "MMDXCVII"
+    "MMDXCVIII" "MMDXCIX" "MMDC" "MMDCI" "MMDCII" "MMDCIII" "MMDCIV" "MMDCV" "MMDCVI" "MMDCVII"
+    "MMDCVIII" "MMDCIX" "MMDCX" "MMDCXI" "MMDCXII" "MMDCXIII" "MMDCXIV" "MMDCXV" "MMDCXVI"
+    "MMDCXVII" "MMDCXVIII" "MMDCXIX" "MMDCXX" "MMDCXXI" "MMDCXXII" "MMDCXXIII" "MMDCXXIV"
+    "MMDCXXV" "MMDCXXVI" "MMDCXXVII" "MMDCXXVIII" "MMDCXXIX" "MMDCXXX" "MMDCXXXI" "MMDCXXXII"
+    "MMDCXXXIII" "MMDCXXXIV" "MMDCXXXV" "MMDCXXXVI" "MMDCXXXVII" "MMDCXXXVIII" "MMDCXXXIX"
+    "MMDCXL" "MMDCXLI" "MMDCXLII" "MMDCXLIII" "MMDCXLIV" "MMDCXLV" "MMDCXLVI" "MMDCXLVII"
+    "MMDCXLVIII" "MMDCXLIX" "MMDCL" "MMDCLI" "MMDCLII" "MMDCLIII" "MMDCLIV" "MMDCLV" "MMDCLVI"
+    "MMDCLVII" "MMDCLVIII" "MMDCLIX" "MMDCLX" "MMDCLXI" "MMDCLXII" "MMDCLXIII" "MMDCLXIV"
+    "MMDCLXV" "MMDCLXVI" "MMDCLXVII" "MMDCLXVIII" "MMDCLXIX" "MMDCLXX" "MMDCLXXI" "MMDCLXXII"
+    "MMDCLXXIII" "MMDCLXXIV" "MMDCLXXV" "MMDCLXXVI" "MMDCLXXVII" "MMDCLXXVIII" "MMDCLXXIX"
+    "MMDCLXXX" "MMDCLXXXI" "MMDCLXXXII" "MMDCLXXXIII" "MMDCLXXXIV" "MMDCLXXXV" "MMDCLXXXVI"
+    "MMDCLXXXVII" "MMDCLXXXVIII" "MMDCLXXXIX" "MMDCXC" "MMDCXCI" "MMDCXCII" "MMDCXCIII"
+    "MMDCXCIV" "MMDCXCV" "MMDCXCVI" "MMDCXCVII" "MMDCXCVIII" "MMDCXCIX" "MMDCC" "MMDCCI"
+    "MMDCCII" "MMDCCIII" "MMDCCIV" "MMDCCV" "MMDCCVI" "MMDCCVII" "MMDCCVIII" "MMDCCIX" "MMDCCX"
+    "MMDCCXI" "MMDCCXII" "MMDCCXIII" "MMDCCXIV" "MMDCCXV" "MMDCCXVI" "MMDCCXVII" "MMDCCXVIII"
+    "MMDCCXIX" "MMDCCXX" "MMDCCXXI" "MMDCCXXII" "MMDCCXXIII" "MMDCCXXIV" "MMDCCXXV" "MMDCCXXVI"
+    "MMDCCXXVII" "MMDCCXXVIII" "MMDCCXXIX" "MMDCCXXX" "MMDCCXXXI" "MMDCCXXXII" "MMDCCXXXIII"
+    "MMDCCXXXIV" "MMDCCXXXV" "MMDCCXXXVI" "MMDCCXXXVII" "MMDCCXXXVIII" "MMDCCXXXIX" "MMDCCXL"
+    "MMDCCXLI" "MMDCCXLII" "MMDCCXLIII" "MMDCCXLIV" "MMDCCXLV" "MMDCCXLVI" "MMDCCXLVII"
+    "MMDCCXLVIII" "MMDCCXLIX" "MMDCCL" "MMDCCLI" "MMDCCLII" "MMDCCLIII" "MMDCCLIV" "MMDCCLV"
+    "MMDCCLVI" "MMDCCLVII" "MMDCCLVIII" "MMDCCLIX" "MMDCCLX" "MMDCCLXI" "MMDCCLXII" "MMDCCLXIII"
+    "MMDCCLXIV" "MMDCCLXV" "MMDCCLXVI" "MMDCCLXVII" "MMDCCLXVIII" "MMDCCLXIX" "MMDCCLXX"
+    "MMDCCLXXI" "MMDCCLXXII" "MMDCCLXXIII" "MMDCCLXXIV" "MMDCCLXXV" "MMDCCLXXVI" "MMDCCLXXVII"
+    "MMDCCLXXVIII" "MMDCCLXXIX" "MMDCCLXXX" "MMDCCLXXXI" "MMDCCLXXXII" "MMDCCLXXXIII"
+    "MMDCCLXXXIV" "MMDCCLXXXV" "MMDCCLXXXVI" "MMDCCLXXXVII" "MMDCCLXXXVIII" "MMDCCLXXXIX"
+    "MMDCCXC" "MMDCCXCI" "MMDCCXCII" "MMDCCXCIII" "MMDCCXCIV" "MMDCCXCV" "MMDCCXCVI"
+    "MMDCCXCVII" "MMDCCXCVIII" "MMDCCXCIX" "MMDCCC" "MMDCCCI" "MMDCCCII" "MMDCCCIII" "MMDCCCIV"
+    "MMDCCCV" "MMDCCCVI" "MMDCCCVII" "MMDCCCVIII" "MMDCCCIX" "MMDCCCX" "MMDCCCXI" "MMDCCCXII"
+    "MMDCCCXIII" "MMDCCCXIV" "MMDCCCXV" "MMDCCCXVI" "MMDCCCXVII" "MMDCCCXVIII" "MMDCCCXIX"
+    "MMDCCCXX" "MMDCCCXXI" "MMDCCCXXII" "MMDCCCXXIII" "MMDCCCXXIV" "MMDCCCXXV" "MMDCCCXXVI"
+    "MMDCCCXXVII" "MMDCCCXXVIII" "MMDCCCXXIX" "MMDCCCXXX" "MMDCCCXXXI" "MMDCCCXXXII"
+    "MMDCCCXXXIII" "MMDCCCXXXIV" "MMDCCCXXXV" "MMDCCCXXXVI" "MMDCCCXXXVII" "MMDCCCXXXVIII"
+    "MMDCCCXXXIX" "MMDCCCXL" "MMDCCCXLI" "MMDCCCXLII" "MMDCCCXLIII" "MMDCCCXLIV" "MMDCCCXLV"
+    "MMDCCCXLVI" "MMDCCCXLVII" "MMDCCCXLVIII" "MMDCCCXLIX" "MMDCCCL" "MMDCCCLI" "MMDCCCLII"
+    "MMDCCCLIII" "MMDCCCLIV" "MMDCCCLV" "MMDCCCLVI" "MMDCCCLVII" "MMDCCCLVIII" "MMDCCCLIX"
+    "MMDCCCLX" "MMDCCCLXI" "MMDCCCLXII" "MMDCCCLXIII" "MMDCCCLXIV" "MMDCCCLXV" "MMDCCCLXVI"
+    "MMDCCCLXVII" "MMDCCCLXVIII" "MMDCCCLXIX" "MMDCCCLXX" "MMDCCCLXXI" "MMDCCCLXXII"
+    "MMDCCCLXXIII" "MMDCCCLXXIV" "MMDCCCLXXV" "MMDCCCLXXVI" "MMDCCCLXXVII" "MMDCCCLXXVIII"
+    "MMDCCCLXXIX" "MMDCCCLXXX" "MMDCCCLXXXI" "MMDCCCLXXXII" "MMDCCCLXXXIII" "MMDCCCLXXXIV"
+    "MMDCCCLXXXV" "MMDCCCLXXXVI" "MMDCCCLXXXVII" "MMDCCCLXXXVIII" "MMDCCCLXXXIX" "MMDCCCXC"
+    "MMDCCCXCI" "MMDCCCXCII" "MMDCCCXCIII" "MMDCCCXCIV" "MMDCCCXCV" "MMDCCCXCVI" "MMDCCCXCVII"
+    "MMDCCCXCVIII" "MMDCCCXCIX" "MMCM" "MMCMI" "MMCMII" "MMCMIII" "MMCMIV" "MMCMV" "MMCMVI"
+    "MMCMVII" "MMCMVIII" "MMCMIX" "MMCMX" "MMCMXI" "MMCMXII" "MMCMXIII" "MMCMXIV" "MMCMXV"
+    "MMCMXVI" "MMCMXVII" "MMCMXVIII" "MMCMXIX" "MMCMXX" "MMCMXXI" "MMCMXXII" "MMCMXXIII"
+    "MMCMXXIV" "MMCMXXV" "MMCMXXVI" "MMCMXXVII" "MMCMXXVIII" "MMCMXXIX" "MMCMXXX" "MMCMXXXI"
+    "MMCMXXXII" "MMCMXXXIII" "MMCMXXXIV" "MMCMXXXV" "MMCMXXXVI" "MMCMXXXVII" "MMCMXXXVIII"
+    "MMCMXXXIX" "MMCMXL" "MMCMXLI" "MMCMXLII" "MMCMXLIII" "MMCMXLIV" "MMCMXLV" "MMCMXLVI"
+    "MMCMXLVII" "MMCMXLVIII" "MMCMXLIX" "MMCML" "MMCMLI" "MMCMLII" "MMCMLIII" "MMCMLIV" "MMCMLV"
+    "MMCMLVI" "MMCMLVII" "MMCMLVIII" "MMCMLIX" "MMCMLX" "MMCMLXI" "MMCMLXII" "MMCMLXIII"
+    "MMCMLXIV" "MMCMLXV" "MMCMLXVI" "MMCMLXVII" "MMCMLXVIII" "MMCMLXIX" "MMCMLXX" "MMCMLXXI"
+    "MMCMLXXII" "MMCMLXXIII" "MMCMLXXIV" "MMCMLXXV" "MMCMLXXVI" "MMCMLXXVII" "MMCMLXXVIII"
+    "MMCMLXXIX" "MMCMLXXX" "MMCMLXXXI" "MMCMLXXXII" "MMCMLXXXIII" "MMCMLXXXIV" "MMCMLXXXV"
+    "MMCMLXXXVI" "MMCMLXXXVII" "MMCMLXXXVIII" "MMCMLXXXIX" "MMCMXC" "MMCMXCI" "MMCMXCII"
+    "MMCMXCIII" "MMCMXCIV" "MMCMXCV" "MMCMXCVI" "MMCMXCVII" "MMCMXCVIII" "MMCMXCIX" "MMM" "MMMI"
+    "MMMII" "MMMIII" "MMMIV" "MMMV" "MMMVI" "MMMVII" "MMMVIII" "MMMIX" "MMMX" "MMMXI" "MMMXII"
+    "MMMXIII" "MMMXIV" "MMMXV" "MMMXVI" "MMMXVII" "MMMXVIII" "MMMXIX" "MMMXX" "MMMXXI" "MMMXXII"
+    "MMMXXIII" "MMMXXIV" "MMMXXV" "MMMXXVI" "MMMXXVII" "MMMXXVIII" "MMMXXIX" "MMMXXX" "MMMXXXI"
+    "MMMXXXII" "MMMXXXIII" "MMMXXXIV" "MMMXXXV" "MMMXXXVI" "MMMXXXVII" "MMMXXXVIII" "MMMXXXIX"
+    "MMMXL" "MMMXLI" "MMMXLII" "MMMXLIII" "MMMXLIV" "MMMXLV" "MMMXLVI" "MMMXLVII" "MMMXLVIII"
+    "MMMXLIX" "MMML" "MMMLI" "MMMLII" "MMMLIII" "MMMLIV" "MMMLV" "MMMLVI" "MMMLVII" "MMMLVIII"
+    "MMMLIX" "MMMLX" "MMMLXI" "MMMLXII" "MMMLXIII" "MMMLXIV" "MMMLXV" "MMMLXVI" "MMMLXVII"
+    "MMMLXVIII" "MMMLXIX" "MMMLXX" "MMMLXXI" "MMMLXXII" "MMMLXXIII" "MMMLXXIV" "MMMLXXV"
+    "MMMLXXVI" "MMMLXXVII" "MMMLXXVIII" "MMMLXXIX" "MMMLXXX" "MMMLXXXI" "MMMLXXXII" "MMMLXXXIII"
+    "MMMLXXXIV" "MMMLXXXV" "MMMLXXXVI" "MMMLXXXVII" "MMMLXXXVIII" "MMMLXXXIX" "MMMXC" "MMMXCI"
+    "MMMXCII" "MMMXCIII" "MMMXCIV" "MMMXCV" "MMMXCVI" "MMMXCVII" "MMMXCVIII" "MMMXCIX" "MMMC"
+    "MMMCI" "MMMCII" "MMMCIII" "MMMCIV" "MMMCV" "MMMCVI" "MMMCVII" "MMMCVIII" "MMMCIX" "MMMCX"
+    "MMMCXI" "MMMCXII" "MMMCXIII" "MMMCXIV" "MMMCXV" "MMMCXVI" "MMMCXVII" "MMMCXVIII" "MMMCXIX"
+    "MMMCXX" "MMMCXXI" "MMMCXXII" "MMMCXXIII" "MMMCXXIV" "MMMCXXV" "MMMCXXVI" "MMMCXXVII"
+    "MMMCXXVIII" "MMMCXXIX" "MMMCXXX" "MMMCXXXI" "MMMCXXXII" "MMMCXXXIII" "MMMCXXXIV" "MMMCXXXV"
+    "MMMCXXXVI" "MMMCXXXVII" "MMMCXXXVIII" "MMMCXXXIX" "MMMCXL" "MMMCXLI" "MMMCXLII" "MMMCXLIII"
+    "MMMCXLIV" "MMMCXLV" "MMMCXLVI" "MMMCXLVII" "MMMCXLVIII" "MMMCXLIX" "MMMCL" "MMMCLI"
+    "MMMCLII" "MMMCLIII" "MMMCLIV" "MMMCLV" "MMMCLVI" "MMMCLVII" "MMMCLVIII" "MMMCLIX" "MMMCLX"
+    "MMMCLXI" "MMMCLXII" "MMMCLXIII" "MMMCLXIV" "MMMCLXV" "MMMCLXVI" "MMMCLXVII" "MMMCLXVIII"
+    "MMMCLXIX" "MMMCLXX" "MMMCLXXI" "MMMCLXXII" "MMMCLXXIII" "MMMCLXXIV" "MMMCLXXV" "MMMCLXXVI"
+    "MMMCLXXVII" "MMMCLXXVIII" "MMMCLXXIX" "MMMCLXXX" "MMMCLXXXI" "MMMCLXXXII" "MMMCLXXXIII"
+    "MMMCLXXXIV" "MMMCLXXXV" "MMMCLXXXVI" "MMMCLXXXVII" "MMMCLXXXVIII" "MMMCLXXXIX" "MMMCXC"
+    "MMMCXCI" "MMMCXCII" "MMMCXCIII" "MMMCXCIV" "MMMCXCV" "MMMCXCVI" "MMMCXCVII" "MMMCXCVIII"
+    "MMMCXCIX" "MMMCC" "MMMCCI" "MMMCCII" "MMMCCIII" "MMMCCIV" "MMMCCV" "MMMCCVI" "MMMCCVII"
+    "MMMCCVIII" "MMMCCIX" "MMMCCX" "MMMCCXI" "MMMCCXII" "MMMCCXIII" "MMMCCXIV" "MMMCCXV"
+    "MMMCCXVI" "MMMCCXVII" "MMMCCXVIII" "MMMCCXIX" "MMMCCXX" "MMMCCXXI" "MMMCCXXII" "MMMCCXXIII"
+    "MMMCCXXIV" "MMMCCXXV" "MMMCCXXVI" "MMMCCXXVII" "MMMCCXXVIII" "MMMCCXXIX" "MMMCCXXX"
+    "MMMCCXXXI" "MMMCCXXXII" "MMMCCXXXIII" "MMMCCXXXIV" "MMMCCXXXV" "MMMCCXXXVI" "MMMCCXXXVII"
+    "MMMCCXXXVIII" "MMMCCXXXIX" "MMMCCXL" "MMMCCXLI" "MMMCCXLII" "MMMCCXLIII" "MMMCCXLIV"
+    "MMMCCXLV" "MMMCCXLVI" "MMMCCXLVII" "MMMCCXLVIII" "MMMCCXLIX" "MMMCCL" "MMMCCLI" "MMMCCLII"
+    "MMMCCLIII" "MMMCCLIV" "MMMCCLV" "MMMCCLVI" "MMMCCLVII" "MMMCCLVIII" "MMMCCLIX" "MMMCCLX"
+    "MMMCCLXI" "MMMCCLXII" "MMMCCLXIII" "MMMCCLXIV" "MMMCCLXV" "MMMCCLXVI" "MMMCCLXVII"
+    "MMMCCLXVIII" "MMMCCLXIX" "MMMCCLXX" "MMMCCLXXI" "MMMCCLXXII" "MMMCCLXXIII" "MMMCCLXXIV"
+    "MMMCCLXXV" "MMMCCLXXVI" "MMMCCLXXVII" "MMMCCLXXVIII" "MMMCCLXXIX" "MMMCCLXXX" "MMMCCLXXXI"
+    "MMMCCLXXXII" "MMMCCLXXXIII" "MMMCCLXXXIV" "MMMCCLXXXV" "MMMCCLXXXVI" "MMMCCLXXXVII"
+    "MMMCCLXXXVIII" "MMMCCLXXXIX" "MMMCCXC" "MMMCCXCI" "MMMCCXCII" "MMMCCXCIII" "MMMCCXCIV"
+    "MMMCCXCV" "MMMCCXCVI" "MMMCCXCVII" "MMMCCXCVIII" "MMMCCXCIX" "MMMCCC" "MMMCCCI" "MMMCCCII"
+    "MMMCCCIII" "MMMCCCIV" "MMMCCCV" "MMMCCCVI" "MMMCCCVII" "MMMCCCVIII" "MMMCCCIX" "MMMCCCX"
+    "MMMCCCXI" "MMMCCCXII" "MMMCCCXIII" "MMMCCCXIV" "MMMCCCXV" "MMMCCCXVI" "MMMCCCXVII"
+    "MMMCCCXVIII" "MMMCCCXIX" "MMMCCCXX" "MMMCCCXXI" "MMMCCCXXII" "MMMCCCXXIII" "MMMCCCXXIV"
+    "MMMCCCXXV" "MMMCCCXXVI" "MMMCCCXXVII" "MMMCCCXXVIII" "MMMCCCXXIX" "MMMCCCXXX" "MMMCCCXXXI"
+    "MMMCCCXXXII" "MMMCCCXXXIII" "MMMCCCXXXIV" "MMMCCCXXXV" "MMMCCCXXXVI" "MMMCCCXXXVII"
+    "MMMCCCXXXVIII" "MMMCCCXXXIX" "MMMCCCXL" "MMMCCCXLI" "MMMCCCXLII" "MMMCCCXLIII" "MMMCCCXLIV"
+    "MMMCCCXLV" "MMMCCCXLVI" "MMMCCCXLVII" "MMMCCCXLVIII" "MMMCCCXLIX" "MMMCCCL" "MMMCCCLI"
+    "MMMCCCLII" "MMMCCCLIII" "MMMCCCLIV" "MMMCCCLV" "MMMCCCLVI" "MMMCCCLVII" "MMMCCCLVIII"
+    "MMMCCCLIX" "MMMCCCLX" "MMMCCCLXI" "MMMCCCLXII" "MMMCCCLXIII" "MMMCCCLXIV" "MMMCCCLXV"
+    "MMMCCCLXVI" "MMMCCCLXVII" "MMMCCCLXVIII" "MMMCCCLXIX" "MMMCCCLXX" "MMMCCCLXXI"
+    "MMMCCCLXXII" "MMMCCCLXXIII" "MMMCCCLXXIV" "MMMCCCLXXV" "MMMCCCLXXVI" "MMMCCCLXXVII"
+    "MMMCCCLXXVIII" "MMMCCCLXXIX" "MMMCCCLXXX" "MMMCCCLXXXI" "MMMCCCLXXXII" "MMMCCCLXXXIII"
+    "MMMCCCLXXXIV" "MMMCCCLXXXV" "MMMCCCLXXXVI" "MMMCCCLXXXVII" "MMMCCCLXXXVIII" "MMMCCCLXXXIX"
+    "MMMCCCXC" "MMMCCCXCI" "MMMCCCXCII" "MMMCCCXCIII" "MMMCCCXCIV" "MMMCCCXCV" "MMMCCCXCVI"
+    "MMMCCCXCVII" "MMMCCCXCVIII" "MMMCCCXCIX" "MMMCD" "MMMCDI" "MMMCDII" "MMMCDIII" "MMMCDIV"
+    "MMMCDV" "MMMCDVI" "MMMCDVII" "MMMCDVIII" "MMMCDIX" "MMMCDX" "MMMCDXI" "MMMCDXII"
+    "MMMCDXIII" "MMMCDXIV" "MMMCDXV" "MMMCDXVI" "MMMCDXVII" "MMMCDXVIII" "MMMCDXIX" "MMMCDXX"
+    "MMMCDXXI" "MMMCDXXII" "MMMCDXXIII" "MMMCDXXIV" "MMMCDXXV" "MMMCDXXVI" "MMMCDXXVII"
+    "MMMCDXXVIII" "MMMCDXXIX" "MMMCDXXX" "MMMCDXXXI" "MMMCDXXXII" "MMMCDXXXIII" "MMMCDXXXIV"
+    "MMMCDXXXV" "MMMCDXXXVI" "MMMCDXXXVII" "MMMCDXXXVIII" "MMMCDXXXIX" "MMMCDXL" "MMMCDXLI"
+    "MMMCDXLII" "MMMCDXLIII" "MMMCDXLIV" "MMMCDXLV" "MMMCDXLVI" "MMMCDXLVII" "MMMCDXLVIII"
+    "MMMCDXLIX" "MMMCDL" "MMMCDLI" "MMMCDLII" "MMMCDLIII" "MMMCDLIV" "MMMCDLV" "MMMCDLVI"
+    "MMMCDLVII" "MMMCDLVIII" "MMMCDLIX" "MMMCDLX" "MMMCDLXI" "MMMCDLXII" "MMMCDLXIII"
+    "MMMCDLXIV" "MMMCDLXV" "MMMCDLXVI" "MMMCDLXVII" "MMMCDLXVIII" "MMMCDLXIX" "MMMCDLXX"
+    "MMMCDLXXI" "MMMCDLXXII" "MMMCDLXXIII" "MMMCDLXXIV" "MMMCDLXXV" "MMMCDLXXVI" "MMMCDLXXVII"
+    "MMMCDLXXVIII" "MMMCDLXXIX" "MMMCDLXXX" "MMMCDLXXXI" "MMMCDLXXXII" "MMMCDLXXXIII"
+    "MMMCDLXXXIV" "MMMCDLXXXV" "MMMCDLXXXVI" "MMMCDLXXXVII" "MMMCDLXXXVIII" "MMMCDLXXXIX"
+    "MMMCDXC" "MMMCDXCI" "MMMCDXCII" "MMMCDXCIII" "MMMCDXCIV" "MMMCDXCV" "MMMCDXCVI"
+    "MMMCDXCVII" "MMMCDXCVIII" "MMMCDXCIX" "MMMD" "MMMDI" "MMMDII" "MMMDIII" "MMMDIV" "MMMDV"
+    "MMMDVI" "MMMDVII" "MMMDVIII" "MMMDIX" "MMMDX" "MMMDXI" "MMMDXII" "MMMDXIII" "MMMDXIV"
+    "MMMDXV" "MMMDXVI" "MMMDXVII" "MMMDXVIII" "MMMDXIX" "MMMDXX" "MMMDXXI" "MMMDXXII"
+    "MMMDXXIII" "MMMDXXIV" "MMMDXXV" "MMMDXXVI" "MMMDXXVII" "MMMDXXVIII" "MMMDXXIX" "MMMDXXX"
+    "MMMDXXXI" "MMMDXXXII" "MMMDXXXIII" "MMMDXXXIV" "MMMDXXXV" "MMMDXXXVI" "MMMDXXXVII"
+    "MMMDXXXVIII" "MMMDXXXIX" "MMMDXL" "MMMDXLI" "MMMDXLII" "MMMDXLIII" "MMMDXLIV" "MMMDXLV"
+    "MMMDXLVI" "MMMDXLVII" "MMMDXLVIII" "MMMDXLIX" "MMMDL" "MMMDLI" "MMMDLII" "MMMDLIII"
+    "MMMDLIV" "MMMDLV" "MMMDLVI" "MMMDLVII" "MMMDLVIII" "MMMDLIX" "MMMDLX" "MMMDLXI" "MMMDLXII"
+    "MMMDLXIII" "MMMDLXIV" "MMMDLXV" "MMMDLXVI" "MMMDLXVII" "MMMDLXVIII" "MMMDLXIX" "MMMDLXX"
+    "MMMDLXXI" "MMMDLXXII" "MMMDLXXIII" "MMMDLXXIV" "MMMDLXXV" "MMMDLXXVI" "MMMDLXXVII"
+    "MMMDLXXVIII" "MMMDLXXIX" "MMMDLXXX" "MMMDLXXXI" "MMMDLXXXII" "MMMDLXXXIII" "MMMDLXXXIV"
+    "MMMDLXXXV" "MMMDLXXXVI" "MMMDLXXXVII" "MMMDLXXXVIII" "MMMDLXXXIX" "MMMDXC" "MMMDXCI"
+    "MMMDXCII" "MMMDXCIII" "MMMDXCIV" "MMMDXCV" "MMMDXCVI" "MMMDXCVII" "MMMDXCVIII" "MMMDXCIX"
+    "MMMDC" "MMMDCI" "MMMDCII" "MMMDCIII" "MMMDCIV" "MMMDCV" "MMMDCVI" "MMMDCVII" "MMMDCVIII"
+    "MMMDCIX" "MMMDCX" "MMMDCXI" "MMMDCXII" "MMMDCXIII" "MMMDCXIV" "MMMDCXV" "MMMDCXVI"
+    "MMMDCXVII" "MMMDCXVIII" "MMMDCXIX" "MMMDCXX" "MMMDCXXI" "MMMDCXXII" "MMMDCXXIII"
+    "MMMDCXXIV" "MMMDCXXV" "MMMDCXXVI" "MMMDCXXVII" "MMMDCXXVIII" "MMMDCXXIX" "MMMDCXXX"
+    "MMMDCXXXI" "MMMDCXXXII" "MMMDCXXXIII" "MMMDCXXXIV" "MMMDCXXXV" "MMMDCXXXVI" "MMMDCXXXVII"
+    "MMMDCXXXVIII" "MMMDCXXXIX" "MMMDCXL" "MMMDCXLI" "MMMDCXLII" "MMMDCXLIII" "MMMDCXLIV"
+    "MMMDCXLV" "MMMDCXLVI" "MMMDCXLVII" "MMMDCXLVIII" "MMMDCXLIX" "MMMDCL" "MMMDCLI" "MMMDCLII"
+    "MMMDCLIII" "MMMDCLIV" "MMMDCLV" "MMMDCLVI" "MMMDCLVII" "MMMDCLVIII" "MMMDCLIX" "MMMDCLX"
+    "MMMDCLXI" "MMMDCLXII" "MMMDCLXIII" "MMMDCLXIV" "MMMDCLXV" "MMMDCLXVI" "MMMDCLXVII"
+    "MMMDCLXVIII" "MMMDCLXIX" "MMMDCLXX" "MMMDCLXXI" "MMMDCLXXII" "MMMDCLXXIII" "MMMDCLXXIV"
+    "MMMDCLXXV" "MMMDCLXXVI" "MMMDCLXXVII" "MMMDCLXXVIII" "MMMDCLXXIX" "MMMDCLXXX" "MMMDCLXXXI"
+    "MMMDCLXXXII" "MMMDCLXXXIII" "MMMDCLXXXIV" "MMMDCLXXXV" "MMMDCLXXXVI" "MMMDCLXXXVII"
+    "MMMDCLXXXVIII" "MMMDCLXXXIX" "MMMDCXC" "MMMDCXCI" "MMMDCXCII" "MMMDCXCIII" "MMMDCXCIV"
+    "MMMDCXCV" "MMMDCXCVI" "MMMDCXCVII" "MMMDCXCVIII" "MMMDCXCIX" "MMMDCC" "MMMDCCI" "MMMDCCII"
+    "MMMDCCIII" "MMMDCCIV" "MMMDCCV" "MMMDCCVI" "MMMDCCVII" "MMMDCCVIII" "MMMDCCIX" "MMMDCCX"
+    "MMMDCCXI" "MMMDCCXII" "MMMDCCXIII" "MMMDCCXIV" "MMMDCCXV" "MMMDCCXVI" "MMMDCCXVII"
+    "MMMDCCXVIII" "MMMDCCXIX" "MMMDCCXX" "MMMDCCXXI" "MMMDCCXXII" "MMMDCCXXIII" "MMMDCCXXIV"
+    "MMMDCCXXV" "MMMDCCXXVI" "MMMDCCXXVII" "MMMDCCXXVIII" "MMMDCCXXIX" "MMMDCCXXX" "MMMDCCXXXI"
+    "MMMDCCXXXII" "MMMDCCXXXIII" "MMMDCCXXXIV" "MMMDCCXXXV" "MMMDCCXXXVI" "MMMDCCXXXVII"
+    "MMMDCCXXXVIII" "MMMDCCXXXIX" "MMMDCCXL" "MMMDCCXLI" "MMMDCCXLII" "MMMDCCXLIII" "MMMDCCXLIV"
+    "MMMDCCXLV" "MMMDCCXLVI" "MMMDCCXLVII" "MMMDCCXLVIII" "MMMDCCXLIX" "MMMDCCL" "MMMDCCLI"
+    "MMMDCCLII" "MMMDCCLIII" "MMMDCCLIV" "MMMDCCLV" "MMMDCCLVI" "MMMDCCLVII" "MMMDCCLVIII"
+    "MMMDCCLIX" "MMMDCCLX" "MMMDCCLXI" "MMMDCCLXII" "MMMDCCLXIII" "MMMDCCLXIV" "MMMDCCLXV"
+    "MMMDCCLXVI" "MMMDCCLXVII" "MMMDCCLXVIII" "MMMDCCLXIX" "MMMDCCLXX" "MMMDCCLXXI"
+    "MMMDCCLXXII" "MMMDCCLXXIII" "MMMDCCLXXIV" "MMMDCCLXXV" "MMMDCCLXXVI" "MMMDCCLXXVII"
+    "MMMDCCLXXVIII" "MMMDCCLXXIX" "MMMDCCLXXX" "MMMDCCLXXXI" "MMMDCCLXXXII" "MMMDCCLXXXIII"
+    "MMMDCCLXXXIV" "MMMDCCLXXXV" "MMMDCCLXXXVI" "MMMDCCLXXXVII" "MMMDCCLXXXVIII" "MMMDCCLXXXIX"
+    "MMMDCCXC" "MMMDCCXCI" "MMMDCCXCII" "MMMDCCXCIII" "MMMDCCXCIV" "MMMDCCXCV" "MMMDCCXCVI"
+    "MMMDCCXCVII" "MMMDCCXCVIII" "MMMDCCXCIX" "MMMDCCC" "MMMDCCCI" "MMMDCCCII" "MMMDCCCIII"
+    "MMMDCCCIV" "MMMDCCCV" "MMMDCCCVI" "MMMDCCCVII" "MMMDCCCVIII" "MMMDCCCIX" "MMMDCCCX"
+    "MMMDCCCXI" "MMMDCCCXII" "MMMDCCCXIII" "MMMDCCCXIV" "MMMDCCCXV" "MMMDCCCXVI" "MMMDCCCXVII"
+    "MMMDCCCXVIII" "MMMDCCCXIX" "MMMDCCCXX" "MMMDCCCXXI" "MMMDCCCXXII" "MMMDCCCXXIII"
+    "MMMDCCCXXIV" "MMMDCCCXXV" "MMMDCCCXXVI" "MMMDCCCXXVII" "MMMDCCCXXVIII" "MMMDCCCXXIX"
+    "MMMDCCCXXX" "MMMDCCCXXXI" "MMMDCCCXXXII" "MMMDCCCXXXIII" "MMMDCCCXXXIV" "MMMDCCCXXXV"
+    "MMMDCCCXXXVI" "MMMDCCCXXXVII" "MMMDCCCXXXVIII" "MMMDCCCXXXIX" "MMMDCCCXL" "MMMDCCCXLI"
+    "MMMDCCCXLII" "MMMDCCCXLIII" "MMMDCCCXLIV" "MMMDCCCXLV" "MMMDCCCXLVI" "MMMDCCCXLVII"
+    "MMMDCCCXLVIII" "MMMDCCCXLIX" "MMMDCCCL" "MMMDCCCLI" "MMMDCCCLII" "MMMDCCCLIII" "MMMDCCCLIV"
+    "MMMDCCCLV" "MMMDCCCLVI" "MMMDCCCLVII" "MMMDCCCLVIII" "MMMDCCCLIX" "MMMDCCCLX" "MMMDCCCLXI"
+    "MMMDCCCLXII" "MMMDCCCLXIII" "MMMDCCCLXIV" "MMMDCCCLXV" "MMMDCCCLXVI" "MMMDCCCLXVII"
+    "MMMDCCCLXVIII" "MMMDCCCLXIX" "MMMDCCCLXX" "MMMDCCCLXXI" "MMMDCCCLXXII" "MMMDCCCLXXIII"
+    "MMMDCCCLXXIV" "MMMDCCCLXXV" "MMMDCCCLXXVI" "MMMDCCCLXXVII" "MMMDCCCLXXVIII" "MMMDCCCLXXIX"
+    "MMMDCCCLXXX" "MMMDCCCLXXXI" "MMMDCCCLXXXII" "MMMDCCCLXXXIII" "MMMDCCCLXXXIV" "MMMDCCCLXXXV"
+    "MMMDCCCLXXXVI" "MMMDCCCLXXXVII" "MMMDCCCLXXXVIII" "MMMDCCCLXXXIX" "MMMDCCCXC" "MMMDCCCXCI"
+    "MMMDCCCXCII" "MMMDCCCXCIII" "MMMDCCCXCIV" "MMMDCCCXCV" "MMMDCCCXCVI" "MMMDCCCXCVII"
+    "MMMDCCCXCVIII" "MMMDCCCXCIX" "MMMCM" "MMMCMI" "MMMCMII" "MMMCMIII" "MMMCMIV" "MMMCMV"
+    "MMMCMVI" "MMMCMVII" "MMMCMVIII" "MMMCMIX" "MMMCMX" "MMMCMXI" "MMMCMXII" "MMMCMXIII"
+    "MMMCMXIV" "MMMCMXV" "MMMCMXVI" "MMMCMXVII" "MMMCMXVIII" "MMMCMXIX" "MMMCMXX" "MMMCMXXI"
+    "MMMCMXXII" "MMMCMXXIII" "MMMCMXXIV" "MMMCMXXV" "MMMCMXXVI" "MMMCMXXVII" "MMMCMXXVIII"
+    "MMMCMXXIX" "MMMCMXXX" "MMMCMXXXI" "MMMCMXXXII" "MMMCMXXXIII" "MMMCMXXXIV" "MMMCMXXXV"
+    "MMMCMXXXVI" "MMMCMXXXVII" "MMMCMXXXVIII" "MMMCMXXXIX" "MMMCMXL" "MMMCMXLI" "MMMCMXLII"
+    "MMMCMXLIII" "MMMCMXLIV" "MMMCMXLV" "MMMCMXLVI" "MMMCMXLVII" "MMMCMXLVIII" "MMMCMXLIX"
+    "MMMCML" "MMMCMLI" "MMMCMLII" "MMMCMLIII" "MMMCMLIV" "MMMCMLV" "MMMCMLVI" "MMMCMLVII"
+    "MMMCMLVIII" "MMMCMLIX" "MMMCMLX" "MMMCMLXI" "MMMCMLXII" "MMMCMLXIII" "MMMCMLXIV" "MMMCMLXV"
+    "MMMCMLXVI" "MMMCMLXVII" "MMMCMLXVIII" "MMMCMLXIX" "MMMCMLXX" "MMMCMLXXI" "MMMCMLXXII"
+    "MMMCMLXXIII" "MMMCMLXXIV" "MMMCMLXXV" "MMMCMLXXVI" "MMMCMLXXVII" "MMMCMLXXVIII"
+    "MMMCMLXXIX" "MMMCMLXXX" "MMMCMLXXXI" "MMMCMLXXXII" "MMMCMLXXXIII" "MMMCMLXXXIV"
+    "MMMCMLXXXV" "MMMCMLXXXVI" "MMMCMLXXXVII" "MMMCMLXXXVIII" "MMMCMLXXXIX" "MMMCMXC" "MMMCMXCI"
+    "MMMCMXCII" "MMMCMXCIII" "MMMCMXCIV" "MMMCMXCV" "MMMCMXCVI" "MMMCMXCVII" "MMMCMXCVIII"
+    "MMMCMXCIX"))
diff --git a/ansi-tests/write-to-string.lsp b/ansi-tests/write-to-string.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..c324c44b04ac4d50d922bd1c3c4170d1ce995cd6
--- /dev/null
+++ b/ansi-tests/write-to-string.lsp
@@ -0,0 +1,43 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Sun Jul 25 12:53:11 2004
+;;;; Contains: Tests of WRITE-TO-STRING
+
+(in-package :cl-test)
+
+(compile-and-load "printer-aux.lsp")
+
+;;; This function is extensively used elsewhere
+
+(deftest write-to-string.1
+  (random-write-to-string-test 1000)
+  nil)
+
+(deftest write-to-string.2
+  (with-standard-io-syntax
+   (write-to-string 2 :allow-other-keys nil))
+  "2")
+
+(deftest write-to-string.3
+  (with-standard-io-syntax
+   (write-to-string 3 :allow-other-keys t '#.(gensym) 0))
+  "3")
+
+(deftest write-to-string.4
+  (with-standard-io-syntax
+   (write-to-string 4 :base 10 :base 2))
+  "4")
+
+;;; Error tests
+
+(deftest write-to-string.error.1
+  (signals-error (write-to-string) program-error)
+  t)
+
+(deftest write-to-string.error.2
+  (signals-error (write-to-string nil '#.(gensym) nil) program-error)
+  t)
+
+(deftest write-to-string.error.3
+  (signals-error (write-to-string nil :radix) program-error)
+  t)
diff --git a/ansi-tests/write.lsp b/ansi-tests/write.lsp
index c3b5c89620783fce30ac6111fd3893bf132d8d51..d13c9598664c6e63418f143664954d221f6c3edc 100644
--- a/ansi-tests/write.lsp
+++ b/ansi-tests/write.lsp
@@ -84,4 +84,3 @@
 
 
 
-