anchor.diff:                :element-type 'subzone
                 :initial-contents
                 (loop for info in raw-info collect
  -                       (make-subzone
  -                        :offset (first info)
  -                        :daylight-p (/= (second info) 0)
  -                        :abbrev (%string-from-unsigned-byte-vector abbrevs (third info))))))
  +                   (make-subzone
  +                    :offset (first info)
  +                    :daylight-p (/= (second info) 0)
  +                    :abbrev (%string-from-unsigned-byte-vector abbrevs (third info))))))
   
   (defun %realize-timezone (zone &optional reload)
     "If timezone has not already been loaded or RELOAD is non-NIL, loads the timezone information from its associated unix file.  If the file is not a valid timezone file, the condition INVALID-TIMEZONE-FILE will be signaled."
  
positive.code: 
  (defun %tz-read-header (inf)
    `(:utc-count ,(%read-binary-integer inf 4)
      :wall-count ,(%read-binary-integer inf 4)
      :leap-count ,(%read-binary-integer inf 4)
      :transition-count ,(%read-binary-integer inf 4)
      :type-count ,(%read-binary-integer inf 4)
      :abbrev-length ,(%read-binary-integer inf 4)))
  
  (defun %tz-read-transitions (inf count)
    (make-array count
                :initial-contents
                (loop for idx from 1 upto count
                      collect (%read-binary-integer inf 4 t))))
  
  (defun %tz-read-indexes (inf count)
    (make-array count
                :initial-contents
                (loop for idx from 1 upto count
                      collect (%read-binary-integer inf 1))))
  
  (defun %tz-read-subzone (inf count)
    (loop for idx from 1 upto count
          collect (list (%read-binary-integer inf 4 t)
                        (%read-binary-integer inf 1)
                        (%read-binary-integer inf 1))))
  
  (defun %tz-read-leap-seconds (inf count)
    (loop for idx from 1 upto count
          collect (list (%read-binary-integer inf 4)
                        (%read-binary-integer inf 4))))
  
  (defun %tz-read-abbrevs (inf length)
    (let ((a (make-array length :element-type '(unsigned-byte 8))))
  
negative.code:   (apply #'%split-timestring (coerce str 'simple-string) args))
  
  (defun %split-timestring (time-string &key
                            (start 0)
                            (end (length time-string))
                            (fail-on-error t) (time-separator #\:)
                            (date-separator #\-)
                            (date-time-separator #\T)
                            (allow-missing-elements t)
                            (allow-missing-date-part allow-missing-elements)
                            (allow-missing-time-part allow-missing-elements)
                            (allow-missing-timezone-part allow-missing-time-part))
    "Based on http://www.ietf.org/rfc/rfc3339.txt including the function names used. Returns (values year month day hour minute second nsec offset-hour offset-minute). On parsing failure, signals INVALID-TIMESTRING if FAIL-ON-ERROR is NIL, otherwise returns NIL."
    (declare (type character date-time-separator time-separator date-separator)
             (type simple-string time-string)
             (optimize (speed 3)))
    (the list
      (let (year month day hour minute second nsec offset-hour offset-minute)
        (declare (type (or null fixnum) start end year month day hour minute second offset-hour offset-minute)
                 (type (or null (signed-byte 32)) nsec))
        (macrolet ((passert (expression)
                     `(unless ,expression
                       (parse-error ',expression)))
                   (parse-integer-into (start-end place &optional low-limit high-limit)
                     (let ((entry (gensym "ENTRY"))
                           (value (gensym "VALUE"))
                           (pos (gensym "POS"))
                           (start (gensym "START"))
                           (end (gensym "END")))
                       `(let ((,entry ,start-end))
                         (if ,entry
                             (let ((,start (car ,entry))
                                   (,end (cdr ,entry)))
                               (multiple-value-bind (,value ,pos) (parse-integer time-string :start ,start :end ,end :junk-allowed t)
                                 (passert (= ,pos ,end))
                                 (setf ,place ,value)
                                 ,(if (and low-limit high-limit)
                                      `(passert (<= ,low-limit ,place ,high-limit))
                                      (values))
                                 (values)))
                             (progn
                               (passert allow-missing-elements)
                               (values))))))
                   (with-parts-and-count ((start end split-chars) &body body)
                     `(multiple-value-bind (parts count) (split ,start ,end ,split-chars)
                       (declare (ignorable count) (type fixnum count)
                        ;;(type #1=(cons (cons fixnum fixnum) (or null #1#)) parts)
                        (type list parts))
                       ,@body)))
          (labels ((split (start end chars)
                     (declare (type fixnum start end))
                     (unless (consp chars)
                       (setf chars (list chars)))
                     (loop with last-match = start
                           with match-count of-type (integer 0 #.most-positive-fixnum) = 0
                           for index of-type fixnum upfrom start
                           while (< index end)
                           when (member (aref time-string index) chars :test #'char-equal)
                           collect (prog1 (if (< last-match index)
                                              (cons last-match index)
                                              nil)
                                     (incf match-count)
                                     (setf last-match (1+ index)))
                                   into result
                           finally (return (values (if (zerop (- index last-match))
                                                       result
                                                       (prog1
                                                           (nconc result (list (cons last-match index)))
                                                         (incf match-count)))
                                                   match-count))))
                   (parse ()
                     (with-parts-and-count (start end date-time-separator)
                       (cond ((= count 2)
                              (if (first parts)
                                  (full-date (first parts))
                                  (passert allow-missing-date-part))
                              (if (second parts)
                                  (full-time (second parts))
                                  (passert allow-missing-time-part))
                              (done))
                             ((and (= count 1)
                                   allow-missing-date-part
                                   (find time-separator time-string
                                         :start (car (first parts))
                                         :end (cdr (first parts))))
                              (full-time (first parts))
                              (done))
                             ((and (= count 1)
                                   allow-missing-time-part
                                   (find date-separator time-string
                                         :start (car (first parts))
                                         :end (cdr (first parts))))
                              (full-date (first parts))
                              (done)))
                       (parse-error nil)))
                   (full-date (start-end)
                     (let ((parts (split (car start-end) (cdr start-end) date-separator)))
                       (passert (%list-length= 3 parts))
                       (date-fullyear (first parts))
                       (date-month (second parts))
                       (date-mday (third parts))))
                   (date-fullyear (start-end)
                     (parse-integer-into start-end year))
                   (date-month (start-end)
                     (parse-integer-into start-end month 1 12))
                   (date-mday (start-end)
                     (parse-integer-into start-end day 1 31))
                   (full-time (start-end)
                     (let ((start (car start-end))
                           (end (cdr start-end)))
                       (with-parts-and-count (start end (list #\Z #\- #\+))
                         (let* ((zulup (find #\Z time-string :test #'char-equal :start start :end end))
                                (sign (unless zulup
                                        (if (find #\+ time-string :test #'char-equal :start start :end end)
                                            1
                                            -1))))
                           (passert (<= 1 count 2))
                           (unless (and (eq (first parts) nil)
                                        (not (rest parts)))
                             ;; not a single #\Z
                             (partial-time (first parts)))
                           (when zulup
                             (setf offset-hour 0
                                   offset-minute 0))
                           (if (= count 1)
                               (passert (or zulup allow-missing-timezone-part))
                               (let* ((entry (second parts))
                                      (start (car entry))
                                      (end (cdr entry)))
                                 (declare (type fixnum start end))
                                 (passert (or zulup
                                              (not (zerop (- end start)))))
                                 (unless zulup
                                   (time-offset (second parts) sign))))))))
                   (partial-time (start-end)
                     (with-parts-and-count ((car start-end) (cdr start-end) time-separator)
                       (passert (eql count 3))
                       (time-hour (first parts))
                       (time-minute (second parts))
                       (time-second (third parts))))
                   (time-hour (start-end)
                     (parse-integer-into start-end hour 0 23))
                   (time-minute (start-end)
                     (parse-integer-into start-end minute 0 59))
                   (time-second (start-end)
                     (with-parts-and-count ((car start-end) (cdr start-end) '(#\. #\,))
                       (passert (<= 1 count 2))
                       (let ((*read-eval* nil))
                         (parse-integer-into (first parts) second 0 59)
                         (if (> count 1)
                             (let* ((start (car (second parts)))
                                    (end (cdr (second parts))))
                               (declare (type (integer 0 #.array-dimension-limit) start end))
                               (passert (<= (- end start) 9))
                               (let ((new-end (position #\0 time-string
                                                        :test-not #'eql
                                                        :start start
                                                        :end end
                                                        :from-end t)))
                                 (when new-end
                                   (setf end (min (1+ new-end)))))
                               (setf nsec (* (the (integer 0 999999999) (parse-integer time-string :start start :end end))
                                             (aref #.(coerce #(1000000000 100000000 10000000
                                                               1000000 100000 10000 1000 100 10 1)
                                                             '(simple-array (signed-byte 32) (10)))
                                                   (- end start)))))
                             (setf nsec 0)))))
                   (time-offset (start-end sign)
                     (with-parts-and-count ((car start-end) (cdr start-end) time-separator)
                       (passert (or (and allow-missing-timezone-part (zerop count))
                                    (= count 1)
                                    (= count 2)))
  
                       (cond
                         ((= count 2)
                          ;; hh:mm offset
                          (parse-integer-into (first parts) offset-hour 0 23)
                          (parse-integer-into (second parts) offset-minute 0 59))
                         ((= (- (cdar parts) (caar parts)) 4)
                          ;; hhmm offset
                          (parse-integer-into (cons (caar parts)
                                                    (+ (caar parts) 2))
                                              offset-hour 0 23)
                          (parse-integer-into (cons (+ (caar parts) 2)
                                                    (+ (caar parts) 4))
                                              offset-minute 0 59))
                         ((= (- (cdar parts) (caar parts)) 2)
                          ;; hh offset
                          (parse-integer-into (cons (caar parts)
                                                    (+ (caar parts) 2))
                                              offset-hour 0 23)
                          (setf offset-minute 0)))
  
                       (setf offset-hour (* offset-hour sign)
                             offset-minute (* offset-minute sign))))
                   (parse-error (failure)
                     (if fail-on-error
                         (error 'invalid-timestring :timestring time-string :failure failure)
                         (return-from %split-timestring nil)))
                   (done ()
                     (return-from %split-timestring (list year month day hour minute second nsec offset-hour offset-minute))))
            (parse))))))
  
  (defun parse-rfc3339-timestring (timestring &key (fail-on-error t)
                                              (allow-missing-time-part nil))
    (parse-timestring timestring :fail-on-error fail-on-error
                      :allow-missing-timezone-part nil
                      :allow-missing-time-part allow-missing-time-part
                      :allow-missing-date-part nil))
  
  (defun parse-timestring (timestring &key
                           start
                           end
                           (fail-on-error t)
                           (time-separator #\:)
                           (date-separator #\-)
                           (date-time-separator #\T)
                           (allow-missing-elements t)
                           (allow-missing-date-part allow-missing-elements)
                           (allow-missing-time-part allow-missing-elements)
                           (allow-missing-timezone-part allow-missing-elements)
                           (offset 0))
    "Parse a timestring and return the corresponding TIMESTAMP. See split-timestring for details. Unspecified fields in the timestring are initialized to their lowest possible value, and timezone offset is 0 (UTC) unless explicitly specified in the input string."
    (let ((parts (%split-timestring (coerce timestring 'simple-string)
                                    :start (or start 0)
  