anchor.diff:  	    finally
   	    (setf printed sum)
   	    (return i))
  -	 do (case style
  -	      (:positional
  -	       (write-string (get-digit current-digit style) stream))
  -	      (otherwise
  -	       (when (/= 0 current-digit)
  -		 (write-string (get-digit current-digit style) stream)
  -		 (write-string (get-power power style) stream))))
  +	 do (when (/= 0 current-digit)
  +	      (write-string (get-digit current-digit style) stream)
  +	      (write-string (get-power power style) stream))
   	 while (and (< printed frac-part)
   		    (< fp-error current-scale))))))
   			 
  
positive.code: 
  (defun print-jp-integer (stream object style)
    (declare (type (integer 0) object))
    (case style
      (:positional
       (loop with lispstr = (format nil "~D" object)
  	for c across lispstr
  	do (write-string (translate-char c style) stream)))
      (otherwise
       (loop with strs = nil
  	for power from 0 by 4
  	for (rest digits4) = (multiple-value-list (floor object 10000))
  	then (multiple-value-list (floor rest 10000))
  	as digits4-str = (make-digits4-string digits4 style)
  	as power-str = (if (plusp power)
  			   (get-power power style) nil)
  	when (plusp (length digits4-str))
  	do (when power-str
  	     (push power-str strs))
  	and do (push digits4-str strs)
  	while (> rest 0)
  	finally (mapc #'(lambda (s) (write-string s stream)) strs)))))
  
  (defun print-fractional-part (stream object style digits-after-dot scale)
    ;; (declare (type float object))
    (let* ((trim-zero? (if digits-after-dot t nil))
  	 (digits-after-dot (or digits-after-dot
  			       (- +power-min+)))
  	 (scale (or scale 0))
  	 (frac-part-l-str (format nil "~,v,vF" digits-after-dot scale object)))
      (when trim-zero?
        (setf frac-part-l-str (string-right-trim '(#\0) frac-part-l-str)))
      (loop for i from (1+ (position #\. frac-part-l-str)) below (length frac-part-l-str)
         as c = (aref frac-part-l-str i)
         for power downfrom -1
         unless (digit-char-p c)
         do (case c
  	    ((#\- #\/)
  	     (assert nil (c) "~C should be treated around this function." c))
  	    ((#\d #\e #\f #\l #\s)
  	     (assert nil (c)
  		     "Exponent marker '~C' is found. This is an internal BUG of jp-numeral." c))
  	    (otherwise
  	     (error 'bad-format-float-error)))
         if (eq style :positional)
         do (write-string (translate-char c style) stream)
         else if (char/= #\0 c)
         do (write-string (translate-char c style) stream)
         (write-string (get-power power style) stream))))
  
  ;; This does not use Lisp printer.
  #+ignore
  (defun print-fractional-2 (stream object style digits-after-dot scale)
    (let* ((ratio (if digits-after-dot
  		    (rational object)
  		    (rationalize object)))
  	 ;; -- support 1000000000000000.1d0
  	 (fp-error (multiple-value-bind (_scaled expon _sign)
  		       (integer-decode-float object)
  		     (declare (ignore _scaled _sign))
  
negative.code: 					    (t :normal))))
    (unless (numberp object)
      (error "~A is not an expected type for jp-numeral" (type-of object)))
    (prog ((*print-base* 10) ; *print-base* must be 10 for jp-numeral
  	 (buf (make-array '(1) :element-type 'character :fill-pointer 0 :adjustable t)))
     try-again
     (handler-case
         (with-output-to-string (buf-stream buf)
  	 (case style
  	   (:positional
  	    (print-positional stream object style digits-after-dot scale))
  	   (otherwise
  	    (when (minusp object)
  	      (write-string (get-minus-sign style) buf-stream))
  	    (ctypecase object
  	      (integer
  	       (print-jp-integer buf-stream (abs object) style))
  	      (ratio
  	       (print-jp-integer buf-stream (denominator object) style)
  	       (write-string (get-parts-of style) buf-stream)
  	       (print-jp-integer buf-stream (abs (numerator object)) style))
  	      (float
  	       (print-fractional buf-stream object style digits-after-dot scale)))
  	    (unless (plusp (length buf))
  	      (write-string (get-digit 0 style) buf-stream)))))
       (no-power-char-error ()
         ;; Decimal chars are exhausted. Use positional.
         (assert (not (eq style :positional)))
  