Current File : //kunden/usr/share/emacs/27.2/lisp/gnus/gnus-util.elc

;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; 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\304\305\306\307\310\311\312\313\314\315&	\210\304\316\317\320\310\311\312\313\314\321&	\210\322\323\324\"\210\322\325\326\"\210\322\327\326\"\210\322\330\331\"\207" [require seq time-date text-property-search 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 (append (when (and (assq 'substring completion-styles-alist) (not (memq 'substring completion-styles))) (list 'substring)) completion-styles) "Value of `completion-styles' to use when completing." (repeat symbol) autoload gnus-get-buffer-window "gnus-win" nnheader-narrow-to-headers "nnheader" nnheader-replace-chars-in-string mail-header-remove-comments "mail-parse"] 10)
#@212 Replace all matches for REGEXP with NEWTEXT in STRING.
If LITERAL is non-nil, insert NEWTEXT literally.  Return a new
string containing the replacements.

This is a compatibility function for different Emacsen.
(defalias 'gnus-replace-in-string #[(string regexp newtext &optional literal) "\304	\n\305%\207" [regexp newtext string literal replace-regexp-in-string nil] 6 (#$ . 1512)])
(make-obsolete 'gnus-replace-in-string 'replace-regexp-in-string "26.1")
#@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 (#$ . 1978)]))
(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)
(defalias 'gnus-goto-char #[(point) "\205b\207" [point] 1])
(put 'gnus-goto-char 'byte-optimizer 'byte-compile-inline-expand)
#@72 Delete by side effect the first occurrence of ELT as a member of LIST.
(defalias 'gnus-delete-first #[(elt list) "@	\232\203\nA\207A\203 A@	\232\204 A\211\202
A\203+\211AA\241\210\n)\207" [list elt total] 3 (#$ . 2750)])
(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]))
#@275 Extract address components from a From header.
Given an RFC-822 (or later) address FROM, extract name and address.
Returns a list of the form (FULL-NAME CANONICAL-ADDRESS).  Much more simple
solution than `mail-header-parse-address', which works much better, but
is slower.
(defalias 'gnus-extract-address-components #[(from) "\303\211\304\305\n\"\203\306\n\307\224\307\225#\202%\304\310\n\"\203%\306\n\311\224\311\225#\203O\304\312\313!\314Q\n\"\203O\306\n\311\211\224#\211\203O\304\315	\"\203O\306	\307\311\225S#	\204\205\304\316\n\"\203h\306\n\311\224T\311\225S#\211\204\205\304\317\n\"\203u\211\204\205\304\320\n\"\203\205\306\n\311\224T\311\225#	\321\230?\205\215	\206\222\n*D\207" [address name from nil string-match "<\\([^@ 	<>]+[!@][^@ 	<>]+\\)>" substring 1 "\\b[^@ 	<>]+[!@][^@ 	<>]+\\b" 0 "[ 	]*<" regexp-quote ">" "^\".*\"$" "(.+)" "()" "(.*" ""] 4 (#$ . 3158)])
#@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 (#$ . 4069)])
#@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 (#$ . 4335)])
(defalias 'gnus-goto-colon #[nil "\301\302!\210\303 \304`\305\306$\206\307\310\306#\206`b)\207" [eol move-beginning-of-line 1 point-at-eol text-property-any gnus-position t search-forward ":"] 5])
#@475 Search current buffer for text property PROP with VALUE.
Behaves like a combination of `text-property-any' and
`text-property-search-forward'.  Searches for the beginning of a
text property `equal' to VALUE.  Returns the value of point at
the beginning of the matching text property span.

If FORWARD-ONLY is non-nil, only search forward from point.

If GOTO is non-nil, move point to the beginning of that span
instead.

If END is non-nil, use the end of the span instead.
(defalias 'gnus-text-property-search #[(prop value &optional forward-only goto end) "`	\204	eb\210\306\n\307#\211\205@
\203-\310\f!>\204'\311\312\313\fD\"\210\f\314H\202@\310\f!>\204=\311\312\313\fD\"\210\f\315H\211\205V\203Qb\202Vb\210+\207" [start forward-only prop value found end text-property-search-forward equal type-of signal wrong-type-argument prop-match 2 1 cl-struct-prop-match-tags target goto] 5 (#$ . 4746)])
(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 (#$ . 6013)])
#@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 (#$ . 6340)])
#@55 Make hierarchical directory name from NEWSGROUP name.
(defalias 'gnus-newsgroup-directory-form #[(newsgroup) "\302!\303\304\"\211\205\305\306	#	\205\307\310	\203$\305	T\"\202%\311\312#Q*\207" [newsgroup idx gnus-newsgroup-savable-name string-match ":" substring 0 "/" nnheader-replace-chars-in-string 46 47] 7 (#$ . 6765)])
(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 (#$ . 7302)])
(defalias 'gnus-file-newer-than #[(file date) "\302\303	!\304
8\262
\"\207" [date file time-less-p file-attributes 5] 5])
#@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 (#$ . 7797)]))
#@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 (#$ . 7997)]))
#@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 (#$ . 8181)]))
(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 (#$ . 8589)]))
(put 'gnus-define-keymap 'lisp-indent-function 1)
(defalias 'gnus-define-keys-1 #[(keymap plist &optional safe) "\204\304\305!\2109\203J\2029\306!\2049<\2039@\307L\210\310@!\210\311AA@JA@@#\210@J\307\n\205o\n\211A\242\2119\203M	J\203Z\312	\"\313=\203g\311	\n\211A\242#\210\202;\n\211A\210\202;)\207" [keymap key plist safe error "Can't set keys in a null keymap" keymapp nil define-prefix-command define-key lookup-key undefined] 5])
(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])
#@52 Return the integer number of seconds passed today.
(defalias 'gnus-seconds-today #[nil "\301\302\211\303#\304@A@\305_\3068\307_#)\207" [now decode-time nil integer + 60 2 3600] 5 (#$ . 9435)])
#@57 Return the integer number of seconds passed this month.
(defalias 'gnus-seconds-month #[nil "\301\302\211\303#\304@A@\305_\3068\307_\310\3118S\307\312#$)\207" [now decode-time nil integer + 60 2 3600 * 3 24] 8 (#$ . 9638)])
#@56 Return the integer number of seconds passed this year.
(defalias 'gnus-seconds-year #[nil "\303 \304\305\306#\307\310\"\311	@	A@\312_\313	8\314_\315\316\n!S\314\317#$+\207" [current now days current-time decode-time nil integer format-time-string "%j" + 60 2 3600 * string-to-number 24] 8 (#$ . 9873)])
#@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 (#$ . 10187)]))
#@54 Return a string like DD-MMM from a big messy string.
(defalias 'gnus-dd-mmm #[(messy-date) "\3031,\304\305\211\306\232\203\307\202(\310\311\312	#\206(\313	!\314\311\315\312\n	%\210\n))\"0\207\210\316\207" [messy-date d time (error) format-time-string "%d-%b" "" (0 0) get-text-property 0 gnus-time safe-date-to-time put-text-property 1 "  -   "] 9 (#$ . 10535)])
#@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 (#$ . 10912)])
(put 'gnus-time-iso8601 'byte-optimizer 'byte-compile-inline-expand)
#@38 Convert the DATE to YYYYMMDDTHHMMSS.
(defalias 'gnus-date-iso8601 #[(date) "\3031/\211\304\232\203\305\202&\306\307\310	#\206&\311	!\312\307\313\310\n	%\210\n))\314\315\n\")0\207\210\304\207" [date d time (error) "" (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 (#$ . 11153)])
#@28 Quote all "%"'s in STRING.
(defalias 'gnus-mode-string-quote #[(string) "\301\302\303#\207" [string replace-regexp-in-string "%" "%%"] 4 (#$ . 11511)])
#@48 Make a hash table of SIZE, testing on `equal'.
(defalias 'gnus-make-hashtable #[(&optional size) "\301\302\206\303\304\305$\207" [size make-hash-table :size 300 :test equal] 5 (#$ . 11670)])
(byte-code "\300\301\302\303#\210\304\305\306\307\310\311\312\313\314\315&	\210\304\316\317\320\310\321\312\322\314\323&	\207" [put gnus-make-hashtable byte-optimizer byte-compile-inline-expand 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\nthe \"*Messages*\" buffer.  If it is neither nil nor `log', add\ntimestamps not only to log messages but also to the ones\ndisplayed 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=\203X\306\310\311\f
#)\203T\312V\203T	G\312U\204T\313 r\314\315!\2033\315 \2026\316\317!q\210db\210\320\321\322\"	\323\261\210[y\210e`|\210)db\210)	\202\223\n\203\216\f\204d
\203q\310\324\f
#\211G\312U\203}\f\205v	\311\306!\210\202\223\313 \311\325\321\322\"	P\"\210	\202\223\310\311\f
#*\207" [time str gnus-add-timestamp-to-message message-log-max format-string args nil log apply message 0 current-time fboundp messages-buffer get-buffer-create "*Messages*" t format-time-string "%Y%m%dT%H%M%S.%3N> " "\n" format-message "%s" inhibit-read-only] 6 (#$ . 12995)])
#@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-message] 3 (#$ . 13837)])
(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_\211\313U\204*\314!\210)\310\207" [level gnus-verbose args duration floor apply message ding nil floatp 10 0 sit-for] 4 (#$ . 14582)])
#@45 Return a list of Message-IDs in REFERENCES.
(defalias 'gnus-split-references #[(references) "\303\304\206\305!\306\307\310\n#\203#\311\303\224\303\225\211#	B\202\f	\237+\207" [references ids beg 0 mail-header-remove-comments "" nil string-match "<[^<]+[^< 	]" substring] 5 (#$ . 14933)])
#@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 (#$ . 15240)])
#@82 Return the last Message-ID in REFERENCES.
If N, return the Nth ancestor instead.
(defalias 'gnus-parent-id #[(references &optional n) "\205YG\304U?\205Y	\203I\304\305\206\306!\307\310\311#\2035\312\304\224\304\225\211#\nB\202\n\237,	\n\233\203E\nA\2029\n@)\207\305!\310\313\"\205X\314\315\")\207" [references n ids beg 0 mail-header-remove-comments "" nil string-match "<[^<]+[^< 	]" substring "\\(<[^<]+>\\)[ 	]*\\'" match-string 1] 5 (#$ . 15621)])
(put 'gnus-parent-id 'byte-optimizer 'byte-compile-inline-expand)
#@61 If BUFFER names a live buffer, return its object; else nil.
(defalias 'gnus-buffer-live-p #[(buffer) "\205\301\302!\211!\205\207" [buffer buffer-live-p get-buffer] 3 (#$ . 16174)])
(byte-code "\300\301\302\303#\210\304\305\301\306#\210\307\305\301\310#\207" [put gnus-buffer-live-p byte-optimizer byte-compile-inline-expand defalias gnus-buffer-exists-p nil make-obsolete "27.1"] 4)
#@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 (#$ . 16571)])
#@21 Get the next event.
(defalias 'gnus-read-event-char #[(&optional prompt) "\302!\211\247\205\n		)B\207" [prompt event read-event] 3 (#$ . 17031)])
#@18 Copy FILE to TO.
(defalias 'gnus-copy-file #[(file &optional to) "\204	\303\304	\"\305\n\"\207" [to default-directory file read-file-name "Copy file to: " copy-file] 3 (#$ . 17186) (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\fq\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 (#$ . 17528)])
#@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 (#$ . 17801)]))
#@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 (#$ . 18039)]))
#@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 (#$ . 18488)])
#@67 Return a composite sort condition based on the functions in FUNS.
(defalias 'gnus-make-sort-function-1 #[(funs) "@\304\305\211:\203)@\306=\203A@\305\304\202)\307!\204)\310\311\"\210A\203C\312\n	E\313\306	\nED\314A!EE\202G\n	E+\207" [funs last first function t1 t2 not functionp error "Invalid sort spec: %s" or and gnus-make-sort-function-1] 8 (#$ . 18789)])
#@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 (#$ . 19177)])
#@313 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' 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-escape-multibyte print-escape-newlines print-escape-nonascii print-length print-level print-string-length)] 3 (#$ . 19403)]))
#@154 Use `prin1' on FORM in the current buffer.
Bind `print-quoted' to t, and `print-length' and `print-level' to
nil.  See also `gnus-bind-print-variables'.
(defalias 'gnus-prin1 #[(form) "\306\307\211\211\211\211\211	\310\np\".\207" [print-string-length print-level print-length print-escape-nonascii print-escape-newlines print-escape-multibyte t nil prin1 print-quoted form] 7 (#$ . 19964)])
#@132 The same as `prin1'.
Bind `print-quoted' to t, and `print-length' and `print-level' to
nil.  See also `gnus-bind-print-variables'.
(defalias 'gnus-prin1-to-string #[(form) "\306\307\211\211\211\211\211	\310\n!.\207" [print-string-length print-level print-length print-escape-nonascii print-escape-newlines print-escape-multibyte t nil prin1-to-string print-quoted form] 7 (#$ . 20371)])
#@151 Use `pp' on FORM in the current buffer.
Bind `print-quoted' to t, and `print-length' and `print-level' to
nil.  See also `gnus-bind-print-variables'.
(defalias 'gnus-pp #[(form &optional stream) "\306\307\211\211\211\211\211	\310\n\206p\".\207" [print-string-length print-level print-length print-escape-nonascii print-escape-newlines print-escape-multibyte t nil pp print-quoted form stream] 7 (#$ . 20774)])
#@139 The same as `pp-to-string'.
Bind `print-quoted' to t, and `print-length' and `print-level' to
nil.  See also `gnus-bind-print-variables'.
(defalias 'gnus-pp-to-string #[(form) "\306\307\211\211\211\211\211	\310\n!.\207" [print-string-length print-level print-length print-escape-nonascii print-escape-newlines print-escape-multibyte t nil pp-to-string print-quoted form] 7 (#$ . 21204)])
#@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 (#$ . 21607)])
#@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 (#$ . 21909)])
#@27 Delete FILE if it exists.
(defalias 'gnus-delete-file #[(file) "\301!\205	\302!\207" [file file-exists-p delete-file] 2 (#$ . 22212)])
#@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 (#$ . 22356)])
#@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\242\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 (#$ . 22537)])
#@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 (#$ . 22967)])
#@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 #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] re-search-forward move put-text-property 0] 5 (#$ . 23178)])
(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 #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] re-search-forward move overlay-put make-overlay 0] 4 (#$ . 23760)])
(put 'gnus-put-overlay-excluding-newlines 'byte-optimizer 'byte-compile-inline-expand)
#@161 The same as `put-text-property', except where `gnus-face' is set.
If so, and PROP is `face', set the second element of its value to VAL.
Otherwise, do nothing.
(defalias 'gnus-put-text-property-excluding-characters-with-faces #[(beg end prop val) "	W\2056\305\306\307	$\310\311\"\203)\306=\2030\310\306\"A\f\206$\312\240\210\2020\313\n\f$\210\n)\202\207" [beg end stop prop val next-single-property-change face nil get-text-property gnus-face default put-text-property] 5 (#$ . 24350)])
#@163 The same as `get-text-property', except where `gnus-face' is set.
If so, and PROP is `face', return the second element of its value.
Otherwise, return the value.
(defalias 'gnus-get-text-property-excluding-characters-with-faces #[(pos prop) "\303	\"\303\304\"\203	\305=\203\nA@\202\303	\")\207" [pos prop val get-text-property gnus-face face] 3 (#$ . 24860)])
#@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 (#$ . 25236)]))
#@70 If t, certain operations will be protected from interruption by C-g.
(defvar gnus-atomic-be-safe t (#$ . 25511))
#@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 (#$ . 25631)]))
(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) "A@@D\207" [x] 2] #[(x) "@\301\302\303A@DDA@ED\207" [x and boundp quote] 5] apply append make-symbol "result-tmp" let setq progn ((inhibit-quit gnus-atomic-be-safe)) sym-temp-assign result forms] 8 (#$ . 26283)]))
(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) "\303\211\203\n@	B\nAA\211\204\304	\305BE*\207" [pairs syms tpairs nil gnus-atomic-progn-assign setq] 5 (#$ . 27399)]))
(byte-code "\300\301!\210\302\303\304\"\207" [require rmail autoload rmail-update-summary "rmailsum"] 3)
#@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\202p\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\264eb\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\335db\210n\204\332\344c\210\344c\210)DE\354ed#\210)\202o
Bq\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 \203f
GH\364 \203U
\365 I\212\366\216\367J!\210HG\370 \210,\202b
rJq\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 #[nil "\301!\207" [window select-window] 2] 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 (#$ . 28011)])
#@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\242db\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 (#$ . 30294)])
#@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\202db\210\310c)\207" [buffer-read-only nil "\f\n0, unseen,,\n*** EOOH ***\n" search-forward "\n" t replace-match "\n^_" ""] 4 (#$ . 31546)])
#@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\242	!\202	\207" [funs arg] 2 (#$ . 31870)])
#@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 (#$ . 32091)])
#@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 (#$ . 32260)])
#@50 Run `run-mode-hooks', saving the current buffer.
(defalias 'gnus-run-mode-hooks #[(&rest funcs) "r\301\302\")\207" [funcs apply run-mode-hooks] 3 (#$ . 32464)])
#@37 Say whether Gnus is running or not.
(defalias 'gnus-alive-p #[nil "\302\300!\205\303!\205rq\210	)\304=\207" [gnus-group-buffer major-mode boundp get-buffer gnus-group-mode] 2 (#$ . 32632)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\210\300\306\307\303#\210\304\306\307\305#\207" [defalias gnus-remove-if seq-remove nil make-obsolete "27.1" gnus-remove-if-not seq-filter] 4)
#@66 Find if a WORD matches any regular expression in the given LIST.
(defalias 'gnus-grep-in-list #[(word list) "\205-	\205-\3042-	\305\211\205+@\306\n\"\203#\307\304\n\"\210A\211\204\305*0\207" [word list r --dolist-tail-- found nil string-match throw] 4 (#$ . 33027)])
#@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 (#$ . 33315)]))
#@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 (#$ . 33581)])
#@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 (#$ . 33812)])
(defalias 'gnus-annotation-in-region-p #[(b e) "	U\203\302\303!>A@\304=\207\305	\302\304$\207" [b e gnus-undeletable text-properties-at t text-property-any] 5])
#@51 Return non-nil if any one of ELEMENTS is non-nil.
(defalias 'gnus-or #[(&rest elements) "\301\302\"\207" [elements seq-drop-while null] 3 (#$ . 34203)])
#@45 Return non-nil if all ELEMENTS are non-nil.
(defalias 'gnus-and #[(&rest elements) "\301>?\207" [elements nil] 2 (#$ . 34363)])
(defalias 'gnus-write-active-file #[(file hashtb &optional full-names) "\n\306\307!\310\216rq\210\311\312
\"\210db\210\313\314\315\316#\205%\317\320!\210\202)rq\210\321\315\211\f\315\322%\210-\207" [nnmail-active-file-coding-system coding-system-for-write file #1=#:temp-buffer #2=#:temp-file hashtb generate-new-buffer " *temp file*" #[nil "\301!\205	\302!\207" [#1# buffer-name kill-buffer] 2] maphash #[(group active) "\205,\304\305	\203\n\202!\n\306\307\"\203\310\311\225\"\202 )A\206(@@$c\207" [active full-names group gname format "%s %d %d y\n" string-match "^[^:]+:" substring 0] 5] 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#\207" [put gnus-with-output-to-file lisp-indent-function 1 edebug-form-spec (form body)] 4)
#@70 Like `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 add-text-properties text-property-any object] 6 (#$ . 35981)])
#@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 (#$ . 36394)])
(defalias 'gnus-string-remove-all-properties #[(string) "\3021\303\304G\305$\210	)0\207\210\207" [string s (error) set-text-properties 0 nil] 5])
#@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 (#$ . 36977)])
#@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 '(#$ . 37148) :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!\210\304\305\306\"\210\305	!\207	\207" [gnus-use-byte-compile form require bytecomp defalias gnus-byte-compile #[(form) "\302\303	!)\207" [byte-compile-warnings form (unresolved callargs redefine) byte-compile] 2]] 3 (#$ . 37400)])
#@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	@@\232\203A\207\302	A\"\241\210\207" [alist key gnus-remassoc] 4 (#$ . 37752)])
(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 (#$ . 38331)])
(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 "/" (#$ . 38699))
(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\"\203Q\312\224\313\nT\234!\314\f_\313\n\315\\\234!\\	\316\n\312#\2032\317
!\202E
\320U\204>
\321U\203B\322\202E\317
!Q\316\n\312\225\"+\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 substring char-to-string 10 13 " " allow-newlines] 6 (#$ . 39027)])
#@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 (#$ . 39681)])
(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 (#$ . 40214)])
#@43 Call standard `completing-read-function'.
(defalias 'gnus-emacs-completing-read #[(prompt collection &optional require-match initial-input history def) "\306\n\307\f
	&)\207" [gnus-completion-styles completion-styles prompt collection require-match initial-input completing-read nil history def] 8 (#$ . 40535)])
(autoload 'ido-completing-read "ido")
#@29 Call `ido-completing-read'.
(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 (#$ . 40899)])
#@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\205C	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] #[nil "\206\301\302\303\"\207" [iswitchb-mode remove-hook minibuffer-setup-hook iswitchb-minibuffer-setup] 3] add-hook minibuffer-setup-hook iswitchb-minibuffer-setup iswitchb-read-buffer] 4 (#$ . 41167)])
(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 (#$ . 42064)]))
#@75 Cache the contents of FILE in VARIABLE.  The contents come from FUNCTION.
(defalias 'gnus-cache-file-contents #[(file variable function) "\306!\307
8\262
\310\211\fJ\211\203#	@\232\203#	A@\232\2042
!\f\nEL\210\n\2025\311	8+\207" [file value contents time variable function file-attributes 5 nil 2] 4 (#$ . 42443)])
#@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\330\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\323('W\204\250\331(\334\327!\210\335c\210&\336Z%\337\340%!\341Q\"\342\")@@
)@8#c\210)A)(T(\202\221.	\202\n+\343!\203\343\344!\210	*\207" [buf tchar #1=#:wconfig prompt choice idx nil current-window-configuration #[nil "\301!\207" [#1# set-window-configuration] 2] 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] 10 (#$ . 42779)])
#@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 (#$ . 43891)])
#@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 (#$ . 44254)])
#@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) "\203v	B\306\307\310\n\"\311\312!\311\313!\314\315\211B\f
\316DC\244\210
DC\244\210\f\203H\f\211A\242\n\211A\242DC\244\210\2021A*\317\320\fB\321\322\323\307\324\f\"BB\325BBE\326\327D\330\331\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 mapcan #[(h) "\301DD\207" [h cdr] 3] result-tail bindings function] 12 (#$ . 44601)]))
#@28 Stringified Emacs version.
(defalias 'gnus-emacs-version #[nil "<\203	\202\n\306\307	>\203\n\202\"\310	>\203!\311!\202\"\312\312\313	>\204/\312\202L\314\315\"\203J\316\f\203E\317\f\320Q\202F\321Q\202L+\207" [gnus-user-agent lst system-configuration system-type system-v codename (gnus emacs type) config type symbol-name nil emacs string-match "^[.0-9]*\\.[0-9]+$" "Emacs/" " (" ")" "" emacs-version] 5 (#$ . 45642)])
#@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 (#$ . 46091)])
#@29 Wrapper for set-file-modes.
(defalias 'gnus-set-file-modes #[(filename mode) "\3021\n\303	\"0\207\210\304\207" [filename mode (error) set-file-modes nil] 3 (#$ . 46694)])
#@114 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 \204\207	@	A\305\306\"A\nV\203#\307\310A\311\"\312\306\313\n%\305\306\"@V\2039\307\310A\311\"\312\306\314%*\207" [image size new-height new-width display-graphic-p image-size t create-image plist-get :data nil :max-height :max-width] 6 (#$ . 46874)])
#@108 Return all regular files below DIR.
The first found will be returned if a file has hard or symbolic links.
(defalias 'gnus-recursive-directory-files #[(dir) "\305\211\211\305\306\211\f!\210)\n+\207" [attrs attr files #1=#:--cl-fn-- dir nil #[(directory) "\306\307\"\310\211\205L\n@\311\312	!!\211\f\235\204D\313	!\314\235\204D\315	!\203D\fB\316	!\2039	
B\202D\317	!\203D	!\210\nA\211\204\310*\207" [directory file --dolist-tail-- attr attrs files directory-files t nil file-attributes file-truename file-name-nondirectory ("." "..") file-readable-p file-regular-p file-directory-p #1#] 4]] 4 (#$ . 47312)])
#@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 (#$ . 47950)])
#@131 To each element of LIST apply PREDICATE.
Return nil if LIST is no list or is empty or some test returns nil;
otherwise, return t.
(defalias 'gnus-test-list #[(list predicate) "\205<\205\303	\"\304\n>)?\207" [list predicate result mapcar nil] 3 (#$ . 48197)])
#@135 Return t if LIST1 is a subset of LIST2.
Similar to `subsetp' but use member for element test so that this works for
lists of strings.
(defalias 'gnus-subsetp #[(list1 list2) "<\205	<\205\203@	\235\205\302A	\"\207\303\207" [list1 list2 gnus-subsetp t] 3 (#$ . 48471)])
#@56 Return member-based set difference of LIST1 and LIST2.
(defalias 'gnus-setdiff #[(list1 list2) "\205#<\205#	<\205#@	\235\203\302A	\"\207@\302A	\"B\207" [list1 list2 gnus-setdiff] 4 (#$ . 48757)])
(defalias 'gnus-image-type-available-p #[(type) "\301 \205\302!\207" [type display-images-p image-type-available-p] 2])
(defalias 'gnus-create-image #[(file &optional type data-p &rest props) "\305\306\"\211\203\307\310\311	!#\307\312\313	!#\3141(\315\316\n\f%0\202*\210\317)\207" [props face file type data-p plist-get :face plist-put :foreground face-foreground :background face-background (error) apply create-image nil] 7])
(defalias 'gnus-put-image #[(glyph &optional string category) "`\304	\n\206	\305\"\210\306`\307$\210\n\204\306`S`\310\311$\210	)\207" [point glyph string category insert-image " " put-text-property gnus-image-category gnus-image-text-deletable t] 5])
#@59 Remove the image matching IMAGE and CATEGORY found first.
(defalias 'gnus-remove-image #[(image &optional category) "e\305\211?\205a\306\n\307\"\211\204&\310\n\307\"\211\205a\306\n\307\"\211\205a\310\n\307\"\206.d	\232\203S\306\n\311\"\f\232\203S\312\n\307\305$\210\306\n\313\"\203\n|\210\202dU\204\305\211\202+\207" [end val start image category nil get-text-property display next-single-property-change gnus-image-category put-text-property gnus-image-text-deletable] 6 (#$ . 49670)])
#@44 Delete all overlays in the current buffer.
(defalias 'gnus-kill-all-overlays #[nil "\303 \304\305\304@A\244\"\n\205\306\n\211A\242!\210\202+\207" [overlayss buffer-read-only overlays overlay-lists nil delq delete-overlay] 4 (#$ . 50193)])
(provide 'gnus-util)