anchor.diff:        (let ((dt (if date (slot-value (-to-number date) '-number-data) dd)))
   	(when (or (eql m :nan) (eql dt :nan))
   	  (error "Reference error."))
  -	(when (or (eql ts :nan) (eql m :infinity) (eql m :-infinity)
  +	(when (or (eql m :infinity) (eql m :-infinity)
   		  (eql dt :infinity) (eql dt :-infinity))
  +	  (setf (slot-value this '-date-value :nan))
   	  (return-from set-month *number-nan*))
   	(setf (slot-value this '-date-value)
   	      (adjust-timestamp! ts (offset :month m :day dt)))
  -	(* 1000 (timestamp-to-unix ts))))))
  +	(!number (* 1000 (timestamp-to-unix ts)))))))
   
   (defmethod set-seconds ((this -date-prototype) sec &optional ms)
     (let ((ts (slot-value this '-date-value))
   	(s (slot-value (-to-number sec) '-number-data)))
       (multiple-value-bind
   	  (ns ss mm hh dd mon yy day-of-weak daylight-saving-time-p timezone-offset timezone-abbr) (decode-timestamp ts)
  -      (let ((nano (if ms (* 1000000 (slot-value (-to-number ms) '-number-data))
  -		      ns)))
  +      (let* ((milli (if ms (slot-value (-to-number ms) '-number-data) ns))
  +	     (nano (if (eql milli :nan)
  +		       :nan
  +		       (if (or (eql milli :infinity) (eql milli :-infinity))
  +			   :infinity milli))))
  +	(when (or (eql s :nan) (eql nano :nan))
  +	  (error "Reference error."))
  +	(when (or (eql s :infinity) (eql s :-infinity) (eql nano :infinity))
  +	  (setf (slot-value this '-date-value :nan))
  +	  (return-from set-seconds *number-nan*))
   	(setf (slot-value this '-date-value)
   	      (adjust-timestamp! ts (offset :sec s :nsec nano)))
  -	(* 1000 (timestamp-to-unix ts))))))
  +	(!number (* 1000 (timestamp-to-unix ts)))))))
   
   (defmethod set-time ((this -date-prototype) time)
     (let* ((tm (slot-value (-to-number time) '-number-data))
  -	 (nano (* 1000000 (mod tm 1000))))
  +	 (nano (if (eql tm :nan)
  +		   :nan
  +		   (if (or (eql tm :infinity) (eql tm :-infinity))
  +		       :infinity (* 1000000 (mod tm 1000))))))
  +    (when (eql nano :infinity)
  +      (setf (slot-value this '-date-value) :nan)
  +      (return-from set-time *number-nan*))
  +    (when (eql nano :nan)
  +      (error "Reference error."))
       (setf (slot-value this '-date-value) (unix-to-timestamp tm :nsec nano))
  -    tm))
  +    (!number tm)))
   
   (defmethod set-utc-date ((this -date-prototype) date)
     (let ((ts (slot-value this '-date-value))
   	(dt (slot-value (-to-number date) '-number-data)))
       (multiple-value-bind
   	  (ns ss mm hh dd mon yy day-of-weak daylight-saving-time-p timezone-offset timezone-abbr) (decode-timestamp ts :timezone +utc-zone+)
  +      (when (or (eql dt :infinity) (eql dt :-infinity))
  +	(setf (slot-value this '-date-value) :nan)
  +	(return-from set-utc-date *number-nan*))
  +      (when (eql dt :nan)
  +	(error "Reference error."))
         (setf (slot-value this '-date-value)
  -	    (adjust-timestamp! ts (offset :day date))))
  -    (* 1000 (timestamp-to-unix ts))))
  +	    (adjust-timestamp! ts (offset :day date)))
  +      (!number (* 1000 (timestamp-to-unix ts))))))
   
   (defmethod set-utc-full-year ((this -date-prototype) year &optional month date)
  -  (let ((tm (slot-value this '-date-value))
  -	(y (-to-number year))
  -	(m (if month (-to-number month) (count-month tm)))
  -	(dt (if date (-to-number date) (count-date tm))))
  -    ))
  +  (let ((ts (slot-value this '-date-value))
  +	(y (slot-value (-to-number year) '-number-data)))
  +    (multiple-value-bind
  +	  (ns ss mm hh dd mon yy day-of-weak daylight-saving-time-p timezone-offset timezone-abbr) (decode-timestamp ts :timezone +utc-zone+)
  +      (let ((m (if month (slot-value (-to-number month) '-number-data) mon))
  +	    (dt (if date (slot-value (-to-number date) '-number-data) dd)))
  +	(when (or (eql y :infinity) (eql y :-infinity) (eql m :infinity)
  +		  (eql m :-infinity) (eql dt :infinity) (eql dt :-infinity))
  +	  (setf (slot-value this '-date-value) :nan)
  +	  (return-from set-utc-full-year *number-nan*))
  +	(when (or (eql y :nan) (eql m :nan) (eql dt :nan))
  +	  (error "Reference error."))
  +	(setf (slot-value this '-date-value)
  +	      (adjust-timestamp! ts (offset :year y :month m :day dt)))
  +	(!number (* 1000 (timestamp-to-unix ts)))))))
   
   (defmethod set-utc-hours ((this -date-prototype) hour &optional min sec ms)
  -  (let ((tm (slot-value this '-date-value))
  -	(h (-to-number hour))
  -	(m (if min (-to-number min) (count-minute tm)))
  -	(s (if sec (-to-number sec) (count-second tm)))
  -	(milli (if ms (-to-number ms) (count-ms tm))))
  -    ))
  +  (let ((ts (slot-value this '-date-value))
  +	(h (slot-value (-to-number hour) '-number-data)))
  +    (multiple-value-bind
  +	  (ns ss mm hh dd mon yy day-of-weak daylight-saving-time-p timezone-offset timezone-abbr) (decode-timestamp ts :timezone +utc-zone+)
  +      (let* ((m (if min (slot-value (-to-number min) '-number-data) mm))
  +	     (s (if sec (slot-value (-to-number sec) '-number-data) ss))
  +	     (milli (if ms (slot-value (-to-number ms) '-number-data) ns))
  +	     (nano (if (eql milli :nan)
  +		       :nan
  +		       (if (or (eql milli :infinity) (eql milli :-infinity))
  +			   :infinity ns))))
  +	(when (or (eql h :infinity) (eql h :-infinity) (eql m :infinity)
  +		  (eql m :-infinity) (eql s :infinity) (eql s :-infinity)
  +		  (eql nano :infinity))
  +	  (setf (slot-value this '-date-value) :nan)
  +	  (return-from set-utc-hours *number-nan*))
  +	(when (or (eql h :nan) (eql m :nan) (eql s :nan) (eql nano :nan))
  +	  (error "Reference error."))
  +	(setf (slot-value this '-date-value)
  +	      (adjust-timestamp! ts (offset :hour h :minute m :sec s :nsec nano)))
  +	(!number (* 1000 (timestamp-to-unix ts)))))))
   
   (defmethod set-utc-milliseconds ((this -date-prototype) ms)
  -  (let ((tm (slot-value this '-date-value))
  -	(milli (-to-number ms)))
  -    ))
  +  (let ((ts (slot-value this '-date-value))
  +	(milli (slot-value (-to-number ms) '-number-data)))
  +    (when (or (eql milli :infinity) (eql milli :-infinity))
  +      (setf (slot-value this '-date-value) :nan)
  +      (return-from set-utc-milliseconds *number-nan*))
  +    (setf (slot-value this '-date-value)
  +	  (adjust-timestamp! ts (offset :nsec (* milli 1000000))))
  +    (!number (* 1000 (timestamp-to-unix ts)))))
   
   (defmethod set-utc-minutes ((this -date-prototype) min &optional sec ms)
  -  (let ((tm (slot-value this '-date-value))
  -	(m (-to-number min))
  -	(s (if sec (-to-number sec) (count-second tm)))
  -	(milli (if ms (-to-number ms) (count-ms tm))))
  -    ))
  +  (let ((ts (slot-value this '-date-value))
  +	(m (slot-value (-to-number min) '-number-data)))
  +    (multiple-value-bind
  +	  (ns ss mm hh dd mon yy day-of-weak daylight-saving-time-p timezone-offset timezone-abbr) (decode-timestamp ts :timezone +utc-zone+)
  +      (let* ((s (if sec (slot-value (-to-number sec) '-number-data) ss))
  +	     (milli (if ms (slot-value (-to-number ms) '-number-data) ns))
  +	     (nano (if (eql ms :nan)
  +		       :nan
  +		       (if (or (eql ms :infinity) (eql ms :-infinity))
  +			   :infinity ns))))
  +	(when (or (eql m :infinity) (eql m :-infinity) (eql s :infinity)
  +		  (eql s :-infinity) (eql nano :infinity))
  +	  (setf (slot-value this '-date-value) :nan)
  +	  (return-from set-utc-minutes *number-nan*))
  +	(when (or (eql m :nan) (eql s :nan) (eql nano :nan))
  +	  (error "Reference error."))
  +	(setf (slot-value this '-date-value)
  +	      (adjust-timestamp! ts (offset :minute m :sec s :nsec nano)))
  +	(!number (* 1000 (timestamp-to-unix ts)))))))
   
   (defmethod set-utc-month ((this -date-prototype) month &optional date)
     (let ((tm (slot-value this '-date-value))
  -	(m (-to-number month))
  -	(dt (if date (-to-number date) (count-date tm))))
  -    ))
  +	(m (slot-value (-to-number month) '-number-data)))
  +    (multiple-value-bind
  +	  (ns ss mm hh dd mon yy day-of-weak daylight-saving-time-p timezone-offset timezone-abbr) (decode-timestamp ts :timezone +utc-zone+)
  +      (let ((dt (if date (slot-value (-to-number date) '-number-data dd))))
  +	(when (or (eql m :infinity) (eql m :-infinity) (eql dt :infinity)
  +		  (eql dt :-infinity))
  +	  (setf (slot-value this '-date-value) :nan)
  +	  (return-from set-utc-month *number-nan*))
  +	(when (or (eql m :nan) (eql dt :nan))
  +	  (error "Reference error."))
  +	(setf (slot-value this '-date-value)
  +	      (adjust-timestamp! ts (offset :month m :day dt)))
  +	(!number (* 1000 (timestamp-to-unix ts)))))))
   
   (defmethod set-utc-seconds ((this -date-prototype) sec &optional ms)
     (let ((tm (slot-value this '-date-value))
  -	(s (-to-number sec))
  -	(milli (if ms (-to-number ms) (count-ms tm))))
  -    ))
  -
  -;;; Implementation dependent. Use form in LOCAL-TIME pack.
  +	(s (slot-value (-to-number sec) '-number-data)))
  +    (multiple-value-bind
  +	  (ns ss mm hh dd mon yy day-of-weak daylight-saving-time-p timezone-offset timezone-abbr) (decode-timestamp ts :timezone +utc-zone+)
  +      (let* ((milli (if ms (slot-value (-to-number ms) '-number-data) ns))
  +	     (nano (if (eql ms :nan)
  +		       :nan
  +		       (if (or (eql ms :infinity) (eql ms :-infinity))
  +			   :infinity ns))))
  +	(when (or (eql s :infinity) (eql s :-infinity) (eql nano :infinity))
  +	  (setf (slot-value this '-date-value) :nan)
  +	  (return-from set-utc-seconds *number-nan*))
  +	(when (or (eql s :nan) (eql nano :nan))
  +	  (error "Reference error."))
  +	(setf (slot-value this '-date-value)
  +	      (adjust-timestamp! ts (offset :sec s :nsec nano)))
  +	(!number (* 1000 (timestamp-to-unix ts)))))))
  +
   (defmethod to-date-string ((this -date-prototype))
  -  )
  +  (let ((ts (slot-value this '-date-value)))
  +    (when (eql ts :nan)
  +      (return-from to-date-string (!string "Invalid Date")))
  +    (!string (format-rfc1123-timestring nil ts))))
   
   (defmethod to-iso-string ((this -date-prototype))
  -  )
  +  (let ((ts (slot-value this '-date-value)))
  +    (when (eql ts :nan)
  +      (return-from to-date-string (!string "Invalid Date")))
  +    (!string (format-timestring nil ts))))
   
   ;;; How to implement this?
   (defmethod to-json ((this -date-prototype) key)
  
positive.code: 	(dt (slot-value (-to-number date) '-number-data)))
      (when (eql dt :nan)
        (error "Reference error."))
      (when (or (eql dt :infinity) (eql dt :-infinity) (eql ts :nan))
        (return-from set-date *number-nan*))
      (setf (slot-value this '-date-value)
  	  (adjust-timestamp! ts (offset :day date)))
      (* 1000 (timestamp-to-unix ts))))
  
  (defmethod set-full-year ((this -date-prototype) year &optional month date)
    (let ((ts (slot-value this '-date-value))
  
negative.code: 
  ;;; Also implementation dependent.
  (defmethod to-string ((this -date-prototype))
    (to-date-string this))
  
  (defmethod to-time-string ((this -date-prototype))
    (to-date-string this))
  
  (defmethod to-utc-string ((this -date-prototype))
    (let ((ts (slot-value this '-date-value)))
      (when (eql ts :nan)
        (return-from to-utc-string (!string "Invalid Date")))
      (!string (format-rfc1123-timestring nil ts :timezone +utc-zone+))))
  
  (defmethod value-of ((this -date-prototype))
    (let ((ts (slot-value this '-date-value)))
      (when (eql ts :nan)
        (return-from value-of *number-nan*))
      (let ((nano (nsec-of ts)))
        (!number (+ (* 1000 (timestamp-to-unix ts)) (floor nano 1000000))))))
  
  (defmethod to-primitive ((this -date-prototype) hint)
    (case hint
      ((default string)
       (-to-primitive this 'string))
      ('number
       (-to-primitive this 'number))
      (t
       (error "Type error."))))
  