anchor.diff:  
   (defun local-time-decoded-date (local-time)
     (multiple-value-bind (leap-cycle year-days)
  -      (floor (day-of local-time) 1461)
  -    (multiple-value-bind (years month-days)
  -        (floor year-days 365)
  -      (let* ((month (decode-month month-days))
  -             (day (1+ (- month-days (month-days month)))))
  -        (values
  -         (+ (* leap-cycle 4)
  -            years
  -            (if (>= month 10)
  -                2001
  -                2000))
  -         (if (>= month 10)
  -             (- month 9)
  -             (+ month 3))
  -         day)))))
  +	  (floor (day-of local-time) 1461)
  +	(multiple-value-bind (years month-days)
  +		(floor year-days 365)
  +	  (let* ((month (decode-month month-days))
  +			 (day (1+ (- month-days (month-days month)))))
  +		(values
  +		 (+ (* leap-cycle 4)
  +			years
  +			(if (>= month 10)
  +				2001
  +				2000))
  +		 (if (>= month 10)
  +			 (- month 9)
  +			 (+ month 3))
  +		 day)))))
   
   (defun local-time-decoded-time (local-time)
     (multiple-value-bind (hours hour-remainder)
  -      (floor (sec-of local-time) 3600)
  -    (multiple-value-bind (minutes seconds)
  -        (floor hour-remainder 60)
  -      (values
  -       hours
  -       minutes
  -       seconds))))
  +	  (floor (sec-of local-time) 3600)
  +	(multiple-value-bind (minutes seconds)
  +		(floor hour-remainder 60)
  +	  (values
  +	   hours
  +	   minutes
  +	   seconds))))
   
   (defparameter +leap-factor+ 1461)
   
   (defun decode-local-time (local-time)
     "Returns the decoded time as multiple values: ms, ss, mm, hh, day, month, year, day-of-week, daylight-saving-time-p, timezone, and the customary timezone abbreviation."
     (multiple-value-bind (hours minutes seconds)
  -      (local-time-decoded-time local-time)
  -    (multiple-value-bind (year month day)
  -        (local-time-decoded-date local-time)
  -      (values
  -       (usec-of local-time)
  -       seconds minutes hours
  -       day month year
  -       (local-time-day-of-week local-time)
  -       (nth-value 1 (timezone local-time))
  -       (timezone-of local-time)
  -       (nth-value 2 (timezone local-time))))))
  +	  (local-time-decoded-time local-time)
  +	(multiple-value-bind (year month day)
  +		(local-time-decoded-date local-time)
  +	  (values
  +	   (usec-of local-time)
  +	   seconds minutes hours
  +	   day month year
  +	   (local-time-day-of-week local-time)
  +	   (nth-value 1 (timezone local-time))
  +	   (timezone-of local-time)
  +	   (nth-value 2 (timezone local-time))))))
   
   (defun skip-timestring-junk (stream junk-allowed &rest expected)
     (cond
  -    (junk-allowed
  -     ;; just skip non-digit characters
  -     (loop for c = (read-char stream nil nil)
  -           while (and c (not (digit-char-p c)))
  -           finally (unread-char c stream)))
  -    (t
  -     ;; must have an expected character or the string end, then
  -     ;; followed by a digit or the string end
  -     (let ((c (read-char stream nil nil)))
  -       (unless (or (null c) (member c expected :test 'eql))
  -         (error
  -          "Junk in timestring: expected ~:[(or ~{~s~^ ~})~;~{~s~}~], got ~s"
  -          (= (length expected) 1)
  -          expected
  -          c)))
  -     (let ((c (read-char stream nil nil)))
  -       (if (or (null c) (digit-char-p c) (member c expected :test 'eql))
  -           (when c
  -             (unread-char c stream))
  -           (error "Junk in timestring: expected digit, got ~s"  c))))))
  +	(junk-allowed
  +	 ;; just skip non-digit characters
  +	 (loop for c = (read-char stream nil nil)
  +		   while (and c (not (digit-char-p c)))
  +		   finally (unread-char c stream)))
  +	(t
  +	 ;; must have an expected character or the string end, then
  +	 ;; followed by a digit or the string end
  +	 (let ((c (read-char stream nil nil)))
  +	   (unless (or (null c) (member c expected :test 'eql))
  +		 (error
  +		  "Junk in timestring: expected ~:[(or ~{~s~^ ~})~;~{~s~}~], got ~s"
  +		  (= (length expected) 1)
  +		  expected
  +		  c)))
  +	 (let ((c (read-char stream nil nil)))
  +	   (if (or (null c) (digit-char-p c) (member c expected :test 'eql))
  +		   (when c
  +			 (unread-char c stream))
  +		   (error "Junk in timestring: expected digit, got ~s"	c))))))
   
   (defun read-integer-str (stream)
     (loop for c = (read-char stream nil nil)
  -        while (and c (digit-char-p c))
  -        collect c into result
  -        finally (progn
  -                  (when c
  -                    (unread-char c stream))
  -                  (return
  -                    (when result
  -                      (parse-integer (coerce result 'string)))))))
  +		while (and c (digit-char-p c))
  +		collect c into result
  +		finally (progn
  +				  (when c
  +					(unread-char c stream))
  +				  (return
  +					(when result
  +					  (parse-integer (coerce result 'string)))))))
   
   (defun read-millisecond-str (stream)
     (loop for c = (read-char stream nil nil)
  -        while (and c (digit-char-p c))
  -        collect c into result
  -        finally (progn
  -                  (when c
  -                    (unread-char c stream))
  -                  (return
  -                    (when result
  -                      (* (expt 10 (- 6 (min (length result) 6)))
  -                         (parse-integer (coerce result 'string)
  -                                        :end (min (length result) 6))))))))
  +		while (and c (digit-char-p c))
  +		collect c into result
  +		finally (progn
  +				  (when c
  +					(unread-char c stream))
  +				  (return
  +					(when result
  +					  (* (expt 10 (- 6 (min (length result) 6)))
  +						 (parse-integer (coerce result 'string)
  +										:end (min (length result) 6))))))))
   
   (defun split-timestring-date (str junk-allowed now-year now-month now-day)
     (let ((result nil))
  -    (with-input-from-string (ins str)
  -      ;; Retrieve the year
  -      (push (read-integer-str ins) result)
  -      (skip-timestring-junk ins junk-allowed #\-)
  -      ;; Retrieve the month
  -      (push (read-integer-str ins) result)
  -      (skip-timestring-junk ins junk-allowed #\-)
  -      ;; Retrieve the day
  -      (push (read-integer-str ins) result))
  -    (list
  -     (or (first result) now-day)
  -     (or (second result) now-month)
  -     (or (third result) now-year))))
  +	(with-input-from-string (ins str)
  +	  ;; Retrieve the year
  +	  (push (read-integer-str ins) result)
  +	  (skip-timestring-junk ins junk-allowed #\-)
  +	  ;; Retrieve the month
  +	  (push (read-integer-str ins) result)
  +	  (skip-timestring-junk ins junk-allowed #\-)
  +	  ;; Retrieve the day
  +	  (push (read-integer-str ins) result))
  +	(list
  +	 (or (first result) now-day)
  +	 (or (second result) now-month)
  +	 (or (third result) now-year))))
   
   (defun split-timestring-time (str junk-allowed now-hour now-minute now-second now-ms)
     (let ((result nil))
  -    (with-input-from-string (ins str)
  -      ;; Retrieve the hour
  -      (push (read-integer-str ins) result)
  -      (skip-timestring-junk ins junk-allowed #\:)
  -      ;; Retrieve the minute
  -      (push (read-integer-str ins) result)
  -      (skip-timestring-junk ins junk-allowed #\:)
  -      ;; Retrieve the second
  -      (push (read-integer-str ins) result)
  -      (skip-timestring-junk ins junk-allowed #\. #\,)
  -      ;; Retrieve the fractional second and convert to milliseconds
  -      (push (read-millisecond-str ins) result))
  -    (list
  -     (or (first result) now-ms)
  -     (or (second result) now-second)
  -     (or (third result) now-minute)
  -     (or (fourth result) now-hour))))
  +	(with-input-from-string (ins str)
  +	  ;; Retrieve the hour
  +	  (push (read-integer-str ins) result)
  +	  (skip-timestring-junk ins junk-allowed #\:)
  +	  ;; Retrieve the minute
  +	  (push (read-integer-str ins) result)
  +	  (skip-timestring-junk ins junk-allowed #\:)
  +	  ;; Retrieve the second
  +	  (push (read-integer-str ins) result)
  +	  (skip-timestring-junk ins junk-allowed #\. #\,)
  +	  ;; Retrieve the fractional second and convert to milliseconds
  +	  (push (read-millisecond-str ins) result))
  +	(list
  +	 (or (first result) now-ms)
  +	 (or (second result) now-second)
  +	 (or (third result) now-minute)
  +	 (or (fourth result) now-hour))))
   
   (defun split-timestring (raw-string start end junk-allowed)
     (let* ((timestring (subseq raw-string start end))
  -         (t-pos (position #\t timestring :test #'string-equal)))
  -    (multiple-value-bind (now-ms now-second now-minute now-hour now-day now-month now-year)
  -        (decode-local-time (now))
  -      (cond
  -        ((eql t-pos 0)
  -         (append (split-timestring-time (subseq timestring 1)
  -                                        junk-allowed
  -                                        now-hour now-minute now-second now-ms)
  -                 (list now-day now-month now-year)))
  -        ((null t-pos)
  -         (append (list now-hour now-minute now-second now-ms)
  -                 (split-timestring-date timestring junk-allowed
  -                                        now-year now-month now-day)))
  -        (t
  -         (append (split-timestring-time (subseq timestring (1+ t-pos))
  -                                        junk-allowed
  -                                        now-hour now-minute now-second now-ms)
  -                 (split-timestring-date (subseq timestring 0 t-pos) junk-allowed
  -                                        now-year now-month now-day)))))))
  +		 (t-pos (position #\t timestring :test #'string-equal)))
  +	(multiple-value-bind (now-ms now-second now-minute now-hour now-day now-month now-year)
  +		(decode-local-time (now))
  +	  (cond
  +		((eql t-pos 0)
  +		 (append (split-timestring-time (subseq timestring 1)
  +										junk-allowed
  +										now-hour now-minute now-second now-ms)
  +				 (list now-day now-month now-year)))
  +		((null t-pos)
  +		 (append (list now-hour now-minute now-second now-ms)
  +				 (split-timestring-date timestring junk-allowed
  +										now-year now-month now-day)))
  +		(t
  +		 (append (split-timestring-time (subseq timestring (1+ t-pos))
  +										junk-allowed
  +										now-hour now-minute now-second now-ms)
  +				 (split-timestring-date (subseq timestring 0 t-pos) junk-allowed
  +										now-year now-month now-day)))))))
   
   (defun parse-timestring (timestring &key (start 0) (end nil) (junk-allowed nil))
     "Parse a timestring and return the corresponding LOCAL-TIME"
     (declare (ignorable junk-allowed))
     (apply #'encode-local-time
  -         (split-timestring timestring
  -                           start
  -                           (or end (length timestring))
  -                           junk-allowed)))
  +		 (split-timestring timestring
  +						   start
  +						   (or end (length timestring))
  +						   junk-allowed)))
   
   (defun construct-timestring (local-time universal-p timezone-p
  -                                        date-elements time-elements date-separator
  -                                        time-separator internal-separator)
  +										date-elements time-elements date-separator
  +										time-separator internal-separator)
     (with-output-to-string (str)
  -                         (multiple-value-bind (usec sec minute hour day month year day-of-week daylight-p zone)
  -                             (decode-local-time local-time)
  -                           (declare (ignore day-of-week daylight-p))
  -                           (check-type date-elements (integer 0 3))
  -                           (check-type time-elements (integer 0 4))
  -                           (cond
  -                             ((> date-elements 2)
  -                              (format str "~:[~;-~]~4,'0d~c"
  -                                      (minusp year)
  -                                      (abs year)
  -                                      date-separator))
  -                             ((plusp date-elements)
  -                              ;; if the year is not shown, but other parts of the date are,
  -                              ;; the year is replaced with a hyphen
  -                              (princ "-" str)))
  -                           (when (> date-elements 1)
  -                             (format str "~2,'0d~c" month date-separator))
  -                           (when (> date-elements 0)
  -                             (format str "~2,'0d" day))
  -                           (when (and (plusp date-elements) (plusp time-elements))
  -                             (princ internal-separator str))
  -                           (when (> time-elements 0)
  -                             (format str "~2,'0d" hour))
  -                           (when (> time-elements 1)
  -                             (format str "~c~2,'0d" time-separator minute))
  -                           (when (> time-elements 2)
  -                             (format str "~c~2,'0d" time-separator sec))
  -                           (when (> time-elements 3)
  -                             (format str ".~6,'0d" usec))
  -                           (when timezone-p
  -                             (let* ((zone (if universal-p +utc-zone+ zone))
  -                                    (offset (local-timezone local-time zone)))
  -                               (format str "~2,'0@d:~2,'0d"
  -                                       (floor offset 3600)
  -                                       (abs (mod offset 3600))))))))
  +						 (multiple-value-bind (usec sec minute hour day month year day-of-week daylight-p zone)
  +							 (decode-local-time local-time)
  +						   (declare (ignore day-of-week daylight-p))
  +						   (check-type date-elements (integer 0 3))
  +						   (check-type time-elements (integer 0 4))
  +						   (cond
  +							 ((> date-elements 2)
  +							  (format str "~:[~;-~]~4,'0d~c"
  +									  (minusp year)
  +									  (abs year)
  +									  date-separator))
  +							 ((plusp date-elements)
  +							  ;; if the year is not shown, but other parts of the date are,
  +							  ;; the year is replaced with a hyphen
  +							  (princ "-" str)))
  +						   (when (> date-elements 1)
  +							 (format str "~2,'0d~c" month date-separator))
  +						   (when (> date-elements 0)
  +							 (format str "~2,'0d" day))
  +						   (when (and (plusp date-elements) (plusp time-elements))
  +							 (princ internal-separator str))
  +						   (when (> time-elements 0)
  +							 (format str "~2,'0d" hour))
  +						   (when (> time-elements 1)
  +							 (format str "~c~2,'0d" time-separator minute))
  +						   (when (> time-elements 2)
  +							 (format str "~c~2,'0d" time-separator sec))
  +						   (when (> time-elements 3)
  +							 (format str ".~6,'0d" usec))
  +						   (when timezone-p
  +							 (let* ((zone (if universal-p +utc-zone+ zone))
  +									(offset (local-timezone local-time zone)))
  +							   (format str "~2,'0@d:~2,'0d"
  +									   (floor offset 3600)
  +									   (abs (mod offset 3600))))))))
   
   (defun format-timestring (stream local-time universal-p timezone-p
  -                                 &optional date-elements time-elements
  -                                 date-separator time-separator internal-separator)
  +								 &optional date-elements time-elements
  +								 date-separator time-separator internal-separator)
     "Produces on stream the timestring corresponding to the LOCAL-TIME with the given options.  If STREAM is NIL, returns a string containing what would have been output.  If STREAM is T, prints the string to *standard-output*."
     (let ((str (construct-timestring local-time universal-p timezone-p
  -                                   (or date-elements 3)
  -                                   (or time-elements 4)
  -                                   (or date-separator #\-)
  -                                   (or time-separator #\:)
  -                                   (cond
  -                                     ((eql internal-separator 0) "")
  -                                     (internal-separator internal-separator)
  -                                     (t "T")))))
  -    (cond
  -      (stream
  -       (princ str stream)
  -       nil)
  -      (t
  -       str))))
  +								   (or date-elements 3)
  +								   (or time-elements 4)
  +								   (or date-separator #\-)
  +								   (or time-separator #\:)
  +								   (cond
  +									 ((eql internal-separator 0) "")
  +									 (internal-separator internal-separator)
  +									 (t "T")))))
  +	(cond
  +	  (stream
  +	   (princ str stream)
  +	   nil)
  +	  (t
  +	   str))))
   
   (defun universal-time (local-time)
     "Return the UNIVERSAL-TIME corresponding to the LOCAL-TIME"
     (multiple-value-bind (usec seconds minutes hours day month year)
  -      (decode-local-time local-time)
  -    (declare (ignore usec))
  -    (encode-universal-time seconds minutes hours day month year)))
  +	  (decode-local-time local-time)
  +	(declare (ignore usec))
  +	(encode-universal-time seconds minutes hours day month year)))
   
   (defun internal-time (local-time)
     "Return the internal system time corresponding to the LOCAL-TIME"
  
positive.code: (defmethod print-object ((object local-time) stream)
    "Print the LOCAL-TIME object using the standard reader notation"
    (when *print-escape*
      (princ "@" stream))
    (format-timestring stream object nil nil))
  
  (defmethod print-object ((object timezone) stream)
    "Print the TIMEZONE object in a reader-rejected manner."
    (format stream "#<TIMEZONE: ~:[UNLOADED~;~{~a~^ ~}~]>"
            (timezone-loaded object)
            (mapcar #'third (timezone-subzones object))))
negative.code: 		 (int-year (if (< month 3) (- year 2001) (- year 2000)))
  		 (zone (realize-timezone (or timezone *default-timezone*)))
  		 (result (make-local-time
  				  :usec us
  				  :sec (+ (* hh 3600) (* mm 60) ss)
  				  :day (+ (floor (* int-year 1461) 4)
                            (month-days int-month)
                            (1- day))
  				  :timezone zone)))
  	result
  	(local-time-adjust result zone result)))
  
  (defun local-time (&key (universal nil) (internal nil) (unix nil) (usec 0) (timezone nil))
    "Produce a LOCAL-TIME instance from the provided numeric time representation."
    (declare (ignorable internal))
    (cond
  	(universal
  	 (multiple-value-bind (sec minute hour date month year)
  		 (decode-universal-time universal)
  	   (encode-local-time usec sec minute hour date month year
  						  (realize-timezone (or timezone
  												*default-timezone*)))))
  	(internal
  	 ;; FIXME: How to portably convert between internal time?
  	 (error "Conversion of internal time not implemented"))
  	(unix
  	 (let* ((days (floor unix 86400))
  			(secs (- unix (* days 86400))))
  	   (make-local-time :day (- days 11017)
  						:sec secs
  						:usec usec
  						:timezone (realize-timezone
  								   (or timezone *default-timezone*)))))))
  
  (defun now ()
    (local-time :universal (get-universal-time)))
  