anchor.diff:  
   (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)
  +  (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-fraction (stream object style digits-after-dot scale)
  +  (declare (type float object))
     (let* ((ratio (if digits-after-dot
   		    (rational object)
   		    (rationalize object)))
  -	 ;; -- support 1000000000000000.1d0
  +	 ;; -- support 100000000000000.1d0
   	 (fp-error (multiple-value-bind (_scaled expon _sign)
   		       (integer-decode-float object)
   		     (declare (ignore _scaled _sign))
  
positive.code: 					    (t :normal))))
    (unless (numberp object)
      (error "~A is not an expected type for jp-numeral" (type-of object)))
    (unless (= *print-base* 10)
      (error "*print-base* must be 10 for jp-numeral"))
    (prog ((buf (make-array '(1) :element-type 'character :fill-pointer 0 :adjustable t)))
     try-again
     (handler-case
         (with-output-to-string (buf-stream buf)
  	 (when (minusp object)
  	   (write-string (get-minus-sign style) buf-stream))
  	 (ctypecase object
  	   (integer
  	    (print-jp-integer buf-stream (abs object) style))
  	   (ratio
  	    (case style
  	      (:positional
  	       (print-jp-integer buf-stream (abs (numerator object)) style)
  	       (write-string (get-parts-of style) buf-stream)
  	       (print-jp-integer buf-stream (denominator object) style))
  	      (t
  	       (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
  	    (let ((int-part
  		   (handler-case (truncate object)
  		     (error ()
  		       (error 'bad-format-float-error)))))
  	      (print-jp-integer buf-stream (abs int-part) style))
  	    (when (plusp (length buf))
  	      (write-char (or decimal-mark (get-radix-point-char style))
  			  buf-stream))
  	    (print-fractional-part 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)))
  
negative.code: 
  ;;; Writers
  
  (defun print-positional (stream object style digits-after-dot scale)
    (let* ((trim-zero? (and (floatp object)
  			  (not digits-after-dot)))
  	 (digits-after-dot (or digits-after-dot
  			       (- +power-min+)))
  	 (scale (or scale 0))
  	 (lispstr
  	  (ctypecase object
  	    (integer (format nil "~D" object))
  	    (ratio (format nil "~A" object))
  	    (float (format nil "~,v,vF" digits-after-dot scale object)))))
      (when trim-zero?
        (setf lispstr (string-right-trim '(#\0) lispstr)))
      (loop for c across lispstr
         as jp-str = 
         (case c
  	 (#\0 (get-digit 0 style))
  	 (#\1 (get-digit 1 style))
  	 (#\2 (get-digit 2 style))
  	 (#\3 (get-digit 3 style))
  	 (#\4 (get-digit 4 style))
  	 (#\5 (get-digit 5 style))
  	 (#\6 (get-digit 6 style))
  	 (#\7 (get-digit 7 style))
  	 (#\8 (get-digit 8 style))
  	 (#\9 (get-digit 9 style))
  	 (#\. (string (get-radix-point-char style))) ; TODO: use decimal-mark arg.
  	 (#\- (get-minus-sign style))
  	 (#\/ (get-parts-of style))
  	 ((#\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)))
         do (write-string jp-str stream))))
  
  
  (defun make-digits4-string (digits4 style)
  