about summary refs log tree commit diff
path: root/configs/shared/emacs/.emacs.d/elpa/magit-20180913.1247/magit.info-2
diff options
context:
space:
mode:
Diffstat (limited to 'configs/shared/emacs/.emacs.d/elpa/magit-20180913.1247/magit.info-2')
-rw-r--r--configs/shared/emacs/.emacs.d/elpa/magit-20180913.1247/magit.info-22676
1 files changed, 2676 insertions, 0 deletions
diff --git a/configs/shared/emacs/.emacs.d/elpa/magit-20180913.1247/magit.info-2 b/configs/shared/emacs/.emacs.d/elpa/magit-20180913.1247/magit.info-2
new file mode 100644
index 000000000000..ef180cef00b4
--- /dev/null
+++ b/configs/shared/emacs/.emacs.d/elpa/magit-20180913.1247/magit.info-2
@@ -0,0 +1,2676 @@
+This is magit.info, produced by makeinfo version 6.5 from magit.texi.
+
+     Copyright (C) 2015-2018 Jonas Bernoulli <jonas@bernoul.li>
+
+     You can redistribute this document 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 document 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.
+INFO-DIR-SECTION Emacs
+START-INFO-DIR-ENTRY
+* Magit: (magit).       Using Git from Emacs with Magit.
+END-INFO-DIR-ENTRY
+
+
+File: magit.info,  Node: Microsoft Windows Performance,  Next: MacOS Performance,  Up: Performance
+
+Microsoft Windows Performance
+.............................
+
+In order to update the status buffer, ‘git’ has to be run a few dozen
+times.  That is problematic on Microsoft Windows, because that operating
+system is exceptionally slow at starting processes.  Sadly this is an
+issue that can only be fixed by Microsoft itself, and they don’t appear
+to be particularly interested in doing so.
+
+   Beside the subprocess issue, there are also other Windows-specific
+performance issues.  Some of these have workarounds.  The maintainers of
+"Git for Windows" try to improve performance on Windows.  Always use the
+latest release in order to benefit from the latest performance tweaks.
+Magit too tries to work around some Windows-specific issues.
+
+   According to some sources, setting the following Git variables can
+also help.
+
+     git config --global core.preloadindex true   # default since v2.1
+     git config --global core.fscache true        # default since v2.8
+     git config --global gc.auto 256
+
+   You should also check whether an anti-virus program is affecting
+performance.
+
+
+File: magit.info,  Node: MacOS Performance,  Prev: Microsoft Windows Performance,  Up: Performance
+
+MacOS Performance
+.................
+
+On macOS Emacs currently creates child processes using ‘fork’.  It
+appears that this also copies GUI resources.  The result is that forking
+takes about 30 times as long on Darwin than on Linux.  And because Magit
+starts many ‘git’ processes even when doing simple things, that makes
+quite a difference.
+
+   On the ‘master’ branch Emacs now uses ‘vfork’ when possible, like
+this was already done on Linux, and now child creation only takes about
+twice as long on Darwin.  See (1) for more information.
+
+   Nobody knows when the changes on the ‘master’ branch will be released
+as ‘26.1’, but it is still a long way off.  You might want to get your
+hands on this change before then.  The easiest way to get a patched
+Emacs is to install the ‘emacs-plus’ formula (2) using ‘homebrew’.  The
+change has been backported, so you get it not only when using ‘--HEAD’,
+but also when using ‘--devel’ or when installing the latest release (by
+not using a version argument).
+
+   Alternatively you can apply the backport (3) manually.
+
+   ---------- Footnotes ----------
+
+   (1) 
+<https://lists.gnu.org/archive/html/bug-gnu-emacs/2017-04/msg00201.html>
+
+   (2) <https://github.com/d12frosted/homebrew-emacs-plus>
+
+   (3) 
+<https://gist.githubusercontent.com/aaronjensen/f45894ddf431ecbff78b1bcf533d3e6b/raw/6a5cd7f57341aba673234348d8b0d2e776f86719/Emacs-25-OS-X-use-vfork.patch>
+
+
+File: magit.info,  Node: Plumbing,  Next: FAQ,  Prev: Customizing,  Up: Top
+
+10 Plumbing
+***********
+
+The following sections describe how to use several of Magit’s core
+abstractions to extend Magit itself or implement a separate extension.
+
+   A few of the low-level features used by Magit have been factored out
+into separate libraries/packages, so that they can be used by other
+packages, without having to depend on Magit.  These libraries are
+described in separate manuals, see *note (with-editor)Top:: and *note
+(magit-popup)Top::.
+
+   If you are trying to find an unused key that you can bind to a
+command provided by your own Magit extension, then checkout
+<https://github.com/magit/magit/wiki/Plugin-Dispatch-Key-Registry>.
+
+* Menu:
+
+* Calling Git::
+* Section Plumbing::
+* Refreshing Buffers::
+* Conventions::
+
+
+File: magit.info,  Node: Calling Git,  Next: Section Plumbing,  Up: Plumbing
+
+10.1 Calling Git
+================
+
+Magit provides many specialized functions for calling Git.  All of these
+functions are defined in either ‘magit-git.el’ or ‘magit-process.el’ and
+have one of the prefixes ‘magit-run-’, ‘magit-call-’, ‘magit-start-’, or
+‘magit-git-’ (which is also used for other things).
+
+   All of these functions accept an indefinite number of arguments,
+which are strings that specify command line arguments for Git (or in
+some cases an arbitrary executable).  These arguments are flattened
+before being passed on to the executable; so instead of strings they can
+also be lists of strings and arguments that are ‘nil’ are silently
+dropped.  Some of these functions also require a single mandatory
+argument before these command line arguments.
+
+   Roughly speaking, these functions run Git either to get some value or
+for side-effects.  The functions that return a value are useful to
+collect the information necessary to populate a Magit buffer, while the
+others are used to implement Magit commands.
+
+   The functions in the value-only group always run synchronously, and
+they never trigger a refresh.  The function in the side-effect group can
+be further divided into subgroups depending on whether they run Git
+synchronously or asynchronously, and depending on whether they trigger a
+refresh when the executable has finished.
+
+* Menu:
+
+* Getting a Value from Git::
+* Calling Git for Effect::
+
+
+File: magit.info,  Node: Getting a Value from Git,  Next: Calling Git for Effect,  Up: Calling Git
+
+10.1.1 Getting a Value from Git
+-------------------------------
+
+These functions run Git in order to get a value, an exit status, or
+output.  Of course you could also use them to run Git commands that have
+side-effects, but that should be avoided.
+
+ -- Function: magit-git-exit-code &rest args
+
+     Executes git with ARGS and returns its exit code.
+
+ -- Function: magit-git-success &rest args
+
+     Executes git with ARGS and returns ‘t’ if the exit code is ‘0’,
+     ‘nil’ otherwise.
+
+ -- Function: magit-git-failure &rest args
+
+     Executes git with ARGS and returns ‘t’ if the exit code is ‘1’,
+     ‘nil’ otherwise.
+
+ -- Function: magit-git-true &rest args
+
+     Executes git with ARGS and returns ‘t’ if the first line printed by
+     git is the string "true", ‘nil’ otherwise.
+
+ -- Function: magit-git-false &rest args
+
+     Executes git with ARGS and returns ‘t’ if the first line printed by
+     git is the string "false", ‘nil’ otherwise.
+
+ -- Function: magit-git-insert &rest args
+
+     Executes git with ARGS and inserts its output at point.
+
+ -- Function: magit-git-string &rest args
+
+     Executes git with ARGS and returns the first line of its output.
+     If there is no output or if it begins with a newline character,
+     then this returns ‘nil’.
+
+ -- Function: magit-git-lines &rest args
+
+     Executes git with ARGS and returns its output as a list of lines.
+     Empty lines anywhere in the output are omitted.
+
+ -- Function: magit-git-items &rest args
+
+     Executes git with ARGS and returns its null-separated output as a
+     list.  Empty items anywhere in the output are omitted.
+
+     If the value of option ‘magit-git-debug’ is non-nil and git exits
+     with a non-zero exit status, then warn about that in the echo area
+     and add a section containing git’s standard error in the current
+     repository’s process buffer.
+
+   If an error occurs when using one of the above functions, then that
+is usually due to a bug, i.e.  using an argument which is not actually
+supported.  Such errors are usually not reported, but when they occur we
+need to be able to debug them.
+
+ -- User Option: magit-git-debug
+
+     Whether to report errors that occur when using ‘magit-git-insert’,
+     ‘magit-git-string’, ‘magit-git-lines’, or ‘magit-git-items’.  This
+     does not actually raise an error.  Instead a message is shown in
+     the echo area, and git’s standard error is insert into a new
+     section in the current repository’s process buffer.
+
+ -- Function: magit-git-str &rest args
+
+     This is a variant of ‘magit-git-string’ that ignores the option
+     ‘magit-git-debug’.  It is mainly intended to be used while handling
+     errors in functions that do respect that option.  Using such a
+     function while handing an error could cause yet another error and
+     therefore lead to an infinite recursion.  You probably won’t ever
+     need to use this function.
+
+
+File: magit.info,  Node: Calling Git for Effect,  Prev: Getting a Value from Git,  Up: Calling Git
+
+10.1.2 Calling Git for Effect
+-----------------------------
+
+These functions are used to run git to produce some effect.  Most Magit
+commands that actually run git do so by using such a function.
+
+   Because we do not need to consume git’s output when using these
+functions, their output is instead logged into a per-repository buffer,
+which can be shown using ‘$’ from a Magit buffer or ‘M-x magit-process’
+elsewhere.
+
+   These functions can have an effect in two distinct ways.  Firstly,
+running git may change something, i.e.  create or push a new commit.
+Secondly, that change may require that Magit buffers are refreshed to
+reflect the changed state of the repository.  But refreshing isn’t
+always desirable, so only some of these functions do perform such a
+refresh after git has returned.
+
+   Sometimes it is useful to run git asynchronously.  For example, when
+the user has just initiated a push, then there is no reason to make her
+wait until that has completed.  In other cases it makes sense to wait
+for git to complete before letting the user do something else.  For
+example after staging a change it is useful to wait until after the
+refresh because that also automatically moves to the next change.
+
+ -- Function: magit-call-git &rest args
+
+     Calls git synchronously with ARGS.
+
+ -- Function: magit-call-process program &rest args
+
+     Calls PROGRAM synchronously with ARGS.
+
+ -- Function: magit-run-git &rest args
+
+     Calls git synchronously with ARGS and then refreshes.
+
+ -- Function: magit-run-git-with-input input &rest args
+
+     Calls git synchronously with ARGS and sends it INPUT on standard
+     input.
+
+     INPUT should be a buffer or the name of an existing buffer.  The
+     content of that buffer is used as the process’ standard input.
+     After the process returns a refresh is performed.
+
+     As a special case, INPUT may also be nil.  In that case the content
+     of the current buffer is used as standard input and *no* refresh is
+     performed.
+
+     This function actually runs git asynchronously.  But then it waits
+     for the process to return, so the function itself is synchronous.
+
+ -- Function: magit-run-git-with-logfile file &rest args
+
+     Calls git synchronously with ARGS.  The process’ output is saved in
+     FILE.  This is rarely useful and so this function might be removed
+     in the future.
+
+     This function actually runs git asynchronously.  But then it waits
+     for the process to return, so the function itself is synchronous.
+
+ -- Function: magit-git &rest args
+
+     Calls git synchronously with ARGS for side-effects only.  This
+     function does not refresh the buffer.
+
+ -- Function: magit-git-wash washer &rest args
+
+     Execute Git with ARGS, inserting washed output at point.  Actually
+     first insert the raw output at point.  If there is no output call
+     ‘magit-cancel-section’.  Otherwise temporarily narrow the buffer to
+     the inserted text, move to its beginning, and then call function
+     WASHER with ARGS as its sole argument.
+
+   And now for the asynchronous variants.
+
+ -- Function: magit-run-git-async &rest args
+
+     Start Git, prepare for refresh, and return the process object.
+     ARGS is flattened and then used as arguments to Git.
+
+     Display the command line arguments in the echo area.
+
+     After Git returns some buffers are refreshed: the buffer that was
+     current when this function was called (if it is a Magit buffer and
+     still alive), as well as the respective Magit status buffer.
+     Unmodified buffers visiting files that are tracked in the current
+     repository are reverted if ‘magit-revert-buffers’ is non-nil.
+
+ -- Function: magit-run-git-with-editor &rest args
+
+     Export GIT_EDITOR and start Git.  Also prepare for refresh and
+     return the process object.  ARGS is flattened and then used as
+     arguments to Git.
+
+     Display the command line arguments in the echo area.
+
+     After Git returns some buffers are refreshed: the buffer that was
+     current when this function was called (if it is a Magit buffer and
+     still alive), as well as the respective Magit status buffer.
+
+ -- Function: magit-start-git &rest args
+
+     Start Git, prepare for refresh, and return the process object.
+
+     If INPUT is non-nil, it has to be a buffer or the name of an
+     existing buffer.  The buffer content becomes the processes standard
+     input.
+
+     Option ‘magit-git-executable’ specifies the Git executable and
+     option ‘magit-git-global-arguments’ specifies constant arguments.
+     The remaining arguments ARGS specify arguments to Git.  They are
+     flattened before use.
+
+     After Git returns, some buffers are refreshed: the buffer that was
+     current when this function was called (if it is a Magit buffer and
+     still alive), as well as the respective Magit status buffer.
+     Unmodified buffers visiting files that are tracked in the current
+     repository are reverted if ‘magit-revert-buffers’ is non-nil.
+
+ -- Function: magit-start-process &rest args
+
+     Start PROGRAM, prepare for refresh, and return the process object.
+
+     If optional argument INPUT is non-nil, it has to be a buffer or the
+     name of an existing buffer.  The buffer content becomes the
+     processes standard input.
+
+     The process is started using ‘start-file-process’ and then setup to
+     use the sentinel ‘magit-process-sentinel’ and the filter
+     ‘magit-process-filter’.  Information required by these functions is
+     stored in the process object.  When this function returns the
+     process has not started to run yet so it is possible to override
+     the sentinel and filter.
+
+     After the process returns, ‘magit-process-sentinel’ refreshes the
+     buffer that was current when ‘magit-start-process’ was called (if
+     it is a Magit buffer and still alive), as well as the respective
+     Magit status buffer.  Unmodified buffers visiting files that are
+     tracked in the current repository are reverted if
+     ‘magit-revert-buffers’ is non-nil.
+
+ -- Variable: magit-this-process
+
+     The child process which is about to start.  This can be used to
+     change the filter and sentinel.
+
+ -- Variable: magit-process-raise-error
+
+     When this is non-nil, then ‘magit-process-sentinel’ raises an error
+     if git exits with a non-zero exit status.  For debugging purposes.
+
+
+File: magit.info,  Node: Section Plumbing,  Next: Refreshing Buffers,  Prev: Calling Git,  Up: Plumbing
+
+10.2 Section Plumbing
+=====================
+
+* Menu:
+
+* Creating Sections::
+* Section Selection::
+* Matching Sections::
+
+
+File: magit.info,  Node: Creating Sections,  Next: Section Selection,  Up: Section Plumbing
+
+10.2.1 Creating Sections
+------------------------
+
+ -- Macro: magit-insert-section &rest args
+
+     Insert a section at point.
+
+     TYPE is the section type, a symbol.  Many commands that act on the
+     current section behave differently depending on that type.  Also if
+     a variable ‘magit-TYPE-section-map’ exists, then use that as the
+     text-property ‘keymap’ of all text belonging to the section (but
+     this may be overwritten in subsections).  TYPE can also have the
+     form ‘(eval FORM)’ in which case FORM is evaluated at runtime.
+
+     Optional VALUE is the value of the section, usually a string that
+     is required when acting on the section.
+
+     When optional HIDE is non-nil collapse the section body by default,
+     i.e.  when first creating the section, but not when refreshing the
+     buffer.  Otherwise, expand it by default.  This can be overwritten
+     using ‘magit-section-set-visibility-hook’.  When a section is
+     recreated during a refresh, then the visibility of predecessor is
+     inherited and HIDE is ignored (but the hook is still honored).
+
+     BODY is any number of forms that actually insert the section’s
+     heading and body.  Optional NAME, if specified, has to be a symbol,
+     which is then bound to the struct of the section being inserted.
+
+     Before BODY is evaluated the ‘start’ of the section object is set
+     to the value of ‘point’ and after BODY was evaluated its ‘end’ is
+     set to the new value of ‘point’; BODY is responsible for moving
+     ‘point’ forward.
+
+     If it turns out inside BODY that the section is empty, then
+     ‘magit-cancel-section’ can be used to abort and remove all traces
+     of the partially inserted section.  This can happen when creating a
+     section by washing Git’s output and Git didn’t actually output
+     anything this time around.
+
+ -- Function: magit-insert-heading &rest args
+
+     Insert the heading for the section currently being inserted.
+
+     This function should only be used inside ‘magit-insert-section’.
+
+     When called without any arguments, then just set the ‘content’ slot
+     of the object representing the section being inserted to a marker
+     at ‘point’.  The section should only contain a single line when
+     this function is used like this.
+
+     When called with arguments ARGS, which have to be strings, then
+     insert those strings at point.  The section should not contain any
+     text before this happens and afterwards it should again only
+     contain a single line.  If the ‘face’ property is set anywhere
+     inside any of these strings, then insert all of them unchanged.
+     Otherwise use the ‘magit-section-heading’ face for all inserted
+     text.
+
+     The ‘content’ property of the section struct is the end of the
+     heading (which lasts from ‘start’ to ‘content’) and the beginning
+     of the body (which lasts from ‘content’ to ‘end’).  If the value of
+     ‘content’ is nil, then the section has no heading and its body
+     cannot be collapsed.  If a section does have a heading then its
+     height must be exactly one line, including a trailing newline
+     character.  This isn’t enforced; you are responsible for getting it
+     right.  The only exception is that this function does insert a
+     newline character if necessary.
+
+ -- Function: magit-cancel-section
+
+     Cancel the section currently being inserted.  This exits the
+     innermost call to ‘magit-insert-section’ and removes all traces of
+     what has already happened inside that call.
+
+ -- Function: magit-define-section-jumper sym title &optional value
+
+     Define an interactive function to go to section SYM.  TITLE is the
+     displayed title of the section.
+
+
+File: magit.info,  Node: Section Selection,  Next: Matching Sections,  Prev: Creating Sections,  Up: Section Plumbing
+
+10.2.2 Section Selection
+------------------------
+
+ -- Function: magit-current-section
+
+     Return the section at point.
+
+ -- Function: magit-region-sections
+
+     Return a list of the selected sections.
+
+     When the region is active and constitutes a valid section
+     selection, then return a list of all selected sections.  This is
+     the case when the region begins in the heading of a section and
+     ends in the heading of a sibling of that first section.  When the
+     selection is not valid then return nil.  Most commands that can act
+     on the selected sections, then instead just act on the current
+     section, the one point is in.
+
+     When the region looks like it would in any other buffer then the
+     selection is invalid.  When the selection is valid then the region
+     uses the ‘magit-section-highlight’.  This does not apply to diffs
+     where things get a bit more complicated, but even here if the
+     region looks like it usually does, then that’s not a valid
+     selection as far as this function is concerned.
+
+ -- Function: magit-region-values &rest types
+
+     Return a list of the values of the selected sections.
+
+     Also see ‘magit-region-sections’ whose doc-string explains when a
+     region is a valid section selection.  If the region is not active
+     or is not a valid section selection, then return nil.  If optional
+     TYPES is non-nil then the selection not only has to be valid; the
+     types of all selected sections additionally have to match one of
+     TYPES, or nil is returned.
+
+
+File: magit.info,  Node: Matching Sections,  Prev: Section Selection,  Up: Section Plumbing
+
+10.2.3 Matching Sections
+------------------------
+
+‘M-x magit-describe-section-briefly’     (‘magit-describe-section-briefly’)
+
+     Show information about the section at point.  This command is
+     intended for debugging purposes.
+
+ -- Function: magit-section-ident
+
+     Return an unique identifier for SECTION.  The return value has the
+     form ‘((TYPE . VALUE)...)’.
+
+ -- Function: magit-get-section
+
+     Return the section identified by IDENT.  IDENT has to be a list as
+     returned by ‘magit-section-ident’.
+
+ -- Function: magit-section-match condition &optional section
+
+     Return ‘t’ if SECTION matches CONDITION.  SECTION defaults to the
+     section at point.  If SECTION is not specified and there also is no
+     section at point, then return ‘nil’.
+
+     CONDITION can take the following forms:
+        • ‘(CONDITION...)’
+
+          matches if any of the CONDITIONs matches.
+
+        • ‘[TYPE...]’
+
+          matches if the first TYPE matches the type of the section, the
+          second matches that of its parent, and so on.
+
+        • ‘[* TYPE...]’
+
+          matches sections that match [TYPE...] and also recursively all
+          their child sections.
+
+        • ‘TYPE’
+
+          matches sections of TYPE regardless of the types of the parent
+          sections.
+
+     Each TYPE is a symbol.  Note that it is not necessary to specify
+     all TYPEs up to the root section as printed by
+     ‘magit-describe-type’, unless of course you want to be that
+     precise.
+
+ -- Function: magit-section-when condition &rest body
+
+     If the section at point matches CONDITION evaluate BODY.
+
+     If the section matches, then evaluate BODY forms sequentially with
+     ‘it’ bound to the section and return the value of the last form.
+     If there are no BODY forms, then return the value of the section.
+     If the section does not match or if there is no section at point
+     then return nil.
+
+     See ‘magit-section-match’ for the forms CONDITION can take.
+
+ -- Function: magit-section-case &rest clauses
+
+     Choose among clauses on the type of the section at point.
+
+     Each clause looks like (CONDITION BODY...).  The type of the
+     section is compared against each CONDITION; the BODY forms of the
+     first match are evaluated sequentially and the value of the last
+     form is returned.  Inside BODY the symbol ‘it’ is bound to the
+     section at point.  If no clause succeeds or if there is no section
+     at point return nil.
+
+     See ‘magit-section-match’ for the forms CONDITION can take.
+     Additionally a CONDITION of t is allowed in the final clause and
+     matches if no other CONDITION match, even if there is no section at
+     point.
+
+ -- Variable: magit-root-section
+
+     The root section in the current buffer.  All other sections are
+     descendants of this section.  The value of this variable is set by
+     ‘magit-insert-section’ and you should never modify it.
+
+   For diff related sections a few additional tools exist.
+
+ -- Function: magit-diff-type &optional section
+
+     Return the diff type of SECTION.
+
+     The returned type is one of the symbols ‘staged’, ‘unstaged’,
+     ‘committed’, or ‘undefined’.  This type serves a similar purpose as
+     the general type common to all sections (which is stored in the
+     ‘type’ slot of the corresponding ‘magit-section’ struct) but takes
+     additional information into account.  When the SECTION isn’t
+     related to diffs and the buffer containing it also isn’t a
+     diff-only buffer, then return nil.
+
+     Currently the type can also be one of ‘tracked’ and ‘untracked’,
+     but these values are not handled explicitly in every place they
+     should be.  A possible fix could be to just return nil here.
+
+     The section has to be a ‘diff’ or ‘hunk’ section, or a section
+     whose children are of type ‘diff’.  If optional SECTION is nil,
+     return the diff type for the current section.  In buffers whose
+     major mode is ‘magit-diff-mode’ SECTION is ignored and the type is
+     determined using other means.  In ‘magit-revision-mode’ buffers the
+     type is always ‘committed’.
+
+ -- Function: magit-diff-scope &optional section strict
+
+     Return the diff scope of SECTION or the selected section(s).
+
+     A diff’s "scope" describes what part of a diff is selected, it is a
+     symbol, one of ‘region’, ‘hunk’, ‘hunks’, ‘file’, ‘files’, or
+     ‘list’.  Do not confuse this with the diff "type", as returned by
+     ‘magit-diff-type’.
+
+     If optional SECTION is non-nil, then return the scope of that,
+     ignoring the sections selected by the region.  Otherwise return the
+     scope of the current section, or if the region is active and
+     selects a valid group of diff related sections, the type of these
+     sections, i.e.  ‘hunks’ or ‘files’.  If SECTION (or if the current
+     section that is nil) is a ‘hunk’ section and the region starts and
+     ends inside the body of a that section, then the type is ‘region’.
+
+     If optional STRICT is non-nil then return nil if the diff type of
+     the section at point is ‘untracked’ or the section at point is not
+     actually a ‘diff’ but a ‘diffstat’ section.
+
+
+File: magit.info,  Node: Refreshing Buffers,  Next: Conventions,  Prev: Section Plumbing,  Up: Plumbing
+
+10.3 Refreshing Buffers
+=======================
+
+All commands that create a new Magit buffer or change what is being
+displayed in an existing buffer do so by calling ‘magit-mode-setup’.
+Among other things, that function sets the buffer local values of
+‘default-directory’ (to the top-level of the repository),
+‘magit-refresh-function’, and ‘magit-refresh-args’.
+
+   Buffers are refreshed by calling the function that is the local value
+of ‘magit-refresh-function’ (a function named ‘magit-*-refresh-buffer’,
+where ‘*’ may be something like ‘diff’) with the value of
+‘magit-refresh-args’ as arguments.
+
+ -- Macro: magit-mode-setup buffer switch-func mode refresh-func
+          &optional refresh-args
+
+     This function displays and selects BUFFER, turns on MODE, and
+     refreshes a first time.
+
+     This function displays and optionally selects BUFFER by calling
+     ‘magit-mode-display-buffer’ with BUFFER, MODE and SWITCH-FUNC as
+     arguments.  Then it sets the local value of
+     ‘magit-refresh-function’ to REFRESH-FUNC and that of
+     ‘magit-refresh-args’ to REFRESH-ARGS.  Finally it creates the
+     buffer content by calling REFRESH-FUNC with REFRESH-ARGS as
+     arguments.
+
+     All arguments are evaluated before switching to BUFFER.
+
+ -- Function: magit-mode-display-buffer buffer mode &optional
+          switch-function
+
+     This function display BUFFER in some window and select it.  BUFFER
+     may be a buffer or a string, the name of a buffer.  The buffer is
+     returned.
+
+     Unless BUFFER is already displayed in the selected frame, store the
+     previous window configuration as a buffer local value, so that it
+     can later be restored by ‘magit-mode-bury-buffer’.
+
+     The buffer is displayed and selected using SWITCH-FUNCTION.  If
+     that is ‘nil’ then ‘pop-to-buffer’ is used if the current buffer’s
+     major mode derives from ‘magit-mode’.  Otherwise ‘switch-to-buffer’
+     is used.
+
+ -- Variable: magit-refresh-function
+
+     The value of this buffer-local variable is the function used to
+     refresh the current buffer.  It is called with ‘magit-refresh-args’
+     as arguments.
+
+ -- Variable: magit-refresh-args
+
+     The list of arguments used by ‘magit-refresh-function’ to refresh
+     the current buffer.  ‘magit-refresh-function’ is called with these
+     arguments.
+
+     The value is usually set using ‘magit-mode-setup’, but in some
+     cases it’s also useful to provide commands which can change the
+     value.  For example, the ‘magit-diff-refresh-popup’ can be used to
+     change any of the arguments used to display the diff, without
+     having to specify again which differences should be shown.
+     ‘magit-diff-more-context’, ‘magit-diff-less-context’, and
+     ‘magit-diff-default-context’ change just the ‘-U<N>’ argument.  In
+     both case this is done by changing the value of this variable and
+     then calling this ‘magit-refresh-function’.
+
+
+File: magit.info,  Node: Conventions,  Prev: Refreshing Buffers,  Up: Plumbing
+
+10.4 Conventions
+================
+
+Also see *note Completion and Confirmation::.
+
+* Menu:
+
+* Theming Faces::
+
+
+File: magit.info,  Node: Theming Faces,  Up: Conventions
+
+10.4.1 Theming Faces
+--------------------
+
+The default theme uses blue for local branches, green for remote
+branches, and goldenrod (brownish yellow) for tags.  When creating a new
+theme, you should probably follow that example.  If your theme already
+uses other colors, then stick to that.
+
+   In older releases these reference faces used to have a background
+color and a box around them.  The basic default faces no longer do so,
+to make Magit buffers much less noisy, and you should follow that
+example at least with regards to boxes.  (Boxes were used in the past to
+work around a conflict between the highlighting overlay and text
+property backgrounds.  That’s no longer necessary because highlighting
+no longer causes other background colors to disappear.)  Alternatively
+you can keep the background color and/or box, but then have to take
+special care to adjust ‘magit-branch-current’ accordingly.  By default
+it looks mostly like ‘magit-branch-local’, but with a box (by default
+the former is the only face that uses a box, exactly so that it sticks
+out).  If the former also uses a box, then you have to make sure that it
+differs in some other way from the latter.
+
+   The most difficult faces to theme are those related to diffs,
+headings, highlighting, and the region.  There are faces that fall into
+all four groups - expect to spend some time getting this right.
+
+   The ‘region’ face in the default theme, in both the light and dark
+variants, as well as in many other themes, distributed with Emacs or by
+third-parties, is very ugly.  It is common to use a background color
+that really sticks out, which is ugly but if that were the only problem
+then it would be acceptable.  Unfortunately many themes also set the
+foreground color, which ensures that all text within the region is
+readable.  Without doing that there might be cases where some foreground
+color is too close to the region background color to still be readable.
+But it also means that text within the region loses all syntax
+highlighting.
+
+   I consider the work that went into getting the ‘region’ face right to
+be a good indicator for the general quality of a theme.  My
+recommendation for the ‘region’ face is this: use a background color
+slightly different from the background color of the ‘default’ face, and
+do not set the foreground color at all.  So for a light theme you might
+use a light (possibly tinted) gray as the background color of ‘default’
+and a somewhat darker gray for the background of ‘region’.  That should
+usually be enough to not collide with the foreground color of any other
+face.  But if some other faces also set a light gray as background
+color, then you should also make sure it doesn’t collide with those (in
+some cases it might be acceptable though).
+
+   Magit only uses the ‘region’ face when the region is "invalid" by its
+own definition.  In a Magit buffer the region is used to either select
+multiple sibling sections, so that commands which support it act on all
+of these sections instead of just the current section, or to select
+lines within a single hunk section.  In all other cases, the section is
+considered invalid and Magit won’t act on it.  But such invalid sections
+happen, either because the user has not moved point enough yet to make
+it valid or because she wants to use a non-magit command to act on the
+region, e.g.  ‘kill-region’.
+
+   So using the regular ‘region’ face for invalid sections is a feature.
+It tells the user that Magit won’t be able to act on it.  It’s
+acceptable if that face looks a bit odd and even (but less so) if it
+collides with the background colors of section headings and other things
+that have a background color.
+
+   Magit highlights the current section.  If a section has subsections,
+then all of them are highlighted.  This is done using faces that have
+"highlight" in their names.  For most sections,
+‘magit-section-highlight’ is used for both the body and the heading.
+Like the ‘region’ face, it should only set the background color to
+something similar to that of ‘default’.  The highlight background color
+must be different from both the ‘region’ background color and the
+‘default’ background color.
+
+   For diff related sections Magit uses various faces to highlight
+different parts of the selected section(s).  Note that hunk headings,
+unlike all other section headings, by default have a background color,
+because it is useful to have very visible separators between hunks.
+That face ‘magit-diff-hunk-heading’, should be different from both
+‘magit-diff-hunk-heading-highlight’ and ‘magit-section-highlight’, as
+well as from ‘magit-diff-context’ and ‘magit-diff-context-highlight’.
+By default we do that by changing the foreground color.  Changing the
+background color would lead to complications, and there are already
+enough we cannot get around.  (Also note that it is generally a good
+idea for section headings to always be bold, but only for sections that
+have subsections).
+
+   When there is a valid region selecting diff-related sibling sections,
+i.e.  multiple files or hunks, then the bodies of all these sections use
+the respective highlight faces, but additionally the headings instead
+use one of the faces ‘magit-diff-file-heading-selection’ or
+‘magit-diff-hunk-heading-selection’.  These faces have to be different
+from the regular highlight variants to provide explicit visual
+indication that the region is active.
+
+   When theming diff related faces, start by setting the option
+‘magit-diff-refine-hunk’ to ‘all’.  You might personally prefer to only
+refine the current hunk or not use hunk refinement at all, but some of
+the users of your theme want all hunks to be refined, so you have to
+cater to that.
+
+   (Also turn on ‘magit-diff-highlight-indentation’,
+‘magit-diff-highlight-trailing’, and ‘magit-diff-paint-whitespace’; and
+insert some whitespace errors into the code you use for testing.)
+
+   For e.g.  "added lines" you have to adjust three faces:
+‘magit-diff-added’, ‘magit-diff-added-highlight’, and
+‘smerge-refined-added’.  Make sure that the latter works well with both
+of the former, as well as ‘smerge-other’ and ‘diff-added’.  Then do the
+same for the removed lines, context lines, lines added by us, and lines
+added by them.  Also make sure the respective added, removed, and
+context faces use approximately the same saturation for both the
+highlighted and unhighlighted variants.  Also make sure the file and
+diff headings work nicely with context lines (e.g.  make them look
+different).  Line faces should set both the foreground and the
+background color.  For example, for added lines use two different
+greens.
+
+   It’s best if the foreground color of both the highlighted and the
+unhighlighted variants are the same, so you will need to have to find a
+color that works well on the highlight and unhighlighted background, the
+refine background, and the highlight context background.  When there is
+an hunk internal region, then the added- and removed-lines background
+color is used only within that region.  Outside the region the
+highlighted context background color is used.  This makes it easier to
+see what is being staged.  With an hunk internal region the hunk heading
+is shown using ‘magit-diff-hunk-heading-selection’, and so are the thin
+lines that are added around the lines that fall within the region.  The
+background color of that has to be distinct enough from the various
+other involved background colors.
+
+   Nobody said this would be easy.  If your theme restricts itself to a
+certain set of colors, then you should make an exception here.
+Otherwise it would be impossible to make the diffs look good in each and
+every variation.  Actually you might want to just stick to the default
+definitions for these faces.  You have been warned.  Also please note
+that if you do not get this right, this will in some cases look to users
+like bugs in Magit - so please do it right or not at all.
+
+
+File: magit.info,  Node: FAQ,  Next: Debugging Tools,  Prev: Plumbing,  Up: Top
+
+Appendix A FAQ
+**************
+
+The next two nodes lists frequently asked questions.  For a list of
+frequently *and recently* asked questions, i.e.  questions that haven’t
+made it into the manual yet, see
+<https://github.com/magit/magit/wiki/FAQ>.
+
+   Please also use the *note Debugging Tools::.
+
+* Menu:
+
+* FAQ - How to ...?::
+* FAQ - Issues and Errors::
+
+
+File: magit.info,  Node: FAQ - How to ...?,  Next: FAQ - Issues and Errors,  Up: FAQ
+
+A.1 FAQ - How to ...?
+=====================
+
+* Menu:
+
+* How to show git's output?::
+* How to install the gitman info manual?::
+* How to show diffs for gpg-encrypted files?::
+* How does branching and pushing work?::
+* Can Magit be used as ediff-version-control-package?::
+
+
+File: magit.info,  Node: How to show git's output?,  Next: How to install the gitman info manual?,  Up: FAQ - How to ...?
+
+A.1.1 How to show git’s output?
+-------------------------------
+
+To show the output of recently run git commands, press ‘$’ (or, if that
+isn’t available, ‘M-x magit-process-buffer’).  This will show a buffer
+containing a section per git invocation; as always press ‘TAB’ to expand
+or collapse them.
+
+   By default, git’s output is only inserted into the process buffer if
+it is run for side-effects.  When the output is consumed in some way,
+also inserting it into the process buffer would be too expensive.  For
+debugging purposes, it’s possible to do so anyway by setting
+‘magit-git-debug’ to ‘t’.
+
+
+File: magit.info,  Node: How to install the gitman info manual?,  Next: How to show diffs for gpg-encrypted files?,  Prev: How to show git's output?,  Up: FAQ - How to ...?
+
+A.1.2 How to install the gitman info manual?
+--------------------------------------------
+
+Git’s manpages can be exported as an info manual called ‘gitman’.
+Magit’s own info manual links to nodes in that manual instead of the
+actual manpages because Info doesn’t support linking to manpages.
+
+   Unfortunately some distributions do not install the ‘gitman’ manual
+by default and you will have to install a separate documentation package
+to get it.
+
+   Magit patches Info adding the ability to visit links to the ‘gitman’
+Info manual by instead viewing the respective manpage.  If you prefer
+that approach, then set the value of ‘magit-view-git-manual-method’ to
+one of the supported packages ‘man’ or ‘woman’, e.g.:
+
+     (setq magit-view-git-manual-method 'man)
+
+
+File: magit.info,  Node: How to show diffs for gpg-encrypted files?,  Next: How does branching and pushing work?,  Prev: How to install the gitman info manual?,  Up: FAQ - How to ...?
+
+A.1.3 How to show diffs for gpg-encrypted files?
+------------------------------------------------
+
+Git supports showing diffs for encrypted files, but has to be told to do
+so.  Since Magit just uses Git to get the diffs, configuring Git also
+affects the diffs displayed inside Magit.
+
+     git config --global diff.gpg.textconv "gpg --no-tty --decrypt"
+     echo "*.gpg filter=gpg diff=gpg" > .gitattributes
+
+
+File: magit.info,  Node: How does branching and pushing work?,  Next: Can Magit be used as ediff-version-control-package?,  Prev: How to show diffs for gpg-encrypted files?,  Up: FAQ - How to ...?
+
+A.1.4 How does branching and pushing work?
+------------------------------------------
+
+Please see *note Branching:: and
+<http://emacsair.me/2016/01/17/magit-2.4>
+
+
+File: magit.info,  Node: Can Magit be used as ediff-version-control-package?,  Prev: How does branching and pushing work?,  Up: FAQ - How to ...?
+
+A.1.5 Can Magit be used as ‘ediff-version-control-package’?
+-----------------------------------------------------------
+
+No, it cannot.  For that to work the functions ‘ediff-magit-internal’
+and ‘ediff-magit-merge-internal’ would have to be implemented, and they
+are not.  These two functions are only used by the three commands
+‘ediff-revision’, ‘ediff-merge-revisions-with-ancestor’, and
+‘ediff-merge-revisions’.
+
+   These commands only delegate the task of populating buffers with
+certain revisions to the "internal" functions.  The equally important
+task of determining which revisions are to be compared/merged is not
+delegated.  Instead this is done without any support whatsoever from the
+version control package/system - meaning that the user has to enter the
+revisions explicitly.  Instead of implementing ‘ediff-magit-internal’ we
+provide ‘magit-ediff-compare’, which handles both tasks like it is 2005.
+
+   The other commands ‘ediff-merge-revisions’ and
+‘ediff-merge-revisions-with-ancestor’ are normally not what you want
+when using a modern version control system like Git.  Instead of letting
+the user resolve only those conflicts which Git could not resolve on its
+own, they throw away all work done by Git and then expect the user to
+manually merge all conflicts, including those that had already been
+resolved.  That made sense back in the days when version control systems
+couldn’t merge (or so I have been told), but not anymore.  Once in a
+blue moon you might actually want to see all conflicts, in which case
+you *can* use these commands, which then use ‘ediff-vc-merge-internal’.
+So we don’t actually have to implement ‘ediff-magit-merge-internal’.
+Instead we provide the more useful command ‘magit-ediff-resolve’ which
+only shows yet-to-be resolved conflicts.
+
+
+File: magit.info,  Node: FAQ - Issues and Errors,  Prev: FAQ - How to ...?,  Up: FAQ
+
+A.2 FAQ - Issues and Errors
+===========================
+
+* Menu:
+
+* Magit is slow::
+* I changed several thousand files at once and now Magit is unusable::
+* I am having problems committing::
+* I am using MS Windows and cannot push with Magit::
+* I am using OS X and SOMETHING works in shell, but not in Magit: I am using OS X and SOMETHING works in shell but not in Magit.
+* Diffs contain control sequences::
+* Expanding a file to show the diff causes it to disappear::
+* Point is wrong in the COMMIT_EDITMSG buffer::
+* The mode-line information isn't always up-to-date::
+* A branch and tag sharing the same name breaks SOMETHING::
+* My Git hooks work on the command-line but not inside Magit::
+* git-commit-mode isn't used when committing from the command-line::
+* Point ends up inside invisible text when jumping to a file-visiting buffer::
+
+
+File: magit.info,  Node: Magit is slow,  Next: I changed several thousand files at once and now Magit is unusable,  Up: FAQ - Issues and Errors
+
+A.2.1 Magit is slow
+-------------------
+
+See *note Performance::.
+
+
+File: magit.info,  Node: I changed several thousand files at once and now Magit is unusable,  Next: I am having problems committing,  Prev: Magit is slow,  Up: FAQ - Issues and Errors
+
+A.2.2 I changed several thousand files at once and now Magit is unusable
+------------------------------------------------------------------------
+
+Magit is *currently* not expected to work under such conditions.  It
+sure would be nice if it did, and v2.5 will hopefully be a big step into
+that direction.  But it might take until v3.1 to accomplish fully
+satisfactory performance, because that requires some heavy refactoring.
+
+   But for now we recommend you use the command line to complete this
+one commit.  Also see *note Performance::.
+
+
+File: magit.info,  Node: I am having problems committing,  Next: I am using MS Windows and cannot push with Magit,  Prev: I changed several thousand files at once and now Magit is unusable,  Up: FAQ - Issues and Errors
+
+A.2.3 I am having problems committing
+-------------------------------------
+
+That likely means that Magit is having problems finding an appropriate
+emacsclient executable.  See *note (with-editor)Configuring
+With-Editor:: and *note (with-editor)Debugging::.
+
+
+File: magit.info,  Node: I am using MS Windows and cannot push with Magit,  Next: I am using OS X and SOMETHING works in shell but not in Magit,  Prev: I am having problems committing,  Up: FAQ - Issues and Errors
+
+A.2.4 I am using MS Windows and cannot push with Magit
+------------------------------------------------------
+
+It’s almost certain that Magit is only incidental to this issue.  It is
+much more likely that this is a configuration issue, even if you can
+push on the command line.
+
+   Detailed setup instructions can be found at
+<https://github.com/magit/magit/wiki/Pushing-with-Magit-from-Windows>.
+
+
+File: magit.info,  Node: I am using OS X and SOMETHING works in shell but not in Magit,  Next: Diffs contain control sequences,  Prev: I am using MS Windows and cannot push with Magit,  Up: FAQ - Issues and Errors
+
+A.2.5 I am using OS X and SOMETHING works in shell, but not in Magit
+--------------------------------------------------------------------
+
+This usually occurs because Emacs doesn’t have the same environment
+variables as your shell.  Try installing and configuring
+<https://github.com/purcell/exec-path-from-shell>.  By default it
+synchronizes ‘$PATH’, which helps Magit find the same ‘git’ as the one
+you are using on the shell.
+
+   If SOMETHING is "passphrase caching with gpg-agent for commit and/or
+tag signing", then you’ll also need to synchronize ‘$GPG_AGENT_INFO’.
+
+
+File: magit.info,  Node: Diffs contain control sequences,  Next: Expanding a file to show the diff causes it to disappear,  Prev: I am using OS X and SOMETHING works in shell but not in Magit,  Up: FAQ - Issues and Errors
+
+A.2.6 Diffs contain control sequences
+-------------------------------------
+
+This happens when you configure Git to always color diffs and/or all of
+its output.  The valid values for relevant Git variables ‘color.ui’ and
+‘color.diff’ are ‘false’, ‘true’ and ‘always’, and the default is
+‘true’.  You should leave it that way because then you get colorful
+output in terminals by default but when git’s output is consumed by
+something else, then no color control sequences are used.
+
+   If you actually use some other tool that requires setting ‘color.ui’
+and/or ‘color.diff’ to ‘always’ (which is highly unlikely), then you can
+override these settings just for Magit by using:
+
+     (setq magit-git-global-arguments
+           (nconc magit-git-global-arguments
+                  '("-c" "color.ui=false"
+                    "-c" "color.diff=false")))
+
+
+File: magit.info,  Node: Expanding a file to show the diff causes it to disappear,  Next: Point is wrong in the COMMIT_EDITMSG buffer,  Prev: Diffs contain control sequences,  Up: FAQ - Issues and Errors
+
+A.2.7 Expanding a file to show the diff causes it to disappear
+--------------------------------------------------------------
+
+This is probably caused by a change of a ‘diff.*’ Git variable.  You
+probably set that variable for a reason, and should therefore only undo
+that setting in Magit by customizing ‘magit-git-global-arguments’.
+
+
+File: magit.info,  Node: Point is wrong in the COMMIT_EDITMSG buffer,  Next: The mode-line information isn't always up-to-date,  Prev: Expanding a file to show the diff causes it to disappear,  Up: FAQ - Issues and Errors
+
+A.2.8 Point is wrong in the ‘COMMIT_EDITMSG’ buffer
+---------------------------------------------------
+
+Neither Magit nor ‘git-commit‘ fiddle with point in the buffer used to
+write commit messages, so something else must be doing it.
+
+   You have probably globally enabled a mode which does restore point in
+file-visiting buffers.  It might be a bit surprising, but when you write
+a commit message, then you are actually editing a file.
+
+   So you have to figure out which package is doing.  ‘saveplace’,
+‘pointback’, and ‘session’ are likely candidates.  These snippets might
+help:
+
+     (setq session-name-disable-regexp "\\(?:\\`'\\.git/[A-Z_]+\\'\\)")
+
+     (with-eval-after-load 'pointback
+       (lambda ()
+         (when (or git-commit-mode git-rebase-mode)
+           (pointback-mode -1))))
+
+
+File: magit.info,  Node: The mode-line information isn't always up-to-date,  Next: A branch and tag sharing the same name breaks SOMETHING,  Prev: Point is wrong in the COMMIT_EDITMSG buffer,  Up: FAQ - Issues and Errors
+
+A.2.9 The mode-line information isn’t always up-to-date
+-------------------------------------------------------
+
+Magit is not responsible for the version control information that is
+being displayed in the mode-line and looks something like ‘Git-master’.
+The built-in "Version Control" package, also known as "VC", updates that
+information, and can be told to do so more often:
+
+     (setq auto-revert-check-vc-info t)
+
+   But doing so isn’t good for performance.  For more (overly
+optimistic) information see *note (emacs)VC Mode Line::.
+
+   If you don’t really care about seeing that information in the
+mode-line, but just don’t want to see _incorrect_ information, then
+consider disabling VC when using Git:
+
+     (setq vc-handled-backends (delq 'Git vc-handled-backends))
+
+   Or to disable it completely:
+
+     (setq vc-handled-backends nil)
+
+
+File: magit.info,  Node: A branch and tag sharing the same name breaks SOMETHING,  Next: My Git hooks work on the command-line but not inside Magit,  Prev: The mode-line information isn't always up-to-date,  Up: FAQ - Issues and Errors
+
+A.2.10 A branch and tag sharing the same name breaks SOMETHING
+--------------------------------------------------------------
+
+Or more generally, ambiguous refnames break SOMETHING.
+
+   Magit assumes that refs are named non-ambiguously across the
+"refs/heads/", "refs/tags/", and "refs/remotes/" namespaces (i.e., all
+the names remain unique when those prefixes are stripped).  We consider
+ambiguous refnames unsupported and recommend that you use a
+non-ambiguous naming scheme.  However, if you do work with a repository
+that has ambiguous refnames, please report any issues you encounter so
+that we can investigate whether there is a simple fix.
+
+
+File: magit.info,  Node: My Git hooks work on the command-line but not inside Magit,  Next: git-commit-mode isn't used when committing from the command-line,  Prev: A branch and tag sharing the same name breaks SOMETHING,  Up: FAQ - Issues and Errors
+
+A.2.11 My Git hooks work on the command-line but not inside Magit
+-----------------------------------------------------------------
+
+When Magit calls ‘git’ it adds a few global arguments including
+‘--literal-pathspecs’ and the ‘git’ process started by Magit then passes
+that setting on to other ‘git’ process it starts itself.  It does so by
+setting the environment variable ‘GIT_LITERAL_PATHSPECS’, not by calling
+subprocesses with the ‘--literal-pathspecs’.  You can therefore override
+this setting in hook scripts using ‘unset GIT_LITERAL_PATHSPECS’.
+
+
+File: magit.info,  Node: git-commit-mode isn't used when committing from the command-line,  Next: Point ends up inside invisible text when jumping to a file-visiting buffer,  Prev: My Git hooks work on the command-line but not inside Magit,  Up: FAQ - Issues and Errors
+
+A.2.12 ‘git-commit-mode’ isn’t used when committing from the command-line
+-------------------------------------------------------------------------
+
+The reason for this is that ‘git-commit.el’ has not been loaded yet
+and/or that the server has not been started yet.  These things have
+always already been taken care of when you commit from Magit because in
+order to do so, Magit has to be loaded and doing that involves loading
+‘git-commit’ and starting the server.
+
+   If you want to commit from the command-line, then you have to take
+care of these things yourself.  Your ‘init.el’ file should contain:
+
+     (require 'git-commit)
+     (server-mode)
+
+   Instead of ‘(require ’git-commit)‘ you may also use:
+
+     (load "/path/to/magit-autoloads.el")
+
+   You might want to do that because loading ‘git-commit’ causes large
+parts of Magit to be loaded.
+
+   There are also some variations of ‘(server-mode)’ that you might want
+to try.  Personally I use:
+
+     (use-package server
+       :config (or (server-running-p) (server-mode)))
+
+   Now you can use:
+
+     $ emacs&
+     $ EDITOR=emacsclient git commit
+
+   However you cannot use:
+
+     $ killall emacs
+     $ EDITOR="emacsclient --alternate-editor emacs" git commit
+
+   This will actually end up using ‘emacs’, not ‘emacsclient’.  If you
+do this, then can still edit the commit message but ‘git-commit-mode’
+won’t be used and you have to exit ‘emacs’ to finish the process.
+
+   Tautology ahead.  If you want to be able to use ‘emacsclient’ to
+connect to a running ‘emacs’ instance, even though no ‘emacs’ instance
+is running, then you cannot use ‘emacsclient’ directly.
+
+   Instead you have to create a script that does something like this:
+
+   Try to use ‘emacsclient’ (without using ‘--alternate-editor’).  If
+that succeeds, do nothing else.  Otherwise start ‘emacs &’ (and
+‘init.el’ must call ‘server-start’) and try to use ‘emacsclient’ again.
+
+
+File: magit.info,  Node: Point ends up inside invisible text when jumping to a file-visiting buffer,  Prev: git-commit-mode isn't used when committing from the command-line,  Up: FAQ - Issues and Errors
+
+A.2.13 Point ends up inside invisible text when jumping to a file-visiting buffer
+---------------------------------------------------------------------------------
+
+This can happen when you type ‘RET’ on a hunk to visit the respective
+file at the respective position.  One solution to this problem is to use
+‘global-reveal-mode’.  It makes sure that text around point is always
+visible.  If that is too drastic for your taste, then you may instead
+use ‘magit-diff-visit-file-hook’ to reveal the text, possibly using
+‘reveal-post-command’ or for Org buffers ‘org-reveal’.
+
+
+File: magit.info,  Node: Debugging Tools,  Next: Keystroke Index,  Prev: FAQ,  Up: Top
+
+B Debugging Tools
+*****************
+
+Magit and its dependencies provide a few debugging tools, and we
+appreciate it very much if you use those tools before reporting an
+issue.  Please include all relevant output when reporting an issue.
+
+‘M-x magit-version’     (‘magit-version’)
+
+     This command shows the currently used versions of Magit, Git, and
+     Emacs in the echo area.  Non-interactively this just returns the
+     Magit version.
+
+‘M-x magit-emacs-Q-command’     (‘magit-emacs-Q-command’)
+
+     This command shows a debugging shell command in the echo area and
+     adds it to the kill ring.  Paste that command into a shell and run
+     it.
+
+     This shell command starts ‘emacs’ with only ‘magit’ and its
+     dependencies loaded.  Neither your configuration nor other
+     installed packages are loaded.  This makes it easier to determine
+     whether some issue lays with Magit or something else.
+
+     If you run Magit from its Git repository, then you should be able
+     to use ‘make emacs-Q’ instead of the output of this command.
+
+‘M-x magit-debug-git-executable’     (‘magit-debug-git-executable’)
+
+     This command displays a buffer containing information about the
+     available and used ‘git’ executable(s), and can be useful when
+     investigating ‘exec-path’ issues.
+
+     Also see *note Git Executable::.
+
+‘M-x with-editor-debug’     (‘with-editor-debug’)
+
+     This command displays a buffer containing information about the
+     available and used ‘~emacsclient’ executable(s), and can be useful
+     when investigating why Magit (or rather ‘with-editor’) cannot find
+     an appropriate ‘emacsclient’ executable.
+
+     Also see *note (with-editor)Debugging::.
+
+   Please also see the *note FAQ::.
+
+
+File: magit.info,  Node: Keystroke Index,  Next: Command Index,  Prev: Debugging Tools,  Up: Top
+
+Appendix C Keystroke Index
+**************************
+
+
+* Menu:
+
+* !:                                     Running Git Manually.
+                                                              (line  12)
+* ! !:                                   Running Git Manually.
+                                                              (line  16)
+* ! a:                                   Running Git Manually.
+                                                              (line  57)
+* ! b:                                   Running Git Manually.
+                                                              (line  61)
+* ! g:                                   Running Git Manually.
+                                                              (line  65)
+* ! k:                                   Running Git Manually.
+                                                              (line  53)
+* ! p:                                   Running Git Manually.
+                                                              (line  24)
+* ! s:                                   Running Git Manually.
+                                                              (line  34)
+* ! S:                                   Running Git Manually.
+                                                              (line  39)
+* $:                                     Viewing Git Output.  (line  16)
+* %:                                     Worktree.            (line   8)
+* % b:                                   Worktree.            (line  13)
+* % c:                                   Worktree.            (line  17)
+* % g:                                   Worktree.            (line  33)
+* % k:                                   Worktree.            (line  28)
+* % p:                                   Worktree.            (line  21)
+* +:                                     Log Buffer.          (line  59)
+* + <1>:                                 Refreshing Diffs.    (line  68)
+* -:                                     Log Buffer.          (line  63)
+* - <1>:                                 Refreshing Diffs.    (line  64)
+* 0:                                     Refreshing Diffs.    (line  72)
+* 1:                                     Section Visibility.  (line  26)
+* 2:                                     Section Visibility.  (line  27)
+* 3:                                     Section Visibility.  (line  28)
+* 4:                                     Section Visibility.  (line  29)
+* =:                                     Log Buffer.          (line  53)
+* ^:                                     Section Movement.    (line  31)
+* a:                                     Applying.            (line  33)
+* A:                                     Cherry Picking.      (line   8)
+* A A:                                   Cherry Picking.      (line  16)
+* A a:                                   Cherry Picking.      (line  23)
+* A A <1>:                               Cherry Picking.      (line  89)
+* A a <1>:                               Cherry Picking.      (line  97)
+* A d:                                   Cherry Picking.      (line  53)
+* A h:                                   Cherry Picking.      (line  41)
+* A n:                                   Cherry Picking.      (line  64)
+* A s:                                   Cherry Picking.      (line  75)
+* A s <1>:                               Cherry Picking.      (line  93)
+* B:                                     Bisecting.           (line   8)
+* b:                                     Blaming.             (line  86)
+* b <1>:                                 The Branch Popup.    (line  12)
+* B B:                                   Bisecting.           (line  16)
+* B b:                                   Bisecting.           (line  31)
+* b b:                                   The Branch Popup.    (line  37)
+* b C:                                   The Branch Popup.    (line  29)
+* b c:                                   The Branch Popup.    (line  55)
+* B g:                                   Bisecting.           (line  36)
+* B k:                                   Bisecting.           (line  41)
+* b k:                                   The Branch Popup.    (line 240)
+* b l:                                   The Branch Popup.    (line  62)
+* b n:                                   The Branch Popup.    (line  45)
+* B r:                                   Bisecting.           (line  47)
+* b r:                                   The Branch Popup.    (line 246)
+* B s:                                   Bisecting.           (line  24)
+* b s:                                   The Branch Popup.    (line  85)
+* b x:                                   The Branch Popup.    (line 224)
+* b Y:                                   The Branch Popup.    (line 113)
+* b y:                                   The Branch Popup.    (line 218)
+* c:                                     Blaming.             (line 120)
+* c <1>:                                 Initiating a Commit. (line   8)
+* c <2>:                                 Editing Rebase Sequences.
+                                                              (line  72)
+* c a:                                   Initiating a Commit. (line  18)
+* c A:                                   Initiating a Commit. (line  66)
+* c c:                                   Initiating a Commit. (line  13)
+* c e:                                   Initiating a Commit. (line  22)
+* c f:                                   Initiating a Commit. (line  42)
+* c F:                                   Initiating a Commit. (line  50)
+* c s:                                   Initiating a Commit. (line  54)
+* c S:                                   Initiating a Commit. (line  62)
+* c w:                                   Initiating a Commit. (line  32)
+* C-<return>:                            Diff Buffer.         (line  48)
+* C-<tab>:                               Section Visibility.  (line  13)
+* C-c C-a:                               Editing Commit Messages.
+                                                              (line 128)
+* C-c C-b:                               Log Buffer.          (line  19)
+* C-c C-b <1>:                           Refreshing Diffs.    (line  90)
+* C-c C-c:                               Popup Buffers and Prefix Commands.
+                                                              (line  20)
+* C-c C-c <1>:                           Select from Log.     (line  20)
+* C-c C-c <2>:                           Editing Commit Messages.
+                                                              (line  19)
+* C-c C-c <3>:                           Editing Rebase Sequences.
+                                                              (line   6)
+* C-c C-d:                               Refreshing Diffs.    (line  80)
+* C-c C-d <1>:                           Editing Commit Messages.
+                                                              (line  57)
+* C-c C-e:                               Diff Buffer.         (line  74)
+* C-c C-f:                               Log Buffer.          (line  23)
+* C-c C-f <1>:                           Refreshing Diffs.    (line  94)
+* C-c C-i:                               Editing Commit Messages.
+                                                              (line 153)
+* C-c C-k:                               Select from Log.     (line  26)
+* C-c C-k <1>:                           Editing Commit Messages.
+                                                              (line  24)
+* C-c C-k <2>:                           Editing Rebase Sequences.
+                                                              (line  11)
+* C-c C-n:                               Log Buffer.          (line  27)
+* C-c C-o:                               Editing Commit Messages.
+                                                              (line 144)
+* C-c C-p:                               Editing Commit Messages.
+                                                              (line 148)
+* C-c C-r:                               Editing Commit Messages.
+                                                              (line 132)
+* C-c C-s:                               Editing Commit Messages.
+                                                              (line 136)
+* C-c C-t:                               Diff Buffer.         (line  70)
+* C-c C-t <1>:                           Editing Commit Messages.
+                                                              (line 140)
+* C-c C-w:                               Editing Commit Messages.
+                                                              (line  63)
+* C-c M-g:                               Minor Mode for Buffers Visiting Files.
+                                                              (line  19)
+* C-c M-g B:                             Minor Mode for Buffers Visiting Files.
+                                                              (line  80)
+* C-c M-g b:                             Minor Mode for Buffers Visiting Files.
+                                                              (line  86)
+* C-c M-g c:                             Minor Mode for Buffers Visiting Files.
+                                                              (line  33)
+* C-c M-g D:                             Minor Mode for Buffers Visiting Files.
+                                                              (line  39)
+* C-c M-g d:                             Minor Mode for Buffers Visiting Files.
+                                                              (line  47)
+* C-c M-g e:                             Minor Mode for Buffers Visiting Files.
+                                                              (line 102)
+* C-c M-g f:                             Minor Mode for Buffers Visiting Files.
+                                                              (line  96)
+* C-c M-g L:                             Minor Mode for Buffers Visiting Files.
+                                                              (line  57)
+* C-c M-g l:                             Minor Mode for Buffers Visiting Files.
+                                                              (line  64)
+* C-c M-g p:                             Minor Mode for Buffers Visiting Files.
+                                                              (line 112)
+* C-c M-g r:                             Minor Mode for Buffers Visiting Files.
+                                                              (line  91)
+* C-c M-g s:                             Minor Mode for Buffers Visiting Files.
+                                                              (line  24)
+* C-c M-g t:                             Minor Mode for Buffers Visiting Files.
+                                                              (line  71)
+* C-c M-g u:                             Minor Mode for Buffers Visiting Files.
+                                                              (line  28)
+* C-c M-s:                               Editing Commit Messages.
+                                                              (line  35)
+* C-w:                                   Common Commands.     (line  21)
+* C-x g:                                 Status Buffer.       (line  22)
+* C-x u:                                 Editing Rebase Sequences.
+                                                              (line  89)
+* d:                                     Diffing.             (line  20)
+* D:                                     Refreshing Diffs.    (line  11)
+* d c:                                   Diffing.             (line  67)
+* d d:                                   Diffing.             (line  25)
+* D f:                                   Refreshing Diffs.    (line  45)
+* D F:                                   Refreshing Diffs.    (line  50)
+* D g:                                   Refreshing Diffs.    (line  16)
+* d p:                                   Diffing.             (line  59)
+* d r:                                   Diffing.             (line  29)
+* D r:                                   Refreshing Diffs.    (line  40)
+* d s:                                   Diffing.             (line  49)
+* D s:                                   Refreshing Diffs.    (line  21)
+* d t:                                   Diffing.             (line  72)
+* D t:                                   Refreshing Diffs.    (line  36)
+* d u:                                   Diffing.             (line  55)
+* d w:                                   Diffing.             (line  43)
+* D w:                                   Refreshing Diffs.    (line  28)
+* DEL:                                   Log Buffer.          (line  43)
+* DEL <1>:                               Diff Buffer.         (line 103)
+* DEL <2>:                               Blaming.             (line  73)
+* DEL <3>:                               Editing Rebase Sequences.
+                                                              (line  28)
+* e:                                     Ediffing.            (line   9)
+* E:                                     Ediffing.            (line  21)
+* e <1>:                                 Editing Rebase Sequences.
+                                                              (line  55)
+* E c:                                   Ediffing.            (line  65)
+* E i:                                   Ediffing.            (line  57)
+* E m:                                   Ediffing.            (line  35)
+* E r:                                   Ediffing.            (line  26)
+* E s:                                   Ediffing.            (line  48)
+* E u:                                   Ediffing.            (line  53)
+* E w:                                   Ediffing.            (line  61)
+* E z:                                   Ediffing.            (line  69)
+* f:                                     Editing Rebase Sequences.
+                                                              (line  63)
+* f <1>:                                 Fetching.            (line  11)
+* F:                                     Pulling.             (line  11)
+* f a:                                   Fetching.            (line  38)
+* f e:                                   Fetching.            (line  24)
+* F e:                                   Pulling.             (line  24)
+* f m:                                   Fetching.            (line  42)
+* f o:                                   Fetching.            (line  28)
+* f p:                                   Fetching.            (line  16)
+* F p:                                   Pulling.             (line  16)
+* f r:                                   Fetching.            (line  33)
+* f u:                                   Fetching.            (line  20)
+* F u:                                   Pulling.             (line  20)
+* g:                                     Automatic Refreshing of Magit Buffers.
+                                                              (line  22)
+* G:                                     Automatic Refreshing of Magit Buffers.
+                                                              (line  31)
+* j:                                     Diff Buffer.         (line  93)
+* k:                                     Viewing Git Output.  (line  24)
+* k <1>:                                 Applying.            (line  40)
+* k <2>:                                 Editing Rebase Sequences.
+                                                              (line  68)
+* k <3>:                                 Stashing.            (line  95)
+* l:                                     Logging.             (line  28)
+* L:                                     Refreshing Logs.     (line  11)
+* L <1>:                                 Log Buffer.          (line   6)
+* L <2>:                                 Log Margin.          (line  47)
+* l a:                                   Logging.             (line  58)
+* l b:                                   Logging.             (line  54)
+* L d:                                   Log Margin.          (line  64)
+* L g:                                   Refreshing Logs.     (line  16)
+* l h:                                   Logging.             (line  46)
+* l H:                                   Reflog.              (line  19)
+* l l:                                   Logging.             (line  33)
+* l L:                                   Logging.             (line  50)
+* L L:                                   Log Margin.          (line  56)
+* L l:                                   Log Margin.          (line  60)
+* l o:                                   Logging.             (line  39)
+* l O:                                   Reflog.              (line  15)
+* l r:                                   Reflog.              (line  11)
+* L s:                                   Refreshing Logs.     (line  21)
+* L t:                                   Refreshing Logs.     (line  36)
+* L w:                                   Refreshing Logs.     (line  28)
+* m:                                     Merging.             (line   9)
+* M:                                     The Remote Popup.    (line  13)
+* m a:                                   Merging.             (line  44)
+* m a <1>:                               Merging.             (line  94)
+* M a:                                   The Remote Popup.    (line  35)
+* M C:                                   The Remote Popup.    (line  26)
+* m e:                                   Merging.             (line  30)
+* m i:                                   Merging.             (line  57)
+* M k:                                   The Remote Popup.    (line  50)
+* m m:                                   Merging.             (line  17)
+* m m <1>:                               Merging.             (line  88)
+* m n:                                   Merging.             (line  37)
+* m p:                                   Merging.             (line  80)
+* M p:                                   The Remote Popup.    (line  54)
+* M P:                                   The Remote Popup.    (line  59)
+* M r:                                   The Remote Popup.    (line  40)
+* m s:                                   Merging.             (line  71)
+* M u:                                   The Remote Popup.    (line  45)
+* M-1:                                   Section Visibility.  (line  33)
+* M-2:                                   Section Visibility.  (line  34)
+* M-3:                                   Section Visibility.  (line  35)
+* M-4:                                   Section Visibility.  (line  36)
+* M-<tab>:                               Section Visibility.  (line  17)
+* M-n:                                   Section Movement.    (line  26)
+* M-n <1>:                               Editing Commit Messages.
+                                                              (line  45)
+* M-n <2>:                               Editing Rebase Sequences.
+                                                              (line  47)
+* M-p:                                   Section Movement.    (line  20)
+* M-p <1>:                               Editing Commit Messages.
+                                                              (line  39)
+* M-p <2>:                               Editing Rebase Sequences.
+                                                              (line  43)
+* M-w:                                   Blaming.             (line 112)
+* M-w <1>:                               Common Commands.     (line  10)
+* M-x magit-clone:                       Repository Setup.    (line  16)
+* M-x magit-debug-git-executable:        Git Executable.      (line  45)
+* M-x magit-debug-git-executable <1>:    Debugging Tools.     (line  30)
+* M-x magit-describe-section-briefly:    Section Types and Values.
+                                                              (line  13)
+* M-x magit-describe-section-briefly <1>: Matching Sections.  (line   6)
+* M-x magit-emacs-Q-command:             Debugging Tools.     (line  16)
+* M-x magit-find-file:                   Visiting Blobs.      (line   6)
+* M-x magit-find-file-other-window:      Visiting Blobs.      (line  11)
+* M-x magit-init:                        Repository Setup.    (line   6)
+* M-x magit-reset-index:                 Staging and Unstaging.
+                                                              (line  87)
+* M-x magit-reverse-in-index:            Staging and Unstaging.
+                                                              (line  62)
+* M-x magit-stage-file:                  Staging from File-Visiting Buffers.
+                                                              (line  10)
+* M-x magit-toggle-buffer-lock:          Modes and Buffers.   (line  17)
+* M-x magit-unstage-file:                Staging from File-Visiting Buffers.
+                                                              (line  18)
+* M-x magit-version:                     Git Executable.      (line  17)
+* M-x magit-version <1>:                 Debugging Tools.     (line  10)
+* M-x magit-wip-commit:                  Wip Modes.           (line 174)
+* M-x with-editor-debug:                 Debugging Tools.     (line  38)
+* n:                                     Section Movement.    (line  16)
+* n <1>:                                 Blaming.             (line  91)
+* N:                                     Blaming.             (line  95)
+* n <2>:                                 Editing Rebase Sequences.
+                                                              (line  39)
+* n <3>:                                 Minor Mode for Buffers Visiting Blobs.
+                                                              (line  16)
+* o:                                     Submodule Popup.     (line   6)
+* O:                                     Subtree.             (line   8)
+* o a:                                   Submodule Popup.     (line  19)
+* O a:                                   Subtree.             (line  20)
+* O c:                                   Subtree.             (line  24)
+* o d:                                   Submodule Popup.     (line  49)
+* o f:                                   Submodule Popup.     (line  57)
+* O f:                                   Subtree.             (line  32)
+* o l:                                   Submodule Popup.     (line  53)
+* O m:                                   Subtree.             (line  28)
+* o p:                                   Submodule Popup.     (line  33)
+* O p:                                   Subtree.             (line  36)
+* o r:                                   Submodule Popup.     (line  26)
+* o s:                                   Submodule Popup.     (line  43)
+* O s:                                   Subtree.             (line  41)
+* o u:                                   Submodule Popup.     (line  38)
+* p:                                     Section Movement.    (line  10)
+* p <1>:                                 Blaming.             (line  99)
+* P:                                     Blaming.             (line 103)
+* p <2>:                                 Editing Rebase Sequences.
+                                                              (line  35)
+* P <1>:                                 Pushing.             (line  11)
+* p <3>:                                 Minor Mode for Buffers Visiting Blobs.
+                                                              (line  12)
+* P e:                                   Pushing.             (line  35)
+* P m:                                   Pushing.             (line  53)
+* P o:                                   Pushing.             (line  39)
+* P p:                                   Pushing.             (line  16)
+* P r:                                   Pushing.             (line  44)
+* P t:                                   Pushing.             (line  59)
+* P T:                                   Pushing.             (line  65)
+* P u:                                   Pushing.             (line  26)
+* q:                                     Quitting Windows.    (line   6)
+* q <1>:                                 Log Buffer.          (line  12)
+* q <2>:                                 Blaming.             (line 107)
+* q <3>:                                 Minor Mode for Buffers Visiting Blobs.
+                                                              (line  20)
+* r:                                     Rebasing.            (line   9)
+* r <1>:                                 Editing Rebase Sequences.
+                                                              (line  51)
+* r a:                                   Rebasing.            (line 107)
+* r e:                                   Rebasing.            (line  33)
+* r e <1>:                               Rebasing.            (line 103)
+* r f:                                   Rebasing.            (line  73)
+* r i:                                   Rebasing.            (line  69)
+* r k:                                   Rebasing.            (line  85)
+* r m:                                   Rebasing.            (line  77)
+* r p:                                   Rebasing.            (line  24)
+* r r:                                   Rebasing.            (line  92)
+* r s:                                   Rebasing.            (line  39)
+* r s <1>:                               Rebasing.            (line  99)
+* r u:                                   Rebasing.            (line  29)
+* r w:                                   Rebasing.            (line  81)
+* RET:                                   Diff Buffer.         (line   8)
+* RET <1>:                               References Buffer.   (line 166)
+* RET <2>:                               Blaming.             (line  59)
+* RET <3>:                               Editing Rebase Sequences.
+                                                              (line  16)
+* s:                                     Staging and Unstaging.
+                                                              (line  28)
+* S:                                     Staging and Unstaging.
+                                                              (line  36)
+* s <1>:                                 Editing Rebase Sequences.
+                                                              (line  59)
+* S-<tab>:                               Section Visibility.  (line  22)
+* SPC:                                   Log Buffer.          (line  33)
+* SPC <1>:                               Diff Buffer.         (line  99)
+* SPC <2>:                               Blaming.             (line  63)
+* SPC <3>:                               Editing Rebase Sequences.
+                                                              (line  21)
+* t:                                     Tagging.             (line   8)
+* T:                                     Notes.               (line   8)
+* T a:                                   Notes.               (line  51)
+* T c:                                   Notes.               (line  46)
+* t k:                                   Tagging.             (line  18)
+* T m:                                   Notes.               (line  37)
+* t p:                                   Tagging.             (line  24)
+* T p:                                   Notes.               (line  29)
+* T r:                                   Notes.               (line  21)
+* t t:                                   Tagging.             (line  13)
+* T T:                                   Notes.               (line  13)
+* TAB:                                   Section Visibility.  (line   9)
+* u:                                     Staging and Unstaging.
+                                                              (line  43)
+* U:                                     Staging and Unstaging.
+                                                              (line  52)
+* v:                                     Applying.            (line  44)
+* V:                                     Reverting.           (line   6)
+* V A:                                   Reverting.           (line  30)
+* V a:                                   Reverting.           (line  38)
+* V s:                                   Reverting.           (line  34)
+* V V:                                   Reverting.           (line  14)
+* V v:                                   Reverting.           (line  20)
+* W:                                     Creating and Sending Patches.
+                                                              (line   6)
+* w:                                     Applying Patches.    (line   8)
+* w a:                                   Applying Patches.    (line  34)
+* w a <1>:                               Applying Patches.    (line  42)
+* w a a:                                 Applying Patches.    (line  47)
+* w m:                                   Applying Patches.    (line  19)
+* W p:                                   Creating and Sending Patches.
+                                                              (line  11)
+* W r:                                   Creating and Sending Patches.
+                                                              (line  17)
+* w s:                                   Applying Patches.    (line  30)
+* w w:                                   Applying Patches.    (line  13)
+* w w <1>:                               Applying Patches.    (line  26)
+* x:                                     Editing Rebase Sequences.
+                                                              (line  76)
+* x <1>:                                 Resetting.           (line   8)
+* X f:                                   Resetting.           (line  43)
+* X h:                                   Resetting.           (line  25)
+* X i:                                   Resetting.           (line  30)
+* X m:                                   Resetting.           (line  14)
+* X s:                                   Resetting.           (line  19)
+* X w:                                   Resetting.           (line  37)
+* X w <1>:                               Wip Modes.           (line 101)
+* Y:                                     Cherries.            (line  17)
+* y:                                     References Buffer.   (line   6)
+* y <1>:                                 Editing Rebase Sequences.
+                                                              (line  85)
+* y c:                                   References Buffer.   (line  19)
+* y o:                                   References Buffer.   (line  24)
+* y y:                                   References Buffer.   (line  14)
+* z:                                     Stashing.            (line   8)
+* z a:                                   Stashing.            (line  58)
+* z b:                                   Stashing.            (line  80)
+* z B:                                   Stashing.            (line  85)
+* z f:                                   Stashing.            (line  91)
+* z i:                                   Stashing.            (line  20)
+* z I:                                   Stashing.            (line  46)
+* z k:                                   Stashing.            (line  71)
+* z l:                                   Stashing.            (line  99)
+* z p:                                   Stashing.            (line  64)
+* z v:                                   Stashing.            (line  76)
+* z w:                                   Stashing.            (line  25)
+* z W:                                   Stashing.            (line  51)
+* z x:                                   Stashing.            (line  32)
+* z z:                                   Stashing.            (line  13)
+* z Z:                                   Stashing.            (line  39)
+
+
+File: magit.info,  Node: Command Index,  Next: Function Index,  Prev: Keystroke Index,  Up: Top
+
+Appendix D Command Index
+************************
+
+
+* Menu:
+
+* auto-revert-mode:                      Automatic Reverting of File-Visiting Buffers.
+                                                              (line  62)
+* forward-line:                          Editing Rebase Sequences.
+                                                              (line  39)
+* git-commit-ack:                        Editing Commit Messages.
+                                                              (line 128)
+* git-commit-cc:                         Editing Commit Messages.
+                                                              (line 144)
+* git-commit-next-message:               Editing Commit Messages.
+                                                              (line  45)
+* git-commit-prev-message:               Editing Commit Messages.
+                                                              (line  39)
+* git-commit-reported:                   Editing Commit Messages.
+                                                              (line 148)
+* git-commit-review:                     Editing Commit Messages.
+                                                              (line 132)
+* git-commit-save-message:               Editing Commit Messages.
+                                                              (line  35)
+* git-commit-signoff:                    Editing Commit Messages.
+                                                              (line 136)
+* git-commit-suggested:                  Editing Commit Messages.
+                                                              (line 153)
+* git-commit-test:                       Editing Commit Messages.
+                                                              (line 140)
+* git-rebase-backward-line:              Editing Rebase Sequences.
+                                                              (line  35)
+* git-rebase-edit:                       Editing Rebase Sequences.
+                                                              (line  55)
+* git-rebase-exec:                       Editing Rebase Sequences.
+                                                              (line  76)
+* git-rebase-fixup:                      Editing Rebase Sequences.
+                                                              (line  63)
+* git-rebase-insert:                     Editing Rebase Sequences.
+                                                              (line  85)
+* git-rebase-kill-line:                  Editing Rebase Sequences.
+                                                              (line  68)
+* git-rebase-move-line-down:             Editing Rebase Sequences.
+                                                              (line  47)
+* git-rebase-move-line-up:               Editing Rebase Sequences.
+                                                              (line  43)
+* git-rebase-pick:                       Editing Rebase Sequences.
+                                                              (line  72)
+* git-rebase-reword:                     Editing Rebase Sequences.
+                                                              (line  51)
+* git-rebase-show-commit:                Editing Rebase Sequences.
+                                                              (line  16)
+* git-rebase-show-or-scroll-down:        Editing Rebase Sequences.
+                                                              (line  28)
+* git-rebase-show-or-scroll-up:          Editing Rebase Sequences.
+                                                              (line  21)
+* git-rebase-squash:                     Editing Rebase Sequences.
+                                                              (line  59)
+* git-rebase-undo:                       Editing Rebase Sequences.
+                                                              (line  89)
+* ido-enter-magit-status:                Status Buffer.       (line  47)
+* magit-am-abort:                        Applying Patches.    (line  34)
+* magit-am-apply-maildir:                Applying Patches.    (line  19)
+* magit-am-apply-patches:                Applying Patches.    (line  13)
+* magit-am-continue:                     Applying Patches.    (line  26)
+* magit-am-popup:                        Applying Patches.    (line   8)
+* magit-am-skip:                         Applying Patches.    (line  30)
+* magit-apply:                           Applying.            (line  33)
+* magit-bisect-bad:                      Bisecting.           (line  31)
+* magit-bisect-good:                     Bisecting.           (line  36)
+* magit-bisect-popup:                    Bisecting.           (line   8)
+* magit-bisect-reset:                    Bisecting.           (line  47)
+* magit-bisect-run:                      Bisecting.           (line  24)
+* magit-bisect-skip:                     Bisecting.           (line  41)
+* magit-bisect-start:                    Bisecting.           (line  16)
+* magit-blame:                           Blaming.             (line  17)
+* magit-blame <1>:                       Minor Mode for Buffers Visiting Files.
+                                                              (line  86)
+* magit-blame-copy-hash:                 Blaming.             (line 112)
+* magit-blame-cycle-style:               Blaming.             (line 120)
+* magit-blame-echo:                      Blaming.             (line  32)
+* magit-blame-next-chunk:                Blaming.             (line  91)
+* magit-blame-next-chunk-same-commit:    Blaming.             (line  95)
+* magit-blame-popup:                     Blaming.             (line  86)
+* magit-blame-popup <1>:                 Minor Mode for Buffers Visiting Files.
+                                                              (line  80)
+* magit-blame-previous-chunk:            Blaming.             (line  99)
+* magit-blame-previous-chunk-same-commit: Blaming.            (line 103)
+* magit-blame-quit:                      Blaming.             (line 107)
+* magit-blame-removal:                   Blaming.             (line  38)
+* magit-blame-removal <1>:               Minor Mode for Buffers Visiting Files.
+                                                              (line  91)
+* magit-blame-reverse:                   Blaming.             (line  46)
+* magit-blame-reverse <1>:               Minor Mode for Buffers Visiting Files.
+                                                              (line  96)
+* magit-blob-next:                       Minor Mode for Buffers Visiting Blobs.
+                                                              (line  16)
+* magit-blob-previous:                   Minor Mode for Buffers Visiting Files.
+                                                              (line 112)
+* magit-blob-previous <1>:               Minor Mode for Buffers Visiting Blobs.
+                                                              (line  12)
+* magit-branch:                          The Branch Popup.    (line  45)
+* magit-branch-and-checkout:             The Branch Popup.    (line  55)
+* magit-branch-checkout:                 The Branch Popup.    (line  62)
+* magit-branch-config-popup:             The Branch Popup.    (line  29)
+* magit-branch-config-popup <1>:         The Branch Config Popup.
+                                                              (line   6)
+* magit-branch-delete:                   The Branch Popup.    (line 240)
+* magit-branch-or-checkout:              The Branch Popup.    (line 350)
+* magit-branch-orphan:                   The Branch Popup.    (line 345)
+* magit-branch-popup:                    The Branch Popup.    (line  12)
+* magit-branch-pull-request:             The Branch Popup.    (line 113)
+* magit-branch-rename:                   The Branch Popup.    (line 246)
+* magit-branch-reset:                    The Branch Popup.    (line 224)
+* magit-branch-shelve:                   Auxillary Branch Commands.
+                                                              (line   8)
+* magit-branch-spinoff:                  The Branch Popup.    (line  85)
+* magit-branch-unshelve:                 Auxillary Branch Commands.
+                                                              (line  19)
+* magit-checkout:                        The Branch Popup.    (line  37)
+* magit-checkout-pull-request:           The Branch Popup.    (line 218)
+* magit-cherry:                          Cherries.            (line  17)
+* magit-cherry-apply:                    Cherry Picking.      (line  23)
+* magit-cherry-donate:                   Cherry Picking.      (line  53)
+* magit-cherry-harvest:                  Cherry Picking.      (line  41)
+* magit-cherry-pick:                     Cherry Picking.      (line  16)
+* magit-cherry-pick-popup:               Cherry Picking.      (line   8)
+* magit-cherry-spinoff:                  Cherry Picking.      (line  75)
+* magit-cherry-spinout:                  Cherry Picking.      (line  64)
+* magit-clone:                           Repository Setup.    (line  16)
+* magit-commit:                          Initiating a Commit. (line  13)
+* magit-commit-amend:                    Initiating a Commit. (line  18)
+* magit-commit-augment:                  Initiating a Commit. (line  66)
+* magit-commit-extend:                   Initiating a Commit. (line  22)
+* magit-commit-fixup:                    Initiating a Commit. (line  42)
+* magit-commit-instant-fixup:            Initiating a Commit. (line  50)
+* magit-commit-instant-squash:           Initiating a Commit. (line  62)
+* magit-commit-popup:                    Initiating a Commit. (line   8)
+* magit-commit-popup <1>:                Minor Mode for Buffers Visiting Files.
+                                                              (line  33)
+* magit-commit-reword:                   Initiating a Commit. (line  32)
+* magit-commit-squash:                   Initiating a Commit. (line  54)
+* magit-copy-buffer-revision:            Common Commands.     (line  21)
+* magit-copy-section-value:              Common Commands.     (line  10)
+* magit-cycle-margin-style:              Log Margin.          (line  60)
+* magit-debug-git-executable:            Git Executable.      (line  45)
+* magit-debug-git-executable <1>:        Debugging Tools.     (line  30)
+* magit-describe-section-briefly:        Section Types and Values.
+                                                              (line  13)
+* magit-describe-section-briefly <1>:    Matching Sections.   (line   6)
+* magit-diff:                            Diffing.             (line  29)
+* magit-diff-buffer-file:                Minor Mode for Buffers Visiting Files.
+                                                              (line  47)
+* magit-diff-buffer-file-popup:          Minor Mode for Buffers Visiting Files.
+                                                              (line  39)
+* magit-diff-default-context:            Refreshing Diffs.    (line  72)
+* magit-diff-dwim:                       Diffing.             (line  25)
+* magit-diff-edit-hunk-commit:           Diff Buffer.         (line  74)
+* magit-diff-flip-revs:                  Refreshing Diffs.    (line  45)
+* magit-diff-less-context:               Refreshing Diffs.    (line  64)
+* magit-diff-more-context:               Refreshing Diffs.    (line  68)
+* magit-diff-paths:                      Diffing.             (line  59)
+* magit-diff-popup:                      Diffing.             (line  20)
+* magit-diff-refresh:                    Refreshing Diffs.    (line  16)
+* magit-diff-refresh-popup:              Refreshing Diffs.    (line  11)
+* magit-diff-save-default-arguments:     Refreshing Diffs.    (line  28)
+* magit-diff-set-default-arguments:      Refreshing Diffs.    (line  21)
+* magit-diff-show-or-scroll-down:        Log Buffer.          (line  43)
+* magit-diff-show-or-scroll-down <1>:    Blaming.             (line  73)
+* magit-diff-show-or-scroll-up:          Log Buffer.          (line  33)
+* magit-diff-show-or-scroll-up <1>:      Blaming.             (line  63)
+* magit-diff-staged:                     Diffing.             (line  49)
+* magit-diff-switch-range-type:          Refreshing Diffs.    (line  40)
+* magit-diff-toggle-file-filter:         Refreshing Diffs.    (line  50)
+* magit-diff-toggle-refine-hunk:         Refreshing Diffs.    (line  36)
+* magit-diff-trace-definition:           Diff Buffer.         (line  70)
+* magit-diff-unstaged:                   Diffing.             (line  55)
+* magit-diff-visit-file:                 Diff Buffer.         (line   8)
+* magit-diff-visit-file-other-window:    Diff Buffer.         (line  65)
+* magit-diff-visit-file-worktree:        Diff Buffer.         (line  48)
+* magit-diff-while-committing:           Refreshing Diffs.    (line  80)
+* magit-diff-while-committing <1>:       Editing Commit Messages.
+                                                              (line  57)
+* magit-diff-working-tree:               Diffing.             (line  43)
+* magit-discard:                         Applying.            (line  40)
+* magit-dispatch-popup:                  Popup Buffers and Prefix Commands.
+                                                              (line  20)
+* magit-ediff-compare:                   Ediffing.            (line  26)
+* magit-ediff-dwim:                      Ediffing.            (line   9)
+* magit-ediff-popup:                     Ediffing.            (line  21)
+* magit-ediff-resolve:                   Ediffing.            (line  35)
+* magit-ediff-show-commit:               Ediffing.            (line  65)
+* magit-ediff-show-staged:               Ediffing.            (line  57)
+* magit-ediff-show-stash:                Ediffing.            (line  69)
+* magit-ediff-show-unstaged:             Ediffing.            (line  53)
+* magit-ediff-show-working-tree:         Ediffing.            (line  61)
+* magit-ediff-stage:                     Ediffing.            (line  48)
+* magit-edit-line-commit:                Minor Mode for Buffers Visiting Files.
+                                                              (line 102)
+* magit-emacs-Q-command:                 Debugging Tools.     (line  16)
+* magit-fetch:                           Fetching.            (line  24)
+* magit-fetch-all:                       Fetching.            (line  38)
+* magit-fetch-branch:                    Fetching.            (line  28)
+* magit-fetch-from-pushremote:           Fetching.            (line  16)
+* magit-fetch-from-upstream:             Fetching.            (line  20)
+* magit-fetch-modules:                   Submodule Popup.     (line  57)
+* magit-fetch-popup:                     Fetching.            (line  11)
+* magit-fetch-refspec:                   Fetching.            (line  33)
+* magit-file-checkout:                   Resetting.           (line  43)
+* magit-file-checkout <1>:               Minor Mode for Buffers Visiting Files.
+                                                              (line 131)
+* magit-file-delete:                     Minor Mode for Buffers Visiting Files.
+                                                              (line 123)
+* magit-file-popup:                      Minor Mode for Buffers Visiting Files.
+                                                              (line  19)
+* magit-file-rename:                     Minor Mode for Buffers Visiting Files.
+                                                              (line 119)
+* magit-file-untrack:                    Minor Mode for Buffers Visiting Files.
+                                                              (line 127)
+* magit-find-file:                       Visiting Blobs.      (line   6)
+* magit-find-file-other-window:          Visiting Blobs.      (line  11)
+* magit-format-patch:                    Creating and Sending Patches.
+                                                              (line  11)
+* magit-git-command:                     Running Git Manually.
+                                                              (line  24)
+* magit-git-command-topdir:              Running Git Manually.
+                                                              (line  16)
+* magit-go-backward:                     Log Buffer.          (line  19)
+* magit-go-backward <1>:                 Refreshing Diffs.    (line  90)
+* magit-go-forward:                      Log Buffer.          (line  23)
+* magit-go-forward <1>:                  Refreshing Diffs.    (line  94)
+* magit-init:                            Repository Setup.    (line   6)
+* magit-jump-to-diffstat-or-diff:        Diff Buffer.         (line  93)
+* magit-kill-this-buffer:                Minor Mode for Buffers Visiting Blobs.
+                                                              (line  20)
+* magit-list-repositories:               Repository List.     (line   6)
+* magit-list-submodules:                 Listing Submodules.  (line  13)
+* magit-list-submodules <1>:             Submodule Popup.     (line  53)
+* magit-log:                             Logging.             (line  39)
+* magit-log-all:                         Logging.             (line  58)
+* magit-log-all-branches:                Logging.             (line  54)
+* magit-log-branches:                    Logging.             (line  50)
+* magit-log-buffer-file:                 Minor Mode for Buffers Visiting Files.
+                                                              (line  64)
+* magit-log-buffer-file-popup:           Minor Mode for Buffers Visiting Files.
+                                                              (line  57)
+* magit-log-bury-buffer:                 Log Buffer.          (line  12)
+* magit-log-current:                     Logging.             (line  33)
+* magit-log-double-commit-limit:         Log Buffer.          (line  59)
+* magit-log-half-commit-limit:           Log Buffer.          (line  63)
+* magit-log-head:                        Logging.             (line  46)
+* magit-log-move-to-parent:              Log Buffer.          (line  27)
+* magit-log-popup:                       Logging.             (line  28)
+* magit-log-refresh:                     Refreshing Logs.     (line  16)
+* magit-log-refresh-popup:               Refreshing Logs.     (line  11)
+* magit-log-refresh-popup <1>:           Log Buffer.          (line   6)
+* magit-log-save-default-arguments:      Refreshing Logs.     (line  28)
+* magit-log-select-pick:                 Select from Log.     (line  20)
+* magit-log-select-quit:                 Select from Log.     (line  26)
+* magit-log-set-default-arguments:       Refreshing Logs.     (line  21)
+* magit-log-toggle-commit-limit:         Log Buffer.          (line  53)
+* magit-log-trace-definition:            Minor Mode for Buffers Visiting Files.
+                                                              (line  71)
+* magit-margin-popup:                    Log Margin.          (line  47)
+* magit-merge:                           Merging.             (line  17)
+* magit-merge <1>:                       Merging.             (line  88)
+* magit-merge-abort:                     Merging.             (line  94)
+* magit-merge-absorb:                    Merging.             (line  44)
+* magit-merge-editmsg:                   Merging.             (line  30)
+* magit-merge-into:                      Merging.             (line  57)
+* magit-merge-nocommit:                  Merging.             (line  37)
+* magit-merge-popup:                     Merging.             (line   9)
+* magit-merge-preview:                   Merging.             (line  80)
+* magit-merge-squash:                    Merging.             (line  71)
+* magit-mode-bury-buffer:                Quitting Windows.    (line   6)
+* magit-notes-edit:                      Notes.               (line  13)
+* magit-notes-merge:                     Notes.               (line  37)
+* magit-notes-merge-abort:               Notes.               (line  51)
+* magit-notes-merge-commit:              Notes.               (line  46)
+* magit-notes-popup:                     Notes.               (line   8)
+* magit-notes-prune:                     Notes.               (line  29)
+* magit-notes-remove:                    Notes.               (line  21)
+* magit-patch-apply:                     Applying Patches.    (line  47)
+* magit-patch-apply-popup:               Applying Patches.    (line  42)
+* magit-patch-popup:                     Creating and Sending Patches.
+                                                              (line   6)
+* magit-pop-revision-stack:              Editing Commit Messages.
+                                                              (line  63)
+* magit-process:                         Viewing Git Output.  (line  16)
+* magit-process-kill:                    Viewing Git Output.  (line  24)
+* magit-pull:                            Pulling.             (line  24)
+* magit-pull-from-pushremote:            Pulling.             (line  16)
+* magit-pull-from-upstream:              Pulling.             (line  20)
+* magit-pull-popup:                      Pulling.             (line  11)
+* magit-push:                            Pushing.             (line  39)
+* magit-push-current:                    Pushing.             (line  35)
+* magit-push-current-to-pushremote:      Pushing.             (line  16)
+* magit-push-current-to-upstream:        Pushing.             (line  26)
+* magit-push-implicitly args:            Pushing.             (line  73)
+* magit-push-matching:                   Pushing.             (line  53)
+* magit-push-popup:                      Pushing.             (line  11)
+* magit-push-refspecs:                   Pushing.             (line  44)
+* magit-push-tag:                        Pushing.             (line  65)
+* magit-push-tags:                       Pushing.             (line  59)
+* magit-push-to-remote remote args:      Pushing.             (line  84)
+* magit-rebase:                          Rebasing.            (line  33)
+* magit-rebase-abort:                    Rebasing.            (line 107)
+* magit-rebase-autosquash:               Rebasing.            (line  73)
+* magit-rebase-continue:                 Rebasing.            (line  92)
+* magit-rebase-edit:                     Rebasing.            (line 103)
+* magit-rebase-edit-commit:              Rebasing.            (line  77)
+* magit-rebase-interactive:              Rebasing.            (line  69)
+* magit-rebase-onto-pushremote:          Rebasing.            (line  24)
+* magit-rebase-onto-upstream:            Rebasing.            (line  29)
+* magit-rebase-popup:                    Rebasing.            (line   9)
+* magit-rebase-remove-commit:            Rebasing.            (line  85)
+* magit-rebase-reword-commit:            Rebasing.            (line  81)
+* magit-rebase-skip:                     Rebasing.            (line  99)
+* magit-rebase-subset:                   Rebasing.            (line  39)
+* magit-reflog-current:                  Reflog.              (line  11)
+* magit-reflog-head:                     Reflog.              (line  19)
+* magit-reflog-other:                    Reflog.              (line  15)
+* magit-refresh:                         Automatic Refreshing of Magit Buffers.
+                                                              (line  22)
+* magit-refresh-all:                     Automatic Refreshing of Magit Buffers.
+                                                              (line  31)
+* magit-remote-add:                      The Remote Popup.    (line  35)
+* magit-remote-config-popup:             The Remote Popup.    (line  26)
+* magit-remote-config-popup <1>:         The Remote Config Popup.
+                                                              (line   6)
+* magit-remote-popup:                    The Remote Popup.    (line  13)
+* magit-remote-prune:                    The Remote Popup.    (line  54)
+* magit-remote-prune-refspecs:           The Remote Popup.    (line  59)
+* magit-remote-remove:                   The Remote Popup.    (line  50)
+* magit-remote-rename:                   The Remote Popup.    (line  40)
+* magit-remote-set-url:                  The Remote Popup.    (line  45)
+* magit-request-pull:                    Creating and Sending Patches.
+                                                              (line  17)
+* magit-reset:                           Resetting.           (line   8)
+* magit-reset-hard:                      Resetting.           (line  25)
+* magit-reset-head:                      Resetting.           (line  14)
+* magit-reset-index:                     Staging and Unstaging.
+                                                              (line  87)
+* magit-reset-index <1>:                 Resetting.           (line  30)
+* magit-reset-soft:                      Resetting.           (line  19)
+* magit-reset-worktree:                  Resetting.           (line  37)
+* magit-reset-worktree <1>:              Wip Modes.           (line 101)
+* magit-reverse:                         Applying.            (line  44)
+* magit-reverse-in-index:                Staging and Unstaging.
+                                                              (line  62)
+* magit-revert:                          Reverting.           (line  14)
+* magit-revert-no-commit:                Reverting.           (line  20)
+* magit-revert-popup:                    Reverting.           (line   6)
+* magit-run-git-gui:                     Running Git Manually.
+                                                              (line  65)
+* magit-run-gitk:                        Running Git Manually.
+                                                              (line  53)
+* magit-run-gitk-all:                    Running Git Manually.
+                                                              (line  57)
+* magit-run-gitk-branches:               Running Git Manually.
+                                                              (line  61)
+* magit-run-popup:                       Running Git Manually.
+                                                              (line  12)
+* magit-section-backward:                Section Movement.    (line  10)
+* magit-section-backward-siblings:       Section Movement.    (line  20)
+* magit-section-cycle:                   Section Visibility.  (line  13)
+* magit-section-cycle-diffs:             Section Visibility.  (line  17)
+* magit-section-cycle-global:            Section Visibility.  (line  22)
+* magit-section-forward:                 Section Movement.    (line  16)
+* magit-section-forward-siblings:        Section Movement.    (line  26)
+* magit-section-hide:                    Section Visibility.  (line  49)
+* magit-section-hide-children:           Section Visibility.  (line  64)
+* magit-section-show:                    Section Visibility.  (line  45)
+* magit-section-show-children:           Section Visibility.  (line  58)
+* magit-section-show-headings:           Section Visibility.  (line  53)
+* magit-section-show-level-1:            Section Visibility.  (line  26)
+* magit-section-show-level-1-all:        Section Visibility.  (line  33)
+* magit-section-show-level-2:            Section Visibility.  (line  27)
+* magit-section-show-level-2-all:        Section Visibility.  (line  34)
+* magit-section-show-level-3:            Section Visibility.  (line  28)
+* magit-section-show-level-3-all:        Section Visibility.  (line  35)
+* magit-section-show-level-4:            Section Visibility.  (line  29)
+* magit-section-show-level-4-all:        Section Visibility.  (line  36)
+* magit-section-toggle:                  Section Visibility.  (line   9)
+* magit-section-toggle-children:         Section Visibility.  (line  68)
+* magit-section-up:                      Section Movement.    (line  31)
+* magit-sequence-abort:                  Cherry Picking.      (line  97)
+* magit-sequence-abort <1>:              Reverting.           (line  38)
+* magit-sequence-continue:               Cherry Picking.      (line  89)
+* magit-sequence-continue <1>:           Reverting.           (line  30)
+* magit-sequence-skip:                   Cherry Picking.      (line  93)
+* magit-sequence-skip <1>:               Reverting.           (line  34)
+* magit-shell-command:                   Running Git Manually.
+                                                              (line  39)
+* magit-shell-command-topdir:            Running Git Manually.
+                                                              (line  34)
+* magit-show-commit:                     Diffing.             (line  67)
+* magit-show-commit <1>:                 Blaming.             (line  59)
+* magit-show-refs:                       References Buffer.   (line  24)
+* magit-show-refs-current:               References Buffer.   (line  19)
+* magit-show-refs-head:                  References Buffer.   (line  14)
+* magit-show-refs-popup:                 References Buffer.   (line   6)
+* magit-snapshot:                        Stashing.            (line  39)
+* magit-snapshot-index:                  Stashing.            (line  46)
+* magit-snapshot-worktree:               Stashing.            (line  51)
+* magit-stage:                           Staging and Unstaging.
+                                                              (line  28)
+* magit-stage-file:                      Staging from File-Visiting Buffers.
+                                                              (line  10)
+* magit-stage-file <1>:                  Minor Mode for Buffers Visiting Files.
+                                                              (line  24)
+* magit-stage-modified:                  Staging and Unstaging.
+                                                              (line  36)
+* magit-stash:                           Stashing.            (line  13)
+* magit-stash-apply:                     Stashing.            (line  58)
+* magit-stash-branch:                    Stashing.            (line  80)
+* magit-stash-branch-here:               Stashing.            (line  85)
+* magit-stash-clear:                     Stashing.            (line  95)
+* magit-stash-drop:                      Stashing.            (line  71)
+* magit-stash-format-patch:              Stashing.            (line  91)
+* magit-stash-index:                     Stashing.            (line  20)
+* magit-stash-keep-index:                Stashing.            (line  32)
+* magit-stash-list:                      Stashing.            (line  99)
+* magit-stash-pop:                       Stashing.            (line  64)
+* magit-stash-popup:                     Stashing.            (line   8)
+* magit-stash-show:                      Diffing.             (line  72)
+* magit-stash-show <1>:                  Stashing.            (line  76)
+* magit-stash-worktree:                  Stashing.            (line  25)
+* magit-status:                          Status Buffer.       (line  22)
+* magit-submodule-add:                   Submodule Popup.     (line  19)
+* magit-submodule-fetch:                 Fetching.            (line  42)
+* magit-submodule-populate:              Submodule Popup.     (line  33)
+* magit-submodule-popup:                 Submodule Popup.     (line   6)
+* magit-submodule-register:              Submodule Popup.     (line  26)
+* magit-submodule-synchronize:           Submodule Popup.     (line  43)
+* magit-submodule-unpopulate:            Submodule Popup.     (line  49)
+* magit-submodule-update:                Submodule Popup.     (line  38)
+* magit-subtree-add:                     Subtree.             (line  20)
+* magit-subtree-add-commit:              Subtree.             (line  24)
+* magit-subtree-merge:                   Subtree.             (line  28)
+* magit-subtree-pull:                    Subtree.             (line  32)
+* magit-subtree-push:                    Subtree.             (line  36)
+* magit-subtree-split:                   Subtree.             (line  41)
+* magit-tag:                             Tagging.             (line  13)
+* magit-tag-delete:                      Tagging.             (line  18)
+* magit-tag-popup:                       Tagging.             (line   8)
+* magit-tag-prune:                       Tagging.             (line  24)
+* magit-tag-release:                     Tagging.             (line  28)
+* magit-toggle-buffer-lock:              Modes and Buffers.   (line  17)
+* magit-toggle-margin:                   Refreshing Logs.     (line  36)
+* magit-toggle-margin <1>:               Log Margin.          (line  56)
+* magit-toggle-margin-details:           Log Margin.          (line  64)
+* magit-tree-popup:                      Subtree.             (line   8)
+* magit-unstage:                         Staging and Unstaging.
+                                                              (line  43)
+* magit-unstage-all:                     Staging and Unstaging.
+                                                              (line  52)
+* magit-unstage-file:                    Staging from File-Visiting Buffers.
+                                                              (line  18)
+* magit-unstage-file <1>:                Minor Mode for Buffers Visiting Files.
+                                                              (line  28)
+* magit-version:                         Git Executable.      (line  17)
+* magit-version <1>:                     Debugging Tools.     (line  10)
+* magit-visit-ref:                       References Buffer.   (line 166)
+* magit-wip-commit:                      Wip Modes.           (line 174)
+* magit-wip-log:                         Wip Modes.           (line  85)
+* magit-wip-log-current:                 Wip Modes.           (line  93)
+* magit-worktree-branch:                 Worktree.            (line  17)
+* magit-worktree-checkout:               Worktree.            (line  13)
+* magit-worktree-checkout-pull-request:  Worktree.            (line  21)
+* magit-worktree-delete:                 Worktree.            (line  28)
+* magit-worktree-popup:                  Worktree.            (line   8)
+* magit-worktree-status:                 Worktree.            (line  33)
+* scroll-down:                           Diff Buffer.         (line 103)
+* scroll-up:                             Diff Buffer.         (line  99)
+* with-editor-cancel:                    Editing Commit Messages.
+                                                              (line  24)
+* with-editor-cancel <1>:                Editing Rebase Sequences.
+                                                              (line  11)
+* with-editor-debug:                     Debugging Tools.     (line  38)
+* with-editor-finish:                    Editing Commit Messages.
+                                                              (line  19)
+* with-editor-finish <1>:                Editing Rebase Sequences.
+                                                              (line   6)
+
+
+File: magit.info,  Node: Function Index,  Next: Variable Index,  Prev: Command Index,  Up: Top
+
+Appendix E Function Index
+*************************
+
+
+* Menu:
+
+* auto-revert-mode:                      Automatic Reverting of File-Visiting Buffers.
+                                                              (line  62)
+* git-commit-check-style-conventions:    Editing Commit Messages.
+                                                              (line 247)
+* git-commit-propertize-diff:            Editing Commit Messages.
+                                                              (line 206)
+* git-commit-save-message:               Editing Commit Messages.
+                                                              (line 187)
+* git-commit-setup-changelog-support:    Editing Commit Messages.
+                                                              (line 191)
+* git-commit-turn-on-auto-fill:          Editing Commit Messages.
+                                                              (line 196)
+* git-commit-turn-on-flyspell:           Editing Commit Messages.
+                                                              (line 201)
+* ido-enter-magit-status:                Status Buffer.       (line  47)
+* magit-add-section-hook:                Section Hooks.       (line  20)
+* magit-after-save-refresh-status:       Automatic Refreshing of Magit Buffers.
+                                                              (line  56)
+* magit-blame:                           Blaming.             (line  17)
+* magit-blame-echo:                      Blaming.             (line  32)
+* magit-blame-removal:                   Blaming.             (line  38)
+* magit-blame-reverse:                   Blaming.             (line  46)
+* magit-branch-config-popup:             The Branch Config Popup.
+                                                              (line   6)
+* magit-branch-or-checkout:              The Branch Popup.    (line 350)
+* magit-branch-orphan:                   The Branch Popup.    (line 345)
+* magit-branch-shelve:                   Auxillary Branch Commands.
+                                                              (line   8)
+* magit-branch-unshelve:                 Auxillary Branch Commands.
+                                                              (line  19)
+* magit-builtin-completing-read:         Support for Completion Frameworks.
+                                                              (line  42)
+* magit-call-git:                        Calling Git for Effect.
+                                                              (line  28)
+* magit-call-process:                    Calling Git for Effect.
+                                                              (line  32)
+* magit-cancel-section:                  Creating Sections.   (line  71)
+* magit-completing-read:                 Support for Completion Frameworks.
+                                                              (line  60)
+* magit-current-section:                 Section Selection.   (line   6)
+* magit-define-section-jumper:           Creating Sections.   (line  77)
+* magit-diff-scope:                      Matching Sections.   (line 111)
+* magit-diff-type:                       Matching Sections.   (line  88)
+* magit-diff-visit-file-other-window:    Diff Buffer.         (line  65)
+* magit-display-buffer:                  Switching Buffers.   (line   6)
+* magit-display-buffer-fullcolumn-most-v1: Switching Buffers. (line  72)
+* magit-display-buffer-fullframe-status-topleft-v1: Switching Buffers.
+                                                              (line  62)
+* magit-display-buffer-fullframe-status-v1: Switching Buffers.
+                                                              (line  56)
+* magit-display-buffer-same-window-except-diff-v1: Switching Buffers.
+                                                              (line  50)
+* magit-display-buffer-traditional:      Switching Buffers.   (line  42)
+* magit-file-checkout:                   Minor Mode for Buffers Visiting Files.
+                                                              (line 131)
+* magit-file-delete:                     Minor Mode for Buffers Visiting Files.
+                                                              (line 123)
+* magit-file-rename:                     Minor Mode for Buffers Visiting Files.
+                                                              (line 119)
+* magit-file-untrack:                    Minor Mode for Buffers Visiting Files.
+                                                              (line 127)
+* magit-generate-buffer-name-default-function: Naming Buffers.
+                                                              (line  17)
+* magit-get-section:                     Matching Sections.   (line  16)
+* magit-git:                             Calling Git for Effect.
+                                                              (line  65)
+* magit-git-exit-code:                   Getting a Value from Git.
+                                                              (line  10)
+* magit-git-failure:                     Getting a Value from Git.
+                                                              (line  19)
+* magit-git-false:                       Getting a Value from Git.
+                                                              (line  29)
+* magit-git-insert:                      Getting a Value from Git.
+                                                              (line  34)
+* magit-git-items:                       Getting a Value from Git.
+                                                              (line  49)
+* magit-git-lines:                       Getting a Value from Git.
+                                                              (line  44)
+* magit-git-str:                         Getting a Value from Git.
+                                                              (line  72)
+* magit-git-string:                      Getting a Value from Git.
+                                                              (line  38)
+* magit-git-success:                     Getting a Value from Git.
+                                                              (line  14)
+* magit-git-true:                        Getting a Value from Git.
+                                                              (line  24)
+* magit-git-wash:                        Calling Git for Effect.
+                                                              (line  70)
+* magit-hunk-set-window-start:           Section Movement.    (line  43)
+* magit-ido-completing-read:             Support for Completion Frameworks.
+                                                              (line  48)
+* magit-insert-am-sequence:              Status Sections.     (line  28)
+* magit-insert-bisect-log:               Status Sections.     (line  46)
+* magit-insert-bisect-output:            Status Sections.     (line  38)
+* magit-insert-bisect-rest:              Status Sections.     (line  42)
+* magit-insert-diff-filter-header:       Status Header Sections.
+                                                              (line  38)
+* magit-insert-error-header:             Status Header Sections.
+                                                              (line  28)
+* magit-insert-head-branch-header:       Status Header Sections.
+                                                              (line  42)
+* magit-insert-heading:                  Creating Sections.   (line  42)
+* magit-insert-ignored-files:            Status Sections.     (line 100)
+* magit-insert-local-branches:           References Sections. (line  17)
+* magit-insert-merge-log:                Status Sections.     (line  18)
+* magit-insert-modules:                  Status Module Sections.
+                                                              (line  12)
+* magit-insert-modules-overview:         Status Module Sections.
+                                                              (line  33)
+* magit-insert-modules-unpulled-from-pushremote: Status Module Sections.
+                                                              (line  50)
+* magit-insert-modules-unpulled-from-upstream: Status Module Sections.
+                                                              (line  44)
+* magit-insert-modules-unpushed-to-pushremote: Status Module Sections.
+                                                              (line  62)
+* magit-insert-modules-unpushed-to-upstream: Status Module Sections.
+                                                              (line  56)
+* magit-insert-push-branch-header:       Status Header Sections.
+                                                              (line  51)
+* magit-insert-rebase-sequence:          Status Sections.     (line  23)
+* magit-insert-recent-commits:           Status Sections.     (line 115)
+* magit-insert-remote-branches:          References Sections. (line  21)
+* magit-insert-remote-header:            Status Header Sections.
+                                                              (line  67)
+* magit-insert-repo-header:              Status Header Sections.
+                                                              (line  63)
+* magit-insert-section:                  Creating Sections.   (line   6)
+* magit-insert-sequencer-sequence:       Status Sections.     (line  33)
+* magit-insert-staged-changes:           Status Sections.     (line  63)
+* magit-insert-stashes:                  Status Sections.     (line  67)
+* magit-insert-status-headers:           Status Header Sections.
+                                                              (line  12)
+* magit-insert-submodules:               Listing Submodules.  (line  35)
+* magit-insert-tags:                     References Sections. (line  25)
+* magit-insert-tags-header:              Status Header Sections.
+                                                              (line  56)
+* magit-insert-tracked-files:            Status Sections.     (line  96)
+* magit-insert-unpulled-cherries:        Status Sections.     (line 126)
+* magit-insert-unpulled-from-pushremote: Status Sections.     (line  79)
+* magit-insert-unpulled-from-upstream:   Status Sections.     (line  74)
+* magit-insert-unpulled-or-recent-commits: Status Sections.   (line 108)
+* magit-insert-unpushed-cherries:        Status Sections.     (line 133)
+* magit-insert-unpushed-to-pushremote:   Status Sections.     (line  89)
+* magit-insert-unpushed-to-upstream:     Status Sections.     (line  84)
+* magit-insert-unstaged-changes:         Status Sections.     (line  59)
+* magit-insert-untracked-files:          Status Sections.     (line  50)
+* magit-insert-upstream-branch-header:   Status Header Sections.
+                                                              (line  46)
+* magit-insert-user-header:              Status Header Sections.
+                                                              (line  75)
+* magit-list-repositories:               Repository List.     (line   6)
+* magit-list-submodules:                 Listing Submodules.  (line  13)
+* magit-log-maybe-show-more-commits:     Section Movement.    (line  57)
+* magit-log-maybe-update-blob-buffer:    Section Movement.    (line  71)
+* magit-log-maybe-update-revision-buffer: Section Movement.   (line  64)
+* magit-maybe-set-dedicated:             Switching Buffers.   (line  97)
+* magit-mode-display-buffer:             Refreshing Buffers.  (line  33)
+* magit-mode-quit-window:                Quitting Windows.    (line  31)
+* magit-mode-setup:                      Refreshing Buffers.  (line  17)
+* magit-push-implicitly:                 Pushing.             (line  73)
+* magit-push-to-remote:                  Pushing.             (line  84)
+* magit-region-sections:                 Section Selection.   (line  10)
+* magit-region-values:                   Section Selection.   (line  29)
+* magit-remote-config-popup:             The Remote Config Popup.
+                                                              (line   6)
+* magit-repolist-column-ident:           Repository List.     (line  30)
+* magit-repolist-column-path:            Repository List.     (line  35)
+* magit-repolist-column-unpulled-from-pushremote: Repository List.
+                                                              (line  49)
+* magit-repolist-column-unpulled-from-upstream: Repository List.
+                                                              (line  44)
+* magit-repolist-column-unpushed-to-pushremote: Repository List.
+                                                              (line  59)
+* magit-repolist-column-unpushed-to-upstream: Repository List.
+                                                              (line  54)
+* magit-repolist-column-version:         Repository List.     (line  39)
+* magit-restore-window-configuration:    Quitting Windows.    (line  20)
+* magit-revert-buffers:                  Editing Commit Messages.
+                                                              (line 178)
+* magit-run-git:                         Calling Git for Effect.
+                                                              (line  36)
+* magit-run-git-async:                   Calling Git for Effect.
+                                                              (line  80)
+* magit-run-git-with-editor:             Calling Git for Effect.
+                                                              (line  93)
+* magit-run-git-with-input:              Calling Git for Effect.
+                                                              (line  40)
+* magit-run-git-with-logfile:            Calling Git for Effect.
+                                                              (line  56)
+* magit-save-window-configuration:       Switching Buffers.   (line  86)
+* magit-section-case:                    Matching Sections.   (line  64)
+* magit-section-hide:                    Section Visibility.  (line  49)
+* magit-section-hide-children:           Section Visibility.  (line  64)
+* magit-section-ident:                   Matching Sections.   (line  11)
+* magit-section-match:                   Matching Sections.   (line  21)
+* magit-section-set-window-start:        Section Movement.    (line  50)
+* magit-section-show:                    Section Visibility.  (line  45)
+* magit-section-show-children:           Section Visibility.  (line  58)
+* magit-section-show-headings:           Section Visibility.  (line  53)
+* magit-section-toggle-children:         Section Visibility.  (line  68)
+* magit-section-when:                    Matching Sections.   (line  52)
+* magit-start-git:                       Calling Git for Effect.
+                                                              (line 105)
+* magit-start-process:                   Calling Git for Effect.
+                                                              (line 124)
+* magit-status-maybe-update-blob-buffer: Section Movement.    (line  83)
+* magit-status-maybe-update-revision-buffer: Section Movement.
+                                                              (line  77)
+* magit-tag-release:                     Tagging.             (line  28)
+* magit-wip-commit-initial-backup:       Wip Modes.           (line 145)
+* magit-wip-log:                         Wip Modes.           (line  85)
+* magit-wip-log-current:                 Wip Modes.           (line  93)
+* with-editor-usage-message:             Editing Commit Messages.
+                                                              (line 215)
+
+
+File: magit.info,  Node: Variable Index,  Prev: Function Index,  Up: Top
+
+Appendix F Variable Index
+*************************
+
+
+* Menu:
+
+* auto-revert-buffer-list-filter:        Automatic Reverting of File-Visiting Buffers.
+                                                              (line  81)
+* auto-revert-interval:                  Automatic Reverting of File-Visiting Buffers.
+                                                              (line  76)
+* auto-revert-stop-on-user-input:        Automatic Reverting of File-Visiting Buffers.
+                                                              (line  71)
+* auto-revert-use-notify:                Automatic Reverting of File-Visiting Buffers.
+                                                              (line  49)
+* auto-revert-verbose:                   Automatic Reverting of File-Visiting Buffers.
+                                                              (line 103)
+* branch.autoSetupMerge:                 The Branch Config Popup.
+                                                              (line  94)
+* branch.autoSetupRebase:                The Branch Config Popup.
+                                                              (line 111)
+* branch.NAME.description:               The Branch Config Popup.
+                                                              (line  61)
+* branch.NAME.merge:                     The Branch Config Popup.
+                                                              (line  23)
+* branch.NAME.pushRemote:                The Branch Config Popup.
+                                                              (line  47)
+* branch.NAME.rebase:                    The Branch Config Popup.
+                                                              (line  35)
+* branch.NAME.remote:                    The Branch Config Popup.
+                                                              (line  29)
+* core.notesRef:                         Notes.               (line  59)
+* git-commit-fill-column:                Editing Commit Messages.
+                                                              (line 228)
+* git-commit-finish-query-functions:     Editing Commit Messages.
+                                                              (line 233)
+* git-commit-known-pseudo-headers:       Editing Commit Messages.
+                                                              (line 124)
+* git-commit-major-mode:                 Editing Commit Messages.
+                                                              (line 163)
+* git-commit-setup-hook:                 Editing Commit Messages.
+                                                              (line 174)
+* git-commit-summary-max-length:         Editing Commit Messages.
+                                                              (line 222)
+* git-rebase-auto-advance:               Editing Rebase Sequences.
+                                                              (line  94)
+* git-rebase-confirm-cancel:             Editing Rebase Sequences.
+                                                              (line 102)
+* git-rebase-show-instructions:          Editing Rebase Sequences.
+                                                              (line  98)
+* global-auto-revert-mode:               Automatic Reverting of File-Visiting Buffers.
+                                                              (line  22)
+* magit-auto-revert-immediately:         Automatic Reverting of File-Visiting Buffers.
+                                                              (line  32)
+* magit-auto-revert-mode:                Automatic Reverting of File-Visiting Buffers.
+                                                              (line  17)
+* magit-auto-revert-tracked-only:        Automatic Reverting of File-Visiting Buffers.
+                                                              (line  55)
+* magit-bisect-show-graph:               Bisecting.           (line  55)
+* magit-blame-disable-modes:             Blaming.             (line 150)
+* magit-blame-echo-style:                Blaming.             (line 133)
+* magit-blame-goto-chunk-hook:           Blaming.             (line 156)
+* magit-blame-read-only:                 Blaming.             (line 145)
+* magit-blame-styles:                    Blaming.             (line 128)
+* magit-blame-time-format:               Blaming.             (line 140)
+* magit-branch-adjust-remote-upstream-alist: The Branch Popup.
+                                                              (line 303)
+* magit-branch-popup-show-variables:     The Branch Popup.    (line  21)
+* magit-branch-prefer-remote-upstream:   The Branch Popup.    (line 258)
+* magit-branch-read-upstream-first:      The Branch Popup.    (line 252)
+* magit-buffer-name-format:              Naming Buffers.      (line  27)
+* magit-bury-buffer-function:            Quitting Windows.    (line  11)
+* magit-cherry-margin:                   Cherries.            (line  22)
+* magit-clone-set-remote.pushDefault:    Repository Setup.    (line  23)
+* magit-commit-ask-to-stage:             Initiating a Commit. (line  74)
+* magit-commit-extend-override-date:     Initiating a Commit. (line  79)
+* magit-commit-reword-override-date:     Initiating a Commit. (line  83)
+* magit-commit-squash-confirm:           Initiating a Commit. (line  87)
+* magit-completing-read-function:        Support for Completion Frameworks.
+                                                              (line  27)
+* magit-diff-adjust-tab-width:           Diff Options.        (line  16)
+* magit-diff-buffer-file-locked:         Minor Mode for Buffers Visiting Files.
+                                                              (line  52)
+* magit-diff-hide-trailing-cr-characters: Diff Options.       (line  67)
+* magit-diff-highlight-hunk-region-functions: Diff Options.   (line  71)
+* magit-diff-highlight-indentation:      Diff Options.        (line  52)
+* magit-diff-highlight-trailing:         Diff Options.        (line  47)
+* magit-diff-paint-whitespace:           Diff Options.        (line  38)
+* magit-diff-refine-hunk:                Diff Options.        (line   6)
+* magit-diff-unmarked-lines-keep-foreground: Diff Options.    (line  97)
+* magit-diff-visit-previous-blob:        Diff Buffer.         (line  37)
+* magit-display-buffer-function:         Switching Buffers.   (line  23)
+* magit-display-buffer-noselect:         Switching Buffers.   (line  14)
+* magit-dwim-selection:                  Completion and Confirmation.
+                                                              (line  42)
+* magit-ediff-dwim-show-on-hunks:        Ediffing.            (line  73)
+* magit-ediff-quit-hook:                 Ediffing.            (line  88)
+* magit-ediff-show-stash-with-index:     Ediffing.            (line  81)
+* magit-file-mode:                       Minor Mode for Buffers Visiting Files.
+                                                              (line  11)
+* magit-generate-buffer-name-function:   Naming Buffers.      (line   6)
+* magit-git-debug:                       Viewing Git Output.  (line  28)
+* magit-git-debug <1>:                   Getting a Value from Git.
+                                                              (line  64)
+* magit-git-executable:                  Git Executable.      (line  39)
+* magit-git-global-arguments:            Global Git Arguments.
+                                                              (line   6)
+* magit-keep-region-overlay:             The Selection.       (line  52)
+* magit-list-refs-sortby:                Additional Completion Options.
+                                                              (line   6)
+* magit-log-auto-more:                   Log Buffer.          (line  67)
+* magit-log-buffer-file-locked:          Minor Mode for Buffers Visiting Files.
+                                                              (line  75)
+* magit-log-margin:                      Log Margin.          (line  12)
+* magit-log-section-args:                Status Options.      (line  36)
+* magit-log-section-commit-count:        Status Sections.     (line 120)
+* magit-log-select-margin:               Select from Log.     (line  30)
+* magit-log-show-refname-after-summary:  Log Buffer.          (line  73)
+* magit-module-sections-hook:            Status Module Sections.
+                                                              (line  20)
+* magit-module-sections-nested:          Status Module Sections.
+                                                              (line  24)
+* magit-no-confirm:                      Action Confirmation. (line  18)
+* magit-pop-revision-stack-format:       Editing Commit Messages.
+                                                              (line  92)
+* magit-post-display-buffer-hook:        Switching Buffers.   (line  92)
+* magit-pre-display-buffer-hook:         Switching Buffers.   (line  81)
+* magit-prefer-remote-upstream:          The Branch Config Popup.
+                                                              (line 139)
+* magit-process-raise-error:             Calling Git for Effect.
+                                                              (line 151)
+* magit-push-current-set-remote-if-missing: Pushing.          (line  96)
+* magit-reflog-margin:                   Reflog.              (line  23)
+* magit-refresh-args:                    Refreshing Buffers.  (line  55)
+* magit-refresh-buffer-hook:             Automatic Refreshing of Magit Buffers.
+                                                              (line  40)
+* magit-refresh-function:                Refreshing Buffers.  (line  49)
+* magit-refresh-status-buffer:           Automatic Refreshing of Magit Buffers.
+                                                              (line  46)
+* magit-refs-filter-alist:               References Buffer.   (line 149)
+* magit-refs-focus-column-width:         References Buffer.   (line  74)
+* magit-refs-margin:                     References Buffer.   (line  89)
+* magit-refs-margin-for-tags:            References Buffer.   (line 115)
+* magit-refs-pad-commit-counts:          References Buffer.   (line  41)
+* magit-refs-primary-column-width:       References Buffer.   (line  61)
+* magit-refs-sections-hook:              References Sections. (line  13)
+* magit-refs-show-commit-count:          References Buffer.   (line  29)
+* magit-refs-show-remote-prefix:         References Buffer.   (line  54)
+* magit-remote-add-set-remote.pushDefault: The Remote Popup.  (line  77)
+* magit-remote-popup-show-variables:     The Remote Popup.    (line  18)
+* magit-repolist-columns:                Repository List.     (line  14)
+* magit-repository-directories:          Status Buffer.       (line  30)
+* magit-repository-directories-depth:    Status Buffer.       (line  40)
+* magit-revision-insert-related-refs:    Revision Buffer.     (line   6)
+* magit-revision-show-gravatar:          Revision Buffer.     (line  10)
+* magit-revision-use-hash-sections:      Revision Buffer.     (line  26)
+* magit-root-section:                    Matching Sections.   (line  80)
+* magit-save-repository-buffers:         Automatic Saving of File-Visiting Buffers.
+                                                              (line  13)
+* magit-section-cache-visibility:        Section Visibility.  (line  95)
+* magit-section-initial-visibility-alist: Section Visibility. (line  78)
+* magit-section-movement-hook:           Section Movement.    (line  38)
+* magit-section-set-visibility-hook:     Section Visibility.  (line 106)
+* magit-section-show-child-count:        Section Options.     (line   9)
+* magit-shell-command-verbose-prompt:    Running Git Manually.
+                                                              (line  46)
+* magit-stashes-margin:                  Stashing.            (line 103)
+* magit-status-headers-hook:             Status Header Sections.
+                                                              (line  18)
+* magit-status-margin:                   Status Options.      (line  10)
+* magit-status-refresh-hook:             Status Options.      (line   6)
+* magit-status-sections-hook:            Status Sections.     (line  10)
+* magit-submodule-list-columns:          Listing Submodules.  (line  21)
+* magit-this-process:                    Calling Git for Effect.
+                                                              (line 146)
+* magit-uniquify-buffer-names:           Naming Buffers.      (line  74)
+* magit-unstage-committed:               Staging and Unstaging.
+                                                              (line  56)
+* magit-update-other-window-delay:       Section Movement.    (line  89)
+* magit-use-sticky-arguments:            Popup Buffers and Prefix Commands.
+                                                              (line  36)
+* magit-visit-ref-behavior:              References Buffer.   (line 177)
+* magit-wip-after-apply-mode:            Wip Modes.           (line 126)
+* magit-wip-after-apply-mode-lighter:    Wip Modes.           (line 186)
+* magit-wip-after-save-local-mode-lighter: Wip Modes.         (line 182)
+* magit-wip-after-save-mode:             Wip Modes.           (line 120)
+* magit-wip-before-change-mode:          Wip Modes.           (line 140)
+* magit-wip-before-change-mode-lighter:  Wip Modes.           (line 190)
+* magit-wip-merge-branch:                Wip Modes.           (line  63)
+* magit-wip-namespace:                   Wip Modes.           (line 194)
+* notes.displayRef:                      Notes.               (line  64)
+* pull.rebase:                           The Branch Config Popup.
+                                                              (line  70)
+* remote.NAME.fetch:                     The Remote Config Popup.
+                                                              (line  25)
+* remote.NAME.push:                      The Remote Config Popup.
+                                                              (line  36)
+* remote.NAME.pushurl:                   The Remote Config Popup.
+                                                              (line  30)
+* remote.NAME.tagOpts:                   The Remote Config Popup.
+                                                              (line  41)
+* remote.NAME.url:                       The Remote Config Popup.
+                                                              (line  20)
+* remote.pushDefault:                    The Branch Config Popup.
+                                                              (line  84)
+