;;; Internal variables
 
+(defvar article-lapsed-timer nil)
+
 (defvar gnus-article-mode-syntax-table
   (let ((table (copy-syntax-table text-mode-syntax-table)))
     (modify-syntax-entry ?- "w" table)
                  (setq bface (get-text-property (gnus-point-at-bol) 'face)
                        eface (get-text-property (1- (gnus-point-at-eol))
                                                 'face))
-                 (message-remove-header date-regexp t)
+                 (delete-region (progn (beginning-of-line) (point))
+                                (progn (end-of-line) (point)))
                  (beginning-of-line))
              (goto-char (point-max)))
            (insert (article-make-date-line date type))
            ;; Do highlighting.
-           (forward-line -1)
+           (beginning-of-line)
            (when (looking-at "\\([^:]+\\): *\\(.*\\)$")
-             (put-text-property (match-beginning 1) (match-end 1)
+             (put-text-property (match-beginning 1) (1+ (match-end 1))
                                 'face bface)
              (put-text-property (match-beginning 2) (match-end 2)
                                 'face eface))))))))
    ((eq type 'local)
     (concat "Date: " (condition-case ()
                         (timezone-make-date-arpa-standard date)
-                      (error date))
-           "\n"))
+                      (error date))))
    ;; Convert to Universal Time.
    ((eq type 'ut)
     (concat "Date: "
            (condition-case ()
                (timezone-make-date-arpa-standard date nil "UT")
-             (error date))
-           "\n"))
+             (error date))))
    ;; Get the original date from the article.
    ((eq type 'original)
-    (concat "Date: " date "\n"))
+    (concat "Date: " date))
    ;; Let the user define the format.
    ((eq type 'user)
     (concat
                         (ignore-errors
                           (gnus-encode-date
                            (timezone-make-date-arpa-standard
-                            date nil "UT"))))
-     "\n"))
+                            date nil "UT"))))))
    ;; Do an X-Sent lapsed format.
    ((eq type 'lapsed)
     ;; If the date is seriously mangled, the timezone functions are
         ;; If dates are odd, then it might appear like the
         ;; article was sent in the future.
         (if (> real-sec 0)
-            " ago\n"
-          " in the future\n"))))))
+            " ago"
+          " in the future"))))))
    (t
     (error "Unknown conversion type: %s" type))))
 
   (interactive (list t))
   (article-date-ut 'lapsed highlight))
 
+(defun article-update-date-lapsed ()
+  "Function to be run from a timer to update the lapsed time line."
+  (save-excursion
+    (when (gnus-buffer-live-p gnus-article-buffer)
+      (set-buffer gnus-article-buffer)
+      (goto-char (point-min))
+      (when (re-search-forward "^X-Sent:" nil t)
+       (article-date-lapsed t)))))
+
+(defun gnus-start-date-timer ()
+  "Start a timer to update the X-Sent header in the article buffers."
+  (interactive)
+  (gnus-stop-date-timer)
+  (setq article-lapsed-timer 
+       (nnheader-run-at-time 1 1 'article-update-date-lapsed)))
+
+(defun gnus-stop-date-timer ()
+  "Stop the X-Sent timer."
+  (interactive)
+  (when article-lapsed-timer
+    (nnheader-delete-timer article-lapsed-timer)
+    (setq article-lapsed-timer nil)))
+
 (defun article-date-user (&optional highlight)
   "Convert the current article date to the user-defined format.
 This format is defined by the `gnus-article-time-format' variable."
 
 ;;; Internal Variables:
 
 (defvar gnus-cite-article nil)
+(defvar gnus-cite-overlay-list nil)
 
 (defvar gnus-cite-prefix-alist nil)
 ;; Alist of citation prefixes.
          gnus-cite-attribution-alist nil
          gnus-cite-loose-prefix-alist nil
          gnus-cite-loose-attribution-alist nil)
+    (while gnus-cite-overlay-list
+      (gnus-delete-overlay (pop gnus-cite-overlay-list)))
     ;; Parse if not too large.
     (if (and (not force)
             gnus-cite-parse-max-size
     (let ((inhibit-point-motion-hooks t)
          from to)
       (goto-line number)
-      (unless (eobp);; Sometimes things become confused.
+      (unless (eobp)                   ; Sometimes things become confused.
        (forward-char (length prefix))
        (skip-chars-forward " \t")
        (setq from (point))
        (skip-chars-backward " \t")
        (setq to (point))
        (when (< from to)
-         (gnus-overlay-put (gnus-make-overlay from to) 'face face))))))
+         (push (setq overlay (gnus-make-overlay from to))
+               gnus-cite-overlay-list)
+         (gnus-overlay-put overlay 'face face))))))
 
 (defun gnus-cite-toggle (prefix)
   (save-excursion
 
 
 If nil, no groups are permanently visible."
   :group 'gnus-group-listing
-  :type '(choice regexp (const nil)))
+  :type 'regexp)
 
 (defcustom gnus-list-groups-with-ticked-articles t
   "*If non-nil, list groups that have only ticked articles.
 
 Return the name of the group is selection was successful."
   ;; Transform the select method into a unique server.
+  (when (stringp method)
+    (setq method (gnus-server-to-method method)))
   (let ((saddr (intern (format "%s-address" (car method)))))
     (setq method (gnus-copy-sequence method))
     (require (car method))
 
   :group 'gnus-visual)
 
 (defcustom gnus-picons-display-where 'picons
-  "Where to display the group and article icons.
+  "*Where to display the group and article icons.
 Legal values are `article' and `picons'."
   :type '(choice symbol string)
   :group 'picons)
 
 (defcustom gnus-picons-has-modeline-p t
-  "Wether the picons window should have a modeline.
+  "*Wether the picons window should have a modeline.
 This is only useful if `gnus-picons-display-where' is `picons'."
   :type 'boolean
   :group 'picons)
 
 (defcustom gnus-picons-database "/usr/local/faces"
-  "Defines the location of the faces database.
+  "*Defines the location of the faces database.
 For information on obtaining this database of pretty pictures, please
 see http://www.cs.indiana.edu/picons/ftp/index.html"
   :type 'directory
   :group 'picons)
 
 (defcustom gnus-picons-news-directories '("news")
-  "Sub-directory of the faces database containing the icons for newsgroups."
+  "*Sub-directory of the faces database containing the icons for newsgroups."
   :type '(repeat string)
   :group 'picons)
 (define-obsolete-variable-alias 'gnus-picons-news-directory
   'gnus-picons-news-directories)
 
 (defcustom gnus-picons-user-directories '("local" "users" "usenix" "misc")
-  "List of directories to search for user faces."
+  "*List of directories to search for user faces."
   :type '(repeat string)
   :group 'picons)
 
 (defcustom gnus-picons-domain-directories '("domains")
-  "List of directories to search for domain faces.
+  "*List of directories to search for domain faces.
 Some people may want to add \"unknown\" to this list."
   :type '(repeat string)
   :group 'picons)
 
 (defcustom gnus-picons-refresh-before-display nil
-  "If non-nil, display the article buffer before computing the picons."
+  "*If non-nil, display the article buffer before computing the picons."
   :type 'boolean
   :group 'picons)
 
 
 (defcustom gnus-picons-x-face-file-name
   (format "/tmp/picon-xface.%s.xbm" (user-login-name))
-  "The name of the file in which to store the converted X-face header."
+  "*The name of the file in which to store the converted X-face header."
   :type 'string
   :group 'picons)
 
 (defcustom gnus-picons-convert-x-face (format "{ echo '/* Width=48, Height=48 */'; uncompface; } | icontopbm | pbmtoxbm > %s" gnus-picons-x-face-file-name)
-  "Command to convert the x-face header into a xbm file."
+  "*Command to convert the x-face header into a xbm file."
   :type 'string
   :group 'picons)
 
       (when (featurep 'xpm)
        (push "xpm" types))
       types))
-  "List of suffixes on picon file names to try."
+  "*List of suffixes on picon file names to try."
   :type '(repeat string)
   :group 'picons)
 
 (defun gnus-picons-x-face-sentinel (process event)
   (let* ((env (assq process gnus-picons-processes-alist))
         (annot (cdr env)))
-    (setq gnus-picons-processes-alist (remassq process
-                                              gnus-picons-processes-alist))
+    (setq gnus-picons-processes-alist
+         (remassq process gnus-picons-processes-alist))
     (when annot
       (set-annotation-glyph annot
                            (make-glyph gnus-picons-x-face-file-name))
 
   (interactive (list (gnus-server-server-name)))
   (let ((buf (current-buffer)))
     (prog1
-       (gnus-browse-foreign-server (gnus-server-to-method server) buf)
+       (gnus-browse-foreign-server server buf)
       (save-excursion
        (set-buffer buf)
        (gnus-server-update-server (gnus-server-server-name))
 
 (defvar gnus-browse-buffer "*Gnus Browse Server*")
 
-(defun gnus-browse-foreign-server (method &optional return-buffer)
-  "Browse the server METHOD."
-  (setq gnus-browse-current-method method)
+(defun gnus-browse-foreign-server (server &optional return-buffer)
+  "Browse the server SERVER."
+  (setq gnus-browse-current-method server)
   (setq gnus-browse-return-buffer return-buffer)
-  (when (stringp method)
-    (setq method (gnus-server-to-method method)))
-  (let ((gnus-select-method method)
-       groups group)
+  (let* ((method (gnus-server-to-method server))
+        (gnus-select-method method)
+        groups group)
     (gnus-message 5 "Connecting to %s..." (nth 1 method))
     (cond
      ((not (gnus-check-server method))
          (progn
            (gnus-group-change-level
             (list t group gnus-level-default-subscribed
-                  nil nil gnus-browse-current-method)
+                  nil nil (if (gnus-server-equal
+                               gnus-browse-current-method "native")
+                              nil
+                            gnus-browse-current-method))
             gnus-level-default-subscribed gnus-level-killed
             (and (car (nth 1 gnus-newsrc-alist))
                  (gnus-gethash (car (nth 1 gnus-newsrc-alist))
 
                    (mail-header-set-id header id))
                (setcar (symbol-value id-dep) header))
            (set id-dep (list header)))
-         (when  header
+         (when header
            (if (boundp (setq ref-dep (intern (or ref "none") dependencies)))
                (setcdr (symbol-value ref-dep)
                        (nconc (cdr (symbol-value ref-dep))
       (gnus-summary-position-point))))
 
 (defun gnus-summary-limit-include-dormant ()
-  "Display all the hidden articles that are marked as dormant."
+  "Display all the hidden articles that are marked as dormant.
+Note that this command only works on a subset of the articles currently
+fetched for this group."
   (interactive)
   (unless gnus-newsgroup-dormant
     (error "There are no dormant articles in this group"))
                        (gnus-summary-article-sparse-p
                         (mail-header-number header))
                        (memq (mail-header-number header)
-                             gnus-newsgroup-limit))))
-      (if (and header
-              (or (not (gnus-summary-article-sparse-p
-                        (mail-header-number header)))
-                  sparse))
-         (prog1
-              ;; The article is present in the buffer, so we just go to it.
-             (gnus-summary-goto-article
-               (mail-header-number header) nil t)
-           (when sparse
-             (gnus-summary-update-article (mail-header-number header))))
+                             gnus-newsgroup-limit)))
+          h)
+      (cond
+       ;; If the article is present in the buffer we just go to it.
+       ((and header
+            (or (not (gnus-summary-article-sparse-p
+                      (mail-header-number header)))
+                sparse))
+       (prog1
+           (gnus-summary-goto-article
+            (mail-header-number header) nil t)
+         (when sparse
+           (gnus-summary-update-article (mail-header-number header)))))
+       (t
        ;; We fetch the article
        (let ((gnus-override-method
               (cond ((gnus-news-group-p gnus-newsgroup-name)
          ;; Fetch the header, and display the article.
          (if (setq number (gnus-summary-insert-subject message-id))
              (gnus-summary-select-article nil nil nil number)
-           (gnus-message 3 "Couldn't fetch article %s" message-id)))))))
+           (gnus-message 3 "Couldn't fetch article %s" message-id))))))))
 
 (defun gnus-summary-enter-digest-group (&optional force)
   "Enter an nndoc group based on the current article.
   "Mark the current article quickly as unread with MARK."
   (let ((article (gnus-summary-article-number)))
     (if (<= article 0)
-       (gnus-error 1 "Can't mark negative article numbers")
+       (progn
+         (gnus-error 1 "Can't mark negative article numbers")
+         nil)
       (setq gnus-newsgroup-marked (delq article gnus-newsgroup-marked))
       (setq gnus-newsgroup-dormant (delq article gnus-newsgroup-dormant))
       (setq gnus-newsgroup-expirable (delq article gnus-newsgroup-expirable))
              (= mark gnus-dormant-mark) (= mark gnus-unread-mark))))
 
       ;; Fix the mark.
-      (gnus-summary-update-mark mark 'unread))
-    t))
+      (gnus-summary-update-mark mark 'unread)
+      t)))
 
 (defun gnus-summary-mark-article (&optional article mark no-expire)
   "Mark ARTICLE with MARK.  MARK can be any character.
         (article (or article (gnus-summary-article-number))))
     (unless article
       (error "No article on current line"))
-    (if (or (= mark gnus-unread-mark)
-           (= mark gnus-ticked-mark)
-           (= mark gnus-dormant-mark))
-       (gnus-mark-article-as-unread article mark)
-      (gnus-mark-article-as-read article mark))
-
-    ;; See whether the article is to be put in the cache.
-    (and gnus-use-cache
-        (not (= mark gnus-canceled-mark))
-        (vectorp (gnus-summary-article-header article))
-        (save-excursion
-          (gnus-cache-possibly-enter-article
-           gnus-newsgroup-name article
-           (gnus-summary-article-header article)
-           (= mark gnus-ticked-mark)
-           (= mark gnus-dormant-mark) (= mark gnus-unread-mark))))
+    (if (not (if (or (= mark gnus-unread-mark)
+                    (= mark gnus-ticked-mark)
+                    (= mark gnus-dormant-mark))
+                (gnus-mark-article-as-unread article mark)
+              (gnus-mark-article-as-read article mark)))
+       t
+      ;; See whether the article is to be put in the cache.
+      (and gnus-use-cache
+          (not (= mark gnus-canceled-mark))
+          (vectorp (gnus-summary-article-header article))
+          (save-excursion
+            (gnus-cache-possibly-enter-article
+             gnus-newsgroup-name article
+             (gnus-summary-article-header article)
+             (= mark gnus-ticked-mark)
+             (= mark gnus-dormant-mark) (= mark gnus-unread-mark))))
 
-    (when (gnus-summary-goto-subject article nil t)
-      (let ((buffer-read-only nil))
-       (gnus-summary-show-thread)
-       ;; Fix the mark.
-       (gnus-summary-update-mark mark 'unread)
-       t))))
+      (when (gnus-summary-goto-subject article nil t)
+       (let ((buffer-read-only nil))
+         (gnus-summary-show-thread)
+         ;; Fix the mark.
+         (gnus-summary-update-mark mark 'unread)
+         t)))))
 
 (defun gnus-summary-update-secondary-mark (article)
   "Update the secondary (read, process, cache) mark."
 (defun gnus-mark-article-as-unread (article &optional mark)
   "Enter ARTICLE in the pertinent lists and remove it from others."
   (let ((mark (or mark gnus-ticked-mark)))
-    (setq gnus-newsgroup-marked (delq article gnus-newsgroup-marked)
-         gnus-newsgroup-dormant (delq article gnus-newsgroup-dormant)
-         gnus-newsgroup-expirable (delq article gnus-newsgroup-expirable)
-         gnus-newsgroup-unreads (delq article gnus-newsgroup-unreads))
-
     (if (<= article 0)
        (progn
          (gnus-error 1 "Can't mark negative article numbers")
          nil)
+      (setq gnus-newsgroup-marked (delq article gnus-newsgroup-marked)
+           gnus-newsgroup-dormant (delq article gnus-newsgroup-dormant)
+           gnus-newsgroup-expirable (delq article gnus-newsgroup-expirable)
+           gnus-newsgroup-unreads (delq article gnus-newsgroup-unreads))
+
       ;; Unsuppress duplicates?
       (when gnus-suppress-duplicates
        (gnus-dup-unsuppress-article article))
             (not (gnus-summary-article-sparse-p (mail-header-number header))))
        ;; We have found the header.
        header
+      ;; If this is a sparse article, we have to nix out its
+      ;; previous entry in the thread hashtb.
+      (when (and header
+                (gnus-summary-article-sparse-p (mail-header-number header)))
+       (let ((thread (gnus-gethash
+                      (gnus-parent-id (mail-header-references header))
+                      gnus-newsgroup-dependencies)))
+         (delq (assq header thread) thread)))
       ;; We have to really fetch the header to this article.
       (save-excursion
        (set-buffer nntp-server-buffer)
 
 (defun gnus-uu-grab-articles (articles process-function
                                       &optional sloppy limit no-errors)
   (let ((state 'first)
+       (gnus-asynchronous nil)
        has-been-begin article result-file result-files process-state
        gnus-summary-display-article-function
        gnus-article-display-hook gnus-article-prepare-hook
 
     (fset 'gnus-characterp 'characterp)))
 
   (fset 'gnus-make-overlay 'make-extent)
+  (fset 'gnus-delete-overlay 'delete-extent)
   (fset 'gnus-overlay-put 'set-extent-property)
   (fset 'gnus-move-overlay 'gnus-xmas-move-overlay)
   (fset 'gnus-overlay-end 'extent-end-position)
 
   :link '(custom-manual "(gnus)Exiting Gnus")
   :group 'gnus)
 
-(defconst gnus-version-number "0.15"
+(defconst gnus-version-number "0.16"
   "Version number for this version of Gnus.")
 
 (defconst gnus-version (format "Quassia Gnus v%s" gnus-version-number)
 
 (unless (featurep 'gnus-xmas)
   (defalias 'gnus-make-overlay 'make-overlay)
+  (defalias 'gnus-delete-overlay 'delete-overlay)
   (defalias 'gnus-overlay-put 'overlay-put)
   (defalias 'gnus-move-overlay 'move-overlay)
   (defalias 'gnus-overlay-end 'overlay-end)
       gnus-article-date-original gnus-article-date-lapsed
       gnus-article-show-all-headers
       gnus-article-edit-mode gnus-article-edit-article
-      gnus-article-edit-done gnus-decode-rfc1522 article-decode-rfc1522)
+      gnus-article-edit-done gnus-decode-rfc1522 article-decode-rfc1522
+      gnus-start-date-timer gnus-stop-date-timer)
      ("gnus-int" gnus-request-type)
      ("gnus-start" gnus-newsrc-parse-options gnus-1 gnus-no-server-1
       gnus-dribble-enter)
 (defun gnus-group-prefixed-name (group method)
   "Return the whole name from GROUP and METHOD."
   (and (stringp method) (setq method (gnus-server-to-method method)))
-  (if (not method)
+  (if (or (not method)
+         (gnus-server-equal method "native"))
       group
     (concat (format "%s" (car method))
            (when (and
 
   :group 'message-headers
   :type 'regexp)
 
-(defcustom message-ignored-supersedes-headers "^Path:\\|^Date\\|^NNTP-Posting-Host:\\|^Xref:\\|^Lines:\\|^Received:\\|^X-From-Line:\\||X-Trace:\\|X-Complaints-To:\\|Return-Path:\\|^Supersedes:"
+(defcustom message-ignored-supersedes-headers "^Path:\\|^Date\\|^NNTP-Posting-Host:\\|^Xref:\\|^Lines:\\|^Received:\\|^X-From-Line:\\|X-Trace:\\|X-Complaints-To:\\|Return-Path:\\|^Supersedes:"
   "*Header lines matching this regexp will be deleted before posting.
 It's best to delete old Path and Date headers before posting to avoid
 any confusion."
   ;; Remove empty lines in the header.
   (save-restriction
     (message-narrow-to-headers)
+    ;; Remove blank lines.
     (while (re-search-forward "^[ \t]*\n" nil t)
-      (replace-match "" t t)))
+      (replace-match "" t t))
 
-  ;; Correct Newsgroups and Followup-To headers: change sequence of
-  ;; spaces to comma and eliminate spaces around commas.  Eliminate
-  ;; embedded line breaks.
-  (goto-char (point-min))
-  (while (re-search-forward "^\\(Newsgroups\\|Followup-To\\): +" nil t)
-    (save-restriction
-      (narrow-to-region
-       (point)
-       (if (re-search-forward "^[^ \t]" nil t)
-          (match-beginning 0)
-        (forward-line 1)
-        (point)))
-      (goto-char (point-min))
-      (while (re-search-forward "\n[ \t]+" nil t)
-       (replace-match " " t t))        ;No line breaks (too confusing)
-      (goto-char (point-min))
-      (while (re-search-forward "[ \t\n]*,[ \t\n]*\\|[ \t]+" nil t)
-       (replace-match "," t t))
-      (goto-char (point-min))
-      ;; Remove trailing commas.
-      (when (re-search-forward ",+$" nil t)
-       (replace-match "" t t)))))
+    ;; Correct Newsgroups and Followup-To headers:  Change sequence of
+    ;; spaces to comma and eliminate spaces around commas.  Eliminate
+    ;; embedded line breaks.
+    (goto-char (point-min))
+    (while (re-search-forward "^\\(Newsgroups\\|Followup-To\\): +" nil t)
+      (save-restriction
+       (narrow-to-region
+        (point)
+        (if (re-search-forward "^[^ \t]" nil t)
+            (match-beginning 0)
+          (forward-line 1)
+          (point)))
+       (goto-char (point-min))
+       (while (re-search-forward "\n[ \t]+" nil t)
+         (replace-match " " t t))      ;No line breaks (too confusing)
+       (goto-char (point-min))
+       (while (re-search-forward "[ \t\n]*,[ \t\n]*\\|[ \t]+" nil t)
+         (replace-match "," t t))
+       (goto-char (point-min))
+       ;; Remove trailing commas.
+       (when (re-search-forward ",+$" nil t)
+         (replace-match "" t t))))))
 
 (defun message-make-date ()
   "Make a valid data header."
 
      (progn
        (forward-line 1)
        (if (nnmail-search-unix-mail-delim)
-          (if (and (not (bobp)) leave-delim)
-              (progn (forward-line -2) (point))
-            (point))
+          (point)
         (point-max))))))
 
 (defun nnfolder-possibly-change-group (group &optional server dont-check)
 
       (pop files))
     (nreverse out)))
 
+(defun nnheader-directory-files (&rest args)
+  "Same as `directory-files', but prune \".\" and \"..\"."
+  (let ((files (apply 'directory-files args))
+       out)
+    (while files
+      (unless (member (file-name-nondirectory (car files)) '("." ".."))
+       (push (car files) out))
+      (pop files))
+    (nreverse out)))
+
 (defmacro nnheader-skeleton-replace (from &optional to regexp)
   `(let ((new (generate-new-buffer " *nnheader replace*"))
         (cur (current-buffer))
 
 
 (deffoo nnmh-request-list (&optional server dir)
   (nnheader-insert "")
+  (nnmh-possibly-change-directory nil server)
   (let ((pathname-coding-system 'binary)
        (nnmh-toplev
         (file-truename (or dir (file-name-as-directory nnmh-directory)))))
   ;; Recurse down all directories.
   (let ((dirs (and (file-readable-p dir)
                   (> (nth 1 (file-attributes (file-chase-links dir))) 2)
-                  (directory-files dir t nil t)))
+                  (nnheader-directory-files dir t nil t)))
        rdir)
     ;; Recurse down directories.
     (while (setq rdir (pop dirs))
-      (when (and (not (member (file-name-nondirectory rdir) '("." "..")))
-                (file-directory-p rdir)
+      (when (and (file-directory-p rdir)
                 (file-readable-p rdir)
-                (equal (file-truename rdir)
-                       (file-truename dir)))
+                (not (equal (file-truename rdir)
+                            (file-truename dir))))
        (nnmh-request-list-1 rdir))))
   ;; For each directory, generate an active file line.
   (unless (string= (expand-file-name nnmh-toplev) dir)
 
      (search . nnweb-dejanews-search)
      (address . "http://xp9.dejanews.com/dnquery.xp")
      (identifier . nnweb-dejanews-identity))
+    (dejanewsold
+     (article . nnweb-dejanews-wash-article)
+     (map . nnweb-dejanews-create-mapping)
+     (search . nnweb-dejanewsold-search)
+     (address . "http://xp9.dejanews.com/dnquery.xp")
+     (identifier . nnweb-dejanews-identity))
     (reference
      (article . nnweb-reference-wash-article)
      (map . nnweb-reference-create-mapping)
 
 
 most: texi2latex.elc latex latexps
 
-gnus: gnus.texi
-       $(MAKEINFO) -eval '(find-file "gnus.texi")' $(XINFOSWI)
+.SUFFIXES: .texi .dvi .ps
 
-message: message.texi
-       $(MAKEINFO) -eval '(find-file "message.texi")' $(XINFOSWI)
+.texi:
+       $(MAKEINFO) -eval '(find-file "$<")' $(XINFOSWI)
 
 dvi: gnus.dvi message.dvi
 
 refcard.dvi: refcard.tex gnuslogo.refcard gnusref.tex
        $(LATEX) refcard.tex
 
-sclean:
+clean:
        rm -f gnus.*.bak *.ky *.cp *.fn *.cps *.kys *.log *.aux *.dvi *.vr \
-       *.tp *.toc \
-       *.pg gnus.latexi *.aux *.[cgk]idx \
+       *.tp *.toc *.pg gnus.latexi *.aux *.[cgk]idx \
        gnus.ilg gnus.ind gnus.[cgk]ind gnus.idx \
-       gnus.tmptexi gnus.tmplatexi gnus.tmplatexi1 texput.log *.orig *.rej \
-       gnus.latexi*~*
-
-clean:
-       make sclean 
-       rm -f *.latexi 
-       rm tmp/*.ps
+       gnus.tmptexi *.tmplatexi gnus.tmplatexi1 texput.log *.orig *.rej \
+       gnus.latexi*~* tmp/*.ps xface.tex picons.tex smiley.tex *.latexi
 
 makeinfo: 
        makeinfo -o gnus gnus.texi      
        makeinfo -o message message.texi        
 
 texi2latex.elc: texi2latex.el
-       $(EMACS) -batch -l bytecomp -f batch-byte-recompile-directory
+       $(EMACS) -batch -l bytecomp --eval '(byte-compile-file "texi2latex.el")'
 
-latex: gnus.texi
+latex: gnus.texi texi2latex.elc
        $(EMACS) -batch -q -no-site-file gnus.texi -l ./texi2latex.elc -f latexi-translate
 
 latexps: 
        make texi2latex.elc
+       rm -f gnus.aux
        egrep -v "label.*Index|chapter.*Index" gnus.latexi > gnus.tmplatexi1
        $(LATEX) gnus.tmplatexi1
-       splitindex
+       ./splitindex
        makeindex -o gnus.kind gnus.kidx
        makeindex -o gnus.cind gnus.cidx
        makeindex -o gnus.gind gnus.gidx
        cat postamble.tex >> gnus.tmplatexi
        $(LATEX) gnus.tmplatexi 
        $(LATEX) gnus.tmplatexi 
-       $(DVIPS) -f gnus.dvi > /local/tmp/larsi/gnus.ps
+       $(DVIPS) -f gnus.dvi > gnus.ps
 
 pss:   
        make latex
        make texi2latex.elc
        make tmps
        make pss
-tmps:
-       if [ ! -d /local/tmp/larsi ]; then mkdir /local/tmp/larsi; fi
-       make screens
-       make herds
-       make etc
-       make piconss
-       make xfaces
-
-herds:
-       cd ps ; for i in new-herd-[0-9]*.gif; do echo $$i; giftoppm $$i | pnmcrop -white | pnmmargin -white 9 | pnmscale 2 | pnmsmooth -size 5 5 | ppmtopgm | pgmtops > ../tmp/`basename $$i .gif`.ps; done
-       cd ps ; giftoppm new-herd-section.gif | pnmscale 4 | pnmsmooth -size 11 11 | ppmtopgm | pgmtops > ../tmp/new-herd-section.ps
-
-screens:
-       cd screen ; for i in *.gif; do echo $$i; giftoppm $$i | pnmmargin -black 1 | ppmtopgm | pgmtops > ../tmp/`basename $$i .gif`.ps; done   
-       giftoppm ps/larsi.gif | ppmtopgm | pgmtops > tmp/larsi.ps
-
-etc:
-       cd ../etc/gnus; for i in gnus-*.xpm; do echo $$i; xpmtoppm $$i | ppmtopgm | pgmtops > ../../texi/tmp/`basename $$i .xpm`.ps; done
-
-piconss:
-       cd picons; for i in *.xbm; do echo $$i; xbmtopbm $$i | pgmtops > ../tmp/picons-`basename $$i .xbm`.ps; done
-       cd picons; for i in *.gif; do echo $$i; giftoppm $$i | ppmtopgm | pgmtops > ../tmp/picons-`basename $$i .gif`.ps; done
-       for i in tmp/picons-*.ps; do echo "\\gnuspicon{$$i}"; done > picons.tmplatexi
-
-xfaces:
-       cd xface; for i in *.gif; do echo $$i; giftoppm $$i | ppmtopgm | pgmtops > ../tmp/xface-`basename $$i .gif`.ps; done
-       for i in tmp/xface-*.ps; do echo "\\gnusxface{$$i}"; done > xface.tmplatexi
 
 \input texinfo                  @c -*-texinfo-*-
 
 @setfilename gnus
-@settitle Quassia Gnus 0.15 Manual
+@settitle Quassia Gnus 0.16 Manual
 @synindex fn cp
 @synindex vr cp
 @synindex pg cp
 @tex
 
 @titlepage
-@title Quassia Gnus 0.15 Manual
+@title Quassia Gnus 0.16 Manual
 
 @author by Lars Magne Ingebrigtsen
 @page
 spool or your mbox file.  All at the same time, if you want to push your
 luck.
 
-This manual corresponds to Quassia Gnus 0.15.
+This manual corresponds to Quassia Gnus 0.16.
 
 @end ifinfo
 
 @item W T e
 @kindex W T e (Summary)
 @findex gnus-article-date-lapsed
+@findex gnus-start-date-timer
+@findex gnus-stop-date-timer
 Say how much time has elapsed between the article was posted and now
-(@code{gnus-article-date-lapsed}).
+(@code{gnus-article-date-lapsed}).  If you want to have this line
+updated continually, you can put
+
+@lisp
+(gnus-start-date-timer)
+@end lisp
+
+in your @file{.gnus.el} file, or you can run it off of some hook.  If
+you want to stop the timer, you can use the @code{gnus-stop-date-timer}
+command.
 
 @item W T o
 @kindex W T o (Summary)
 
 @item 
 @code{junk}: If the split is the symbol @code{junk}, then don't save
-this message anywhere.
+this message.
 
 @item
 @var{(: function arg1 arg2 ...)}:  If the split is a list, and the first
 substitions in the group names), you can say things like:
 
 @example
-(any "debian-\(\\w*\\)@@lists.debian.org" "mail.debian.\\1")
+(any "debian-\\(\\w*\\)@@lists.debian.org" "mail.debian.\\1")
 @end example
 
 @node Mail and Procmail
 default.  If the current group is @samp{gnu.emacs.gnus}, for instance, 
 @file{all.emacs.all.SCORE}, @file{not.alt.all.SCORE} and
 @file{gnu.all.SCORE} would all apply.  In short, the instances of
-@samp{all} in the score file names are translated into @samp{.+}, and
+@samp{all} in the score file names are translated into @samp{.*}, and
 then a regexp match is done.
 
 This means that if you have some score entries that you want to apply to
 
 \input texinfo                  @c -*-texinfo-*-
 
 @setfilename message
-@settitle Message 0.15 Manual
+@settitle Message 0.16 Manual
 @synindex fn cp
 @synindex vr cp
 @synindex pg cp
 @tex
 
 @titlepage
-@title Message 0.15 Manual
+@title Message 0.16 Manual
 
 @author by Lars Magne Ingebrigtsen
 @page
 * Key Index::         List of Message mode keys.
 @end menu
 
-This manual corresponds to Message 0.15.  Message is distributed with
+This manual corresponds to Message 0.16.  Message is distributed with
 the Gnus distribution bearing the same version number as this manual
 has.