;;; gnu-elpa-features.el --- Auto-generated autoloads  -*- lexical-binding:t -*-

;; ¡¡ This file is auto-generated by `gnu-elpa--make-features', DO NOT EDIT !!

;; Copyright (C) 2020-2021  Free Software Foundation, Inc.

;; Author: gnu-elpa-maint.el

;; This program is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.

;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with this program.  If not, see <https://www.gnu.org/licenses/>.

;;; Code:

;; Don't edit this file, it's auto-generated by `gnu-elpa--make-features'!

(dolist (x '((ace-window-display-mode "Minor mode for showing the ace window key in the mode line.

If called interactively, toggle `Ace-Window-Display mode'.  If
the prefix argument is positive, enable the mode, and if it is
zero or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (ace-window "Select a window.
Perform an action based on ARG described below.

By default, behaves like extended `other-window'.

Prefixed with one \\[universal-argument], does a swap between the
selected window and the current window, so that the selected
buffer moves to current window (and current buffer moves to
selected window).

Prefixed with two \\[universal-argument]'s, deletes the selected
window.

(fn ARG)" t nil)
	     (ace-maximize-window "Ace maximize window." t nil)
	     (ace-swap-window "Ace swap window." t nil)
	     (ace-delete-window "Ace delete window." t nil)
	     (ace-select-window "Ace select window." t nil)
	     (pcomplete/ag "Completion for the `ag' command." nil nil)
	     (pcomplete/ack "Completion for the `ack' command.
Start an argument with '-' to complete short options and '--' for
long options." nil nil)
	     (ack "Run ack using COMMAND-ARGS and collect output in a buffer.
When called interactively, the value of DIRECTORY is provided by
`ack-default-directory-function'.

The following keys are available while reading from the
minibuffer:

\\{ack-minibuffer-local-map}

(fn COMMAND-ARGS &optional DIRECTORY)" t nil)
	     (adaptive-wrap-prefix-mode "Wrap the buffer text with adaptive filling.

If called interactively, toggle `Adaptive-Wrap-Prefix mode'.  If
the prefix argument is positive, enable the mode, and if it is
zero or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (adjust-parens-mode "Indent and dedent Lisp code, automatically adjust close parens.

If called interactively, toggle `Adjust-Parens mode'.  If the
prefix argument is positive, enable the mode, and if it is zero
or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (advice-patch "Replace OLDCODE with NEWCODE in the definition of NAME.
OLDCODE is an S-expression to replace in the source code.
It can also be a vector of S-expressions, so that you can specify the various original source codes found in various Emacs versions.

(fn NAME NEWCODE OLDCODE)" nil nil)
	     (global-aggressive-indent-mode "Toggle Aggressive-Indent mode in all buffers.
With prefix ARG, enable Global Aggressive-Indent mode if ARG is positive;
otherwise, disable it.  If called from Lisp, enable the mode if
ARG is omitted or nil.

Aggressive-Indent mode is enabled in all buffers where
`aggressive-indent-mode' would do it.

See `aggressive-indent-mode' for more information on
Aggressive-Indent mode.

(fn &optional ARG)" t nil)
	     (aggressive-indent-mode "Toggle Aggressive-Indent mode on or off.

If called interactively, toggle `Aggressive-Indent mode'.  If the
prefix argument is positive, enable the mode, and if it is zero
or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

\\{aggressive-indent-mode-map}

(fn &optional ARG)" t nil)
	     (aggressive-indent-indent-region-and-on "Indent region between L and R, and then some.
Call `indent-region' between L and R, and then keep indenting
until nothing more happens.

(fn L R)" t nil)
	     (aggressive-indent-indent-defun "Indent current defun.
Throw an error if parentheses are unbalanced.
If L and R are provided, use them for finding the start and end of defun.

(fn &optional L R)" t nil)
	     (all "Show all lines in the current buffer containing a match for REGEXP.

If a match spreads across multiple lines, all those lines are shown.

Each line is displayed with NLINES lines before and after, or -NLINES
before if NLINES is negative.
NLINES defaults to `list-matching-lines-default-context-lines'.
Interactively it is the prefix arg.

The lines are shown in a buffer named `*All*'.
Any changes made in that buffer will be propagated to this buffer.

(fn REGEXP &optional NLINES)" t nil)
	     (ampc "Ampc is an asynchronous client for the MPD media player.
This function is the main entry point for ampc.

HOST and PORT specify the MPD instance to connect to.  The values
default to the ones specified in `ampc-default-server'.

(fn &optional HOST PORT SUSPEND)" t nil)
	     (ampc-on-p "Return non-nil if ampc is connected to the daemon." t nil)
	     (ampc-suspended-p "Return non-nil if ampc is suspended." t nil)
	     (ampc-tag-files "Start the tagging subsystem.
FILES should be a list of absolute file names, the files to tag.

(fn FILES)" nil nil)
	     (ampc-tagger-dired "Start the tagging subsystem on dired's marked files.
With optional prefix argument ARG, use the next ARG files.

(fn &optional ARG)" t nil)
	     (ampc-tagger-dired-mode "Minor mode that adds a audio file meta data tagging key binding to dired.

If called interactively, toggle `Ampc-Tagger-Dired mode'.  If the
prefix argument is positive, enable the mode, and if it is zero or
negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable the
mode if ARG is nil, omitted, or is a positive number.  Disable the
mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when it is
disabled.

(fn &optional ARG)" t nil)
	     (arbitools-mode "Major mode for Chess Tournament Management.

(fn)" t nil)
	     (aa2u-mark-rectangle-as-text "Like ‘aa2u-mark-as-text’ on the region-rectangle.
When called from a program the rectangle's corners
are START (top left) and END (bottom right).

(fn START END &optional UNMARK)" t nil)
	     (aa2u-mark-as-text "Set property ‘aa2u-text’ of the text from START to END.
This prevents ‘aa2u’ from misinterpreting \"|\", \"-\" and \"+\"
in that region as lines and intersections to be replaced.
Prefix arg means to remove property ‘aa2u-text’, instead.

(fn START END &optional UNMARK)" t nil)
	     (aa2u-rectangle "Like ‘aa2u’ on the region-rectangle.
When called from a program the rectangle's corners
are START (top left) and END (bottom right).

(fn START END)" t nil)
	     (aa2u "Convert simple ASCII art line drawings to Unicode.
Specifically, perform the following replacements:

  - (hyphen)          BOX DRAWINGS LIGHT HORIZONTAL
  | (vertical bar)    BOX DRAWINGS LIGHT VERTICAL
  + (plus)            (one of)
                      BOX DRAWINGS LIGHT VERTICAL AND HORIZONTAL
                      BOX DRAWINGS LIGHT DOWN AND RIGHT
                      BOX DRAWINGS LIGHT DOWN AND LEFT
                      BOX DRAWINGS LIGHT UP AND RIGHT
                      BOX DRAWINGS LIGHT UP AND LEFT
                      BOX DRAWINGS LIGHT VERTICAL AND RIGHT
                      BOX DRAWINGS LIGHT VERTICAL AND LEFT
                      BOX DRAWINGS LIGHT UP AND HORIZONTAL
                      BOX DRAWINGS LIGHT DOWN AND HORIZONTAL
                      BOX DRAWINGS LIGHT UP
                      BOX DRAWINGS LIGHT DOWN
                      BOX DRAWINGS LIGHT LEFT
                      BOX DRAWINGS LIGHT RIGHT
                      QUESTION MARK

More precisely, hyphen and vertical bar are substituted unconditionally,
first, and plus is substituted with a character depending on its north,
south, east and west neighbors.

NB: Actually, ‘aa2u’ can also use \"HEAVY\" instead of \"LIGHT\",
depending on the value of variable ‘aa2u-uniform-weight’.

This command operates on either the active region,
or the accessible portion otherwise.

(fn BEG END &optional INTERACTIVE)" t nil)
	     (dired-async-do-rename "Run ‘dired-do-rename’ asynchronously.

(fn &optional ARG)" t nil)
	     (dired-async-do-hardlink "Run ‘dired-do-hardlink’ asynchronously.

(fn &optional ARG)" t nil)
	     (dired-async-do-symlink "Run ‘dired-do-symlink’ asynchronously.

(fn &optional ARG)" t nil)
	     (dired-async-do-copy "Run ‘dired-do-copy’ asynchronously.

(fn &optional ARG)" t nil)
	     (dired-async-mode "Do dired actions asynchronously.

If called interactively, toggle `Dired-Async mode'.  If the
prefix argument is positive, enable the mode, and if it is zero
or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (async-byte-compile-file "Byte compile Lisp code FILE asynchronously.

Same as `byte-compile-file' but asynchronous.

(fn FILE)" t nil)
	     (async-bytecomp-package-mode "Byte compile asynchronously packages installed with package.el.
Async compilation of packages can be controlled by
`async-bytecomp-allowed-packages'.

If called interactively, toggle `Async-Bytecomp-Package mode'.
If the prefix argument is positive, enable the mode, and if it is
zero or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (async-byte-recompile-directory "Compile all *.el files in DIRECTORY asynchronously.
All *.elc files are systematically deleted before proceeding.

(fn DIRECTORY &optional QUIET)" nil nil)
	     (async-start "Execute START-FUNC (often a lambda) in a subordinate Emacs process.
When done, the return value is passed to FINISH-FUNC.  Example:

    (async-start
       ;; What to do in the child process
       (lambda ()
         (message \"This is a test\")
         (sleep-for 3)
         222)

       ;; What to do when it finishes
       (lambda (result)
         (message \"Async process done, result should be 222: %s\"
                  result)))

If FINISH-FUNC is nil or missing, a future is returned that can
be inspected using `async-get', blocking until the value is
ready.  Example:

    (let ((proc (async-start
                   ;; What to do in the child process
                   (lambda ()
                     (message \"This is a test\")
                     (sleep-for 3)
                     222))))

        (message \"I'm going to do some work here\") ;; ....

        (message \"Waiting on async process, result should be 222: %s\"
                 (async-get proc)))

If you don't want to use a callback, and you don't care about any
return value from the child process, pass the `ignore' symbol as
the second argument (if you don't, and never call `async-get', it
will leave *emacs* process buffers hanging around):

    (async-start
     (lambda ()
       (delete-file \"a remote file on a slow link\" nil))
     \\='ignore)

Note: Even when FINISH-FUNC is present, a future is still
returned except that it yields no value (since the value is
passed to FINISH-FUNC).  Call `async-get' on such a future always
returns nil.  It can still be useful, however, as an argument to
`async-ready' or `async-wait'.

(fn START-FUNC &optional FINISH-FUNC)" nil nil)
	     (async-start-process "Start the executable PROGRAM asynchronously.  See `async-start'.
PROGRAM is passed PROGRAM-ARGS, calling FINISH-FUNC with the
process object when done.  If FINISH-FUNC is nil, the future
object will return the process object when the program is
finished.  Set DEFAULT-DIRECTORY to change PROGRAM's current
working directory.

(fn NAME PROGRAM FINISH-FUNC &rest PROGRAM-ARGS)" nil nil)
	     (aumix "Run the aumix program in a buffer.
An *aumix* buffer is created if it doesn't already exist.
See `aumix-mode' for details of operating the mode." t nil)
	     (aumix-mode "Major mode for running the aumix program.
Key bindings are per the aumix program.  Press `k' for a summary,
or see KEYS in \"man aumix\".  `\\[aumix-mode-quit]' quits and kills the buffer.

The various terminal setups of `term-mode' are unchanged.  Note
in Emacs 24 the ANSI colours use `font-lock-mode' so be sure
that's turned on (which it is by default).  In Emacs 21 the
opposite was true; if you turn on font lock then you lose the
colours.

In XEmacs 21.4, term.el doesn't seem to work very well with
ncurses programs.  A message \"Error opening terminal: eterm\" is
from aumix (the ncurses library) complaining the terminfo is not
found.  Adding TERMINFO=/usr/share/xemacs21/xemacs-packages/etc/
or wherever the /e/eterm file lives might help.  If something
doesn't work then C-c C-x C-k will kill the buffer.

`clone-buffer' doesn't work on an aumix-mode buffer, as of Emacs
24.3.  Two or more aumix programs can run simultaneously (their
displays update with the underlying mixer settings), so perhaps
`clone-buffer' could be made to work.  A `rename-buffer' and
second `M-x aumix' works.  But normally only a single aumix-mode
buffer is desired.

----
The aumix home page is
  URL `http://jpj.net/~trevor/aumix.html'
The aumix-mode.el home page is
  URL `http://user42.tuxfamily.org/aumix-mode/index.html'

----
\\{aumix-mode-map}
" nil nil)
	     (auto-correct-scan "Scan the buffer or region for misspelled words.

When a misspelled word is found, offer to correct the misspelled
word and auto-correct the typo in the future.

When `auto-correct-mode' is enabled, use the `ispell' command
instead." t nil)
	     (auto-correct-scan-region "Scan the region between START and END for misspelled words.

Interactively, START and END are the current region.

When a misspelled word is found, offer to correct the misspelled
word and auto-correct the typo in the future.

When `auto-correct-mode' is enabled, use the `ispell' command
instead.

(fn START END)" t nil)
	     (auto-correct-scan-buffer "Scan current buffer for misspelled words.

When a misspelled word is found, offer to correct the misspelled
word and auto-correct the typo in the future.

When `auto-correct-mode' is enabled, use the `ispell' command
instead." t nil)
	     (auto-correct-fix-and-add "Use `ispell-word' to fix a misspelled word at point.

Once the misspelled word is fixed, auto-correct will remember the
fix and auto-correct it from then on, so long as
`auto-correct-mode' is enabled.

With a non-nil argument LOCAL (interactively, the prefix argument),
create a fix for the typo that will be auto-corrected for buffers
using the current local mode.

This is pointless to use when `auto-correct-mode' is enabled;
instead, use `ispell-word' and `auto-correct-toggle-ispell-local'
to use the local abbrev table.

(fn LOCAL)" t nil)
	     (auto-correct-mode "Activate automatic corrections.

If called interactively, toggle `Auto-Correct mode'.  If the
prefix argument is positive, enable the mode, and if it is zero
or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

Auto correct expansions will only work when this mode is enabled,
but auto-correct can be trained with `auto-correct-fix-and-add'
even if this mode is disabled.

When this mode is enabled, corrections made with flyspell and
Ispell will be made automatically after fixing them once.

In order to add corrections to the auto-correct abbrev table in
flyspell (and thus have them corrected later), set
`flyspell-use-global-abbrev-table-p' to non-nil.

In order to set corrections as local using Ispell, use
the command `auto-correct-toggle-ispell-local'.

\\{auto-correct-mode-map}

(fn &optional ARG)" t nil)
	     (auto-overlay-load-overlays "Load overlays for BUFFER from FILE.
Returns t if successful, nil otherwise.
Defaults to the current buffer.

If FILE is null, or is a string that only specifies a directory,
the filename is constructed from the buffer's file name and
SET-ID. If the buffer is not associated with a file and FILE
doesn't specify a full filename, an error occurs.

The FILE should be generated by `auto-overlay-save-overlays'. By
default, the buffer contents and regexp definitions for SET-ID
will be checked to make sure neither have changed since the
overlays were saved. If they don't match, the saved overlay data
will not be loaded, and the function will return nil.

If NO-REGEXP-CHECK is non-nil, the check for matching regexp
definitions will be skipped; the saved overlays will be loaded
even if different regexp definitions were active when the
overlays were saved.

(fn SET-ID &optional BUFFER FILE NO-REGEXP-CHECK)" nil nil)
	     (auto-overlay-share-regexp-set "Make TO-BUFFER share the regexp set identified by SET-ID with FROM-BUFFER.
Any changes to that regexp set in either buffer will be reflected in the
other. TO-BUFFER defaults to the current buffer.

(fn SET-ID FROM-BUFFER &optional TO-BUFFER)" nil nil)
	     (auto-overlay-load-regexp "Load REGEXP into the auto-overlay definition identified by
DEFINITION-ID in the regexp list named SET-ID in the current
buffer.

If POS is nil, REGEXP is added at the end of the definition. If
it is t, it is added at the beginning. If it is an integer, it is
added at that position.


REGEXP should be a list of the form:

  (RGXP &optional :edge EDGE :id REGEXP-ID
        &rest PROPERTY1 PROPERTY2 ... )

RGXP is either a single regular expression (a string), or a cons
cell of the form (RGXP . GROUP) where RGXP is a regular
expression and GROUP is an integer specifying which group in the
regular expression forms the delimiter for the auto-overlay. The
rest of the PROPERTY entries should be cons cells of the
form (NAME . VALUE) where NAME is an overlay property name (a
symbol) and VALUE is its value.

The :edge and :id properties are optional. EDGE should be one of
the symbols `start' or `end'. If it is not specified, :edge is
assumed to be `start'. ID property is a symbol that can be used to
uniquely identify REGEXP (see `auto-overlay-unload-regexp').

(fn SET-ID DEFINITION-ID REGEXP &optional POS NOPARSE)" nil nil)
	     (auto-overlay-load-definition "Load DEFINITION into the set of auto-overlay definitions SET-ID
in the current buffer. If SET-ID does not exist, it is created.

If POS is nil, DEFINITION is added at the end of the list of
auto-overlay definitions. If it is t, it is added at the
beginning. If it is an integer, it is added at that position in
the list. The position in the list makes no difference to the
behaviour of the auto-overlays. But it can make a difference to
the speed and efficiency. In general, higher-priority and
exclusive DEFINITIONS should appear earlier in the list.

Returns a unique id for the loaded definition, which can be used
to unload it later using `auto-overlay-unload-definition' (which
see).


DEFINITION should be a list of the form:

  (CLASS @optional :id DEFINITION-ID @rest REGEXP1 REGEXP2 ... )

CLASS is a symbol specifying the auto-overlay class. The standard
classes are `word', `line', `self', `flat' and `nested'. The :id
property is optional. It should be a symbol that uniquely
identifies the DEFINITION within SET-ID (see
`auto-overlay-unload-definition').

REGEXP should be a list of the form:

  (RGXP &optional :edge EDGE :id REGEXP-ID
        &rest PROPERTY1 PROPERTY2 ... )

RGXP is either a single regular expression (a string), or a cons
cell of the form (RGXP . GROUP) where RGXP is a regular
expression and GROUP is an integer specifying which group in the
regular expression forms the delimiter for the auto-overlay. The
rest of the PROPERTY entries should be cons cells of the
form (NAME . VALUE) where NAME is an overlay property name (a
symbol) and VALUE is its value.

The EDGE and ID properties are optional. EDGE should be one of
the symbols `start' or `end'. If it is not specified, :edge is
assumed to be `start'. ID should be a symbol that uniquely
identifies REGEXP within DEFINITION (see
`auto-overlay-unload-regexp').

(fn SET-ID DEFINITION &optional POS NOPARSE)" nil nil)
	     (auto-overlay-load-set "Load the set of auto-overlay DEFINITIONS
into the set identified by SET-ID the current buffer.

DEFINITIONS should be a list of the form:

  (DEFINITION1 DEFINITION2 ... )

The DEFINITION's should be lists of the form:

  (CLASS @optional :id DEFINITION-ID @rest REGEXP1 REGEXP2 ... )

CLASS is a symbol specifying the auto-overlay class. The standard
classes are 'word, 'line, 'self, 'flat and 'nested. The :id
property is optional. It should be a symbol that can be used to
uniquely identify DEFINITION (see
`auto-overlay-unload-definition').

The REGEXP's should be lists of the form:

  (RGXP &optional :edge EDGE :id REGEXP-ID
        &rest PROPERTY1 PROPERTY2 ... )

RGXP is either a single regular expression (a string), or a cons
cell of the form (RGXP . GROUP) where RGXP is a regular
expression and GROUP is an integer specifying which group in the
regular expression forms the delimiter for the auto-overlay. The
rest of the PROPERTY entries should be cons cells of the
form (NAME . VALUE) where NAME is an overlay property name (a
symbol) and VALUE is its value.

The :edge and :id properties are optional. EDGE should be one of
the symbols 'start or 'end. If it is not specified, :edge is
assumed to be 'start. ID property is a symbol that can be used to
uniquely identify REGEXP (see `auto-overlay-unload-regexp').

(fn SET-ID DEFINITIONS &optional NOPARSE)" nil nil)
	     (auto-overlay-local-binding "Return \"overlay local \" binding of SYMBOL at POINT,
or the current local binding if there is no overlay binding. If
there is no overlay binding and SYMBOL is not bound, return
nil. POINT defaults to the point.

If ONLY-OVERLAY is non-nil, only overlay bindings are
returned. If none exists at POINT, nil is returned

An \"overlay local\" binding is created by giving an overlay a
non-nil value for a property named SYMBOL. If more than one
overlay at POINT has a non-nil SYMBOL property, the value from
the highest priority overlay is returned.

See `auto-overlay-highest-priority-at-point' for a definition of
\"highest priority\".

(fn SYMBOL &optional POINT ONLY-OVERLAY)" nil nil)
	     (auto-overlay-highest-priority-at-point "Return highest priority overlay at POINT, defaulting to the point.

If two overlays have the same priority, the innermost one takes
precedence (i.e. the one that begins later, or if they begin at
the same point the one that ends earlier).

The remaining arguments are as for `auto-overlays-at' (which see).

(fn &optional POINT &rest PROP-TESTS &key INACTIVE ALL-OVERLAYS &allow-other-keys)" nil nil)
	     (auto-overlays-at-point "Return overlays overlapping POINT, defaulting to the point.

If keyword argument :inactive is non-nil, both active and
inactive overlays are returned (usually inactive ones are
ignored).

If keyword argument :all-overlays is non-nil, all overlays are
returned, not just auto-overlays.

Any remaining arguments (which *must* come after any keyword
arguments) specify property tests, each of which should be a list
with one of the following forms:

  (FUNCTION PROPERTY)

  (FUNCTION PROPERTY VALUE)

  (FUNCTION (PROPERTY1 PROPERTY2 ...) (VALUE1 VALUE2 ...))

where PROPERTY indicates an overlay property name (a symbol), and
VALUE indicates an arbitrary value or lisp expression.

For each overlay between START and END, first the values
corresponding to the property names are retrieved from the
overlay, then FUNCTION is called with the properties values
followed by the other values as its arguments. The test is
satisfied if the result is non-nil, otherwise it fails. Tests are
evaluated in order, but only up to the first failure. Only
overlays that satisfy all property tests are returned.

(fn &optional POINT &rest PROP-TESTS &key INACTIVE ALL-OVERLAYS &allow-other-keys)" nil nil)
	     (auto-overlays-in "Return auto overlays overlapping region between START and END.

If keyword argument :within is non-nil, only overlays entirely
within START and END are returned.

If keyword argument :inactive is non-nil, both active and
inactive overlays are returned (usually inactive ones are
ignored).

If keyword argument :all-overlays is non-nil, all overlays are
returned, not just auto-overlays.

Any remaining arguments (which *must* come after any keyword
arguments) specify property tests, each of which should be a list
with one of the following forms:

  PROPERTY

  (FUNCTION PROPERTY)

  (FUNCTION PROPERTY VALUE)

  (FUNCTION (PROPERTY1 PROPERTY2 ...) (VALUE1 VALUE2 ...))

where PROPERTY indicates an overlay property name (a symbol), and
VALUE indicates an arbitrary value or lisp expression.

For each overlay between START and END, first the values
corresponding to the property names are retrieved from the
overlay, then FUNCTION is called with the properties values
followed by the other values as its arguments. The test is
satisfied if the result is non-nil, otherwise it fails.

A PROPERTY symbol on its own tests whether that property has a
non-null value, equivalent to (identity PROPERTY).

Tests are evaluated in order, but only up to the first failure.
Only overlays that satisfy all property tests are returned.

(fn START END &rest PROP-TESTS &key WITHIN INACTIVE ALL-OVERLAYS &allow-other-keys)" nil nil)
	     (beacon-mode "Toggle Beacon mode on or off.

If called interactively, toggle `Beacon mode'.  If the prefix
argument is positive, enable the mode, and if it is zero or
negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

\\{beacon-mode-map}

(fn &optional ARG)" t nil)
	     (beacon-blink "Blink the beacon at the position of the cursor.
Unlike `beacon-blink-automated', the beacon will blink
unconditionally (even if `beacon-mode' is disabled), and this can
be invoked as a user command or called from lisp code." t nil)
	     (bluetooth-list-devices "Display a list of Bluetooth devices.
This function starts Bluetooth mode which offers an interface
offering device management functions, e.g. pairing, connecting,
scanning the bus, displaying device info etc." t nil)
	     (bnf-mode "A major mode for editing BNF grammars.

\\{bnf-mode-map}
The variable `bnf-mode-algol-comments-style' can be changed to control
comments style used in grammars.

Turning on BNF mode calls the value of `prog-mode-hook' and then of
`bnf-mode-hook', if they are non-nil.

(fn)" t nil)
	     (brief-easy-start "Emulate Brief by changing less favored Emacs settings for programmers.
Before enabling brief mode this sets the following:
 1) No line wrapping by setting `truncate-lines' 't.
 2) No jumppy scrolling in both vertical and horizontal directions.
 3) Smaller borders.
This function is used by the quick launcher 'b' script." t nil)
	     (brief-mode "Enable/Disable/Toggle Brief emulation mode.
With a prefix argument ARG, enable Brief mode if ARG is positive,
and disable it otherwise.  If called from Lisp, enable the mode
if ARG is omitted or nil.  If called interactively without ARG,
toggle brief-mode.

(fn &optional ARG)" t nil)
	     (buffer-expose-project-no-stars "Expose buffers of `projectile-project-buffers' omitting *special* ones.

If MAX is given it determines the maximum number of windows to
show per page, which defaults to `buffer-expose-max-num-windows'.

(fn &optional MAX)" t nil)
	     (buffer-expose-project-stars "Expose *special* buffers of `projectile-project-buffers'.

If MAX is given it determines the maximum number of windows to
show per page, which defaults to `buffer-expose-max-num-windows'.

(fn &optional MAX)" t nil)
	     (buffer-expose-project "Expose buffers of `projectile-project-buffers'.

If MAX is given it determines the maximum number of windows to
show per page, which defaults to `buffer-expose-max-num-windows'.

(fn &optional MAX)" t nil)
	     (buffer-expose-dired-buffers "Expose dired buffers of `buffer-list'.

If MAX is given it determines the maximum number of windows to
show per page, which defaults to `buffer-expose-max-num-windows'.

(fn &optional MAX)" t nil)
	     (buffer-expose-no-stars "Expose buffers of `buffer-list' omitting *special* ones.

If MAX is given it determines the maximum number of windows to
show per page, which defaults to
`buffer-expose-max-num-windows'.

(fn &optional MAX)" t nil)
	     (buffer-expose-stars "Expose *special* buffers of `buffer-list'.

If MAX is given it determines the maximum number of windows to
show per page, which defaults to `buffer-expose-max-num-windows'.

(fn &optional MAX)" t nil)
	     (buffer-expose-major-mode "Expose buffers with major mode MODE.

MAX is the maximum number of windows to show per page, which
defaults to `buffer-expose-max-num-windows'.

(fn MAX MODE)" t nil)
	     (buffer-expose-current-mode "Expose buffers with mode of current major mode.

MAX is the maximum number of windows to show per page, which
defaults to `buffer-expose-max-num-windows'.

(fn &optional MAX)" t nil)
	     (buffer-expose "Expose buffers of `buffer-list'.

If MAX is given it determines the maximum number of windows to
show per page, which defaults to `buffer-expose-max-num-windows'.

(fn &optional MAX)" t nil)
	     (buffer-expose-mode "Expose buffers.

If called interactively, toggle `Buffer-Expose mode'.  If the
prefix argument is positive, enable the mode, and if it is zero
or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

Instantiate bindings of `buffer-expose-mode-map'.

(fn &optional ARG)" t nil)
	     (bug-hunter-init-file "Test ASSERTION throughout `user-init-file'.
All sexps inside `user-init-file' are read and passed to
`bug-hunter-hunt' as a list.  See `bug-hunter-hunt' for how to use
ASSERTION.

(fn &optional ASSERTION)" t nil)
	     (bug-hunter-file "Bisect FILE while testing ASSERTION.
All sexps in FILE are read and passed to `bug-hunter-hunt' as a
list.  See `bug-hunter-hunt' for how to use ASSERTION.

(fn FILE &optional ASSERTION)" t nil)
	     (caps-lock-mode "Make self-inserting keys invert the capitalization.

If called interactively, toggle `Caps-Lock mode'.  If the prefix
argument is positive, enable the mode, and if it is zero or
negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (global-captain-mode "Toggle Captain mode in all buffers.
With prefix ARG, enable Global Captain mode if ARG is positive;
otherwise, disable it.  If called from Lisp, enable the mode if
ARG is omitted or nil.

Captain mode is enabled in all buffers where
`captain-mode' would do it.

See `captain-mode' for more information on
Captain mode.

(fn &optional ARG)" t nil)
	     (captain-mode "Call the captain to automatically capitalize the start of every sentence.

If called interactively, toggle `Captain mode'.  If the prefix
argument is positive, enable the mode, and if it is zero or
negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

The captain will also automatically capitalize words you've told
him you want capitalized with `captain-capitalize-word'.

\\{captain-mode-map}

(fn &optional ARG)" t nil)
	     (chess-tutorial "A simple chess training display." t nil)
	     (chess-fischer-random-position "Generate a Fischer Random style position." nil nil)
	     (chess-puzzle "Pick a random puzzle from FILE, and solve it against the default engine.
The spacebar in the display buffer is bound to `chess-puzzle-next',
making it easy to go on to the next puzzle once you've solved one.

(fn FILE &optional INDEX)" t nil)
	     (chess-pgn-mode "A mode for editing chess PGN files.

(fn)" t nil)
	     (chess-pgn-read "Read and display a PGN game after point.

(fn &optional FILE)" t nil)
	     (chess-link "Play out a game between two engines, and watch the progress.
If you want to run an engine as a bot, make the transport the first
engine, and the computer the second engine.

(fn FIRST-ENGINE-TYPE SECOND-ENGINE-TYPE)" t nil)
	     (chess-ics "Connect to an Internet Chess Server.

(fn SERVER PORT &optional HANDLE PASSWORD-OR-FILENAME HELPER &rest HELPER-ARGS)" t nil)
	     (chess-create-display "Create a display, letting the user's customization decide the style.
If MODULES-TOO is non-nil, also create and associate the modules
listed in `chess-default-modules'.

(fn PERSPECTIVE &optional MODULES-TOO)" nil nil)
	     (chess "Start a game of chess, playing against ENGINE (a module name).
With prefix argument, prompt for the engine to play against.
Otherwise use `chess-default-engine' to determine the engine.

(fn &optional ENGINE DISABLE-POPUP ENGINE-RESPONSE-HANDLER &rest ENGINE-CTOR-ARGS)" t nil)
	     (clipboard-collector-create "Create clipboard collector command named NAME.

Calling the command will start a timer which checks the clipboard
for changes. If the content of a clipboard change match a rule of
RULES with format of `clipboard-collector--rules', it is
collected according to the rule.

The command will enable `clipboard-collector-mode' which will
bind `clipboard-collector-finish' to finish collecting items
using FINISHF which defaults to
`clipboard-collector-finish-default'.

(fn NAME RULES &optional FINISHF)" nil t)
	     (clipboard-collector-mode "Start collecting clipboard items.

If called interactively, toggle `Clipboard-Collector mode'.  If
the prefix argument is positive, enable the mode, and if it is
zero or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

Rules used are defined in `clipboard-collector--rules'. Because
this mode is only for temporary use and you want its bindings to
have precedence over all other ones when activated,
`clipboard-collector-mode-map' is made transient while this mode
is active.

(fn &optional ARG)" t nil)
	     (cobol-mode "COBOL mode is a major mode for handling COBOL files.

(fn)" t nil)
	     (coffee-mode "Major mode for editing CoffeeScript.

(fn)" t nil)
	     (global-compact-docstrings-mode "Toggle Compact-Docstrings mode in all buffers.
With prefix ARG, enable Global Compact-Docstrings mode if ARG is positive;
otherwise, disable it.  If called from Lisp, enable the mode if
ARG is omitted or nil.

Compact-Docstrings mode is enabled in all buffers where
`compact-docstrings--mode-on' would do it.

See `compact-docstrings-mode' for more information on
Compact-Docstrings mode.

(fn &optional ARG)" t nil)
	     (compact-docstrings-mode "Shrink empty lines in docstrings and doc comments.

If called interactively, toggle `Compact-Docstrings mode'.  If
the prefix argument is positive, enable the mode, and if it is
zero or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (company-ebdb "`company-mode' completion backend for EBDB.

(fn COMMAND &optional ARG &rest IGNORE)" t nil)
	     (company-math-symbols-unicode "Company backend for insertion of Unicode mathematical symbols.
COMMAND and ARG is as required by company backends.
See the unicode-math page [1] for a list of fonts that have a
good support for mathematical symbols. Unicode provides only a
limited range of sub(super)scripts; see the wikipedia page [2]
for details.

 [1] http://ftp.snt.utwente.nl/pub/software/tex/help/Catalogue/entries/unicode-math.html
 [2] https://en.wikipedia.org/wiki/Unicode_subscripts_and_superscripts

(fn COMMAND &optional ARG &rest IGNORED)" t nil)
	     (company-math-symbols-latex "Company backend for LaTeX mathematical symbols.
COMMAND and ARG is as required by company backends.

(fn COMMAND &optional ARG &rest IGNORED)" t nil)
	     (company-latex-commands "Company backend for latex commands.
COMMAND and ARG is as required by company backends.

(fn COMMAND &optional ARG &rest IGNORED)" t nil)
	     (company-statistics-mode "Statistical sorting for company-mode.  Ranks completion candidates by
the frequency with which they have been chosen in recent (as given by
`company-statistics-size') history.

If called interactively, toggle `Company-Statistics mode'.  If the
prefix argument is positive, enable the mode, and if it is zero or
negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable the
mode if ARG is nil, omitted, or is a positive number.  Disable the
mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when it is
disabled.

Turning this mode on and off preserves the statistics.  They are also
preserved automatically between Emacs sessions in the default
configuration.  You can customize this behavior with
`company-statistics-auto-save', `company-statistics-auto-restore' and
`company-statistics-file'.

(fn &optional ARG)" t nil)
	     (context-coloring-js2-colorize "Color the buffer using the `js2-mode'." nil nil)
	     (context-coloring-eval-expression-predicate "Non-nil if the minibuffer is for `eval-expression'." nil nil)
	     (context-coloring-eval-expression-colorize "Color the `eval-expression' minibuffer prompt as elisp." t nil)
	     (context-coloring-elisp-colorize "Color the current Emacs Lisp buffer." t nil)
	     (context-coloring-mode "Toggle contextual code coloring.
With a prefix argument ARG, enable Context Coloring mode if ARG
is positive, and disable it otherwise.  If called from Lisp,
enable the mode if ARG is omitted or nil.

Context Coloring mode is a buffer-local minor mode.  When
enabled, code is colored by scope.  Scopes are colored
hierarchically.  Variables referenced from nested scopes retain
the color of their defining scopes.  Certain syntax, like
comments and strings, is still colored with `font-lock'.

The entire buffer is colored initially.  Changes to the buffer
trigger recoloring.

Define your own colors by customizing faces like
`context-coloring-level-N-face', where N is a number starting
from 0.  If no face is found on a custom theme nor the `user'
theme, the defaults are used.

New language / major mode support can be added with
`context-coloring-define-dispatch', which see.

Feature inspired by Douglas Crockford.

(fn &optional ARG)" t nil)
	     (cpio-mode "Treat cpio archives like file systems with a dired UI.

(fn)" t nil)
	     (cpio-discern-archive-type "Return a symbol reflecting the type of the cpio archive in the current buffer.
Values are `bin', `newc', `odc', `crc', `tar', `ustar', `hpbin', `hpodc',
or nil if the current buffer does not begin with a cpio entry header." nil nil)
	     (cpio-mode-find-file-hook "find-file hook to detect if a file is likely a cpio archive.
If it is, then put it under cpio-mode." nil nil)
	     (crisp-mode "Toggle CRiSP/Brief emulation (CRiSP mode).
With a prefix argument ARG, enable CRiSP mode if ARG is positive,
and disable it otherwise.  If called from Lisp, enable the mode
if ARG is omitted or nil.

(fn &optional ARG)" t nil)
	     (tsv-mode "Major mode for editing files of tab-separated value type.

(fn)" t nil)
	     (csv-mode "Major mode for editing files of comma-separated value type.

CSV mode is derived from `text-mode', and runs `text-mode-hook' before
running `csv-mode-hook'.  It turns `auto-fill-mode' off by default.
CSV mode can be customized by user options in the CSV customization
group.  The separators are specified by the value of `csv-separators'.

CSV mode commands ignore blank lines and comment lines beginning with
the value of `csv-comment-start', which delimit \"paragraphs\".
\"Sexp\" is re-interpreted to mean \"field\", so that `forward-sexp'
(\\[forward-sexp]), `kill-sexp' (\\[kill-sexp]), etc. all apply to fields.
Standard comment commands apply, such as `comment-dwim' (\\[comment-dwim]).

If `font-lock-mode' is enabled then separators, quoted values and
comment lines are highlighted using respectively `csv-separator-face',
`font-lock-string-face' and `font-lock-comment-face'.

The user interface (UI) for CSV mode commands is similar to that of
the standard commands `sort-fields' and `sort-numeric-fields', except
that if there is no prefix argument then the UI prompts for the field
index or indices.  In `transient-mark-mode' only: if the region is not
set then the UI attempts to set it to include all consecutive CSV
records around point, and prompts for confirmation; if there is no
prefix argument then the UI prompts for it, offering as a default the
index of the field containing point if the region was not set
explicitly.  The region set automatically is delimited by blank lines
and comment lines, and the number of header lines at the beginning of
the region given by the value of `csv-header-lines' are skipped.

Sort order is controlled by `csv-descending'.

CSV mode provides the following specific keyboard key bindings:

\\{csv-mode-map}

(fn)" t nil)
	     (cycle-quotes "Cycle between string quote styles." t nil)
	     (darkroom-tentative-mode "Enters `darkroom-mode' when all other windows are deleted.

If called interactively, toggle `DarkRoom-Tentative mode'.  If
the prefix argument is positive, enable the mode, and if it is
zero or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (darkroom-mode "Remove visual distractions and focus on writing. When this
mode is active, everything but the buffer's text is elided from
view. The buffer margins are set so that text is centered on
screen. Text size is increased (display engine allowing) by
`darkroom-text-scale-increase'.

If called interactively, toggle `Darkroom mode'.  If the prefix
argument is positive, enable the mode, and if it is zero or
negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (dbus-codegen-make-proxy "Create a new D-Bus proxy based on the introspection data.

If the data type of the D-Bus proxy is not yet defined, this will
define it with `dbus-codegen-define-proxy', under a type name NAME.

BUS is either a Lisp symbol, `:system' or `:session', or a string
denoting the bus address.

SERVICE is the D-Bus service name to be used.  PATH is the D-Bus
object path SERVICE is registered at.  INTERFACE is an interface
offered by SERVICE.

INTERFACE is an interface which is represented by this proxy.

ARGS are keyword-value pair.  Currently only one keyword is
supported:

:redefine FLAG -- if FLAG is non-nil, redefine the data type and
associated functions.

Other keywords are same as `dbus-codegen-define-proxy'.

(fn NAME BUS SERVICE PATH INTERFACE &rest ARGS)" nil nil)
	     (dbus-codegen-define-proxy "Define a new D-Bus proxy NAME.
This defines a new struct type for the proxy and convenient
functions for D-Bus method calls and signal registration.

XML is either a string which defines the interface of the D-Bus
proxy, or a Lisp form which returns a string.  The format of the
string must comply with the standard D-Bus introspection data
format as described in:
`http://dbus.freedesktop.org/doc/dbus-specification.html#introspection-format'.

INTERFACE is a name of interface which is represented by this
proxy.

ARGS are keyword-value pair.  Currently only one keyword is
supported:

:transform-name FUNCTION -- FUNCTION is a function which converts
D-Bus method/signal/property names, into another representation.
By default `dbus-codegen-transform-name' is used.

(fn NAME XML INTERFACE &rest ARGS)" nil t)
	     (delight "Modify the lighter value displayed in the mode line for the given mode SPEC
if and when the mode is loaded.

SPEC can be either a mode symbol, or a list containing multiple elements of
the form (MODE VALUE FILE).  In the latter case the two optional arguments are
omitted, as they are instead specified for each element of the list.

For minor modes, VALUE is the replacement lighter value (or nil to disable)
to set in the `minor-mode-alist' variable.  For major modes VALUE is the
replacement buffer-local `mode-name' value to use when a buffer changes to
that mode.

In both cases VALUE is commonly a string, but may in fact contain any valid
mode line construct.  For details see the `mode-line-format' variable, and
Info node `(elisp) Mode Line Format'.

The FILE argument is passed through to `eval-after-load'.  If FILE is nil then
the mode symbol is passed as the required feature.  If FILE is t then it is
assumed that the mode is already loaded.  (Note that you can also use \\='emacs
for this purpose).  These FILE options are relevant to minor modes only.

For major modes you should specify the keyword :major as the value of FILE,
to prevent the mode being treated as a minor mode.

(fn SPEC &optional VALUE FILE)" nil nil)
	     (read-dict "Read the name of a dictionary with completion, and return it.

Prompt with PROMPT. By default, return DEFAULT. If DICTLIST is
supplied, only complete on dictionaries in that list.

If ALLOW-UNLOADED is non-nil, also complete on the names of
unloaded dictionaries (actually, on any Elisp file in the current
`load-path' restricted to subdirectories of your home directory
whose file name starts with \"dict-\"). If an unloaded dictionary
is read, the name of the Elisp file will be returned, without
extension, suitable for passing to `load-library'.

(fn PROMPT &optional DEFAULT DICTLIST ALLOW-UNLOADED ALLOW-UNMATCHED)" nil nil)
	     (dictree-load "Load a dictionary object from file FILE.
Returns the dictionary if successful, nil otherwise.

Interactively, FILE is read from the mini-buffer.

(fn FILE)" t nil)
	     (dictree-p "Return t if OBJ is a dictionary tree, nil otherwise.

(fn OBJ)" nil nil)
	     (make-dictree-meta-dict "Create a meta-dictionary based on the list of dictionaries
in DICTIONARY-LIST.

COMBINE-FUNCTION is used to combine data from different
dictionaries. It is passed two pieces of data, each an
association of the same key, but in different dictionaries. It
should return a combined datum.

The other arguments are as for `dictree-create'. Note that
caching is only possible if NAME is supplied, otherwise the
CACHE-THRESHOLD argument is ignored and caching is disabled.

(fn DICTIONARY-LIST &optional NAME FILENAME AUTOSAVE UNLISTED COMBINE-FUNCTION CACHE-POLICY CACHE-THRESHOLD CACHE-UPDATE-POLICY)" nil nil)
	     (make-dictree-custom "Create an empty dictionary and return it.

The NAME through PLIST-LOADFUN arguments are as for
`dictree-create' (which see).

The remaining arguments control the type of trie to use as the
underlying data structure. See `trie-create' for details.

(fn &optional NAME FILENAME AUTOSAVE UNLISTED &key COMPARISON-FUNCTION INSERT-FUNCTION RANK-FUNCTION CACHE-POLICY CACHE-THRESHOLD CACHE-UPDATE-POLICY KEY-SAVEFUN KEY-LOADFUN DATA-SAVEFUN DATA-LOADFUN PLIST-SAVEFUN PLIST-LOADFUN CREATEFUN INSERTFUN DELETEFUN LOOKUPFUN MAPFUN EMPTYFUN STACK-CREATEFUN STACK-POPFUN STACK-EMPTYFUN TRANSFORM-FOR-PRINT TRANSFORM-FROM-READ)" nil nil)
	     (make-dictree "Create an empty dictionary and return it.

If NAME is supplied, the dictionary is stored in the variable
NAME, and saved to a file named \"NAME.el(c)\".

FILENAME sets the default file name to use when saving the
dictionary. If the AUTOSAVE flag is non-nil, then the dictionary
will automatically be saved to this file when it is unloaded or
when exiting Emacs. If FIlENAME is a directory, then it will be
saved to a file called \"NAME.el(c)\" under that directory.

If UNLISTED is non-nil, the dictionary will not be recorded in
the list of loaded dictionaries. Note that this disables
autosaving.

COMPARISON-FUNCTION sets the function used to compare elements of
the keys. It should take two arguments, A and B, both of the type
contained by the sequences used as keys (e.g. if the keys will
be strings, the function will be passed two characters). It
should return t if the first is strictly \"less than\" the
second. Defaults to `<'.

INSERT-FUNCTION sets the function used to insert data into the
dictionary. It should take two arguments: the new data, and the
data already in the dictionary, and should return the data to
insert. Defaults to replacing any existing data with the new
data.

RANK-FUNCTION sets the function used to rank the results of
`dictree-complete'. It should take two arguments, each a cons
whose car is a dictree key (a sequence) and whose cdr is the data
associated with that key. It should return non-nil if the first
argument is \"better\" than the second, nil otherwise. It
defaults to \"lexicographic\" comparison of the keys, ignoring
the data (which is not very useful, since an unranked
`dictree-complete' query already does this much more
efficiently).

CACHE-POLICY should be a symbol (`time', `length',
`time-and-length' or `time-or-length'), which determines which
query operations are cached. The `time' setting caches queries
that take longer (in seconds) than the CACHE-THRESHOLD value.

The `length' setting caches query operations based on the length
of the string involved the query. For this setting, CACHE-POLICY
should be a plist with properties :long and :short. Lookups,
fuzzy matches, and regexp queries that do not end in \".*\" will
be cached if the string is longer than the :long value (since
long strings are likely to be the slower ones in these
cases). Completions, fuzzy completions, and regexp queries that
end in \".*\" will be cached if the string or regexp is shorter
than the :short value (since short strings are likely to be the
slower ones for those cases).

The `time-and-length' setting only caches results if both
conditions are satisfied simultaneously, whereas the
`time-or-length' setting caches results if either condition is
satisfied. For these settings, CACHE-THRESHOLD must be a plist
with properties :time, :long and :short, specifying the
corresponding cache thresholds.

CACHE-THRESHOLD defaults to nil. The values nil and t are
special. If CACHE-THRESHOLD is set to nil, no caching is done. If
it is t, everything is cached for that type of query (similar
behaviour can be obtained by setting the a `time' CACHE-THRESHOLD
of 0, but it is better to use t).

CACHE-UPDATE-POLICY should be a symbol (`synchronize' or
`delete'), which determines how the caches are updated when data
is inserted or deleted. The former updates tainted cache entries,
which makes queries faster but insertion and deletion slower,
whereas the latter deletes any tainted cache entries, which makes
queries slower but insertion and deletion faster.

KEY-SAVEFUN, DATA-SAVEFUN and PLIST-SAVEFUN are functions used to
convert keys, data and property lists into lisp objects that have
a valid read syntax, for writing to file. DATA-SAVEFUN and
PLIST-SAVEFUN are used when saving the dictionary (see
`dictree-save' and `dictree-write'), and all three functions are
used when dumping the contents of the dictionary (see
`dictree-dump-to-buffer' and `dictree-dump-to-file').
KEY-SAVEFUN, DATA-SAVEFUN and PLIST-SAVEFUN should each accept
one argument: a key, data or property list from DICT,
respectively. They should return a lisp object which has a valid
read syntax. When defining these functions, be careful not to
accidentally modify the lisp object in the dictionary; usually,
you will need to make a copy before converting it.

KEY-LOADFUN, DATA-LOADFUN and PLIST-LOADFUN are used to convert
keys, data and property lists back again when loading a
dictionary (only DATA-LOADFUN and PLIST-LOADFUN, see
`dictree-save' and `dictree-write') or populating it from a
file (all three, see `dictree-populate-from-file'). They should
accept one argument: a lisp object of the type produced by the
corresponding SAVEFUN, and return a lisp object to use in the
loaded dictionary.

TRIE-TYPE sets the type of trie to use as the underlying data
structure. See `trie-create' for details.

(fn &optional NAME FILENAME AUTOSAVE UNLISTED COMPARISON-FUNCTION INSERT-FUNCTION RANK-FUNCTION CACHE-POLICY CACHE-THRESHOLD CACHE-UPDATE-POLICY KEY-SAVEFUN KEY-LOADFUN DATA-SAVEFUN DATA-LOADFUN PLIST-SAVEFUN PLIST-LOADFUN TRIE-TYPE)" nil nil)
	     (diff-hl-margin-mode "Toggle displaying `diff-hl-mode' highlights on the margin.

If called interactively, toggle `Diff-Hl-Margin mode'.  If the
prefix argument is positive, enable the mode, and if it is zero
or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (diff-hl-flydiff-mode "Perform highlighting on-the-fly.
This is a global minor mode.  It alters how `diff-hl-mode' works.

If called interactively, toggle `Diff-Hl-Flydiff mode'.  If the
prefix argument is positive, enable the mode, and if it is zero
or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (diff-hl-dired-mode-unless-remote nil nil nil)
	     (diff-hl-dired-mode "Toggle VC diff highlighting on the side of a Dired window.

If called interactively, toggle `Diff-Hl-Dired mode'.  If the
prefix argument is positive, enable the mode, and if it is zero
or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (global-diff-hl-amend-mode "Toggle Diff-Hl-Amend mode in all buffers.
With prefix ARG, enable Global Diff-Hl-Amend mode if ARG is
positive; otherwise, disable it.  If called from Lisp, enable the mode if ARG
is omitted or nil.

Diff-Hl-Amend mode is enabled in all buffers where
`turn-on-diff-hl-amend-mode' would do it.

See `diff-hl-amend-mode' for more information on Diff-Hl-Amend mode.

(fn &optional ARG)" t nil)
	     (diff-hl-amend-mode "Show changes against the second-last revision in `diff-hl-mode'.
Most useful with backends that support rewriting local commits,
and most importantly, \"amending\" the most recent one.
Currently only supports Git, Mercurial and Bazaar.

If called interactively, toggle `Diff-Hl-Amend mode'.  If the
prefix argument is positive, enable the mode, and if it is zero
or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (global-diff-hl-mode "Toggle Diff-Hl mode in all buffers.
With prefix ARG, enable Global Diff-Hl mode if ARG is positive;
otherwise, disable it.  If called from Lisp, enable the mode if ARG is
omitted or nil.

Diff-Hl mode is enabled in all buffers where
`diff-hl--global-turn-on' would do it.

See `diff-hl-mode' for more information on Diff-Hl mode.

(fn &optional ARG)" t nil)
	     (diff-hl--global-turn-on "Call `turn-on-diff-hl-mode' if the current major mode is applicable." nil nil)
	     (turn-on-diff-hl-mode "Turn on `diff-hl-mode' or `diff-hl-dir-mode' in a buffer if appropriate." nil nil)
	     (diff-hl-mode "Toggle VC diff highlighting.

If called interactively, toggle `Diff-Hl mode'.  If the prefix
argument is positive, enable the mode, and if it is zero or
negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (diffview-message "Show `message-mode' buffer in a side-by-side view.

This is useful for reading patches from mailing lists." t nil)
	     (diffview-region "Show current diff region in a side-by-side view." t nil)
	     (diffview-current "Show current diff buffer in a side-by-side view." t nil)
	     (dired-du-insert-marked-dirs "Insert all marked subdirectories." t nil)
	     (dired-du-count-sizes "Count sizes of files marked with MARK.
If MARK evaluates nil, then use `dired-marker-char'.

Optional arg ALL-MARKS, if non-nil, then accept all mark characters.

Optional arg INCLUDE-DIRS, if non-nil, include the recursive size of the
marked directories.
If called interactively with a prefix, then prompt for previous
args.  Otherwise, all optional arguments but INCLUDE-DIRS are nil, and
INCLUDE-DIRS is set to variable `dired-du-mode'.

Directories '.' '..' are not special: if they are marked, then return
their recursive size.

(fn MARK &optional ALL-MARKS INCLUDE-DIRS)" t nil)
	     (dired-du-mode "Toggle dired-du mode.
Interactively with no argument, this command toggles the mode.
A positive prefix argument enables the mode, any other prefix
argument disables it.  From Lisp, argument omitted or nil enables
the mode, `toggle' toggles the state.

If called interactively, toggle `Dired-Du mode'.  If the prefix
argument is positive, enable the mode, and if it is zero or
negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

Show the recursive size of directories in Dired buffers.
Once this mode is enabled, every new Dired buffer displays
recursive dir sizes.
The directory size is obtained with `dired-du-used-space-program'.

Note that obtaining the recursive size of all the directories
in a Dired buffer might be slow; thus, it may significantly delay
the time to display a new Dired buffer.

Instead of enabling `dired-du-mode' by default in all Dired buffers
you might prefer to use this mode as a convenient interface to
the `du' program: just enable it in the current Dired buffer,
and disable it once you have finished checking the used space.

(fn &optional ARG)" t nil)
	     (dired-git-info-auto-enable "Enable `dired-git-info-mode' if current dired buffer is in a git repo.

Add this function to `dired-after-readin-hook' to enable the mode
automatically inside git repos." nil nil)
	     (dired-git-info-mode "Toggle git message info in current dired buffer.

If called interactively, toggle `Dired-Git-Info mode'.  If the
prefix argument is positive, enable the mode, and if it is zero
or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (disk-usage-by-types-here "Run `disk-usage-by-types' in current directory." t nil)
	     (disk-usage-by-types "

(fn &optional DIRECTORY)" t nil)
	     (disk-usage-here "Run `disk-usage' in current directory." t nil)
	     (disk-usage "Display listing of files in DIRECTORY with their size.
If DIRECTORY is nil, use current directory.

(fn &optional DIRECTORY)" t nil)
	     (log-session-mode "Minor mode to log a session (keystrokes, timestamps etc).

If called interactively, toggle `Log-Session mode'.  If the
prefix argument is positive, enable the mode, and if it is zero
or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (dismal-mode "A major mode for editing SpreadSheets.
A command menu is available by typing C-c C-m (C-m is also RET).
\\[dis-copy-to-dismal] will paste text from another buffer into dismal.
The left mouse button is bound to `dis-mouse-highlight-cell-or-range'
and right mouse button is bound to `dis-mouse-highlight-row'.

 Special commands:
\\{dismal-map}

 Special commands:
\\{dismal-minibuffer-map}
" t nil)
	     (djvu-bookmark-handler "Handler to jump to a particular bookmark location in a djvu document.
BMK is a bookmark record, not a bookmark name (i.e., not a string).
Changes current buffer and point and returns nil, or signals a `file-error'.

(fn BMK)" nil nil)
	     (djvu-inspect-file "Inspect Djvu FILE on PAGE.
Call djvused with the same sequence of arguments that is used
by `djvu-init-page'.  Display the output in `djvu-script-buffer'.
This may come handy if `djvu-find-file' chokes on a Djvu file.

(fn FILE &optional PAGE)" t nil)
	     (djvu-find-file "Read and edit Djvu FILE on PAGE.  Return Read buffer.
If VIEW is non-nil start external viewer.
If NOSELECT is non-nil visit FILE, but do not make it current.
If NOCONFIRM is non-nil don't ask for confirmation when reverting buffer
from file.

(fn FILE &optional PAGE VIEW NOSELECT NOCONFIRM)" t nil)
	     (djvu-dummy-mode "Djvu dummy mode for `auto-mode-alist'." nil nil)
	     (docbook-find-file "Visit FILENAME as a DocBook document.

(fn FILENAME)" t nil)
	     (dts-mode "Major mode for editing Device Tree source files.

(fn)" t nil)
	     (easy-mark "Similar to `easy-kill' (which see) but for marking.

(fn &optional N)" t nil)
	     (easy-kill "Kill thing at point in the order of region, url, email and line.
Temporally activate additional key bindings as follows:

  letters => select or expand selection according to `easy-kill-alist';
  1..9    => expand selection by that number;
  0       => shrink to the initial selection;
  +,=/-   => expand or shrink selection;
  @       => append selection to previous kill;
  ?       => help;
  C-w     => kill selection;
  C-SPC   => turn selection into an active region;
  C-g     => abort;
  others  => save selection and exit.

(fn &optional N)" t nil)
	     (copy-gnorb-ebdb-link nil nil nil)
	     (gnorb-ebdb-link-id "Access slot \"id\" of `gnorb-ebdb-link' struct X.

(fn X)" nil nil)
	     (gnorb-ebdb-link-group "Access slot \"group\" of `gnorb-ebdb-link' struct X.

(fn X)" nil nil)
	     (gnorb-ebdb-link-date "Access slot \"date\" of `gnorb-ebdb-link' struct X.

(fn X)" nil nil)
	     (gnorb-ebdb-link-subject "Access slot \"subject\" of `gnorb-ebdb-link' struct X.

(fn X)" nil nil)
	     (gnorb-ebdb-link-p "

(fn X)" nil nil)
	     (ediprolog-localize "After `ediprolog-localize', any Prolog process started from
this buffer becomes buffer-local." t nil)
	     (ediprolog-consult "Buffer is loaded into a Prolog process. If NEW-PROCESS is
non-nil, start a new process. Otherwise use the existing process,
if any. In case of errors, point is moved to the position of the
first error, and the mark is left at the previous position.

In transient mark mode, if the region is active, the function
operates on the region.

(fn &optional NEW-PROCESS)" t nil)
	     (ediprolog-remove-interactions "Remove all lines starting with `ediprolog-prefix' from buffer.

In transient mark mode, if the region is active, the function
operates on the region." t nil)
	     (ediprolog-interact "Send QUERY to Prolog process and interact as on a terminal.

You can use \\[keyboard-quit] to unblock Emacs in the case of
longer-running queries. When the query completes and the toplevel
asks for input, use \\[ediprolog-toplevel] to resume interaction
with the Prolog process.

(fn QUERY)" nil nil)
	     (ediprolog-dwim "Load current buffer into Prolog or post query (Do What I Mean).
If invoked on a line starting with `:-' or `?-', possibly
preceded by `%' and whitespace, call `ediprolog-interact' with
the query as argument. Otherwise, call `ediprolog-consult'.

With prefix argument 0, kill the Prolog process. With prefix 1,
equivalent to `ediprolog-consult'. With prefix 2, equivalent to
`ediprolog-consult' with a new Prolog process. With prefix 7,
equivalent to `ediprolog-toplevel'. With just C-u, first call
`ediprolog-consult' and then, if point is on a query, call
`ediprolog-interact' with it as argument. Analogously, C-u C-u
for `ediprolog-consult' with a new process. With other prefix
arguments, equivalent to `ediprolog-remove-interactions'.

(fn &optional ARG)" t nil)
	     (eev-beginner "Load all basic modules of eev, turn eev-mode on, and open a tutorial." t nil)
	     (eglot-ensure "Start Eglot session for current buffer if there isn't one." nil nil)
	     (eglot "Manage a project with a Language Server Protocol (LSP) server.

The LSP server of CLASS started (or contacted) via CONTACT.  If
this operation is successful, current *and future* file buffers
of MANAGED-MAJOR-MODE inside PROJECT automatically become
\"managed\" by the LSP server, meaning information about their
contents is exchanged periodically to provide enhanced
code-analysis via `xref-find-definitions', `flymake-mode',
`eldoc-mode', `completion-at-point', among others.

Interactively, the command attempts to guess MANAGED-MAJOR-MODE
from current buffer, CLASS and CONTACT from
`eglot-server-programs' and PROJECT from `project-current'.  If
it can't guess, the user is prompted.  With a single
\\[universal-argument] prefix arg, it always prompt for COMMAND.
With two \\[universal-argument] prefix args, also prompts for
MANAGED-MAJOR-MODE.

PROJECT is a project instance as returned by `project-current'.

CLASS is a subclass of symbol `eglot-lsp-server'.

CONTACT specifies how to contact the server.  It is a
keyword-value plist used to initialize CLASS or a plain list as
described in `eglot-server-programs', which see.

INTERACTIVE is t if called interactively.

(fn MANAGED-MAJOR-MODE PROJECT CLASS CONTACT &optional INTERACTIVE)" t nil)
	     (eldoc-eval-expression "Eval expression with eldoc support in mode-line." t nil)
	     (eldoc-in-minibuffer-mode "Show eldoc for current minibuffer input.

If called interactively, toggle `Eldoc-In-Minibuffer mode'.  If
the prefix argument is positive, enable the mode, and if it is
zero or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (electric-spacing-mode "Toggle automatic surrounding space insertion (Electric Spacing mode).
With a prefix argument ARG, enable Electric Spacing mode if ARG is
positive, and disable it otherwise.  If called from Lisp, enable
the mode if ARG is omitted or nil.

This is a local minor mode.  When enabled, typing an operator automatically
inserts surrounding spaces.  e.g., `=' becomes ` = ', `+=' becomes ` += '.
This is very handy for many programming languages.

(fn &optional ARG)" t nil)
	     (elisp-benchmarks-run "Run all the benchmarks and present the results.
If non nil SELECTOR is a regexp to match the benchmark names to be executed.
The test is repeated RUNS number of times.  If RUNS is nil `elb-runs' is used as
default.
RECOMPILE all the benchmark folder when non nil.

(fn &optional SELECTOR (RECOMPILE t) RUNS)" t nil)
	     (enwc-register-backend "Register the backend KEY with DEFINITION.

Signals an error if a backend with KEY already exists and FORCEP is nil.

(fn DEFINITION &optional FORCEP)" nil nil)
	     (enwc "The main front-end to ENWC.
This sets up the buffer and scans for networks.
In order to use this, one must have already run
`enwc-setup'.

\\{enwc-mode-map}" t nil)
	     (epoch-view-mode "Visualize epoch (Unix) timestamps.

If called interactively, toggle `Epoch-View mode'.  If the prefix
argument is positive, enable the mode, and if it is zero or
negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (exco-org-show-day "Show meetings for the date specified by MONTH DAY YEAR.

(fn MONTH DAY YEAR)" nil nil)
	     (excorporate-diary-enable "Enable Excorporate diary support." t nil)
	     (exco-calfw-show-day "Show meetings for the date specified by MONTH DAY YEAR.

(fn MONTH DAY YEAR)" nil nil)
	     (excorporate "Start Excorporate.
If `excorporate-configuration' is non-nil, use it without
prompting, otherwise prompt for Exchange account information, starting
with an email address.

Prefixed with one \\[universal-argument], always prompt for
Exchange account information for a new web service connection.
ARGUMENT is the prefix argument.

(fn &optional ARGUMENT)" t nil)
	     (er/expand-region "Increase selected region by semantic units.

With prefix argument expands the region that many times.
If prefix argument is negative calls `er/contract-region'.
If prefix argument is 0 it resets point and mark to their state
before calling `er/expand-region' for the first time.

(fn ARG)" t nil)
	     (filladapt-mode "Toggle Filladapt minor mode.
With arg, turn Filladapt mode on iff arg is positive.  When
Filladapt mode is enabled, auto-fill-mode and the fill-paragraph
command are both smarter about guessing a proper fill-prefix and
finding paragraph boundaries when bulleted and indented lines and
paragraphs are used.

(fn &optional ARG)" t nil)
	     (frame-tabs-mode "Toggle display of a buffer tabs side window on each frame.
With a prefix argument ARG, enable this mode if ARG is positive,
and disable it otherwise.  If called from Lisp, enable the mode
if ARG is omitted or nil.

When this mode is enabled, every normal frame is equipped with a
side window showing tabs for all buffers that appeared on that
frame.

(fn &optional ARG)" t nil)
	     (frog-menu-read "Read from a menu of variable `frog-menu-type'.

PROMPT is a string with prompt information for the user.

COLLECTION is a list from which the user can choose an item. It
can be a list of strings or an alist mapping strings to return
values. Users can switch to `completing-read' from COLLECTION
using the TAB key. For sorting the displayed strings see
`frog-menu-sort-function'.

ACTIONS is an additional list of actions that can be given to let
the user choose an action instead an item from COLLECTION.

Each ACTION is a list of the form:

    (KEY DESCRIPTION RETURN)

Where KEY is a string to be interpreted as spelled-out
keystrokes, using the same format as for `kbd'.

DESCRIPTION is a string to be displayed along with KEY to
describe the action.

RETURN will be the returned value if KEY is pressed.

(fn PROMPT COLLECTION &optional ACTIONS)" nil nil)
	     (frog-menu-call "Read a command from CMDS and execute it.

CMDS is of format as specified by `completing-read'
collections. If PROMPT is given it should be a string with prompt
information for the user.

(fn CMDS &optional PROMPT)" nil nil)
	     (gcmh-mode "Minor mode to tweak Garbage Collection strategy.

If called interactively, toggle `Gcmh mode'.  If the prefix
argument is positive, enable the mode, and if it is zero or
negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (ggtags-try-complete-tag "A function suitable for `hippie-expand-try-functions-list'.

(fn OLD)" nil nil)
	     (ggtags-build-imenu-index "A function suitable for `imenu-create-index-function'." nil nil)
	     (ggtags-mode "Toggle Ggtags mode on or off.

If called interactively, toggle `Ggtags mode'.  If the prefix
argument is positive, enable the mode, and if it is zero or
negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

\\{ggtags-mode-map}

(fn &optional ARG)" t nil)
	     (ggtags-find-tag-dwim "Find NAME by context.
If point is at a definition tag, find references, and vice versa.
If point is at a line that matches `ggtags-include-pattern', find
the include file instead.

When called interactively with a prefix arg, always find
definition tags.

(fn NAME &optional WHAT)" t nil)
	     (ggtags-find-project nil nil nil)
	     (gited-list-branches "List all branches or tags for the current repository.
Optional arg PATTERN if non-nil, then must be \"local\", \"remote\",
 or \"tags\".  That lists local branches, remote branches and tags,
 respectively.  When PATTERN is nil, then list the local branches.
Optional arg OTHER-WINDOW means to display the Gited buffer in another window.
Optional arg UPDATE if non-nil, then force to update the gited buffer.
 Otherwise, just switch to the Gited buffer if already exists.
When called interactively prompt for PATTERN.
When called interactively with a prefix set OTHER-WINDOW non-nil.

(fn &optional PATTERN OTHER-WINDOW UPDATE)" t nil)
	     (gle-mode "Major mode to edit Graphics Layout Engine files.

(fn)" t nil)
	     (gnome-c-style-mode "A minor-mode for editing GNOME-style C source code.

If called interactively, toggle `GNOME-C-Style mode'.  If the
prefix argument is positive, enable the mode, and if it is zero
or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (gnome-c-snippet-insert "

(fn COMMAND)" t nil)
	     (gnome-c-snippet-insert-PackageClass "Insert the class name (in CamelCase) before the current point.

(fn PACKAGE CLASS)" t nil)
	     (gnome-c-snippet-insert-PACKAGE_CLASS "Insert the class name before the current point.

(fn PACKAGE CLASS)" t nil)
	     (gnome-c-snippet-insert-package_class "Insert the class name before the current point.

(fn PACKAGE CLASS)" t nil)
	     (gnome-c-align-decls-region "Reformat function declarations in the region between BEG and END.

The `gnome-c-align-identifier-start-column',
`gnome-c-align-arglist-start-column', and
`gnome-c-align-arglist-identifier-start-column' variables
control the widths.

To set those variables, use \\[gnome-c-align-set-column],
\\[gnome-c-align-guess-columns], or
\\[gnome-c-align-guess-optimal-columns].

If they are not set, this function internally calls
\\[gnome-c-align-guess-optimal-columns] before formatting.

(fn BEG END)" t nil)
	     (gnome-c-align-guess-columns "Guess the existing alignment rule from the declarations in BEG and END.

This sets `gnome-c-align-identifier-start-column',
`gnome-c-align-arglist-start-column', and
`gnome-c-align-arglist-identifier-start-column'.

(fn BEG END)" t nil)
	     (gnome-c-align-guess-optimal-columns "Compute the optimal alignment rule from the declarations in BEG and END.

This sets `gnome-c-align-identifier-start-column',
`gnome-c-align-arglist-start-column', and
`gnome-c-align-arglist-identifier-start-column'.

(fn BEG END)" t nil)
	     (gnome-c-align-set-column "Set alignment column of SYMBOL.

(fn SYMBOL)" t nil)
	     (gnome-c-align-arglist-at-point "Reformat argument list at point, aligning argument to the right end.

(fn &optional IDENTIFIER-START-COLUMN)" t nil)
	     (gnu-elpa-keyring-update "Import new GNU ELPA keys (if any) into package.el's keyring." nil nil)
	     (gnugo-imgen-create-xpms "Return a list of XPM images suitable for BOARD-SIZE.
The size and style of the images are determined by
`gnugo-imgen-sizing-function' (rounded down to an even number)
and `gnugo-imgen-style', respectively.  See `gnugo-xpms'.

The returned list is cached; see also `gnugo-imgen-clear-cache'.

(fn BOARD-SIZE)" nil nil)
	     (gnugo-frolic-in-the-leaves "Display the game tree in a *GNUGO Frolic* buffer.
This looks something like:

  1 B  --  E7    E7    E7    E7
  2 W  --  K10   K10   K10   K10
  3 B  --  E2    E2    E2    E2
  4 W  --  J3    J3    J3    J3
  5 B  --  A6    A6    A6    A6
  6 W  --  C9    C9    C9    C9
           │
           ├─────┬─────┐
           │     │     │
  7 B  --  H7   !B8    C8    C8
                       │
                       ├─────┐
                       │     │
  8 W  --  D9    D9    D9    E9
  9 B  --              H8    H8
 10 W  --              PASS  PASS
 11 B  --              H5    PASS
 12 W  --              PASS
 13 B  --             *PASS

with 0, 1, ... N (in this case N is 3) in the header line
to indicate the branches.  Branch 0 is the \"main line\".
Point (* in this example) indicates the current position,
\"!\" indicates comment properties (e.g., B8, branch 1),
and moves not actually on the game tree (e.g., E7, branch 3)
are dimmed.  Type \\[describe-mode] in that buffer for details." t nil)
	     (gnugo "Run gnugo in a buffer, or resume a game in progress.
If there is already a game in progress you may resume it instead
of starting a new one.  Prefix arg means skip the game-in-progress
check and start a new game straight away.

Before starting, Emacs queries you for additional command-line
options (Emacs supplies \"--mode gtp --quiet\" automatically).

Note that specifying \"--infile FILENAME\" (or, \"-l FILENAME\")
silently clobbers certain other options, such as \"--color\".
For details, see info node `(gnugo) Invoking GNU Go'.

\\<gnugo-board-mode-map>
To play, use \\[gnugo-move] to place a stone or \\[gnugo-pass] to pass.
See `gnugo-board-mode' for a full list of commands.

(fn &optional NEW-GAME)" t nil)
	     (gnus-mock-resume "Resume a previous Gnus mock session.
If your testing involves shutting Emacs down completely and
restarting it, this command can be used to do that.  INIT-FILE
should be the init file saved into the temporary directory
created by the previous session.

In order for this to work you'll have to prevent the previous
Gnus mock session from deleting its temporary directory, either
by setting `gnus-mock-cleanup-p' to nil before starting that
session, or removing the cleanup lambda form from
`kill-emacs-hook'.

(fn INIT-FILE)" t nil)
	     (gnus-mock-start "Start a new Emacs process, with the Gnus mock setup.
The new Emacs process will be started as \"-Q\", with the mock
Gnus settings pre-loaded.  Any of the normal Gnus entry points
will start a mock Gnus session." t nil)
	     (gpastel-mode "Listen to GPaste events.

If called interactively, toggle `Gpastel mode'.  If the prefix
argument is positive, enable the mode, and if it is zero or
negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (greader-speechd "greader speech-dispatcher back-end.

(fn COMMAND &optional ARG &rest _)" nil nil)
	     (greader-espeak "back-end main function of greader-espeak.

(fn COMMAND &optional ARG &rest _)" nil nil)
	     (greenbar-mode "Enable \"green bar striping\" of comint output

If called interactively, toggle `Greenbar mode'.  If the prefix
argument is positive, enable the mode, and if it is zero or
negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (guess-language-mode "Toggle guess-language mode.

If called interactively, toggle `Guess-Language mode'.  If the
prefix argument is positive, enable the mode, and if it is zero
or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

Interactively with no argument, this command toggles the mode.
A positive prefix argument enables the mode, any other prefix
argument disables it.  From Lisp, argument omitted or nil enables
the mode, `toggle' toggles the state.

Guess-language is a buffer-local minor mode.  It guesses the
language of the current paragraph when flyspell detects an
incorrect word and changes ispell's dictionary and typo-mode
accordingly.  If the language settings change, flyspell is rerun
on the current paragraph.  If the paragraph is shorter than
`guess-language-min-paragraph-length', none of the above happens
because there is likely not enough text to guess the language
correctly.

(fn &optional ARG)" t nil)
	     (make-heap "Create an empty heap with comparison function COMPARE-FUNCTION.

COMPARE-FUNCTION takes two arguments, A and B, and returns
non-nil or nil. To implement a max-heap, it should return non-nil
if A is greater than B. To implemenet a min-heap, it should
return non-nil if A is less than B.

Optional argument INITIAL-SIZE sets the initial size of the heap,
defaulting to 10. Optional argument RESIZE-FACTOR sets the factor
by which the heap's size is increased if it runs out of space,
defaulting to 2.

(fn COMPARE-FUNCTION &optional INITIAL-SIZE RESIZE-FACTOR)" nil nil)
	     (hes-mode "Toggle highlighting of escape sequences.

If called interactively, toggle `Hes mode'.  If the prefix
argument is positive, enable the mode, and if it is zero or
negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (turn-off-hes-mode "Turn off highlighting of escape sequences" t nil)
	     (turn-on-hes-mode "Turn on highlighting of escape sequences." t nil)
	     (define-hook-function "Define FUNCTION to be a function, then add it to hooks.

The hooks to add are specified by the :hooks keyword.  This is a
simple list of hooks, unquoted, and the new function is added to
each one.

(fn FUNCTION ARGS &optional DOCSTRING &rest BODY)" nil t)
	     (define-hook-helper "Define a hook helper for the variable HOOK-hook with ARGS as the argument list.

This helper consists of all the code in BODY.  HOOK should not be
quoted.  The keywords are:

:name    Specifies a name to use for the generated function.  As part
         of this macro, a function called hook-helper--HOOK will be
         created.  If NAME is given, then the function becomes
         ‘hook-helper--HOOK/NAME’.

:append  If non-nil, append the hook helper to the hook variable.

:suffix  Allows a user to specify that the hook variable doesn't
         end with ‘-hook’, but instead with another suffix, such as
         ‘-function’.  SUFFIX should be a string, and defaults to ‘hook’
         if not specified.  Note that SUFFIX is not assumed to start with
         a hyphen.

(fn HOOK ARGS &optional DOCSTRING &rest BODY)" nil t)
	     (create-hook-helper "Creates a new hook helper ID for the hooks in HOOKS.

If a hook helper with id ID already exists, it's overridden.  All instances of
the helper in its associated hooks are replaced.

See `hkhlp-normalize-hook-spec' for an explanation of HOOKS.

(fn ID ARGS &optional DOCSTRING &keys HOOKS &rest BODY)" nil t)
	     (nxml-html5-dt-compile "

(fn NAME PARAMS)" nil nil)
	     (defhydra "Create a Hydra - a family of functions with prefix NAME.

NAME should be a symbol, it will be the prefix of all functions
defined here.

BODY has the format:

    (BODY-MAP BODY-KEY &rest BODY-PLIST)

DOCSTRING will be displayed in the echo area to identify the
Hydra.  When DOCSTRING starts with a newline, special Ruby-style
substitution will be performed by `hydra--format'.

Functions are created on basis of HEADS, each of which has the
format:

    (KEY CMD &optional HINT &rest PLIST)

BODY-MAP is a keymap; `global-map' is used quite often.  Each
function generated from HEADS will be bound in BODY-MAP to
BODY-KEY + KEY (both are strings passed to `kbd'), and will set
the transient map so that all following heads can be called
though KEY only.  BODY-KEY can be an empty string.

CMD is a callable expression: either an interactive function
name, or an interactive lambda, or a single sexp (it will be
wrapped in an interactive lambda).

HINT is a short string that identifies its head.  It will be
printed beside KEY in the echo erea if `hydra-is-helpful' is not
nil.  If you don't even want the KEY to be printed, set HINT
explicitly to nil.

The heads inherit their PLIST from BODY-PLIST and are allowed to
override some keys.  The keys recognized are :exit and :bind.
:exit can be:

- nil (default): this head will continue the Hydra state.
- t: this head will stop the Hydra state.

:bind can be:
- nil: this head will not be bound in BODY-MAP.
- a lambda taking KEY and CMD used to bind a head.

It is possible to omit both BODY-MAP and BODY-KEY if you don't
want to bind anything.  In that case, typically you will bind the
generated NAME/body command.  This command is also the return
result of `defhydra'.

(fn NAME BODY &optional DOCSTRING &rest HEADS)" nil t)
	     (ivy-switch-buffer-other-window "Switch to another buffer in another window." t nil)
	     (ivy-switch-view "Switch to one of the window views stored by `ivy-push-view'." t nil)
	     (ivy-switch-buffer "Switch to another buffer." t nil)
	     (ivy-mode "Toggle Ivy mode on or off.
Turn Ivy mode on if ARG is positive, off otherwise.
Turning on Ivy mode sets `completing-read-function' to
`ivy-completing-read'.

Global bindings:
\\{ivy-mode-map}

Minibuffer bindings:
\\{ivy-minibuffer-map}

(fn &optional ARG)" t nil)
	     (ivy-completing-read "Read a string in the minibuffer, with completion.

This interface conforms to `completing-read' and can be used for
`completing-read-function'.

PROMPT is a string that normally ends in a colon and a space.
COLLECTION is either a list of strings, an alist, an obarray, or a hash table.
PREDICATE limits completion to a subset of COLLECTION.
REQUIRE-MATCH is a boolean value.  See `completing-read'.
INITIAL-INPUT is a string inserted into the minibuffer initially.
HISTORY is a list of previously selected inputs.
DEF is the default value.
INHERIT-INPUT-METHOD is currently ignored.

(fn PROMPT COLLECTION &optional PREDICATE REQUIRE-MATCH INITIAL-INPUT HISTORY DEF INHERIT-INPUT-METHOD)" nil nil)
	     (ivy-read "Read a string in the minibuffer, with completion.

PROMPT is a string, normally ending in a colon and a space.
`ivy-count-format' is prepended to PROMPT during completion.

COLLECTION is either a list of strings, a function, an alist, or
a hash table, supplied for `minibuffer-completion-table'.

PREDICATE is applied to filter out the COLLECTION immediately.
This argument is for compatibility with `completing-read'.

When REQUIRE-MATCH is non-nil, only members of COLLECTION can be
selected.

If INITIAL-INPUT is non-nil, then insert that input in the
minibuffer initially.

HISTORY is a name of a variable to hold the completion session
history.

KEYMAP is composed with `ivy-minibuffer-map'.

PRESELECT, when non-nil, determines which one of the candidates
matching INITIAL-INPUT to select initially.  An integer stands
for the position of the desired candidate in the collection,
counting from zero.  Otherwise, use the first occurrence of
PRESELECT in the collection.  Comparison is first done with
`equal'.  If that fails, and when applicable, match PRESELECT as
a regular expression.

DEF is for compatibility with `completing-read'.

UPDATE-FN is called each time the candidate list is re-displayed.

When SORT is non-nil, `ivy-sort-functions-alist' determines how
to sort candidates before displaying them.

ACTION is a function to call after selecting a candidate.
It takes one argument, the selected candidate. If COLLECTION is
an alist, the argument is a cons cell, otherwise it's a string.

MULTI-ACTION, when non-nil, is called instead of ACTION when
there are marked candidates. It takes the list of candidates as
its only argument. When it's nil, ACTION is called on each marked
candidate.

UNWIND is a function of no arguments to call before exiting.

RE-BUILDER is a function transforming input text into a regex
pattern.

MATCHER is a function which can override how candidates are
filtered based on user input.  It takes a regex pattern and a
list of candidates, and returns the list of matching candidates.

DYNAMIC-COLLECTION is a boolean specifying whether the list of
candidates is updated after each input by calling COLLECTION.

EXTRA-PROPS can be used to store collection-specific
session-specific data.

CALLER is a symbol to uniquely identify the caller to `ivy-read'.
It is used, along with COLLECTION, to determine which
customizations apply to the current completion session.

(fn PROMPT COLLECTION &key PREDICATE REQUIRE-MATCH INITIAL-INPUT HISTORY PRESELECT DEF KEYMAP UPDATE-FN SORT ACTION MULTI-ACTION UNWIND RE-BUILDER MATCHER DYNAMIC-COLLECTION EXTRA-PROPS CALLER)" nil nil)
	     (ivy-resume "Resume the last completion session." t nil)
	     (ivy-explorer-mode "Globally enable `ivy-explorer' for file navigation.

If called interactively, toggle `Ivy-Explorer mode'.  If the
prefix argument is positive, enable the mode, and if it is zero
or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

`ivy-explorer-mode' is a global minor mode which changes
`read-file-name-function' which is used for file completion.

When `ivy-explorer-enable-counsel-explorer' (by default it is),
`find-file' and `counsel-find-file' will be remapped to
`counsel-explorer.', too.

See `ivy-explorer-map' for bindings used in the minibuffer.

(fn &optional ARG)" t nil)
	     (ivy-posframe-mode "Display ivy via posframe.

If called interactively, toggle `Ivy-Posframe mode'.  If the
prefix argument is positive, enable the mode, and if it is zero
or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (javaimp-organize-imports "Groups import statements according to the value of
`javaimp-import-group-alist' (which see) and prints resulting
groups leaving one blank line between groups.

If the file already contains some import statements, this command
rewrites them, starting with the same place.  Else, if the the
file contains package directive, this command inserts one blank
line below and then imports.  Otherwise, imports are inserted at
the beginning of buffer.

Classes within a single group are ordered in a lexicographic
order.  Imports not matched by any regexp in `javaimp-import-group-alist'
are assigned a default order defined by
`javaimp-import-default-order'.

NEW-IMPORTS is a list of additional imports; each element should
be of the form (CLASS . TYPE), where CLASS is a string and TYPE
is `ordinary' or `static'.  Interactively, NEW-IMPORTS is nil.

(fn &rest NEW-IMPORTS)" t nil)
	     (javaimp-add-import "Imports classname in the current file.  Interactively,
asks for a class to import, adds import statement and calls
`javaimp-organize-imports'.  Import statements are not
duplicated.  Completion alternatives are constructed based on
this module's dependencies' classes, JDK classes and top-level
classes in the current module.

(fn CLASSNAME)" t nil)
	     (javaimp-visit-project "Loads a project and its submodules.  DIR should point to a
directory containing pom.xml / build.gradle[.kts].

After being processed by this command, the module tree becomes
known to javaimp and `javaimp-add-import' may be called inside
any module file.

(fn DIR)" t nil)
	     (jgraph-mode "A major mode for editing Jgraph files.

(fn)" t nil)
	     (js2-jsx-mode "Major mode for editing JSX code in Emacs 26 and earlier.

To edit JSX code in Emacs 27, use `js-mode' as your major mode
with `js2-minor-mode' enabled.

To customize the indentation for this mode, set the SGML offset
variables (`sgml-basic-offset' et al) locally, like so:

  (defun set-jsx-indentation ()
    (setq-local sgml-basic-offset js2-basic-offset))
  (add-hook \\='js2-jsx-mode-hook #\\='set-jsx-indentation)

(fn)" t nil)
	     (js2-mode "Major mode for editing JavaScript code.

(fn)" t nil)
	     (js2-minor-mode "Minor mode for running js2 as a background linter.
This allows you to use a different major mode for JavaScript editing,
such as `js-mode', while retaining the asynchronous error/warning
highlighting features of `js2-mode'.

If called interactively, toggle `Js2 minor mode'.  If the prefix
argument is positive, enable the mode, and if it is zero or
negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (js2-highlight-unused-variables-mode "Toggle highlight of unused variables.

If called interactively, toggle `Js2-Highlight-Unused-Variables
mode'.  If the prefix argument is positive, enable the mode, and
if it is zero or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (js2-imenu-extras-mode "Toggle Imenu support for frameworks and structural patterns.

If called interactively, toggle `Js2-Imenu-Extras mode'.  If the
prefix argument is positive, enable the mode, and if it is zero
or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (js2-imenu-extras-setup nil nil nil)
	     (json-mode "Major mode for editing JavaScript Object Notation (JSON) data files.

(fn)" t nil)
	     (jumpc "Initialize jump cursor." t nil)
	     (org-kiwix-setup-link "Setup Org link for org-kiwix." nil nil)
	     (kiwix-mode "Kiwix global minor mode for searching Kiwix serve.

If called interactively, toggle `Kiwix mode'.  If the prefix
argument is positive, enable the mode, and if it is zero or
negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (kiwix-at-point "Search for the symbol at point with `kiwix-query'." t nil)
	     (kiwix-launch-server "Launch Kiwix server." t nil)
	     (landmark "Start or resume an Landmark game.
If a game is in progress, this command allows you to resume it.
Here is the relation between prefix args and game options:

prefix arg | robot is auto-started | weights are saved from last game
---------------------------------------------------------------------
none / 1   | yes                   | no
       2   | yes                   | yes
       3   | no                    | yes
       4   | no                    | no

You start by moving to a square and typing \\[landmark-start-robot],
if you did not use a prefix arg to ask for automatic start.
Use \\[describe-mode] for more info.

(fn PARG)" t nil)
	     (landmark-test-run "Run 100 Landmark games, each time saving the weights from the previous game." t nil)
	     (leaf "Symplify your `.emacs' configuration for package NAME with ARGS.

(fn NAME &rest ARGS)" nil t)
	     (leaf-key-describe-bindings "Display all the bindings configured via `leaf-key'." t nil)
	     (leaf-expand "Expand `leaf' at point." t nil)
	     (leaf-create-issue-template "Create issue template buffer." t nil)
	     (leaf-pp "Output the pretty-printed representation of leaf SEXP.

(fn SEXP)" nil nil)
	     (leaf-pp-to-string "Return format string of `leaf' SEXP like `pp-to-string'.

(fn SEXP)" nil t)
	     (leaf-available-keywords "Return current available `leaf' keywords list." t nil)
	     (lex-parse-re "Parse STRING as a regular expression.
LEXER specifies the regexp syntax to use.  It can be `ere', or `bre'
and it defaults to `bre'.

(fn STRING &optional LEXER)" nil nil)
	     (lex-compile "Compile a set of regular expressions.
ALIST is a list of elements of the form (REGEXP . VALUE).
The compiled automaton will match all those regexps at the same time
and will return the VALUE fof the leftmost longest match.

Each REGEXP object should be in the sexp form described in the
Commentary section.

(fn ALIST)" nil nil)
	     (lmc-asm-mode "Major mode to edit LMC assembly code.

(fn)" t nil)
	     (load-dirs-reload "Load all Emacs Lisp files in `load-dirs'.
Clears the list of loaded files and just calls `load-dir-load'." t nil)
	     (load-dirs "Load all Emacs Lisp files in `load-dirs'.
Will not load a file twice (use `load-dir-reload' for that).
Recurses into subdirectories if `load-dir-recursive' is t." t nil)
	     (provide-me "Call `provide' with the feature's symbol name made from
source-code's file basename sans extension.  For example if you
write (provide-me) inside file ~/lisp/foo.el, this is the same as
writing: (provide \\='foo).

With a prefix, that prefix is prepended to the `provide' So in
the previous example, if you write (provide-me \"bar-\") this is the
same as writing (provide \\='bar-foo).

(fn &optional PREFIX)" nil t)
	     (require-relative-list "Run `require-relative' on each name in LIST which should be a list of
strings, each string being the relative name of file you want to run.

(fn LIST &optional OPT-PREFIX)" nil t)
	     (require-relative "Run `require' on an Emacs Lisp file relative to the Emacs Lisp code
that is in the process of being loaded or eval'd.  The symbol used in require
is the base file name (without directory or file extension) treated as a
symbol.

WARNING: it is best to to run this function before any
buffer-setting or buffer changing operations.

(fn RELATIVE-FILE &optional OPT-FILE OPT-PREFIX)" nil nil)
	     (load-relative "Load an Emacs Lisp file relative to Emacs Lisp code that is in
the process of being loaded or eval'd.

FILE-OR-LIST is either a string or a list of strings containing
files that you want to loaded.  If SYMBOL is given, the location of
of the file of where that was defined (as given by `symbol-file' is used
if other methods of finding __FILE__ don't work.

(fn FILE-OR-LIST &optional SYMBOL)" nil nil)
	     (with-relative-file "Read the relative FILE into a temporary buffer and evaluate BODY
in this buffer.

(fn FILE &rest BODY)" nil t)
	     (find-file-noselect-relative "Read relative FILENAME into a buffer and return the buffer.
If a buffer exists visiting FILENAME, return that one, but
verify that the file has not changed since visited or saved.
The buffer is not selected, just returned to the caller.
Optional second arg NOWARN non-nil means suppress any warning messages.
Optional third arg RAWFILE non-nil means the file is read literally.
Optional fourth arg WILDCARDS non-nil means do wildcard processing
and visit all the matching files.  When wildcards are actually
used and expanded, return a list of buffers that are visiting
the various files.

(fn FILENAME &optional NOWARN RAWFILE WILDCARDS)" nil nil)
	     (__FILE__ "Return the string name of file/buffer that is currently begin executed.

The first approach for getting this information is perhaps the
most pervasive and reliable.  But it the most low-level and not
part of a public API, so it might change in future
implementations.  This method uses the name that is recorded by
readevalloop of `lread.c' as the car of variable
`current-load-list'.

Failing that, we use `load-file-name' which should work in some
subset of the same places that the first method works.  However
`load-file-name' will be nil for code that is eval'd.  To cover
those cases, we try function `buffer-file-name' which is initially
correct, for eval'd code, but will change and may be wrong if the
code sets or switches buffers after the initial execution.

As a last resort, you can pass in SYMBOL which should be some
symbol that has been previously defined if none of the above
methods work we will use the file-name value find via
`symbol-file'.

(fn &optional SYMBOL)" nil nil)
	     (loccur "Perform a simple grep in current buffer.

This command hides all lines from the current buffer except those
containing the regular expression REGEX.  A second call of the function
unhides lines again.

When called interactively, either prompts the user for REGEXP or,
when called with an active region, uses the content of the
region, unless called with the universal prefix (C-u)

(fn REGEX)" t nil)
	     (loccur-current "Call `loccur' for the current word." t nil)
	     (markchars-global-mode "Toggle Markchars mode in all buffers.
With prefix ARG, enable Markchars-Global mode if ARG is positive;
otherwise, disable it.  If called from Lisp, enable the mode if
ARG is omitted or nil.

Markchars mode is enabled in all buffers where
`(lambda nil (markchars-mode 1))' would do it.

See `markchars-mode' for more information on
Markchars mode.

(fn &optional ARG)" t nil)
	     (markchars-mode "Mark special characters.
Which characters to mark are defined by `markchars-pattern'.

If called interactively, toggle `Markchars mode'.  If the prefix
argument is positive, enable the mode, and if it is zero or
negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

The default is to mark nonascii chars with a magenta underline.

(fn &optional ARG)" t nil)
	     (memory-usage "List all buffers and their memory usage." t nil)
	     (metar "Display recent weather information.
If a prefix argument is given, prompt for country and station name.
If two prefix arguments are given, prompt for exact station code.
Otherwise, determine the best station via latitude/longitude.

(fn &optional ARG)" t nil)
	     (midikbd-open "Open the raw Midi device FILE as a source for Midi input.
This should be an ALSA device like \"/dev/snd/midiC1D0\".  If your
Midi producing device is a software Midi device, you might need to
call

    sudo modprobe snd-virmidi

in order to have some virtual ALSA ports available as such raw Midi
devices.

(fn FILE)" t nil)
	     (mines "Play the minesweeper game.
Called with a prefix prompt for the difficulty level.

(fn &optional ARG)" t nil)
	     (minibuffer-line-mode "Display status info in the minibuffer window.

If called interactively, toggle `Minibuffer-Line mode'.  If the
prefix argument is positive, enable the mode, and if it is zero
or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (minimap-mode "Toggle minimap mode.

If called interactively, toggle `Minimap mode'.  If the prefix
argument is positive, enable the mode, and if it is zero or
negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (mmm-add-classes "Add the submode classes CLASSES to `mmm-classes-alist'.

(fn CLASSES)" nil nil)
	     (nxml-web-mode "

(fn)" t nil)
	     (html-erb-mode "

(fn)" t nil)
	     (multishell-list "Edit your current and historic list of shell buffers.

If optional COMPLETING is nil, we present the full
`multishell-history' list in a popped buffer named `*Shells*'.

In the buffer, hit ? or h for a list of commands.

When optional COMPLETING is non-nil, it must be a list of
multishell-history completion candidate entries, as provided by
`completing-read'. Then we present the list as a part of
minibuffer completion.

You can get to the shells listing by recursively invoking
\\[multishell-pop-to-shell] at the `multishell-pop-to-shell'
`universal-argument' prompts.

(fn &optional COMPLETING)" t nil)
	     (multishell-pop-to-shell "Easily navigate to and within multiple shell buffers, local and remote.

Use a single `universal-argument' (\\[universal-argument]) to launch and choose between
nalternate shell buffers, and a doubled universal argument to also set your
choice as the ongoing default.  Append a path to a new shell name to launch
a shell in that directory, and use Emacs tramp syntax to launch a remote
shell. There is a shortcut to manage your list of current and
historical shells, collectively, using `multishell-list' - see below.

Customize-group `multishell' to set up a key binding and tweak behaviors.

Manage your collection of current and historical shells by
recursively invoking \\[multishell-pop-to-shell] at the `multishell-pop-to-shell'
universal argument prompts, eg:

  \\[universal-argument] \\[multishell-pop-to-shell] \\[multishell-pop-to-shell]

(That will be just a few keys if you do the above customization.)

Hit ? in the listing buffer for editing commands.

==== Basic operation:

 - If the current buffer is in shell-mode then focus is moved to
   the process input point.

   (Use a universal argument go to a different shell buffer
   when already in a buffer that has a process - see below.)

 - If not in a shell buffer, go to a window that is already
   showing a shell buffer, if any.

   In this case, the cursor is not moved to the process input
   point. Repeating the command once you're in the buffer will
   then move the cursor to the process input point.

   We respect `pop-up-windows', so you can adjust it to set the
   other-buffer/same-buffer behavior.

 - Otherwise, start a new shell buffer, using the current
   directory as the working directory.

If a buffer with the resulting name exists and its shell process
was disconnected or otherwise stopped, it's resumed.

===== Universal arg to start and select between named shell buffers:

You can assign a distinct name to new shell buffers by prefixing
your \\[multishell-pop-to-shell] invocation with a single or double
`universal-argument', \\[universal-argument]:

 - With a single universal argument, prompt for the buffer name
   to use (without the asterisks that shell mode will put around
   the name), defaulting to `shell'.

   Completion is available.

   This combination makes it easy to start and switch across
   multiple shell restarts.

 - A double universal argument will prompt for the name and set
   the default to that name, so the target shell becomes the
   primary.

   See `multishell-primary-name' for info about preserving the
   setting across emacs restarts.

 - Manage your collection of current and historical shells by
   recursively invoking \\[multishell-pop-to-shell] at the `multishell-pop-to-shell'
   universal argument prompts, or at any time via
   \\[multishell-list]. Hit ? in the listing buffer for editing
   commands.

===== Select starting directory and remote host:

The shell buffer name you give to the prompt for a universal arg
can include an appended path. That will be used for the startup
directory. You can use tramp remote syntax to specify a remote
shell. If there is an element after a final `/', that's used for
the buffer name. Otherwise, the host, domain, or path is used.

For example:

* `#root/sudo:root@localhost:/etc' for a buffer named \"*#root*\" with a
  root shell starting in /etc.

* `/ssh:example.net:' for a shell buffer in your homedir on example.net.
  The buffer will be named \"*example.net*\".

* `#ex/ssh:example.net|sudo:root@example.net:/var/log' for a root shell
  starting in /var/log on example.net named \"*#ex*\".

* `interior/ssh:gateway.corp.com|ssh:interior.corp.com:' to go
  via gateway.corp.com to your homedir on interior.corp.com.  The
  buffer will be named \"*interior*\". You could append a sudo
  hop to the path, combining the previous example, and so on.

File visits from the shell, and many common emacs activities like
dired, will be on the host where the shell is running, in the
auspices of the target account, and relative to the current
directory.

You can change the startup path for a shell buffer by editing it
at the completion prompt. The new path will not take effect for
an already-running shell.

To remove a shell buffer's history entry, kill the buffer and
affirm removal of the entry when prompted.

===== Activate savehist to retain shell buffer names and paths across Emacs restarts:

To have emacs maintain your history of shell buffer names and paths,
customize the savehist group to activate savehist.

(fn &optional ARG NAME HERE)" t nil)
	     (nameless-mode "Toggle Nameless mode on or off.

If called interactively, toggle `Nameless mode'.  If the prefix
argument is positive, enable the mode, and if it is zero or
negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

\\{nameless-mode-map}

(fn &optional ARG)" t nil)
	     (define-namespace "Inside the namespace NAME, execute BODY.
NAME can be any symbol (not quoted), but it's highly recommended
to use some form of separator (such as :, /, or -).  For a
complete description of this macro, please visit the frontpage
with \\[names-view-manual].

In summary, this macro has two main effects:

1. Any definitions inside BODY will have NAME prepended to the
symbol given.  Ex:

    (define-namespace foo-
    (defvar bar 1 \"docs\")
    )

expands to

    (defvar foo-bar 1 \"docs\")


2. Any function calls and variable names get NAME prepended to
them if such a variable or function exists.  Ex:

    (define-namespace foo:
    (defun message (x y) nil)
    (message \"%s\" my-var)
    )

expands to

    (defun foo:message (x y) nil)
    (foo:message \"%s\" my-var)

Note how `message' is expanded to `foo:message' in the second
form, because that function exists.  Meanwhile, `bar' is left
untouched because `foo:bar' is not a known variable name.

===============================

AUTOLOAD

In order for `define-namespace' to work with \";;;###autoload\"
comments must replace all instances of \";;;###autoload\" inside
your `define-namespace' with `:autoload'.
Afterwards, add an \";;;###autoload\" comment just above your
`define-namespace'.

===============================

KEYWORDS

Immediately after NAME you may add keywords which customize the
behaviour of `define-namespace'. For a list of possible keywords
and a description of their effects, see the variable
`names--keyword-list'.

(fn NAME [KEYWORD ...] BODY)" nil t)
	     (nhexl-mode "Minor mode to edit files via hex-dump format

If called interactively, toggle `Nhexl mode'.  If the prefix
argument is positive, enable the mode, and if it is zero or
negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (global-nlinum-mode "Toggle Nlinum mode in all buffers.
With prefix ARG, enable Global Nlinum mode if ARG is positive;
otherwise, disable it.  If called from Lisp, enable the mode if
ARG is omitted or nil.

Nlinum mode is enabled in all buffers where
`(lambda nil (unless (minibufferp) (nlinum-mode)))' would do it.

See `nlinum-mode' for more information on
Nlinum mode.

(fn &optional ARG)" t nil)
	     (nlinum-mode "Toggle display of line numbers in the left margin (Linum mode).
With a prefix argument ARG, enable Linum mode if ARG is positive,
and disable it otherwise.  If called from Lisp, enable the mode
if ARG is omitted or nil.

Linum mode is a buffer-local minor mode.

(fn &optional ARG)" t nil)
	     (notes-w3-follow-link-mouse "* Follow the URL where the mouse is.

(fn E)" t nil)
	     (notes-w3-follow-link "* Follow the URL at the point.
Takes a PT to look at and a WHERE to open the URL (`otherwindow' or nil).
This code works hard to recognize URLs based on context information.
URLs can be quoted by whitespace, beginning and end of lines,
or the official < and >.

As a special case we also recognize (and skip) the text \"prev:\"
and \"next:\" before the URL.  Notes-mode uses these fields to link
entries.

(fn PT &optional WHERE)" t nil)
	     (notes-w3-url "Open a notes-url.  Handle simple URLs here, or call notes-w3-alternate-url.
Takes the URL as an argument.  Optionally you specify
WHERE the information should appear (either `otherwindow' or nil,
defaults to nil).
BEST-EFFORT causes notes-w3-url allows the tag portion of the URL to not
match.  If there's no tag match, it looks for the nearest matching prefix.

URLs optionally can begin with an URL: tag, which will be ignored.

notes-w3-url handles only <file://localhost/...> (or <file:///...>) URLs.
Other URLs it hands off to the routine in notes-w3-alternate-url
for processing.  If you use w3-mode, then
    (setq notes-w3-alternate-url \\='w3-follow-link)
will have w3 handle tough URLs.

(fn URL &optional WHERE BEST-EFFORT)" nil nil)
	     (notes-mode "Enable notes-mode for a buffer.

Inside a notes buffer one can click on URLs and follow them to
other notes files.

See the file notes-variables.el for all customization options.
To change options, (require \\='notes-variables) in your .emacs
and then change things.

Subjects in notes mode are lines beginning with an asterisk
and underlined with dashes.  Subjects can be completed
with \\[notes-complete-subject] and are automatically underlined.

You may wish to add this code to your .emacs file:
    (add-to-list \\='auto-mode-alist
      (cons \"/9[0-9][0-9][0-9][0-9][0-9].?\\\\\\='\" \\='notes-mode))
    (define-key global-map [?\\C-c ?n] \\='notes-index-todays-link)
to automatically enter notes mode.

I have two suggestions for how to organize your notes files.
First, I collect my notes into a separate file per day.  (If you have
fewer notes, you may find once-per-week or month more suitable.)
Second, at the beginning of each file I have a subject \"* Today\".
Since every file has this subject, I can use its prev and next links
to easily move around the collection of files.

The key-bindings of this mode are:
\\{notes-mode-map}

(fn)" t nil)
	     (notes-underline-line "* Create a row of dashes as long as this line, or adjust the current underline." t nil)
	     (notes-index-mode "Notes-index-mode with mouse support.

You may wish to change notes-bold-face and notes-use-font-lock.

There should be no need to add notes-index-mode to auto-mode-alist
since the index generation functions add code to the index file
which invokes notes-index-mode.

Key bindings are:
\\{notes-index-mode-map}

(fn)" t nil)
	     (notes-index-todays-link "* Open the notes file for today." t nil)
	     (notes-format-date "Format the TIME up to be a notes-format date.
If no TIME is specified, use today's date.

(fn &optional TIME)" nil nil)
	     (global-num3-mode "Toggle Num3 mode in all buffers.
With prefix ARG, enable Global Num3 mode if ARG is positive;
otherwise, disable it.  If called from Lisp, enable the mode if
ARG is omitted or nil.

Num3 mode is enabled in all buffers where
`num3-mode' would do it.

See `num3-mode' for more information on
Num3 mode.

(fn &optional ARG)" t nil)
	     (num3-mode "Toggle num3 minor mode in the current buffer.
Num3 minor mode makes long numbers more readable by highlighting
groups of digits when font-lock mode is enabled.

If called interactively, toggle `num3 mode'.  If the prefix
argument is positive, enable the mode, and if it is zero or
negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

If a number is longer than `num3-threshold', the mode will split
it into a group of `num3-group-size' (if number is decimal) or
four (if number is hexadecimal or binary) digits.

Hexadecimal numbers are recognised by \"0x\" or \"#x\"
prefix (case insensitive) and binary numbers by \"0b\" or \"#b\"
prefix.  (There is no special handling for octal numbers –
starting with \"0o\" or \"#o\" – and instead they are handled
like decimal numbers).

Decimal fractions are recognised as well and grouped from the
beginning rathar then the end.  For instance, with group size of
three, a number \"12345.12345\" will be split into groups as
follows: \"12|345.123|45\".  Fractions without integer part are
also recognised, eg. \".12345\".

Groups are highlighted alternately using `num3-face-odd' and
`num3-face-even' faces.  `num3-face-odd' face (which is empty by
default) is the one used for the group closest to the decimal
point, i.e. groups are counted starting with one outwards from
the (place where) decimal point (would be) is.

(fn &optional ARG)" t nil)
	     (oauth2-url-retrieve "Retrieve an URL asynchronously using TOKEN to access it.
TOKEN can be obtained with `oauth2-auth'.  CALLBACK gets called with CBARGS
when finished.  See `url-retrieve'.

(fn TOKEN URL CALLBACK &optional CBARGS REQUEST-METHOD REQUEST-DATA REQUEST-EXTRA-HEADERS)" nil nil)
	     (oauth2-url-retrieve-synchronously "Retrieve an URL synchronously using TOKEN to access it.
TOKEN can be obtained with `oauth2-auth'.

(fn TOKEN URL &optional REQUEST-METHOD REQUEST-DATA REQUEST-EXTRA-HEADERS)" nil nil)
	     (oauth2-auth-and-store "Request access to a resource and store it using `plstore'.

(fn AUTH-URL TOKEN-URL SCOPE CLIENT-ID CLIENT-SECRET &optional REDIRECT-URI STATE)" nil nil)
	     (oauth2-auth "Authenticate application via OAuth2.

(fn AUTH-URL TOKEN-URL CLIENT-ID CLIENT-SECRET &optional SCOPE STATE REDIRECT-URI)" nil nil)
	     (oauth2-refresh-access "Refresh OAuth access TOKEN.
TOKEN should be obtained with `oauth2-request-access'.

(fn TOKEN)" nil nil)
	     (omn-mode "Major mode for editing OWL Manchester Notation.

This is a format for specifying OWL ontologies, that is designed
to be easy to type and to read. It is fully documented and
specified at http://www.w3.org/TR/owl2-manchester-syntax/

(fn)" t nil)
	     (on-screen-global-mode "Global minor mode guiding your eyes while scrolling.
With a prefix argument ARG, enable the mode if ARG is positive,
and disable it otherwise.  If called from Lisp, enable the mode
if ARG is omitted or nil.

You can make use of `on-screen-inhibit-highlighting' to prevent
highlighting on a per-buffer basis.

Type M-x customize-group on-screen RET for configuration.

(fn &optional ARG)" t nil)
	     (on-screen-mode "Buffer local minor mode guiding your eyes while scrolling.
With a prefix argument ARG, enable the mode if ARG is positive,
and disable it otherwise.  If called from Lisp, enable the mode
if ARG is omitted or nil.
Type M-x customize-group on-screen RET for configuration.

(fn &optional ARG)" t nil)
	     (org-edna-mode "Toggle Org Edna mode.

If called interactively, toggle `Org-Edna mode'.  If the prefix
argument is positive, enable the mode, and if it is zero or
negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (org-edna--unload "Unload Org Edna.

Remove Edna's workers from `org-trigger-hook' and
`org-blocker-hook'." nil nil)
	     (org-edna--load "Setup the hooks necessary for Org Edna to run.

This means adding to `org-trigger-hook' and `org-blocker-hook'." nil nil)
	     (orgalist-mode "Toggle Org-like lists and their relative commands.

With a prefix argument ARG, enable Auto Fill mode if ARG is
positive, and disable it otherwise.  If called from Lisp, enable
the mode if ARG is omitted or nil.

When Orgalist mode is enabled, any line beginning with \"-\",
\"+\", \"1.\" or \"a.\" followed by a space starts a list.  You
can then operate locally on the list, e.g., to insert new items,
move items or sort them.  See below for details.

Moreover, you can add check-boxes to items

  - [ ] A checkbox, toggled with `C-c C-c'

turn an unordered list into a description list

  - term :: description

and control numbering in an ordered list

  4. [@4] a forced numbered item

key             binding
---             -------
M-<RET>         `orgalist-insert-item'
M-<UP>          `orgalist-previous-item'
M-<DOWN>        `orgalist-next-item'
M-S-<UP>        `orgalist-move-item-up'
M-S-<DOWN>      `orgalist-move-item-down'
M-<LEFT>        `orgalist-outdent-item'
M-<RIGHT>       `orgalist-indent-item'
M-S-<LEFT>      `orgalist-outdent-item-tree'
M-S-<RIGHT>     `orgalist-indent-item-tree'
C-c -           `orgalist-cycle-bullet'
C-c ^           `orgalist-sort-items'
C-c C-c         `orgalist-check-item'

(fn &optional ARG)" t nil)
	     (osc-make-server "Create an OSC server which listens on HOST and PORT.
DEFAULT-HANDLER is a function with arguments (path &rest args) which is called
when a new OSC message arrives.  See `osc-server-set-handler' for more
fine grained control.
A process object is returned which can be dicarded with `delete-process'.

(fn HOST PORT DEFAULT-HANDLER)" nil nil)
	     (osc-send-message "Send an OSC message from CLIENT to the specified PATH with ARGS.

(fn CLIENT PATH &rest ARGS)" nil nil)
	     (osc-make-client "Create an OSC client process which talks to HOST and PORT.

(fn HOST PORT)" nil nil)
	     (other-frame-window-mode "Minor mode for other frame/window buffer placement.
Enable mode if ARG is positive.

\\[ofw-other-window] <command> causes a buffer displayed by <command>
to appear in another window in the same frame; a window
is created if necessary.

\\[ofw-other-frame] <command> causes a buffer displayed by <command>
to appear in another frame; a frame is created if necessary.

\\[ofw-move-to-other-window] moves the current buffer to another
window in the same frame.

\\[ofw-move-to-other-frame] moves the current buffer to another
frame.

In addition, \\[ofw-other-window] and \\[ofw-other-frame] can be followed by these keys:

0 - deletes the current window/frame

1 - deletes the other windows/frames.

2 - shows another view of the current buffer in a new
    window/frame.

a - creates a commit log entry for the current defun in
    another window/frame.

b - switches to another buffer in another window/frame.

d - start dired in another window/frame.

f - find-file in another window/frame.

m - compose mail in another window/frame.

o - select another window/frame.

r - find-file-read-only in another window/frame.

(fn &optional ARG)" t nil)
	     (global-pabbrev-mode "Toggle Pabbrev mode in all buffers.
With prefix ARG, enable Global Pabbrev mode if ARG is positive;
otherwise, disable it.  If called from Lisp, enable the mode if
ARG is omitted or nil.

Pabbrev mode is enabled in all buffers where
`pabbrev-global-mode' would do it.

See `pabbrev-mode' for more information on
Pabbrev mode.

(fn &optional ARG)" t nil)
	     (pabbrev-mode "Toggle pabbrev mode.
With arg, turn on Predicative Abbreviation mode if and only if arg is
positive.

This mode is another abbreviation expansion mode somewhat like
`dabbrev-expand', in that it looks through the current buffer for
symbols that can complete the current symbol. Unlike `dabbrev-expand',
it does this by discovering the words during the Emacs idle time, and
places the results into data structures which enable very rapid
extraction of expansions. The upshot of this is that it can offer
suggestions as you type, without causing an unacceptable slow down.

There is an associated `global-pabbrev-mode' which turns on the mode
on in all buffers.

(fn &optional ARG)" t nil)
	     (paced-repopulate-current-dictionary-async "Repopulate current dictionary from its population commands, asynchronously.

Population commands are stored in the field of the same name.

Note that this will empty the dictionary's contents." t nil)
	     (paced-repopulate-named-dictionary-async "Repopulate dictionary named KEY from its population commands, asynchronously.

Population commands are stored in the field of the same name.

Note that this will empty the dictionary's contents.

(fn KEY)" t nil)
	     (paced-load-all-dictionaries "Load all dictionaries in `paced-dictionary-directory'." t nil)
	     (phps-mode-format-buffer "Format current buffer according to PHPs mode." t nil)
	     (phps-mode-flycheck-setup "Setup `flycheck' for `phps-mode'." nil nil)
	     (phps-mode-rescan-buffer "Re-scan buffer." t nil)
	     (pinentry-start "Start a Pinentry service.

Once the environment is properly set, subsequent invocations of
the gpg command will interact with Emacs for passphrase input.

If the optional QUIET argument is non-nil, messages at startup
will not be shown.

(fn &optional QUIET)" t nil)
	     (poker "Play a game of texas hold 'em poker.

(fn INITIAL-STACK MIN-BET PLAYERS)" t nil)
	     (posframe-delete-all "Delete all posframe frames and buffers." t nil)
	     (posframe-hide-all "Hide all posframe frames." t nil)
	     (posframe-show "Pop up a posframe and show STRING at POSITION.

POSITION can be:
1. An integer, meaning point position.
2. A cons of two integers, meaning absolute X and Y coordinates.
3. Other type, in which case the corresponding POSHANDLER should be
   provided.

POSHANDLER is a function of one argument returning an actual
position.  Its argument is a plist of the following form:

  (:position xxx
   :position-info xxx
   :poshandler xxx
   :font-height xxx
   :font-width xxx
   :posframe xxx
   :posframe-width xxx
   :posframe-height xxx
   :posframe-buffer xxx
   :parent-frame xxx
   :parent-window-left xxx
   :parent-window-top xxx
   :parent-frame-width xxx
   :parent-frame-height xxx
   :parent-window xxx
   :parent-window-width  xxx
   :parent-window-height xxx
   :minibuffer-height xxx
   :mode-line-height  xxx
   :header-line-height xxx
   :tab-line-height xxx
   :x-pixel-offset xxx
   :y-pixel-offset xxx)

By default, poshandler is auto-selected based on the type of POSITION,
but the selection can be overridden using the POSHANDLER argument.
The builtin poshandler functions are listed below:

1.  `posframe-poshandler-frame-center'
2.  `posframe-poshandler-frame-top-center'
3.  `posframe-poshandler-frame-top-left-corner'
4.  `posframe-poshandler-frame-top-right-corner'
5.  `posframe-poshandler-frame-bottom-center'
6.  `posframe-poshandler-frame-bottom-left-corner'
7.  `posframe-poshandler-frame-bottom-right-corner'
8.  `posframe-poshandler-window-center'
9.  `posframe-poshandler-window-top-center'
10. `posframe-poshandler-window-top-left-corner'
11. `posframe-poshandler-window-top-right-corner'
12. `posframe-poshandler-window-bottom-center'
13. `posframe-poshandler-window-bottom-left-corner'
14. `posframe-poshandler-window-bottom-right-corner'
15. `posframe-poshandler-point-top-left-corner'
16. `posframe-poshandler-point-bottom-left-corner'
17. `posframe-poshandler-point-bottom-left-corner-upward'

This posframe's buffer is BUFFER-OR-NAME, which can be a buffer
or a name of a (possibly nonexistent) buffer.

If NO-PROPERTIES is non-nil, The STRING's properties will
be removed before being shown in posframe.

WIDTH, MIN-WIDTH, HEIGHT and MIN-HEIGHT, specify bounds on the
new total size of posframe.  MIN-HEIGHT and MIN-WIDTH default to
the values of ‘window-min-height’ and ‘window-min-width’
respectively.  These arguments are specified in the canonical
character width and height of posframe.

If LEFT-FRINGE or RIGHT-FRINGE is a number, left fringe or
right fringe with be shown with the specified width.

By default, posframe shows no borders, but users can specify
borders by setting INTERNAL-BORDER-WIDTH to a positive number.
Border color can be specified by INTERNAL-BORDER-COLOR
or via the ‘internal-border’ face.

Posframe's font as well as foreground and background colors are
derived from the current frame by default, but can be overridden
using the FONT, FOREGROUND-COLOR and BACKGROUND-COLOR arguments,
respectively.

By default, posframe will display no header-line, mode-line and
tab-line.  In case a header-line, mode-line or tab-line is
desired, users can set RESPECT-HEADER-LINE and RESPECT-MODE-LINE
to t.

INITIALIZE is a function with no argument.  It will run when
posframe buffer is first selected with `with-current-buffer'
in `posframe-show', and only run once (for performance reasons).

If LINES-TRUNCATE is non-nil, then lines will truncate in the
posframe instead of wrap.

OVERRIDE-PARAMETERS is very powful, *all* the frame parameters
used by posframe's frame can be overridden by it.

TIMEOUT can specify the number of seconds after which the posframe
will auto-hide.

If REFRESH is a number, posframe's frame-size will be re-adjusted
every REFRESH seconds.

When ACCEPT-FOCUS is non-nil, posframe will accept focus.
be careful, you may face some bugs when set it to non-nil.

HIDEHANDLER is a function, when it return t, posframe will be
hide when `post-command-hook' is executed, this function has a
plist argument:

  (:posframe-buffer xxx
   :posframe-parent-buffer xxx)

The builtin hidehandler functions are listed below:

1. `posframe-hidehandler-when-buffer-switch'


You can use `posframe-delete-all' to delete all posframes.

(fn BUFFER-OR-NAME &key STRING POSITION POSHANDLER WIDTH HEIGHT MIN-WIDTH MIN-HEIGHT X-PIXEL-OFFSET Y-PIXEL-OFFSET LEFT-FRINGE RIGHT-FRINGE INTERNAL-BORDER-WIDTH INTERNAL-BORDER-COLOR FONT FOREGROUND-COLOR BACKGROUND-COLOR RESPECT-HEADER-LINE RESPECT-MODE-LINE INITIALIZE NO-PROPERTIES KEEP-RATIO LINES-TRUNCATE OVERRIDE-PARAMETERS TIMEOUT REFRESH ACCEPT-FOCUS HIDEHANDLER &allow-other-keys)" nil nil)
	     (posframe-workable-p "Test posframe workable status." nil nil)
	     (style-format nil t nil)
	     (xml-mode "Major mode for editing XML, specialized from SGML mode.
Sets various variables appropriately for XML.

Can be used without a DTD.  In that case, warnings about undefined
elements and entities are suppressed and various commands' behaviour
is modified to account for the lack of information.  For instance, the
element names offered for selection or completion are those in the
parse of the document, but other names may be entered.

Note that without a DTD, indenting lines will only work if
`sgml-indent-data' is non-nil.

(fn)" t nil)
	     (sgml-mode "Major mode for editing SGML.
\\<sgml-mode-map>Makes > display the matching <.  Makes / display matching /.
Use \\[sgml-validate] to validate your document with an SGML parser.

You can find information with:
\\[sgml-show-context]  Show the nesting of elements at cursor position.
\\[sgml-list-valid-tags]  Show the tags valid at cursor position.

Insert tags with completion of contextually valid tags with \\[sgml-insert-tag].
End the current element with \\[sgml-insert-end-tag].  Insert an element (i.e.
both start and end tag) with \\[sgml-insert-element].  Or tag a region with
\\[sgml-tag-region].

To tag a region with the mouse, use transient mark mode or secondary selection.

Structure editing:
\\[sgml-backward-element]  Moves backwards over the previous element.
\\[sgml-forward-element]  Moves forward over the next element.
\\[sgml-down-element]  Move forward and down one level in the element structure.
\\[sgml-backward-up-element]  Move backward out of this element level.
\\[sgml-beginning-of-element]  Move to after the start tag of the current element.
\\[sgml-end-of-element]  Move to before the end tag of the current element.
\\[sgml-kill-element]  Kill the element following the cursor.

Finding interesting positions
\\[sgml-next-data-field]  Move forward to next point where data is allowed.
\\[sgml-next-trouble-spot]  Move forward to next point where something is
	amiss with the structure.

Folding and unfolding
\\[sgml-fold-element]  Fold the lines comprising the current element, leaving
	the first line visible.
\\[sgml-fold-subelement]  Fold the elements in the content of the current element.
	Leaving the first line of every element visible.
\\[sgml-unfold-line]  Show hidden lines in current line.

User options:

sgml-omittag  Set this to reflect OMITTAG in the SGML declaration.
sgml-shorttag  Set this to reflect SHORTTAG in the SGML declaration.
sgml-namecase-general  Set this to reflect NAMECASE GENERAL in the SGML declaration.
sgml-auto-insert-required-elements  If non-nil, automatically insert required
	elements in the content of an inserted element.
sgml-omittag-transparent  If non-nil, will show legal tags inside elements
	with omitable start tags and legal tags beyond omitable end tags.
sgml-leave-point-after-insert  If non-nil, the point will remain after
	inserted tag(s).
sgml-warn-about-undefined-elements  If non-nil, print a warning when a tag
	for a undefined element is found.
sgml-max-menu-size  Max number of entries in Tags and Entities menus before
 	they are split into several panes.
sgml-always-quote-attributes  If non-nil, quote all attribute values
	inserted after finishing edit attributes.
sgml-minimize-attributes  Determines minimization of attributes inserted by
	edit-attributes.
sgml-normalize-trims  If non-nil, sgml-normalize will trim off white space
	from end of element when adding end tag.
sgml-indent-step  How much to increment indent for every element level.
sgml-indent-data  If non-nil, indent in data/mixed context also.
sgml-set-face     If non-nil, psgml will set the face of parsed markup.
sgml-markup-faces The faces used when the above variable is non-nil.
sgml-public-map  Mapping from public identifiers to file names.
sgml-offer-save  If non-nil, ask about saving modified buffers before
		\\[sgml-validate] is run.

All bindings:
\\{sgml-mode-map}

(fn)" t nil)
	     (pspp-mode "Major mode to edit PSPP files.

(fn)" t nil)
	     (global-quarter-plane-mode "Toggle Quarter-Plane mode in all buffers.
With prefix ARG, enable Global Quarter-Plane mode if ARG is positive;
otherwise, disable it.  If called from Lisp, enable the mode if
ARG is omitted or nil.

Quarter-Plane mode is enabled in all buffers where
`quarter-plane-mode' would do it.

See `quarter-plane-mode' for more information on
Quarter-Plane mode.

(fn &optional ARG)" t nil)
	     (quarter-plane-mode "Toggle Quarter-Plane mode on or off.
Interactively, with no prefix argument, toggle the mode.
With universal prefix ARG turn mode on.
With zero or negative ARG turn mode off.

Use point movement commands that act as if the text extended
infinitely down and to the right, inserting spaces as necessary.
Excess whitespace is trimmed when saving or exiting Quarter-Plane mode.

Because it works by inserting spaces, Quarter-Plane mode won't work in
read-only buffers.

\\{quarter-plane-mode-map}

(fn &optional ARG)" t nil)
	     (rails-routes-find "Find rails routes on current project." t nil)
	     (rainbow-mode "Colorize strings that represent colors.
This will fontify with colors the string like \"#aabbcc\" or \"blue\".

If called interactively, toggle `Rainbow mode'.  If the prefix
argument is positive, enable the mode, and if it is zero or
negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (rcirc-menu "Show a list of all your `rcirc' buffers." t nil)
	     (register-list "Display a list of registers.
An optional argument TYPE defines a regexp to restrict the
register menu to.  A second optional argument FONTIFICATION
decides if the display preserves original fontification for
values.

The default types are defined in `register-list-default-types',
which see.

The list is displayed in a buffer named `*Register List*' in
`register-list-mode', which see.

(fn &optional TYPE FONTIFY)" t nil)
	     (relint-buffer "Scan BUFFER for regexp errors. Return list of diagnostics.
Each element in the returned list has the form

  (MESSAGE EXPR-POS ERROR-POS STRING STRING-IDX SEVERITY),

where MESSAGE is the message string, EXPR-POS the location of the
flawed expression, ERROR-POS the exact position of the error or
nil if unavailable, STRING is nil or a string to which the
message pertains, STRING-IDX is nil or an index into STRING,
and SEVERITY is `error' or `warning'.
The intent is that ERROR-POS is the position in the buffer that
corresponds to STRING at STRING-IDX, if such a location can be
determined.

(fn BUFFER)" nil nil)
	     (relint-current-buffer "Scan the current buffer for regexp errors.
The buffer must be in emacs-lisp-mode." t nil)
	     (relint-directory "Scan all *.el files in DIR for regexp-related errors.

(fn DIR)" t nil)
	     (relint-file "Scan FILE, an elisp file, for regexp-related errors.

(fn FILE)" t nil)
	     (repology "Query Repology interactively.

This function interacts with Repology API in three ways.  You can:

1. List all packages associated to a given project.  See function
   `repology-project-lookup'.

2. Find potential problems related to packages in a repository, using
   `repology-repository-problems'.  The function provides the list of
   repositories to choose from.

3. Search for projects matching some criteria.  Here, you build incrementally
   a filter by selecting properties from a list.  See `repology-projects-search'
   for more information.  Select \"OK\" to actually send the request.

   During the filter creation, you may change the maximum number of projects
   displayed by selecting \"limit\" from the list of properties.  The default
   value is `repology-projects-limit'." t nil)
	     (rich-minority-mode "Toggle Rich minority mode on or off.

If called interactively, toggle `Rich minority mode'.  If the
prefix argument is positive, enable the mode, and if it is zero
or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

\\{rich-minority-mode-map}

(fn &optional ARG)" t nil)
	     (rm--mode-list-as-string-list "Return `minor-mode-list' as a simple list of strings." nil nil)
	     (rnc-mode "Major mode to edit Relax-NG Compact files.

(fn)" t nil)
	     (scroll-restore-mode "Toggle Scroll Restore mode.
With arg, turn Scroll Restore mode on if arg is positive, off
otherwise.

In Scroll Restore mode Emacs attempts to restore the original
position that existed before executing a sequence of scrolling
commands whenever that position becomes visible again.  The
option `scroll-restore-commands' permits to specify the set of
commands that may constitute such a sequence.  In addition you
can

- recenter the window when you scroll back to the original
  position, see the option `scroll-restore-recenter',

- aggressively jump back to the original position before
  executing a command not in `scroll-restore-commands', see
  `scroll-restore-jump-back',

- change the appearance of the cursor in the selected window
  while the original position is off-screen, see the option
  `scroll-restore-handle-cursor',

- change the appearance of the region in the selected window
  while the original position is off-screen, see the option
  `scroll-restore-handle-region'.

(fn &optional ARG)" t nil)
	     (sed-mode "Sed editing mode.

(fn)" t nil)
	     (shelisp-mode "Enable elisp expressions embedded in ANSI APC (Application
Program Control) escape sequences to be located and executed
while in a shell mode buffer.

If called interactively, toggle `ShElisp mode'.  If the prefix
argument is positive, enable the mode, and if it is zero or
negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (shell-command+ "Intelligently execute string COMMAND in inferior shell.

If COMMAND is prefixed with an absolute or relative path, the
created process will the executed in the specified path.

When COMMAND starts with...
  <  the output of COMMAND replaces the current selection
  >  COMMAND is run with the current selection as input
  |  the current selection is filtered through COMMAND
  !  COMMAND is simply executed (same as without any prefix)

If `shell-command+-use-eshell' is non-nil, and the the first
argument of COMMAND has a defined `eshell'-function, use that.

Inside COMMAND, % is replaced with the current file name.  To
insert a literal % quote it using a backslash.

These extentions can all be combined with one-another.

In case a region is active, `shell-command+' will only work with the region
between BEG and END.  Otherwise the whole buffer is processed.

(fn COMMAND BEG END)" t nil)
	     (shen-mode "Major mode for editing Shen code.

(fn)" t nil)
	     (inferior-shen "Run an inferior Shen process, input and output via buffer `*inferior-shen*'.
If there is a process already running in `*inferior-shen*', just switch
to that buffer.
With argument, allows you to edit the command line (default is value
of `inferior-shen-program').  Runs the hooks from
`inferior-shen-mode-hook' (after the `comint-mode-hook' is run).
(Type \\[describe-mode] in the process buffer for a list of commands.)

(fn CMD)" t nil)
	     (sisu-mode "Major mode for editing SiSU files.
SiSU document structuring, publishing in multiple formats and search.
URL `http://www.sisudoc.org/'

(fn)" t nil)
	     (slime-volleyball "Start a slime volleyball game." t nil)
	     (sm-c-mode "C editing mode based on SMIE.

(fn)" t nil)
	     (smalltalk-mode "Major mode for editing Smalltalk code.

Commands:
\\{smalltalk-mode-map}

(fn)" t nil)
	     (gst "Invoke GNU Smalltalk.

(fn COMMAND-LINE)" t nil)
	     (smart-yank-mode "Alter the behavior of yank commands in several ways.

If called interactively, toggle `Smart-Yank mode'.  If the prefix
argument is positive, enable the mode, and if it is zero or
negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

Turning on this mode has the following effects:

 - Makes any command except yank commands reset the
  `kill-ring-yank-pointer', instead of only killing commands.

 - Remaps `yank-pop' to `smart-yank-yank-pop'.

 - When yanking an older element from the `kill-ring' with
   \\[smart-yank-yank-pop] (and not replacing it with a subsequent \\[smart-yank-yank-pop]), the
   element is automatically \"moved to the first position\" of
   the `kill-ring' so that `yank' invoked later will again yank
   this element.

(fn &optional ARG)" t nil)
	     (sml-yacc-mode "Major Mode for editing ML-Yacc files.

(fn)" t nil)
	     (sml-lex-mode "Major Mode for editing ML-Lex files.

(fn)" t nil)
	     (sml-cm-mode "Major mode for SML/NJ's Compilation Manager configuration files.

(fn)" t nil)
	     (sml-mode "Major mode for editing Standard ML code.
This mode runs `sml-mode-hook' just before exiting.
See also (info \"(sml-mode)Top\").

(fn)" t nil)
	     (sml-run "Run the program CMD with given arguments ARG.
The command is run in buffer *CMD* using mode `inferior-sml-mode'.
If the buffer already exists and has a running process, then
just go to this buffer.

If a prefix argument is used, the user is also prompted for a HOST
on which to run CMD using `remote-shell-program'.

(Type \\[describe-mode] in the process's buffer for a list of commands.)

(fn CMD ARG &optional HOST)" t nil)
	     (sokoban "Sokoban.

Push the blocks onto the target squares.

sokoban-mode keybindings:
   \\<sokoban-mode-map>
\\[sokoban-start-game]	Starts a new game of Sokoban
\\[sokoban-restart-level]	Restarts the current level
\\[sokoban-goto-level]	Jumps to a specified level
\\[fit-frame-to-buffer]	Fit frame to buffer
\\[sokoban-save]	Save current state
\\[sokoban-load]	Restore saved state
\\[sokoban-move-left]	Move one square to the left
\\[sokoban-move-right]	Move one square to the right
\\[sokoban-move-up]	Move one square up
\\[sokoban-move-down]	Move one square down" t nil)
	     (speed-of-thought-hook-in "Add functions ON and OFF to `speed-of-thought-mode' hooks.
If `speed-of-thought-mode' is already on, call ON.

(fn ON OFF)" nil nil)
	     (speed-of-thought-mode "Toggle Speed-Of-Thought mode on or off.

If called interactively, toggle `Speed-Of-Thought mode'.  If the
prefix argument is positive, enable the mode, and if it is zero
or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

\\{speed-of-thought-mode-map}

(fn &optional ARG)" t nil)
	     (spinner-start "Start a mode-line spinner of given TYPE-OR-OBJECT.
If TYPE-OR-OBJECT is an object created with `make-spinner',
simply activate it.  This method is designed for minor modes, so
they can use the spinner as part of their lighter by doing:
    '(:eval (spinner-print THE-SPINNER))
To stop this spinner, call `spinner-stop' on it.

If TYPE-OR-OBJECT is anything else, a buffer-local spinner is
created with this type, and it is displayed in the
`mode-line-process' of the buffer it was created it.  Both
TYPE-OR-OBJECT and FPS are passed to `make-spinner' (which see).
To stop this spinner, call `spinner-stop' in the same buffer.

Either way, the return value is a function which can be called
anywhere to stop this spinner.  You can also call `spinner-stop'
in the same buffer where the spinner was created.

FPS, if given, is the number of desired frames per second.
Default is `spinner-frames-per-second'.

DELAY, if given, is the number of seconds to wait until actually
displaying the spinner. It is safe to cancel the spinner before
this time, in which case it won't display at all.

(fn &optional TYPE-OR-OBJECT FPS DELAY)" nil nil)
	     (spinner-create "Create a spinner of the given TYPE.
The possible TYPEs are described in `spinner--type-to-frames'.

FPS, if given, is the number of desired frames per second.
Default is `spinner-frames-per-second'.

If BUFFER-LOCAL is non-nil, the spinner will be automatically
deactivated if the buffer is killed.  If BUFFER-LOCAL is a
buffer, use that instead of current buffer.

When started, in order to function properly, the spinner runs a
timer which periodically calls `force-mode-line-update' in the
curent buffer.  If BUFFER-LOCAL was set at creation time, then
`force-mode-line-update' is called in that buffer instead.  When
the spinner is stopped, the timer is deactivated.

DELAY, if given, is the number of seconds to wait after starting
the spinner before actually displaying it. It is safe to cancel
the spinner before this time, in which case it won't display at
all.

(fn &optional TYPE BUFFER-LOCAL FPS DELAY)" nil nil)
	     (sql-beeline "Run beeline as an inferior process.

(fn &optional BUFFER)" t nil)
	     (sqlind-setup-style-default "Define an sql-indentation style where keywords are right aligned." t nil)
	     (sqlind-setup-style-right "Define an sql-indentation style where keywords are right aligned." t nil)
	     (sqlind-setup-style-left "Define an sql-indentation style where keywords are left aligned." t nil)
	     (sqlind-setup "Enable SQL syntactic indentation unconditionally.
This function is deprecated, consider using the function
`sqlind-minor-mode' instead." nil nil)
	     (sqlind-minor-mode "Toggle SQL syntactic indentation on or off.
With syntactic indentation, hitting TAB on a line in a SQL buffer
will indent the line according to the syntactic context of the
SQL statement being edited.

If called interactively, toggle `Sqlind minor mode'.  If the
prefix argument is positive, enable the mode, and if it is zero
or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

A set of alignment rules are also enabled with this minor mode.
Selecting a region of text and typing `M-x align RET` will align
the statements.  This can be used, for example, to align the 'as'
column aliases in select statements.

(fn &optional ARG)" t nil)
	     (svg-clock "Start/stop the svg clock.

(fn &key SIZE FOREGROUND BACKGROUND NO-SECONDS NO-FACE)" t nil)
	     (svg-clock-insert "Insert a self-updating image displaying an analog clock at point.
Optional argument SIZE the size of the clock in pixels.
Optional argument FOREGROUND the foreground color.
Optional argument BACKGROUND the background color.
Optional argument OFFSET the offset in seconds between current and displayed
time.
Optional argument NO-SECONDS says whether to do a seconds hand.
Optional argument NO-FACE says whether to decorate the face.

(fn &optional SIZE FOREGROUND BACKGROUND OFFSET NO-SECONDS NO-FACE)" nil nil)
	     (swiper-isearch-backward "Like `swiper-isearch' but the first result is before the point.

(fn &optional INITIAL-INPUT)" t nil)
	     (swiper-isearch "A `swiper' that's not line-based.

(fn &optional INITIAL-INPUT)" t nil)
	     (swiper-all "Run `swiper' for all open buffers.

(fn &optional INITIAL-INPUT)" t nil)
	     (swiper "`isearch-forward' with an overview.
When non-nil, INITIAL-INPUT is the initial search pattern.

(fn &optional INITIAL-INPUT)" t nil)
	     (swiper-all-thing-at-point "`swiper-all' with `ivy-thing-at-point'." t nil)
	     (swiper-thing-at-point "`swiper' with `ivy-thing-at-point'." t nil)
	     (swiper-backward "`isearch-backward' with an overview.
When non-nil, INITIAL-INPUT is the initial search pattern.

(fn &optional INITIAL-INPUT)" t nil)
	     (swiper-avy "Jump to one of the current swiper candidates." t nil)
	     (tNFA-regexp-match "Return non-nil if STRING matches REGEXP, nil otherwise.
Sets the match data if there was a match; see `match-beginning',
`match-end' and `match-string'.

REGEXP and STRING can be any sequence type (vector, list, or
string); they need not be actual strings. Special characters in
REGEXP are still just that: elements of the sequence that are
characters which have a special meaning in regexps.

The :test keyword argument specifies how to test whether two
individual elements of STRING are identical. The default is `eq'.

Only a subset of the full Emacs regular expression syntax is
supported. There is no support for regexp constructs that are
only meaningful for strings (character ranges and character
classes inside character alternatives, and syntax-related
backslash constructs). Back-references and non-greedy postfix
operators are not supported, so `?' after a postfix operator
loses its special meaning. Also, matches are always anchored, so
`$' and `^' lose their special meanings (use `.*' at the
beginning and end of the regexp to get an unanchored match).

(fn REGEXP STRING &key (TEST #\\='eq))" nil nil)
	     (tNFA-from-regexp "Create a tagged NFA that recognizes the regular expression REGEXP.
The return value is the initial state of the tagged NFA.

REGEXP can be any sequence type (vector, list, or string); it
need not be an actual string. Special characters in REGEXP are
still just that: elements of the sequence that are characters
which have a special meaning in regexps.

The :test keyword argument specifies how to test whether two
individual elements of STRING are identical. The default is `eq'.

Only a subset of the full Emacs regular expression syntax is
supported. There is no support for regexp constructs that are
only meaningful for strings (character ranges and character
classes inside character alternatives, and syntax-related
backslash constructs). Back-references and non-greedy postfix
operators are not supported, so `?' after a postfix operator
loses its special meaning. Also, matches are always anchored, so
`$' and `^' lose their special meanings (use `.*' at the
beginning and end of the regexp to get an unanchored match).

(fn REGEXP &key (TEST #\\='eq))" nil nil)
	     (temp-buffer-browse-mode "Toggle Temp-Buffer-Browse mode on or off.

If called interactively, toggle `Temp-Buffer-Browse mode'.  If
the prefix argument is positive, enable the mode, and if it is
zero or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

\\{temp-buffer-browse-mode-map}

(fn &optional ARG)" t nil)
	     (temp-buffer-browse-activate "Activate temporary key bindings for current window.
Specifically set up keys `SPC', `DEL' and `RET' to scroll up,
scroll down and close the temp buffer window, respectively." nil nil)
	     (test-simple-run "Register command line to run tests non-interactively and bind key to run test.
After calling this function, you can run test by key specified by `test-simple-runner-key'.

It is preferable to write at the first line of test files as a comment, e.g,
;;;; (test-simple-run \"emacs -batch -L %s -l %s\" (file-name-directory (locate-library \"test-simple.elc\")) buffer-file-name)

Calling this function interactively, COMMAND-LINE-FORMATS is set above.

(fn &rest COMMAND-LINE-FORMATS)" t nil)
	     (test-simple-clear "Initialize and reset everything to run tests.
You should run this before running any assertions.  Running more than once
clears out information from the previous run.

(fn &optional TEST-INFO TEST-START-MSG)" t nil)
	     (test-simple-start "

(fn &optional TEST-START-MSG)" nil t)
	     (tf-with-timeout "Like `with-timeout' but with support for unbreakable code.

Provides ability to inhibit timeout during parts of the body.
Note that most of the time, you may not need this functionality
at all unless you want to be very “clean” about things---you
could get by with the regular with-timeout and not using
sit-for's in the body.  Or with the regular with-timeout and
using unwind-protect.


A judicious use of `unwind-protect' may seem to alleviate the
need for this function. This function, however, provides
additional flexibility in that the inhibitedness can be altered
at run-time depending on various conditions.


Run BODY, but if it doesn't finish in SECONDS seconds, give up.
If we give up, we run the TIMEOUT-FORMS which are contained in TLIST
and return the value of the last one.
The call should look like:
 (tf-with-timeout quoted-expr (SECONDS TIMEOUT-FORMS...) BODY...)

The timeout is checked whenever Emacs waits for some kind of external
event (such as keyboard input, input from subprocesses, or a certain time);
if the program loops without waiting in any way, the timeout will not
be detected.  Furthermore:

During the execution of the body, we SHALL NOT time out when INHIBIT-VAR's
content is non-nil.  Thus, for example, you might initially setq a
variable my-var as nil, supply inhibitp as `my-var', and then you may
setq my-var to t or nil within the body of tf-with-timeout to enable
or disable timeout.  The best use of this functionality is to setq
inhibitp to t when during parts of loops where you do not want the
body broken within certain parts of the loop.  (Of course, if that
part of the loop does not contain any sit-for's or read's then you
don't have to worry about this in the first place..)


Again, Do not forget to bind my-var to some value before attempting to use this
tf-with-timeout :)

Here's an example:


 (let ((myinhibit t))
  (tf-with-timeout \\='myinhibit \\='mytag \\='mytimedoutvar
		   (2 2)
		   (setq a nil)
		   (setq b nil)
		   (sit-for 4)
		   (setq a 4)
		   (setq myinhibit nil)
		   (sit-for 2)
		   (setq b 5)
		   ))


The above example requests a timeout within 2 seconds.  However, the
timeout can takes place only when myinhibit is set to nil,
which becomes true after about 4 seconds.  Thus, after the execution of the
body, a has the value 4, but b has the value nil.

See `tf-test-timeout' for another example.

Important Note: If the body of a loop tends to stay in a timeout
inhibited region for most of the time, then make sure that the timeout
enabled region atleast spans about 0.02 seconds.. thus, use (sleep-for
0.02) if needed.. this is because we check every 0.01 seconds if an
uninhibited timeout condition has been satisfied.

But perhaps you do not want to include (sleep-for 0.02) because that
wastes precious cpu time.  Simple, don't include it, just after a long
inhibited body, you can include a timeout check within the body
instead of (sleep-for 0.02):
 (tf-with-timeout-check \\='mytag \\='mytimedoutvar \\='myinhibitp)

Moreover, if that is the main check you rely on, you it perhaps makes
sense to increase the value of `tf-with-timeout-repeat-sec', so that
your cpu cycles are not wasted every 0.01 sec.  See the doc of that
variable for more.

TIMERTAG should be a quoted symbol, also we WILL set that symbol to t
during the execution of these forms.

TIMEDOUTVAR is the variable that times out.

(fn INHIBIT-VAR TIMERTAG TIMEDOUTVAR TLIST &rest BODY)" nil t)
	     (tf-run-with-idle-timer "Similar to `run-with-idle-timer', except that provides more options.

Args are SECS, REPEAT, REDOSECS, REDOREPEAT, INCLUDERUNTIME,
FUNCTION and &rest ARGS.

Similar to `run-with-idle-timer', but provides more options.
Suppose you want Emacs to run an action every REDOSECS for as
long as Emacs remains idle.  Emacs' `run-with-idle-timer' will
perform the action exactly once every time Emacs goes idle.  This
function, on the other hand, will allow
you to keep performing an action as long as Emacs remains idle.

SECS is the number of seconds to wait once Emacs has first gone
idle or a function that returns this number when called with no arguments.
Note that the way `run-with-idle-timer' is defined, SECS will
unfortunately be called immediately after you call this function, but
REDOSECS will be *every* time Emacs *remains* idle..yay..

If REDOREPEAT is non-nil, the action is repeated as long Emacs remains
idle.  REDOSECS is the number of additional seconds (after the action
has been done) to wait if Emacs remains idle before performing the
action again.  Again, redosecs does not have to be a number, it can be
a function which yields such a number...

If INCLUDERUNTIME is non-nil, REDOSECS is the number of
additional seconds to wait after the action has been invoked (not
finished).

If REPEAT is nonnil, the entire cycle is repeated every time Emacs
next goes idle.. (as in the default `run-with-idle-timer').

(fn SECS REPEAT REDOSECS REDOREPEAT INCLUDERUNTIME FUNCTION &rest ARGS)" nil nil)
	     (tf-time-difference "Return the time in seconds elaspsed from TIMESUB to TIMEPLUS.

Conceptually:  (- TIMEPLUS TIMESUB ).

(fn TIMEPLUS TIMESUB)" nil nil)
	     (timerfunctions-introduction "Provides electric help from variable `timerfunctions-introduction'." t nil)
	     (tiny-helper "Helper function for `tiny-expand'.

The arguments to this function construct a “tiny expression”
\"mBSEO|F\" where
  E is the end value (END-VAL)     - defaults to 0 internally if nil or \"\",
                                      or 9 if BEGIN-VAL is nil or \"\" too.
  B is the begin value (BEGIN-VAL) - defaults to 0 internally if nil or \"\".
  S is the separator (SEP)         - defaults to \" \" if nil or \"\".
  O is the elisp operation (OP)    - defaults to \"\" if nil.
  F is the format (FMT)            - defaults to \"\" if nil.

If `tiny' expansion is possible at point, do it.
Otherwise activate the helper to generate a valid “tiny
expression” and expand that.

Usage: Call TINY-HELPER, ↵↵↵↵↵            -> 0 1 2 3 4 5 6 7 8 9
       Call TINY-HELPER, 9↵2↵_↵+1*x2↵↵    -> 5_7_9_11_13_15_17_19
       Call TINY-HELPER, 15↵1↵↵-30*2x↵%x↵ -> 1c 1a 18 16 14 12 10 e c a 8 6 4 2 0

(fn &optional END-VAL BEGIN-VAL SEP OP FMT)" t nil)
	     (tiny-expand "Expand current snippet.
It polls the expander functions one by one
if they can expand the thing at point.
First one to return a string succeeds.
These functions are expected to set `tiny-beg' and `tiny-end'
to the bounds of the snippet that they matched.
At the moment, only `tiny-mapconcat' is supported.
`tiny-mapconcat2' should be added to expand rectangles." t nil)
	     (transcribe-mode "Toggle transcribe-mode

If called interactively, toggle `Transcribe mode'.  If the prefix
argument is positive, enable the mode, and if it is zero or
negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (global-undo-tree-mode "Toggle Undo-Tree mode in all buffers.
With prefix ARG, enable Global Undo-Tree mode if ARG is positive;
otherwise, disable it.  If called from Lisp, enable the mode if
ARG is omitted or nil.

Undo-Tree mode is enabled in all buffers where
`turn-on-undo-tree-mode' would do it.

See `undo-tree-mode' for more information on
Undo-Tree mode.

(fn &optional ARG)" t nil)
	     (undo-tree-mode "Toggle undo-tree mode.
With no argument, this command toggles the mode.
A positive prefix argument turns the mode on.
A negative prefix argument turns it off.

If called interactively, toggle `Undo-Tree mode'.  If the prefix
argument is positive, enable the mode, and if it is zero or
negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

Undo-tree-mode replaces Emacs' standard undo feature with a more
powerful yet easier to use version, that treats the undo history
as what it is: a tree.

The following keys are available in `undo-tree-mode':

  \\{undo-tree-map}

Within the undo-tree visualizer, the following keys are available:

  \\{undo-tree-visualizer-mode-map}

(fn &optional ARG)" t nil)
	     (uniq-file-read "For `project-read-file-name-function'.

(fn PROMPT ALL-FILES &optional PREDICATE HIST DEFAULT)" nil nil)
	     (url-ntlm-auth "Return an NTLM HTTP authorization header.
Get the contents of the Authorization header for a HTTP response
using NTLM authentication, to access URL.  Because NTLM is a
two-step process, this function expects to be called twice, first
to generate the NTLM type 1 message (request), then to respond to
the server's type 2 message (challenge) with a suitable response.

url-get-authentication' calls `url-ntlm-auth' once when checking
what authentication schemes are supported (PROMPT and ARGS are
nil), and then twice for every stage of the handshake: the first
time PROMPT is nil, the second, t; ARGS contains the server
response's \"WWW-Authenticate\" header, munged by
`url-parse-args'.

If PROMPT is not t then this function just returns nil.  This is
to avoid calculating responses twice.

OVERWRITE and REALM are ignored.

ARGS is expected to contain the WWW-Authentication header from
the server's last response.  These are used by
`url-http-get-stage' to determine what stage we are at.

(fn URL &optional PROMPT OVERWRITE REALM ARGS)" nil nil)
	     (validate-mark-safe-local "Mark SYMBOL as a safe local if its custom type is obeyed.

(fn SYMBOL)" nil nil)
	     (validate-variable "Check that SYMBOL's value matches its schema.
SYMBOL must be the name of a custom option with a defined
`custom-type'. If SYMBOL has a value and a type, they are checked
with `validate-value'. NOERROR is passed to `validate-value'.

(fn SYMBOL &optional NOERROR)" nil nil)
	     (validate-value "Check that VALUE matches SCHEMA.
If it matches return VALUE, otherwise signal a `user-error'.

If NOERROR is non-nil, return t to indicate a match and nil to
indicate a failure.

(fn VALUE SCHEMA &optional NOERROR)" nil nil)
	     (valign-mode "Visually align Org tables.

If called interactively, toggle `Valign mode'.  If the prefix
argument is positive, enable the mode, and if it is zero or
negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (valign-table "Visually align the table at point." t nil)
	     (vcard-parse-buffer "Parse current buffer, containing vCard data.
Returns a list of contact objects." t nil)
	     (vcard-parse-file "Parse FILE containing vCard data into an alist.

(fn FILE)" t nil)
	     (vcard-mode "Major mode for viewing vCard files.

(fn)" t nil)
	     (vcl-mode "Major mode for editing Varnish Configuration Language code.

Key bindings:
\\{vcl-mode-map}

(fn)" t nil)
	     (vdiff-current-file "Start vdiff between current buffer and its file on disk.
This command can be used instead of `revert-buffer'.  If there is
nothing to revert then this command fails." t nil)
	     (vdiff-files3 "Start a vdiff session with 3 files. If called interactively,
you will be asked to select two files.

(fn FILE-A FILE-B FILE-C &optional ON-QUIT)" t nil)
	     (vdiff-merge-conflict "Start vdiff session using merge conflicts marked in FILE.

(fn FILE &optional RESTORE-WINDOWS-ON-QUIT)" t nil)
	     (vdiff-buffers3 "Start a vdiff session. If called interactively, you will be
asked to select two buffers. ON-QUIT is a function to run on
exiting the vdiff session. It is called with the three vdiff
buffers as arguments. The last two options, RESTORE-WINDOWS-ON-QUIT and
KILL-BUFFERS-ON-QUIT restore the previous window configuration
and kill the vdiff buffers after quitting vdiff. Note that if you
are going to kill the buffers you should probably be using a
function for ON-QUIT to do something useful with the result.

(fn BUFFER-A BUFFER-B BUFFER-C &optional ON-QUIT RESTORE-WINDOWS-ON-QUIT KILL-BUFFERS-ON-QUIT)" t nil)
	     (vdiff-buffers "Start a vdiff session. If called interactively, you will be
asked to select two buffers. ROTATE adjusts the buffer's
initial layout. A prefix argument can be used to set this
variable interactively. ON-QUIT is a function to run on exiting
the vdiff session. It is called with the two vdiff buffers as
arguments. The last two options, RESTORE-WINDOWS-ON-QUIT and
KILL-BUFFERS-ON-QUIT restore the previous window configuration
and kill the vdiff buffers after quitting vdiff. Note that if you
are going to kill the buffers you should probably be using a
function for ON-QUIT to do something useful with the result.

(fn BUFFER-A BUFFER-B &optional ROTATE ON-QUIT RESTORE-WINDOWS-ON-QUIT KILL-BUFFERS-ON-QUIT)" t nil)
	     (vdiff-files "Start a vdiff session. If called interactively, you will be
asked to select two files. ROTATE adjusts the buffer's
initial layout. A prefix argument can be used to set this
variable interactively. ON-QUIT is a function to run on exiting
the vdiff session. It is called with the two vdiff buffers as
arguments.

(fn FILE-A FILE-B &optional ROTATE ON-QUIT)" t nil)
	     (vigenere-encrypt-buffer "Encrypt the current buffer with a Vigenere cipher using KEY.

Note: A Vigenere cipher should not be considered
cryptographically secure.

(fn KEY)" t nil)
	     (vigenere-decrypt-buffer "Decrypt the current buffer with a Vigenere cipher using KEY.

Note: A Vigenere cipher should not be considered
cryptographically secure.

(fn KEY)" t nil)
	     (vigenere-encrypt-region "Encrypt region from BEGIN to END with a Vigenere cipher using KEY.

Note: A Vigenere cipher should not be considered
cryptographically secure.

(fn KEY BEGIN END)" t nil)
	     (vigenere-decrypt-region "Decrypt region from BEGIN to END with a Vigenere cipher using KEY.

Note: A Vigenere cipher should not be considered
cryptographically secure.

(fn KEY BEGIN END)" t nil)
	     (visual-fill-mode "Auto-refill paragraphs without modifying the buffer.

If called interactively, toggle `Visual-Fill mode'.  If the
prefix argument is positive, enable the mode, and if it is zero
or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (vlf-occur-load "Load serialized `vlf-occur' results from current buffer." t nil)
	     (vlf-ediff-files "Run batch by batch ediff over FILE-A and FILE-B.
Files are processed with VLF with BATCH-SIZE chunks.
Requesting next or previous difference at the end or beginning
respectively of difference list, runs ediff over the adjacent chunks.

(fn FILE-A FILE-B BATCH-SIZE)" t nil)
	     (vlf "View Large FILE in batches.  When MINIMAL load just a few bytes.
You can customize number of bytes displayed by customizing
`vlf-batch-size'.
Return newly created buffer.

(fn FILE &optional MINIMAL)" t nil)
	     (wcheck-actions "Offer actions for marked text.

This function is usually called through a right mouse button
event or interactively by a user. In both cases function's
arguments are filled automatically.

If buffer position POS is on marked text (and action program is
properly configured) show a menu of actions. When this function
is called interactively POS is automatically the current point
position. Optional EVENT argument is a mouse event which is
present if this function is called through a right mouse button
click on marked text. If EVENT is non-nil use a graphic toolkit's
menu (when available) for selecting actions. Otherwise use a text
menu.

When user chooses one of the options from the menu the related
action is executed. It could mean that the original marked text
is replaced with the chosen substitute. Menu options can trigger
any kind of actions, though.

(fn POS &optional EVENT)" t nil)
	     (wcheck-jump-backward "Move point backward to previous marked text area." t nil)
	     (wcheck-jump-forward "Move point forward to next marked text area." t nil)
	     (wcheck-mode "General interface for text checkers.

With optional (prefix) ARG turn on the mode if ARG is positive,
otherwise turn it off. If ARG is not given toggle the mode.

Wcheck is a minor mode for automatically checking and marking
strings in Emacs buffer. Wcheck sends (parts of) buffer's content
to a text-checker back-end and, relying on its output, decides if
some parts of text should be marked.

Wcheck can be used with external spell-checker programs such as
Ispell and Enchant, but actually any tool that can receive text
stream from standard input and send text to standard output can
be used. The checker back-end can also be an Emacs Lisp function.

Different configuration units are called \"languages\". See the
documentation of variables `wcheck-language-data',
`wcheck-language-data-defaults' and `wcheck-language' for
information on how to configure Wcheck mode. You can access and
configure the variables through customize group `wcheck'.

Interactive command `wcheck-change-language' is used to switch
languages. Command `wcheck-actions' gives an action menu for the
marked text at point (also accessible through the right-click
mouse menu). Commands `wcheck-jump-forward' and
`wcheck-jump-backward' move point to next/previous marked text
area.

A note for Emacs Lisp programmers: Emacs Lisp function
`wcheck-marked-text-at' returns information about marked text at
a buffer position. Function `wcheck-query-language-data' can be
used for querying effective configuration data for any language.

(fn &optional ARG)" t nil)
	     (wcheck-change-language "Change language for current buffer (or globally).
Change `wcheck-mode' language to LANGUAGE. The change is
buffer-local but if GLOBAL is non-nil (prefix argument if called
interactively) then change the global default language.

(fn LANGUAGE &optional GLOBAL)" t nil)
	     (wconf-create "Clone the current configuration or create a new \"empty\" one.
The new configuration is appended to the list and becomes active.

With optional prefix argument NEW, or if there are no
configurations yet, create a new configuration from the current
window config.

(fn &optional NEW)" t nil)
	     (wconf-load "Load stored configurations from FILENAME, defaults to
`wconf-file'.

(fn &optional FILENAME)" t nil)
	     (ws-start "Start a server using HANDLERS and return the server object.

HANDLERS may be a single function (which is then called on every
request) or a list of conses of the form (MATCHER . FUNCTION),
where the FUNCTION associated with the first successful MATCHER
is called.  Handler functions are called with two arguments, the
process and the request object.

A MATCHER may be either a function (in which case it is called on
the request object) or a cons cell of the form (KEYWORD . STRING)
in which case STRING is matched against the value of the header
specified by KEYWORD.

Any supplied NETWORK-ARGS are assumed to be keyword arguments for
`make-network-process' to which they are passed directly.

For example, the following starts a simple hello-world server on
port 8080.

  (ws-start
   (lambda (request)
     (with-slots (process headers) request
       (process-send-string process
        \"HTTP/1.1 200 OK\\r\\nContent-Type: text/plain\\r\\n\\r\\nhello world\")))
   8080)

Equivalently, the following starts an identical server using a
function MATCH and the `ws-response-header' convenience
function.

  (ws-start
   \\='(((lambda (_) t) .
      (lambda (proc request)
        (ws-response-header proc 200 \\='(\"Content-type\" . \"text/plain\"))
        (process-send-string proc \"hello world\")
        t)))
   8080)

(fn HANDLERS PORT &optional LOG-BUFFER &rest NETWORK-ARGS)" nil nil)
	     (webfeeder-build "Build a WEBFEED out of HTML-FILES.
The WEBFEED is an XML file that contains every blog post in a
machine-readable format.

The WEBFEED file is stored in PROJECT-DIR where HTML-FILES are
also assumed to reside.

For more details on the other arguments, see
`webfeeder-make-atom', `webfeeder-make-rss' and
`webfeeder-html-files-to-items'.

(fn WEBFEED PROJECT-DIR URL HTML-FILES &key TITLE SUBTITLE DESCRIPTION AUTHOR GENERATOR BUILD-DATE PREDICATE MAX-ENTRIES (BUILDER \\='webfeeder-make-atom))" nil nil)
	     (webfeeder-make-atom "Return a webfeed string in Atom format that contains every FEED-ITEMS.

WEBFEED is the path where the feed is intended to be stored,
relative to URL.

A feed can have a TITLE: if not, the URL will be used.

When BUILD-DATE is nil, use `current-time'.  Otherwise it can be
a time expression as in `current-time'.  0 means EPOCH.

When provided, FEED-ITEMS are only added if (PREDICATE FEED-ITEM)
returns non-nil.

The number of items is limited to MAX-ENTRIES.  When nil, all
items are included.

FEED-ITEMS can be generated with `webfeeder-html-files-to-items'.

(fn WEBFEED URL FEED-ITEMS &key TITLE SUBTITLE AUTHOR GENERATOR BUILD-DATE PREDICATE MAX-ENTRIES &allow-other-keys)" nil nil)
	     (webfeeder-make-rss "Return a webfeed string in RSS format that contains every FEED-ITEMS.

WEBFEED is the path where the feed is intended to be stored,
relative to URL.

A feed can have a TITLE and DESCRIPTION: if not, the URL will be
used.

When BUILD-DATE is nil, use `current-time'.  Otherwise it can be
a time expression as in `current-time'.  0 means EPOCH.

When provided, FEED-ITEMS are only added if (PREDICATE FEED-ITEM)
returns non-nil.

The number of items is limited to MAX-ENTRIES.  When nil, all
items are included.

FEED-ITEMS can be generated with `webfeeder-html-files-to-items'.

(fn WEBFEED URL FEED-ITEMS &key TITLE DESCRIPTION AUTHOR GENERATOR BUILD-DATE PREDICATE MAX-ENTRIES &allow-other-keys)" nil nil)
	     (webfeeder-html-files-to-items "Parse the source HTML-FILES and return a list of webfeeder-items.
PROJECT-DIR is where HTML files are also assumed to reside.
PROJECT-DIR is the local root of the website hosted at URL.
HTML parsing details can be customized through the following
variables:
- `webfeeder-author-function'
- `webfeeder-date-function'
- `webfeeder-title-function'
- `webfeeder-subtitle-function'
- `webfeeder-body-function'.
- `webfeeder-categories-function'.
- `webfeeder-generator-function'.

(fn PROJECT-DIR URL HTML-FILES)" nil nil)
	     (windresize "Resize windows interactively.
INCREMENT is the number of lines by which borders should move.

By default, the method for resizing is by moving the borders.
The left/right key will move the only movable vertical border to
the left/right and the up/down key will move the only horizontal
movable border up/down.  If there are two movable borders, the
right and the bottom border will have priority over the left and
upper border.  You can reverse this priority by using \\[windresize-left-force-left],
\\[windresize-right-force-left], etc.

Resizing can also be done by increasing/decreasing the window
width and height.  The up and down arrow keys will enlarge or
shrink the window vertically and the right and left arrow keys
will enlarge or shrink the window horizontally.

You can toggle the method with \\[windresize-toggle-method].

You can set the number of line by which a border should move by
calling \\[windresize-set-increment] with a numeric prefix.
You can temporarily negate the number of lines by which the
windows are resized by using \\[windresize-left-minus], \\[windresize-right-minus], etc.
If you want to permanently negate this increment value,
use `\\[windresize-negate-increment]' instead.

You can also save window configurations with `\\[windresize-save-window-configuration]' in a ring,
and restore them with `\\[windresize-restore-window-configuration]'.

`\\[windresize-cancel-and-quit]' will quit `windresize' and cancel any change.  `\\[windresize-exit]'
will set the new window configuration and exit.

\\{windresize-map}

(fn &optional INCREMENT)" t nil)
	     (wisitoken-grammar-mode "A major mode for Wisi grammar files.

(fn)" t nil)
	     (100secwp "Start game." t nil)
	     (xclip-mode "Minor mode to use the `xclip' program to copy&paste.

If called interactively, toggle `Xclip mode'.  If the prefix
argument is positive, enable the mode, and if it is zero or
negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     (xpm-m2z-circle "Like `xpm-m2z-ellipse' with a shared radius RADIUS.

(fn CX CY RADIUS)" nil nil)
	     (xpm-m2z-ellipse "Return an ellipse with center (CX,CY) and radii RX and RY.
Both CX and CY must be non-integer, preferably
precisely half-way between integers, e.g., 13/2 => 6.5.
The ellipse is represented as a list of unique XPM coords,
with the \"span\", i.e., (- HI LO -1), of the extreme X and Y
components equal to twice the rounded (to integer) value of
RX and RY, respectively.  For example:

 (xpm-m2z-ellipse 1.5 3.5 5.8 4.2)
 => list of length 20

    min  max  span
 X   -3    6    10
 Y    0    7     8

The span is always an even number.  As a special case, if the
absolute value of RX or RY is less than 1, the value is nil.

(fn CX CY RX RY)" nil nil)
	     (xpm-generate-buffer "Return a new buffer in XPM image format.
In this buffer, undo is disabled (see `buffer-enable-undo').

NAME is the buffer and XPM name.  For best interoperation
with other programs, NAME should be a valid C identifier.
WIDTH, HEIGHT and CPP are integers that specify the image
width, height and characters/pixel, respectively.

PALETTE is an alist ((PX . COLOR) ...), where PX is either
a character or string of length CPP, and COLOR is a string.
If COLOR includes a space, it is included directly,
otherwise it is automatically prefixed with \"c \".

For example, to produce palette fragment:

 \"X  c blue\",
 \"Y  s border c green\",

you can specify PALETTE as:

 ((?X . \"blue\")
  (?Y . \"s border c green\"))

This example presumes CPP is 1.

(fn NAME WIDTH HEIGHT CPP PALETTE)" nil nil)
	     (xpm-grok "Analyze buffer and prepare internal data structures.
When called as a command, display in the echo area a
summary of image dimensions, cpp and palette.
Set buffer-local variable `xpm--gg' and return its value.
Normally, preparation includes making certain parts of the
buffer intangible.  Optional arg SIMPLE non-nil inhibits that.

(fn &optional SIMPLE)" t nil)
	     (xr-skip-set-pp "Convert a skip set string to `rx' notation and pretty-print.
This function uses `xr-skip-set' to translate SKIP-SET-STRING
into DIALECT.
It is intended for use from an interactive elisp session.
See `xr' for a description of the DIALECT argument.

(fn SKIP-SET-STRING &optional DIALECT)" nil nil)
	     (xr-pp "Convert to `rx' notation and output the pretty-printed result.
This function uses `xr' to translate RE-STRING into DIALECT.
It is intended for use from an interactive elisp session.
See `xr' for a description of the DIALECT argument.

(fn RE-STRING &optional DIALECT)" nil nil)
	     (xr-skip-set-lint "Detect dubious practices and possible mistakes in SKIP-SET-STRING.
This includes uses of tolerated but discouraged constructs.
Outright syntax violations are signalled as errors.
The argument is interpreted according to the syntax of
`skip-chars-forward' and `skip-chars-backward'.
Return a list of (OFFSET . COMMENT) where COMMENT applies at OFFSET
in SKIP-SET-STRING.

(fn SKIP-SET-STRING)" nil nil)
	     (xr-lint "Detect dubious practices and possible mistakes in RE-STRING.
This includes uses of tolerated but discouraged constructs.
Outright regexp syntax violations are signalled as errors.
If PURPOSE is `file', perform additional checks assuming that RE-STRING
is used to match a file name.
Return a list of (OFFSET . COMMENT) where COMMENT applies at OFFSET
in RE-STRING.

(fn RE-STRING &optional PURPOSE)" nil nil)
	     (xr-skip-set "Convert a skip set string argument to rx notation.
SKIP-SET-STRING is interpreted according to the syntax of
`skip-chars-forward' and `skip-chars-backward' and converted to
a character class on `rx' form.
If desired, `rx' can then be used to convert the result to an
ordinary regexp.
See `xr' for a description of the DIALECT argument.

(fn SKIP-SET-STRING &optional DIALECT)" nil nil)
	     (xr "Convert a regexp string to rx notation; the inverse of `rx'.
Passing the returned value to `rx' (or `rx-to-string') yields a regexp string
equivalent to RE-STRING.  DIALECT controls the choice of keywords,
and is one of:
`verbose'       -- verbose keywords
`brief'         -- short keywords
`terse'         -- very short keywords
`medium' or nil -- a compromise (the default)

(fn RE-STRING &optional DIALECT)" nil nil)
	     (snippet-mode "A mode for editing yasnippets" t nil)
	     (yas-global-mode "Toggle Yas minor mode in all buffers.
With prefix ARG, enable Yas-Global mode if ARG is positive;
otherwise, disable it.  If called from Lisp, enable the mode if
ARG is omitted or nil.

Yas minor mode is enabled in all buffers where
`yas-minor-mode-on' would do it.

See `yas-minor-mode' for more information on
Yas minor mode.

(fn &optional ARG)" t nil)
	     (yas-minor-mode "Toggle YASnippet mode.

If called interactively, toggle `Yas minor mode'.  If the prefix
argument is positive, enable the mode, and if it is zero or
negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

When YASnippet mode is enabled, `yas-expand', normally bound to
the TAB key, expands snippets of code depending on the major
mode.

With no argument, this command toggles the mode.
positive prefix argument turns on the mode.
Negative prefix argument turns off the mode.

Key bindings:
\\{yas-minor-mode-map}

(fn &optional ARG)" t nil)
	     (ztree-view-on-window-configuration-changed "Hook called then window configuration changed to resize buffer's contents" nil nil)
	     (ztree-mode "A major mode for displaying the directory tree in text mode.

(fn)" t nil)
	     (ztree-dir "Create an interactive buffer with the directory tree of the PATH given.

(fn PATH)" t nil)
	     (ztree-diff "Create an interactive buffer with the directory tree of the path given.
Argument DIR1 left directory.
Argument DIR2 right directory.

(fn DIR1 DIR2)" t nil)
	     (ztreediff-mode "A minor mode for displaying the difference of the directory trees in text mode.

If called interactively, toggle `ZtreeDiff mode'.  If the prefix
argument is positive, enable the mode, and if it is zero or
negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

The mode's hook is called both when the mode is enabled and when
it is disabled.

(fn &optional ARG)" t nil)
	     ))
  (let ((f (car x)))
    (unless (fboundp f)
      (apply #'autoload f "gnu-elpa" (cdr x)))))
(unless (fboundp 'pcomplete/ack-grep) (defalias 'pcomplete/ack-grep 'pcomplete/ack))
(unless (fboundp 'aggressive-indent-global-mode) (defalias 'aggressive-indent-global-mode #'global-aggressive-indent-mode))
(add-to-list 'auto-mode-alist '("\\.trf?\\'" . arbitools-mode))
(add-to-list 'auto-mode-alist '("\\.bnf\\'" . bnf-mode))
(add-to-list 'auto-mode-alist '("\\.pgn\\'" . chess-pgn-mode))
(unless (fboundp 'pgn-mode) (defalias 'pgn-mode 'chess-pgn-mode))
(unless (fboundp 'chess-session) (defalias 'chess-session 'chess))
(add-to-list 'auto-mode-alist '("Cakefile" . coffee-mode))
(add-to-list 'auto-mode-alist '("\\.coffee\\'" . coffee-mode))
(add-to-list 'auto-mode-alist '("\\.tsv\\'" . tsv-mode))
(add-to-list 'auto-mode-alist '("\\.[Cc][Ss][Vv]\\'" . csv-mode))
(unless (fboundp 'dictree-create-custom) (defalias 'dictree-create-custom 'make-dictree-custom))
(unless (fboundp 'dictree-create) (defalias 'dictree-create 'make-dictree))
(add-to-list 'auto-mode-alist '("\\.djvu\\'" . djvu-dummy-mode))
(add-to-list 'auto-mode-alist '("\\.dtsi?\\'" . dts-mode))
(unless (fboundp 'easy-mark-sexp) (defalias 'easy-mark-sexp 'easy-mark "Use `easy-mark' instead. The alias may be removed in future."))
(unless (fboundp 'gited-list) (defalias 'gited-list 'gited-list-branches))
(add-to-list 'auto-mode-alist '("\\.gle\\'" . gle-mode))
(unless (fboundp 'heap-create) (defalias 'heap-create 'make-heap))
(add-to-list 'auto-mode-alist '("\\.jgr\\'" . jgraph-mode))
(add-to-list 'auto-mode-alist '("\\.json\\'" . json-mode))
(unless (fboundp 'landmark-repeat) (defalias 'landmark-repeat 'landmark-test-run))
(add-to-list 'auto-mode-alist '("\\.elmc\\'" . lmc-asm-mode))
(add-to-list 'auto-mode-alist '("\\.omn\\'" . omn-mode))
(add-to-list 'auto-mode-alist '("\\.pomn\\'" . omn-mode))
(unless (fboundp 'global-on-screen-mode) (defalias 'global-on-screen-mode 'on-screen-global-mode))
(add-to-list 'auto-mode-alist '("\\.sps\\'" . pspp-mode))
(add-to-list 'auto-mode-alist '("\\.rnc\\'" . rnc-mode))
(add-to-list 'interpreter-mode-alist '("sed" . sed-mode))
(add-to-list 'auto-mode-alist '("\\.sed\\'" . sed-mode))
(add-to-list 'auto-mode-alist '("\\.shen\\'" . shen-mode))
(unless (fboundp 'run-shen) (defalias 'run-shen 'inferior-shen))
(add-to-list 'auto-mode-alist '("\\.ss[imt]\\'" . sisu-mode))
(add-to-list 'auto-mode-alist '("\\.st\\'" . smalltalk-mode))
(add-to-list 'auto-mode-alist '("\\.grm\\'" . sml-yacc-mode))
(add-to-list 'auto-mode-alist '("\\.cm\\'" . sml-cm-mode))
(add-to-list 'auto-mode-alist '("\\.s\\(ml\\|ig\\)\\'" . sml-mode))
(unless (fboundp 'run-sml) (defalias 'run-sml 'sml-run))
(add-to-list 'auto-mode-alist '("\\.[Vv][Cc][Ff]\\'" . vcard-mode))
(add-to-list 'auto-mode-alist (cons (purecopy "\\.vcl\\'") 'vcl-mode))
(add-to-list 'auto-mode-alist '("\\.wy\\'" . wisitoken-grammar-mode))
(defconst gnu-elpa--autoloads-table '(("ace-" . "ace-window") ("ack" . "ack") ("adaptive-wrap-prefix-mode" . "adaptive-wrap") ("adjust-parens-mode" . "adjust-parens") ("advice-patch" . "advice-patch") ("aggressive-indent-" . "aggressive-indent") ("all" . "all") ("ampc" . "ampc") ("arbitools-mode" . "arbitools") ("aa2u" . "ascii-art-to-unicode") ("async-" . "async") ("aumix" . "aumix-mode") ("auto-correct-" . "auto-correct") ("auto-overlay" . "auto-overlays") ("pcomplete/a" . "ack") ("provide-me" . "load-relative") ("pabbrev-mode" . "pabbrev") ("paced-" . "paced") ("phps-mode-" . "phps-mode") ("pinentry-start" . "pinentry") ("poker" . "poker") ("posframe-" . "posframe") ("pspp-mode" . "pspp-mode") ("global-aggressive-indent-mode" . "aggressive-indent") ("global-captain-mode" . "captain") ("global-compact-docstrings-mode" . "compact-docstrings") ("global-diff-hl-" . "diff-hl") ("global-nlinum-mode" . "nlinum") ("global-num3-mode" . "num3-mode") ("global-pabbrev-mode" . "pabbrev") ("global-quarter-plane-mode" . "quarter-plane") ("global-undo-tree-mode" . "undo-tree") ("gle-mode" . "gle-mode") ("gnorb-ebdb-link-" . "ebdb-gnorb") ("gnome-c-" . "gnome-c-style") ("gnu-elpa-keyring-update" . "gnu-elpa-keyring-update") ("gnugo" . "gnugo") ("gnus-mock-" . "gnus-mock") ("gcmh-mode" . "gcmh") ("ggtags-" . "ggtags") ("gited-list-branches" . "gited") ("gpastel-mode" . "gpastel") ("greader-" . "greader") ("greenbar-mode" . "greenbar") ("guess-language-mode" . "guess-language") ("gst" . "smalltalk-mode") ("dired-async-" . "async") ("dired-du-" . "dired-du") ("dired-git-info-" . "dired-git-info") ("dictree-" . "dict-tree") ("diff-hl-" . "diff-hl") ("diffview-" . "diffview") ("disk-usage" . "disk-usage") ("dismal-mode" . "dismal") ("darkroom-" . "darkroom") ("dbus-codegen-" . "dbus-codegen") ("delight" . "delight") ("define-hook-" . "hook-helpers") ("define-namespace" . "names") ("defhydra" . "hydra") ("djvu-" . "djvu") ("docbook-find-file" . "docbook") ("dts-mode" . "dts-mode") ("beacon-" . "beacon") ("bluetooth-list-devices" . "bluetooth") ("bnf-mode" . "bnf-mode") ("brief-" . "brief") ("buffer-expose" . "buffer-expose") ("bug-hunter-" . "bug-hunter") ("caps-lock-mode" . "caps-lock") ("captain-mode" . "captain") ("chess" . "chess") ("clipboard-collector-" . "clipboard-collector") ("cobol-mode" . "cobol-mode") ("coffee-mode" . "coffee-mode") ("compact-docstrings-mode" . "compact-docstrings") ("company-ebdb" . "company-ebdb") ("company-math-symbols-" . "company-math") ("company-latex-commands" . "company-math") ("company-statistics-mode" . "company-statistics") ("context-coloring-" . "context-coloring") ("copy-gnorb-ebdb-link" . "ebdb-gnorb") ("cpio-" . "cpio-mode") ("crisp-mode" . "crisp") ("create-hook-helper" . "hook-helpers") ("csv-mode" . "csv-mode") ("cycle-quotes" . "cycle-quotes") ("tsv-mode" . "csv-mode") ("turn-on-diff-hl-mode" . "diff-hl") ("turn-on-hes-mode" . "highlight-escape-sequences") ("turn-off-hes-mode" . "highlight-escape-sequences") ("tNFA-" . "tNFA") ("temp-buffer-browse-" . "temp-buffer-browse") ("test-simple-" . "test-simple") ("tf-" . "timerfunctions") ("timerfunctions-introduction" . "timerfunctions") ("tiny-" . "tiny") ("transcribe-mode" . "transcribe") ("read-dict" . "dict-tree") ("require-relative" . "load-relative") ("register-list" . "register-list") ("relint-" . "relint") ("repology" . "repology") ("rails-routes-find" . "rails-routes") ("rainbow-mode" . "rainbow-mode") ("rcirc-menu" . "rcirc-menu") ("rich-minority-mode" . "rich-minority") ("rm--mode-list-as-string-list" . "rich-minority") ("rnc-mode" . "rnc-mode") ("make-dictree" . "dict-tree") ("make-heap" . "heap") ("markchars-" . "markchars") ("memory-usage" . "memory-usage") ("metar" . "metar") ("midikbd-open" . "midi-kbd") ("mines" . "mines") ("minibuffer-line-mode" . "minibuffer-line") ("minimap-mode" . "minimap") ("mmm-add-classes" . "mmm-mode") ("multishell-" . "multishell") ("log-session-mode" . "dismal") ("load-dirs" . "load-dir") ("load-relative" . "load-relative") ("loccur" . "loccur") ("landmark" . "landmark") ("leaf" . "leaf") ("lex-" . "lex") ("lmc-asm-mode" . "lmc") ("easy-" . "easy-kill") ("ediprolog-" . "ediprolog") ("eev-beginner" . "eev") ("eglot" . "eglot") ("eldoc-" . "eldoc-eval") ("electric-spacing-mode" . "electric-spacing") ("elisp-benchmarks-run" . "elisp-benchmarks") ("enwc" . "enwc") ("epoch-view-mode" . "epoch-view") ("exco" . "excorporate") ("er/expand-region" . "expand-region") ("filladapt-mode" . "filladapt") ("find-file-noselect-relative" . "load-relative") ("frame-tabs-mode" . "frame-tabs") ("frog-menu-" . "frog-menu") ("hes-mode" . "highlight-escape-sequences") ("html-erb-mode" . "mmm-mode") ("nxml-html5-dt-compile" . "html5-schema") ("nxml-web-mode" . "mmm-mode") ("nameless-mode" . "nameless") ("nhexl-mode" . "nhexl-mode") ("nlinum-mode" . "nlinum") ("notes-" . "notes-mode") ("num3-mode" . "num3-mode") ("ivy-switch-" . "ivy") ("ivy-mode" . "ivy") ("ivy-completing-read" . "ivy") ("ivy-re" . "ivy") ("ivy-explorer-mode" . "ivy-explorer") ("ivy-posframe-mode" . "ivy-posframe") ("inferior-shen" . "shen-mode") ("javaimp-" . "javaimp") ("jgraph-mode" . "jgraph-mode") ("js2-" . "js2-mode") ("json-mode" . "json-mode") ("jumpc" . "jumpc") ("org-kiwix-setup-link" . "kiwix") ("org-edna-" . "org-edna") ("orgalist-mode" . "orgalist") ("oauth2-" . "oauth2") ("omn-mode" . "omn-mode") ("on-screen-" . "on-screen") ("osc-" . "osc") ("other-frame-window-mode" . "other-frame-window") ("kiwix-" . "kiwix") ("with-relative-file" . "load-relative") ("windresize" . "windresize") ("wisitoken-grammar-mode" . "wisitoken-grammar-mode") ("wcheck-" . "wcheck-mode") ("wconf-" . "wconf") ("ws-start" . "web-server") ("webfeeder-" . "webfeeder") ("__FILE__" . "load-relative") ("style-format" . "psgml") ("sgml-mode" . "psgml") ("scroll-restore-mode" . "scroll-restore") ("sed-mode" . "sed-mode") ("shelisp-mode" . "shelisp") ("shell-command+" . "shell-command+") ("shen-mode" . "shen-mode") ("sisu-mode" . "sisu-mode") ("slime-volleyball" . "slime-volleyball") ("sm-c-mode" . "sm-c-mode") ("smalltalk-mode" . "smalltalk-mode") ("smart-yank-mode" . "smart-yank") ("sml-" . "sml-mode") ("sokoban" . "sokoban") ("speed-of-thought-" . "sotlisp") ("spinner-" . "spinner") ("sql-beeline" . "sql-beeline") ("sqlind-" . "sql-indent") ("svg-clock" . "svg-clock") ("swiper" . "swiper") ("snippet-mode" . "yasnippet") ("xml-mode" . "psgml") ("xclip-mode" . "xclip") ("xpm-" . "xpm") ("xr" . "xr") ("quarter-plane-mode" . "quarter-plane") ("undo-tree-mode" . "undo-tree") ("uniq-file-read" . "uniquify-files") ("url-ntlm-auth" . "url-http-ntlm") ("validate-" . "validate") ("valign-" . "valign") ("vcard-" . "vcard") ("vcl-mode" . "vcl-mode") ("vdiff-" . "vdiff") ("vigenere-" . "vigenere") ("visual-fill-mode" . "visual-fill") ("vlf" . "vlf") ("100secwp" . "wpuzzle") ("yas-" . "yasnippet") ("ztree" . "ztree")))

;; Local Variables:
;; version-control: never
;; no-update-autoloads: t
;; End:

(provide 'gnu-elpa-features)
;;; gnu-elpa-features.el ends here
