;;; gnus-load.el --- automatically extracted custom dependencies and autoload
;;
;;; Code:

(put 'canlock 'custom-loads '(canlock))
(put 'comm 'custom-loads '(dig tls))
(put 'dig 'custom-loads '(dig))
(put 'earcon 'custom-loads '(earcon))
(put 'extensions 'custom-loads '(sha1))
(put 'faces 'custom-loads '(gnus message))
(put 'gmm 'custom-loads '(gmm-utils))
(put 'gnus 'custom-loads '(deuglify gnus gnus-art gnus-async gnus-delay gnus-demon gnus-diary gnus-dup gnus-eform gnus-sieve gnus-soup gnus-undo gnus-uu gnus-win gnus-xmas mail-source mm-url nnimap nnmail nntp spam-stat))
(put 'gnus-agent 'custom-loads '(gnus gnus-agent))
(put 'gnus-article 'custom-loads '(gnus-art gnus-cite))
(put 'gnus-article-buttons 'custom-loads '(gnus-art))
(put 'gnus-article-emphasis 'custom-loads '(gnus-art))
(put 'gnus-article-headers 'custom-loads '(gnus-art gnus-fun gnus-sum))
(put 'gnus-article-hiding 'custom-loads '(gnus-art gnus-cite gnus-sum))
(put 'gnus-article-highlight 'custom-loads '(gnus-art))
(put 'gnus-article-mime 'custom-loads '(gnus-art gnus-sum mm-uu))
(put 'gnus-article-saving 'custom-loads '(gnus gnus-art))
(put 'gnus-article-signature 'custom-loads '(gnus-art))
(put 'gnus-article-treat 'custom-loads '(gnus-art))
(put 'gnus-article-various 'custom-loads '(gnus-art gnus-sum))
(put 'gnus-article-washing 'custom-loads '(gnus-art))
(put 'gnus-asynchronous 'custom-loads '(gnus-async))
(put 'gnus-audio 'custom-loads '(gnus-audio))
(put 'gnus-cache 'custom-loads '(gnus gnus-cache))
(put 'gnus-charset 'custom-loads '(gnus gnus-group gnus-sum))
(put 'gnus-cite 'custom-loads '(gnus-cite))
(put 'gnus-delay 'custom-loads '(gnus-delay))
(put 'gnus-demon 'custom-loads '(gnus-demon))
(put 'gnus-diary 'custom-loads '(gnus-diary nndiary))
(put 'gnus-dribble-file 'custom-loads '(gnus-start))
(put 'gnus-duplicate 'custom-loads '(gnus-dup))
(put 'gnus-edit-form 'custom-loads '(gnus-eform))
(put 'gnus-exit 'custom-loads '(gnus gnus-group))
(put 'gnus-extract 'custom-loads '(binhex gnus gnus-uu uudecode))
(put 'gnus-extract-archive 'custom-loads '(gnus-uu))
(put 'gnus-extract-post 'custom-loads '(gnus-uu))
(put 'gnus-extract-view 'custom-loads '(gnus-sum gnus-uu))
(put 'gnus-files 'custom-loads '(gnus nnmail))
(put 'gnus-format 'custom-loads '(gnus-spec))
(put 'gnus-fun 'custom-loads '(gnus-fun))
(put 'gnus-group 'custom-loads '(gnus gnus-group gnus-topic))
(put 'gnus-group-foreign 'custom-loads '(gnus-group gnus-msg))
(put 'gnus-group-icons 'custom-loads '(gnus-group))
(put 'gnus-group-levels 'custom-loads '(gnus gnus-group gnus-start))
(put 'gnus-group-listing 'custom-loads '(gnus-group))
(put 'gnus-group-new 'custom-loads '(gnus-start))
(put 'gnus-group-select 'custom-loads '(gnus gnus-group gnus-sum))
(put 'gnus-group-various 'custom-loads '(gnus gnus-group gnus-start))
(put 'gnus-group-visual 'custom-loads '(gnus gnus-group))
(put 'gnus-message 'custom-loads '(gnus gnus-msg message))
(put 'gnus-meta 'custom-loads '(gnus))
(put 'gnus-newsrc 'custom-loads '(gnus-start))
(put 'gnus-nocem 'custom-loads '(gnus-nocem))
(put 'gnus-outlook-deuglify 'custom-loads '(deuglify))
(put 'gnus-picon 'custom-loads '(gnus gnus-art gnus-picon))
(put 'gnus-registry 'custom-loads '(gnus-registry))
(put 'gnus-score 'custom-loads '(gnus gnus-nocem))
(put 'gnus-score-adapt 'custom-loads '(gnus gnus-score))
(put 'gnus-score-decay 'custom-loads '(gnus-score))
(put 'gnus-score-default 'custom-loads '(gnus-score gnus-sum))
(put 'gnus-score-expire 'custom-loads '(gnus-kill gnus-score))
(put 'gnus-score-files 'custom-loads '(gnus gnus-score))
(put 'gnus-score-kill 'custom-loads '(gnus gnus-kill))
(put 'gnus-score-various 'custom-loads '(gnus gnus-score))
(put 'gnus-server 'custom-loads '(gnus gnus-srvr nnheader))
(put 'gnus-server-visual 'custom-loads '(gnus-srvr))
(put 'gnus-sieve 'custom-loads '(gnus-sieve))
(put 'gnus-soup 'custom-loads '(gnus-soup))
(put 'gnus-start 'custom-loads '(gnus gnus-group gnus-int gnus-start gnus-util nnheader))
(put 'gnus-start-server 'custom-loads '(gnus-start))
(put 'gnus-summary 'custom-loads '(gnus gnus-sum))
(put 'gnus-summary-choose 'custom-loads '(gnus-sum))
(put 'gnus-summary-exit 'custom-loads '(gnus gnus-sum))
(put 'gnus-summary-format 'custom-loads '(gnus gnus-diary gnus-sum))
(put 'gnus-summary-mail 'custom-loads '(gnus-sum))
(put 'gnus-summary-maneuvering 'custom-loads '(gnus-sum))
(put 'gnus-summary-marks 'custom-loads '(gnus gnus-sum))
(put 'gnus-summary-pick 'custom-loads '(gnus-salt))
(put 'gnus-summary-sort 'custom-loads '(gnus-sum))
(put 'gnus-summary-tree 'custom-loads '(gnus-salt))
(put 'gnus-summary-various 'custom-loads '(gnus-sum))
(put 'gnus-summary-visual 'custom-loads '(gnus-sum))
(put 'gnus-thread 'custom-loads '(gnus-group gnus-sum))
(put 'gnus-threading 'custom-loads '(gnus-sum))
(put 'gnus-topic 'custom-loads '(gnus-topic))
(put 'gnus-undo 'custom-loads '(gnus-undo))
(put 'gnus-various 'custom-loads '(gnus gnus-sum gnus-util))
(put 'gnus-visual 'custom-loads '(earcon gnus gnus-art gnus-audio smiley))
(put 'gnus-windows 'custom-loads '(gnus-win))
(put 'gnus-xmas 'custom-loads '(gnus gnus-xmas))
(put 'imap 'custom-loads '(imap))
(put 'languages 'custom-loads '(sieve))
(put 'lisp 'custom-loads '(gmm-utils))
(put 'mail 'custom-loads '(gnus imap message mm-decode pop3 sieve-manage spam spam-report starttls))
(put 'mail-source 'custom-loads '(mail-source nndiary pop3))
(put 'mailcap 'custom-loads '(mailcap))
(put 'message 'custom-loads '(message mml mml-sec))
(put 'message-buffers 'custom-loads '(message))
(put 'message-faces 'custom-loads '(message))
(put 'message-forwarding 'custom-loads '(message))
(put 'message-headers 'custom-loads '(message))
(put 'message-insertion 'custom-loads '(message))
(put 'message-interface 'custom-loads '(message))
(put 'message-mail 'custom-loads '(message))
(put 'message-news 'custom-loads '(message))
(put 'message-sending 'custom-loads '(message))
(put 'message-various 'custom-loads '(message))
(put 'mime 'custom-loads '(mailcap mm-bodies mm-encode mm-util pgg-def rfc1843 smime))
(put 'mime-display 'custom-loads '(flow-fill mm-decode mm-view))
(put 'mime-security 'custom-loads '(gnus-art mm-decode mml2015))
(put 'mm-url 'custom-loads '(mm-url))
(put 'multimedia 'custom-loads '(gnus-audio mm-decode))
(put 'news 'custom-loads '(canlock gnus message mm-decode spam spam-report))
(put 'nndiary 'custom-loads '(nndiary))
(put 'nnimap 'custom-loads '(nnimap))
(put 'nnmail 'custom-loads '(nnmail))
(put 'nnmail-duplicate 'custom-loads '(nnmail))
(put 'nnmail-expire 'custom-loads '(nnmail))
(put 'nnmail-files 'custom-loads '(nnmail))
(put 'nnmail-prepare 'custom-loads '(nnmail))
(put 'nnmail-procmail 'custom-loads '(nnmail))
(put 'nnmail-retrieve 'custom-loads '(nnmail))
(put 'nnmail-split 'custom-loads '(nndiary nnmail))
(put 'nnmail-various 'custom-loads '(nnmail))
(put 'nntp 'custom-loads '(nntp))
(put 'pgg 'custom-loads '(pgg-def pgg-gpg pgg-parse pgg-pgp pgg-pgp5))
(put 'pgg-gpg 'custom-loads '(pgg-gpg))
(put 'pgg-parse 'custom-loads '(pgg-parse))
(put 'pgg-pgp 'custom-loads '(pgg-pgp))
(put 'pgg-pgp5 'custom-loads '(pgg-pgp5))
(put 'pop3 'custom-loads '(pop3))
(put 'sha1 'custom-loads '(sha1))
(put 'sieve 'custom-loads '(sieve sieve-mode))
(put 'sieve-manage 'custom-loads '(sieve-manage))
(put 'smiley 'custom-loads '(smiley))
(put 'smime 'custom-loads '(smime))
(put 'spam 'custom-loads '(spam))
(put 'spam-bogofilter 'custom-loads '(spam))
(put 'spam-ifile 'custom-loads '(spam))
(put 'spam-report 'custom-loads '(spam-report))
(put 'spam-spamoracle 'custom-loads '(spam))
(put 'spam-stat 'custom-loads '(spam-stat))
(put 'starttls 'custom-loads '(starttls))
(put 'tls 'custom-loads '(tls))
(put 'tools 'custom-loads '(sieve))

;; The remainder of this file is for handling :version.
;; We provide a minimum of information so that `customize-changed-options'
;; can do its job.

;; For groups we set `custom-version', `group-documentation' and
;; `custom-tag' (which are shown in the customize buffer), so we
;; don't have to load the file containing the group.

;; This macro is used so we don't modify the information about
;; variables and groups if it's already set. (We don't know when
;; cus-load.el is going to be loaded and at that time some of the
;; files might be loaded and some others might not).
(defmacro custom-put-if-not (symbol propname value)
  `(unless (get ,symbol ,propname)
     (put ,symbol ,propname ,value)))

(custom-put-if-not 'gmm 'custom-version '"22.1")
(custom-put-if-not 'gmm 'group-documentation "Utility functions for Gnus, Message and MML")
(custom-put-if-not 'gnus-audio 'custom-version '"21.1")
(custom-put-if-not 'gnus-audio 'group-documentation "Playing sound in Gnus.")
(custom-put-if-not 'gnus-charset 'custom-version '"21.1")
(custom-put-if-not 'gnus-charset 'group-documentation "Group character set issues.")
(custom-put-if-not 'gnus-delay 'custom-version '"22.1")
(custom-put-if-not 'gnus-delay 'group-documentation "Arrange for sending postings later.")
(custom-put-if-not 'gnus-diary 'custom-version '"22.1")
(custom-put-if-not 'gnus-diary 'group-documentation "Utilities on top of the nndiary back end for Gnus.")
(custom-put-if-not 'gnus-outlook-deuglify 'custom-version '"22.1")
(custom-put-if-not 'gnus-outlook-deuglify 'group-documentation "Deuglify articles generated by broken user agents like MS Outlook (Express).")
(custom-put-if-not 'gnus-registry 'custom-version '"22.1")
(custom-put-if-not 'gnus-registry 'group-documentation "Article Registry.")
(custom-put-if-not 'imap 'custom-version '"21.1")
(custom-put-if-not 'imap 'group-documentation "Low-level IMAP issues.")
(custom-put-if-not 'mail-source 'custom-version '"21.1")
(custom-put-if-not 'mail-source 'group-documentation "The mail-fetching library.")
(custom-put-if-not 'mailcap 'custom-version '"21.1")
(custom-put-if-not 'mailcap 'group-documentation "Definition of viewers for MIME types.")
(custom-put-if-not 'mime-display 'custom-version '"21.1")
(custom-put-if-not 'mime-display 'group-documentation "Display of MIME in mail and news articles.")
(custom-put-if-not 'nndiary 'custom-version '"22.1")
(custom-put-if-not 'nndiary 'group-documentation "The Gnus Diary back end.")
(custom-put-if-not 'pgg 'custom-version '"22.1")
(custom-put-if-not 'pgg 'group-documentation "Glue for the various PGP implementations.")
(custom-put-if-not 'sha1 'custom-version '"22.1")
(custom-put-if-not 'sha1 'group-documentation "Elisp interface for SHA1 hash computation.")
(custom-put-if-not 'sieve 'custom-version '"22.1")
(custom-put-if-not 'sieve 'group-documentation "Manage sieve scripts.")
(custom-put-if-not 'spam 'custom-version '"22.1")
(custom-put-if-not 'spam 'group-documentation "Spam configuration.")
(custom-put-if-not 'spam-stat 'custom-version '"22.1")
(custom-put-if-not 'spam-stat 'group-documentation "Statistical spam detection for Emacs.
Use the functions to build a dictionary of words and their statistical
distribution in spam and non-spam mails.  Then use a function to determine
whether a buffer contains spam or not.")
(custom-put-if-not 'starttls 'custom-version '"21.1")
(custom-put-if-not 'starttls 'group-documentation "Support for `Transport Layer Security' protocol.")


;;;### (autoloads nil "binhex" "binhex.el" (0 0 0 0))
;;; Generated autoloads from binhex.el

(defconst binhex-begin-line "^:...............................................................$")

(autoload 'binhex-decode-region-internal "binhex" "\
Binhex decode region between START and END without using an external program.
If HEADER-ONLY is non-nil only decode header and return filename.

\(fn START END &optional HEADER-ONLY)" t nil)

(autoload 'binhex-decode-region-external "binhex" "\
Binhex decode region between START and END using external decoder.

\(fn START END)" t nil)

(autoload 'binhex-decode-region "binhex" "\
Binhex decode region between START and END.

\(fn START END)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "binhex" '("binhex-")))

;;;***

;;;### (autoloads nil "canlock" "canlock.el" (0 0 0 0))
;;; Generated autoloads from canlock.el

(autoload 'canlock-insert-header "canlock" "\
Insert a Cancel-Key and/or a Cancel-Lock header if possible.

\(fn &optional ID-FOR-KEY ID-FOR-LOCK PASSWORD)" nil nil)

(autoload 'canlock-verify "canlock" "\
Verify Cancel-Lock or Cancel-Key in BUFFER.
If BUFFER is nil, the current buffer is assumed.  Signal an error if
it fails.

\(fn &optional BUFFER)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "canlock" '("canlock-")))

;;;***

;;;### (autoloads nil "compface" "compface.el" (0 0 0 0))
;;; Generated autoloads from compface.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "compface" '("uncompface")))

;;;***

;;;### (autoloads nil "deuglify" "deuglify.el" (0 0 0 0))
;;; Generated autoloads from deuglify.el

(autoload 'gnus-article-outlook-unwrap-lines "deuglify" "\
Unwrap lines that appear to be wrapped citation lines.
You can control what lines will be unwrapped by frobbing
`gnus-outlook-deuglify-unwrap-min' and `gnus-outlook-deuglify-unwrap-max',
indicating the minimum and maximum length of an unwrapped citation line.  If
NODISPLAY is non-nil, don't redisplay the article buffer.

\(fn &optional NODISPLAY)" t nil)

(autoload 'gnus-article-outlook-repair-attribution "deuglify" "\
Repair a broken attribution line.
If NODISPLAY is non-nil, don't redisplay the article buffer.

\(fn &optional NODISPLAY)" t nil)

(autoload 'gnus-outlook-deuglify-article "deuglify" "\
Full deuglify of broken Outlook (Express) articles.
Treat dumbquotes, unwrap lines, repair attribution and rearrange citation.  If
NODISPLAY is non-nil, don't redisplay the article buffer.

\(fn &optional NODISPLAY)" t nil)

(autoload 'gnus-article-outlook-deuglify-article "deuglify" "\
Deuglify broken Outlook (Express) articles and redisplay.

\(fn)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "deuglify" '("gnus-")))

;;;***

;;;### (autoloads nil "dgnushack" "dgnushack.el" (0 0 0 0))
;;; Generated autoloads from dgnushack.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "dgnushack" '("dgnushack-" "ange-ftp-re-read-dir" "efs-re-read-dir" "nndb-request-article" "play-sound-file" "byte-compile-dest-file" "my-getenv" "srcdir" "facep")))

;;;***

;;;### (autoloads nil "dig" "dig.el" (0 0 0 0))
;;; Generated autoloads from dig.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "dig" '("query-dig" "dig")))

;;;***

;;;### (autoloads nil "dns" "dns.el" (0 0 0 0))
;;; Generated autoloads from dns.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "dns" '("query-dns" "dns-")))

;;;***

;;;### (autoloads nil "earcon" "earcon.el" (0 0 0 0))
;;; Generated autoloads from earcon.el

(autoload 'gnus-earcon-display "earcon" "\
Play sounds in message buffers.

\(fn)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "earcon" '("earcon-")))

;;;***

;;;### (autoloads nil "flow-fill" "flow-fill.el" (0 0 0 0))
;;; Generated autoloads from flow-fill.el

(autoload 'fill-flowed-encode "flow-fill" "\


\(fn &optional BUFFER)" nil nil)

(autoload 'fill-flowed "flow-fill" "\


\(fn &optional BUFFER)" nil nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "flow-fill" '("fill-flowed-")))

;;;***

;;;### (autoloads nil "format-spec" "format-spec.el" (0 0 0 0))
;;; Generated autoloads from format-spec.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "format-spec" '("format-spec")))

;;;***

;;;### (autoloads nil "gmm-utils" "gmm-utils.el" (0 0 0 0))
;;; Generated autoloads from gmm-utils.el

(autoload 'gmm-message "gmm-utils" "\
If LEVEL is lower than `gmm-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.

\(fn LEVEL &rest ARGS)" nil nil)

(autoload 'gmm-error "gmm-utils" "\
Beep an error if LEVEL is equal to or less than `gmm-verbose'.
ARGS are passed to `message'.

\(fn LEVEL &rest ARGS)" nil nil)

(autoload 'gmm-widget-p "gmm-utils" "\
Non-nil if SYMBOL is a widget.

\(fn SYMBOL)" nil nil)

(autoload 'gmm-tool-bar-from-list "gmm-utils" "\
Make a tool bar from ICON-LIST.

Within each entry of ICON-LIST, the first element is a menu
command, the second element is an icon file name and the third
element is a test function.  You can use \\[describe-key]
<menu-entry> to find out the name of a menu command.  The fourth
and all following elements are passed as the PROPS argument to the
function `tool-bar-local-item'.

If ZAP-LIST is a list, remove those item from the default
`tool-bar-map'.  If it is t, start with a new sparse map.  You
can use \\[describe-key] <icon> to find out the name of an icon
item.  When \\[describe-key] <icon> shows \"<tool-bar> <new-file>
runs the command find-file\", then use `new-file' in ZAP-LIST.

DEFAULT-MAP specifies the default key map for ICON-LIST.

\(fn ICON-LIST ZAP-LIST DEFAULT-MAP)" nil nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gmm-utils" '("gmm-" "defun-gmm")))

;;;***

;;;### (autoloads nil "gnus" "gnus.el" (0 0 0 0))
;;; Generated autoloads from gnus.el
(when (fboundp 'custom-autoload)
 (custom-autoload 'gnus-select-method "gnus"))

(autoload 'gnus-slave-no-server "gnus" "\
Read network news as a slave, without connecting to the local server.

\(fn &optional ARG)" t nil)

(autoload 'gnus-no-server "gnus" "\
Read network news.
If ARG is a positive number, Gnus will use that as the startup
level. If ARG is nil, Gnus will be started at level 2.  If ARG is
non-nil and not a positive number, Gnus will prompt the user for the
name of an NNTP server to use.
As opposed to `gnus', this command will not connect to the local
server.

\(fn &optional ARG SLAVE)" t nil)

(autoload 'gnus-slave "gnus" "\
Read news as a slave.

\(fn &optional ARG)" t nil)

(autoload 'gnus-other-frame "gnus" "\
Pop up a frame to read news.
This will call one of the Gnus commands which is specified by the user
option `gnus-other-frame-function' (default `gnus') with the argument
ARG if Gnus is not running, otherwise just pop up a Gnus frame.  The
optional second argument DISPLAY should be a standard display string
such as \"unix:0\" to specify where to pop up a frame.  If DISPLAY is
omitted or the function `make-frame-on-display' is not available, the
current display is used.

\(fn &optional ARG DISPLAY)" t nil)

(autoload 'gnus "gnus" "\
Read network news.
If ARG is non-nil and a positive number, Gnus will use that as the
startup level.  If ARG is non-nil and not a positive number, Gnus will
prompt the user for the name of an NNTP server to use.

\(fn &optional ARG DONT-CONNECT SLAVE)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-agent" "gnus-agent.el" (0 0 0 0))
;;; Generated autoloads from gnus-agent.el

(autoload 'gnus-unplugged "gnus-agent" "\
Start Gnus unplugged.

\(fn)" t nil)

(autoload 'gnus-plugged "gnus-agent" "\
Start Gnus plugged.

\(fn)" t nil)

(autoload 'gnus-slave-unplugged "gnus-agent" "\
Read news as a slave unplugged.

\(fn &optional ARG)" t nil)

(autoload 'gnus-agentize "gnus-agent" "\
Allow Gnus to be an offline newsreader.

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

This will modify the `gnus-setup-news-hook', and
`message-send-mail-real-function' variables, and install the Gnus agent
minor mode in all Gnus buffers.

\(fn)" t nil)

(autoload 'gnus-agent-possibly-save-gcc "gnus-agent" "\
Save GCC if Gnus is unplugged.

\(fn)" nil nil)

(autoload 'gnus-agent-rename-group "gnus-agent" "\
Rename fully-qualified OLD-GROUP as NEW-GROUP.
Always updates the agent, even when disabled, as the old agent
files would corrupt gnus when the agent was next enabled.
Depends upon the caller to determine whether group renaming is
supported.

\(fn OLD-GROUP NEW-GROUP)" nil nil)

(autoload 'gnus-agent-delete-group "gnus-agent" "\
Delete fully-qualified GROUP.
Always updates the agent, even when disabled, as the old agent
files would corrupt gnus when the agent was next enabled.
Depends upon the caller to determine whether group deletion is
supported.

\(fn GROUP)" nil nil)

(autoload 'gnus-agent-get-undownloaded-list "gnus-agent" "\
Construct list of articles that have not been downloaded.

\(fn)" nil nil)

(autoload 'gnus-agent-possibly-alter-active "gnus-agent" "\
Possibly expand a group's active range to include articles
downloaded into the agent.

\(fn GROUP ACTIVE &optional INFO)" nil nil)

(autoload 'gnus-agent-find-parameter "gnus-agent" "\
Search for GROUPs SYMBOL in the group's parameters, the group's
topic parameters, the group's category, or the customizable
variables.  Returns the first non-nil value found.

\(fn GROUP SYMBOL)" nil nil)

(autoload 'gnus-agent-batch-fetch "gnus-agent" "\
Start Gnus and fetch session.

\(fn)" t nil)

(autoload 'gnus-agent-batch "gnus-agent" "\
Start Gnus, send queue and fetch session.

\(fn)" t nil)

(autoload 'gnus-agent-regenerate "gnus-agent" "\
Regenerate all agent covered files.
If CLEAN, obsolete (ignore).

\(fn &optional CLEAN REREAD)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-agent" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-art" "gnus-art.el" (0 0 0 0))
;;; Generated autoloads from gnus-art.el

(autoload 'gnus-article-prepare-display "gnus-art" "\
Make the current buffer look like a nice article.

\(fn)" nil nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-art" '("gnus-" "article-")))

;;;***

;;;### (autoloads nil "gnus-async" "gnus-async.el" (0 0 0 0))
;;; Generated autoloads from gnus-async.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-async" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-audio" "gnus-audio.el" (0 0 0 0))
;;; Generated autoloads from gnus-audio.el

(autoload 'gnus-audio-play "gnus-audio" "\
Play a sound FILE through the speaker.

\(fn FILE)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-audio" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-bcklg" "gnus-bcklg.el" (0 0 0 0))
;;; Generated autoloads from gnus-bcklg.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-bcklg" '("gnus-backlog-")))

;;;***

;;;### (autoloads nil "gnus-cache" "gnus-cache.el" (0 0 0 0))
;;; Generated autoloads from gnus-cache.el

(autoload 'gnus-jog-cache "gnus-cache" "\
Go through all groups and put the articles into the cache.

Usage:
$ emacs -batch -l ~/.emacs -l gnus -f gnus-jog-cache

\(fn)" t nil)

(autoload 'gnus-cache-generate-active "gnus-cache" "\
Generate the cache active file.

\(fn &optional DIRECTORY)" t nil)

(autoload 'gnus-cache-generate-nov-databases "gnus-cache" "\
Generate NOV files recursively starting in DIR.

\(fn DIR)" t nil)

(autoload 'gnus-cache-rename-group "gnus-cache" "\
Rename OLD-GROUP as NEW-GROUP.
Always updates the cache, even when disabled, as the old cache
files would corrupt Gnus when the cache was next enabled.  It
depends on the caller to determine whether group renaming is
supported.

\(fn OLD-GROUP NEW-GROUP)" nil nil)

(autoload 'gnus-cache-delete-group "gnus-cache" "\
Delete GROUP from the cache.
Always updates the cache, even when disabled, as the old cache
files would corrupt gnus when the cache was next enabled.
Depends upon the caller to determine whether group deletion is
supported.

\(fn GROUP)" nil nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-cache" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-cite" "gnus-cite.el" (0 0 0 0))
;;; Generated autoloads from gnus-cite.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-cite" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-cus" "gnus-cus.el" (0 0 0 0))
;;; Generated autoloads from gnus-cus.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-cus" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-delay" "gnus-delay.el" (0 0 0 0))
;;; Generated autoloads from gnus-delay.el

(autoload 'gnus-delay-article "gnus-delay" "\
Delay this article by some time.
DELAY is a string, giving the length of the time.  Possible values are:

* <digits><units> for <units> in minutes (`m'), hours (`h'), days (`d'),
  weeks (`w'), months (`M'), or years (`Y');

* YYYY-MM-DD for a specific date.  The time of day is given by the
  variable `gnus-delay-default-hour', minute and second are zero.

* hh:mm for a specific time.  Use 24h format.  If it is later than this
  time, then the deadline is tomorrow, else today.

\(fn DELAY)" t nil)

(autoload 'gnus-delay-send-queue "gnus-delay" "\
Send all the delayed messages that are due now.

\(fn)" t nil)

(autoload 'gnus-delay-initialize "gnus-delay" "\
Initialize the gnus-delay package.
This sets up a key binding in `message-mode' to delay a message.
This tells Gnus to look for delayed messages after getting new news.

The optional arg NO-KEYMAP is ignored.
Checking delayed messages is skipped if optional arg NO-CHECK is non-nil.

\(fn &optional NO-KEYMAP NO-CHECK)" nil nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-delay" '("gnus-delay-")))

;;;***

;;;### (autoloads nil "gnus-demon" "gnus-demon.el" (0 0 0 0))
;;; Generated autoloads from gnus-demon.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-demon" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-diary" "gnus-diary.el" (0 0 0 0))
;;; Generated autoloads from gnus-diary.el

(autoload 'gnus-user-format-function-d "gnus-diary" "\


\(fn HEADER)" nil nil)

(autoload 'gnus-user-format-function-D "gnus-diary" "\


\(fn HEADER)" nil nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-diary" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-dired" "gnus-dired.el" (0 0 0 0))
;;; Generated autoloads from gnus-dired.el

(autoload 'turn-on-gnus-dired-mode "gnus-dired" "\
Convenience method to turn on gnus-dired-mode.

\(fn)" nil nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-dired" '("gnus-dired-")))

;;;***

;;;### (autoloads nil "gnus-draft" "gnus-draft.el" (0 0 0 0))
;;; Generated autoloads from gnus-draft.el

(autoload 'gnus-draft-reminder "gnus-draft" "\
Reminder user if there are unsent drafts.

\(fn)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-draft" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-dup" "gnus-dup.el" (0 0 0 0))
;;; Generated autoloads from gnus-dup.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-dup" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-eform" "gnus-eform.el" (0 0 0 0))
;;; Generated autoloads from gnus-eform.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-eform" '("gnus-edit-form")))

;;;***

;;;### (autoloads nil "gnus-ems" "gnus-ems.el" (0 0 0 0))
;;; Generated autoloads from gnus-ems.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-ems" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-fun" "gnus-fun.el" (0 0 0 0))
;;; Generated autoloads from gnus-fun.el

(autoload 'gnus-random-x-face "gnus-fun" "\
Return X-Face header data chosen randomly from `gnus-x-face-directory'.

\(fn)" t nil)

(autoload 'gnus-insert-random-x-face-header "gnus-fun" "\
Insert a random X-Face header from `gnus-x-face-directory'.

\(fn)" t nil)

(autoload 'gnus-x-face-from-file "gnus-fun" "\
Insert an X-Face header based on an image file.

\(fn FILE)" t nil)

(autoload 'gnus-face-from-file "gnus-fun" "\
Return a Face header based on an image file.

\(fn FILE)" t nil)

(autoload 'gnus-convert-face-to-png "gnus-fun" "\
Convert FACE (which is base64-encoded) to a PNG.
The PNG is returned as a string.

\(fn FACE)" nil nil)

(autoload 'gnus-convert-png-to-face "gnus-fun" "\
Convert FILE to a Face.
FILE should be a PNG file that's 48x48 and smaller than or equal to
726 bytes.

\(fn FILE)" nil nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-fun" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-gl" "gnus-gl.el" (0 0 0 0))
;;; Generated autoloads from gnus-gl.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-gl" '("gnus-" "bbb-")))

;;;***

;;;### (autoloads nil "gnus-group" "gnus-group.el" (0 0 0 0))
;;; Generated autoloads from gnus-group.el

(autoload 'gnus-fetch-group "gnus-group" "\
Start Gnus if necessary and enter GROUP.
Returns whether the fetching was successful or not.

\(fn GROUP &optional ARTICLES)" t nil)

(autoload 'gnus-fetch-group-other-frame "gnus-group" "\
Pop up a frame and enter GROUP.

\(fn GROUP)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-group" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-int" "gnus-int.el" (0 0 0 0))
;;; Generated autoloads from gnus-int.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-int" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-kill" "gnus-kill.el" (0 0 0 0))
;;; Generated autoloads from gnus-kill.el

(defalias 'gnus-batch-kill 'gnus-batch-score)

(autoload 'gnus-batch-score "gnus-kill" "\
Run batched scoring.
Usage: emacs -batch -l ~/.emacs -l gnus -f gnus-batch-score

\(fn)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-kill" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-logic" "gnus-logic.el" (0 0 0 0))
;;; Generated autoloads from gnus-logic.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-logic" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-mh" "gnus-mh.el" (0 0 0 0))
;;; Generated autoloads from gnus-mh.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-mh" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-ml" "gnus-ml.el" (0 0 0 0))
;;; Generated autoloads from gnus-ml.el

(autoload 'turn-on-gnus-mailing-list-mode "gnus-ml" "\


\(fn)" nil nil)

(autoload 'gnus-mailing-list-insinuate "gnus-ml" "\
Setup group parameters from List-Post header.
If FORCE is non-nil, replace the old ones.

\(fn &optional FORCE)" t nil)

(autoload 'gnus-mailing-list-mode "gnus-ml" "\
Minor mode for providing mailing-list commands.

\\{gnus-mailing-list-mode-map}

\(fn &optional ARG)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-ml" '("gnus-mailing-list-")))

;;;***

;;;### (autoloads nil "gnus-mlspl" "gnus-mlspl.el" (0 0 0 0))
;;; Generated autoloads from gnus-mlspl.el

(autoload 'gnus-group-split-setup "gnus-mlspl" "\
Set up the split for nnmail-split-fancy.
Sets things up so that nnmail-split-fancy is used for mail
splitting, and defines the variable nnmail-split-fancy according with
group parameters.

If AUTO-UPDATE is non-nil (prefix argument accepted, if called
interactively), it makes sure nnmail-split-fancy is re-computed before
getting new mail, by adding gnus-group-split-update to
nnmail-pre-get-new-mail-hook.

A non-nil CATCH-ALL replaces the current value of
gnus-group-split-default-catch-all-group.  This variable is only used
by gnus-group-split-update, and only when its CATCH-ALL argument is
nil.  This argument may contain any fancy split, that will be added as
the last split in a `|' split produced by gnus-group-split-fancy,
unless overridden by any group marked as a catch-all group.  Typical
uses are as simple as the name of a default mail group, but more
elaborate fancy splits may also be useful to split mail that doesn't
match any of the group-specified splitting rules.  See
`gnus-group-split-fancy' for details.

\(fn &optional AUTO-UPDATE CATCH-ALL)" t nil)

(autoload 'gnus-group-split-update "gnus-mlspl" "\
Computes nnmail-split-fancy from group params and CATCH-ALL.
It does this by calling by calling (gnus-group-split-fancy nil
nil CATCH-ALL).

If CATCH-ALL is nil, gnus-group-split-default-catch-all-group is used
instead.  This variable is set by gnus-group-split-setup.

\(fn &optional CATCH-ALL)" t nil)

(autoload 'gnus-group-split "gnus-mlspl" "\
Uses information from group parameters in order to split mail.
See `gnus-group-split-fancy' for more information.

gnus-group-split is a valid value for nnmail-split-methods.

\(fn)" nil nil)

(autoload 'gnus-group-split-fancy "gnus-mlspl" "\
Uses information from group parameters in order to split mail.
It can be embedded into `nnmail-split-fancy' lists with the SPLIT

\(: gnus-group-split-fancy GROUPS NO-CROSSPOST CATCH-ALL)

GROUPS may be a regular expression or a list of group names, that will
be used to select candidate groups.  If it is omitted or nil, all
existing groups are considered.

if NO-CROSSPOST is omitted or nil, a & split will be returned,
otherwise, a | split, that does not allow crossposting, will be
returned.

For each selected group, a SPLIT is composed like this: if SPLIT-SPEC
is specified, this split is returned as-is (unless it is nil: in this
case, the group is ignored).  Otherwise, if TO-ADDRESS, TO-LIST and/or
EXTRA-ALIASES are specified, a regexp that matches any of them is
constructed (extra-aliases may be a list).  Additionally, if
SPLIT-REGEXP is specified, the regexp will be extended so that it
matches this regexp too, and if SPLIT-EXCLUDE is specified, RESTRICT
clauses will be generated.

If CATCH-ALL is nil, no catch-all handling is performed, regardless of
catch-all marks in group parameters.  Otherwise, if there is no
selected group whose SPLIT-REGEXP matches the empty string, nor is
there a selected group whose SPLIT-SPEC is 'catch-all, this fancy
split (say, a group name) will be appended to the returned SPLIT list,
as the last element of a '| SPLIT.

For example, given the following group parameters:

nnml:mail.bar:
\((to-address . \"bar@femail.com\")
 (split-regexp . \".*@femail\\\\.com\"))
nnml:mail.foo:
\((to-list . \"foo@nowhere.gov\")
 (extra-aliases \"foo@localhost\" \"foo-redist@home\")
 (split-exclude \"bugs-foo\" \"rambling-foo\")
 (admin-address . \"foo-request@nowhere.gov\"))
nnml:mail.others:
\((split-spec . catch-all))

Calling (gnus-group-split-fancy nil nil \"mail.others\") returns:

\(| (& (any \"\\\\(bar@femail\\\\.com\\\\|.*@femail\\\\.com\\\\)\"
	   \"mail.bar\")
      (any \"\\\\(foo@nowhere\\\\.gov\\\\|foo@localhost\\\\|foo-redist@home\\\\)\"
	   - \"bugs-foo\" - \"rambling-foo\" \"mail.foo\"))
   \"mail.others\")

\(fn &optional GROUPS NO-CROSSPOST CATCH-ALL)" nil nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-mlspl" '("gnus-group-split-")))

;;;***

;;;### (autoloads nil "gnus-move" "gnus-move.el" (0 0 0 0))
;;; Generated autoloads from gnus-move.el

(autoload 'gnus-change-server "gnus-move" "\
Move from FROM-SERVER to TO-SERVER.
Update the .newsrc.eld file to reflect the change of nntp server.

\(fn FROM-SERVER TO-SERVER)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-move" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-msg" "gnus-msg.el" (0 0 0 0))
;;; Generated autoloads from gnus-msg.el

(autoload 'gnus-msg-mail "gnus-msg" "\
Start editing a mail message to be sent.
Like `message-mail', but with Gnus paraphernalia, particularly the
Gcc: header for archiving purposes.

\(fn &optional TO SUBJECT OTHER-HEADERS CONTINUE SWITCH-ACTION YANK-ACTION SEND-ACTIONS)" t nil)

(autoload 'gnus-button-mailto "gnus-msg" "\
Mail to ADDRESS.

\(fn ADDRESS)" nil nil)

(autoload 'gnus-button-reply "gnus-msg" "\
Like `message-reply'.

\(fn &optional TO-ADDRESS WIDE)" t nil)

(define-mail-user-agent 'gnus-user-agent 'gnus-msg-mail 'message-send-and-exit 'message-kill-buffer 'message-send-hook)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-msg" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-nocem" "gnus-nocem.el" (0 0 0 0))
;;; Generated autoloads from gnus-nocem.el

(autoload 'gnus-nocem-scan-groups "gnus-nocem" "\
Scan all NoCeM groups for new NoCeM messages.

\(fn)" t nil)

(autoload 'gnus-nocem-load-cache "gnus-nocem" "\
Load the NoCeM cache.

\(fn)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-nocem" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-picon" "gnus-picon.el" (0 0 0 0))
;;; Generated autoloads from gnus-picon.el

(autoload 'gnus-treat-from-picon "gnus-picon" "\
Display picons in the From header.
If picons are already displayed, remove them.

\(fn)" t nil)

(autoload 'gnus-treat-mail-picon "gnus-picon" "\
Display picons in the Cc and To headers.
If picons are already displayed, remove them.

\(fn)" t nil)

(autoload 'gnus-treat-newsgroups-picon "gnus-picon" "\
Display picons in the Newsgroups and Followup-To headers.
If picons are already displayed, remove them.

\(fn)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-picon" '("gnus-picon-")))

;;;***

;;;### (autoloads nil "gnus-range" "gnus-range.el" (0 0 0 0))
;;; Generated autoloads from gnus-range.el

(autoload 'gnus-sorted-difference "gnus-range" "\
Return a list of elements of LIST1 that do not appear in LIST2.
Both lists have to be sorted over <.
The tail of LIST1 is not copied.

\(fn LIST1 LIST2)" nil nil)

(autoload 'gnus-sorted-ndifference "gnus-range" "\
Return a list of elements of LIST1 that do not appear in LIST2.
Both lists have to be sorted over <.
LIST1 is modified.

\(fn LIST1 LIST2)" nil nil)

(autoload 'gnus-sorted-complement "gnus-range" "\
Return a list of elements that are in LIST1 or LIST2 but not both.
Both lists have to be sorted over <.

\(fn LIST1 LIST2)" nil nil)

(autoload 'gnus-intersection "gnus-range" "\


\(fn LIST1 LIST2)" nil nil)

(autoload 'gnus-sorted-intersection "gnus-range" "\
Return intersection of LIST1 and LIST2.
LIST1 and LIST2 have to be sorted over <.

\(fn LIST1 LIST2)" nil nil)

(autoload 'gnus-sorted-range-intersection "gnus-range" "\
Return intersection of RANGE1 and RANGE2.
RANGE1 and RANGE2 have to be sorted over <.

\(fn RANGE1 RANGE2)" nil nil)

(defalias 'gnus-set-sorted-intersection 'gnus-sorted-nintersection)

(autoload 'gnus-sorted-nintersection "gnus-range" "\
Return intersection of LIST1 and LIST2 by modifying cdr pointers of LIST1.
LIST1 and LIST2 have to be sorted over <.

\(fn LIST1 LIST2)" nil nil)

(autoload 'gnus-sorted-union "gnus-range" "\
Return union of LIST1 and LIST2.
LIST1 and LIST2 have to be sorted over <.

\(fn LIST1 LIST2)" nil nil)

(autoload 'gnus-sorted-nunion "gnus-range" "\
Return union of LIST1 and LIST2 by modifying cdr pointers of LIST1.
LIST1 and LIST2 have to be sorted over <.

\(fn LIST1 LIST2)" nil nil)

(autoload 'gnus-add-to-sorted-list "gnus-range" "\
Add NUM into sorted LIST by side effect.

\(fn LIST NUM)" nil nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-range" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-registry" "gnus-registry.el" (0 0 0 0))
;;; Generated autoloads from gnus-registry.el

(autoload 'gnus-registry-initialize "gnus-registry" "\


\(fn)" t nil)

(autoload 'gnus-registry-install-hooks "gnus-registry" "\
Install the registry hooks.

\(fn)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-registry" '("gnus-registry-")))

;;;***

;;;### (autoloads nil "gnus-salt" "gnus-salt.el" (0 0 0 0))
;;; Generated autoloads from gnus-salt.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-salt" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-score" "gnus-score.el" (0 0 0 0))
;;; Generated autoloads from gnus-score.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-score" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-setup" "gnus-setup.el" (0 0 0 0))
;;; Generated autoloads from gnus-setup.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-setup" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-sieve" "gnus-sieve.el" (0 0 0 0))
;;; Generated autoloads from gnus-sieve.el

(autoload 'gnus-sieve-update "gnus-sieve" "\
Update the Sieve script in gnus-sieve-file, by replacing the region
between gnus-sieve-region-start and gnus-sieve-region-end with
\(gnus-sieve-script gnus-sieve-select-method gnus-sieve-crosspost), then
execute gnus-sieve-update-shell-command.
See the documentation for these variables and functions for details.

\(fn)" t nil)

(autoload 'gnus-sieve-generate "gnus-sieve" "\
Generate the Sieve script in gnus-sieve-file, by replacing the region
between gnus-sieve-region-start and gnus-sieve-region-end with
\(gnus-sieve-script gnus-sieve-select-method gnus-sieve-crosspost).
See the documentation for these variables and functions for details.

\(fn)" t nil)

(autoload 'gnus-sieve-article-add-rule "gnus-sieve" "\


\(fn)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-sieve" '("gnus-sieve-")))

;;;***

;;;### (autoloads nil "gnus-soup" "gnus-soup.el" (0 0 0 0))
;;; Generated autoloads from gnus-soup.el

(autoload 'gnus-batch-brew-soup "gnus-soup" "\
Brew a SOUP packet from groups mention on the command line.
Will use the remaining command line arguments as regular expressions
for matching on group names.

For instance, if you want to brew on all the nnml groups, as well as
groups with \"emacs\" in the name, you could say something like:

$ emacs -batch -f gnus-batch-brew-soup ^nnml \".*emacs.*\"

Note -- this function hasn't been implemented yet.

\(fn)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-soup" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-spec" "gnus-spec.el" (0 0 0 0))
;;; Generated autoloads from gnus-spec.el

(autoload 'gnus-update-format "gnus-spec" "\
Update the format specification near point.

\(fn VAR)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-spec" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-srvr" "gnus-srvr.el" (0 0 0 0))
;;; Generated autoloads from gnus-srvr.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-srvr" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-start" "gnus-start.el" (0 0 0 0))
;;; Generated autoloads from gnus-start.el

(autoload 'gnus-declare-backend "gnus-start" "\
Declare back end NAME with ABILITIES as a Gnus back end.

\(fn NAME &rest ABILITIES)" nil nil)

(autoload 'gnus-fixup-nnimap-unread-after-getting-new-news "gnus-start" "\


\(fn)" nil nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-start" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-sum" "gnus-sum.el" (0 0 0 0))
;;; Generated autoloads from gnus-sum.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-sum" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-topic" "gnus-topic.el" (0 0 0 0))
;;; Generated autoloads from gnus-topic.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-topic" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-undo" "gnus-undo.el" (0 0 0 0))
;;; Generated autoloads from gnus-undo.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-undo" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-util" "gnus-util.el" (0 0 0 0))
;;; Generated autoloads from gnus-util.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-util" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-uu" "gnus-uu.el" (0 0 0 0))
;;; Generated autoloads from gnus-uu.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-uu" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-vm" "gnus-vm.el" (0 0 0 0))
;;; Generated autoloads from gnus-vm.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-vm" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-win" "gnus-win.el" (0 0 0 0))
;;; Generated autoloads from gnus-win.el

(autoload 'gnus-add-configuration "gnus-win" "\
Add the window configuration CONF to `gnus-buffer-configuration'.

\(fn CONF)" nil nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-win" '("gnus-")))

;;;***

;;;### (autoloads nil "gnus-xmas" "gnus-xmas.el" (0 0 0 0))
;;; Generated autoloads from gnus-xmas.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "gnus-xmas" '("gnus-" "menu-bar-mode")))

;;;***

;;;### (autoloads nil "hex-util" "hex-util.el" (0 0 0 0))
;;; Generated autoloads from hex-util.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "hex-util" '("encode-hex-string" "decode-hex-string")))

;;;***

;;;### (autoloads nil "html2text" "html2text.el" (0 0 0 0))
;;; Generated autoloads from html2text.el

(autoload 'html2text "html2text" "\
Convert HTML to plain text in the current buffer.

\(fn)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "html2text" '("html2text-")))

;;;***

;;;### (autoloads nil "ietf-drums" "ietf-drums.el" (0 0 0 0))
;;; Generated autoloads from ietf-drums.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "ietf-drums" '("ietf-drums-")))

;;;***

;;;### (autoloads nil "imap" "imap.el" (0 0 0 0))
;;; Generated autoloads from imap.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "imap" '("imap-")))

;;;***

;;;### (autoloads nil "legacy-gnus-agent" "legacy-gnus-agent.el"
;;;;;;  (0 0 0 0))
;;; Generated autoloads from legacy-gnus-agent.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "legacy-gnus-agent" '("gnus-agent-")))

;;;***

;;;### (autoloads nil "lpath" "lpath.el" (0 0 0 0))
;;; Generated autoloads from lpath.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "lpath" '("maybe-")))

;;;***

;;;### (autoloads nil "mail-parse" "mail-parse.el" (0 0 0 0))
;;; Generated autoloads from mail-parse.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "mail-parse" '("mail-")))

;;;***

;;;### (autoloads nil "mail-prsvr" "mail-prsvr.el" (0 0 0 0))
;;; Generated autoloads from mail-prsvr.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "mail-prsvr" '("mail-parse-")))

;;;***

;;;### (autoloads nil "mail-source" "mail-source.el" (0 0 0 0))
;;; Generated autoloads from mail-source.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "mail-source" '("mail-source")))

;;;***

;;;### (autoloads nil "mailcap" "mailcap.el" (0 0 0 0))
;;; Generated autoloads from mailcap.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "mailcap" '("mailcap-")))

;;;***

;;;### (autoloads nil "message" "message.el" (0 0 0 0))
;;; Generated autoloads from message.el

(defvar message-from-style 'default "\
*Specifies how \"From\" headers look.

If nil, they contain just the return address like:
	king@grassland.com
If `parens', they look like:
	king@grassland.com (Elvis Parsley)
If `angles', they look like:
	Elvis Parsley <king@grassland.com>

Otherwise, most addresses look like `angles', but they look like
`parens' if `angles' would need quoting and `parens' would not.")

(custom-autoload 'message-from-style "message" t)

(defvar message-signature-separator "^-- *$" "\
Regexp matching the signature separator.")

(custom-autoload 'message-signature-separator "message" t)

(defvar message-user-organization-file "/usr/lib/news/organization" "\
*Local news organization file.")

(custom-autoload 'message-user-organization-file "message" t)

(defvar message-send-mail-function 'message-send-mail-with-sendmail "\
Function to call to send the current buffer as mail.
The headers should be delimited by a line whose contents match the
variable `mail-header-separator'.

Valid values include `message-send-mail-with-sendmail' (the default),
`message-send-mail-with-mh', `message-send-mail-with-qmail',
`message-smtpmail-send-it', `smtpmail-send-it' and `feedmail-send-it'.

See also `send-mail-function'.")

(custom-autoload 'message-send-mail-function "message" t)

(defvar message-citation-line-function 'message-insert-citation-line "\
*Function called to insert the \"Whomever writes:\" line.

Note that Gnus provides a feature where the reader can click on
`writes:' to hide the cited text.  If you change this line too much,
people who read your message will have to change their Gnus
configuration.  See the variable `gnus-cite-attribution-suffix'.")

(custom-autoload 'message-citation-line-function "message" t)

(defvar message-yank-prefix "> " "\
*Prefix inserted on the lines of yanked messages.
Fix `message-cite-prefix-regexp' if it is set to an abnormal value.
See also `message-yank-cited-prefix'.")

(custom-autoload 'message-yank-prefix "message" t)

(defvar message-cite-function 'message-cite-original "\
*Function for citing an original message.
Predefined functions include `message-cite-original' and
`message-cite-original-without-signature'.
Note that `message-cite-original' uses `mail-citation-hook' if that is non-nil.")

(custom-autoload 'message-cite-function "message" t)

(defvar message-indent-citation-function 'message-indent-citation "\
*Function for modifying a citation just inserted in the mail buffer.
This can also be a list of functions.  Each function can find the
citation between (point) and (mark t).  And each function should leave
point and mark around the citation text as modified.")

(custom-autoload 'message-indent-citation-function "message" t)

(defvar message-signature t "\
*String to be inserted at the end of the message buffer.
If t, the `message-signature-file' file will be inserted instead.
If a function, the result from the function will be used instead.
If a form, the result from the form will be used instead.")

(custom-autoload 'message-signature "message" t)

(defvar message-signature-file "~/.signature" "\
*Name of file containing the text inserted at end of message buffer.
Ignored if the named file doesn't exist.
If nil, don't insert a signature.")

(custom-autoload 'message-signature-file "message" t)

(defvar message-signature-insert-empty-line t "\
*If non-nil, insert an empty line before the signature separator.")

(custom-autoload 'message-signature-insert-empty-line "message" t)

(define-mail-user-agent 'message-user-agent 'message-mail 'message-send-and-exit 'message-kill-buffer 'message-send-hook)

(autoload 'message-mode "message" "\
Major mode for editing mail and news to be sent.
Like Text Mode but with these additional commands:\\<message-mode-map>
C-c C-s  `message-send' (send the message)  C-c C-c  `message-send-and-exit'
C-c C-d  Postpone sending the message       C-c C-k  Kill the message
C-c C-f  move to a header field (and create it if there isn't):
	 C-c C-f C-t  move to To	C-c C-f C-s  move to Subject
	 C-c C-f C-c  move to Cc	C-c C-f C-b  move to Bcc
	 C-c C-f C-w  move to Fcc	C-c C-f C-r  move to Reply-To
	 C-c C-f C-u  move to Summary	C-c C-f C-n  move to Newsgroups
	 C-c C-f C-k  move to Keywords	C-c C-f C-d  move to Distribution
         C-c C-f C-o  move to From (\"Originator\")
	 C-c C-f C-f  move to Followup-To
	 C-c C-f C-m  move to Mail-Followup-To
	 C-c C-f C-i  cycle through Importance values
	 C-c C-f s    change subject and append \"(was: <Old Subject>)\"
	 C-c C-f x    crossposting with FollowUp-To header and note in body
	 C-c C-f t    replace To: header with contents of Cc: or Bcc:
	 C-c C-f a    Insert X-No-Archive: header and a note in the body
C-c C-t  `message-insert-to' (add a To header to a news followup)
C-c C-l  `message-to-list-only' (removes all but list address in to/cc)
C-c C-n  `message-insert-newsgroups' (add a Newsgroup header to a news reply)
C-c C-b  `message-goto-body' (move to beginning of message text).
C-c C-i  `message-goto-signature' (move to the beginning of the signature).
C-c C-w  `message-insert-signature' (insert `message-signature-file' file).
C-c C-y  `message-yank-original' (insert current message, if any).
C-c C-q  `message-fill-yanked-message' (fill what was yanked).
C-c C-e  `message-elide-region' (elide the text between point and mark).
C-c C-v  `message-delete-not-region' (remove the text outside the region).
C-c C-z  `message-kill-to-signature' (kill the text up to the signature).
C-c C-r  `message-caesar-buffer-body' (rot13 the message body).
C-c C-a  `mml-attach-file' (attach a file as MIME).
C-c C-u  `message-insert-or-toggle-importance'  (insert or cycle importance).
C-c M-n  `message-insert-disposition-notification-to'  (request receipt).
C-c M-m  `message-mark-inserted-region' (mark region with enclosing tags).
C-c M-f  `message-mark-insert-file' (insert file marked with enclosing tags).
M-RET    `message-newline-and-reformat' (break the line and reformat).

\(fn)" t nil)

(autoload 'message-mail "message" "\
Start editing a mail message to be sent.
OTHER-HEADERS is an alist of header/value pairs.  CONTINUE says whether
to continue editing a message already being composed.  SWITCH-FUNCTION
is a function used to switch to and display the mail buffer.

\(fn &optional TO SUBJECT OTHER-HEADERS CONTINUE SWITCH-FUNCTION YANK-ACTION SEND-ACTIONS)" t nil)

(autoload 'message-news "message" "\
Start editing a news article to be sent.

\(fn &optional NEWSGROUPS SUBJECT)" t nil)

(autoload 'message-reply "message" "\
Start editing a reply to the article in the current buffer.

\(fn &optional TO-ADDRESS WIDE)" t nil)

(autoload 'message-wide-reply "message" "\
Make a \"wide\" reply to the message in the current buffer.

\(fn &optional TO-ADDRESS)" t nil)

(autoload 'message-followup "message" "\
Follow up to the message in the current buffer.
If TO-NEWSGROUPS, use that as the new Newsgroups line.

\(fn &optional TO-NEWSGROUPS)" t nil)

(autoload 'message-cancel-news "message" "\
Cancel an article you posted.
If ARG, allow editing of the cancellation message.

\(fn &optional ARG)" t nil)

(autoload 'message-supersede "message" "\
Start composing a message to supersede the current message.
This is done simply by taking the old article and adding a Supersedes
header line with the old Message-ID.

\(fn)" t nil)

(autoload 'message-recover "message" "\
Reread contents of current buffer from its last auto-save file.

\(fn)" t nil)

(autoload 'message-forward "message" "\
Forward the current message via mail.
Optional NEWS will use news to forward instead of mail.
Optional DIGEST will use digest to forward.

\(fn &optional NEWS DIGEST)" t nil)

(autoload 'message-forward-make-body "message" "\


\(fn FORWARD-BUFFER &optional DIGEST)" nil nil)

(autoload 'message-forward-rmail-make-body "message" "\


\(fn FORWARD-BUFFER)" nil nil)

(autoload 'message-insinuate-rmail "message" "\
Let RMAIL use message to forward.

\(fn)" t nil)

(autoload 'message-resend "message" "\
Resend the current article to ADDRESS.

\(fn ADDRESS)" t nil)

(autoload 'message-bounce "message" "\
Re-mail the current message.
This only makes sense if the current message is a bounce message that
contains some mail you have written which has been bounced back to
you.

\(fn)" t nil)

(autoload 'message-mail-other-window "message" "\
Like `message-mail' command, but display mail buffer in another window.

\(fn &optional TO SUBJECT)" t nil)

(autoload 'message-mail-other-frame "message" "\
Like `message-mail' command, but display mail buffer in another frame.

\(fn &optional TO SUBJECT)" t nil)

(autoload 'message-news-other-window "message" "\
Start editing a news article to be sent.

\(fn &optional NEWSGROUPS SUBJECT)" t nil)

(autoload 'message-news-other-frame "message" "\
Start editing a news article to be sent.

\(fn &optional NEWSGROUPS SUBJECT)" t nil)

(autoload 'bold-region "message" "\
Bold all nonblank characters in the region.
Works by overstriking characters.
Called from program, takes two arguments START and END
which specify the range to operate on.

\(fn START END)" t nil)

(autoload 'unbold-region "message" "\
Remove all boldness (overstruck characters) in the region.
Called from program, takes two arguments START and END
which specify the range to operate on.

\(fn START END)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "message" '("message-" "nil")))

;;;***

;;;### (autoloads nil "messagexmas" "messagexmas.el" (0 0 0 0))
;;; Generated autoloads from messagexmas.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "messagexmas" '("message-")))

;;;***

;;;### (autoloads nil "messcompat" "messcompat.el" (0 0 0 0))
;;; Generated autoloads from messcompat.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "messcompat" '("message-")))

;;;***

;;;### (autoloads nil "mm-bodies" "mm-bodies.el" (0 0 0 0))
;;; Generated autoloads from mm-bodies.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "mm-bodies" '("mm-")))

;;;***

;;;### (autoloads nil "mm-decode" "mm-decode.el" (0 0 0 0))
;;; Generated autoloads from mm-decode.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "mm-decode" '("mm-")))

;;;***

;;;### (autoloads nil "mm-encode" "mm-encode.el" (0 0 0 0))
;;; Generated autoloads from mm-encode.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "mm-encode" '("mm-")))

;;;***

;;;### (autoloads nil "mm-extern" "mm-extern.el" (0 0 0 0))
;;; Generated autoloads from mm-extern.el

(autoload 'mm-extern-cache-contents "mm-extern" "\
Put the external-body part of HANDLE into its cache.

\(fn HANDLE)" nil nil)

(autoload 'mm-inline-external-body "mm-extern" "\
Show the external-body part of HANDLE.
This function replaces the buffer of HANDLE with a buffer contains
the entire message.
If NO-DISPLAY is nil, display it. Otherwise, do nothing after replacing.

\(fn HANDLE &optional NO-DISPLAY)" nil nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "mm-extern" '("mm-extern-")))

;;;***

;;;### (autoloads nil "mm-partial" "mm-partial.el" (0 0 0 0))
;;; Generated autoloads from mm-partial.el

(autoload 'mm-inline-partial "mm-partial" "\
Show the partial part of HANDLE.
This function replaces the buffer of HANDLE with a buffer contains
the entire message.
If NO-DISPLAY is nil, display it. Otherwise, do nothing after replacing.

\(fn HANDLE &optional NO-DISPLAY)" nil nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "mm-partial" '("mm-partial-find-parts")))

;;;***

;;;### (autoloads nil "mm-url" "mm-url.el" (0 0 0 0))
;;; Generated autoloads from mm-url.el

(autoload 'mm-url-insert-file-contents "mm-url" "\
Insert file contents of URL.
If `mm-url-use-external' is non-nil, use `mm-url-program'.

\(fn URL)" nil nil)

(autoload 'mm-url-insert-file-contents-external "mm-url" "\
Insert file contents of URL using `mm-url-program'.

\(fn URL)" nil nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "mm-url" '("mm-url-")))

;;;***

;;;### (autoloads nil "mm-util" "mm-util.el" (0 0 0 0))
;;; Generated autoloads from mm-util.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "mm-util" '("mm-")))

;;;***

;;;### (autoloads nil "mm-uu" "mm-uu.el" (0 0 0 0))
;;; Generated autoloads from mm-uu.el

(autoload 'mm-uu-dissect "mm-uu" "\
Dissect the current buffer and return a list of uu handles.
The optional NOHEADER means there's no header in the buffer.
MIME-TYPE specifies a MIME type and parameters, which defaults to the
value of `mm-uu-text-plain-type'.

\(fn &optional NOHEADER MIME-TYPE)" nil nil)

(autoload 'mm-uu-dissect-text-parts "mm-uu" "\
Dissect text parts and put uu handles into HANDLE.
Assume text has been decoded if DECODED is non-nil.

\(fn HANDLE &optional DECODED)" nil nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "mm-uu" '("mm-")))

;;;***

;;;### (autoloads nil "mm-view" "mm-view.el" (0 0 0 0))
;;; Generated autoloads from mm-view.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "mm-view" '("mm-")))

;;;***

;;;### (autoloads nil "mml" "mml.el" (0 0 0 0))
;;; Generated autoloads from mml.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "mml" '("mime-to-mml" "mml-")))

;;;***

;;;### (autoloads nil "mml-sec" "mml-sec.el" (0 0 0 0))
;;; Generated autoloads from mml-sec.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "mml-sec" '("mml-")))

;;;***

;;;### (autoloads nil "mml-smime" "mml-smime.el" (0 0 0 0))
;;; Generated autoloads from mml-smime.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "mml-smime" '("mml-smime-")))

;;;***

;;;### (autoloads nil "mml1991" "mml1991.el" (0 0 0 0))
;;; Generated autoloads from mml1991.el

(autoload 'mml1991-encrypt "mml1991" "\


\(fn CONT &optional SIGN)" nil nil)

(autoload 'mml1991-sign "mml1991" "\


\(fn CONT)" nil nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "mml1991" '("mml1991-")))

;;;***

;;;### (autoloads nil "mml2015" "mml2015.el" (0 0 0 0))
;;; Generated autoloads from mml2015.el

(autoload 'mml2015-decrypt "mml2015" "\


\(fn HANDLE CTL)" nil nil)

(autoload 'mml2015-decrypt-test "mml2015" "\


\(fn HANDLE CTL)" nil nil)

(autoload 'mml2015-verify "mml2015" "\


\(fn HANDLE CTL)" nil nil)

(autoload 'mml2015-verify-test "mml2015" "\


\(fn HANDLE CTL)" nil nil)

(autoload 'mml2015-encrypt "mml2015" "\


\(fn CONT &optional SIGN)" nil nil)

(autoload 'mml2015-sign "mml2015" "\


\(fn CONT)" nil nil)

(autoload 'mml2015-self-encrypt "mml2015" "\


\(fn)" nil nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "mml2015" '("mml2015-")))

;;;***

;;;### (autoloads nil "netrc" "netrc.el" (0 0 0 0))
;;; Generated autoloads from netrc.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "netrc" '("netrc-")))

;;;***

;;;### (autoloads nil "nnagent" "nnagent.el" (0 0 0 0))
;;; Generated autoloads from nnagent.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nnagent" '("nnagent-")))

;;;***

;;;### (autoloads nil "nnbabyl" "nnbabyl.el" (0 0 0 0))
;;; Generated autoloads from nnbabyl.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nnbabyl" '("nnbabyl-")))

;;;***

;;;### (autoloads nil "nndb" "nndb.el" (0 0 0 0))
;;; Generated autoloads from nndb.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nndb" '("nndb-")))

;;;***

;;;### (autoloads nil "nndiary" "nndiary.el" (0 0 0 0))
;;; Generated autoloads from nndiary.el

(autoload 'nndiary-generate-nov-databases "nndiary" "\
Generate NOV databases in all nndiary directories.

\(fn &optional SERVER)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nndiary" '("nndiary-")))

;;;***

;;;### (autoloads nil "nndir" "nndir.el" (0 0 0 0))
;;; Generated autoloads from nndir.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nndir" '("nndir-")))

;;;***

;;;### (autoloads nil "nndoc" "nndoc.el" (0 0 0 0))
;;; Generated autoloads from nndoc.el

(autoload 'nndoc-add-type "nndoc" "\
Add document DEFINITION to the list of nndoc document definitions.
If POSITION is nil or `last', the definition will be added
as the last checked definition, if t or `first', add as the
first definition, and if any other symbol, add after that
symbol in the alist.

\(fn DEFINITION &optional POSITION)" nil nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nndoc" '("nndoc-")))

;;;***

;;;### (autoloads nil "nndraft" "nndraft.el" (0 0 0 0))
;;; Generated autoloads from nndraft.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nndraft" '("nndraft-")))

;;;***

;;;### (autoloads nil "nneething" "nneething.el" (0 0 0 0))
;;; Generated autoloads from nneething.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nneething" '("nneething-")))

;;;***

;;;### (autoloads nil "nnfolder" "nnfolder.el" (0 0 0 0))
;;; Generated autoloads from nnfolder.el

(autoload 'nnfolder-generate-active-file "nnfolder" "\
Look for mbox folders in the nnfolder directory and make them into groups.
This command does not work if you use short group names.

\(fn)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nnfolder" '("nnfolder-")))

;;;***

;;;### (autoloads nil "nngateway" "nngateway.el" (0 0 0 0))
;;; Generated autoloads from nngateway.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nngateway" '("nngateway-")))

;;;***

;;;### (autoloads nil "nnheader" "nnheader.el" (0 0 0 0))
;;; Generated autoloads from nnheader.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nnheader" '("news-reply-yank-" "mail-header-" "make-" "gnus-")))

;;;***

;;;### (autoloads nil "nnheaderxm" "nnheaderxm.el" (0 0 0 0))
;;; Generated autoloads from nnheaderxm.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nnheaderxm" '("nnheader-")))

;;;***

;;;### (autoloads nil "nnimap" "nnimap.el" (0 0 0 0))
;;; Generated autoloads from nnimap.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nnimap" '("nnimap-")))

;;;***

;;;### (autoloads nil "nnkiboze" "nnkiboze.el" (0 0 0 0))
;;; Generated autoloads from nnkiboze.el

(autoload 'nnkiboze-generate-groups "nnkiboze" "\
\"Usage: emacs -batch -l nnkiboze -f nnkiboze-generate-groups\".
Finds out what articles are to be part of the nnkiboze groups.

\(fn)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nnkiboze" '("nnkiboze-")))

;;;***

;;;### (autoloads nil "nnlistserv" "nnlistserv.el" (0 0 0 0))
;;; Generated autoloads from nnlistserv.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nnlistserv" '("nnlistserv-")))

;;;***

;;;### (autoloads nil "nnmail" "nnmail.el" (0 0 0 0))
;;; Generated autoloads from nnmail.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nnmail" '("nnmail-")))

;;;***

;;;### (autoloads nil "nnmaildir" "nnmaildir.el" (0 0 0 0))
;;; Generated autoloads from nnmaildir.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nnmaildir" '("nnmaildir-")))

;;;***

;;;### (autoloads nil "nnmbox" "nnmbox.el" (0 0 0 0))
;;; Generated autoloads from nnmbox.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nnmbox" '("nnmbox-")))

;;;***

;;;### (autoloads nil "nnmh" "nnmh.el" (0 0 0 0))
;;; Generated autoloads from nnmh.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nnmh" '("nnmh-")))

;;;***

;;;### (autoloads nil "nnml" "nnml.el" (0 0 0 0))
;;; Generated autoloads from nnml.el

(autoload 'nnml-generate-nov-databases "nnml" "\
Generate NOV databases in all nnml directories.

\(fn &optional SERVER)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nnml" '("nnml-")))

;;;***

;;;### (autoloads nil "nnnil" "nnnil.el" (0 0 0 0))
;;; Generated autoloads from nnnil.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nnnil" '("nnnil-")))

;;;***

;;;### (autoloads nil "nnoo" "nnoo.el" (0 0 0 0))
;;; Generated autoloads from nnoo.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nnoo" '("nnoo-" "defvoo" "deffoo")))

;;;***

;;;### (autoloads nil "nnrss" "nnrss.el" (0 0 0 0))
;;; Generated autoloads from nnrss.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nnrss" '("nnrss-")))

;;;***

;;;### (autoloads nil "nnslashdot" "nnslashdot.el" (0 0 0 0))
;;; Generated autoloads from nnslashdot.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nnslashdot" '("nnslashdot-")))

;;;***

;;;### (autoloads nil "nnsoup" "nnsoup.el" (0 0 0 0))
;;; Generated autoloads from nnsoup.el

(autoload 'nnsoup-pack-replies "nnsoup" "\
Make an outbound package of SOUP replies.

\(fn)" t nil)

(autoload 'nnsoup-set-variables "nnsoup" "\
Use the SOUP methods for posting news and mailing mail.

\(fn)" t nil)

(autoload 'nnsoup-revert-variables "nnsoup" "\
Revert posting and mailing methods to the standard Emacs methods.

\(fn)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nnsoup" '("nnsoup-")))

;;;***

;;;### (autoloads nil "nnspool" "nnspool.el" (0 0 0 0))
;;; Generated autoloads from nnspool.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nnspool" '("nnspool-")))

;;;***

;;;### (autoloads nil "nntp" "nntp.el" (0 0 0 0))
;;; Generated autoloads from nntp.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nntp" '("nntp-")))

;;;***

;;;### (autoloads nil "nnultimate" "nnultimate.el" (0 0 0 0))
;;; Generated autoloads from nnultimate.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nnultimate" '("nnultimate-")))

;;;***

;;;### (autoloads nil "nnvirtual" "nnvirtual.el" (0 0 0 0))
;;; Generated autoloads from nnvirtual.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nnvirtual" '("nnvirtual-")))

;;;***

;;;### (autoloads nil "nnwarchive" "nnwarchive.el" (0 0 0 0))
;;; Generated autoloads from nnwarchive.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nnwarchive" '("nnwarchive-")))

;;;***

;;;### (autoloads nil "nnweb" "nnweb.el" (0 0 0 0))
;;; Generated autoloads from nnweb.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nnweb" '("nnweb-")))

;;;***

;;;### (autoloads nil "nnwfm" "nnwfm.el" (0 0 0 0))
;;; Generated autoloads from nnwfm.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "nnwfm" '("nnwfm-")))

;;;***

;;;### (autoloads nil "parse-time" "parse-time.el" (0 0 0 0))
;;; Generated autoloads from parse-time.el

(autoload 'parse-time-string "parse-time" "\
Parse the time-string STRING into (SEC MIN HOUR DAY MON YEAR DOW DST TZ).
The values are identical to those of `decode-time', but any values that are
unknown are returned as nil.

\(fn STRING)" nil nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "parse-time" '("parse-" "digit-char-p")))

;;;***

;;;### (autoloads nil "pgg" "pgg.el" (0 0 0 0))
;;; Generated autoloads from pgg.el

(autoload 'pgg-encrypt-region "pgg" "\
Encrypt the current region between START and END for RCPTS.

If optional argument SIGN is non-nil, do a combined sign and encrypt.

If optional PASSPHRASE is not specified, it will be obtained from the
passphrase cache or user.

\(fn START END RCPTS &optional SIGN PASSPHRASE)" t nil)

(autoload 'pgg-encrypt-symmetric-region "pgg" "\
Encrypt the current region between START and END symmetric with passphrase.

If optional PASSPHRASE is not specified, it will be obtained from the
cache or user.

\(fn START END &optional PASSPHRASE)" t nil)

(autoload 'pgg-encrypt-symmetric "pgg" "\
Encrypt the current buffer using a symmetric, rather than key-pair, cipher.

If optional arguments START and END are specified, only encrypt within
the region.

If optional PASSPHRASE is not specified, it will be obtained from the
passphrase cache or user.

\(fn &optional START END PASSPHRASE)" t nil)

(autoload 'pgg-encrypt "pgg" "\
Encrypt the current buffer for RCPTS.

If optional argument SIGN is non-nil, do a combined sign and encrypt.

If optional arguments START and END are specified, only encrypt within
the region.

If optional PASSPHRASE is not specified, it will be obtained from the
passphrase cache or user.

\(fn RCPTS &optional SIGN START END PASSPHRASE)" t nil)

(autoload 'pgg-decrypt-region "pgg" "\
Decrypt the current region between START and END.

If optional PASSPHRASE is not specified, it will be obtained from the
passphrase cache or user.

\(fn START END &optional PASSPHRASE)" t nil)

(autoload 'pgg-decrypt "pgg" "\
Decrypt the current buffer.

If optional arguments START and END are specified, only decrypt within
the region.

If optional PASSPHRASE is not specified, it will be obtained from the
passphrase cache or user.

\(fn &optional START END PASSPHRASE)" t nil)

(autoload 'pgg-sign-region "pgg" "\
Make the signature from text between START and END.

If the optional 3rd argument CLEARTEXT is non-nil, it does not create
a detached signature.

If this function is called interactively, CLEARTEXT is enabled
and the output is displayed.

If optional PASSPHRASE is not specified, it will be obtained from the
passphrase cache or user.

\(fn START END &optional CLEARTEXT PASSPHRASE)" t nil)

(autoload 'pgg-sign "pgg" "\
Sign the current buffer.

If the optional argument CLEARTEXT is non-nil, it does not create a
detached signature.

If optional arguments START and END are specified, only sign data
within the region.

If this function is called interactively, CLEARTEXT is enabled
and the output is displayed.

If optional PASSPHRASE is not specified, it will be obtained from the
passphrase cache or user.

\(fn &optional CLEARTEXT START END PASSPHRASE)" t nil)

(autoload 'pgg-verify-region "pgg" "\
Verify the current region between START and END.
If the optional 3rd argument SIGNATURE is non-nil, it is treated as
the detached signature of the current region.

If the optional 4th argument FETCH is non-nil, we attempt to fetch the
signer's public key from `pgg-default-keyserver-address'.

\(fn START END &optional SIGNATURE FETCH)" t nil)

(autoload 'pgg-verify "pgg" "\
Verify the current buffer.
If the optional argument SIGNATURE is non-nil, it is treated as
the detached signature of the current region.
If the optional argument FETCH is non-nil, we attempt to fetch the
signer's public key from `pgg-default-keyserver-address'.
If optional arguments START and END are specified, only verify data
within the region.

\(fn &optional SIGNATURE FETCH START END)" t nil)

(autoload 'pgg-insert-key "pgg" "\
Insert the ASCII armored public key.

\(fn)" t nil)

(autoload 'pgg-snarf-keys-region "pgg" "\
Import public keys in the current region between START and END.

\(fn START END)" t nil)

(autoload 'pgg-snarf-keys "pgg" "\
Import public keys in the current buffer.

\(fn)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "pgg" '("pgg-")))

;;;***

;;;### (autoloads nil "pgg-def" "pgg-def.el" (0 0 0 0))
;;; Generated autoloads from pgg-def.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "pgg-def" '("pgg-")))

;;;***

;;;### (autoloads nil "pgg-gpg" "pgg-gpg.el" (0 0 0 0))
;;; Generated autoloads from pgg-gpg.el

(autoload 'pgg-gpg-symmetric-key-p "pgg-gpg" "\
True if decoded armor MESSAGE-KEYS has symmetric encryption indicator.

\(fn MESSAGE-KEYS)" nil nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "pgg-gpg" '("pgg-gpg-")))

;;;***

;;;### (autoloads nil "pgg-parse" "pgg-parse.el" (0 0 0 0))
;;; Generated autoloads from pgg-parse.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "pgg-parse" '("pgg-")))

;;;***

;;;### (autoloads nil "pgg-pgp" "pgg-pgp.el" (0 0 0 0))
;;; Generated autoloads from pgg-pgp.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "pgg-pgp" '("pgg-pgp-")))

;;;***

;;;### (autoloads nil "pgg-pgp5" "pgg-pgp5.el" (0 0 0 0))
;;; Generated autoloads from pgg-pgp5.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "pgg-pgp5" '("pgg-pgp5-")))

;;;***

;;;### (autoloads nil "pop3" "pop3.el" (0 0 0 0))
;;; Generated autoloads from pop3.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "pop3" '("pop3-")))

;;;***

;;;### (autoloads nil "qp" "qp.el" (0 0 0 0))
;;; Generated autoloads from qp.el

(autoload 'quoted-printable-decode-region "qp" "\
Decode quoted-printable in the region between FROM and TO, per RFC 2045.
If CODING-SYSTEM is non-nil, decode bytes into characters with that
coding-system.

Interactively, you can supply the CODING-SYSTEM argument
with \\[universal-coding-system-argument].

The CODING-SYSTEM argument is a historical hangover and is deprecated.
QP encodes raw bytes and should be decoded into raw bytes.  Decoding
them into characters should be done separately.

\(fn FROM TO &optional CODING-SYSTEM)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "qp" '("quoted-printable-")))

;;;***

;;;### (autoloads nil "rfc1843" "rfc1843.el" (0 0 0 0))
;;; Generated autoloads from rfc1843.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "rfc1843" '("rfc1843-")))

;;;***

;;;### (autoloads nil "rfc2045" "rfc2045.el" (0 0 0 0))
;;; Generated autoloads from rfc2045.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "rfc2045" '("rfc2045-encode-string")))

;;;***

;;;### (autoloads nil "rfc2047" "rfc2047.el" (0 0 0 0))
;;; Generated autoloads from rfc2047.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "rfc2047" '("rfc2047-")))

;;;***

;;;### (autoloads nil "rfc2104" "rfc2104.el" (0 0 0 0))
;;; Generated autoloads from rfc2104.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "rfc2104" '("rfc2104-")))

;;;***

;;;### (autoloads nil "rfc2231" "rfc2231.el" (0 0 0 0))
;;; Generated autoloads from rfc2231.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "rfc2231" '("rfc2231-")))

;;;***

;;;### (autoloads nil "score-mode" "score-mode.el" (0 0 0 0))
;;; Generated autoloads from score-mode.el

(autoload 'gnus-score-mode "score-mode" "\
Mode for editing Gnus score files.
This mode is an extended emacs-lisp mode.

\\{gnus-score-mode-map}

\(fn)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "score-mode" '("gnus-score-" "score-mode-")))

;;;***

;;;### (autoloads nil "sha1" "sha1.el" (0 0 0 0))
;;; Generated autoloads from sha1.el

(autoload 'sha1 "sha1" "\
Return the SHA1 (Secure Hash Algorithm) of an object.
OBJECT is either a string or a buffer.
Optional arguments BEG and END denote buffer positions for computing the
hash of a portion of OBJECT.
If BINARY is non-nil, return a string in binary form.

\(fn OBJECT &optional BEG END BINARY)" nil nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "sha1" '("sha1-")))

;;;***

;;;### (autoloads nil "sieve" "sieve.el" (0 0 0 0))
;;; Generated autoloads from sieve.el

(autoload 'sieve-manage "sieve" "\


\(fn SERVER &optional PORT)" t nil)

(autoload 'sieve-upload "sieve" "\


\(fn &optional NAME)" t nil)

(autoload 'sieve-upload-and-bury "sieve" "\


\(fn &optional NAME)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "sieve" '("sieve-")))

;;;***

;;;### (autoloads nil "sieve-manage" "sieve-manage.el" (0 0 0 0))
;;; Generated autoloads from sieve-manage.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "sieve-manage" '("sieve-manage-" "imap-starttls-")))

;;;***

;;;### (autoloads nil "sieve-mode" "sieve-mode.el" (0 0 0 0))
;;; Generated autoloads from sieve-mode.el

(autoload 'sieve-mode "sieve-mode" "\
Major mode for editing Sieve code.
This is much like C mode except for the syntax of comments.  Its keymap
inherits from C mode's and it has the same variables for customizing
indentation.  It has its own abbrev table and its own syntax table.

Turning on Sieve mode runs `sieve-mode-hook'.

\(fn)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "sieve-mode" '("sieve-")))

;;;***

;;;### (autoloads nil "smiley" "smiley.el" (0 0 0 0))
;;; Generated autoloads from smiley.el





(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "smiley" '("smiley-" "gnus-smiley-file-types")))

;;;***

;;;### (autoloads nil "smime" "smime.el" (0 0 0 0))
;;; Generated autoloads from smime.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "smime" '("smime")))

;;;***

;;;### (autoloads nil "spam" "spam.el" (0 0 0 0))
;;; Generated autoloads from spam.el

(autoload 'spam-initialize "spam" "\
Install the spam.el hooks and do other initialization

\(fn)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "spam" '("spam-")))

;;;***

;;;### (autoloads nil "spam-report" "spam-report.el" (0 0 0 0))
;;; Generated autoloads from spam-report.el

(autoload 'spam-report-process-queue "spam-report" "\
Report all queued requests from `spam-report-requests-file'.

If FILE is given, use it instead of `spam-report-requests-file'.
If KEEP is t, leave old requests in the file.  If KEEP is the
symbol `ask', query before flushing the queue file.

\(fn &optional FILE KEEP)" t nil)

(autoload 'spam-report-url-ping-mm-url "spam-report" "\
Ping a host through HTTP, addressing a specific GET resource. Use
the external program specified in `mm-url-program' to connect to
server.

\(fn HOST REPORT)" nil nil)

(autoload 'spam-report-url-to-file "spam-report" "\
Collect spam report requests in `spam-report-requests-file'.
Customize `spam-report-url-ping-function' to use this function.

\(fn HOST REPORT)" nil nil)

(autoload 'spam-report-agentize "spam-report" "\
Add spam-report support to the Agent.
Spam reports will be queued with \\[spam-report-url-to-file] when
the Agent is unplugged, and will be submitted in a batch when the
Agent is plugged.

\(fn)" t nil)

(autoload 'spam-report-deagentize "spam-report" "\
Remove spam-report support from the Agent.
Spam reports will be queued with the method used when
\\[spam-report-agentize] was run.

\(fn)" t nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "spam-report" '("spam-report-")))

;;;***

;;;### (autoloads nil "spam-stat" "spam-stat.el" (0 0 0 0))
;;; Generated autoloads from spam-stat.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "spam-stat" '("spam-stat" "with-spam-stat-max-buffer-size")))

;;;***

;;;### (autoloads nil "starttls" "starttls.el" (0 0 0 0))
;;; Generated autoloads from starttls.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "starttls" '("starttls-")))

;;;***

;;;### (autoloads nil "time-date" "time-date.el" (0 0 0 0))
;;; Generated autoloads from time-date.el

(autoload 'date-to-time "time-date" "\
Parse a string that represents a date-time and return a time value.

\(fn DATE)" nil nil)

(autoload 'time-to-seconds "time-date" "\
Convert time value TIME to a floating point number.
You can use `float-time' instead.

\(fn TIME)" nil nil)

(autoload 'seconds-to-time "time-date" "\
Convert SECONDS (a floating point number) to a time value.

\(fn SECONDS)" nil nil)

(autoload 'time-less-p "time-date" "\
Say whether time value T1 is less than time value T2.

\(fn T1 T2)" nil nil)

(autoload 'days-to-time "time-date" "\
Convert DAYS into a time value.

\(fn DAYS)" nil nil)

(autoload 'time-since "time-date" "\
Return the time elapsed since TIME.
TIME should be either a time value or a date-time string.

\(fn TIME)" nil nil)

(defalias 'subtract-time 'time-subtract)

(autoload 'time-subtract "time-date" "\
Subtract two time values.
Return the difference in the format of a time value.

\(fn T1 T2)" nil nil)

(autoload 'time-add "time-date" "\
Add two time values.  One should represent a time difference.

\(fn T1 T2)" nil nil)

(autoload 'date-to-day "time-date" "\
Return the number of days between year 1 and DATE.
DATE should be a date-time string.

\(fn DATE)" nil nil)

(autoload 'days-between "time-date" "\
Return the number of days between DATE1 and DATE2.
DATE1 and DATE2 should be date-time strings.

\(fn DATE1 DATE2)" nil nil)

(autoload 'date-leap-year-p "time-date" "\
Return t if YEAR is a leap year.

\(fn YEAR)" nil nil)

(autoload 'time-to-day-in-year "time-date" "\
Return the day number within the year corresponding to TIME.

\(fn TIME)" nil nil)

(autoload 'time-to-days "time-date" "\
The number of days between the Gregorian date 0001-12-31bce and TIME.
TIME should be a time value.
The Gregorian date Sunday, December 31, 1bce is imaginary.

\(fn TIME)" nil nil)

(autoload 'safe-date-to-time "time-date" "\
Parse a string that represents a date-time and return a time value.
If DATE is malformed, return a time value of zeros.

\(fn DATE)" nil nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "time-date" '("time-to-number-of-days" "encode-time-value" "with-decoded-time-value")))

;;;***

;;;### (autoloads nil "tls" "tls.el" (0 0 0 0))
;;; Generated autoloads from tls.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "tls" '("open-tls-stream" "tls-")))

;;;***

;;;### (autoloads nil "utf7" "utf7.el" (0 0 0 0))
;;; Generated autoloads from utf7.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "utf7" '("utf7-")))

;;;***

;;;### (autoloads nil "uudecode" "uudecode.el" (0 0 0 0))
;;; Generated autoloads from uudecode.el

(autoload 'uudecode-decode-region-external "uudecode" "\
Uudecode region between START and END using external program.
If FILE-NAME is non-nil, save the result to FILE-NAME.  The program
used is specified by `uudecode-decoder-program'.

\(fn START END &optional FILE-NAME)" t nil)

(autoload 'uudecode-decode-region-internal "uudecode" "\
Uudecode region between START and END without using an external program.
If FILE-NAME is non-nil, save the result to FILE-NAME.

\(fn START END &optional FILE-NAME)" t nil)

(autoload 'uudecode-decode-region "uudecode" "\
Uudecode region between START and END.
If FILE-NAME is non-nil, save the result to FILE-NAME.

\(fn START END &optional FILE-NAME)" nil nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "uudecode" '("uudecode-")))

;;;***

;;;### (autoloads nil "webmail" "webmail.el" (0 0 0 0))
;;; Generated autoloads from webmail.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "webmail" '("webmail-")))

;;;***

;;;### (autoloads nil "yenc" "yenc.el" (0 0 0 0))
;;; Generated autoloads from yenc.el

(autoload 'yenc-decode-region "yenc" "\
Yenc decode region between START and END using an internal decoder.

\(fn START END)" t nil)

(autoload 'yenc-extract-filename "yenc" "\
Extract file name from an yenc header.

\(fn)" nil nil)

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "yenc" '("yenc-")))

;;;***

;;;### (autoloads nil nil ("cus-load.el") (0 0 0 0))

;;;***

(provide 'gnus-load)

;;; Local Variables:
;;; version-control: never
;;; no-byte-compile: t
;;; no-update-autoloads: t
;;; End:
;;; gnus-load.el ends here
