anchor.diff:            (index stream) (1+ index))
       integer))
   
  -(define-stream-write-sequence octet-output-stream
  +(define-stream-write-sequence octet-output-stream simple-octet-vector
     (let* ((buffer (buffer stream))
            (length (length buffer))
            (index (index stream)))
  
positive.code: (defmethod #.*stream-element-type-function* ((stream octet-stream))
    '(unsigned-byte 8))
  
  (defmacro define-stream-read-sequence (specializer &body body)
    #+sbcl
    `(defmethod sb-gray:stream-read-sequence ((stream ,specializer) seq &optional (start 0) end)
       (cond
         ((not (typep seq 'simple-octet-vector))
          (call-next-method))
         (t
          (let ((end (or end (length seq))))
            ,@body))))
    #+cmu
    `(defmethod ext:stream-read-sequence ((stream ,specializer) seq &optional (start 0) end)
       (cond
         ((not (typep seq 'simple-octet-vector))
          (call-next-method))
         (t
          (let ((end (or end (length seq))))
            ,@body))))
    #+allegro
    `(defmethod excl:stream-read-sequence ((stream ,specializer) seq &optional (start 0) end)
       (cond
         ((not (typep seq 'simple-octet-vector))
          (call-next-method))
         (t
          (let ((end (or end (length seq))))
            ,@body))))
    #+openmcl
    `(defmethod ccl:stream-read-vector ((stream ,specializer) seq start end)
       (cond
         ((not (typep seq 'simple-octet-vector))
          (call-next-method))
         (t
          ,@body)))
    #+lispworks
    `(defmethod stream:stream-read-sequence ((stream ,specializer) seq start end)
       (cond
         ((not (typep seq 'simple-octet-vector))
          (call-next-method))
         (t
          ,@body))))
  
  (defmacro define-stream-write-sequence (specializer &body body)
    #+sbcl
    `(defmethod sb-gray:stream-write-sequence ((stream ,specializer) seq &optional (start 0) end)
       (cond
         ((not (typep seq 'simple-octet-vector))
          (call-next-method))
         (t
          (let ((end (or end (length seq))))
            ,@body))))
    #+cmu
    `(defmethod ext:stream-write-sequence ((stream ,specializer) seq &optional (start 0) end)
       (cond
         ((not (typep seq 'simple-octet-vector))
          (call-next-method))
         (t
          (let ((end (or end (length seq))))
            ,@body))))
    #+allegro
    `(defmethod stream:stream-write-sequence ((stream ,specializer) seq &optional (start 0) end)
       (cond
         ((not (typep seq 'simple-octet-vector))
          (call-next-method))
         (t
          (let ((end (or end (length seq))))
            ,@body))))
    #+openmcl
    `(defmethod ccl:stream-write-vector ((stream ,specializer) seq start end)
       (cond
         ((not (typep seq 'simple-octet-vector))
          (call-next-method))
         (t
          ,@body)))
    #+lispworks
    `(defmethod stream:stream-write-sequence ((stream ,specializer) seq start end)
       (cond
         ((not (typep seq 'simple-octet-vector))
          (call-next-method))
         (t
          ,@body))))
  
  ;;; input streams
  
negative.code:        (setf (index stream) (1+ index))
         (aref buffer index)))))
  
  (define-stream-read-sequence octet-input-stream simple-octet-vector
    (let ((buffer (buffer stream))
          (index (index stream))
          (buffer-end (end stream)))
  