1#@!#!123s

��JFIF�� 1#@!#!123s
: / proc / self / root / usr / share / emacs / 24.3 / lisp / gnus /
Filename : gnus-util.elc
back
;ELC���
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:10:09 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/gnus/gnus-util.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!\204
�\302\301\303\304B\"\210\305\306!\210\307\310\311\312\313\314\315\316\317\320\321\322BB&	\210\307\323\324\325\313\314\315\316\317\326&	\210\327\330\331\"\210\327\332\333\"\210\327\334\333\"\210\327\335\336\"\210\300\337!\203Q�\302\340\341\"\210\202\\�\300\342!\203\\�\302\340\342\"\210\300\207" [fboundp declare-function defalias macro #[(&rest r) "\300\207" [nil] 1] require time-date custom-declare-variable gnus-completing-read-function 'gnus-emacs-completing-read "Function use to do completing read." :version "24.1" :group gnus-meta :type radio (function-item :doc "Use Emacs standard `completing-read' function." gnus-emacs-completing-read) ((function-item :doc "Use `ido-completing-read' function." gnus-ido-completing-read) (function-item :doc "Use iswitchb based completing-read function." gnus-iswitchb-completing-read)) gnus-completion-styles (if (and (boundp 'completion-styles-alist) (boundp 'completion-styles)) (append (when (and (assq 'substring completion-styles-alist) (not (memq 'substring completion-styles))) (list 'substring)) completion-styles) nil) "Value of `completion-styles' to use when completing." list autoload gnus-get-buffer-window "gnus-win" nnheader-narrow-to-headers "nnheader" nnheader-replace-chars-in-string mail-header-remove-comments "mail-parse" replace-regexp-in-string gnus-replace-in-string #[(string regexp newtext &optional literal) "\304	\n\305%\207" [regexp newtext string literal replace-regexp-in-string nil] 6 "Replace all matches for REGEXP with NEWTEXT in STRING.\nIf LITERAL is non-nil, insert NEWTEXT literally.  Return a new\nstring containing the replacements.\n\nThis is a compatibility function for different Emacsen."] replace-in-string] 12)
#@50 Return non-nil if VARIABLE is bound and non-nil.
(defalias 'gnus-boundp #[(variable) "\301!\205�J\207" [variable boundp] 2 (#$ . 2289)])
#@72 Pop to BUFFER, evaluate FORMS, and then return to the original window.
(defalias 'gnus-eval-in-buffer-window '(macro . #[(buffer &rest forms) "\305\306!\305\307!\305\310!\311\n\312BD	\313\314BBDE\315\316\317	\316\320	D\321\322	DDE\323DF\fBB\320\nDEE+\207" [buf w tempvar buffer forms make-symbol "GnusStartBufferWindow" "w" "buf" let* ((selected-window)) gnus-get-buffer-window ('visible) unwind-protect progn if select-window set-buffer window-buffer pop-to-buffer] 11 (#$ . 2435)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put gnus-eval-in-buffer-window lisp-indent-function 1 edebug-form-spec (form body)] 4)
#@54 Get hash value.  Arguments are STRING and HASHTABLE.
(defalias 'gnus-intern-safe '(macro . #[(string hashtable) "\302\303\304	EDC\305BB\207" [string hashtable let symbol intern ((or (boundp symbol) (set symbol nil)) symbol)] 5 (#$ . 3077)]))
(defalias 'gnus-goto-char #[(point) "\205�b\207" [point] 1])
(put 'gnus-goto-char 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'gnus-buffer-exists-p '(macro . #[(buffer) "\301\300DC\302BB\207" [buffer let ((when buffer (funcall (if (stringp buffer) 'get-buffer 'buffer-name) buffer)))] 3]))
(defalias 'gnus-make-local-hook 'ignore)
#@72 Delete by side effect the first occurrence of ELT as a member of LIST.
(defalias 'gnus-delete-first #[(elt list) "@	\232\203\n�A\207A\203#�\211A@)	\232\204#�A\211\202
�A\2031�\211\211AA)\241\210\n)\207" [list elt total x] 3 (#$ . 3672)])
(defalias 'gnus-delete-line '(macro . #[(&optional n) "\301\302\303\304\206	�\305D\306BBE\207" [n delete-region (point-at-bol) progn forward-line 1 ((point))] 5]))
#@285 Extract address components from a From header.
Given an RFC-822 address FROM, extract full name and canonical address.
Returns a list of the form (FULL-NAME CANONICAL-ADDRESS).  Much more simple
solution than `mail-extract-address-components', which works much better, but
is slower.
(defalias 'gnus-extract-address-components #[(from) "\303\211\304\305\n\"\203�\n\306\224\306\225O\202#�\304\307\n\"\203#�\n\310\224\310\225O\203K�\304\311\312!\313Q\n\"\203K�\n\310\211\224O\211\203K�\304\314	\"\203K�	\306\310\225SO	\204�\304\315\n\"\203c�\n\310\224T\310\225SO\211\204�\304\316\n\"\203p�\211\204�\304\317\n\"\203�\n\310\224T\310\225O	\320\230?\205\207�	\206\214�\n*D\207" [address name from nil string-match "<\\([^@ 	<>]+[!@][^@ 	<>]+\\)>" 1 "\\b[^@ 	<>]+[!@][^@ 	<>]+\\b" 0 "[ 	]*<" regexp-quote ">" "^\".*\"$" "(.+)" "()" "(.*" ""] 4 (#$ . 4094)])
#@58 Return the value of the header FIELD of current article.
(defalias 'gnus-fetch-field #[(field) "\302\303!\210\212\214\304\305 \210\306	!+\207" [inhibit-point-motion-hooks field require message t nnheader-narrow-to-headers message-fetch-field] 2 (#$ . 4969)])
#@63 Fetch FIELD from the original version of the current article.
(defalias 'gnus-fetch-original-field #[(field) "rq\210\302	!)\207" [gnus-original-article-buffer field gnus-fetch-field] 2 (#$ . 5235)])
(defalias 'gnus-goto-colon #[nil "\301 \210\302 \303`\304\305$\206�\306\307\305#\206�`b)\207" [eol beginning-of-line point-at-eol text-property-any gnus-position t search-forward ":"] 5])
(defalias 'gnus-decode-newsgroups #[(newsgroups group &optional method) "\303\304!\210\206�\305	!\306\307\310\n!\311#)\207" [method group newsgroups require gnus-group gnus-find-method-for-group mapconcat #[(group) "\302\303	\"\"\207" [group method gnus-group-name-decode gnus-group-name-charset] 5] message-tokenize-header ","] 4])
#@64 Delete all text in the current buffer with text property PROP.
(defalias 'gnus-remove-text-with-property #[(prop) "e\303\304	\n\"\204�\305	\n\"	\2051�\306	d\n\303$	\206!�d|\210\205+�\305	\n\"\211\204�\303*\207" [end start prop nil get-text-property next-single-property-change text-property-any] 6 (#$ . 5972)])
#@64 Return a list of text property regions that has property PROP.
(defalias 'gnus-find-text-property-region #[(start end prop) "\305\211\306\n\"\204�\307\n\"\n\203F�\306\n\"\310\nd$\211\204*�\305\211\202�\203=�\311 \n\305\223\311 \f\305\223E	B\307\n\"\211\204�	\237*\207" [value regions start prop end nil get-text-property next-single-property-change text-property-not-all make-marker] 6 (#$ . 6299)])
#@55 Make hierarchical directory name from NEWSGROUP name.
(defalias 'gnus-newsgroup-directory-form #[(newsgroup) "\302!\303\304\"\211\205�\305	O	\205�\306\307	\203#�	T\310O\202$�\311\312#Q*\207" [newsgroup idx gnus-newsgroup-savable-name string-match ":" 0 "/" nnheader-replace-chars-in-string nil 46 47] 7 (#$ . 6724)])
(defalias 'gnus-newsgroup-savable-name #[(group) "\301\302\303#\207" [group nnheader-replace-chars-in-string 47 46] 4])
(defalias 'gnus-string> #[(s1 s2) "	\231\206	�	\230?\207" [s1 s2] 2])
#@198 Return t if first arg string is less than second in lexicographic order.
Case is significant if and only if `case-fold-search' is nil.
Symbols are also allowed; their print names are used instead.
(defalias 'gnus-string< #[(s1 s2) "\203 �	9\203�\303	!\202�	\227\n9\203�\303\n!\202�\n\227\231\207	\n\231\207" [case-fold-search s1 s2 symbol-name] 3 (#$ . 7250)])
(defalias 'gnus-file-newer-than #[(file date) "\303\304!8\211@\n@V\206�	@\n@U\205�	A@\nA@V)\207" [file fdate date 5 file-attributes] 4])
(defalias 'gnus-float-time 'float-time)
#@46 Set the keys in PLIST in the current keymap.
(defalias 'gnus-local-set-keys '(macro . #[(&rest plist) "\301\302\303DE\207" [plist gnus-define-keys-1 (current-local-map) quote] 4 (#$ . 7803)]))
#@37 Define all keys in PLIST in KEYMAP.
(defalias 'gnus-define-keys '(macro . #[(keymap &rest plist) "\302\303D\303	DE\207" [keymap plist gnus-define-keys-1 quote] 4 (#$ . 8003)]))
#@78 Define all keys in PLIST in KEYMAP without overwriting previous definitions.
(defalias 'gnus-define-keys-safe '(macro . #[(keymap &rest plist) "\302\303D\303	D\304BBB\207" [keymap plist gnus-define-keys-1 quote (t)] 4 (#$ . 8187)]))
(byte-code "\300\301\302\303#\210\300\304\302\303#\210\300\305\302\303#\207" [put gnus-define-keys lisp-indent-function 1 gnus-define-keys-safe gnus-local-set-keys] 4)
#@37 Define all keys in PLIST in KEYMAP.
(defalias 'gnus-define-keymap '(macro . #[(keymap &rest plist) "\302\303	DE\207" [keymap plist gnus-define-keys-1 quote] 4 (#$ . 8595)]))
(put 'gnus-define-keymap 'lisp-indent-function 1)
(defalias 'gnus-define-keys-1 #[(keymap plist &optional safe) "\204�\305\306!\2109\203�J\202<�\307!\204<�<\203<�@\310L\210\311@!\210\312AA@J\211A@)@#\210@J\310\205s�\211A@\2119\203P�\nJ\f\203]�\313\n\"\314=\203j�\312\n\211A@#\210\202>�\211A@\210\202>�)\207" [keymap x key plist safe error "Can't set keys in a null keymap" keymapp nil define-prefix-command define-key lookup-key undefined] 6])
(defalias 'gnus-y-or-n-p #[(prompt) "\301!\302\303!\210\207" [prompt y-or-n-p message ""] 3])
(defalias 'gnus-yes-or-no-p #[(prompt) "\301!\302\303!\210\207" [prompt yes-or-no-p message ""] 3])
#@44 Return the number of seconds passed today.
(defalias 'gnus-seconds-today #[nil "\301\302 !\303@A@\304_AA@\305_#)\207" [now decode-time current-time + 60 3600] 5 (#$ . 9444)])
#@49 Return the number of seconds passed this month.
(defalias 'gnus-seconds-month #[nil "\301\302 !\303@A@\304_AA@\305_\306\233@S\307_$)\207" [now decode-time current-time + 60 3600 3 86400] 6 (#$ . 9629)])
#@48 Return the number of seconds passed this year.
(defalias 'gnus-seconds-year #[nil "\302\303 !\304\305\303 \"\306	@	A@\307_	AA@\310_\311!S\312_$*\207" [days now decode-time current-time format-time-string "%j" + 60 3600 string-to-number 86400] 6 (#$ . 9843)])
#@88 Convert DATE string to Emacs time.
Cache the result as a text property stored in DATE.
(defalias 'gnus-date-get-time '(macro . #[(date) "\301\302DC\303BB\207" [date let d ((if (equal "" d) '(0 0) (or (get-text-property 0 'gnus-time d) (let ((time (safe-date-to-time d))) (put-text-property 0 1 'gnus-time time d) time))))] 3 (#$ . 10111)]))
#@54 Return a string like DD-MMM from a big messy string.
(defalias 'gnus-dd-mmm #[(messy-date) "\300\301\302\217\207" [nil (byte-code "\303\304\211\305\232\203�\306\202$�\307\310\311	#\206$�\312	!\313\310\314\311\n	%\210\n))\"\207" [messy-date d time format-time-string "%d-%b" "" (0 0) get-text-property 0 gnus-time safe-date-to-time put-text-property 1] 9) ((error "  -   "))] 3 (#$ . 10459)])
#@52 Return a string of TIME in YYYYMMDDTHHMMSS format.
(defalias 'gnus-time-iso8601 #[(time) "\301\302\"\207" [time format-time-string "%Y%m%dT%H%M%S"] 3 (#$ . 10861)])
(put 'gnus-time-iso8601 'byte-optimizer 'byte-compile-inline-expand)
#@38 Convert the DATE to YYYYMMDDTHHMMSS.
(defalias 'gnus-date-iso8601 #[(date) "\300\301\302\217\207" [nil (byte-code "\211\303\232\203\f�\304\202\"�\305\306\307	#\206\"�\310	!\311\306\312\307\n	%\210\n))\313\314\n\")\207" [date d time #1="" (0 0) get-text-property 0 gnus-time safe-date-to-time put-text-property 1 format-time-string "%Y%m%dT%H%M%S"] 7) ((error #1#))] 3 (#$ . 11102)])
#@28 Quote all "%"'s in STRING.
(defalias 'gnus-mode-string-quote #[(string) "\301\302\303#\207" [string gnus-replace-in-string "%" "%%"] 4 (#$ . 11495)])
(defalias 'gnus-make-hashtable #[(&optional hashsize) "\301\203
�\302!\303]\202�\303\304\"\207" [hashsize make-vector gnus-create-hash-size 256 0] 3])
(defalias 'gnus-create-hash-size #[(min) "\302\211	W\203�\303_\211\202�)\207" [i min 1 2] 3])
(byte-code "\300\301\302\303\304\305\306\307\310\311&	\210\300\312\313\314\304\315\306\316\310\317&	\207" [custom-declare-variable gnus-verbose 6 "*Integer that says how verbose Gnus should be.\nThe higher the number, the more messages Gnus will flash to say what\nit's doing.  At zero, Gnus will be totally mute; at five, Gnus will\ndisplay most important messages; and at ten, Gnus will keep on\njabbering all the time." :version "24.1" :group gnus-start :type integer gnus-add-timestamp-to-message nil "Non-nil means add timestamps to messages that Gnus issues.\nIf it is `log', add timestamps to only the messages that go into the\n\"*Messages*\" buffer (in XEmacs, it is the \" *Message-Log*\" buffer).\nIf it is neither nil nor `log', add timestamps not only to log messages\nbut also to the ones displayed in the echo area." "23.1" gnus-various (choice :format "%{%t%}:\n %[Value Menu%] %v" (const :tag "Logged messages only" log) (sexp :tag "All messages" :match (lambda (widget value) value) :value t) (const :tag "No timestamp" nil))] 10)
(defvar gnus-action-message-log nil)
#@158 Display message with timestamp.  Arguments are the same as `message'.
The `gnus-add-timestamp-to-message' variable controls how to add
timestamp to message.
(defalias 'gnus-message-with-timestamp #[(format-string &rest args) "\306\211\n\307=\203I�\306\310\311\f
#)\203E�\312V\203E�	G\312U\204E�\313 r\314\315!q\210db\210\316\317\"	\320\261\210[y\210e`|\210db\210)	\202\204�\n\203�\f\204U�
\203b�\310\321\f
#\322	G!\203n�\f\205g�	\311\306!\210\202\204�\313 \311\323\316\317\"	P\"\210	\202\204�\310\311\f
#*\207" [time str gnus-add-timestamp-to-message message-log-max format-string args nil log apply message 0 current-time get-buffer-create "*Messages*" format-time-string "%Y%m%dT%H%M%S.%3N> " "\n" format zerop "%s"] 5 (#$ . 12993)])
#@259 If LEVEL is lower than `gnus-verbose' print ARGS using `message'.

Guideline for numbers:
1 - error messages, 3 - non-serious error messages, 5 - messages for things
that take a long time, 7 - not very important messages on stuff, 9 - messages
inside loops.
(defalias 'gnus-message #[(level &rest args) "	X\203(�\n\203�\306\307\"\202�\306\304\"
:\203%�\310X\203%�\f
B\f)\207\306\311\"\207" [level gnus-verbose gnus-add-timestamp-to-message args message gnus-action-message-log apply gnus-message-with-timestamp 3 format] 3 (#$ . 13750)])
(defalias 'gnus-final-warning #[nil ":\205�\301\302\"\211\205�\303\304\305\306\307#\"\207" [gnus-action-message-log delete nil message "Warning: %s" mapconcat identity "; "] 6])
#@95 Beep an error if LEVEL is equal to or less than `gnus-verbose'.
ARGS are passed to `message'.
(defalias 'gnus-error #[(level &rest args) "\304!	X\203+�\305\306\n\"\210\307 \210\310\311!\203*�\312\304!Z\313_\211!\204*�\314!\210)\310\207" [level gnus-verbose args duration floor apply message ding nil floatp zerop 10 sit-for] 4 (#$ . 14487)])
#@45 Return a list of Message-IDs in REFERENCES.
(defalias 'gnus-split-references #[(references) "\303\304\206�\305!\306\307\310\n#\203\"�\303\224\303\225\211O	B\202\f�	\237+\207" [references ids beg 0 mail-header-remove-comments "" nil string-match "<[^<]+[^< 	]"] 4 (#$ . 14842)])
#@112 Return a list of Message-IDs in REFERENCES (in In-Reply-To
  format), trimmed to only contain the Message-IDs.
(defalias 'gnus-extract-references #[(references) "\305!\306\211\306\211\203&�\f@\307\310\"\203�\311\312\"	B\fA\211\204�*	*\207" [references refs ids id --dolist-tail-- gnus-split-references nil string-match "<[^<>]+>" match-string 0] 4 (#$ . 15136)])
#@82 Return the last Message-ID in REFERENCES.
If N, return the Nth ancestor instead.
(defalias 'gnus-parent-id #[(references &optional n) "\205X�\304G!?\205X�	\203H�\305\306\206�\307!\310\311\312#\2034�\305\224\305\225\211O\nB\202�\n\237,	\n\233\203D�\nA\2028�\n@)\207\306!\311\313\"\205W�\314\315\")\207" [references n ids beg zerop 0 mail-header-remove-comments "" nil string-match "<[^<]+[^< 	]" "\\(<[^<]+>\\)[ 	]*\\'" match-string 1] 4 (#$ . 15517)])
(put 'gnus-parent-id 'byte-optimizer 'byte-compile-inline-expand)
#@37 Say whether BUFFER is alive or not.
(defalias 'gnus-buffer-live-p #[(buffer) "\205	�\301\302!!\207" [buffer buffer-live-p get-buffer] 3 (#$ . 16062)])
(put 'gnus-buffer-live-p 'byte-optimizer 'byte-compile-inline-expand)
#@43 Recenter the current buffer horizontally.
(defalias 'gnus-horizontal-recenter #[nil "i\303 \304\245W\203�\305\306p\307\"\310\"\207`\311\306p\307\"!\310	\205e�\312 b\210m\204;�`	W\203;�\313\210\ni]\314y\210\202$�b\210\n\303 V\203\\�\305\306p\307\"i\303 \315\245Z\304\n\303 Z\\^\"\210\202d�\305\306p\307\"\310\"\210\n+\207" [orig end max window-width 2 set-window-hscroll gnus-get-buffer-window t 0 window-end window-start nil 1 3] 6 (#$ . 16291)])
#@21 Get the next event.
(defalias 'gnus-read-event-char #[(&optional prompt) "\302!\211\247\205\n�		)B\207" [prompt event read-event] 3 (#$ . 16751)])
#@18 Copy FILE to TO.
(defalias 'gnus-copy-file #[(file &optional to) "\204	�\303\304	\"\305!\203�\306!\307\n!P\310\n\"\207" [to default-directory file read-file-name "Copy file to: " file-directory-p file-name-as-directory file-name-nondirectory copy-file] 3 (#$ . 16906) (list (read-file-name "Copy file: " default-directory) (read-file-name "Copy file to: " default-directory))])
(defvar gnus-work-buffer " *gnus work*")
#@42 Put point in the empty Gnus work buffer.
(defalias 'gnus-set-work-buffer #[nil "\301!\203\f�q\210\302 \207\303!q\210\304 \210\305 \207" [gnus-work-buffer get-buffer erase-buffer gnus-get-buffer-create kill-all-local-variables mm-enable-multibyte] 2 (#$ . 17338)])
#@44 Find the real name of a foreign newsgroup.
(defalias 'gnus-group-real-name '(macro . #[(group) "\301\302DC\303BB\207" [group let gname ((if (string-match "^[^:]+:" gname) (substring gname (match-end 0)) gname))] 3 (#$ . 17611)]))
#@128 Find the server name of a foreign newsgroup.
For example, (gnus-group-server "nnimap+yxa:INBOX.foo") would
yield "nnimap:yxa".
(defalias 'gnus-group-server '(macro . #[(group) "\301\302DC\303BB\207" [group let gname ((if (string-match "^\\([^:+]+\\)\\(?:\\+\\([^:]*\\)\\)?:" gname) (format "%s:%s" (match-string 1 gname) (or (match-string 2 gname) "")) (format "%s:%s" (car gnus-select-method) (cadr gnus-select-method))))] 3 (#$ . 17849)]))
#@67 Return a composite sort condition based on the functions in FUNS.
(defalias 'gnus-make-sort-function #[(funs) "\301!\203�\207\204�\207A\204�@<\203$�\302\303\304\305\306!!E!\207@\207" [funs functionp gnus-byte-compile lambda (t1 t2) gnus-make-sort-function-1 reverse] 6 (#$ . 18298)])
#@67 Return a composite sort condition based on the functions in FUNS.
(defalias 'gnus-make-sort-function-1 #[(funs) "@\305\306\211:\203,�@\307=\203!�\211A@)\306\305\202,�\310!\204,�\311\312\"\210A\203F�\313\n	E\314\307	\nED\315A!EE\202J�\n	E+\207" [funs last first function x t1 t2 not functionp error "Invalid sort spec: %s" or and gnus-make-sort-function-1] 8 (#$ . 18599)])
#@45 Turn off edit menu in `gnus-TYPE-mode-map'.
(defalias 'gnus-turn-off-edit-menu #[(type) "\301\302\303\304\"!J\305\306#\207" [type define-key intern format "gnus-%s-mode-map" [menu-bar edit] undefined] 5 (#$ . 18995)])
#@334 Bind print-* variables and evaluate FORMS.
This macro is used with `prin1', `pp', etc. in order to ensure printed
Lisp objects are loadable.  Bind `print-quoted' and `print-readably'
to t, and `print-escape-multibyte', `print-escape-newlines',
`print-escape-nonascii', `print-length', `print-level' and
`print-string-length' to nil.
(defalias 'gnus-bind-print-variables '(macro . #[(&rest forms) "\301\302BB\207" [forms let ((print-quoted t) (print-readably t) print-escape-multibyte print-escape-newlines print-escape-nonascii print-length print-level print-string-length)] 3 (#$ . 19221)]))
#@175 Use `prin1' on FORM in the current buffer.
Bind `print-quoted' and `print-readably' to t, and `print-length' and
`print-level' to nil.  See also `gnus-bind-print-variables'.
(defalias 'gnus-prin1 #[(form) "\306\211\307\211\211\211\211\211	\n\310p\".\207" [print-string-length print-level print-length print-escape-nonascii print-escape-newlines print-escape-multibyte t nil prin1 print-readably print-quoted form] 8 (#$ . 19822)])
#@153 The same as `prin1'.
Bind `print-quoted' and `print-readably' to t, and `print-length' and
`print-level' to nil.  See also `gnus-bind-print-variables'.
(defalias 'gnus-prin1-to-string #[(form) "\306\211\307\211\211\211\211\211	\n\310!.\207" [print-string-length print-level print-length print-escape-nonascii print-escape-newlines print-escape-multibyte t nil prin1-to-string print-readably print-quoted form] 8 (#$ . 20271)])
#@172 Use `pp' on FORM in the current buffer.
Bind `print-quoted' and `print-readably' to t, and `print-length' and
`print-level' to nil.  See also `gnus-bind-print-variables'.
(defalias 'gnus-pp #[(form &optional stream) "\306\211\307\211\211\211\211\211	\n\310\f\206�p\".\207" [print-string-length print-level print-length print-escape-nonascii print-escape-newlines print-escape-multibyte t nil pp print-readably print-quoted form stream] 8 (#$ . 20716)])
#@160 The same as `pp-to-string'.
Bind `print-quoted' and `print-readably' to t, and `print-length' and
`print-level' to nil.  See also `gnus-bind-print-variables'.
(defalias 'gnus-pp-to-string #[(form) "\306\211\307\211\211\211\211\211	\n\310!.\207" [print-string-length print-level print-length print-escape-nonascii print-escape-newlines print-escape-multibyte t nil pp-to-string print-readably print-quoted form] 8 (#$ . 21189)])
#@59 Make DIRECTORY (and all its parents) if it doesn't exist.
(defalias 'gnus-make-directory #[(directory) "\303\304!\210\n\203�\305\n!\204�\306\n\307\"\210)\307\207" [nnmail-pathname-coding-system file-name-coding-system directory require nnmail file-exists-p make-directory t] 3 (#$ . 21634)])
#@46 Write the current buffer's contents to FILE.
(defalias 'gnus-write-buffer #[(file) "\303\304!\210\305\306\n!!\210\307ed\n\310\311%)\207" [nnmail-pathname-coding-system file-name-coding-system file require nnmail gnus-make-directory file-name-directory write-region nil quietly] 6 (#$ . 21936)])
#@27 Delete FILE if it exists.
(defalias 'gnus-delete-file #[(file) "\301!\205	�\302!\207" [file file-exists-p delete-file] 2 (#$ . 22239)])
#@37 Remove duplicate entries from LIST.
(defalias 'gnus-delete-duplicates #[(list) "\302	\203�	@\235\204�	@B	\211A@\210\202�\237)\207" [result list nil] 2 (#$ . 22383)])
#@106 Delete files in DIRECTORY.  Subdirectories remain.
If there's no subdirectory, delete DIRECTORY as well.
(defalias 'gnus-delete-directory #[(directory) "\304!\2058�\305\306\307#\310\211\203/�\211A@\311\n!@\306=\203(�\306\202�\312\n!\210\202�	?\2057�\313!+\207" [directory dir file files file-directory-p directory-files t "^\\([^.]\\|\\.\\([^.]\\|\\..\\)\\).*" nil file-attributes delete-file delete-directory] 4 (#$ . 22565)])
#@43 Return STRING stripped of all whitespace.
(defalias 'gnus-strip-whitespace #[(string) "\301\302\"\203�\303\304\305\211$\202��\207" [string string-match "[
\n	 ]+" replace-match "" t] 5 (#$ . 23012)])
#@89 The same as `put-text-property', but don't put this prop on any newlines in the region.
(defalias 'gnus-put-text-property-excluding-newlines #[(beg end prop val) "\306 \307\216\212\214	b\210\310\n\311#\203�\312	\313\224\f
$\210`\202\n�\312	`\f
$,\207" [save-match-data-internal beg gnus-emphasize-whitespace-regexp end prop val match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) re-search-forward move gnus-put-text-property 0] 5 (#$ . 23223)])
(put 'gnus-put-text-property-excluding-newlines 'byte-optimizer 'byte-compile-inline-expand)
#@89 The same as `put-text-property', but don't put this prop on any newlines in the region.
(defalias 'gnus-put-overlay-excluding-newlines #[(beg end prop val) "\306 \307\216\212\214	b\210\310\n\311#\203!�\312\313	\314\224\"\f
#\210`\202\n�\312\313	`\"\f
#,\207" [save-match-data-internal beg gnus-emphasize-whitespace-regexp end prop val match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) re-search-forward move gnus-overlay-put gnus-make-overlay 0] 4 (#$ . 23817)])
(put 'gnus-put-overlay-excluding-newlines 'byte-optimizer 'byte-compile-inline-expand)
#@99 The same as `put-text-property', but don't put props on characters with the `gnus-face' property.
(defalias 'gnus-put-text-property-excluding-characters-with-faces #[(beg end prop val) "	\nU?\205.�\305	\306\"\203�\307	\306\310\n$	\nU\204�\311	\307	\306\310\n$\211\f$\210\202�)\207" [beg b end prop val get-text-property gnus-face next-single-property-change nil gnus-put-text-property] 7 (#$ . 24423)])
#@37 Return a list of faces at POSITION.
(defalias 'gnus-faces-at '(macro . #[(position) "\301\302DC\303BB\207" [position let pos ((delq nil (cons (get-text-property pos 'face) (mapcar (lambda (overlay) (overlay-get overlay 'face)) (overlays-at pos)))))] 3 (#$ . 24840)]))
(byte-code "\300\301!\203�\302\303\301\"\210\202�\302\303\304\"\210\302\305\300\306!\203�\306\202 �\307\"\210\302\310\300\311!\203.�\311\202/�\312\"\207" [fboundp invisible-p defalias gnus-invisible-p #[(pos) "\303\304\"\n\305=\203�	\202�	\n>\206�	\n\236)\207" [pos prop buffer-invisibility-spec get-char-property invisible t] 3 "Return non-nil if the character after POS is currently invisible."] gnus-next-char-property-change next-extent-change next-char-property-change gnus-previous-char-property-change previous-extent-change previous-char-property-change] 4)
#@70 If t, certain operations will be protected from interruption by C-g.
(defvar gnus-atomic-be-safe t (#$ . 25689))
#@457 Evaluate FORMS atomically, which means to protect the evaluation
from being interrupted by the user.  An error from the forms themselves
will return without finishing the operation.  Since interrupts from
the user are disabled, it is recommended that only the most minimal
operations are performed by FORMS.  If you wish to assign many
complicated values atomically, compute the results into temporary
variables and then do only the assignment atomically.
(defalias 'gnus-atomic-progn '(macro . #[(&rest forms) "\301\302BB\207" [forms let ((inhibit-quit gnus-atomic-be-safe))] 3 (#$ . 25809)]))
(put 'gnus-atomic-progn 'lisp-indent-function 0)
#@457 Evaluate FORMS, but ensure that the variables listed in PROTECT
are not changed if anything in FORMS signals an error or otherwise
non-locally exits.  The variables listed in PROTECT are updated atomically.
It is safe to use gnus-atomic-progn-assign with long computations.

Note that if any of the symbols in PROTECT were unbound, they will be
set to nil on a successful assignment.  In case of an error or other
non-local exit, it will still be unbound.
(defalias 'gnus-atomic-progn-assign '(macro . #[(protect &rest forms) "\306\307\"\306\310	\"\306\311	\"\n\312\313	\"\312\313\n\"\314\315!\316\313C\"\316\f\317\320BE\317
BF\316\321\317BE\257.\207" [protect temp-sym-map sym-temp-map temp-sym-let sym-temp-let temp-sym-assign mapcar #[(x) "\301\302!\303P!D\207" [x make-symbol symbol-name "-tmp"] 3] #[(x) "\211A@)@D\207" [x] 3] #[(x) "@\301\302\303\211A@)DD\211A@)ED\207" [x and boundp quote] 6] apply append make-symbol "result-tmp" let setq progn ((inhibit-quit gnus-atomic-be-safe)) sym-temp-assign result forms] 8 (#$ . 26461)]))
(put 'gnus-atomic-progn-assign 'lisp-indent-function 1)
#@317 Similar to setq, except that the real symbols are only assigned when
there are no errors.  And when the real symbols are assigned, they are
done so atomically.  If other variables might be changed via side-effect,
see gnus-atomic-progn-assign.  It is safe to use gnus-atomic-setq
with potentially long computations.
(defalias 'gnus-atomic-setq '(macro . #[(&rest pairs) "\304\211\203�\n@	B\n\211AA)\211\204�\305	\306BE*\207" [pairs syms tpairs x nil gnus-atomic-progn-assign setq] 5 (#$ . 27595)]))
#@170 Append the current article to an Rmail file named FILENAME.
In Emacs 22 this writes Babyl format; in Emacs 23 it writes mbox unless
FILENAME exists and is Babyl format.
(defalias 'gnus-output-to-rmail #[(filename &optional ask) "\306\307!\210\306\310!\210\306\311!\210\312!\313\301!\203�\202�p\314\315!\316\317!\212\320!\204u�\321!\203;�\322!\202u�<\203I�\323\324\325Q!\203q�\326!=r=q\210\316\317!\203\\�\317 \210\327>?@\330!\210+\331=!\210)\202u�\332\333!\210\fq\210\334 \210\335
!\210\203\211�\336 \210\202\264�eb\210\337\340!\203\230�\341y\210\202\237�\342\343 \344\261\210\327A\345\346\327\347#\203\263�\350 \210\351c\210\202\242�)\320!\211B\204\354�\204\336�\327Cdb\210\352u\210\337\353!\204\335�db\210n\204\332�\344c\210\344c\210)DE\354ed#\210)\202oBq\210\327\313\355!\205\371�\355JFCF\203\204\f\356 \210\357 \210~\210dd}\210\335\f!\210F\203k\203,eb\210~\210\360\361!\210`d}\210\362\347!\210\363 \203fGH\364 \203U\365 I\212\366\216\367J!\210HG\370 \210,\202brJq\210HG\370 \210*\371 \210)\372F!\210\373 \210**\331\f!+\207" [filename rmail-default-rmail-file rmail-default-file babyl tmpbuf artbuf require rmail mm-util nnmail expand-file-name boundp get-buffer-create " *Gnus-output*" fboundp rmail-insert-rmail-file-header get-file-buffer file-exists-p mail-file-babyl-p gnus-yes-or-no-p "\"" "\" does not exist, create it? " create-file-buffer nil gnus-write-buffer kill-buffer error "Output file does not exist" erase-buffer insert-buffer-substring gnus-convert-article-to-rmail looking-at "From " 1 "From nobody " current-time-string "\n" re-search-forward "^From " t beginning-of-line ">" -2 "\n\n" mm-append-to-file rmail-current-message rmail-swap-buffers-maybe rmail-maybe-set-message-counters search-backward "\n" rmail-count-new-messages rmail-summary-exists rmail-summary-displayed selected-window ((select-window window)) rmail-pop-to-buffer rmail-update-summary rmail-maybe-display-summary rmail-show-message save-buffer ask file-buffer mm-text-coding-system coding-system-for-write require-final-newline case-fold-search outbuf buffer-read-only nnmail-pathname-coding-system file-name-coding-system msg rmail-total-messages total window rmail-summary-buffer] 5 (#$ . 28110)])
#@59 Append the current article to a mail file named FILENAME.
(defalias 'gnus-output-to-mail #[(filename &optional ask) "\306\307!\210\310!p\311\312!\212\313!\204G�\314!\204G�\203(�\315\316\317Q!\203C�\320!r\fq\210\321
&'\322!\210+\323\f!\210)\202G�\324\325!\210	q\210\326 \210\327\n!\210eb\210\330\331!\203`�\332y\210\202g�\333\334 \335\261\210\321(\336\337\321\340#\203{�\341 \210\342c\210\202j�)\313!\211)\204\263�\321*\212db\210\343u\210\330\344!\204\242�db\210n\204\237�\335c\210\335c\210db\210+,\345ed#\210+\202\314�)q\210\321*db\210m\204\304�\335c\210\335c\210\327	!\210)*\323	!*\207" [filename tmpbuf artbuf ask file-buffer mm-text-coding-system require nnmail expand-file-name get-buffer-create " *Gnus-output*" get-file-buffer file-exists-p gnus-y-or-n-p "\"" "\" does not exist, create it? " create-file-buffer nil gnus-write-buffer kill-buffer error "Output file does not exist" erase-buffer insert-buffer-substring looking-at "From " 1 "From nobody " current-time-string "\n" re-search-forward "^From " t beginning-of-line ">" -2 "\n\n" mm-append-to-file coding-system-for-write require-final-newline case-fold-search outbuf buffer-read-only nnmail-pathname-coding-system file-name-coding-system] 5 (#$ . 30373)])
#@60 Convert article in current buffer to Rmail message format.
(defalias 'gnus-convert-article-to-rmail #[nil "\301eb\210\302c\210\303\304\301\305#\203�\306\307\305\211#\210\202�db\210\310c)\207" [buffer-read-only nil "\f\n0, unseen,,\n*** EOOH ***\n" search-forward "\n" t replace-match "\n^_" ""] 4 (#$ . 31625)])
#@111 Apply the result of the first function in FUNS to the second, and so on.
ARG is passed to the first function.
(defalias 'gnus-map-function #[(funs arg) "\203�\211A@	!\202��	\207" [funs arg] 2 (#$ . 31949)])
#@61 Does the same as `run-hooks', but saves the current buffer.
(defalias 'gnus-run-hooks #[(&rest funcs) "r\301\302\")\207" [funcs apply run-hooks] 3 (#$ . 32167)])
#@70 Does the same as `run-hook-with-args', but saves the current buffer.
(defalias 'gnus-run-hook-with-args #[(hook &rest args) "r\302\303	#)\207" [hook args apply run-hook-with-args] 4 (#$ . 32336)])
#@105 Run `run-mode-hooks' if it is available, otherwise `run-hooks'.
This function saves the current buffer.
(defalias 'gnus-run-mode-hooks #[(&rest funcs) "\301\302!\203
�r\303\302\")\207r\303\304\")\207" [funcs fboundp run-mode-hooks apply run-hooks] 3 (#$ . 32541)])
#@37 Say whether Gnus is running or not.
(defalias 'gnus-alive-p #[nil "\302\300!\205�\303!\205�rq\210	)\304=\207" [gnus-group-buffer major-mode boundp get-buffer gnus-group-mode] 2 (#$ . 32814)])
#@208 Return a copy of SEQUENCE with all items satisfying PREDICATE removed.
SEQUENCE should be a list, a vector, or a string.  Returns always a list.
If HASH-TABLE-P is non-nil, regards SEQUENCE as a hash table.
(defalias 'gnus-remove-if #[(predicate sequence &optional hash-table-p) "\304	\203�\305\306\n\"\210\202/�\n<\204�\307\n\304\"\n\203/�\n@!\204(�\n@B\nA\211\204�\237)\207" [out hash-table-p sequence predicate nil mapatoms #[(symbol) "	!?\205\f�	\nB\211\207" [predicate symbol out] 2] append] 4 (#$ . 33017)])
#@212 Return a copy of SEQUENCE with all items not satisfying PREDICATE removed.
SEQUENCE should be a list, a vector, or a string.  Returns always a list.
If HASH-TABLE-P is non-nil, regards SEQUENCE as a hash table.
(defalias 'gnus-remove-if-not #[(predicate sequence &optional hash-table-p) "\304	\203�\305\306\n\"\210\202/�\n<\204�\307\n\304\"\n\203/�\n@!\203(�\n@B\nA\211\204�\237)\207" [out hash-table-p sequence predicate nil mapatoms #[(symbol) "	!\205�	\nB\211\207" [predicate symbol out] 2] append] 4 (#$ . 33550)])
(byte-code "\300\301!\203�\302\303\301\"\210\202�\302\303\304\"\210\300\207" [fboundp assq-delete-all defalias gnus-delete-alist #[(key alist) "\303	\n\236\211\203�\304\n\"\202�\n)\207" [entry key alist nil delq] 3 "Delete from ALIST all elements whose car is KEY.\nReturn the modified alist."]] 3)
#@66 Find if a WORD matches any regular expression in the given LIST.
(defalias 'gnus-grep-in-list #[(word list) "\205�	\205�\302\303\215\207" [word list found (byte-code "\304\211\205�\n@\305	\"\203�\306\307	\"\210\nA\211\204�\304*\207" [list r --dolist-tail-- word nil string-match throw found] 4)] 2 (#$ . 34395)])
#@33 Modify ALIST to be without KEY.
(defalias 'gnus-alist-pull '(macro . #[(key alist &optional assoc-p) "9\204\n�\304\305\"\210	\203�\306\202�\307\310\311\nEEE)\207" [alist assoc-p fun key error "Not a symbol: %s" assoc assq setq delq] 6 (#$ . 34726)]))
#@72 Return a regexp that matches a whole line, if RE matches a part of it.
(defalias 'gnus-globalify-regexp #[(re) "\301\302\"?\205	�\303\301\304\"?\205�\305Q\207" [re string-match "^\\^" "^.*" "\\$$" ".*$"] 5 (#$ . 34992)])
#@51 Set the window start to POINT, or (point) if nil.
(defalias 'gnus-set-window-start #[(&optional point) "\302p\303\"\211\205�\304	\206�`\")\207" [win point gnus-get-buffer-window t set-window-start] 4 (#$ . 35223)])
(defalias 'gnus-annotation-in-region-p #[(b e) "	U\203�\303\304!>\211A@)\305=\207\306	\303\305$\207" [b e x gnus-undeletable text-properties-at t text-property-any] 6])
#@52 Return non-nil if any of the elements are non-nil.
(defalias 'gnus-or #[(&rest elems) "\300\301\215\207" [found (byte-code "\205�\211A@\203��\301\302\303\"\210\202��\207" [elems throw found t] 3)] 2 (#$ . 35622)])
#@52 Return non-nil if all of the elements are non-nil.
(defalias 'gnus-and #[(&rest elems) "\300\301\215\207" [found (byte-code "\203�\211A@\204��\301\302\303\"\210\202��\304\207" [elems throw found nil t] 3)] 2 (#$ . 35846)])
(defalias 'gnus-write-active-file #[(file hashtb &optional full-names) "\n\306\307\310!!\311\216rq\210\312 \210\313\314
\"\210db\210\315\316\317\320#\205*�\321\322!\210\202�)rq\210\323\317\211\f\317\324%\210-\207" [nnmail-active-file-coding-system coding-system-for-write file #1=#:temp-buffer #2=#:temp-file hashtb get-buffer-create generate-new-buffer-name " *temp file*" ((byte-code "\301!\203\n�\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) mm-disable-multibyte mapatoms #[(sym) "\205>�\303!\205>�J\205>�\304\305	\203�\2020�\306\307!\310\311\n\"\203-�\n\312\225\313O\202.�\n)!JA\2069�J@J@$c\207" [sym full-names gname boundp format "%S %d %d y\n" intern symbol-name string-match "^[^:]+:" 0 nil] 6] search-backward "\\." nil t delete-char 1 write-region 0] 7])
(defalias 'gnus-with-output-to-file '(macro . #[(file &rest body) "\306\307!\306\310!\306\311!\306\312!\313\n\314B\315\n\316BBD	\317B\320B\321\322\323\324	\325BBB\326\327\n\330	\331	DEE\332\333\334\f\335BBBBB\330	\336\337BBBBEEFD\257\300
\340\341	\342BB\343\344\333\345\336	F\334\f\346BBBBBEEC\",BB\207" [append leng size buffer file body make-symbol "output-buffer" "output-buffer-size" "output-buffer-length" "output-buffer-append" let* (131072) make-string (0) (0) (nil) standard-output lambda (c) aset (c) if = setq 1+ progn write-region nil ('no-msg) 0 (t) when > (0) let ((coding-system-for-write 'no-conversion)) substring ('no-msg)] 18]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\210\306\307!\203�\310\311\307\"\210\202�\310\311\312\"\210\300\207" [put gnus-with-output-to-file lisp-indent-function 1 edebug-form-spec (form body) fboundp union defalias gnus-union #[(l1 l2) "\204�	\207	\204\f�\207	\232\203�\207G	GY\204 �		\2039�	@\235\2040�	@B	\211A@\210\202 �\207" [l1 l2] 2 "Set union of lists L1 and L2."]] 4)
#@75 Like `gnus-add-text-properties', only applied on where PROPERTY is VALUE.
(defalias 'gnus-add-text-properties-when #[(property value start end properties &optional object) "\306	\203*�	\nW\203*�\307	\n\f$\211\203*�\310	
\n$\210\311\n\f$\211\204�	\2055�\310	\n
\n$)\207" [point start end property value properties nil text-property-not-all gnus-add-text-properties text-property-any object] 6 (#$ . 37932)])
#@73 Like `remove-text-properties', only applied on where PROPERTY is VALUE.
(defalias 'gnus-remove-text-properties-when #[(property value start end properties &optional object) "\306	\203*�	\nW\203*�\307	\n\f$\211\203*�\310	
$\210\311\n\f$\211\204�	\2036�\310	\n
$\210)\312\207" [point start end property value properties nil text-property-not-all remove-text-properties text-property-any t object] 6 (#$ . 38355)])
(defalias 'gnus-string-remove-all-properties #[(string) "\300\301\302\217\207" [nil (byte-code "\302\303G\304$\210	)\207" [string s set-text-properties 0 nil] 5) ((error string))] 3])
#@61 Like `string-equal', except it compares case-insensitively.
(defalias 'gnus-string-equal #[(x y) "G	GU\205�	\230\206�\227	\227\230\207" [x y] 2 (#$ . 38973)])
#@130 If non-nil, byte-compile crucial run-time code.
Setting it to nil has no effect after the first time `gnus-byte-compile'
is run.
(custom-declare-variable 'gnus-use-byte-compile t '(#$ . 39144) :type 'boolean :version "22.1" :group 'gnus-various)
#@58 Byte-compile FORM if `gnus-use-byte-compile' is non-nil.
(defalias 'gnus-byte-compile #[(form) "\203�\302\303\304\217\210\305\306!\210\307\310\311\"\210\310	!\207	\207" [gnus-use-byte-compile form nil (byte-code "\300\301!\207" [require byte-optimize] 2) ((error)) require bytecomp defalias gnus-byte-compile #[(form) "\302\303	!)\207" [byte-compile-warnings form (unresolved callargs redefine) byte-compile] 2]] 3 (#$ . 39396)])
#@309 Delete by side effect any elements of LIST whose car is `equal' to KEY.
The modified LIST is returned.  If the first member
of LIST has a car that is `equal' to KEY, there is no way to remove it
by side effect; therefore, write `(setq foo (gnus-remassoc key foo))' to be
sure of changing the value of `foo'.
(defalias 'gnus-remassoc #[(key alist) "\205�	\211@@)\232\203�A\207\303	A\"\241\210\207" [alist key x gnus-remassoc] 5 (#$ . 39836)])
(defalias 'gnus-update-alist-soft #[(key value alist) "\203
�	B\303	\n\"B\207\303	\n\"\207" [value key alist gnus-remassoc] 4])
#@45 Create a command that will go to info NODE.
(defalias 'gnus-create-info-command #[(node) "\301\302\303\304P\305D\306BBBBB\207" [node lambda nil (interactive) "Enter the info system at node " Info-goto-node ((setq gnus-info-buffer (current-buffer)) (gnus-configure-windows 'info))] 6 (#$ . 40423)])
(defalias 'gnus-not-ignore #[(&rest args) "\300\207" [t] 1])
#@141 The regexp of directory separator character.
If you find some problem with the directory separator character, try
"[/\\]" for some systems.
(defvar gnus-directory-sep-char-regexp "/" (#$ . 40791))
(defalias 'gnus-url-unhex #[(x) "\301V\203�\302Y\203�\303\302Z\\\207\303\304Z\\\207\305Z\207" [x 57 97 10 65 48] 3])
#@218 Remove %XX, embedded spaces, etc in a url.
If optional second argument ALLOW-NEWLINES is non-nil, then allow the
decoding of carriage returns and line feeds in the string, which is normally
forbidden in URL encoding.
(defalias 'gnus-url-unhex-string #[(str &optional allow-newlines) "\306\307\310\311\n\"\203P�\312\224\313\nT\234!\211\314_\313\n\315\\\234!\\	\n\312O\2031�\316
!\202D�
\317U\204=�
\320U\203A�\321\202D�\316
!Q\n\312\225\322O+\202�	\nP\211*\207" [case-fold-search tmp str start ch1 code "" t string-match "%[0-9a-f][0-9a-f]" 0 gnus-url-unhex 16 2 char-to-string 10 13 " " nil allow-newlines] 6 (#$ . 41119)])
#@187 Transform SPEC into a function that can be called.
SPEC is a predicate specifier that contains stuff like `or', `and',
`not', lists and functions.  The functions all take one parameter.
(defalias 'gnus-make-predicate #[(spec) "\301\302\303!E\207" [spec lambda (elem) gnus-make-predicate-1] 4 (#$ . 41764)])
(defalias 'gnus-make-predicate-1 #[(spec) "9\203	�\301B\207<\205\"�@\302>\203�@\303\304A\"B\207\305\306\"\207" [spec (elem) (or and not) mapcar gnus-make-predicate-1 error "Invalid predicate specifier: %s"] 4])
#@39 Call `gnus-completing-read-function'.
(defalias 'gnus-completing-read #[(prompt collection &optional require-match initial-input history def) "	\n\205\n�\306\n\307Q\310Q\f
	\n&\207" [gnus-completing-read-function prompt def collection require-match initial-input " (default " ")" ": " history] 7 (#$ . 42297)])
#@43 Call standard `completing-read-function'.
(defalias 'gnus-emacs-completing-read #[(prompt collection &optional require-match initial-input history def) "\306\n\307\310\"\311\f
\n&)\207" [gnus-completion-styles completion-styles prompt collection require-match initial-input completing-read mapcar list nil history def] 8 (#$ . 42618)])
(autoload 'ido-completing-read "ido")
#@38 Call `ido-completing-read-function'.
(defalias 'gnus-ido-completing-read #[(prompt collection &optional require-match initial-input history def) "\306	\307\n\f
&\207" [prompt collection require-match initial-input history def ido-completing-read nil] 8 (#$ . 43005)])
#@44 `iswitchb' based completing-read function.
(defalias 'gnus-iswitchb-completing-read #[(prompt collection &optional require-match initial-input history def) "\305\306!\210\307\310\216	\204�\311\312\313\"\210\314\n\f#*\207" [iswitchb-make-buflist-hook iswitchb-mode prompt def require-match require iswitchb #[nil "\306\205�C	J\n#\307\211\307\211	\2033�	@\310
\"\203&�\202)�
B	A\211	\204�*\237*\211\n\207" [initial-input history collection filtered-choices choices x append nil memql --dolist-tail-- iswitchb-temp-buflist] 5] ((byte-code "\204	�\301\302\303\"\210\301\207" [iswitchb-mode remove-hook minibuffer-setup-hook iswitchb-minibuffer-setup] 3)) add-hook minibuffer-setup-hook iswitchb-minibuffer-setup iswitchb-read-buffer] 4 (#$ . 43282)])
(defalias 'gnus-graphic-display-p #[nil "\300 \207" [display-graphic-p] 1])
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put gnus-parse-without-error lisp-indent-function 0 edebug-form-spec (body)] 4)
#@62 Allow continuing onto the next line even if an error occurs.
(defalias 'gnus-parse-without-error '(macro . #[(&rest body) "\301\302\303\304\305\306\307\"B\310BBBE\207" [body while (not (eobp)) condition-case nil progn append ((goto-char (point-max))) ((error (gnus-error 4 "Invalid data on line %d" (count-lines (point-min) (point))) (forward-line 1)))] 8 (#$ . 44270)]))
#@75 Cache the contents of FILE in VARIABLE.  The contents come from FUNCTION.
(defalias 'gnus-cache-file-contents #[(file variable function) "\306\307!8\310\211\fJ\211\203 �	@\232\203 �	A@\232\204/�
!\f\nEL\210\n\2022�\311	8+\207" [file value contents time variable function 5 file-attributes nil 2] 4 (#$ . 44649)])
#@99 Ask user a multiple choice question.
CHOICE is a list of the choice char and help message at IDX.
(defalias 'gnus-multiple-choice #[(prompt choice &optional idx) "\306\211\307 \310\216\212	\204\334�\311\312\313\314\f\315#\316P#\210\317 \211\f\236\204\n�\306\320\321!\322!\210\323 \210\324 \210\325 \210\326\261\210\327\f\211
\206C�\330\331\306\211\211\211\"%&'()*+*\203{�
*@8G'+'V\204r�'+*A\211*\204^�+\332\\+\333 S+\245'\333 S'\245&)\203\327�('W\204\250�\331(\334\327!\210\335c\210&\336Z%\337\340%!\341Q\"\342\")\211,@@)
)@8#c\210)A)(T(\202\221�.	\202\n�+\343!\203\347�\344!\210	*\207" [buf tchar #1=#:wconfig prompt choice idx nil current-window-configuration ((set-window-configuration #1#)) message "%s (%s): " mapconcat #[(s) "\301@!\207" [s char-to-string] 2] ", " ", ?" read-char get-buffer-create "*Gnus Help*" pop-to-buffer fundamental-mode buffer-disable-undo erase-buffer ":\n\n" -1 1 0 4 window-width delete-char "\n" 3 "%c: %-" int-to-string "s" format buffer-live-p kill-buffer pad width n i alist list max x] 10 (#$ . 44979)])
(defalias 'gnus-select-frame-set-input-focus 'select-frame-set-input-focus)
#@84 Given a frame or window, return the associated display name.
Return nil otherwise.
(defalias 'gnus-frame-or-window-display-name #[(object) "\302!\204�\303!\205'�\304!\211\205'�\305\301\"\211;\205&�\306\307	\"\205&�	)\207" [object display framep windowp window-frame frame-parameter string-match "\\`[^:]*:[0-9]+\\(\\.[0-9]+\\)?\\'"] 4 (#$ . 46156)])
#@22 Update the tool bar.
(defalias 'gnus-tool-bar-update #[(&rest ignore) "\303\300!\2055�\2055�\304\305\306!\203�\306\202/�\305\307!\203 �\307\202/�\305\310!\203.�\311 C\310\202/�\312\313\n	\"*\207" [tool-bar-mode args func boundp nil fboundp tool-bar-update force-window-update redraw-frame selected-frame ignore apply] 3 (#$ . 46519)])
#@366 Apply FUNCTION to each element of the sequences, and make a list of the results.
If there are several sequences, FUNCTION is called with that many arguments,
and mapping stops as soon as the shortest sequence runs out.  With just one
sequence, this is like `mapcar'.  With several, it is like the Common Lisp
`mapcar' function extended to arbitrary sequence types.
(defalias 'gnus-mapcar '(macro . #[(function seq1 &rest seqs2_n) "\203y�	B\306\307\310\n\"\311\312!\311\313!\314\315\211B\f
\316DC\244\210
DC\244\210\f\203H�\f\211A@\n\211A@DC\244\210\2021�A*\317\320\fB\321\322\323\307\324\f\"BB\325BBE\326\327D\330\331\307\332\f\"\"BBBF\327
DF-\207\307	E\207" [seqs2_n seq1 seqs cnt heads result 0 mapcar #[(seq) "\301\302\303T\211!P!\207" [cnt make-symbol "head" int-to-string] 5] make-symbol "result" "result-tail" let* nil (cons nil nil) while and setcdr cons funcall #[(h) "\301D\207" [h car] 2] (nil) setq cdr apply nconc #[(h) "\301DD\207" [h cdr] 3] result-tail bindings function] 13 (#$ . 46866)]))
(byte-code "\300\301!\203�\302\303\301\"\210\202�\302\303\304\"\210\300\207" [fboundp merge defalias gnus-merge #[(type list1 list2 pred) "\304	\203)�\n\203)�\n@	@\"\203�\n\211A@B\202�	\211A@B\202�\237	\244\n\244)\207" [res list1 list2 pred nil] 3 "Destructively merge lists LIST1 and LIST2 to produce a new list.\nArgument TYPE is for compatibility and ignored.\nOrdering of the elements is preserved according to PRED, a `less-than'\npredicate on the elements."]] 3)
#@28 Stringified Emacs version.
(defalias 'gnus-emacs-version #[nil "<\203	�\202\n�\306\307	>\203�\n\202\"�\310	>\203!�\311!\202\"�\312\312\211\313\314	>\2045�\312\202U�\315\316\"\203S�\317\320\321\"\f\203N�\322\f\323Q\202O�\324Q\202U�,\207" [gnus-user-agent lst system-configuration system-type system-v codename (gnus emacs type) config type symbol-name nil "Emacs" emacs string-match "^\\(\\([.0-9]+\\)*\\)\\.[0-9]+$" "Emacs/" match-string 1 " (" ")" "" emacsname emacs-version] 6 (#$ . 48399)])
#@92 Rename OLD-PATH as NEW-PATH.  If TRIM, recursively delete
empty directories from OLD-PATH.
(defalias 'gnus-rename-file #[(old-path new-path &optional trim) "\306!\205U�\307!\310!\307!\310!\311\312\f!\210\313\314#\210\205T�\315	!\211@\316\235\203=�A\211\202.�G\317U\205T�\320	!\210\321\322	\323P!!\202(�-\207" [old-path old-dir old-name new-path new-dir new-name file-exists-p file-name-directory file-name-nondirectory nil gnus-make-directory rename-file t directory-files ("." "..") 0 delete-directory file-name-as-directory file-truename ".." temp trim] 5 (#$ . 48916)])
#@29 Wrapper for set-file-modes.
(defalias 'gnus-set-file-modes #[(filename mode) "\300\301\302\217\207" [nil (set-file-modes filename mode) ((error))] 3 (#$ . 49519)])
(byte-code "\300\301!\203�\302\303\301\"\210\202�\302\303\304\"\210\302\305\300\306!\203�\306\202 �\307\"\207" [fboundp set-process-query-on-exit-flag defalias gnus-set-process-query-on-exit-flag process-kill-without-query gnus-read-shell-command read-shell-command read-string] 4)
#@59 Set the value for char RANGE to VALUE in DISPLAY-TABLE.  
(defalias 'gnus-put-display-table '(macro . #[(range value display-table) "\303	\nF\207" [display-table range value aset] 4 (#$ . 49974)]))
#@46 Find value for CHARACTER in DISPLAY-TABLE.  
(defalias 'gnus-get-display-table '(macro . #[(character display-table) "\302	E\207" [display-table character aref] 3 (#$ . 50179)]))
#@113 Rescale IMAGE to SIZE if possible.
SIZE is in format (WIDTH . HEIGHT). Return a new image.
Sizes are in pixels.
(defalias 'gnus-rescale-image #[(image size) "\304\305!\203\f�\306p!\204�\207	@	A\307\310\"A\nV\203.�\311\312A\313\"\314\310\315\n%\206-�\307\310\"@V\203H�\311\312A\313\"\314\310\316%\206G�*\207" [image size new-height new-width fboundp imagemagick-types get-buffer-window image-size t create-image plist-get :data imagemagick :height :width] 6 (#$ . 50366)])
#@37 Return all regular files below DIR.
(defalias 'gnus-recursive-directory-files #[(dir) "\304\305	\306\"\304\211\203?�@\307\n!\310\235\2048�\311\n!\2038�\312\n!\203+�\nB\2028�\313\n!\2038�\314\315\n!\"A\211\204
�*)\207" [files dir file --dolist-tail-- nil directory-files t file-name-nondirectory ("." "..") file-readable-p file-regular-p file-directory-p append gnus-recursive-directory-files] 4 (#$ . 50859)])
#@63 Return non-nil if any of the members of ELEMENTS are in LIST.
(defalias 'gnus-list-memq-of-list #[(elements list) "\305	\305\211\203�@\206�\n\f>A\211\204\n�*)\207" [found elements elem --dolist-tail-- list nil] 3 (#$ . 51287)])
(byte-code "\300\301!\203�\302\303\301\"\210\202�\302\303\304\"\210\300\305!\203!�\302\306\305\"\210\202,�\302\306\307\"\210\310\306\311\312#\210\300\313!\203:�\302\314\313\"\210\202?�\302\314\315\"\210\300\316!\203M�\302\317\316\"\210\202R�\302\317\320\"\210\300\207" [fboundp match-substitute-replacement defalias gnus-match-substitute-replacement #[(replacement &optional fixedcase literal string subexp) "\306\307\"\310 \311\216\312\313\314\310\315!\"!\210\316\f
	%+\207" [string match save-match-data-internal replacement fixedcase literal match-string 0 match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) set-match-data mapcar #[(x) "\247\203\n�\301\224Z\207\207" [x 0] 2] t replace-match subexp] 6 "Return REPLACEMENT as it will be inserted by `replace-match'.\nIn other words, all back-references in the form `\\&' and `\\N'\nare substituted with actual strings matched by the last search.\nOptional FIXEDCASE, LITERAL, STRING and SUBEXP have the same\nmeaning as for `replace-match'.\n\nThis is the definition of match-substitute-replacement in subr.el from GNU Emacs."] string-match-p gnus-string-match-p #[(regexp string &optional start) "\304 \305\216\306	\n#*\207" [save-match-data-internal regexp string start match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) string-match] 4 "Same as `string-match' except this function does not change the match data."] put byte-optimizer byte-compile-inline-expand string-prefix-p gnus-string-prefix-p #[(str1 str2 &optional ignore-case) "G	GX\205�	\304GO\203�\227\n\227\230\202�\n\230)\207" [str1 str2 prefix ignore-case 0] 3 "Return non-nil if STR1 is a prefix of STR2.\nIf IGNORE-CASE is non-nil, the comparison is done without paying attention\nto case differences."] macroexpand-all gnus-macroexpand-all #[(form &optional environment) ":\203=�\305\306!\211G\307\211\nW\203(�\233\3108\f\"\240\210T\211\202�\311\f\"\211=\2037�\202;�\310	\f\"+\207\207" [form expanded len idx environment 1 copy-sequence nil gnus-macroexpand-all macroexpand] 5 "Return result of expanding macros at all levels in FORM.\nIf no macros are expanded, FORM is returned unchanged.\nThe second optional arg ENVIRONMENT specifies an environment of macro\ndefinitions to shadow the loaded ones for use in file byte-compilation."]] 4)
(defalias 'gnus-bound-and-true-p #[(sym) "\301!\205�J\207" [sym boundp] 2])
(byte-code "\300\301!\203�\302\303\301\"\210\202�\302\303\304\"\210\305\306!\207" [fboundp timer--function defalias gnus-timer--function #[(timer) "\301\234\207" [timer 5] 2] provide gnus-util] 3)