anchor.diff:  (defun decode-unit-to-bytes (bytes &key (start 0) (end (length bytes))
   				     (state (make-instance 'scsu-state)))
     (let* ((ret-list (multiple-value-list 
  -		    (decode-to-string bytes :src-start start :src-end end :state state)))
  +		    (decode-to-string bytes :start1 start :end1 end :state state)))
   	 (ret-string (first ret-list)))
       (declare (type list ret-list)
   	     (type string ret-string))	     
  
positive.code: 	   (:unicode-mode (encode-unit*/unicode-mode state code-point write-func))))))
  
  (defun encode-from-string (string
  			   &key (src-start 0) (src-end (length string))
  			     (bytes (make-array (length string) ; no way to expect length..
  						:fill-pointer 0 :adjustable t
  						:element-type '(unsigned-byte 8)))
  			     (dst-start 0) ; TODO: change name to ":start1, :start2"?
  			     (dst-end (length bytes))
  			     (state (make-instance 'scsu-state)))
    (declare (type string string)
  	   (type (array (unsigned-byte 8) *) bytes)	   
  	   (type fixnum src-start src-end dst-start dst-end))
    (with-writing-function (put-byte current)
        (bytes dst-start dst-end :element-type (unsigned-byte 8))
      (loop for i of-type fixnum from src-start below src-end
         as c of-type character = (char string i)
         do (encode-unit* state (char-code c) #'put-byte))
      (values bytes current state)))
  
negative.code: 	   code-point))))
  
  (defun decode-to-string (bytes
  			 &key (start1 0) (end1 (length bytes))
  			   (string (make-array (floor end1 2) ; a rough expectation.
  					       :element-type 'character
  					       :fill-pointer 0 :adjustable t))
  			   (start2 0) (end2 (length string))
  			   (state (make-instance 'scsu-state)))
    (declare (type (array (unsigned-byte 8) *) bytes)
  	   (type fixnum start1 end1 start2 end2)
  	   (type string string))
    ;; TODO: Don't reduce to last bytes..
    (with-reading-function (pick-byte src-current)
        (bytes start1 end1)
      (with-writing-function (put-char dst-current)
  	(string start2 end2 :element-type character)
        (loop while (< src-current end1) ; TODO: should return even after a completed control byte.
  	 as code-point of-type unicode-code-point = (decode-unit* state #'pick-byte)
  	 do (put-char (code-char code-point)))
        (values string dst-current state src-current))))
  