anchor.diff:  	      (unless (zerop d0)
   		(put-n (get-digit d0 style))))))))))
   
  -(defun print-jp-integer (stream object style scale)
  +(defun print-jp-integer (stream object style)
     (declare (type integer object))
  -  (setf object (* object (expt 10 scale)))
     (loop with strs = nil
        for power from 0 by 4
        for (rest digits4) = (multiple-value-list (floor object 10000))
  
positive.code:      while (plusp rest)
       finally (mapc #'(lambda (s) (write-string s stream)) strs)))
  
  (defun print-fractional-part (stream object style digits-after-dot scale)
    (let* ((trim-zero? (not digits-after-dot))
  	 (digits-after-dot (or digits-after-dot
  			       (- +power-min+)))
  	 (scale (or scale 0))
  	 (lispstr (format nil "~,v,vF" digits-after-dot scale object)))
      (when trim-zero?
        (setf lispstr (string-right-trim '(#\0) lispstr)))
      (loop for i from (1+ (position #\. lispstr)) below (length lispstr)
         as c = (aref lispstr i)
         for power downfrom -1 to (- digits-after-dot)
         unless (digit-char-p c)
         do (error 'not-formattable-error)
         if (char/= #\0 c)
         do (write-string (translate-digit c style) stream)
         (write-string (get-power power style) stream))))
  
  
  (defun flag-to-style (colon-p at-sign-p)
  
negative.code: 
  (defun yen (stream object &optional colon-p at-sign-p digits-after-dot
  	    &aux (style (flag-to-style colon-p at-sign-p)))
    (flet ((print-ysr (signum yen sen rin)
  	   (when (zerop signum)
  	     (return-from print-ysr
  	       (pprint-jp-numeral stream 0 colon-p at-sign-p
  				  0 0 (get-yen style))))
  	   (when (minusp signum)
  	     (write-string (get-minus-sign style) stream))
  	   (unless (zerop yen)
  	     (pprint-jp-numeral stream (abs yen) colon-p at-sign-p
  				0 0 (get-yen style)))
  	   (unless (zerop sen)
  	     (pprint-jp-numeral stream (abs sen) colon-p at-sign-p
  				0 0 (get-sen style)))
  	   (unless (zerop rin)
  	     (pprint-jp-numeral stream (abs rin) colon-p at-sign-p
  				0 0 (get-power -2 style))))) ; 'rin' char (厘) 
      (case digits-after-dot
        ((nil 2)
         (setf digits-after-dot 2)
         (let ((quot-2 (round object 1/100)))
  	 (multiple-value-bind (yen sen) (truncate quot-2 100)
  	   (print-ysr (signum quot-2) yen sen 0))))
        (3
         (let ((quot-3 (round object 1/1000)))
  	 (multiple-value-bind (yen rin-rest) (truncate quot-3 1000)
  	   (multiple-value-bind (sen rin) (truncate rin-rest 10)
  	     (print-ysr (signum quot-3) yen sen rin)))))
        (otherwise
         (error "digits should be 2, 3, or nil")))))
  
  (defun Y (stream object &optional colon-p at-sign-p digits-after-dot)
    (yen stream object colon-p at-sign-p digits-after-dot))
  