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: 			       (state (make-instance 'scsu-state)))
    (declare (type fixnum start end)
  	   (type (array (unsigned-byte 8) *) bytes))
    (check-type code-point (integer 0 #x10FFFF))
    (let ((tmp-string (make-array 1 :element-type 'character)))
      (declare (type simple-string tmp-string)
  	     (dynamic-extent tmp-string))
      (setf (schar tmp-string 0) code-point)
      (encode-from-string tmp-string :src-start 0 :src-end 1
  			:bytes bytes :dst-start start :dst-end end :state 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))))
  