anchor.diff:           (set! pos (1- pos))
            (string-set! buf pos #\-))
           
  -        (write-substring stream buf pos (- buf-size pos)))))
  -
  -(define (print-string stream str)
  +        (write-substring writer buf pos (- buf-size pos)))))
  +
  +(define (print-string writer str)
     (if *print-readably*
         (begin
  -        (print-double-quote stream)
  -        (write-string stream str)
  -        (print-double-quote stream))
  -      (write-string stream str)))
  +        (print-double-quote writer)
  +        (write-string writer str)
  +        (print-double-quote writer))
  +      (write-string writer str)))
   
   
   (define character-names '((#\Space . "Space")
                             (#\Newline . "Newline")))
   
  -(define (print-char stream ch)
  +(define (print-char writer ch)
     (if *print-readably*
         (begin
  -       (write-string stream "#\\")
  +       (write-string writer "#\\")
          (define name (assoc ch character-names))
  -       (write-string stream (if name
  +       (write-string writer (if name
                                   (character-string ch)
                                   (cdr name))))
  -      (write-string stream (character-string ch))))
  -
  -(define (print-symbol stream sym)
  +      (write-string writer (character-string ch))))
  +
  +(define (print-symbol writer sym)
     (define str (symbol-name sym))
  -  (write-substring stream str 0 (string-length str)))
  +  (write-substring writer str 0 (string-length str)))
   
   (define special-printed-forms
     '((false . "false")
  
positive.code:                        (set! write-from (1- write-from)))
  
                        ((eq? ch #\%)
                         (print-newline stream))
  
                        ((or (eq? ch #\A) (eq? ch #\a))
                         (with-value (*print-readably* false)
                           (print stream (car args)))
                         (set! args (cdr args)))
  
                        ((or (eq? ch #\S) (eq? ch #\s))
                         (with-value (*print-readably* true)
                           (print stream (car args)))
                         (set! args (cdr args)))
  
                        ((or (eq? ch #\D) (eq? ch #\d))
                         (with-value (*print-radix* 10)
                           (print stream (car args)))
                         (set! args (cdr args)))
  
                        ((or (eq? ch #\X) (eq? ch #\x))
                         (with-value (*print-radix* 16)
                           (print stream (car args)))
                         (set! args (cdr args)))
  
                        ((or (eq? ch #\C) (eq? ch #\c))
                         (print-char stream (car args))
                         (set! args (cdr args)))
  
                        (true
  
negative.code:     (define (unquote name)
        (begin
          (define str (character-string (unquote ch)))
          (lambda (writer) (write-string writer str))))))
  
  (define-char-printer print-newline #\Newline)
  (define-char-printer print-double-quote #\")
  
  (define (print-number writer num)
    (if (= num 0)
        (write-string writer "0")
        (begin
          (unless (and (<= 2 *print-radix*)
                       (<= *print-radix* (string-length print-number-digits)))
  