anchor.diff:    nil)
   
   (defun make-in-memory-output-stream (&key (element-type :default)
  -                                     (external-format *default-character-encoding*))
  +                                     external-format
  +                                     initial-buffer-size)
     "Returns a binary output stream which accepts objects of type ELEMENT-TYPE \(a subtype of OCTET) and makes available a sequence that contains the octes that were actually output."
     (declare (optimize speed))
  +  (unless external-format
  +    (setf external-format *default-character-encoding*))
     (when (eq element-type :bivalent)
       (setf element-type :default))
     (make-instance 'vector-output-stream
                    :vector (make-vector-stream-buffer
                             :element-type (cond
  -                                          ((equal element-type '(unsigned-byte 8)) element-type)
  -                                          (t
  -                                           (ecase element-type
  -                                             (:default '(unsigned-byte 8))
  -                                             (character 'character)))))
  +                                          ((or (eq element-type :default)
  +                                               (equal element-type '(unsigned-byte 8)))
  +                                           '(unsigned-byte 8))
  +                                          ((eq element-type 'character)
  +                                           'character)
  +                                          ((subtypep element-type '(unsigned-byte 8))
  +                                           '(unsigned-byte 8))
  +                                          (t (error "Illegal element-type ~S" element-type)))
  +                          :initial-size initial-buffer-size)
                    :element-type element-type
                    :external-format (ensure-external-format external-format)))
   
  
positive.code:        (unwind-protect
              (progn
                (setq ,var (make-in-memory-output-stream :element-type ,element-type
                                                         :external-format ,external-format))
                ,@body
                (get-output-stream-sequence ,var :return-as ,return-as))
           (when ,var (close ,var))))))
  
negative.code: 
  (defun extend-vector-output-stream-buffer (extension stream &key (start 0) (end (length extension)))
    (declare (optimize speed)
             (type array-index start end)
             (type vector extension))
    (vector-extend extension (vector-stream-vector stream) :start start :end end)
    (incf (vector-stream-index stream) (- end start))
  