anchor.diff:  		    (UTF16Decode(fst,snd))))))))))
   
   (defmethod concat ((this -string-proto) &rest args)
  -  (let ((out (slot-value this '-string-raw)))
  +  (let ((out (slot-value this '-string-data)))
       (dolist (arg args)
         (setf out (concatenate 'string out arg)))
       (!string out)))
   
   (defmethod ends-with ((this -string-proto) search &optional end)
  -  )
  +  (when (eql (type-of search) '-reg-exp-proto)
  +    (error "Type error."))
  +  (let* ((search-str (slot-value (-to-string search) '-string-data))
  +	 (this-str (slot-value this '-string-data))
  +	 (len (length this-str))
  +	 (end-pos (if end (slot-value (-to-integer end) '-number-data) len))
  +	 (end-position (!min (!max end-pos 0) len))
  +	 (start (- end-position (length search-str))))
  +    (when (< start 0)
  +      (return-from ends-with *boolean-false*))
  +    (if (string= search-str (subseq this-str start))
  +	*boolean-true*
  +	*boolean-false*)))
   
   (defmethod includes ((this -string-proto) search &optional pos)
  -  )
  +  (when (eql (type-of search) '-reg-exp-proto)
  +    (error "Type error."))
  +  (let* ((search-str (slot-value search '-string-data))
  +	 (this-str (slot-value this '-string-data))
  +	 (position (if pos (slot-value (-to-integer pos) '-number-data) 0))
  +	 (len (length this-str))
  +	 (start (!min (!max position 0) len)))
  +    (if (search search-str this-str :start2 start)
  +	*boolean-true*
  +	*boolean-false*)))
   
   (defmethod index-of ((this -string-proto) search &optional pos)
  -  )
  +  (let* ((search-str (slot-value (-to-string search) '-string-data))
  +	 (this-str (slot-value this '-string-data))
  +	 (position (if pos (slot-value (-to-integer pos) '-number-data) 0))
  +	 (len (length this-str))
  +	 (start (!min (!max position 0) len)))
  +    (let ((s (search search-str this-str :start2 start)))
  +      (if s
  +	  (!number s)
  +	  (!number -1)))))
   
   (defmethod last-index-of ((this -string-proto) search &optional pos)
  -  )
  +  (let* ((search-str (slot-value (-to-string search) '-string-data))
  +	 (this-str (slot-value this '-string-data))
  +	 (position (if pos (slot-value (-to-integer pos) '-number-data) 0))
  +	 (len (length this-str))
  +	 (start (!min (!max position 0) len)))
  +    (let ((s (search search-str this-str :start2 start :from-end t)))
  +      (if s
  +	  (!number s)
  +	  (!number -1)))))
   
   (defmethod locale-compare ((this -string-proto) that)
  -  )
  +  (let ((this-str (slot-value this '-string-data))
  +	(that-str (slot-value that '-string-data)))
  +    ))
   
   (defmethod match ((this -string-proto) regexp)
     )
   
   (defmethod normalize ((this -string-proto) &optional form)
  -  )
  +  (let ((this-str (slot-value this '-string-data))
  +	(form (if form (slot-value form '-string-data) "NFC")))
  +    (when (not (member form ("NFC" "NFD" "NFKC" "NFKD")))
  +      (error "Range error."))
  +    ))
   
   (defmethod repeat ((this -string-proto) count)
  -  )
  +  (let ((this-str (slot-value this '-string-data))
  +	(n (slot-value (-to-integer count) '-number-data)))
  +    (if (or (eql n :nan) (eql n :infinity) (eql n :-infinity) (< n 0))
  +	(error "Range error.")
  +	(if (zerop n)
  +	    (!string "")
  +	    (let ((str ""))
  +	      (!string (loop repeat n
  +			    do (setf str (concatenate 'string str this-str)))))))))
   
   (defmethod replace ((this -string-proto) search replace)
     )
   
   (defmethod search ((this -string-proto) regexp)
  -  )
  -
  -(defmethod slice ((this -string-proto) start end)
  -  )
  -
  -(defmethod split ((this -string-proto) separator limit)
  +  (let ((this-str (slot-value this '-string-data)))
  +    ))
  +
  +(defmethod slice ((this -string-proto) start &optional end)
  +  (let* ((this-str (slot-value this '-string-data))
  +	 (len (length this-str))
  +	 (int-start (slot-value (-to-integer start) '-number-data))
  +	 (int-end (if end (slot-value (-to-integer end) '-number-data) len))
  +	 (from (if (or (< int-start 0) (eql int-start :-infinity))
  +		   (!max 0 (+ len int-start))
  +		   (!min len int-start)))
  +	 (to (if (or (< int-end 0) (eql int-end :-infinity))
  +		 (!max 0 (+ len int-end))
  +		 (!min len int-end))))
  +    (!string (subseq this-str from to))))
  +
  +(defmethod split ((this -string-proto) separator &optional limit)
     )
   
   (defmethod starts-with ((this -string-proto) search &optional pos)
  -  )
  -
  -(defmethod substring ((this -string-proto) start end)
  -  )
  +  (let* ((this-str (slot-value this '-string-data))
  +	 (search-str (slot-value (-to-string search) '-string-data))
  +	 (position (if pos (slot-value (-to-integer pos) '-number-data) 0))
  +	 (len (length this-str))
  +	 (slen (length search-str))
  +	 (start (!min (!max position 0) len)))
  +    (if (string= (subseq this-str start (+ start slen)) search-str)
  +	*boolean-true*
  +	*boolean-false*)))
  +
  +(defmethod substring ((this -string-proto) start &optional end)
  +  (let* ((this-str (slot-value this '-string-data))
  +	 (len (length this-str))
  +	 (int-start (-to-integer start))
  +	 (int-end (if end (-to-integer end) len))
  +	 (final-start (!min (!max int-start 0) len))
  +	 (final-end (!min (!max int-end 0) len))
  +	 (from (!min final-start final-end))
  +	 (to (!max final-start final-end)))
  +    (!string (subseq this-str from to))))
   
   (defmethod to-locale-lower-case ((this -string-proto))
     )
  
positive.code:   )
  
  (defmethod to-lower-case ((this -string-proto))
    )
  
  (defmethod to-string ((this -string-proto))
    )
  
  (defmethod to-upper-case ((this -string-proto))
    )
  
  (defmethod trim ((this -string-proto))
    )
  
  (defmethod value-of ((this -string-proto))
    )
  
  (defmethod iterator ((this -string-proto))
    )
  
negative.code: 	      ;; 10FFFF is 1114111
  	      (<= 0 next-cp 1114111))
  	 ;; Range error.
  	 (error "Range error.")
         do (setf (aref out i) (UTF16Encoding next-cp)))
      (!string out))
  
  