anchor.diff:  	       ((:break-characters ,break-var))
   	       ((:after-line-break ,after-var))
   	       ((:after-line-break-initially ,initially-var)))
  -        (declare (ignorable ,fill-var ,break-var ,after-var))
  +        (declare (ignorable ,fill-var ,break-var ,after-var ,initially-var))
   	(let ((,stream (make-instance
   			'filling-stream
   			:stream ,stream
  
positive.code: 			       `(:break-characters ,break-var))
  			,@(and after-line-break
  			       `(:after-line-break ,after-var)))))
  	  (when ,initially-var
  	    (write-string ,after-var ,stream))
  	  ,@body))
        ,@args)))
  
  
negative.code: 			  (encapsulating-stream-stream stream))))
  	(call-next-method))))
  
  (defmethod stream-write-string :around ((stream filling-stream) string
                                          &optional (start 0) (end (length string)))
    (dotimes (i (- end start))
      (stream-write-char stream (aref string (+ i start)))))
  
  ;;; All the monkey business with the lambda form has to do with capturing the
  ;;; keyword arguments of the macro while preserving the user's evaluation order.
  
  (defmacro filling-output ((stream &rest args &key fill-width break-characters
  				  after-line-break after-line-break-initially)
  			  &body body)
    (when (eq stream t)
      (setq stream '*standard-output*))
    (with-gensyms (fill-var break-var after-var initially-var)
  