;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:09:34 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/gnus/gnus-agent.el
;;; in Emacs version 24.3.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(byte-code "\300\301!\210\300\302!\210\300\303!\210\300\304!\210\300\305!\210\300\306!\210\300\307!\210\300\310!\210\311\312\313\"\210\311\314\315\"\210\316\317\320\321\322\323\324\325&\210\316\326\327\330\322\323\324\331&\210\316\332\327\333\322\323\324\331&\210\316\334\327\335\336\337\322\323\324\331&	\210\316\340\341\342\322\323\324\343&\210\316\344\345\346\322\323\324\347&\210\316\350\327\351\322\323\324\352&\210\316\353\327\354\322\323\324\331&\210\316\355\327\356\322\323\324\331&\210\316\357\327\356\322\323\324\331&\210\316\360\361\362\336\363\322\323\324\364&	\210\316\365\327\366\336\363\324\367\322\323&	\210\316\370\371\372\336\373\324\374\322\323&	\210\316\375\376\377\336\363\324\352\322\323&	\210\316\201@\201A\201B\336\363\324\201C\322\323&	\210\316\201D\327\201E\336\337\324\352\322\323&	\210\316\201F\201G\201H\336\337\322\323\324\343&	\210\316\201I\201J\201K\336\337\322\323\324\201L&	\210\316\201M\376\201N\336\337\324\352\322\323&	\210\316\201O\327\201P\336\337\324\201Q\322\323&	\210\316\201R\376\201S\336\337\322\323\324\201T&	\210\316\201U\327\201V\336\337\322\323\324\352&	\210\316\201W\201X\201Y\336\337\322\323\324\201Z&	\207" [require gnus gnus-cache nnmail nnvirtual gnus-sum gnus-score gnus-srvr gnus-util autoload gnus-server-update-server "gnus-srvr" gnus-agent-customize-category "gnus-cus" custom-declare-variable gnus-agent-directory (nnheader-concat gnus-directory "agent/") "Where the Gnus agent will store its files." :group gnus-agent :type directory gnus-agent-plugged-hook nil "Hook run when plugging into the network." hook gnus-agent-unplugged-hook "Hook run when unplugging from the network." gnus-agent-fetched-hook "Hook run when finished fetching articles." :version "22.1" gnus-agent-handle-level gnus-level-subscribed "Groups on levels higher than this variable will be ignored by the Agent." integer gnus-agent-expire-days 7 "Read articles older than this will be expired.\nIf you wish to disable Agent expiring, see `gnus-agent-enable-expiration'." (number :tag "days") gnus-agent-expire-all "If non-nil, also expire unread, ticked and dormant articles.\nIf nil, only read articles will be expired." boolean gnus-agent-group-mode-hook "Hook run in Agent group minor modes." gnus-agent-summary-mode-hook "Hook run in Agent summary minor modes." gnus-agent-server-mode-hook gnus-agent-confirmation-function 'y-or-n-p "Function to confirm when error happens." "21.1" function gnus-agent-synchronize-flags "Indicate if flags are synchronized when you plug in.\nIf this is `ask' the hook will query the user." (choice (const :tag "Always" t) (const :tag "Never" nil) (const :tag "Ask" ask)) gnus-agent-go-online 'ask "Indicate if offline servers go online when you plug in.\nIf this is `ask' the hook will query the user." "21.3" (choice (const :tag "Always" t) (const :tag "Never" nil) (const :tag "Ask" ask)) gnus-agent-mark-unread-after-downloaded t "Indicate whether to mark articles unread after downloaded." gnus-agent-download-marks '(download) "Marks for downloading." (repeat (symbol :tag "Mark")) gnus-agent-consider-all-articles "When non-nil, the agent will let the agent predicate decide\nwhether articles need to be downloaded or not, for all articles.  When\nnil, the default, the agent will only let the predicate decide\nwhether unread articles are downloaded or not.  If you enable this,\ngroups with large active ranges may open slower and you may also want\nto look into the agent expiry settings to block the expiration of\nread articles as they would just be downloaded again." gnus-agent-max-fetch-size 10000000 "Chunk size for `gnus-agent-fetch-session'.\nThe function will split its article fetches into chunks smaller than\nthis limit." gnus-agent-enable-expiration 'ENABLE "The default expiration state for each group.\nWhen set to ENABLE, the default, `gnus-agent-expire' will expire old\ncontents from a group's local storage.  This value may be overridden\nto disable expiration in specific categories, topics, and groups.  Of\ncourse, you could change gnus-agent-enable-expiration to DISABLE then\nenable expiration per categories, topics, and groups." (radio (const :format "Enable " ENABLE) (const :format "Disable " DISABLE)) gnus-agent-expire-unagentized-dirs "*Whether expiration should expire in unagentized directories.\nHave gnus-agent-expire scan the directories under\n(gnus-agent-directory) for groups that are no longer agentized.\nWhen found, offer to remove them." gnus-agent-auto-agentize-methods "Initially, all servers from these methods are agentized.\nThe user may remove or add servers using the Server buffer.\nSee Info nodes `(gnus)Server Buffer', `(gnus)Agent Variables'." (repeat symbol) gnus-agent-queue-mail "Whether and when outgoing mail should be queued by the agent.\nWhen `always', always queue outgoing mail.  When nil, never\nqueue.  Otherwise, queue if and only if unplugged." (radio (const :format "Always" always) (const :format "Never" nil) (const :format "When unplugged" t)) gnus-agent-prompt-send-queue "If non-nil, `gnus-group-send-queue' will prompt if called when unplugged." gnus-agent-article-alist-save-format 1 "Indicates whether to use compression(2), versus no\ncompression(1), when writing agentview files.  The compressed\nfiles do save space but load times are 6-7 times higher.  A group\nmust be opened then closed for the agentview to be updated using\nthe new format." (radio (const :format "Compressed" 2) (const :format "Uncompressed" 1))] 10)
(defvar gnus-agent-history-buffers nil)
(defvar gnus-agent-buffer-alist nil)
#@650 An assoc list identifying the articles whose headers have been fetched.
If successfully fetched, these headers will be stored in the group's overview
file.  The key of each assoc pair is the article ID, the value of each assoc
pair is a flag indicating whether the identified article has been downloaded
(gnus-agent-fetch-articles sets the value to the day of the download).
NOTES:
1) The last element of this list can not be expired as some
   routines (for example, get-agent-fetch-headers) use the last
   value to track which articles have had their headers retrieved.
2) The function `gnus-agent-regenerate' may destructively modify the value.
(defvar gnus-agent-article-alist nil (#$ . 6154))
(defvar gnus-agent-group-alist nil)
(defvar gnus-category-alist nil)
(defvar gnus-agent-current-history nil)
(defvar gnus-agent-overview-buffer nil)
(defvar gnus-category-predicate-cache nil)
(defvar gnus-category-group-cache nil)
(defvar gnus-agent-spam-hashtb nil)
(defvar gnus-agent-file-name nil)
(defvar gnus-agent-file-coding-system 'raw-text)
(defvar gnus-agent-file-loading-cache nil)
(defvar gnus-agent-total-fetched-hashtb nil)
(defvar gnus-agent-inhibit-update-total-fetched-for nil)
(defvar gnus-agent-need-update-total-fetched-for nil)
(byte-code "\300\301!\204\302\301\303\"\210\300\207" [fboundp directory-files-and-attributes defalias #[(directory &optional full match nosort) "\306\307	\n\f$\306\211	\203%	@\211\310
!BB	A\211	\204*\237)\207" [result directory full match nosort file nil directory-files file-attributes --dolist-tail--] 6]] 3)
(defalias 'gnus-open-agent #[nil "\301\302 \210\303 \210\304 \210\305\306\307\"\210\305\310\307\"\210\305\311\307\"\207" [gnus-agent t gnus-agent-read-servers gnus-category-read gnus-agent-create-buffer add-hook gnus-group-mode-hook gnus-agent-mode gnus-summary-mode-hook gnus-server-mode-hook] 3])
(defalias 'gnus-agent-create-buffer #[nil "\211\205\302\303	!!)\203\304\207\305\306!rq\210\307 \210)\310\207" [gnus-agent-overview-buffer buffer buffer-live-p get-buffer t gnus-get-buffer-create " *Gnus agent overview*" mm-enable-multibyte nil] 4])
(gnus-add-shutdown 'gnus-close-agent 'gnus)
(defalias 'gnus-close-agent #[nil "\306\211\306\211\211\205
;\203\307\202\310
!)\205*\311\307\f!\"\312\f!)\207" [gnus-category-predicate-cache gnus-category-group-cache gnus-agent-spam-hashtb gnus-agent-overview-buffer buf buffer nil get-buffer buffer-name delete kill-buffer gnus-buffers] 4])
#@127 Performs the body then updates the group's line in the group
buffer.  Automatically blocks multiple updates due to recursion.
(defalias 'gnus-agent-with-refreshed-group '(macro . #[(group &rest body) "\302\303\304BB\305\306\307\310\311\312	\313BBFEE\207" [body group prog1 let ((gnus-agent-inhibit-update-total-fetched-for t)) when (and gnus-agent-need-update-total-fetched-for (not gnus-agent-inhibit-update-total-fetched-for)) with-current-buffer gnus-group-buffer (setq gnus-agent-need-update-total-fetched-for nil) gnus-group-update-group (t)] 10 (#$ . 8648)]))
#@34 Load FILE and do a `read' there.
(defalias 'gnus-agent-read-file #[(file) "\301\302!rq\210\303\216\304\305\306\217+\207" [#1=#:temp-buffer generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) nil (byte-code "\301!\210eb\210\302p!\207" [file nnheader-insert-file-contents read] 2) ((error))] 3 (#$ . 9221)])
(defalias 'gnus-agent-method #[nil "\302@!\303\211A@)\304\232\203\305\202\211A@)Q\207" [gnus-command-method x symbol-name "/" "" "unnamed"] 5])
(put 'gnus-agent-method 'byte-optimizer 'byte-compile-inline-expand)
#@39 The name of the Gnus agent directory.
(defalias 'gnus-agent-directory #[nil "\303\304\305	@!\306	\211A@)\307\232\203\310\202	\211A@)Q!\306#\207" [gnus-agent-directory gnus-command-method x nnheader-concat nnheader-translate-file-chars symbol-name "/" "" "unnamed"] 7 (#$ . 9816)])
(put 'gnus-agent-directory 'byte-optimizer 'byte-compile-inline-expand)
#@47 The full name of the Gnus agent library FILE.
(defalias 'gnus-agent-lib-file #[(file) "\304\305\304\306\307	\310\311\n@!\312\n\211A@)\313\232\203\314\202\"\n\211A@)Q!\312#\"!\"\207" [file gnus-agent-directory gnus-command-method x expand-file-name file-name-as-directory "agent.lib" nnheader-concat nnheader-translate-file-chars symbol-name "/" "" "unnamed"] 12 (#$ . 10182)])
(defalias 'gnus-agent-cat-set-property #[(category property value) "\203	\n\236\206	\305B\n\nAB\241\210)\241\210\202<\n	\nA@@=\2034\n\211\211AA)\241\210\202;\nA\211\204)\n\207" [value property category cell x nil] 3])
(defalias 'gnus-agent-cat-name '(macro . #[(category) "\301D\207" [category car] 2]))
(defalias 'gnus-agent-cat-days-until-old '(macro . #[(category) "\301\302\303ED\207" [category cdr assq 'agent-days-until-old] 4]))
(put 'gnus-agent-cat-days-until-old 'gv-expander #[(do &rest args) "\302\303\304	$\207" [do args gv--defsetter gnus-agent-cat-days-until-old #[(value category) "\302\303	F\207" [category value gnus-agent-cat-set-property 'agent-days-until-old] 4]] 5])
(defalias 'gnus-agent-cat-enable-expiration '(macro . #[(category) "\301\302\303ED\207" [category cdr assq 'agent-enable-expiration] 4]))
(put 'gnus-agent-cat-enable-expiration 'gv-expander #[(do &rest args) "\302\303\304	$\207" [do args gv--defsetter gnus-agent-cat-enable-expiration #[(value category) "\302\303	F\207" [category value gnus-agent-cat-set-property 'agent-enable-expiration] 4]] 5])
(defalias 'gnus-agent-cat-groups '(macro . #[(category) "\301\302\303ED\207" [category cdr assq 'agent-groups] 4]))
(put 'gnus-agent-cat-groups 'gv-expander #[(do &rest args) "\302\303\304	$\207" [do args gv--defsetter gnus-agent-cat-groups #[(value category) "\302\303	F\207" [category value gnus-agent-cat-set-property 'agent-groups] 4]] 5])
(defalias 'gnus-agent-cat-high-score '(macro . #[(category) "\301\302\303ED\207" [category cdr assq 'agent-high-score] 4]))
(put 'gnus-agent-cat-high-score 'gv-expander #[(do &rest args) "\302\303\304	$\207" [do args gv--defsetter gnus-agent-cat-high-score #[(value category) "\302\303	F\207" [category value gnus-agent-cat-set-property 'agent-high-score] 4]] 5])
(defalias 'gnus-agent-cat-length-when-long '(macro . #[(category) "\301\302\303ED\207" [category cdr assq 'agent-long-article] 4]))
(put 'gnus-agent-cat-length-when-long 'gv-expander #[(do &rest args) "\302\303\304	$\207" [do args gv--defsetter gnus-agent-cat-length-when-long #[(value category) "\302\303	F\207" [category value gnus-agent-cat-set-property 'agent-long-article] 4]] 5])
(defalias 'gnus-agent-cat-length-when-short '(macro . #[(category) "\301\302\303ED\207" [category cdr assq 'agent-short-article] 4]))
(put 'gnus-agent-cat-length-when-short 'gv-expander #[(do &rest args) "\302\303\304	$\207" [do args gv--defsetter gnus-agent-cat-length-when-short #[(value category) "\302\303	F\207" [category value gnus-agent-cat-set-property 'agent-short-article] 4]] 5])
(defalias 'gnus-agent-cat-low-score '(macro . #[(category) "\301\302\303ED\207" [category cdr assq 'agent-low-score] 4]))
(put 'gnus-agent-cat-low-score 'gv-expander #[(do &rest args) "\302\303\304	$\207" [do args gv--defsetter gnus-agent-cat-low-score #[(value category) "\302\303	F\207" [category value gnus-agent-cat-set-property 'agent-low-score] 4]] 5])
(defalias 'gnus-agent-cat-predicate '(macro . #[(category) "\301\302\303ED\207" [category cdr assq 'agent-predicate] 4]))
(put 'gnus-agent-cat-predicate 'gv-expander #[(do &rest args) "\302\303\304	$\207" [do args gv--defsetter gnus-agent-cat-predicate #[(value category) "\302\303	F\207" [category value gnus-agent-cat-set-property 'agent-predicate] 4]] 5])
(defalias 'gnus-agent-cat-score-file '(macro . #[(category) "\301\302\303ED\207" [category cdr assq 'agent-score] 4]))
(put 'gnus-agent-cat-score-file 'gv-expander #[(do &rest args) "\302\303\304	$\207" [do args gv--defsetter gnus-agent-cat-score-file #[(value category) "\302\303	F\207" [category value gnus-agent-cat-set-property 'agent-score] 4]] 5])
(defalias 'gnus-agent-cat-enable-undownloaded-faces '(macro . #[(category) "\301\302\303ED\207" [category cdr assq 'agent-enable-undownloaded-faces] 4]))
(byte-code "\300\301\302\303#\210\300\304\302\305#\207" [put gnus-agent-cat-enable-undownloaded-faces gv-expander #[(do &rest args) "\302\303\304	$\207" [do args gv--defsetter gnus-agent-cat-enable-undownloaded-faces #[(value category) "\302\303	F\207" [category value gnus-agent-cat-set-property 'agent-enable-undownloaded-faces] 4]] 5] gnus-agent-cat-groups #[(do &rest args) "\302\303\304	$\207" [do args gv--defsetter gnus-agent-cat-groups #[(val &rest args) "\302\303	C\"B\207" [args val gnus-agent-set-cat-groups append] 4]] 5]] 4)
(defalias 'gnus-agent-set-cat-groups #[(category groups) "\306=?\205\307	\236A\211\n=\203\310\202~\nA=\2037\307	\236\2062\307\310B	\f	AB\241\210\f)\241\202~\203e\211A@\311
!\f	\f=\204a\f
\312
\313
\307\f\236A\"\"\210)*\2029\310)\307	\236\206|\307\310B	\f	AB\241\210\f)\241*\207" [groups category old-g new-g cell group ignore agent-groups nil gnus-group-category gnus-agent-set-cat-groups delete old-category #1=#:v gnus-category-group-cache] 7])
(defalias 'gnus-agent-cat-make #[(name &optional default-agent-predicate) "\302	\206\303BD\207" [name default-agent-predicate agent-predicate false] 3])
(put 'gnus-agent-cat-make 'byte-optimizer 'byte-compile-inline-expand)
#@55 Read a group name in the minibuffer, with completion.
(defalias 'gnus-agent-read-group #[nil "\302 \206\211\203\303	!\304\305\211\306\305\211	&)\207" [gnus-newsgroup-name def gnus-group-group-name gnus-group-decoded-name gnus-group-completing-read nil t] 8 (#$ . 15666)])
#@52 Initialize data structures for efficient fetching.
(defalias 'gnus-agent-start-fetch #[nil "\300 \207" [gnus-agent-create-buffer] 1 (#$ . 15952)])
#@40 Save all data structures and clean up.
(defalias 'gnus-agent-stop-fetch #[nil "\302r	q\210~)\207" [gnus-agent-spam-hashtb nntp-server-buffer nil] 1 (#$ . 16105)])
#@18 Do FORMS safely.
(defalias 'gnus-agent-with-fetch '(macro . #[(&rest forms) "\301\302\303\304BBB\305BB\207" [forms unwind-protect let ((gnus-agent-fetching t)) (gnus-agent-start-fetch) ((gnus-agent-stop-fetch))] 5 (#$ . 16275)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put gnus-agent-with-fetch lisp-indent-function 0 edebug-form-spec (body)] 4)
(defalias 'gnus-agent-append-to-list '(macro . #[(tail value) "\302\303\304	\305BBEE\207" [tail value setq setcdr cons (nil)] 7]))
(defalias 'gnus-agent-message '(macro . #[(level &rest args) "\302\303\304BB\305	BE\207" [level args if <= (gnus-verbose) message] 4]))
#@38 Hook run when installing agent mode.
(defvar gnus-agent-mode-hook nil (#$ . 16916))
(defvar gnus-agent-mode nil)
(defvar gnus-agent-mode-status '(gnus-agent-mode " Plugged"))
#@59 Minor mode for providing a agent support in Gnus buffers.
(defalias 'gnus-agent-mode #[nil "\306\307\310!\"\210\311\312\310!\"\313\314\315	\"!\316\303!\210\317\n\320L\210\316\n!\317L\210\321\322\323\"\2034\313\314\324	\"! \210\n\f\236\204A\n
AB\fB\n\236\204V\n\313\314\325	\"!JBB\326=\203l\320\327\330!\210*\331\332\313\314\333	\"!\"*\207" [major-mode buffer mode gnus-agent-mode minor-mode-alist gnus-agent-mode-status string-match "^gnus-\\(.*\\)-mode$" symbol-name match-string 1 intern format "gnus-agent-%s-mode" make-local-variable t nil gnus-visual-p agent-menu menu "gnus-agent-%s-make-menu-bar" "gnus-agent-%s-mode-map" gnus-group-mode :unknown gnus-agent-toggle-plugged gnus-run-hooks gnus-agent-mode-hook "gnus-agent-%s-mode-hook" minor-mode-map-alist gnus-plugged gnus-agent-go-online init-plugged] 6 (#$ . 17097)])
(defvar gnus-agent-group-mode-map (make-sparse-keymap))
(gnus-define-keys-1 'gnus-agent-group-mode-map '("Ju" gnus-agent-fetch-groups "Jc" gnus-enter-category-buffer "Jj" gnus-agent-toggle-plugged "Js" gnus-agent-fetch-session "JY" gnus-agent-synchronize-flags "JS" gnus-group-send-queue "Ja" gnus-agent-add-group "Jr" gnus-agent-remove-group "Jo" gnus-agent-toggle-group-plugged))
(defalias 'gnus-agent-group-make-menu-bar #[nil "\301\302!?\205\303\304!\210\305\302\306\307$\207" [gnus-agent-group-mode-map boundp gnus-agent-group-menu (lambda (#1=#:def-tmp-var) (defvar gnus-agent-group-menu #1# #2="")) nil easy-menu-do-define #2# ("Agent" ["Toggle plugged" gnus-agent-toggle-plugged t] ["Toggle group plugged" gnus-agent-toggle-group-plugged t] ["List categories" gnus-enter-category-buffer t] ["Add (current) group to category" gnus-agent-add-group t] ["Remove (current) group from category" gnus-agent-remove-group t] ["Send queue" gnus-group-send-queue gnus-plugged] ("Fetch" ["All" gnus-agent-fetch-session gnus-plugged] ["Group" gnus-agent-fetch-group gnus-plugged]) ["Synchronize flags" gnus-agent-synchronize-flags t])] 5])
(defvar gnus-agent-summary-mode-map (make-sparse-keymap))
(gnus-define-keys-1 'gnus-agent-summary-mode-map '("Jj" gnus-agent-toggle-plugged "Ju" gnus-agent-summary-fetch-group "JS" gnus-agent-fetch-group "Js" gnus-agent-summary-fetch-series "J#" gnus-agent-mark-article "J\243" gnus-agent-unmark-article "@" gnus-agent-toggle-mark "Jc" gnus-agent-catchup))
(defalias 'gnus-agent-summary-make-menu-bar #[nil "\301\302!?\205\303\304!\210\305\302\306\307$\207" [gnus-agent-summary-mode-map boundp gnus-agent-summary-menu (lambda (#1=#:def-tmp-var) (defvar gnus-agent-summary-menu #1# #2="")) nil easy-menu-do-define #2# ("Agent" ["Toggle plugged" gnus-agent-toggle-plugged t] ["Mark as downloadable" gnus-agent-mark-article t] ["Unmark as downloadable" gnus-agent-unmark-article t] ["Toggle mark" gnus-agent-toggle-mark t] ["Fetch downloadable" gnus-agent-summary-fetch-group t] ["Catchup undownloaded" gnus-agent-catchup t])] 5])
(defvar gnus-agent-server-mode-map (make-sparse-keymap))
(gnus-define-keys-1 'gnus-agent-server-mode-map '("Jj" gnus-agent-toggle-plugged "Ja" gnus-agent-add-server "Jr" gnus-agent-remove-server))
(defalias 'gnus-agent-server-make-menu-bar #[nil "\301\302!?\205\303\304!\210\305\302\306\307$\207" [gnus-agent-server-mode-map boundp gnus-agent-server-menu (lambda (#1=#:def-tmp-var) (defvar gnus-agent-server-menu #1# #2="")) nil easy-menu-do-define #2# ("Agent" ["Toggle plugged" gnus-agent-toggle-plugged t] ["Add" gnus-agent-add-server t] ["Remove" gnus-agent-remove-server t])] 5])
(defalias 'gnus-agent-make-mode-line-string #[(string mouse-button mouse-func) "\303\304!\203\303\305!\203\304\306\305	\n\"\307\310%\207\207" [string mouse-button mouse-func fboundp propertize make-mode-line-mouse-map local-map mouse-face mode-line-highlight] 6])
#@42 Toggle whether Gnus is unplugged or not.
(defalias 'gnus-agent-toggle-plugged #[(set-to) "	=\2042\203 \304\305!\210\nA\306\307\310\311#\240\210\303!\210\2022\312 \210\304\313!\210\nA\306\314\310\311#\240\210\315\316!\207" [set-to gnus-plugged gnus-agent-mode-status gnus-agent-go-online gnus-run-hooks gnus-agent-plugged-hook gnus-agent-make-mode-line-string " Plugged" mouse-2 gnus-agent-toggle-plugged gnus-agent-close-connections gnus-agent-unplugged-hook " Unplugged" set-buffer-modified-p t] 5 (#$ . 20885) (list (not gnus-plugged))])
(defalias 'gnus-agent-while-plugged '(macro . #[(&rest body) "\301\302\303\304\305BB\306BBE\207" [body let ((original-gnus-plugged gnus-plugged)) unwind-protect progn (gnus-agent-toggle-plugged t) ((gnus-agent-toggle-plugged original-gnus-plugged))] 6]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put gnus-agent-while-plugged lisp-indent-function 0 edebug-form-spec (body)] 4)
#@46 Close all methods covered by the Gnus agent.
(defalias 'gnus-agent-close-connections #[nil "\301 \205\302\211A@!\210\202)\207" [methods gnus-agent-covered-methods gnus-close-server] 3 (#$ . 21834)])
#@23 Start Gnus unplugged.
(defalias 'gnus-unplugged #[nil "\301\302 \207" [gnus-plugged nil gnus] 1 (#$ . 22047) nil])
#@21 Start Gnus plugged.
(defalias 'gnus-plugged #[nil "\301\302 \207" [gnus-plugged t gnus] 1 (#$ . 22169) nil])
#@33 Read news as a slave unplugged.
(defalias 'gnus-slave-unplugged #[(&optional arg) "\302\303	\302\304#\207" [gnus-plugged arg nil gnus slave] 4 (#$ . 22285) "P"])
#@354 Allow Gnus to be an offline newsreader.

The gnus-agentize function is now called internally by gnus when
gnus-agent is set.  If you wish to avoid calling gnus-agentize,
customize gnus-agent to nil.

This will modify the `gnus-setup-news-hook', and
`message-send-mail-real-function' variables, and install the Gnus agent
minor mode in all Gnus buffers.
(defalias 'gnus-agentize #[nil "\305 \210\306\307\310	\311\"!?\205!\n\205!\312\313\314\"\210\315\316\fB\"\210\317 \207" [message-send-mail-real-function gnus-agent-directory gnus-agent-auto-agentize-methods gnus-select-method gnus-secondary-select-methods gnus-open-agent gnus-agent-send-mail file-exists-p nnheader-concat "lib/servers" gnus-message 3 "First time agent user, agentizing remote groups..." mapc #[(server-or-method) "\211\203	<\203	\206\353\306	\n\"A\206\353	\307\232\203!\206\324\306	\f\"A\206\324\306	
\"A\206\324\203X	\310\311@@@@@A@#\232\204X\211A@\210\2025\211@@*\206\324\203\214	\310\311\211@@)@A@#\232\204\214\211A@\210\202g@)\206\324A\312\211\203\321\313\211A@8\211;\204\236	\312\314\315\316\215+\232\203\236\312\211\204\243+\211\203\350\306	\n\"\204\350	B\nB))\211@>\205

\312\211\315\317\215+B\312\211)\207" [server-or-method server gnus-server-method-cache gnus-select-method gnus-server-alist gnus-predefined-server-alist assoc "native" format "%s:%s" nil 4 t server-name (byte-code "\206	\n\204\306\307\"\210\306\310\f
D\"\210\211A@)\311\235\203*\312\313@\"\2026\312\314@\211A@)#\211B\211\235\204V\204V\315@\"\204VB*\207" [method gnus-select-method nocache gnus-server-method-cache gnus-server-alist gnus-predefined-server-alist mapc #[#1=(name-method) "A	\232\205\f\302\303@\"\207" [name-method method throw server-name] 3] #[#2=(server-alist) "\301\302\"\207" [server-alist mapc #[#3=(name-method) "\303A	\"\205\n\235\204\nB\304\305@\"\207" [name-method method gnus-server-method-cache gnus-methods-equal-p throw server-name] 3]] 3] #4=(nil "") format #5="%s" #6="%s:%s" assoc x name name-method no-enter-cache] 5) (byte-code "\206	\n\204\306\307\"\210\306\310\f
D\"\210\211A@)\311\235\203*\312\313@\"\2026\312\314@\211A@)#\211B\211\235\204V\204V\315@\"\204VB*\207" [method gnus-select-method nocache gnus-server-method-cache gnus-server-alist gnus-predefined-server-alist mapc #[#1# "A	\232\205\f\302\303@\"\207" [name-method method throw server-name] 3] #[#2# "\301\302\"\207" [server-alist mapc #[#3# "\303A	\"\205\n\235\204\nB\304\305@\"\207" [name-method method gnus-server-method-cache gnus-methods-equal-p throw server-name] 3]] 3] #4# format #5# #6# assoc x name name-method no-enter-cache] 5) gnus-opened-servers opened x gnus-secondary-select-methods servers gnus-newsrc-alist match method alist no-enter-cache nocache result gnus-agent-auto-agentize-methods gnus-agent-covered-methods gnus-agent-method-p-cache] 6] gnus-agent-write-servers] 4 (#$ . 22455) nil])
#@92 Make sure the queue group exists.
Optional arg GROUP-NAME allows to specify another group.
(defalias 'gnus-agent-queue-setup #[(&optional group-name) "\303\304\305\206\306\"	\"J?\2055\307\206\306\310\"\210\311\312\304\305\206#\306\"\313\314#\210)\315\304\305\2061\306\"\316\317#\207" [group-name gnus-newsrc-hashtb gnus-level-default-subscribed intern-soft format "nndraft:%s" "queue" gnus-request-create-group (nndraft #1="") 1 gnus-subscribe-group nil (nndraft #1#) gnus-group-set-parameter gnus-dummy ((gnus-draft-mode))] 4 (#$ . 25541)])
(defalias 'gnus-agent-send-mail #[nil "\203	\203\303=\204\304 \207eb\210\305\306\307\n!\310Q!\210\311\310!\210\312\313!\210\314\315\316\317\211$\210\320\315!\207" [gnus-agent-queue-mail gnus-plugged mail-header-separator always message-multi-smtp-send-mail re-search-forward "^" regexp-quote "\n" replace-match gnus-agent-insert-meta-information mail gnus-request-accept-article "nndraft:queue" nil t gnus-group-refresh-group] 5])
#@164 Insert meta-information into the message that says how it's to be posted.
TYPE can be either `mail' or `news'.  If the latter, then METHOD can
be a select method.
(defalias 'gnus-agent-insert-meta-information #[(type &optional method) "\212\303!\210eb\210\304\305	!\306\307\310\n\"\311\261\210\312u\210\313\311\314\315#\205*\316\317\315\211#\210\202)\207" [gnus-agent-meta-information-header type method message-remove-header ": " symbol-name " " format "%S" "\n" -1 search-backward nil t replace-match "\\n"] 7 (#$ . 26541)])
#@38 Restore GCC field from saved header.
(defalias 'gnus-agent-restore-gcc #[nil "\212eb\210\301\302\303!\304Q\305\306#\205\307\310\311\"\210\202)\207" [gnus-agent-gcc-header re-search-forward "^" regexp-quote ":" nil t replace-match "Gcc:" fixedcase] 4 (#$ . 27080)])
(defalias 'gnus-agent-any-covered-gcc #[nil "\214\303 \210\304\305\306\307#\211\205\310\311\312\313\314\"!\"\306\n\204-	\203-\315	@!	A\202\n,\207" [gcc methods covered message-narrow-to-headers mail-fetch-field "gcc" nil t mapcar gnus-inews-group-method message-unquote-tokens message-tokenize-header " ," gnus-agent-method-p] 7])
#@32 Save GCC if Gnus is unplugged.
(defalias 'gnus-agent-possibly-save-gcc #[nil "?\205#\303 \205#\212eb\210\304\305\306\307\304#\205\"\310\n\311P\312\"\210\202*\207" [gnus-plugged case-fold-search gnus-agent-gcc-header gnus-agent-any-covered-gcc t re-search-forward "^gcc:" nil replace-match ":" fixedcase] 4 (#$ . 27699)])
#@28 Do GCC if Gnus is plugged.
(defalias 'gnus-agent-possibly-do-gcc #[nil "\204\n\301 ?\205\f\302 \207" [gnus-plugged gnus-agent-any-covered-gcc gnus-inews-do-gcc] 1 (#$ . 28033)])
#@60 Put all new articles in the current groups into the Agent.
(defalias 'gnus-agent-fetch-groups #[(n) "\204\302\303!\210\304	\305\"\207" [gnus-plugged n error "Groups can't be fetched when Gnus is unplugged" gnus-group-iterate gnus-agent-fetch-group] 3 (#$ . 28220) "P"])
#@47 Put all new articles in GROUP into the Agent.
(defalias 'gnus-agent-fetch-group #[(&optional group) "\206	\211\204\306\307!\210\310!\204\311\312\"\207\n\313\216\314\315!\210\316!\317\216\315\320 \210\321\f\"\210\322\323\324#-\207" [group gnus-newsgroup-name gnus-plugged original-gnus-plugged gnus-command-method gnus-agent-fetching error "No group on the current line" gnus-agent-group-covered-p message "%s isn't covered by the agent" ((gnus-agent-toggle-plugged original-gnus-plugged)) gnus-agent-toggle-plugged t gnus-find-method-for-group ((gnus-agent-stop-fetch)) gnus-agent-start-fetch gnus-agent-fetch-group-1 gnus-message 5 "Fetching %s...done"] 5 (#$ . 28499) (list (gnus-group-group-name))])
#@45 Add the current group to an agent category.
(defalias 'gnus-agent-add-group #[(category arg) "	\236\306\211\307
\310\"\210\f\f\311\f\312\f\236A\n\244\"\210)\313 +\207" [category gnus-category-alist groups c cat arg nil gnus-group-iterate #[(group) "\304\305!\211\236A\203	\306\n\307\304	\236A\"\"\210)B\211\207" [group c #1=#:v groups agent-groups gnus-group-category gnus-agent-set-cat-groups delete] 6] gnus-agent-set-cat-groups agent-groups gnus-category-write #2=#:v] 4 (#$ . 29224) (list (intern (gnus-completing-read "Add to category" (mapcar #'(lambda (cat) (symbol-name (car cat))) gnus-category-alist) t)) current-prefix-arg)])
#@59 Remove the current group from its agent category, if any.
(defalias 'gnus-agent-remove-group #[(arg) "\302\303	\304\"\210\305 )\207" [c arg nil gnus-group-iterate #[(group) "\303\304!\211\236A\205	\305\n\306\303	\236A\"\")\207" [group c #1=#:v agent-groups gnus-group-category gnus-agent-set-cat-groups delete] 6] gnus-category-write] 3 (#$ . 29882) "P"])
#@43 Synchronize unplugged flags with servers.
(defalias 'gnus-agent-synchronize-flags #[nil "\212\302 \303\211\205!	@\304\305\306!!\203\307!\210	A\211\204\n\303+\207" [gnus-command-method --dolist-tail-- gnus-agent-covered-methods nil file-exists-p gnus-agent-lib-file "flags" gnus-agent-synchronize-flags-server] 4 (#$ . 30251) nil])
#@64 Synchronize flags according to `gnus-agent-synchronize-flags'.
(defalias 'gnus-agent-possibly-synchronize-flags #[nil "\212\302 \303\211\205!	@\304!\305=\203\306!\210	A\211\204\n\303+\207" [gnus-command-method --dolist-tail-- gnus-agent-covered-methods nil gnus-server-status ok gnus-agent-possibly-synchronize-flags-server] 3 (#$ . 30597) nil])
#@50 Synchronize flags set when unplugged for server.
(defalias 'gnus-agent-synchronize-flags-server #[(method) "\304\305\306\307!!\205B\310\311!q\210\312 \210\313\306\307!!\210\204)\314\315\316\nA@#\210\202?\317\n!\204:\314\315\320\nA@#\210\202?\321\322\323\217\210\324\304!*\207" [method gnus-agent gnus-command-method gnus-plugged nil file-exists-p gnus-agent-lib-file "flags" get-buffer-create " *Gnus Agent flag synchronize*" erase-buffer nnheader-insert-file-contents gnus-message 1 "You must be plugged to synchronize flags with server %s" gnus-check-server "Couldn't open server %s" err (byte-code "`\301\302p!!\210`|\210)\202" [bgn eval read] 3) ((end-of-file (byte-code "\300\301\302!!\207" [delete-file gnus-agent-lib-file "flags"] 3)) (error (byte-code "\302\303!\304ed\302\303!\305\306%\210\307\310\311	!#\210)\305\207" [file err gnus-agent-lib-file "flags" write-region nil silent error "Couldn't set flags from file %s due to %s" error-message-string] 6))) kill-buffer] 4 (#$ . 30959)])
#@75 Synchronize flags for server according to `gnus-agent-synchronize-flags'.
(defalias 'gnus-agent-possibly-synchronize-flags-server #[(method) "\303\304\305!!\205)\203\306=\203&\306=\205)\307\310\311	\211A@)\"!\205)\312	!\207" [gnus-agent-synchronize-flags method x file-exists-p gnus-agent-lib-file "flags" ask gnus-y-or-n-p format "Synchronize flags on server `%s'? " gnus-agent-synchronize-flags-server] 5 (#$ . 31977)])
#@243 Rename fully-qualified OLD-GROUP as NEW-GROUP.
Always updates the agent, even when disabled, as the old agent
files would corrupt gnus when the agent was next enabled.
Depends upon the caller to determine whether group renaming is
supported.
(defalias 'gnus-agent-rename-group #[(old-group new-group) "\306!\307\310\211\311!*!\306\f!\307\310\211\311\f!*!\312\313#\210\314\315\"\203>\316\225\310O\202@)\f\314\315\"\203W\316\225\310O\202Y)\317	\"\320	\310#\210\320
#\210\321	#\322\310\211	%\210\322\f@A
%.	\207" [old-group old-command-method gnus-command-method old-path new-group new-command-method gnus-find-method-for-group directory-file-name nil gnus-agent-group-pathname gnus-rename-file t string-match "^[^:]+:" 0 gnus-agent-get-group-info gnus-agent-save-group-info gnus-agent-get-local gnus-agent-set-local new-path nnmail-pathname-coding-system file-name-coding-system gname old-real-group new-real-group old-active old-local] 6 (#$ . 32416)])
#@226 Delete fully-qualified GROUP.
Always updates the agent, even when disabled, as the old agent
files would corrupt gnus when the agent was next enabled.
Depends upon the caller to determine whether group deletion is
supported.
(defalias 'gnus-agent-delete-group #[(group) "\306!\307\310\211\311!*!\f\312!\210\313\314\"\203)\315\225\310O\202+)\316	\310#\210\317	#\320\310\211	%-\207" [group command-method gnus-command-method path nnmail-pathname-coding-system file-name-coding-system gnus-find-method-for-group directory-file-name nil gnus-agent-group-pathname gnus-delete-directory string-match "^[^:]+:" 0 gnus-agent-save-group-info gnus-agent-get-local gnus-agent-set-local gname real-group local] 6 (#$ . 33442)])
#@37 Enroll SERVER in the agent program.
(defalias 'gnus-agent-add-server #[nil "\306 \307 \205n
\310\n;\203\377\n\211\203\"<\203\"\206\373\311\f\"A\206\373\312\232\2034
\206\344\311\"\"A\206\344\311#\"A\206\344$%%\203m\313\314%@@@%@@A@#\232\204m%\211A%@\210\202J%\211&@@*\206\344'((\203\241\313\314(\211&@@)(@A@#\232\204\241(\211A(@\210\202|(@)\206\344)A\310\211*++\203\341\315+\211A+@8\211;\204\262\n\310\316,-\317\320\215+\232\203\262\n*\310\211+\204\267*+\211.\203\370\311\f\"\204\370.B\fB.))\202m
\n
\232\203	

\202m
\n@;\203
\203
\321\n\"\202m
\n\2032
\2042
\n\211&A@)\322\232\2032
\n\202m
\n\323\n@!/\324\311/0\">\203k
\325/\326P!\n\236\204k
\327\n@0\236>\203k
\330\n\325/\326P!\nA@DC\"\202l
\n**\204w
\331\332!\210\333\n!\203\201
\331\334!\210	1B1\3102\335!\210\336 \210\337\340\341#+\207" [server named-server method group gnus-server-method-cache gnus-select-method gnus-server-server-name gnus-server-named-server nil assoc "native" format "%s:%s" 4 t server-name (byte-code "\206	\n\204\306\307\"\210\306\310\f
D\"\210\211A@)\311\235\203*\312\313@\"\2026\312\314@\211A@)#\211B\211\235\204V\204V\315@\"\204VB*\207" [method gnus-select-method nocache gnus-server-method-cache gnus-server-alist gnus-predefined-server-alist mapc #[(name-method) "A	\232\205\f\302\303@\"\207" [name-method method throw server-name] 3] #[(server-alist) "\301\302\"\207" [server-alist mapc #[(name-method) "\303A	\"\205\n\235\204\nB\304\305@\"\207" [name-method method gnus-server-method-cache gnus-methods-equal-p throw server-name] 3]] 3] (nil #1="") format "%s" "%s:%s" assoc x name name-method no-enter-cache] 5) gnus-server-extend-method #1# symbol-name address intern "-address" physical-address append error "No server on the current line" gnus-agent-method-p "Server already in the agent program" gnus-server-update-server gnus-agent-write-servers gnus-message 1 "Entered %s into the Agent" gnus-server-alist gnus-predefined-server-alist gnus-opened-servers opened x gnus-secondary-select-methods servers gnus-newsrc-alist match alist no-enter-cache nocache result method-name gnus-valid-select-methods gnus-agent-covered-methods gnus-agent-method-p-cache] 6 (#$ . 34195) nil])
#@39 Remove SERVER from the agent program.
(defalias 'gnus-agent-remove-server #[nil "\304 \305 \204\306\307!\210	\n\235\204\306\310!\210\311	\n\"\312\313!\210\314 \210\315\316\317#*\207" [server named-server gnus-agent-covered-methods gnus-agent-method-p-cache gnus-server-server-name gnus-server-named-server error "No server on the current line" "Server not in the agent program" delete nil gnus-server-update-server gnus-agent-write-servers gnus-message 1 "Removed %s from the agent"] 4 (#$ . 36520) nil])
#@36 Read the alist of covered servers.
(defalias 'gnus-agent-read-servers #[nil "\304\305\306\"!\307\205\310 \207" [gnus-agent-directory gnus-agent-covered-methods gnus-agent-method-p-cache gnus-server-alist gnus-agent-read-file nnheader-concat "lib/servers" nil gnus-agent-read-servers-validate] 4 (#$ . 37042)])
(defalias 'gnus-agent-read-servers-validate #[nil "\301\302\303\"\207" [gnus-agent-covered-methods mapcar #[(server-or-method) ";\203	\202\306\211\307\310\215+\211\211\203#\f<\203#\f\206\373\311\f
\"A\206\373\f\312\232\2036\206\344\311\f\"A\206\344\311\f\"A\206\344\203o\f\313\314@@@@@A@#\232\204o\211A@\210\202L\211@@*\206\344\203\243\f\313\314\211@@)@A@#\232\204\243\211A@\210\202~@)\206\344A\306\211\203\341\315\211A@8\211;\204\264\f\306\316\307\317\215+\232\203\264\306\211\204\271+\211\203\370\311\f
\"\204\370\fB
B))\211\203
\f\235?\205
\fB\306\211 \202
\320\321\322\f#*\207" [server-or-method no-enter-cache nocache method server gnus-server-method-cache nil server-name (byte-code "\206	\n\204\306\307\"\210\306\310\f
D\"\210\211A@)\311\235\203*\312\313@\"\2026\312\314@\211A@)#\211B\211\235\204V\204V\315@\"\204VB*\207" [method gnus-select-method nocache gnus-server-method-cache gnus-server-alist gnus-predefined-server-alist mapc #[#1=(name-method) "A	\232\205\f\302\303@\"\207" [name-method method throw server-name] 3] #[#2=(server-alist) "\301\302\"\207" [server-alist mapc #[#3=(name-method) "\303A	\"\205\n\235\204\nB\304\305@\"\207" [name-method method gnus-server-method-cache gnus-methods-equal-p throw server-name] 3]] 3] #4=(nil "") format #5="%s" #6="%s:%s" assoc x name name-method no-enter-cache] 5) assoc "native" format "%s:%s" 4 t (byte-code "\206	\n\204\306\307\"\210\306\310\f
D\"\210\211A@)\311\235\203*\312\313@\"\2026\312\314@\211A@)#\211B\211\235\204V\204V\315@\"\204VB*\207" [method gnus-select-method nocache gnus-server-method-cache gnus-server-alist gnus-predefined-server-alist mapc #[#1# "A	\232\205\f\302\303@\"\207" [name-method method throw server-name] 3] #[#2# "\301\302\"\207" [server-alist mapc #[#3# "\303A	\"\205\n\235\204\nB\304\305@\"\207" [name-method method gnus-server-method-cache gnus-methods-equal-p throw server-name] 3]] 3] #4# format #5# #6# assoc x name name-method no-enter-cache] 5) gnus-message 8 "Ignoring disappeared server `%s'" gnus-select-method gnus-server-alist gnus-predefined-server-alist gnus-opened-servers opened x gnus-secondary-select-methods servers gnus-newsrc-alist match alist result gnus-agent-covered-methods gnus-agent-method-p-cache] 6] nil] 4])
(defalias 'gnus-agent-read-servers-validate-native #[(native-method) "\301\302\"\211\207" [gnus-agent-covered-methods mapcar #[(method) "\203\n	\232\203\f\302\207\207" [method native-method "native"] 2]] 3])
#@37 Write the alist of covered servers.
(defalias 'gnus-agent-write-servers #[nil "\306\307\310\"!\210	\n\307\311\"\312\313\314!!\315\216r
q\210\316p\")r
q\210\317\320\211\320\321%\210.\207" [gnus-agent-directory nnheader-file-coding-system nnmail-pathname-coding-system file-name-coding-system coding-system-for-write #1=#:temp-buffer gnus-make-directory nnheader-concat "lib" "lib/servers" get-buffer-create generate-new-buffer-name " *temp file*" ((byte-code "\301!\203\n\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) prin1 write-region nil 0 #2=#:temp-file gnus-agent-covered-methods] 7 (#$ . 40030)])
#@212 Mark the next N articles as downloadable.
If N is negative, mark backward instead.  If UNMARK is non-nil, remove
the mark instead.  The difference between N and the actual number of
articles marked is returned.
(defalias 'gnus-agent-mark-article #[(n &optional unmark) "\304W\305!\304V\203B\306\307`\310\"\211\203\311\n!\210)\307`\312\"\206&\313 \"\210\314\315	\2033\316\2024\317\320\321#!\203BS\211\202	\304U\204M\322\323\324\"\210\325 \210\326 \210*\207" [n backward to unmark 0 abs gnus-summary-set-agent-mark get-text-property gnus-intangible gnus-summary-goto-subject gnus-number gnus-summary-last-subject zerop gnus-summary-next-subject -1 1 nil t gnus-message 7 "No more articles" gnus-summary-recenter gnus-summary-position-point] 6 (#$ . 40660) "p"])
#@181 Remove the downloadable mark from the next N articles.
If N is negative, unmark backward instead.  The difference between N and
the actual number of articles unmarked is returned.
(defalias 'gnus-agent-unmark-article #[(n) "\301\302\"\207" [n gnus-agent-mark-article t] 3 (#$ . 41447) "p"])
#@180 Toggle the downloadable mark from the next N articles.
If N is negative, toggle backward instead.  The difference between N and
the actual number of articles toggled is returned.
(defalias 'gnus-agent-toggle-mark #[(n) "\301\302\"\207" [n gnus-agent-mark-article toggle] 3 (#$ . 41746) "p"])
#@165 Mark ARTICLE as downloadable.  If UNMARK is nil, article is marked.
When UNMARK is t, the article is unmarked.  For any other value, the
article's mark is toggled.
(defalias 'gnus-summary-set-agent-mark #[(article &optional unmark) "\306=\203\n\306\202\307=\203\307\202	\n>\310	\306\307#\205\217\311\203\207\312	\n\"	>\2034\f\202\215	\n>\203>
\202\215	
>\203J\202\215	>\203V\202\215	>\203b\202\215	>\203n\202\215	>\203z\202\215	\236A\206\215\202\215\313\n	\"
\314\")\207" [unmark article gnus-newsgroup-downloadable gnus-newsgroup-unsendable gnus-unsendable-mark gnus-downloadable-mark nil t gnus-summary-goto-subject gnus-summary-update-mark delq gnus-add-to-sorted-list unread gnus-newsgroup-unreads gnus-unread-mark gnus-newsgroup-marked gnus-ticked-mark gnus-newsgroup-spam-marked gnus-spam-mark gnus-newsgroup-dormant gnus-dormant-mark gnus-newsgroup-expirable gnus-expirable-mark gnus-newsgroup-reads gnus-ancient-mark] 4 (#$ . 42046)])
#@59 Construct list of articles that have not been downloaded.
(defalias 'gnus-agent-get-undownloaded-list #[nil "\306!\307\302!\210\310	!\211\205\351\311!\312\313\314\f\"\315\"\205#\316C\211\316C\211\203\273
\203\273\211@@)
@\211W\203UA\202\267V\203u\316B\241\316B\241
A\202\267\211@A)\203\210A
A\202\267A
A\203\245@W\203\245A\211\204\223@\232\204\267\316B\241*\2023
\203\334
\211A@\316B\241\316B\241)\202\273AA\211.)\207" [gnus-newsgroup-name gnus-command-method gnus-newsgroup-agentized alist gnus-newsgroup-headers headers gnus-find-method-for-group make-local-variable gnus-agent-method-p gnus-agent-load-alist sort mapcar #[(h) "\301H\207" [h 0] 2] < nil gnus-use-cache gnus-newsgroup-cached cached undownloaded tail-undownloaded unfetched tail-unfetched x h a num gnus-newsgroup-undownloaded gnus-newsgroup-unfetched] 5 (#$ . 43050)])
#@121 Mark as read all unhandled articles.
An article is unhandled if it is neither cached, nor downloaded, nor
downloadable.
(defalias 'gnus-agent-catchup #[nil "\212\n\204\203\305\211\306	!\n\"\"	\203%\307	\211A@\f\"\210\202)\310 )\207" [gnus-newsgroup-undownloaded articles gnus-newsgroup-downloadable gnus-newsgroup-cached gnus-catchup-mark gnus-sorted-ndifference gnus-copy-sequence gnus-summary-mark-article gnus-summary-position-point] 4 (#$ . 44014) nil])
#@51 Fetch the process-marked articles into the Agent.
(defalias 'gnus-agent-summary-fetch-series #[nil "\205$	\305\306!\307\"\211\310 \210\311\312\313\f\"\"\210\313\n\313\f\"\"+\211\207" [gnus-newsgroup-processable gnus-newsgroup-downloadable dl processable gnus-newsgroup-undownloaded sort gnus-copy-sequence < gnus-agent-summary-fetch-group mapc gnus-summary-remove-process-mark gnus-sorted-ndifference] 6 (#$ . 44491) nil])
#@106 Fetch the downloadable articles in the group.
Optional arg ALL, if non-nil, means to fetch all articles.
(defalias 'gnus-agent-summary-fetch-group #[(&optional all) "\203	\202	\n\306!\307\310\216\311\312!\210\204$\313\314!\210\315\216\312\316 \210\317\320\"\211\"*\212\307\211\203\230@\211\n>\203u\321\n\"\235\204\200 \235\204\200\322!\"\210\202\200\203\200\323\312\"\210\324\307\312#\203\216\325!\210)A\211\204F-\f+\207" [all gnus-newsgroup-articles gnus-newsgroup-downloadable gnus-newsgroup-name fetched-articles gnus-command-method gnus-find-method-for-group nil ((gnus-agent-toggle-plugged original-gnus-plugged)) gnus-agent-toggle-plugged t error "No articles to download" ((gnus-agent-stop-fetch)) gnus-agent-start-fetch gnus-sorted-ndifference gnus-agent-fetch-articles delq gnus-summary-mark-article gnus-summary-set-agent-mark gnus-summary-goto-subject gnus-summary-update-download-mark articles gnus-plugged original-gnus-plugged gnus-agent-fetching gnus-newsgroup-undownloaded article --dolist-tail-- was-marked-downloadable gnus-agent-mark-unread-after-downloaded gnus-newsgroup-dormant gnus-newsgroup-marked gnus-unread-mark] 6 (#$ . 44930) "P"])
#@123 Fetch the current article as it is selected.
This can be added to `gnus-select-article-hook' or
`gnus-mark-article-hook'.
(defalias 'gnus-agent-fetch-selected-article #[nil "\n\205\306	!\205\307\fC\"\205\310\f
\"\311\f!)\207" [gnus-current-select-method gnus-command-method gnus-plugged gnus-newsgroup-name gnus-current-article gnus-newsgroup-undownloaded gnus-agent-method-p gnus-agent-fetch-articles delq gnus-summary-update-download-mark] 3 (#$ . 46171)])
#@61 Update a plugged group by performing the indicated actions.
(defalias 'gnus-agent-synchronize-group-flags #[(group actions server) "\211\203<\203\206\352\306	\"A\206\352\307\232\203!\n\206\323\306\"A\206\323\306\f\"A\206\323
\203W\310\311@@@@@A@#\232\204W\211A@\210\2024\211@@*\206\323  \203\213\310\311 \211@@) @A@#\232\204\213 \211A @\210\202f @)\206\323!A\312\211\"#$$\203\320\313$\211A$@8\211#;\204\235#\312\314%&#\315\316\215+\232\203\235#\"\312\211$\204\242\"+\211'\203\347\306	\"\204\347'B	B'))(\317\320)*\"J8\206	
\317\320\321)(\"\211)*\"J8+\322),\"\210+\203\337
,\312-\211.\203\306
.@\211-@-A@\317-8/01/\3122\211.\203\274
.@\2112\323=\203v
+AA0\324=\203\\
\325\202]
\326\317+81\"\240\210\327+\320+@3\"J\"\210\202\263
2\330>\203\263
\3062\331+8\"\2114\204\234
\331+\2332C\2114\331+8B\240\21040\324=\203\251
\325\202\252
\3264A1\"\241\210).A\211.\204B
-.A\211.\204\"
*5\2116\205\325
\332\3336!!)\203\337
\334)\314\"\210*\312\207" [server gnus-server-method-cache gnus-select-method gnus-server-alist gnus-predefined-server-alist gnus-opened-servers assoc "native" format "%s:%s" nil 4 t server-name (byte-code "\206	\n\204\306\307\"\210\306\310\f
D\"\210\211A@)\311\235\203*\312\313@\"\2026\312\314@\211A@)#\211B\211\235\204V\204V\315@\"\204VB*\207" [method gnus-select-method nocache gnus-server-method-cache gnus-server-alist gnus-predefined-server-alist mapc #[(name-method) "A	\232\205\f\302\303@\"\207" [name-method method throw server-name] 3] #[(server-alist) "\301\302\"\207" [server-alist mapc #[(name-method) "\303A	\"\205\n\235\204\nB\304\305@\"\207" [name-method method gnus-server-method-cache gnus-methods-equal-p throw server-name] 3]] 3] (nil "") format "%s" "%s:%s" assoc x name name-method no-enter-cache] 5) 2 intern-soft gnus-group-full-name gnus-request-set-mark read add gnus-range-add gnus-remove-from-range gnus-get-unread-articles-in-group (tick) 3 buffer-live-p get-buffer gnus-group-update-group opened x gnus-secondary-select-methods servers gnus-newsrc-alist match method alist no-enter-cache nocache result gnus-command-method group gnus-newsrc-hashtb info actions action --dolist-tail-- marks what range mark gnus-active-hashtb info-marks gnus-group-buffer buffer] 6 (#$ . 46646)])
#@248 Sync the agent's active file with the current buffer.
Pass non-nil for GROUPS-P if the buffer starts out in groups format.
Regardless, both the file and the buffer end up in active format
if METHOD is agentized; otherwise the function is a no-op.
(defalias 'gnus-agent-save-active #[(method &optional groups-p) "\306!\2053\307\310ed\"!\311\312!\f\203\313\314\n\"\210\202$\315\314\n\"\210\316\n\"\210\317 \210
\320!,\207" [method gnus-command-method new file groups-p gnus-agent-file-coding-system gnus-agent-method-p gnus-make-hashtable count-lines gnus-agent-lib-file "active" gnus-groups-to-gnus-format nil gnus-active-to-gnus-format gnus-agent-write-active erase-buffer nnheader-insert-file-contents nnheader-file-coding-system] 4 (#$ . 49061)])
(defalias 'gnus-agent-write-active #[(file new) "\304\305!!\210	\306\307#)\207" [file gnus-agent-file-coding-system nnmail-active-file-coding-system new gnus-make-directory file-name-directory gnus-write-active-file nil] 4])
#@87 Possibly expand a group's active range to include articles
downloaded into the agent.
(defalias 'gnus-agent-possibly-alter-active #[(group active &optional info) "\206\306	!\307!\205v\310	!@\206\311A\206\311\n@\206&\f\nA\206.
\fW\203<\240\210
V\203H\241\210\205u\f\312ZW\205u\3138AA\314T\fSBC\"\240\210)\315	\fS#-)\207" [gnus-command-method group local active active-min active-max gnus-find-method-for-group gnus-agent-method-p gnus-agent-get-local 0 100 2 gnus-range-add gnus-agent-set-local agent-min agent-max info read] 5 (#$ . 50058)])
#@87 Update a single group's active range in the agent's copy of the server's active file.
(defalias 'gnus-agent-save-group-info #[(method group active) "\306!\205\261\206	\n\f\307\310!#\311\211$%\312\313#!!\210#\314\315\316!!&'\317\216r&q\210\320 \210\321#!\203h\322#!\210eb\210\323\324\325(!\326Q\311\327#\203h\212\330p!%\330p!$)\331 \332y\210`|\210)\205\240\333\334\335(!%\206{)A)A]$\206\207)@)@^$c\210db\210\336\337\311\327#\205\240\340\332!\210\202\221)r&q\210\341\311\211'\311\342%\210.\n\207" [method gnus-command-method nnheader-file-coding-system coding-system-for-write nnmail-pathname-coding-system file-name-coding-system gnus-agent-method-p gnus-agent-lib-file "active" nil gnus-make-directory file-name-directory get-buffer-create generate-new-buffer-name " *temp file*" ((byte-code "\301!\203\n\302!\210\301\207" [#1=#:temp-buffer buffer-name kill-buffer] 2)) mm-disable-multibyte file-exists-p nnheader-insert-file-contents re-search-forward "^" regexp-quote " " t read point-at-bol 1 format "%S %d %d y\n" intern search-backward "\\." delete-char write-region 0 file oactive-min oactive-max #1# #2=#:temp-file group active] 8 (#$ . 50657)])
#@84 Get a single group's active range in the agent's copy of the server's active file.
(defalias 'gnus-agent-get-group-info #[(method group) "\306!\205`\206	\n\f\307\310!\311\211\312\313!!\210\314\315!rq\210\316\216\317 \210\320!\205^\321!\210eb\210\322\323\324!\325Q\311\326#\205^\212\327p!\327p!\211)B.	\207" [method gnus-command-method nnheader-file-coding-system coding-system-for-write nnmail-pathname-coding-system file-name-coding-system gnus-agent-method-p gnus-agent-lib-file "active" nil gnus-make-directory file-name-directory generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1=#:temp-buffer buffer-name kill-buffer] 2)) mm-disable-multibyte file-exists-p nnheader-insert-file-contents re-search-forward "^" regexp-quote " " t read file oactive-min oactive-max #1# group] 5 (#$ . 51857)])
#@50 Alist of non-ASCII group names and decoded ones.
(defvar gnus-agent-decoded-group-names nil (#$ . 52722))
#@39 Return a decoded group name of GROUP.
(defalias 'gnus-agent-decoded-group-name #[(group) "\303	\"A\206\304\305\"\203\306!\nB	B\n)\207\207" [group gnus-agent-decoded-group-names decoded assoc string-match "[^-]" gnus-group-decoded-name] 3 (#$ . 52834)])
#@35 Translate GROUP into a file name.
(defalias 'gnus-agent-group-path #[(group) "\306\307\310!\311\312	\"\203	\313\225\314O\202	)\315\316\317\n\f#+\320\316#!
\204Z\321\322\323\306\324@!\325\211A@)\326\232\203I\327\202Q\211A@)Q!\325#\"!\203\\\207\320\315\317\n\f#+\207" [group gname to from string nnmail-use-long-file-names nnheader-translate-file-chars nnheader-replace-duplicate-chars-in-string gnus-agent-decoded-group-name string-match "^[^:]+:" 0 nil 47 95 mm-subst-char-in-string 46 file-directory-p expand-file-name nnheader-concat symbol-name "/" "" "unnamed" gnus-agent-directory gnus-command-method x] 10 (#$ . 53106)])
#@35 Translate GROUP into a file name.
(defalias 'gnus-agent-group-pathname #[(group) "\305\306!\307\310	\"\203	\311\225\312O\202	)\n\203>\313\314\315\n@!\316\n\211A@)\317\232\2031\320\2027\n\211A@)Q!\316#\202d\321!\313\314\315\n@!\316\n\211A@)\317\232\203Y\320\202_\n\211A@)Q!\316#)\"\207" [group gname gnus-command-method gnus-agent-directory x nnmail-group-pathname gnus-agent-decoded-group-name string-match "^[^:]+:" 0 nil nnheader-concat nnheader-translate-file-chars symbol-name "/" "" "unnamed" gnus-find-method-for-group] 9 (#$ . 53773)])
(defalias 'gnus-agent-get-function #[(method) "\301!\203	@\207\302\303!\210\303\207" [method gnus-online require nnagent] 2])
#@61 Return the subset of methods that are covered by the agent.
(defalias 'gnus-agent-covered-methods #[nil "\301\302\303\304\"\"\207" [gnus-agent-covered-methods delq nil mapcar gnus-server-to-method] 5 (#$ . 54471)])
(defalias 'gnus-agent-history-buffer #[nil "\303\304@!\305\211A@)\306\232\203\307\202\211A@)Q\n\"A\207" [gnus-command-method x gnus-agent-history-buffers assoc symbol-name "/" "" "unnamed"] 5])
(defalias 'gnus-agent-open-history #[nil "\212\305@!\306\211A@)\307\232\203\310\202\211A@)Q\311\312\313\305@!\306\211A@)\307\232\2033\310\2029\211A@)Q\"!qB\nB\314 \210\315 \210\316c\210\317\320!\321!\203X\322!\210\323\304!\210\211*\207" [gnus-command-method x gnus-agent-history-buffers file gnus-agent-file-name symbol-name "/" "" "unnamed" gnus-get-buffer-create format " *Gnus agent %s history*" mm-disable-multibyte erase-buffer "\n" gnus-agent-lib-file "history" file-exists-p nnheader-insert-file-contents make-local-variable] 8])
(defalias 'gnus-agent-close-history #[nil "\211\205\305\306	!!)\2056\307!\210\310\311\312\n@!\313\n\211A@)\314\232\203)\315\202/\n\211A@)Q\f\"\f\"\211\207" [gnus-agent-current-history buffer gnus-command-method x gnus-agent-history-buffers buffer-live-p get-buffer kill-buffer delq assoc symbol-name "/" "" "unnamed"] 7])
#@56 Fetch ARTICLES from GROUP and put them into the Agent.
(defalias 'gnus-agent-fetch-articles #[(group articles) "\205W\306	!\210\nG\307W?\205\f\310C5\3116\310\21178\211A@\2117\203\3157\2119@@)\206;7TV\203EA\202,7\2119@@)=\203\\\2119@A)\204!7
@\211:\203m:\311H\202p7T)\2118V\203~
A\202\\575@B\240\210;687U\203\261
@\312H\211<\311X\203\253
@\313H\314_\315]\202\255<)\202\262\311\\\2116W\203!5\211@\237\240\210\3105B5\3116\202!5A\204\3315@\205U\310C\211=>\316	!?\317\320 !@\321A\310\211BC\310DEF5\211@\237\240\2105\2375\322?!\210\323\313\324\325	!#\210\326\2165\211A5@\211\203O\327	G\310\330\331\217*\2038
\332	\"B\202\217
\333\334!HrHq\210\335\216\3107\211A@\2117\203\202
\323\336\3377\325	!$\210\340	7I#\204n
\3417	\"\203G
db\2107`BBBB\342I!\210\202G
\343Ied#\210B\237B,rIq\210B\203KB\2119@A)BA@A\206\252
d}\210eb\210m\204@\344\345\310\321#\203\346\347\310\321#\203\311\225b\210\350\310w\210\351\310w\210\310C\352\353!\203\361
\354\224\354\225{\355\307\224\307\225{!BCBC\311\225b\210\202\322
\356CB\2119@@)@#\210eb\210\357\360\310\321#\204\361D\202\354\224\354\225{DJK\362ed?\363B\2119@@)!P\310\364%\210)>B\2119@@)\310B\241>~\210BA\211B\204\231
)\202
)=A.	.\207" [articles group gnus-agent-article-alist alist gnus-newsgroup-headers headers gnus-agent-load-alist 2 nil 0 6 7 65 1000 gnus-agent-group-pathname time-to-days current-time t gnus-make-directory gnus-message "Fetching articles for %s..." gnus-agent-decoded-group-name ((byte-code "\303	A\n#\210\304	A\"\210\305\306\307\"\207" [group fetched-articles date gnus-agent-save-alist gnus-agent-update-files-total-fetched-for gnus-message 7 ""] 4)) retrieve-articles (byte-code ";\203\f\303!@\202
\304	!\204\305	!\210\306\307\310\311	\n#!!)\207" [group method func gnus-find-method-for-group featurep require fboundp intern format "%s-%s"] 6) ((error)) gnus-retrieve-articles generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1=#:temp-buffer buffer-name kill-buffer] 2)) 10 "Fetching article %s for %s..." gnus-backlog-request-article gnus-request-article insert-buffer-substring copy-to-buffer search-forward "\n\n" search-backward "\nXrefs: " "^ " " " looking-at "\\([^: \n]+\\):\\([0-9]+\\) *" 1 string-to-number gnus-agent-crosspost re-search-forward "^Message-ID: *<\\([^>\n]+\\)>" "No-Message-ID-in-article" write-region number-to-string silent selected-sets current-set-size article header-number x header gnus-agent-max-fetch-size char-size fetched-articles tail-fetched-articles dir date case-fold-search pos crosses id nnmail-pathname-coding-system file-name-coding-system func #1# nntp-server-buffer gnus-agent-file-coding-system coding-system-for-write] 7 (#$ . 55789)])
#@62 Delete ARTICLES that were fetched from GROUP into the agent.
(defalias 'gnus-agent-unfetch-articles #[(group articles) "\205\271\306\307\n!\210\310B\311\312\"\f\211A@
A\203\233\203\233
A\211@@)W\203B\211A@\202\227U\203\224
A\211@A)\211\203\206\313\n!\314!P\315\203q\316\317!8\206r\320!\321!\210\322\n[\"\210+)
\211\211AA)\241\210\202\227
A)\202\fA\323\n!-\203\271	\204\271rq\210\310\324\n\306\"\210)\207" [articles gnus-agent-inhibit-update-total-fetched-for group gnus-agent-article-alist alist next-possibility t gnus-agent-load-alist nil sort < gnus-agent-group-pathname number-to-string float 7 file-attributes 0 delete-file gnus-agent-update-files-total-fetched-for gnus-agent-save-alist gnus-group-update-group delete-this x have-this timestamp file-name gnus-agent-total-fetched-hashtb size-file nnmail-pathname-coding-system file-name-coding-system gnus-agent-need-update-total-fetched-for gnus-group-buffer] 5 (#$ . 58611)])
(defalias 'gnus-agent-crosspost #[(crosses article &optional date) "\206\306\307\211\211\211\211rq\210\310!\203&\311v\210`\311y\210`)\205\254\211@@)\312\f\"\211\204R\f\313\211@@)!D\211B\211@A)BAB\241\210r\314\315\316\f\"!q\210deU\203~\fpBB\307\317\320\217\210\310\321\211@A)!!\210\321\211@A)!c\210\322\n	#\210\323 \210)A\211\204,\307-\207" [date end beg alist group gnus-agent-article-alist t nil nnheader-find-nov-line 1 assoc gnus-agent-load-alist gnus-get-buffer-create format " *Gnus agent overview %s*" (byte-code "\303\304\305\n\"!\210)\303\207" [nnmail-pathname-coding-system file-name-coding-system group nnheader-insert-file-contents gnus-agent-article-name ".overview"] 4) ((error)) string-to-number insert-buffer-substring gnus-agent-check-overview-buffer gnus-agent-overview-buffer article crosses x gnus-agent-group-alist gnus-agent-buffer-alist] 6])
(defalias 'gnus-agent-backup-overview-buffer #[nil "\203/\306\307\"\310\311	\312
\313\314\fT\211!\313R\211!\204\315ed\311\316%\210\317\320\321#\210,\322\207" [gnus-newsgroup-name nnmail-pathname-coding-system file-name-coding-system name cnt root gnus-agent-article-name ".overview" 0 nil file-exists-p "~" int-to-string write-region no-msg gnus-message 1 "Created backup copy of overview in %s." t] 6])
#@141 Check the overview file given for sanity.
In particular, checks that the file is sorted by article number
and that there are no duplicates.
(defalias 'gnus-agent-check-overview-buffer #[(&optional buffer) "\305\306\212\n\203\f\nq\210\214~\210eb\210`dW\205\204`\306\307\310\217\250\203+\306f\311=\204>\2042\312 \313\314\315\f\316 {#\210\202}	U\203[\204K\312 \313\314\317#\210\f\314y\210`|\210\202}	W\203{\204h\312 \313\314\320\"\210\321\314ed#\210eb\210\305\202}\314y\210*\202,\207" [backed-up prev-num buffer cur p -1 nil (byte-code "\300p!\207" [read] 2) ((error)) 9 gnus-agent-backup-overview-buffer gnus-message 1 "Overview buffer contains garbage '%s'." point-at-eol "Duplicate overview line for %d" "Overview buffer not sorted!" sort-numeric-fields] 5 (#$ . 60974)])
#@182 Flush all agent index files for every subscribed group within
  the given SERVER-OR-METHOD.  When called with nil, the current
  value of gnus-command-method identifies the server.
(defalias 'gnus-agent-flush-server #[(&optional server-or-method) "\203\363\211\203	<\203	\206\357\306	\n\"A\206\357	\307\232\203%\206\330\306	\f\"A\206\330\306	
\"A\206\330\203\\	\310\311@@@@@A@#\232\204\\\211A@\210\2029\211@@*\206\330\203\220	\310\311\211@@)@A@#\232\204\220\211A@\210\202k@)\206\330A\312\211\203\325\313\211A@8\211;\204\242	\312\314\315\316\215+\232\203\242\312\211\204\247+\211\203\354\306	\n\"\204\354	B\nB))\202\365\205
\211A@\317\3138\"\203
\320@!\210)\202\373*\207" [server-or-method server gnus-server-method-cache gnus-select-method gnus-server-alist gnus-predefined-server-alist assoc "native" format "%s:%s" nil 4 t server-name (byte-code "\206	\n\204\306\307\"\210\306\310\f
D\"\210\211A@)\311\235\203*\312\313@\"\2026\312\314@\211A@)#\211B\211\235\204V\204V\315@\"\204VB*\207" [method gnus-select-method nocache gnus-server-method-cache gnus-server-alist gnus-predefined-server-alist mapc #[(name-method) "A	\232\205\f\302\303@\"\207" [name-method method throw server-name] 3] #[(server-alist) "\301\302\"\207" [server-alist mapc #[(name-method) "\303A	\"\205\n\235\204\nB\304\305@\"\207" [name-method method gnus-server-method-cache gnus-methods-equal-p throw server-name] 3]] 3] (nil "") format "%s" "%s:%s" assoc x name name-method no-enter-cache] 5) gnus-methods-equal-p gnus-agent-flush-group gnus-opened-servers opened x gnus-secondary-select-methods servers gnus-newsrc-alist match method alist no-enter-cache nocache result gnus-command-method entry] 6 (#$ . 61784)])
#@338 Flush the agent's index files such that the GROUP no longer
appears to have any local content.  The actual content, the
article files, may then be deleted using gnus-agent-expire-group.
If flushing was a mistake, the gnus-agent-regenerate-group method
provides an undo mechanism by reconstructing the index files from
the article files.
(defalias 'gnus-agent-flush-group #[(group) "\206\306	!\307\310	\"\307\311	\"\f\312\n!\203\313\n!\210\312!\203(\313!\210\314	\315#\210\314	\316#\210\317\315	\315#,\207" [gnus-command-method group overview agentview nnmail-pathname-coding-system file-name-coding-system gnus-find-method-for-group gnus-agent-article-name ".overview" ".agentview" file-exists-p delete-file gnus-agent-update-view-total-fetched-for nil t gnus-agent-save-group-info] 4 (#$ . 63658) (list (gnus-agent-read-group))])
#@307 Flush the agent's index files such that the group no longer
appears to have any local content.  The actual content, the
article files, is then deleted using gnus-agent-expire-group. The
gnus-agent-regenerate-group method provides an undo mechanism by
reconstructing the index files from the article files.
(defalias 'gnus-agent-flush-cache #[nil "\212\n\203)\n\211@A)q\210\f\306ed\307\310\n\211@@)\"\311\312%\210)\nA\211\204\205w\307\313\211@@)\"\314\315\316!!\317\216rq\210\320\211@A)!\210\321c\210\320\322p\"\210\321c\210)rq\210\306\311\211\311\323%\210,A\211\204.\311*\207" [nnmail-pathname-coding-system file-name-coding-system gnus-agent-buffer-alist x gnus-agent-file-coding-system coding-system-for-write write-region gnus-agent-article-name ".overview" nil silent ".agentview" get-buffer-create generate-new-buffer-name " *temp file*" ((byte-code "\301!\203\n\302!\210\301\207" [#1=#:temp-buffer buffer-name kill-buffer] 2)) princ "\n" 1 0 gnus-agent-group-alist #1# #2=#:temp-file] 7 (#$ . 64510) nil])
#@176 Search for GROUPs SYMBOL in the group's parameters, the group's
topic parameters, the group's category, or the customizable
variables.  Returns the first non-nil value found.
(defalias 'gnus-agent-find-parameter #[(group symbol) "\302	\303#\206\304\305!A	\303#\206	\306\236AJ\207" [group symbol gnus-group-find-parameter t gnus-group-parameter-value gnus-group-category ((agent-short-article . gnus-agent-short-article) (agent-long-article . gnus-agent-long-article) (agent-low-score . gnus-agent-low-score) (agent-high-score . gnus-agent-high-score) (agent-days-until-old . gnus-agent-expire-days) (agent-enable-expiration . gnus-agent-enable-expiration) (agent-predicate . gnus-agent-predicate))] 4 (#$ . 65565)])
#@169 Fetch interesting headers into the agent.  The group's overview
file will be updated to include the headers while a list of available
article numbers will be returned.
(defalias 'gnus-agent-fetch-headers #[(group &optional force) "\205\306\307	\310\"!?\211\2036\203,\311	\f\"J\312
@\313
A\314#]
AB!)\2029\312\311	\f\"J!\2029\315	!4\316\21156\317\320	\"789\n\204\212\321\322\311	:\"J88\323;\211<\203\200<@\211;@\324>\204w\3254;A\"4<A\211<\204b*\326\3274!\330\"444=\204\230>\204\316\331	!\203\316\n\203\254\3324	\"4\202\316\333?!\211@@@)T\311	\f\"JAAB\3344BABC\"4*4\203\335\335\336\337\3404\341\"#\210rCq\2104\203;
\335\342\343\344	!#\210\345\346\3477!\341\"!\210\3504	\"\351=\204
\352 \210\353 \210\354Ded#\210\355	47#\210EF\353 \210\356ed7\323\357%\210)\360	\341\"\210\361	4\323#\2104\210\202@
\323\362\363\217\210*4.\207" [gnus-agent-consider-all-articles group fetch-all gnus-newsgroup-maximum-articles gnus-active-hashtb active gnus-predicate-implies-unread gnus-agent-find-parameter agent-predicate intern-soft gnus-uncompress-range - -1 gnus-list-of-unread-articles identity gnus-agent-article-name ".overview" 3 2 nil (seen recent killed cache) gnus-range-add sort gnus-uncompress-sequence < gnus-agent-load-alist gnus-agent-uncached-articles last gnus-list-range-intersection gnus-message 10 "gnus-agent-fetch-headers: undownloaded articles are '%s'" gnus-compress-sequence t 8 "Fetching headers for %s..." gnus-agent-decoded-group-name gnus-make-directory nnheader-translate-file-chars file-name-directory gnus-retrieve-headers nov nnvirtual-convert-headers gnus-agent-check-overview-buffer copy-to-buffer gnus-agent-braid-nov write-region silent gnus-agent-update-view-total-fetched-for gnus-agent-save-alist (byte-code "\301 \210\302!\207" [file erase-buffer nnheader-insert-file-contents] 2) ((error)) articles gnus-decode-encoded-word-function gnus-decode-encoded-address-function file nnmail-pathname-coding-system file-name-coding-system gnus-newsrc-hashtb arts --dolist-tail-- gnus-agent-cache gnus-plugged gnus-agent-article-alist x high low nntp-server-buffer gnus-agent-overview-buffer gnus-agent-file-coding-system coding-system-for-write] 7 (#$ . 66294)])
#@94 Reads the article number at point.  Returns nil when a valid article number can not be read.
(defalias 'gnus-agent-read-article-number #[nil "\304\305!\2056\306\225\306\224Z\211\307W\203\310p!\2025\307U\2055\306\224\306\225S{\310p!\311\n!	\232\2054\n+)\207" [len str1 num str2 looking-at "[0-9]+	" 0 9 read int-to-string] 3 (#$ . 68547)])
(put 'gnus-agent-read-article-number 'byte-optimizer 'byte-compile-inline-expand)
#@80 Copy the indicated ARTICLE from the overview buffer to the nntp server buffer.
(defalias 'gnus-agent-copy-nov-line #[(article) "\306\211\211q\210m\204Z\307\310!\205H\311\225\311\224Z\211\312W\203%\313p!\202G\f\312U\205G\311\224\311\225S{\313p!\314!
\232\205F+)\211\203T\nW\203Z\315y\210\202	\316 \210m\204h\n=\204nq\202~`\315y\210`q\210\317	#+\207" [e b art gnus-agent-overview-buffer len str1 nil looking-at "[0-9]+	" 0 9 read int-to-string 1 beginning-of-line insert-buffer-substring num str2 article nntp-server-buffer] 4 (#$ . 68986)])
(put 'gnus-agent-copy-nov-line 'byte-optimizer 'byte-compile-inline-expand)
#@307 Merge agent overview data with given file.
Takes unvalidated headers for ARTICLES from
`gnus-agent-overview-buffer' and validated headers from the given
FILE and places the combined valid headers into
`nntp-server-buffer'.  This function can be used, when file
doesn't exist, to valid the overview buffer.
(defalias 'gnus-agent-braid-nov #[(group articles file) "\306\211\nq\210eb\210q\210\307 \210\310\f!\203\311\f!\210db\210\312y\210edU\204\327\313p!\211
@W\204\327\314
@!\203?`\315y\210`|\210
\211A@\306\211\211\nq\210m\204\251\316\317!\205\225\320\225\320\224Z\211\321W\203o\313p!\202\224\321U\205\224\320\224\320\225S{\313p! \322 !!!\232\205\223 +)\211\203\243W\203\251\315y\210\202R\323 \210m\204\270=\204\275q\202\320`\315y\210`q\210\324\n#,\210\306\325\326\217\210db\210
\205
\203\352\nq\210`q\210`\"\324\n	\"\210\"b\210)\206\374\327\330\331\215\205
\202\375*\207" [last start gnus-agent-overview-buffer nntp-server-buffer file articles nil erase-buffer file-exists-p nnheader-insert-file-contents -1 read nnheader-find-nov-line 1 looking-at #1="[0-9]+	" 0 9 int-to-string beginning-of-line insert-buffer-substring (byte-code "\203\276\306p!\211@W\203\307y\210\310\202/	@U\203+\311 \210`\307y\210`|\210\312\202/\311 \210\312)\204\211A@\312\211\211
q\210m\204\226\313\314!\205\205\315\225\315\224Z\211\316W\203_\306p!\202\204\316U\205\204\315\224\315\225S{\306p!\317!\232\205\203+)\211\203\220	\nW\203\226\307y\210\202B\311 \210m\204\243\n	=\204\251q\202\271`\307y\210`q\210\320
\f#,\210\202\312\207" [articles art article e b gnus-agent-overview-buffer read 1 t beginning-of-line nil looking-at #1# 0 9 int-to-string insert-buffer-substring len str1 num str2 nntp-server-buffer] 5) ((error)) -134217728 problems (byte-code "\306\211m\204|\307\310!\205>\311\225\311\224Z\211\312W\203 \313p!\202=\n\312U\205=\311\224\311\225S{\313p!\314\f!
\232\205<\f+)\211\204P\315 \210`\316y\210`|\210\202W\203_\317\316y\210\202U\203s\315 \210`\316y\210`|\210\202\316y\210\202	\203\221\320\316ed#\210eb\210\321\322\323\317\"\210*\306\207" [art sort len str1 num str2 nil looking-at #1# 0 9 read int-to-string beginning-of-line 1 t sort-numeric-fields -134217728 throw problems last] 5) article e b art len str1 num str2 p] 4 (#$ . 69650)])
#@41 Load the article-state alist for GROUP.
(defalias 'gnus-agent-load-alist #[(group) "\n\306\307\"\310\f!\205\311\f\312\301#\211+\207" [group gnus-agent-read-agentview nnmail-pathname-coding-system file-name-coding-system agentview gnus-agent-article-alist gnus-agent-article-name ".agentview" file-exists-p gnus-cache-file-contents gnus-agent-file-loading-cache] 4 (#$ . 72059)])
#@34 Load FILE and do a `read' there.
(defalias 'gnus-agent-read-agentview #[(file) "\301\302!rq\210\303\216\304\305\306\217+\207" [#1=#:temp-buffer generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) nil (byte-code "\306!\210eb\210\307p!\310\311\312\217\310\n\313U\203]\314\310\315 \210\316 q\210eb\210m\204T\317\320!\203N\321\322!\230\203N\323\324\321\325!!\"\211\203N\f\324\321\326!!\241\210\326y\210\202&\327 \210\314*\202R
\n\326U\203l\326U?\202R
\n\322U\203R
\310\211\211\203E
\211 @@)\211 @A)!\310\211\211\"#$!\204\243\310\202(
!A<\204\322!@$!A#$#X\203\314$\"B\"$T\211$\202\266\"\237\202(
!\203%
!@:\204\360!@\247\203
!@\"B\"\202
!\211 @@)$!\211 @A)#$#X\203
$\"B\"$T\211$\202
!A\211!\204\327\"\237,A\203{\211A@BB\202.
\330\331\"+\322U?	\203_
%\332!\210)+\207" [file changed-version version alist entry inhibit-quit nnheader-insert-file-contents read nil (byte-code "\300p!\207" [read] 2) ((end-of-file 0)) 0 t gnus-agent-open-history gnus-agent-history-buffer looking-at "[^	\n]+	\\([0-9]+\\)	\\([^ \n]+\\) \\([0-9]+\\)" match-string 2 assoc string-to-number 3 1 gnus-agent-close-history sort car-less-than-car gnus-agent-save-alist gnus-agent-read-agentview gnus-agent-article-alist-save-format uncomp sequence state x ranges result last first gnus-agent-article-alist] 5) (((end-of-file file-error) (byte-code "\300\301\302\217\207" [nil (byte-code "\306	\307\310\311\"\306\312\313$\f\203/\f\211A@\211A@\204+\314
@!\315\316
8!BB)\202+\207" [alist nnmail-pathname-coding-system file-name-coding-system gnus-agent-read-agentview file-attributes fa nil directory-files-and-attributes gnus-agent-article-name "" "^[0-9]+$" t string-to-number time-to-days 5] 6) ((file-error))] 3)))] 3 (#$ . 72452)])
#@41 Save the article-state alist for GROUP.
(defalias 'gnus-agent-save-alist #[(group &optional articles state) "\306\nB\211\306\211\306\211\211A@\211\203zA\2036A@@W\2036A\211\202!A\204GBC\241\210\202tA@@V\203_BAB\241\210\202tA@@U\203t\211A@)\241\210A\202\fA\307\n\211@@)\310\n!\211@@)#\210\311\312\313\"!\210\312\314\"\315\316\317!! !\320\216r q\210\"\321=\203\276\322\np\"\210\202<
\"\323=\203<
\n\306\211\211\211#$%&''\203
'\211@@)&'\211@A)\211%#\236$'A'$\203\n
$&$AB\241\210\202\324%&D#B#\202\324#''\2035
'\211A'@\211$\324$A\237!\241\210\202
\322#p\"\210-\325c\210\322\"p\"\210\325c\210)r q\210\326\306\211!\306\327%\210,\330\306\".\207" [nnmail-pathname-coding-system file-name-coding-system gnus-agent-article-alist prev all print-level nil gnus-agent-set-local last gnus-make-directory gnus-agent-article-name "" ".agentview" get-buffer-create generate-new-buffer-name " *temp file*" ((byte-code "\301!\203\n\302!\210\301\207" [#1=#:temp-buffer buffer-name kill-buffer] 2)) 1 princ 2 gnus-compress-sequence "\n" write-region 0 gnus-agent-update-view-total-fetched-for print-length item article articles state x group #1# #2=#:temp-file gnus-agent-article-alist-save-format compressed comp-list day-of-download article-id alist] 7 (#$ . 74343)])
(defvar gnus-agent-article-local nil)
(defvar gnus-agent-article-local-times nil)
(defvar gnus-agent-file-loading-local nil)
#@123 Load the METHOD'S local file.  The local file contains min/max
article counts for each of the method's subscribed groups.
(defalias 'gnus-agent-load-local #[(&optional method) "\206	\n\203\304\n!\204\305	\306\307\"J\"\204*\310\311\312!\313\314#\n\203*\nT)\207" [method gnus-command-method gnus-agent-article-local-times gnus-agent-article-local zerop gnus-methods-equal-p intern "+method" gnus-cache-file-contents gnus-agent-lib-file "local" gnus-agent-file-loading-local gnus-agent-read-and-cache-local] 5 (#$ . 75846)])
#@186 Load and read FILE then bind its contents to
gnus-agent-article-local.  If that variable had `dirty' (also known as
modified) original contents, they are first saved to their own file.
(defalias 'gnus-agent-read-and-cache-local #[(file) "\203\302\303\"J\203\304 \210\305	!\207" [gnus-agent-article-local file intern "+dirty" gnus-agent-save-local gnus-agent-read-local] 3 (#$ . 76389)])
#@34 Load FILE and do a `read' there.
(defalias 'gnus-agent-read-local #[(file) "\304\305ed\"!\306\307\310!r\nq\210\311\216\312\313\314\217\210eb\210g\315U\203*\306y\210T\202m\204<\316\317\320\217\210\306y\210T\202*+\321\322	\"\312L\210\321\323	\"L\210	*\207" [line my-obarray #1=#:temp-buffer gnus-command-method gnus-make-hashtable count-lines 1 generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) nil (byte-code "\303\n!\210)\303\207" [gnus-agent-file-coding-system nnheader-file-coding-system file nnheader-insert-file-contents] 2) ((file-error)) 59 err (byte-code "\306\211\211p\307\n!\307\n!\307\n!
;\203 \310
\"
\f\311\\\311\\BL\210-\306\207" [my-obarray obarray cur max min group nil read intern 0] 5) ((error (byte-code "\303\304\305	\306\n!%\207" [file line err gnus-message 3 "Warning - invalid agent local: %s on line %d: %s" error-message-string] 7))) intern "+dirty" "+method"] 4 (#$ . 76788)])
#@70 Save gnus-agent-article-local under it method's agent.lib directory.
(defalias 'gnus-agent-save-local #[(&optional force) "\211\205e\n\204\306\307	\"J\205e\306\310	\"J\311\312!\313\311\314!!\210
\f\315\316\317!!\320\216rq\210\306\310	\"J\321\211\211\211p\322\323	\".rq\210\324\321\211\321\325%\210.)\207" [gnus-agent-article-local my-obarray force gnus-command-method dest gnus-agent-file-coding-system intern "+dirty" "+method" gnus-agent-lib-file "local" gnus-make-directory "" get-buffer-create generate-new-buffer-name " *temp file*" ((byte-code "\301!\203\n\302!\210\301\207" [#1=#:temp-buffer buffer-name kill-buffer] 2)) nil mapatoms #[(symbol) "\302!\204\303\207\304!\305\235\203\303\207J\211\2052\306!\210\307\310!\210\307	@!\210\307\310!\210\307	A!\210\307\311!)\207" [symbol range boundp nil symbol-name ("+dirty" "+method") prin1 princ " " "\n"] 3] write-region 0 nnmail-pathname-coding-system file-name-coding-system coding-system-for-write #1# #2=#:temp-file standard-output article item print-length print-level] 8 (#$ . 77785)])
(defalias 'gnus-agent-get-local #[(group &optional gmane method) "\206	\306\307\n\"\203\n\310\225\311O\202\n)\206\312	!\313 \314
\"\315!\2053J\211\204n\316	!\211\203m\211@@)\317!\211@@)B\320	@A\f
&\210+-\207" [gmane group gname method gnus-command-method local string-match "^[^:]+:" 0 nil gnus-find-method-for-group gnus-agent-load-local intern boundp gnus-agent-load-alist last gnus-agent-set-local symb minmax gnus-agent-article-alist gnus-agent-file-loading-cache alist x] 8])
(defalias 'gnus-agent-set-local #[(group min max &optional gmane method local) "\206	\306\307\n\"\203\n\310\225\311O\202\n)\206\312	!
\206&\313 \314
\"\315!\2057J\211\203h@=\203OA=\204h\203h\203h\240\210\241\210\202\217\203q\311\202\225\203\207\203\207BL\210\202\217\316
\"\205\225\314\317
\"\320L-\207" [gmane group gname method gnus-command-method local string-match "^[^:]+:" 0 nil gnus-find-method-for-group gnus-agent-load-local intern boundp unintern "+dirty" t symb minmax min max] 4])
(defalias 'gnus-agent-article-name #[(article group) "\302\303\304	!!\"\207" [article group expand-file-name file-name-as-directory gnus-agent-group-pathname] 5])
#@34 Show error message and return t.
(defalias 'gnus-agent-batch-confirmation #[(msg) "\301\302\303#\210\304\207" [msg gnus-message 1 "%s" t] 4 (#$ . 80149)])
#@31 Start Gnus and fetch session.
(defalias 'gnus-agent-batch-fetch #[nil "\301 \210\302\303 \210)\304 \207" [gnus-agent-confirmation-function gnus gnus-agent-batch-confirmation gnus-agent-fetch-session gnus-group-exit] 1 (#$ . 80311) nil])
#@64 Fetch all articles and headers that are eligible for fetching.
(defalias 'gnus-agent-fetch-session #[nil "\204\306\307!\210	\204\306\310!\210\300 \311\211\211\212
\203u
@\312\n!\204-\313\n!\203n\314\n!\203n\315
@!\316\216\317\320 \210\f\211A@\211\203m\321!X\203@\204]\203e\322\n\"\210\202@\323\324\325\217\210\202@*
A\211\204\326\327!\210\330\331\332\"-\207" [gnus-agent-covered-methods gnus-plugged gnus-command-method group groups methods error "No servers are covered by the Gnus agent" "Can't fetch articles while Gnus is unplugged" nil gnus-server-opened gnus-open-server gnus-online gnus-groups-from-server ((gnus-agent-stop-fetch)) t gnus-agent-start-fetch gnus-group-level gnus-agent-fetch-group-1 err (gnus-agent-fetch-group-1 group gnus-command-method) ((error (byte-code "\302\303\304	!\"!\204\305\306!\210\302\207" [gnus-agent-confirmation-function err format "Error %s while fetching session.  Should gnus continue? " error-message-string error "Cannot fetch articles into the Gnus agent"] 5)) (quit (byte-code "\303!\210	\304\305\306\n!\"!\204\307\310\311\"\210\303\207" [group gnus-agent-confirmation-function err gnus-agent-regenerate-group format "%s while fetching session.  Should gnus continue? " error-message-string signal quit "Cannot fetch articles into the Gnus agent"] 5))) gnus-run-hooks gnus-agent-fetched-hook gnus-message 6 "Finished fetching articles into the Gnus agent" gnus-agent-fetching gnus-agent-handle-level debug-on-error debug-on-quit] 5 (#$ . 80555) nil])
#@14 Fetch GROUP.
(defalias 'gnus-agent-fetch-group-1 #[(group method) "	\n\f
:;<\306\211\211\211\211\211\211\211\211=>?@ABCDE<;:FG\307	!\204@\310\311	\"\210H\204T\312	I\"J\204T\313	!\205JKH\204\227L\306M\211N\203\226N@\211M\314\315\312	O\"J8\211?8\236A\211B\203\214\316B!K\244K)NA\211N\204h*\317K\320\"K\321	!C\317\322KC\"\320\"\211C\205
\n\206\274\323CG\324\"\206\310\325C\306\211	$\326 \210\327	!A\330\331	\332\"!\211@\333>\204
\331	\334\"\211=\203
=\335=\203\370\336	!=\202
=@;\204
=CC==\203
\337=!\210)@\340=\205
K??\205
\306C\211B\341	!KKPQ\211A@\211E\203\325
E\324HRP\203]
RP\211S@@)V\203]
PA\211P\204F
RP\211S@@)=\203v
P\211S@A)\204\321
K\203\215
RK@V\203\215
KA\211K\204{
RK@=\204\310
R\f\236A\206\240
T\331	\342\"\331	\343\"\331	\344\"\331	\345\"\331	\346\"UVWXYD@ .\203\321
QR\306B\241Q)\2020
,\306Z\347[BA\205\350
\350	BA\"\211Z\"[\347BAZ\"\\H\203}K\306]\211N\203N@]\351]\352\"\210NA\211N\204*Z\306]\211N\203WN@]^\203@\353]J\"J\354]_\"\210\355]\306\352#\203N\356]!\210NA\211N\204'*\\\306]\211N\205yN@]\354]`\"\210NA\211N\204c\306*\202L\306M\211N\203\306N@\211M\357=\203\275M\314\315\312	O\"J8\211?8\236\211aA\203\274\353a\314?8\">\314?\233>\240\210)NA\211N\204\210*\315?\206\330\315\312	O\"J8\211?8b?AA\360b\\\"\240\210)\361	\352\"\210\362\324!\210\363\364\365?!\366Q\367\370	!\371Q\"+).\207" [method group gnus-newsgroup-dependencies gnus-newsgroup-headers gnus-newsgroup-scored gnus-use-cache nil gnus-check-group error "Can't open server for %s" intern-soft gnus-activate-group 3 2 gnus-uncompress-range sort < gnus-agent-fetch-headers append make-vector 0 gnus-get-newsgroup-headers-xover gnus-agent-create-buffer gnus-group-category gnus-get-predicate gnus-agent-find-parameter agent-predicate (gnus-agent-true gnus-agent-false) agent-score-file file gnus-all-score-files gnus-score-headers gnus-agent-false gnus-agent-load-alist agent-long-article agent-short-article agent-low-score agent-high-score agent-days-until-old gnus-sorted-ndifference gnus-agent-fetch-articles gnus-summary-set-agent-mark t delq gnus-summary-mark-article gnus-summary-goto-subject gnus-summary-update-download-mark download gnus-add-to-range gnus-group-update-group sit-for gnus-dribble-enter "(gnus-group-set-info '" gnus-prin1-to-string ")" "^(gnus-group-set-info '(\"" regexp-quote "\"" gnus-summary-expunge-below gnus-summary-mark-below gnus-orphan-score score-param marks info predicate category arts articles gnus-score gnus-headers gnus-newsgroup-name gnus-command-method gnus-newsgroup-active gnus-active-hashtb gnus-newsgroup-downloadable marked-articles gnus-agent-download-marks mark --dolist-tail-- gnus-newsrc-hashtb alist arts-tail num x gnus-summary-default-score gnus-agent-expire-days gnus-agent-high-score gnus-agent-low-score gnus-agent-short-article gnus-agent-long-article fetched-articles gnus-newsgroup-undownloaded unfetched-articles article gnus-agent-mark-unread-after-downloaded gnus-unread-mark gnus-canceled-mark marked-arts read] 19 (#$ . 82101)])
#@43 Hook run in `gnus-category-mode' buffers.
(defvar gnus-category-mode-hook nil (#$ . 85288))
#@216 Format of category lines.

Valid specifiers include:
%c  Topic name (string)
%g  The number of groups in the topic (integer)

General format specifiers can also be used.  See Info node
`(gnus)Formatting Variables'.
(defvar gnus-category-line-format "     %(%20c%): %g\n" (#$ . 85387))
#@54 The format specification for the category mode line.
(defvar gnus-category-mode-line-format "Gnus: %%b" (#$ . 85678))
#@65 The selection predicate used when no other source is available.
(defvar gnus-agent-predicate 'false (#$ . 85802))
#@53 Articles that have fewer lines than this are short.
(defvar gnus-agent-short-article 500 (#$ . 85922))
#@51 Articles that have more lines than this are long.
(defvar gnus-agent-long-article 1000 (#$ . 86031))
#@62 Articles that have a score lower than this have a low score.
(defvar gnus-agent-low-score 0 (#$ . 86138))
#@64 Articles that have a score higher than this have a high score.
(defvar gnus-agent-high-score 0 (#$ . 86250))
(defvar gnus-category-buffer "*Agent Category*")
(defvar gnus-category-line-format-alist '((99 gnus-tmp-name 115) (103 gnus-tmp-groups 100)))
(defvar gnus-category-mode-line-format-alist '((117 user-defined 115)))
(defvar gnus-category-line-format-spec nil)
(defvar gnus-category-mode-line-format-spec nil)
(defvar gnus-category-mode-map nil)
(byte-code "\301\302\303\304#\210\204\305 \306!\210\307\300\310\"\210\301\207" [gnus-category-mode-map put gnus-category-mode mode-class special make-sparse-keymap suppress-keymap gnus-define-keys-1 ("q" gnus-category-exit "k" gnus-category-kill "c" gnus-category-copy "a" gnus-category-add "e" gnus-agent-customize-category "p" gnus-category-edit-predicate "g" gnus-category-edit-groups "s" gnus-category-edit-score "l" gnus-category-list "	" gnus-info-find-node "" gnus-bug)] 4)
#@43 *Hook run after the creation of the menu.
(defvar gnus-category-menu-hook nil (#$ . -87197))
(defalias 'gnus-category-make-menu-bar #[nil "\301\302!\210\303\304!?\205\305\306!\210\307\304\310\311$\210\312\313!\207" [gnus-category-mode-map gnus-turn-off-edit-menu category boundp gnus-category-menu (lambda (#1=#:def-tmp-var) (defvar gnus-category-menu #1# #2="")) nil easy-menu-do-define #2# ("Categories" ["Add" gnus-category-add t] ["Kill" gnus-category-kill t] ["Copy" gnus-category-copy t] ["Edit category" gnus-agent-customize-category t] ["Edit predicate" gnus-category-edit-predicate t] ["Edit score" gnus-category-edit-score t] ["Edit groups" gnus-category-edit-groups t] ["Exit" gnus-category-exit t]) gnus-run-hooks gnus-category-menu-hook] 5])
#@281 Major mode for listing and editing agent categories.

All normal editing commands are switched off.
\<gnus-category-mode-map>
For more in-depth information on this mode, read the manual
(`\[gnus-info-find-node]').

The following commands are available:

\{gnus-category-mode-map}
(defalias 'gnus-category-mode #[nil "\306\307\310\"\203\n\311 \210\312 \210\313 \210\314\315\316 \210\317\320!\210\321 \210\322\211\323\324!\207" [major-mode mode-name mode-line-process gnus-category-mode-map truncate-lines buffer-read-only gnus-visual-p category-menu menu gnus-category-make-menu-bar kill-all-local-variables gnus-simplify-mode-line gnus-category-mode "Category" gnus-set-default-directory nil use-local-map buffer-disable-undo t gnus-run-mode-hooks gnus-category-mode-hook] 4 (#$ . 87962) nil])
(defalias 'gnus-category-position-point 'gnus-goto-colon)
(defalias 'gnus-category-insert-line #[(category) "\304\305@\"\306\236AG\307 \210\310``T\311!\210\312	D#*\207" [category gnus-tmp-name gnus-tmp-groups gnus-category-line-format-spec format "%s" agent-groups beginning-of-line gnus-add-text-properties eval gnus-category] 5])
#@28 Go to the Category buffer.
(defalias 'gnus-enter-category-buffer #[nil "\300 \210\301\302!\210\303 \207" [gnus-category-setup-buffer gnus-configure-windows category gnus-category-prepare] 2 (#$ . 89106) nil])
(defalias 'gnus-category-setup-buffer #[nil "\301!?\205r\302!q\210\303 )\207" [gnus-category-buffer get-buffer gnus-get-buffer-create gnus-category-mode] 2])
(defalias 'gnus-category-prepare #[nil "\303\304!\210\303\305\306\"\210\307\310 \210\n\203\311\n\211A@!\210\202eb\210\312 *\207" [gnus-category-alist buffer-read-only alist gnus-set-format category-mode category t nil erase-buffer gnus-category-insert-line gnus-category-position-point] 3])
(defalias 'gnus-category-name #[nil "\300\301\302 \303\"!\206
\304\305!\207" [intern get-text-property point-at-bol gnus-category error "No category on the current line"] 4])
#@26 Read the category alist.
(defalias 'gnus-category-read #[nil "\304\305!rq\210\306\216\307\310\311\217+\206!\312\313\211\314	\206\315*BDC\211\207" [#1=#:temp-buffer default-agent-predicate name gnus-category-alist generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) nil (byte-code "\303\304\305\"!\210eb\210\306p!\307\310\311\217\211\203\n\202\312\313	\"*\207" [gnus-agent-directory old-list new-list nnheader-insert-file-contents nnheader-concat "lib/categories" read nil (byte-code "\300p!\207" [read] 2) ((error)) mapcar #[(c) "\306\307\211\211B\211A\310\2037\f\2037\n@\f@\211	\205&
	B*\307B\241\210\nAA\fA\202	A,\"\241\210\207" [c #2=#:result #3=#:result-tail #4=#:head1 #5=#:head2 symb delq nil (agent-predicate agent-score-file agent-groups) valu] 7]] 5) ((error)) default short agent-predicate false] 4 (#$ . 89958)])
#@27 Write the category alist.
(defalias 'gnus-category-write #[nil "\306\211\307\310\n\311\"!\210\310\n\312\"\313\314\315!!\316\216rq\210\317\320\321
\"p\"\210\322 \210\317
p\")rq\210\323\306\211\f\306\324%\210,\207" [gnus-category-predicate-cache gnus-category-group-cache gnus-agent-directory #1=#:temp-buffer #2=#:temp-file gnus-category-alist nil gnus-make-directory nnheader-concat "lib" "lib/categories" get-buffer-create generate-new-buffer-name " *temp file*" ((byte-code "\301!\203\n\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) prin1 mapcar #[(c) "@\301\302\"A\301\303\"A\301\304\"AF\207" [c assoc agent-predicate agent-score-file agent-groups] 6] newline write-region 0] 8 (#$ . 90882)])
#@34 Edit the predicate for CATEGORY.
(defalias 'gnus-category-edit-predicate #[(category) "	\236\303\304\n\236A\305\306\"\307\310\311\312\313D\314BB\315BB\316BBB#)\207" [category gnus-category-alist info gnus-edit-form agent-predicate format "Editing the select predicate for category %s" lambda (predicate) gnus-agent-cat-set-property assq quote (gnus-category-alist) ('agent-predicate predicate) ((gnus-category-write) (gnus-category-list))] 9 (#$ . 91603) (list (gnus-category-name))])
#@41 Edit the score expression for CATEGORY.
(defalias 'gnus-category-edit-score #[(category) "	\236\303\304\n\236A\305\306\"\307\310\311\312\313D\314BB\315BB\316BBB#)\207" [category gnus-category-alist info gnus-edit-form agent-score format "Editing the score expression for category %s" lambda (score-file) gnus-agent-cat-set-property assq quote (gnus-category-alist) ('agent-score-file score-file) ((gnus-category-write) (gnus-category-list))] 9 (#$ . 92098) (list (gnus-category-name))])
#@35 Edit the group list for CATEGORY.
(defalias 'gnus-category-edit-groups #[(category) "	\236\303\304\n\236A\305\306\"\307\310\311\312\313D\314BB\315BB\316BBB#)\207" [category gnus-category-alist info gnus-edit-form agent-groups format "Editing the group list for category %s" lambda (groups) gnus-agent-set-cat-groups assq quote (gnus-category-alist) (groups) ((gnus-category-write) (gnus-category-list))] 9 (#$ . 92595) (list (gnus-category-name))])
#@28 Kill the current category.
(defalias 'gnus-category-kill #[(category) "	\236\304\305 \306y\210`|\210\307	\"\310 *\207" [category gnus-category-alist buffer-read-only info nil point-at-bol 1 delq gnus-category-write] 3 (#$ . 93054) (list (gnus-category-name))])
#@28 Copy the current category.
(defalias 'gnus-category-copy #[(category to) "	\236\306\n!\211\211
\240\210)\307\310\"\210))	B\311 \210\312 )\207" [category gnus-category-alist info newcat #1=#:v to gnus-copy-sequence gnus-agent-set-cat-groups nil gnus-category-write gnus-category-list #2=#:v] 4 (#$ . 93326) (list (gnus-category-name) (intern (read-string "New name: ")))])
#@24 Create a new category.
(defalias 'gnus-category-add #[(category) "	\236\203\304\305\"\210\306\211\307\n\206\310*BD	B\311 \210\312 \207" [category gnus-category-alist default-agent-predicate name error "Category %s already exists" nil agent-predicate false gnus-category-write gnus-category-list] 4 (#$ . 93715) "SCategory name: "])
#@22 List all categories.
(defalias 'gnus-category-list #[nil "\300 \207" [gnus-category-prepare] 1 (#$ . 94063) nil])
#@29 Return to the group buffer.
(defalias 'gnus-category-exit #[nil "\300p!\210\301\302\303\"\207" [kill-buffer gnus-configure-windows group t] 3 (#$ . 94183) nil])
(defvar gnus-category-not (byte-code "\300\301\302\303\304\305\"!E\207" [! not intern format "%c" 172] 6))
#@68 Mapping from short score predicate symbols to predicate functions.
(defvar gnus-category-predicate-alist '((spam . gnus-agent-spam-p) (short . gnus-agent-short-p) (long . gnus-agent-long-p) (low . gnus-agent-low-scored-p) (high . gnus-agent-high-scored-p) (read . gnus-agent-read-p) (true . gnus-agent-true) (false . gnus-agent-false)) (#$ . 94457))
#@40 Say whether an article is spam or not.
(defalias 'gnus-agent-spam-p #[nil "\204\303\304!	\305H\306\232\205#\307	\310H!\311\n\"J\312\n\"\313L\210)\207" [gnus-agent-spam-hashtb gnus-headers string gnus-make-hashtable 1000 5 "" gnus-simplify-subject 1 intern-soft intern t] 4 (#$ . 94813)])
#@41 Say whether an article is short or not.
(defalias 'gnus-agent-short-p #[nil "\302H	W\207" [gnus-headers gnus-agent-short-article 7] 2 (#$ . 95115)])
#@40 Say whether an article is long or not.
(defalias 'gnus-agent-long-p #[nil "\302H	V\207" [gnus-headers gnus-agent-long-article 7] 2 (#$ . 95271)])
#@48 Say whether an article has a low score or not.
(defalias 'gnus-agent-low-scored-p #[nil "	W\207" [gnus-score gnus-agent-low-score] 2 (#$ . 95424)])
#@49 Say whether an article has a high score or not.
(defalias 'gnus-agent-high-scored-p #[nil "	V\207" [gnus-score gnus-agent-high-score] 2 (#$ . 95579)])
#@40 Say whether an article is read or not.
(defalias 'gnus-agent-read-p #[nil "\303\304H\305\211\306	\n\"J88\"\207" [gnus-headers gnus-newsgroup-name gnus-newsrc-hashtb gnus-member-of-range 0 2 intern-soft] 7 (#$ . 95737)])
#@33 Make a function from PREDICATE.
(defalias 'gnus-category-make-function #[(predicate) "\302!\211G\303U\203	@9\203	@\202\304\305\306	E!)\207" [predicate func gnus-category-make-function-1 1 gnus-byte-compile lambda nil] 5 (#$ . 95964)])
#@11 Return t.
(defalias 'gnus-agent-true #[nil "\300\207" [t] 1 (#$ . 96213)])
#@13 Return nil.
(defalias 'gnus-agent-false #[nil "\300\207" [nil] 1 (#$ . 96294)])
#@33 Make a function from PREDICATE.
(defalias 'gnus-category-make-function-1 #[(predicate) "9\204\303!\203	\236A\206C\207:\203?@\304>\203%\305\2028@\306>\2030\307\2028@\n>\2058\310\311\312A\"B\207\313\314\"\207" [predicate gnus-category-predicate-alist gnus-category-not functionp (& and) and (| or) or not mapcar gnus-category-make-function-1 error "Unknown predicate type: %s"] 4 (#$ . 96380)])
#@45 Return the function implementing PREDICATE.
(defalias 'gnus-get-predicate #[(predicate) "\303	\"A\206\304!	\nBC\244\n)\207" [predicate gnus-category-predicate-cache func assoc gnus-category-make-function] 3 (#$ . 96801)])
#@223 Say whether PREDICATE implies unread articles only.
It is okay to miss some cases, but there must be no false positives.
That is, if this predicate returns true, then indeed the predicate must
return only unread articles.
(defalias 'gnus-predicate-implies-unread #[(predicate) "\301\302!!\303=\207" [predicate gnus-function-implies-unread-1 gnus-category-make-function-1 t] 3 (#$ . 97037)])
#@287 Recursively evaluate a predicate function to determine whether it can select
any read articles.  Returns t if the function is known to never
return read articles, nil when it is known to always return read
articles, and t_nil when the function may return both read and unread
articles.
(defalias 'gnus-function-implies-unread-1 #[(function) "@\303\304A\"\211\305=\203#\306	>\203\306\202\205\307	>\205\205\307\202\205\n\310=\203A\311	>\2033\311\202\205\307	>\203=\307\202\205\306\202\205\n\312=\203Y	@\307=\203S	@\202\205	@?\202\205\n\313=\203c\311\202\205\n\314=\203m\306\202\205\n\315=\203w\311\202\205\316\317\215\203\201\307\202\205\320\321\"*\207" [function args func mapcar gnus-function-implies-unread-1 and t t_nil or nil not gnus-agent-read-p gnus-agent-false gnus-agent-true found-match (byte-code "	\205!\n	\211@A)=\203\304\305\306\"\210\202	A\211\204\307)\207" [gnus-category-predicate-alist alist func x throw found-match t nil] 4) error "Unknown predicate function: %s"] 5 (#$ . 97436)])
#@39 Return the category GROUP belongs to.
(defalias 'gnus-group-category #[(group) "\2040\306\307!	\310\211\f\211A@\211\203/\311\n\236A\203\312\211A@\"\nL\210\202+\313
\"J\206;\314	\236\207" [gnus-category-group-cache gnus-category-alist cat groups cs group gnus-make-hashtable 1000 nil agent-groups intern intern-soft default] 3 (#$ . 98483)])
#@426 Expire all old articles in GROUP.
If you want to force expiring of certain articles, this function can
take ARTICLES, and FORCE parameters as well.

The articles on which the expiration process runs are selected as follows:
  if ARTICLES is null, all read and unmarked articles.
  if ARTICLES is t, all articles.
  if ARTICLES is a list, just those articles.
FORCE is equivalent to setting the expiration predicates to true.
(defalias 'gnus-agent-expire-group #[(group &optional articles force) "\204\n\306	\n#\207\307\211\310E	\311=\203\312\313\314\315R!\203r\316!\317\320!\321$\322\216\323\324!%\325%!\203q\326\327!&r&q\210\330\216\331%!\210\332$\333\334ed\"!\211\"\210+\212\335
\336\f\"'\337'!\205k'J)	\n%\210)-\340\341\342\343 #)\207" [group articles force gnus-agent-expire-stats orig overview gnus-agent-expire 0 0.0 t yes-or-no-p "Are you sure that you want to " "expire all articles in " "? " gnus-find-method-for-group gnus-get-buffer-create " *expire overview*" nil ((kill-buffer overview)) gnus-agent-lib-file "active" file-exists-p generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1=#:temp-buffer buffer-name kill-buffer] 2)) nnheader-insert-file-contents gnus-active-to-gnus-format gnus-make-hashtable count-lines gnus-agent-expire-group-1 intern-soft boundp gnus-message 4 "%s" gnus-agent-expire-done-message gnus-command-method active-file #1# sym] 6 (#$ . 98851) (list (gnus-agent-read-group))])
(defalias 'gnus-agent-expire-group-1 #[(group overview active articles force) "\306!	\307!\310\311\312!\203\f\312JB\n@\204.\313\314\"\315=\203.\316\317\320\n#\202\266\316\317\321\n#\210\322!\210\323A\324B\323\211CD\325\326E\"J8FGH\327\330 !\313\331\"ZIH\205s@?\205s\332H!\211J@@)CKL\203~\333\202\261M\310=\203\211\333\202\261M\204\225\333\334\335\217\202\261\336\337H\211J@@)\332H!\211J@@)B!\340M\341\"\"NL\203\274\333\202\343M\310=\203\307\333\202\343M\203\320\333\202\343\337\342\343F8\236A!\337\344\343F8\236A!\244O\f\345PP\323Q\346R\333\211ST\347\350H\"\211S\347\351N\"\244\211S\347\352O\"\244\211S\347\353K\"\244SUq\210\354 \210\355 \210\356P!\203S
\316\357\360\"\210\361P!\210eb\210\333V`\211VdW\203M
\333\362\363\217\210\364y\210\2029
)\316\357\365\"\210\366\333!\210\316\357\367\"\210\323\364\325WOX\340S\370\"S+\316\357\371\"\210\316\357\372\"\210SSSA\203\362
S\211J@@)SA@@=\203\351
S@AS\211JA@)AY\211Z\211@\206\254
Y@\240\210ZAZYAYZ\211@\206\302
Y@\240\210ZAZYAYZ\211@\206\330
Y@\240\210S\211J\211AA)\241\210*\202{
SA\211S\202}
)\373\374\215\203\316\357\375\"\210\376\377S\"\210\316\357\201x\"\210\201ySG![\333C\211H\\\323]S\203$\201z\201{QT\211Q[\245_!\333^\211_RV\203M_R\316\357\201|R#\210*S@\211`@a`A@b\325`8c\343`8dc\203\341\201}eX\203\222\201~\201\nacb\203\215\201\200\202\220\201\201%\210b\203\322\356\f\201\202a!P!\204\306`A\211f\333\240\210)\343eX\203\306\201~\201\203\nS\211J@@)#\210d\204\322\316\364\201\204\"\210\\abB\333B\241\\\202b\250\204\355\201\205\202 \356\f\201\202a!P!\204\n`A\211g\333\240\210)\201\206\202 bIW\203\201\207\202 @\205 \201\210\211T\203\347\333hT\201\211>\203E\333\201\212\201\213\217\210`A\211i\333\240\210)d\203\223\201\214hBh\201\215d!\203`d\202ed]Zb\210DTD\201\216 j\364y\210`\211kjZlAl\\A]l\\]jk|\210+m\203\260an@Y\203\260\\abB\333B\241\\\202\276\201\217\201\220T\"hBhh\203\343\201\221eX\203\343\201~\201\222\na\201\223\201\224h\201\225#$\210)\202\201}eX\203\373\201~\201\226\na#\210\\abB\333B\241\\d\203\201\215d!\203d\333\211\223\210SAS-\202HAH\310oHG\232\204>HG\201\227!\210\201\230 \203hpq\201\231\f!\210\201\232edP\333\201\233%\210\366\333!\210\201\234\310\"\210)M\310=\203t\201\235 \210-\311\201\236!\203\254\201\236J\211rAA\211s\211@A\\\240\210)rA\211t\211@C\\\240\210)r\211u\211@D\\\240\210*\201\237B[\".)v\203\320
\204\320rwq\210\333v\201\240\310\"\210)+\207" [group nnmail-pathname-coding-system decoded file-name-coding-system dir gnus-agent-inhibit-update-total-fetched-for gnus-agent-group-pathname gnus-agent-decoded-group-name t boundp gnus-agent-expire-current-dirs gnus-agent-find-parameter agent-enable-expiration DISABLE gnus-message 5 "Expiry skipping over %s" "Expiring articles in %s" gnus-agent-load-alist 0 0.0 2 intern-soft time-to-days current-time agent-days-until-old last nil (gnus-agent-unread-articles group) ((error)) gnus-sorted-difference gnus-uncompress-range sort < tick 3 dormant ".overview" -1 mapcar #[(e) "@A\301\211F\207" [e nil] 4] #[(e) "\301\302\301F\207" [e nil unread] 4] #[(e) "\301\302\301F\207" [e nil marked] 4] #[(e) "\301\302\301F\207" [e nil special] 4] erase-buffer buffer-disable-undo file-exists-p 7 "gnus-agent-expire: Loading overview..." nnheader-insert-file-contents (byte-code "\302p!\303\\\304\211F	B\304\207" [p dlist read 0 nil] 4) ((error (byte-code "\301\302\303`$\207" [nov-file gnus-message 1 "gnus-agent-expire: read error occurred when reading expression at %s in %s.  Skipping to next line."] 5))) 1 "gnus-agent-expire: Loading overview... Done" set-buffer-modified-p "gnus-agent-expire: Sorting entries... " #[(a b) "@	@W\203\n\302\207@	@V\203\303\207\3048J\206\305\304	8J\206$\305\211	X*\207" [a b t nil 2 3] 4] "gnus-agent-expire: Sorting entries... Done" "gnus-agent-expire: Merging entries... " sort-results (byte-code "\303\304\205)\305\211A@8\211\203	\nW\203$\306\307\310\"\210\202	\202+\207" [dlist pos prev-pos -1 nil 3 throw sort-results unsorted] 3) "gnus-agent-expire: Unsorted overview; inserting markers to compensate." mapc #[(entry) "\3038\211\205\303\233\211\304 	\305\223\240))\207" [entry pos #1=#:c 3 make-marker nil] 5] force bytes-freed size-files-deleted files-deleted nov-entries-deleted gnus-newsrc-hashtb info gnus-agent-article-alist alist day x specials gnus-agent-expire-all articles unreads marked nov-file cnt completed dlist type overview p unread special secnd first len tail-alist position-offset message-log-max new-completed entry article-number fetch-date keep marker gnus-verbose #2=#:c #3=#:c actions #4=#:c from to freed gnus-agent-consider-all-articles active inhibit-quit gnus-agent-file-coding-system coding-system-for-write stats #5=#:c #6=#:c #7=#:c gnus-agent-need-update-total-fetched-for gnus-group-buffer "gnus-agent-expire: Merging entries... Done" float truncate 100.0 "%3d%% completed..." 10 message "gnus-agent-expire: %s:%d: Kept %s article%s." " and file" "" number-to-string "gnus-agent-expire cleared download flag on %s:%d as the cached article file is missing." "gnus-agent-expire detected a missing NOV entry.  Run gnus-agent-regenerate-group to restore it." read externally-expired expired forced (forced expired) (byte-code "\306\307	!\"\310\311\312\n!8!\f\\
\\
T
\313\n!\210*\314B\306\207" [dir article-number file-name size bytes-freed size-files-deleted nnheader-concat number-to-string float 7 file-attributes delete-file "expired cached article" files-deleted actions] 4) ((error)) "NOV entry removed" markerp point-at-bol format "Removed %s article number from article alist" 8 "gnus-agent-expire: %s:%d: %s" mapconcat identity ", " "gnus-agent-expire: %s:%d: Article kept as expiration tests failed." gnus-agent-save-alist buffer-modified-p gnus-make-directory write-region silent gnus-agent-update-view-total-fetched-for gnus-summary-update-info gnus-agent-expire-stats gnus-agent-update-files-total-fetched-for gnus-group-update-group] 9])
#@474 Expire all old articles.
If you want to force expiring of certain articles, this function can
take ARTICLES, GROUP and FORCE parameters as well.

The articles on which the expiration process runs are selected as follows:
  if ARTICLES is null, all read and unmarked articles.
  if ARTICLES is t, all articles.
  if ARTICLES is a list, just those articles.
Setting GROUP will limit expiration to that group.
FORCE is equivalent to setting the expiration predicates to true.
(defalias 'gnus-agent-expire #[(&optional articles group force) "\203\n\306	\n#\207	\307=\203\310\311!\205\265\312 \313\314\211\315E\313\211\211$%&\316\317!\320\216&\211A&@\211\203\251\321\322!'\323'!\203\245\324\325!(r(q\210\326\216\327'!\210\330
\331\332ed\"!\211\"\210+\333
!\313)\211*\203\244*@)\334)\"+\335+!\205\207+J)\211,\203\232\212\336)\f,	\n%\210))*A\211*\204q*)\202/)\337 \210\340\341\342\343 #.\207" [group articles force orig overview gnus-command-method gnus-agent-expire-group t yes-or-no-p "Are you sure that you want to expire all articles in every agentized group? " gnus-agent-covered-methods nil 0 0.0 gnus-get-buffer-create " *expire overview*" ((kill-buffer overview)) gnus-agent-lib-file "active" file-exists-p generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1=#:temp-buffer buffer-name kill-buffer] 2)) nnheader-insert-file-contents gnus-active-to-gnus-format gnus-make-hashtable count-lines gnus-groups-from-server intern-soft boundp gnus-agent-expire-group-1 gnus-agent-expire-unagentized-dirs gnus-message 4 "%s" gnus-agent-expire-done-message gnus-agent-expire-stats gnus-agent-expire-current-dirs methods active-file #1# expiring-group --dolist-tail-- sym active] 7 (#$ . 106546) nil])
(defalias 'gnus-agent-expire-done-message #[nil "\304V\2037\305\306!\2037\306J\307	8\310\n\311V\203*A\203*\n\312\245A\202\313\314	@	A@\n@%+\207\315\207" [gnus-verbose stats size units 4 boundp gnus-agent-expire-stats 2 (B KB MB GB) 1024.0 1024.0 format "Expiry recovered %d NOV entries, deleted %d files, and freed %.f %s." "Expiry...done"] 6])
(defalias 'gnus-agent-expire-unagentized-dirs #[nil "\205\233\306\302!\205\233\307 \302J\310\f\311	\"\312L\210\n\203I\n\211A@\211;\203\313!\203\314	\"J\204\311	\"\312L\210\315\316!!\2021\310\211\317\211\320!!\210\205\231\204i\321\322!\205\231\205\231\211A@\204\204\321\323\324\"!\203\225\310\211\310\325\211!\210,)\202i.\207" [gnus-agent-expire-unagentized-dirs keep gnus-agent-expire-current-dirs dir nnmail-pathname-coding-system file-name-coding-system boundp gnus-make-hashtable nil intern t file-directory-p intern-soft file-name-directory directory-file-name #[(d) "\306!\307\n\211A@\211\205b	\310\232\204	\311\232\204	\312\232\203O\313!\307\314\315!\211\f\"J\204=\316!\202(\203K
\235\204K
B*\202\317\320	\"\211!\203	!\210\202*\207" [d file files r keep to-remove directory-files nil "." ".." ".overview" file-name-as-directory intern-soft file-name-directory directory-file-name file-directory-p nnheader-concat checker] 4 "Given a directory, check it and its subdirectories for\n              membership in the keep hash.  If it isn't found, add\n              it to to-remove."] expand-file-name gnus-y-or-n-p "gnus-agent-expire has identified local directories that are not currently required by any agentized group.  Do you wish to consider deleting them?" format "Delete %s? " #[(f-or-d) "\300\301\302\217\207" [nil (byte-code "\301!\203\302\303\304\217\207\305!\207" [f-or-d file-directory-p nil (delete-directory f-or-d) ((file-error (byte-code "\304!	\203	\211A@\211\305\235\204\306\n\"!\210\202\307!\207" [f-or-d files f delete-recursive directory-files ("." "..") nnheader-concat delete-directory] 5))) delete-file] 3) ((error))] 3] gnus-agent-directory to-remove checker gnus-expert-user delete-recursive files f] 5])
#@43 Start Gnus, send queue and fetch session.
(defalias 'gnus-agent-batch #[nil "\303\304\305 \210*\306\307 \210\310 )\207" [gnus-always-read-dribble-file init-file-user gnus-agent-confirmation-function "" t gnus gnus-agent-batch-confirmation gnus-group-send-queue gnus-agent-fetch-session] 2 (#$ . 110529) nil])
(defalias 'gnus-agent-unread-articles #[(group) "\306\211\307	\"J88\310!\311C\211\203r\n\203r\211A@@\n@\211\f\247\2031\f\2024\f@
\f\247\203A\f\202D\fA
\203S
W\203^
\311B\241\311\202jV\205j\nA\312+\204#)\202\203\204
\211A@@\311B\241\202r\fA,\207" [group gnus-newsrc-hashtb read known unread tail-unread 2 intern-soft gnus-agent-load-alist nil t candidate range min max] 6])
#@242 Restrict ARTICLES to numbers already fetched.
Returns a sublist of ARTICLES that excludes those article ids in GROUP
that have already been fetched.
If CACHED-HEADER is nil, articles are only excluded if the article itself
has been fetched.
(defalias 'gnus-agent-uncached-articles #[(articles group &optional cached-header) "\204	\204\226\306\n!\203\226
\307C\211	\n\f\203{\203{@\f\211@@)\f\211
\fW\203I\n
\307B\241\nA\202w
\fU\203t\204i\f\211@A)\204i\n
\307B\241\nA\fA\202w\fA*\202\203\221\n\211A@\307B\241\n\202{	A,\207
\207" [gnus-agent-cache gnus-plugged group gnus-agent-article-alist ref articles gnus-agent-load-alist nil arts uncached tail-uncached x v2 v1 cached-header] 4 (#$ . 111272)])
(defalias 'gnus-agent-retrieve-headers #[(articles group &optional fetch-old) "\212\306 \210\307\211\310\311\"\312\211	,-\313\314\315
!\316\"!\210.\203?\317.\247\2035\320/@.Z]\2026\320\321/!@B!/\322
!\203Yr0q\210\323 \21012\324
/@\"\210*\325/\316#\211\203g
3q\210\323 \210\3124\326\")\327=\204~\330 \210\202%
5@\331=\203%
3q\210\312C\21167/@8\321/!@9eb\210d\312:;`;W\203

\332\333!\205\354\334\225\334\224Z\211<\335W\203\306\336p!\202\353<\335U\205\353\334\224\334\225S{=\336p!>\337>!?=?\232\205\352>+)\211:\203\3737:\312B\2417\320y\210\202\246*\3406A89B\"67@\203
\340\211@7@B\"\3416\",0q\210\323 \2103q\210\3420ed#\210\203A
\343
#\2103q\2101@\344 \210\345ed
\312\346%\210)\347\316\"\210\350!\210\351\312#\210\202s
3q\210\323 \210\3520!\210..\203\200
.\247\203\213
\353/@\321/!@\"\210)\327\207" [group nnmail-pathname-coding-system file-name-coding-system uncached-articles cached-articles file gnus-agent-create-buffer identity gnus-agent-article-name ".overview" nil gnus-make-directory nnheader-translate-file-chars file-name-directory t gnus-uncompress-range 1 last file-exists-p erase-buffer nnheader-insert-nov-file gnus-agent-uncached-articles gnus-retrieve-headers nov nnvirtual-convert-headers nntp looking-at "[0-9]+	" 0 9 read int-to-string gnus-list-range-intersection gnus-sorted-nunion copy-to-buffer gnus-agent-braid-nov gnus-agent-check-overview-buffer write-region silent gnus-agent-update-view-total-fetched-for gnus-agent-load-alist gnus-agent-save-alist insert-buffer-substring nnheader-nov-delete-outside-range gnus-decode-encoded-address-function gnus-decode-encoded-word-function fetch-old articles gnus-agent-overview-buffer gnus-agent-file-coding-system nnheader-file-coding-system nntp-server-buffer gnus-agent gnus-current-select-method fetched-articles tail-fetched-articles min max art pm len str1 num str2 coding-system-for-write] 7])
#@49 Retrieve ARTICLE in GROUP from the agent cache.
(defalias 'gnus-agent-request-article #[(article group) "\205I	\204
\n?\205I\247\205I\306\f!\307\310!\f\"\311\312!\205H\313\314!8\315V\205H\316 \210\317 \210\320!\210)\321,\207" [gnus-agent gnus-agent-cache gnus-plugged article group gnus-command-method gnus-find-method-for-group gnus-agent-article-name number-to-string nil file-exists-p 7 file-attributes 0 erase-buffer gnus-kill-all-overlays insert-file-contents t file buffer-read-only nnmail-pathname-coding-system file-name-coding-system gnus-cache-coding-system coding-system-for-read] 3 (#$ . 113996)])
(defalias 'gnus-agent-store-article #[(article group) "\306!\307\310\n!\"\f\311!?\2053\312\313!!\210\314ed\315\316%\210\317!\210\320\nC\321\322 !#,\207" [group gnus-command-method article file nnmail-pathname-coding-system file-name-coding-system gnus-find-method-for-group gnus-agent-article-name number-to-string file-exists-p gnus-make-directory file-name-directory write-region nil silent gnus-agent-load-alist gnus-agent-save-alist time-to-days current-time gnus-cache-coding-system coding-system-for-write] 6])
#@320 Regenerate GROUP.
If REREAD is t, all articles in the .overview are marked as unread.
If REREAD is a list, the specified articles will be marked as unread.
In addition, their NOV entries in .overview will be refreshed using
the articles' current headers.
If REREAD is not nil, downloaded articles are marked as unread.
(defalias 'gnus-agent-regenerate-group #[(group &optional reread) "\205\212\306\307\310\311!#\210	\206\312!\313\314\"\315\n!\316
@\317!\203:\320\321\316\322\323\324\316\325\326$\"\"\327\"\202?\330!\210\316A\316\211BC\316\211DE\316F\331\332!GrGq\210\333\216\334 \210\317\n!\203nHI\335\n!\210)\336\316!\210\326JJ\2036
\316Jeb\210`dW\203 
\337\340!\203
\341\225\341\224Z\342X\203
\343p!CBC\344y\210C@C\211KA@)LMN<\203\325MN>\203\325\345 \344y\210`|\210CAC\306\346\347M#\210\202\f
L\203\f
MLW\203\355\306\350\351\"\210\326J\202\f
MLU\203\f
\352y\210\306\346\353M#\210\345 \344y\210`|\210CAC*\202\200\306\344\354\"\210\345 \344y\210`|\210\202\200J\203u\306\307\355\"\210\356\344ed#\210\316C\202u)\357 \210A\204D
C\203A\203\306
C\203X
A@C@V\203\306
\306\350\360\311!A@$\210\361A@!P\331\332!OrOq\210\362\216\334 \210\335\n!\210\363 \210\364 E+E\341A@I\210C\203\262
\365\366C@!\367QP\370P\316\326#\204\253
\371P!\210\344y\210)\202\265
eb\210\372E!\210)A@CBC\202:
A@C@=\203\363
A@\373\307\374\361A@!P!8!BDBDAAACAC\202:
C@\316BDBDCAC\202:
Q\203\205\316DB\211RS\375!TT\203|RA@@T\211K@@)U\211V\204CRUCC\241RTAT\202xUVW\203^RUCRAB\241\210TAT\202xUVU\203sTATRAR\202xRAR*\202SAD+\202\313\376D!\376\375!!TRT\203\312R\204\256T\211K@@)\316BDBD\202\312R\211K@@)T\211K@@)W\203\312RT@C\241\210*\326W\377 \211F\203\347HX\201]ed\n\316\201^%\210)F\206\374N\203\366Y\206\374DY\232?FDYF\203D\201_!\210Z\201`\201aZ\"\203%Z\341\225\316O\202'Z)\201b[\"J\2068\201c!\\\201d\\\"\210*,N\203Y\203\201eN<\203^N\202h\321\316\322\201fY\"\"\201g\201hEC	#\210F\203\201i\316\"\210\306\307\201j\"\210F.\207" [group gnus-command-method file dir point nnmail-pathname-coding-system gnus-message 5 "Regenerating in %s" gnus-agent-decoded-group-name gnus-find-method-for-group gnus-agent-article-name ".overview" file-name-directory nil file-exists-p sort delq mapcar #[(name) "\302\303	\"!?\205
\304	!\207" [dir name file-directory-p nnheader-concat string-to-number] 4] directory-files "^[0-9]+$" t > gnus-make-directory generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1=#:temp-buffer buffer-name kill-buffer] 2)) mm-disable-multibyte nnheader-insert-file-contents set-buffer-modified-p looking-at "[0-9]+	" 0 9 read 1 point-at-bol 4 "gnus-agent-regenerate-group: NOV entry of article %s deleted." 3 "gnus-agent-regenerate-group: NOV entries are NOT in ascending order." -1 "gnus-agent-regenerate-group: NOV entries contained duplicate of article %s.	 Duplicate deleted." "gnus-agent-regenerate-group: NOV entries contained line that did not begin with an article number.  Deleted line." "gnus-agent-regenerate-group: Sorting NOV entries into ascending order." sort-numeric-fields gnus-agent-check-overview-buffer "Regenerating NOV %s %d..." number-to-string ((byte-code "\301!\203\n\302!\210\301\207" [#2=#:temp-buffer buffer-name kill-buffer] 2)) nnheader-remove-body nnheader-parse-naked-head "^" int-to-string "	" re-search-backward re-search-forward nnheader-insert-nov time-to-days file-attributes gnus-agent-load-alist last buffer-modified-p file-name-coding-system downloaded dl nov-arts alist header regenerated #1# gnus-agent-file-coding-system nnheader-file-coding-system load x l2 l1 reread #2# key gnus-agent-consider-all-articles n merged o oID nID inhibit-quit coding-system-for-write gnus-agent-article-alist gname gnus-active-hashtb group-active write-region silent gnus-agent-save-alist string-match "^[^:]+:" intern-soft gnus-activate-group gnus-agent-possibly-alter-active gnus-agent-synchronize-group-flags #[(c) "\302=\203		@\207	A\205	@\207" [reread c t] 2] del (read) gnus-agent-update-files-total-fetched-for ""] 11 (#$ . 115173) (list (gnus-agent-read-group) (catch 'mark (while (let (c (cursor-in-echo-area t) (echo-keystrokes 0)) (message "Mark as unread: (n)one / (a)ll / all (d)ownloaded articles? (n) ") (setq c (read-char-exclusive)) (cond ((or (eq c 13) (eq c 110) (eq c 78)) (throw 'mark nil)) ((or (eq c 97) (eq c 65)) (throw 'mark t)) ((or (eq c 100) (eq c 68)) (throw 'mark 'some))) (gnus-message 3 "Ignoring unexpected input") (sit-for 1) t))))])
#@66 Regenerate all agent covered files.
If CLEAN, obsolete (ignore).
(defalias 'gnus-agent-regenerate #[(&optional clean reread) "\305\306\307\310\"\210\311 \305\211\2038\n@\312	!\305\211\2030\n@\313\f\"\206(\nA\211\204*\nA\211\204*\306\307\314\"\210)\207" [regenerated gnus-command-method --dolist-tail-- group reread nil gnus-message 4 "Regenerating Gnus agent files..." gnus-agent-covered-methods gnus-groups-from-server gnus-agent-regenerate-group "Regenerating Gnus agent files...done"] 4 (#$ . 119817) "P"])
#@36 Switch servers into online status.
(defalias 'gnus-agent-go-online #[(&optional force) "\305\211\205<\n@\211A@\306=\2034\307=\203+\310\311\312	\211@@)	@A@#!\202,\2034	A\313\240\210\nA\211\204\305*\207" [gnus-opened-servers server --dolist-tail-- force x nil offline ask gnus-y-or-n-p format "Switch %s:%s into online status? " close] 6 (#$ . 120353) (list t)])
#@55 Toggle the status of the server of the current group.
(defalias 'gnus-agent-toggle-group-plugged #[(group) "\305!\306	\n\"\211A@)\211\307=\203\310	\311\"\210\202%\312	!\210\310	\307\"\210\313\314	@	\211A@)\f\307=\2039\307\202:\315\f\307=\203D\315\202E\307%*\207" [group method gnus-opened-servers x status gnus-find-method-for-group assoc offline gnus-server-set-status closed gnus-close-server message "Turn %s:%s from %s to %s." online] 8 (#$ . 120735) (list (gnus-group-group-name))])
(defalias 'gnus-agent-group-covered-p #[(group) "\301\302!!\207" [group gnus-agent-method-p gnus-group-method] 3])
#@87 Update, or set, the total disk space used by the articles that the
agent has fetched.
(defalias 'gnus-agent-update-files-total-fetched-for #[(group delta &optional method path) "\205\320\306\n\f\206\307
!\310\f\"J\206!\311\f\"\312\313\314\"L<\203\247\203q\315\316\211A@\211\203i\317\320\321\322\f\247\203Y\323!\202[\"!8\206b\314!\\\2028*\202\247\3248[\325\f\316\326\306$\316\211A@\211\203\242\317\3278\206\233\314!\\\202\203+\306 AA\211!\211@\\\240. \203\320	\204\320r\"q\210\316 \330
\306\"\210)\207" [gnus-agent-total-fetched-hashtb gnus-agent-inhibit-update-total-fetched-for method gnus-command-method path group t gnus-agent-group-pathname intern-soft intern make-list 3 0 0.0 nil float 7 file-attributes nnheader-concat number-to-string 2 directory-files-and-attributes "^-?[0-9]+$" 8 gnus-group-update-group entry nnmail-pathname-coding-system file-name-coding-system delta file sum info gnus-agent-need-update-total-fetched-for #1=#:c gnus-group-buffer] 9 (#$ . 121357)])
#@146 Update, or set, the total disk space used by the .agentview and
.overview files.  These files are calculated separately as they can be
modified.
(defalias 'gnus-agent-update-view-total-fetched-for #[(group agent-over &optional method path) "\205m\306\n\f\206\307
!\310\f\"J\206!\311\f\"\312\313\314\"L\315\316\317\f\2034\320\2025\321\"!8\206<\314\306\203J\322\202K\314\233\211\240.\203m	\204mrq\210\323\324
\306\"\210)\207" [gnus-agent-total-fetched-hashtb gnus-agent-inhibit-update-total-fetched-for method gnus-command-method path group t gnus-agent-group-pathname intern-soft intern make-list 3 0 7 file-attributes nnheader-concat ".overview" ".agentview" 1 nil gnus-group-update-group entry nnmail-pathname-coding-system file-name-coding-system agent-over size gnus-agent-need-update-total-fetched-for #1=#:c gnus-group-buffer] 6 (#$ . 122435)])
#@55 Get the total disk space used by the specified GROUP.
(defalias 'gnus-agent-total-fetched-for #[(group &optional method no-inhibit) "\306\232?\205A	\204\307\310!\n\311!\312\f	\"J\211\203&\313\314
\"\202@?\314\315\316\n\f$\315\317\n\f$\320\316\n\f$#)+\207" [group gnus-agent-total-fetched-hashtb method gnus-command-method path entry "dummy.group" gnus-make-hashtable 1024 gnus-agent-group-pathname intern-soft apply + gnus-agent-update-view-total-fetched-for nil t gnus-agent-update-files-total-fetched-for no-inhibit gnus-agent-inhibit-update-total-fetched-for] 9 (#$ . 123335)])
(provide 'gnus-agent)