.emacs.d.git - Gitblit

Chizi123

2018-11-18 c655eea759be1db69c5e6b45c228139d8390122a

commit \| author \| age
5cb5f7	1	;;; magit-autoloads.el --- automatically extracted autoloads
C	2	;;
	3	;;; Code:
	4
	5	(add-to-list 'load-path (directory-file-name
	6	(or (file-name-directory #$) (car load-path))))
	7
	8
	9	;;;### (autoloads nil "git-rebase" "git-rebase.el" (0 0 0 0))
	10	;;; Generated autoloads from git-rebase.el
	11
	12	(autoload 'git-rebase-mode "git-rebase" "\
	13	Major mode for editing of a Git rebase file.
	14
	15	Rebase files are generated when you run 'git rebase -i' or run
	16	`magit-interactive-rebase'. They describe how Git should perform
	17	the rebase. See the documentation for git-rebase (e.g., by
	18	running 'man git-rebase' at the command line) for details.
	19
	20	\(fn)" t nil)
	21
	22	(defconst git-rebase-filename-regexp "/git-rebase-todo\\'")
	23
	24	(add-to-list 'auto-mode-alist (cons git-rebase-filename-regexp 'git-rebase-mode))
	25
	26	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "git-rebase" '("git-rebase-")))
	27
	28	;;;***
	29
	30	;;;### (autoloads nil "magit" "magit.el" (0 0 0 0))
	31	;;; Generated autoloads from magit.el
	32	(autoload 'magit-dispatch-popup "magit" nil t)
	33	(autoload 'magit-run-popup "magit" nil t)
	34
	35	(autoload 'magit-git-command "magit" "\
	36	Execute COMMAND asynchronously; display output.
	37
	38	Interactively, prompt for COMMAND in the minibuffer. \"git \" is
	39	used as initial input, but can be deleted to run another command.
	40
	41	With a prefix argument COMMAND is run in the top-level directory
	42	of the current working tree, otherwise in `default-directory'.
	43
	44	\(fn COMMAND)" t nil)
	45
	46	(autoload 'magit-git-command-topdir "magit" "\
	47	Execute COMMAND asynchronously; display output.
	48
	49	Interactively, prompt for COMMAND in the minibuffer. \"git \" is
	50	used as initial input, but can be deleted to run another command.
	51
	52	COMMAND is run in the top-level directory of the current
	53	working tree.
	54
	55	\(fn COMMAND)" t nil)
	56
	57	(autoload 'magit-shell-command "magit" "\
	58	Execute COMMAND asynchronously; display output.
	59
	60	Interactively, prompt for COMMAND in the minibuffer. With a
	61	prefix argument COMMAND is run in the top-level directory of
	62	the current working tree, otherwise in `default-directory'.
	63
	64	\(fn COMMAND)" t nil)
	65
	66	(autoload 'magit-shell-command-topdir "magit" "\
	67	Execute COMMAND asynchronously; display output.
	68
	69	Interactively, prompt for COMMAND in the minibuffer. COMMAND
	70	is run in the top-level directory of the current working tree.
	71
	72	\(fn COMMAND)" t nil)
	73
	74	(autoload 'magit-version "magit" "\
	75	Return the version of Magit currently in use.
	76	If optional argument PRINT-DEST is non-nil, output
	77	stream (interactively, the echo area, or the current buffer with
	78	a prefix argument), also print the used versions of Magit, Git,
	79	and Emacs to it.
	80
	81	\(fn &optional PRINT-DEST)" t nil)
	82
	83	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit" '("magit-")))
	84
	85	;;;***
	86
	87	;;;### (autoloads nil "magit-apply" "magit-apply.el" (0 0 0 0))
	88	;;; Generated autoloads from magit-apply.el
	89
	90	(autoload 'magit-stage-file "magit-apply" "\
	91	Stage all changes to FILE.
	92	With a prefix argument or when there is no file at point ask for
	93	the file to be staged. Otherwise stage the file at point without
	94	requiring confirmation.
	95
	96	\(fn FILE)" t nil)
	97
	98	(autoload 'magit-stage-modified "magit-apply" "\
	99	Stage all changes to files modified in the worktree.
	100	Stage all new content of tracked files and remove tracked files
	101	that no longer exist in the working tree from the index also.
	102	With a prefix argument also stage previously untracked (but not
	103	ignored) files.
	104
	105	\(fn &optional ALL)" t nil)
	106
	107	(autoload 'magit-unstage-file "magit-apply" "\
	108	Unstage all changes to FILE.
	109	With a prefix argument or when there is no file at point ask for
	110	the file to be unstaged. Otherwise unstage the file at point
	111	without requiring confirmation.
	112
	113	\(fn FILE)" t nil)
	114
	115	(autoload 'magit-unstage-all "magit-apply" "\
	116	Remove all changes from the staging area.
	117
	118	\(fn)" t nil)
	119
	120	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-apply" '("magit-")))
	121
	122	;;;***
	123
	124	;;;### (autoloads nil "magit-autorevert" "magit-autorevert.el" (0
	125	;;;;;; 0 0 0))
	126	;;; Generated autoloads from magit-autorevert.el
	127
	128	(defvar magit-auto-revert-mode (and (not global-auto-revert-mode) (not noninteractive)) "\
	129	Non-nil if Magit-Auto-Revert mode is enabled.
	130	See the `magit-auto-revert-mode' command
	131	for a description of this minor mode.
	132	Setting this variable directly does not take effect;
	133	either customize it (see the info node `Easy Customization')
	134	or call the function `magit-auto-revert-mode'.")
	135
	136	(custom-autoload 'magit-auto-revert-mode "magit-autorevert" nil)
	137
	138	(autoload 'magit-auto-revert-mode "magit-autorevert" "\
	139	Toggle Auto-Revert mode in all buffers.
	140	With prefix ARG, enable Magit-Auto-Revert mode if ARG is positive;
	141	otherwise, disable it. If called from Lisp, enable the mode if
	142	ARG is omitted or nil.
	143
	144	Auto-Revert mode is enabled in all buffers where
	145	`magit-turn-on-auto-revert-mode-if-desired' would do it.
	146	See `auto-revert-mode' for more information on Auto-Revert mode.
	147
	148	\(fn &optional ARG)" t nil)
	149
	150	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-autorevert" '("auto-revert-buffer" "magit-")))
	151
	152	;;;***
	153
	154	;;;### (autoloads nil "magit-bisect" "magit-bisect.el" (0 0 0 0))
	155	;;; Generated autoloads from magit-bisect.el
	156	(autoload 'magit-bisect-popup "magit-bisect" nil t)
	157
	158	(autoload 'magit-bisect-start "magit-bisect" "\
	159	Start a bisect session.
	160
	161	Bisecting a bug means to find the commit that introduced it.
	162	This command starts such a bisect session by asking for a know
	163	good and a bad commit. To move the session forward use the
	164	other actions from the bisect popup (\\<magit-status-mode-map>\\[magit-bisect-popup]).
	165
	166	\(fn BAD GOOD)" t nil)
	167
	168	(autoload 'magit-bisect-reset "magit-bisect" "\
	169	After bisecting, cleanup bisection state and return to original `HEAD'.
	170
	171	\(fn)" t nil)
	172
	173	(autoload 'magit-bisect-good "magit-bisect" "\
	174	While bisecting, mark the current commit as good.
	175	Use this after you have asserted that the commit does not contain
	176	the bug in question.
	177
	178	\(fn)" t nil)
	179
	180	(autoload 'magit-bisect-bad "magit-bisect" "\
	181	While bisecting, mark the current commit as bad.
	182	Use this after you have asserted that the commit does contain the
	183	bug in question.
	184
	185	\(fn)" t nil)
	186
	187	(autoload 'magit-bisect-skip "magit-bisect" "\
	188	While bisecting, skip the current commit.
	189	Use this if for some reason the current commit is not a good one
	190	to test. This command lets Git choose a different one.
	191
	192	\(fn)" t nil)
	193
	194	(autoload 'magit-bisect-run "magit-bisect" "\
	195	Bisect automatically by running commands after each step.
	196
	197	Unlike `git bisect run' this can be used before bisecting has
	198	begun. In that case it behaves like `git bisect start; git
	199	bisect run'.
	200
	201	\(fn CMDLINE &optional BAD GOOD)" t nil)
	202
	203	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-bisect" '("magit-")))
	204
	205	;;;***
	206
	207	;;;### (autoloads nil "magit-blame" "magit-blame.el" (0 0 0 0))
	208	;;; Generated autoloads from magit-blame.el
	209
	210	(autoload 'magit-blame-echo "magit-blame" "\
	211	For each line show the revision in which it was added.
	212	Show the information about the chunk at point in the echo area
	213	when moving between chunks. Unlike other blaming commands, do
	214	not turn on `read-only-mode'.
	215
	216	\(fn)" t nil)
	217
	218	(autoload 'magit-blame-addition "magit-blame" "\
	219	For each line show the revision in which it was added.
	220
	221	\(fn)" t nil)
	222
	223	(autoload 'magit-blame-removal "magit-blame" "\
	224	For each line show the revision in which it was removed.
	225
	226	\(fn)" t nil)
	227
	228	(autoload 'magit-blame-reverse "magit-blame" "\
	229	For each line show the last revision in which it still exists.
	230
	231	\(fn)" t nil)
	232	(autoload 'magit-blame-popup "magit-blame" nil t)
	233
	234	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-blame" '("magit-")))
	235
	236	;;;***
	237
	238	;;;### (autoloads nil "magit-bookmark" "magit-bookmark.el" (0 0 0
	239	;;;;;; 0))
	240	;;; Generated autoloads from magit-bookmark.el
	241
	242	(autoload 'magit-bookmark--status-jump "magit-bookmark" "\
	243	Handle a Magit status BOOKMARK.
	244
	245	\(fn BOOKMARK)" nil nil)
	246
	247	(autoload 'magit-bookmark--status-make-record "magit-bookmark" "\
	248	Create a Magit status bookmark.
	249
	250	\(fn)" nil nil)
	251
	252	(autoload 'magit-bookmark--refs-jump "magit-bookmark" "\
	253	Handle a Magit refs BOOKMARK.
	254
	255	\(fn BOOKMARK)" nil nil)
	256
	257	(autoload 'magit-bookmark--refs-make-record "magit-bookmark" "\
	258	Create a Magit refs bookmark.
	259
	260	\(fn)" nil nil)
	261
	262	(autoload 'magit-bookmark--log-jump "magit-bookmark" "\
	263	Handle a Magit log BOOKMARK.
	264
	265	\(fn BOOKMARK)" nil nil)
	266
	267	(autoload 'magit-bookmark--log-make-record "magit-bookmark" "\
	268	Create a Magit log bookmark.
	269
	270	\(fn)" nil nil)
	271
	272	(autoload 'magit-bookmark--reflog-jump "magit-bookmark" "\
	273	Handle a Magit reflog BOOKMARK.
	274
	275	\(fn BOOKMARK)" nil nil)
	276
	277	(autoload 'magit-bookmark--reflog-make-record "magit-bookmark" "\
	278	Create a Magit reflog bookmark.
	279
	280	\(fn)" nil nil)
	281
	282	(autoload 'magit-bookmark--stashes-jump "magit-bookmark" "\
	283	Handle a Magit stash list BOOKMARK.
	284
	285	\(fn BOOKMARK)" nil nil)
	286
	287	(autoload 'magit-bookmark--stashes-make-record "magit-bookmark" "\
	288	Create a Magit stash list bookmark.
	289
	290	\(fn)" nil nil)
	291
	292	(autoload 'magit-bookmark--cherry-jump "magit-bookmark" "\
	293	Handle a Magit cherry BOOKMARK.
	294
	295	\(fn BOOKMARK)" nil nil)
	296
	297	(autoload 'magit-bookmark--cherry-make-record "magit-bookmark" "\
	298	Create a Magit cherry bookmark.
	299
	300	\(fn)" nil nil)
	301
	302	(autoload 'magit-bookmark--diff-jump "magit-bookmark" "\
	303	Handle a Magit diff BOOKMARK.
	304
	305	\(fn BOOKMARK)" nil nil)
	306
	307	(autoload 'magit-bookmark--diff-make-record "magit-bookmark" "\
	308	Create a Magit diff bookmark.
	309
	310	\(fn)" nil nil)
	311
	312	(autoload 'magit-bookmark--revision-jump "magit-bookmark" "\
	313	Handle a Magit revision BOOKMARK.
	314
	315	\(fn BOOKMARK)" nil nil)
	316
	317	(autoload 'magit-bookmark--revision-make-record "magit-bookmark" "\
	318	Create a Magit revision bookmark.
	319
	320	\(fn)" nil nil)
	321
	322	(autoload 'magit-bookmark--stash-jump "magit-bookmark" "\
	323	Handle a Magit stash BOOKMARK.
	324
	325	\(fn BOOKMARK)" nil nil)
	326
	327	(autoload 'magit-bookmark--stash-make-record "magit-bookmark" "\
	328	Create a Magit stash bookmark.
	329
	330	\(fn)" nil nil)
	331
	332	(autoload 'magit-bookmark--submodules-jump "magit-bookmark" "\
	333	Handle a Magit submodule list BOOKMARK.
	334
	335	\(fn BOOKMARK)" nil nil)
	336
	337	(autoload 'magit-bookmark--submodules-make-record "magit-bookmark" "\
	338	Create a Magit submodule list bookmark.
	339
	340	\(fn)" nil nil)
	341
	342	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-bookmark" '("magit-bookmark--")))
	343
	344	;;;***
	345
	346	;;;### (autoloads nil "magit-branch" "magit-branch.el" (0 0 0 0))
	347	;;; Generated autoloads from magit-branch.el
	348	(autoload 'magit-branch-popup "magit" nil t)
	349
	350	(autoload 'magit-checkout "magit-branch" "\
	351	Checkout REVISION, updating the index and the working tree.
	352	If REVISION is a local branch, then that becomes the current
	353	branch. If it is something else, then `HEAD' becomes detached.
	354	Checkout fails if the working tree or the staging area contain
	355	changes.
	356
	357	\(git checkout REVISION).
	358
	359	\(fn REVISION)" t nil)
	360
	361	(autoload 'magit-branch-create "magit-branch" "\
	362	Create BRANCH at branch or revision START-POINT.
	363
	364	\(git branch [ARGS] BRANCH START-POINT).
	365
	366	\(fn BRANCH START-POINT &optional ARGS)" t nil)
	367
	368	(autoload 'magit-branch-and-checkout "magit-branch" "\
	369	Create and checkout BRANCH at branch or revision START-POINT.
	370
	371	\(git checkout [ARGS] -b BRANCH START-POINT).
	372
	373	\(fn BRANCH START-POINT &optional ARGS)" t nil)
	374
	375	(autoload 'magit-branch-or-checkout "magit-branch" "\
	376	Hybrid between `magit-checkout' and `magit-branch-and-checkout'.
	377
	378	Ask the user for an existing branch or revision. If the user
	379	input actually can be resolved as a branch or revision, then
	380	check that out, just like `magit-checkout' would.
	381
	382	Otherwise create and checkout a new branch using the input as
	383	its name. Before doing so read the starting-point for the new
	384	branch. This is similar to what `magit-branch-and-checkout'
	385	does.
	386
	387	\(fn ARG &optional START-POINT)" t nil)
	388
	389	(autoload 'magit-branch-checkout "magit-branch" "\
	390	Checkout an existing or new local branch.
	391
	392	Read a branch name from the user offering all local branches and
	393	a subset of remote branches as candidates. Omit remote branches
	394	for which a local branch by the same name exists from the list
	395	of candidates. The user can also enter a completely new branch
	396	name.
	397
	398	- If the user selects an existing local branch, then check that
	399	out.
	400
	401	- If the user selects a remote branch, then create and checkout
	402	a new local branch with the same name. Configure the selected
	403	remote branch as push target.
	404
	405	- If the user enters a new branch name, then create and check
	406	that out, after also reading the starting-point from the user.
	407
	408	In the latter two cases the upstream is also set. Whether it is
	409	set to the chosen START-POINT or something else depends on the
	410	value of `magit-branch-adjust-remote-upstream-alist', just like
	411	when using `magit-branch-and-checkout'.
	412
	413	\(fn BRANCH &optional START-POINT)" t nil)
	414
	415	(autoload 'magit-branch-orphan "magit-branch" "\
	416	Create and checkout an orphan BRANCH with contents from revision START-POINT.
	417
	418	\(git checkout --orphan [ARGS] BRANCH START-POINT).
	419
	420	\(fn BRANCH START-POINT &optional ARGS)" t nil)
	421
	422	(autoload 'magit-branch-pull-request "magit-branch" "\
	423	Create and configure a new branch from a pull-request.
	424	Please see the manual for more information.
	425
	426	\(fn PR)" t nil)
	427
	428	(autoload 'magit-branch-spinoff "magit-branch" "\
	429	Create new branch from the unpushed commits.
	430
	431	Create and checkout a new branch starting at and tracking the
	432	current branch. That branch in turn is reset to the last commit
	433	it shares with its upstream. If the current branch has no
	434	upstream or no unpushed commits, then the new branch is created
	435	anyway and the previously current branch is not touched.
	436
	437	This is useful to create a feature branch after work has already
	438	began on the old branch (likely but not necessarily \"master\").
	439
	440	If the current branch is a member of the value of option
	441	`magit-branch-prefer-remote-upstream' (which see), then the
	442	current branch will be used as the starting point as usual, but
	443	the upstream of the starting-point may be used as the upstream
	444	of the new branch, instead of the starting-point itself.
	445
	446	If optional FROM is non-nil, then the source branch is reset
	447	to `FROM~', instead of to the last commit it shares with its
	448	upstream. Interactively, FROM is only ever non-nil, if the
	449	region selects some commits, and among those commits, FROM is
	450	the commit that is the fewest commits ahead of the source
	451	branch.
	452
	453	The commit at the other end of the selection actually does not
	454	matter, all commits between FROM and `HEAD' are moved to the new
	455	branch. If FROM is not reachable from `HEAD' or is reachable
	456	from the source branch's upstream, then an error is raised.
	457
	458	\(fn BRANCH &optional FROM &rest ARGS)" t nil)
	459
	460	(autoload 'magit-branch-reset "magit-branch" "\
	461	Reset a branch to the tip of another branch or any other commit.
	462
	463	When the branch being reset is the current branch, then do a
	464	hard reset. If there are any uncommitted changes, then the user
	465	has to confirm the reset because those changes would be lost.
	466
	467	This is useful when you have started work on a feature branch but
	468	realize it's all crap and want to start over.
	469
	470	When resetting to another branch and a prefix argument is used,
	471	then also set the target branch as the upstream of the branch
	472	that is being reset.
	473
	474	\(fn BRANCH TO &optional ARGS SET-UPSTREAM)" t nil)
	475
	476	(autoload 'magit-branch-delete "magit-branch" "\
	477	Delete one or multiple branches.
	478	If the region marks multiple branches, then offer to delete
	479	those, otherwise prompt for a single branch to be deleted,
	480	defaulting to the branch at point.
	481
	482	\(fn BRANCHES &optional FORCE)" t nil)
	483
	484	(autoload 'magit-branch-rename "magit-branch" "\
	485	Rename the branch named OLD to NEW.
	486
	487	With a prefix argument FORCE, rename even if a branch named NEW
	488	already exists.
	489
	490	If `branch.OLD.pushRemote' is set, then unset it. Depending on
	491	the value of `magit-branch-rename-push-target' (which see) maybe
	492	set `branch.NEW.pushRemote' and maybe rename the push-target on
	493	the remote.
	494
	495	\(fn OLD NEW &optional FORCE)" t nil)
	496
	497	(autoload 'magit-branch-shelve "magit-branch" "\
	498	Shelve a BRANCH.
	499	Rename \"refs/heads/BRANCH\" to \"refs/shelved/BRANCH\",
	500	and also rename the respective reflog file.
	501
	502	\(fn BRANCH)" t nil)
	503
	504	(autoload 'magit-branch-unshelve "magit-branch" "\
	505	Unshelve a BRANCH
	506	Rename \"refs/shelved/BRANCH\" to \"refs/heads/BRANCH\",
	507	and also rename the respective reflog file.
	508
	509	\(fn BRANCH)" t nil)
	510
	511	(autoload 'magit-branch-config-popup "magit-branch" "\
	512	Popup console for setting branch variables.
	513
	514	\(fn BRANCH)" t nil)
	515
	516	(autoload 'magit-edit-branch*description "magit-branch" "\
	517	Edit the description of the current branch.
	518	With a prefix argument edit the description of another branch.
	519
	520	The description for the branch named NAME is stored in the Git
	521	variable `branch.<name>.description'.
	522
	523	\(fn BRANCH)" t nil)
	524
	525	(autoload 'magit-set-branch*merge/remote "magit-branch" "\
	526	Set or unset the upstream of the current branch.
	527	With a prefix argument do so for another branch.
	528
	529	When the branch in question already has an upstream then simply
	530	unsets it. Invoke this command again to set another upstream.
	531
	532	Together the Git variables `branch.<name>.remote' and
	533	`branch.<name>.merge' define the upstream branch of the local
	534	branch named NAME. The value of `branch.<name>.remote' is the
	535	name of the upstream remote. The value of `branch.<name>.merge'
	536	is the full reference of the upstream branch, on the remote.
	537
	538	Non-interactively, when UPSTREAM is non-nil, then always set it
	539	as the new upstream, regardless of whether another upstream was
	540	already set. When nil, then always unset.
	541
	542	\(fn BRANCH UPSTREAM)" t nil)
	543
	544	(autoload 'magit-cycle-branch*rebase "magit-branch" "\
	545	Cycle the value of `branch.<name>.rebase' for the current branch.
	546	With a prefix argument cycle the value for another branch.
	547
	548	The Git variables `branch.<name>.rebase' controls whether pulling
	549	into the branch named NAME is done by rebasing that branch onto
	550	the fetched branch or by merging that branch.
	551
	552	When `true' then pulling is done by rebasing.
	553	When `false' then pulling is done by merging.
	554
	555	When that variable is undefined then the value of `pull.rebase'
	556	is used instead. It defaults to `false'.
	557
	558	\(fn BRANCH)" t nil)
	559
	560	(autoload 'magit-cycle-branch*pushRemote "magit-branch" "\
	561	Cycle the value of `branch.<name>.pushRemote' for the current branch.
	562	With a prefix argument cycle the value for another branch.
	563
	564	The Git variable `branch.<name>.pushRemote' specifies the remote
	565	that the branch named NAME is usually pushed to. The value has
	566	to be the name of an existing remote.
	567
	568	If that variable is undefined, then the value of the Git variable
	569	`remote.pushDefault' is used instead, provided that it is defined,
	570	which by default it is not.
	571
	572	\(fn BRANCH)" t nil)
	573
	574	(autoload 'magit-cycle-pull\.rebase "magit-branch" "\
	575	Cycle the repository-local value of `pull.rebase'.
	576
	577	The Git variable `pull.rebase' specifies whether pulling is done
	578	by rebasing or by merging. It can be overwritten using the Git
	579	variable `branch.<name>.rebase'.
	580
	581	When `true' then pulling is done by rebasing.
	582	When `false' (the default) then pulling is done by merging.
	583
	584	\(fn)" t nil)
	585
	586	(autoload 'magit-cycle-remote\.pushDefault "magit-branch" "\
	587	Cycle the repository-local value of `remote.pushDefault'.
	588
	589	The Git variable `remote.pushDefault' specifies the remote that
	590	local branches are usually pushed to. It can be overwritten
	591	using the Git variable `branch.<name>.pushRemote'.
	592
	593	\(fn)" t nil)
	594
	595	(autoload 'magit-cycle-branch*autoSetupMerge "magit-branch" "\
	596	Cycle the repository-local value of `branch.autoSetupMerge'.
	597
	598	The Git variable `branch.autoSetupMerge' under what circumstances
	599	creating a branch (named NAME) should result in the variables
	600	`branch.<name>.merge' and `branch.<name>.remote' being set
	601	according to the starting point used to create the branch. If
	602	the starting point isn't a branch, then these variables are never
	603	set.
	604
	605	When `always' then the variables are set regardless of whether
	606	the starting point is a local or a remote branch.
	607
	608	When `true' (the default) then the variable are set when the
	609	starting point is a remote branch, but not when it is a local
	610	branch.
	611
	612	When `false' then the variables are never set.
	613
	614	\(fn)" t nil)
	615
	616	(autoload 'magit-cycle-branch*autoSetupRebase "magit-branch" "\
	617	Cycle the repository-local value of `branch.autoSetupRebase'.
	618
	619	The Git variable `branch.autoSetupRebase' specifies whether
	620	creating a branch (named NAME) should result in the variable
	621	`branch.<name>.rebase' being set to `true'.
	622
	623	When `always' then the variable is set regardless of whether the
	624	starting point is a local or a remote branch.
	625
	626	When `local' then the variable are set when the starting point
	627	is a local branch, but not when it is a remote branch.
	628
	629	When `remote' then the variable are set when the starting point
	630	is a remote branch, but not when it is a local branch.
	631
	632	When `never' (the default) then the variable is never set.
	633
	634	\(fn)" t nil)
	635
	636	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-branch" '("magit-")))
	637
	638	;;;***
	639
	640	;;;### (autoloads nil "magit-clone" "magit-clone.el" (0 0 0 0))
	641	;;; Generated autoloads from magit-clone.el
	642
	643	(autoload 'magit-clone "magit-clone" "\
	644	Clone the REPOSITORY to DIRECTORY.
	645	Then show the status buffer for the new repository.
	646
	647	\(fn REPOSITORY DIRECTORY)" t nil)
	648
	649	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-clone" '("magit-clone-")))
	650
	651	;;;***
	652
	653	;;;### (autoloads nil "magit-collab" "magit-collab.el" (0 0 0 0))
	654	;;; Generated autoloads from magit-collab.el
	655
	656	(autoload 'magit-browse-pull-request "magit-collab" "\
	657	Visit pull-request PR using `browse-url'.
	658
	659	Currently this only supports Github, but that restriction will
	660	be lifted eventually to support other Git forges.
	661
	662	\(fn PR)" t nil)
	663
	664	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-collab" '("magit-")))
	665
	666	;;;***
	667
	668	;;;### (autoloads nil "magit-commit" "magit-commit.el" (0 0 0 0))
	669	;;; Generated autoloads from magit-commit.el
	670
	671	(autoload 'magit-commit-create "magit-commit" "\
	672	Create a new commit on `HEAD'.
	673	With a prefix argument, amend to the commit at `HEAD' instead.
	674
	675	\(git commit [--amend] ARGS)
	676
	677	\(fn &optional ARGS)" t nil)
	678
	679	(autoload 'magit-commit-amend "magit-commit" "\
	680	Amend the last commit.
	681
	682	\(git commit --amend ARGS)
	683
	684	\(fn &optional ARGS)" t nil)
	685
	686	(autoload 'magit-commit-extend "magit-commit" "\
	687	Amend the last commit, without editing the message.
	688
	689	With a prefix argument keep the committer date, otherwise change
	690	it. The option `magit-commit-extend-override-date' can be used
	691	to inverse the meaning of the prefix argument.
	692	\(git commit
	693	--amend --no-edit)
	694
	695	\(fn &optional ARGS OVERRIDE-DATE)" t nil)
	696
	697	(autoload 'magit-commit-reword "magit-commit" "\
	698	Reword the last commit, ignoring staged changes.
	699
	700	With a prefix argument keep the committer date, otherwise change
	701	it. The option `magit-commit-reword-override-date' can be used
	702	to inverse the meaning of the prefix argument.
	703
	704	Non-interactively respect the optional OVERRIDE-DATE argument
	705	and ignore the option.
	706
	707	\(git commit --amend --only)
	708
	709	\(fn &optional ARGS OVERRIDE-DATE)" t nil)
	710
	711	(autoload 'magit-commit-fixup "magit-commit" "\
	712	Create a fixup commit.
	713
	714	With a prefix argument the target COMMIT has to be confirmed.
	715	Otherwise the commit at point may be used without confirmation
	716	depending on the value of option `magit-commit-squash-confirm'.
	717
	718	\(fn &optional COMMIT ARGS)" t nil)
	719
	720	(autoload 'magit-commit-squash "magit-commit" "\
	721	Create a squash commit, without editing the squash message.
	722
	723	With a prefix argument the target COMMIT has to be confirmed.
	724	Otherwise the commit at point may be used without confirmation
	725	depending on the value of option `magit-commit-squash-confirm'.
	726
	727	\(fn &optional COMMIT ARGS)" t nil)
	728
	729	(autoload 'magit-commit-augment "magit-commit" "\
	730	Create a squash commit, editing the squash message.
	731
	732	With a prefix argument the target COMMIT has to be confirmed.
	733	Otherwise the commit at point may be used without confirmation
	734	depending on the value of option `magit-commit-squash-confirm'.
	735
	736	\(fn &optional COMMIT ARGS)" t nil)
	737
	738	(autoload 'magit-commit-instant-fixup "magit-commit" "\
	739	Create a fixup commit targeting COMMIT and instantly rebase.
	740
	741	\(fn &optional COMMIT ARGS)" t nil)
	742
	743	(autoload 'magit-commit-instant-squash "magit-commit" "\
	744	Create a squash commit targeting COMMIT and instantly rebase.
	745
	746	\(fn &optional COMMIT ARGS)" t nil)
	747
	748	(autoload 'magit-commit-reshelve "magit-commit" "\
	749	Change the committer date and possibly the author date of `HEAD'.
	750
	751	If you are the author of `HEAD', then both dates are changed,
	752	otherwise only the committer date. The current time is used
	753	as the initial minibuffer input and the original author (if
	754	that is you) or committer date is available as the previous
	755	history element.
	756
	757	\(fn DATE)" t nil)
	758	(autoload 'magit-commit-absorb-popup "magit-commit" nil t)
	759
	760	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-commit" '("magit-")))
	761
	762	;;;***
	763
	764	;;;### (autoloads nil "magit-diff" "magit-diff.el" (0 0 0 0))
	765	;;; Generated autoloads from magit-diff.el
	766
	767	(autoload 'magit-diff-popup "magit-diff" "\
	768	Popup console for diff commands.
	769
	770	\(fn ARG)" t nil)
	771
	772	(autoload 'magit-diff-buffer-file-popup "magit-diff" "\
	773	Popup console for diff commands.
	774
	775	This is a variant of `magit-diff-popup' which shows the same popup
	776	but which limits the diff to the file being visited in the current
	777	buffer.
	778
	779	\(fn)" t nil)
	780
	781	(autoload 'magit-diff-dwim "magit-diff" "\
	782	Show changes for the thing at point.
	783
	784	\(fn &optional ARGS FILES)" t nil)
	785
	786	(autoload 'magit-diff-range "magit-diff" "\
	787	Show differences between two commits.
	788
	789	REV-OR-RANGE should be a range or a single revision. If it is a
	790	revision, then show changes in the working tree relative to that
	791	revision. If it is a range, but one side is omitted, then show
	792	changes relative to `HEAD'.
	793
	794	If the region is active, use the revisions on the first and last
	795	line of the region as the two sides of the range. With a prefix
	796	argument, instead of diffing the revisions, choose a revision to
	797	view changes along, starting at the common ancestor of both
	798	revisions (i.e., use a \"...\" range).
	799
	800	\(fn REV-OR-RANGE &optional ARGS FILES)" t nil)
	801
	802	(autoload 'magit-diff-working-tree "magit-diff" "\
	803	Show changes between the current working tree and the `HEAD' commit.
	804	With a prefix argument show changes between the working tree and
	805	a commit read from the minibuffer.
	806
	807	\(fn &optional REV ARGS FILES)" t nil)
	808
	809	(autoload 'magit-diff-staged "magit-diff" "\
	810	Show changes between the index and the `HEAD' commit.
	811	With a prefix argument show changes between the index and
	812	a commit read from the minibuffer.
	813
	814	\(fn &optional REV ARGS FILES)" t nil)
	815
	816	(autoload 'magit-diff-unstaged "magit-diff" "\
	817	Show changes between the working tree and the index.
	818
	819	\(fn &optional ARGS FILES)" t nil)
	820
	821	(autoload 'magit-diff-unmerged "magit-diff" "\
	822	Show changes that are being merged.
	823
	824	\(fn &optional ARGS FILES)" t nil)
	825
	826	(autoload 'magit-diff-while-committing "magit-diff" "\
	827	While committing, show the changes that are about to be committed.
	828	While amending, invoking the command again toggles between
	829	showing just the new changes or all the changes that will
	830	be committed.
	831
	832	\(fn &optional ARGS)" t nil)
	833
	834	(autoload 'magit-diff-buffer-file "magit-diff" "\
	835	Show diff for the blob or file visited in the current buffer.
	836
	837	\(fn)" t nil)
	838
	839	(autoload 'magit-diff-paths "magit-diff" "\
	840	Show changes between any two files on disk.
	841
	842	\(fn A B)" t nil)
	843
	844	(autoload 'magit-show-commit "magit-diff" "\
	845	Visit the revision at point in another buffer.
	846	If there is no revision at point or with a prefix argument prompt
	847	for a revision.
	848
	849	\(fn REV &optional ARGS FILES MODULE)" t nil)
	850
	851	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-diff" '("magit-")))
	852
	853	;;;***
	854
	855	;;;### (autoloads nil "magit-ediff" "magit-ediff.el" (0 0 0 0))
	856	;;; Generated autoloads from magit-ediff.el
	857	(autoload 'magit-ediff-popup "magit-ediff" nil t)
	858
	859	(autoload 'magit-ediff-resolve "magit-ediff" "\
	860	Resolve outstanding conflicts in FILE using Ediff.
	861	FILE has to be relative to the top directory of the repository.
	862
	863	In the rare event that you want to manually resolve all
	864	conflicts, including those already resolved by Git, use
	865	`ediff-merge-revisions-with-ancestor'.
	866
	867	\(fn FILE)" t nil)
	868
	869	(autoload 'magit-ediff-stage "magit-ediff" "\
	870	Stage and unstage changes to FILE using Ediff.
	871	FILE has to be relative to the top directory of the repository.
	872
	873	\(fn FILE)" t nil)
	874
	875	(autoload 'magit-ediff-compare "magit-ediff" "\
	876	Compare REVA:FILEA with REVB:FILEB using Ediff.
	877
	878	FILEA and FILEB have to be relative to the top directory of the
	879	repository. If REVA or REVB is nil, then this stands for the
	880	working tree state.
	881
	882	If the region is active, use the revisions on the first and last
	883	line of the region. With a prefix argument, instead of diffing
	884	the revisions, choose a revision to view changes along, starting
	885	at the common ancestor of both revisions (i.e., use a \"...\"
	886	range).
	887
	888	\(fn REVA REVB FILEA FILEB)" t nil)
	889
	890	(autoload 'magit-ediff-dwim "magit-ediff" "\
	891	Compare, stage, or resolve using Ediff.
	892	This command tries to guess what file, and what commit or range
	893	the user wants to compare, stage, or resolve using Ediff. It
	894	might only be able to guess either the file, or range or commit,
	895	in which case the user is asked about the other. It might not
	896	always guess right, in which case the appropriate `magit-ediff-*'
	897	command has to be used explicitly. If it cannot read the user's
	898	mind at all, then it asks the user for a command to run.
	899
	900	\(fn)" t nil)
	901
	902	(autoload 'magit-ediff-show-staged "magit-ediff" "\
	903	Show staged changes using Ediff.
	904
	905	This only allows looking at the changes; to stage, unstage,
	906	and discard changes using Ediff, use `magit-ediff-stage'.
	907
	908	FILE must be relative to the top directory of the repository.
	909
	910	\(fn FILE)" t nil)
	911
	912	(autoload 'magit-ediff-show-unstaged "magit-ediff" "\
	913	Show unstaged changes using Ediff.
	914
	915	This only allows looking at the changes; to stage, unstage,
	916	and discard changes using Ediff, use `magit-ediff-stage'.
	917
	918	FILE must be relative to the top directory of the repository.
	919
	920	\(fn FILE)" t nil)
	921
	922	(autoload 'magit-ediff-show-working-tree "magit-ediff" "\
	923	Show changes between `HEAD' and working tree using Ediff.
	924	FILE must be relative to the top directory of the repository.
	925
	926	\(fn FILE)" t nil)
	927
	928	(autoload 'magit-ediff-show-commit "magit-ediff" "\
	929	Show changes introduced by COMMIT using Ediff.
	930
	931	\(fn COMMIT)" t nil)
	932
	933	(autoload 'magit-ediff-show-stash "magit-ediff" "\
	934	Show changes introduced by STASH using Ediff.
	935	`magit-ediff-show-stash-with-index' controls whether a
	936	three-buffer Ediff is used in order to distinguish changes in the
	937	stash that were staged.
	938
	939	\(fn STASH)" t nil)
	940
	941	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-ediff" '("magit-ediff-")))
	942
	943	;;;***
	944
	945	;;;### (autoloads nil "magit-extras" "magit-extras.el" (0 0 0 0))
	946	;;; Generated autoloads from magit-extras.el
	947
	948	(autoload 'magit-run-git-gui "magit-extras" "\
	949	Run `git gui' for the current git repository.
	950
	951	\(fn)" t nil)
	952
	953	(autoload 'magit-run-git-gui-blame "magit-extras" "\
	954	Run `git gui blame' on the given FILENAME and COMMIT.
	955	Interactively run it for the current file and the `HEAD', with a
	956	prefix or when the current file cannot be determined let the user
	957	choose. When the current buffer is visiting FILENAME instruct
	958	blame to center around the line point is on.
	959
	960	\(fn COMMIT FILENAME &optional LINENUM)" t nil)
	961
	962	(autoload 'magit-run-gitk "magit-extras" "\
	963	Run `gitk' in the current repository.
	964
	965	\(fn)" t nil)
	966
	967	(autoload 'magit-run-gitk-branches "magit-extras" "\
	968	Run `gitk --branches' in the current repository.
	969
	970	\(fn)" t nil)
	971
	972	(autoload 'magit-run-gitk-all "magit-extras" "\
	973	Run `gitk --all' in the current repository.
	974
	975	\(fn)" t nil)
	976
	977	(autoload 'ido-enter-magit-status "magit-extras" "\
	978	Drop into `magit-status' from file switching.
	979
	980	This command does not work in Emacs 26. It does work in Emacs 25
	981	and Emacs 27. See https://github.com/magit/magit/issues/3634 and
	982	https://debbugs.gnu.org/cgi/bugreport.cgi?bug=31707.
	983
	984	To make this command available use something like:
	985
	986	(add-hook \\='ido-setup-hook
	987	(lambda ()
	988	(define-key ido-completion-map
	989	(kbd \"C-x g\") \\='ido-enter-magit-status)))
	990
	991	Starting with Emacs 25.1 the Ido keymaps are defined just once
	992	instead of every time Ido is invoked, so now you can modify it
	993	like pretty much every other keymap:
	994
	995	(define-key ido-common-completion-map
	996	(kbd \"C-x g\") \\='ido-enter-magit-status)
	997
	998	\(fn)" t nil)
	999
	1000	(autoload 'magit-dired-jump "magit-extras" "\
	1001	Visit file at point using Dired.
	1002	With a prefix argument, visit in another window. If there
	1003	is no file at point, then instead visit `default-directory'.
	1004
	1005	\(fn &optional OTHER-WINDOW)" t nil)
	1006
	1007	(autoload 'magit-dired-log "magit-extras" "\
	1008	Show log for all marked files, or the current file.
	1009
	1010	\(fn &optional FOLLOW)" t nil)
	1011
	1012	(autoload 'magit-do-async-shell-command "magit-extras" "\
	1013	Open FILE with `dired-do-async-shell-command'.
	1014	Interactively, open the file at point.
	1015
	1016	\(fn FILE)" t nil)
	1017
	1018	(autoload 'magit-previous-line "magit-extras" "\
	1019	Like `previous-line' but with Magit-specific shift-selection.
	1020
	1021	Magit's selection mechanism is based on the region but selects an
	1022	area that is larger than the region. This causes `previous-line'
	1023	when invoked while holding the shift key to move up one line and
	1024	thereby select two lines. When invoked inside a hunk body this
	1025	command does not move point on the first invocation and thereby
	1026	it only selects a single line. Which inconsistency you prefer
	1027	is a matter of preference.
	1028
	1029	\(fn &optional ARG TRY-VSCROLL)" t nil)
	1030
	1031	(function-put 'magit-previous-line 'interactive-only '"use `forward-line' with negative argument instead.")
	1032
	1033	(autoload 'magit-next-line "magit-extras" "\
	1034	Like `next-line' but with Magit-specific shift-selection.
	1035
	1036	Magit's selection mechanism is based on the region but selects
	1037	an area that is larger than the region. This causes `next-line'
	1038	when invoked while holding the shift key to move down one line
	1039	and thereby select two lines. When invoked inside a hunk body
	1040	this command does not move point on the first invocation and
	1041	thereby it only selects a single line. Which inconsistency you
	1042	prefer is a matter of preference.
	1043
	1044	\(fn &optional ARG TRY-VSCROLL)" t nil)
	1045
	1046	(function-put 'magit-next-line 'interactive-only 'forward-line)
	1047
	1048	(autoload 'magit-clean "magit-extras" "\
	1049	Remove untracked files from the working tree.
	1050	With a prefix argument also remove ignored files,
	1051	with two prefix arguments remove ignored files only.
	1052
	1053	\(git clean -f -d [-x\|-X])
	1054
	1055	\(fn &optional ARG)" t nil)
	1056
	1057	(autoload 'magit-add-change-log-entry "magit-extras" "\
	1058	Find change log file and add date entry and item for current change.
	1059	This differs from `add-change-log-entry' (which see) in that
	1060	it acts on the current hunk in a Magit buffer instead of on
	1061	a position in a file-visiting buffer.
	1062
	1063	\(fn &optional WHOAMI FILE-NAME OTHER-WINDOW)" t nil)
	1064
	1065	(autoload 'magit-add-change-log-entry-other-window "magit-extras" "\
	1066	Find change log file in other window and add entry and item.
	1067	This differs from `add-change-log-entry-other-window' (which see)
	1068	in that it acts on the current hunk in a Magit buffer instead of
	1069	on a position in a file-visiting buffer.
	1070
	1071	\(fn &optional WHOAMI FILE-NAME)" t nil)
	1072
	1073	(autoload 'magit-edit-line-commit "magit-extras" "\
	1074	Edit the commit that added the current line.
	1075
	1076	With a prefix argument edit the commit that removes the line,
	1077	if any. The commit is determined using `git blame' and made
	1078	editable using `git rebase --interactive' if it is reachable
	1079	from `HEAD', or by checking out the commit (or a branch that
	1080	points at it) otherwise.
	1081
	1082	\(fn &optional TYPE)" t nil)
	1083
	1084	(autoload 'magit-reshelve-since "magit-extras" "\
	1085	Change the author and committer dates of the commits since REV.
	1086
	1087	Ask the user for the first reachable commit whose dates should
	1088	be changed. The read the new date for that commit. The initial
	1089	minibuffer input and the previous history element offer good
	1090	values. The next commit will be created one minute later and so
	1091	on.
	1092
	1093	This command is only intended for interactive use and should only
	1094	be used on highly rearranged and unpublished history.
	1095
	1096	\(fn REV)" t nil)
	1097
	1098	(autoload 'magit-pop-revision-stack "magit-extras" "\
	1099	Insert a representation of a revision into the current buffer.
	1100
	1101	Pop a revision from the `magit-revision-stack' and insert it into
	1102	the current buffer according to `magit-pop-revision-stack-format'.
	1103	Revisions can be put on the stack using `magit-copy-section-value'
	1104	and `magit-copy-buffer-revision'.
	1105
	1106	If the stack is empty or with a prefix argument, instead read a
	1107	revision in the minibuffer. By using the minibuffer history this
	1108	allows selecting an item which was popped earlier or to insert an
	1109	arbitrary reference or revision without first pushing it onto the
	1110	stack.
	1111
	1112	When reading the revision from the minibuffer, then it might not
	1113	be possible to guess the correct repository. When this command
	1114	is called inside a repository (e.g. while composing a commit
	1115	message), then that repository is used. Otherwise (e.g. while
	1116	composing an email) then the repository recorded for the top
	1117	element of the stack is used (even though we insert another
	1118	revision). If not called inside a repository and with an empty
	1119	stack, or with two prefix arguments, then read the repository in
	1120	the minibuffer too.
	1121
	1122	\(fn REV TOPLEVEL)" t nil)
	1123
	1124	(autoload 'magit-copy-section-value "magit-extras" "\
	1125	Save the value of the current section for later use.
	1126
	1127	Save the section value to the `kill-ring', and, provided that
	1128	the current section is a commit, branch, or tag section, push
	1129	the (referenced) revision to the `magit-revision-stack' for use
	1130	with `magit-pop-revision-stack'.
	1131
	1132	When the current section is a branch or a tag, and a prefix
	1133	argument is used, then save the revision at its tip to the
	1134	`kill-ring' instead of the reference name.
	1135
	1136	When the region is active, then save that to the `kill-ring',
	1137	like `kill-ring-save' would, instead of behaving as described
	1138	above.
	1139
	1140	\(fn)" t nil)
	1141
	1142	(autoload 'magit-copy-buffer-revision "magit-extras" "\
	1143	Save the revision of the current buffer for later use.
	1144
	1145	Save the revision shown in the current buffer to the `kill-ring'
	1146	and push it to the `magit-revision-stack'.
	1147
	1148	This command is mainly intended for use in `magit-revision-mode'
	1149	buffers, the only buffers where it is always unambiguous exactly
	1150	which revision should be saved.
	1151
	1152	Most other Magit buffers usually show more than one revision, in
	1153	some way or another, so this command has to select one of them,
	1154	and that choice might not always be the one you think would have
	1155	been the best pick.
	1156
	1157	In such buffers it is often more useful to save the value of
	1158	the current section instead, using `magit-copy-section-value'.
	1159
	1160	When the region is active, then save that to the `kill-ring',
	1161	like `kill-ring-save' would, instead of behaving as described
	1162	above.
	1163
	1164	\(fn)" t nil)
	1165
	1166	(autoload 'magit-abort-dwim "magit-extras" "\
	1167	Abort current operation.
	1168	Depending on the context, this will abort a merge, a rebase, a
	1169	patch application, a cherry-pick, a revert, or a bisect.
	1170
	1171	\(fn)" t nil)
	1172
	1173	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-extras" '("magit-")))
	1174
	1175	;;;***
	1176
	1177	;;;### (autoloads nil "magit-fetch" "magit-fetch.el" (0 0 0 0))
	1178	;;; Generated autoloads from magit-fetch.el
	1179	(autoload 'magit-fetch-popup "magit-fetch" nil t)
	1180
	1181	(autoload 'magit-fetch-from-pushremote "magit-fetch" "\
	1182	Fetch from the push-remote of the current branch.
	1183
	1184	\(fn ARGS)" t nil)
	1185
	1186	(autoload 'magit-fetch-from-upstream "magit-fetch" "\
	1187	Fetch from the upstream repository of the current branch.
	1188
	1189	\(fn ARGS)" t nil)
	1190
	1191	(autoload 'magit-fetch-other "magit-fetch" "\
	1192	Fetch from another repository.
	1193
	1194	\(fn REMOTE ARGS)" t nil)
	1195
	1196	(autoload 'magit-fetch-branch "magit-fetch" "\
	1197	Fetch a BRANCH from a REMOTE.
	1198
	1199	\(fn REMOTE BRANCH ARGS)" t nil)
	1200
	1201	(autoload 'magit-fetch-refspec "magit-fetch" "\
	1202	Fetch a REFSPEC from a REMOTE.
	1203
	1204	\(fn REMOTE REFSPEC ARGS)" t nil)
	1205
	1206	(autoload 'magit-fetch-all "magit-fetch" "\
	1207	Fetch from all remotes.
	1208
	1209	\(fn ARGS)" t nil)
	1210
	1211	(autoload 'magit-fetch-all-prune "magit-fetch" "\
	1212	Fetch from all remotes, and prune.
	1213	Prune remote tracking branches for branches that have been
	1214	removed on the respective remote.
	1215
	1216	\(fn)" t nil)
	1217
	1218	(autoload 'magit-fetch-all-no-prune "magit-fetch" "\
	1219	Fetch from all remotes.
	1220
	1221	\(fn)" t nil)
	1222
	1223	(autoload 'magit-fetch-modules "magit-fetch" "\
	1224	Fetch all submodules.
	1225
	1226	Option `magit-fetch-modules-jobs' controls how many submodules
	1227	are being fetched in parallel. Also fetch the super-repository,
	1228	because `git-fetch' does not support not doing that. With a
	1229	prefix argument fetch all remotes.
	1230
	1231	\(fn &optional ALL)" t nil)
	1232
	1233	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-fetch" '("magit-")))
	1234
	1235	;;;***
	1236
	1237	;;;### (autoloads nil "magit-files" "magit-files.el" (0 0 0 0))
	1238	;;; Generated autoloads from magit-files.el
	1239
	1240	(autoload 'magit-find-file "magit-files" "\
	1241	View FILE from REV.
	1242	Switch to a buffer visiting blob REV:FILE,
	1243	creating one if none already exists.
	1244
	1245	\(fn REV FILE)" t nil)
	1246
	1247	(autoload 'magit-find-file-other-window "magit-files" "\
	1248	View FILE from REV, in another window.
	1249	Like `magit-find-file', but create a new window or reuse an
	1250	existing one.
	1251
	1252	\(fn REV FILE)" t nil)
	1253	(autoload 'magit-file-popup "magit" nil t)
	1254
	1255	(defvar global-magit-file-mode t "\
	1256	Non-nil if Global Magit-File mode is enabled.
	1257	See the `global-magit-file-mode' command
	1258	for a description of this minor mode.
	1259	Setting this variable directly does not take effect;
	1260	either customize it (see the info node `Easy Customization')
	1261	or call the function `global-magit-file-mode'.")
	1262
	1263	(custom-autoload 'global-magit-file-mode "magit-files" nil)
	1264
	1265	(autoload 'global-magit-file-mode "magit-files" "\
	1266	Toggle Magit-File mode in all buffers.
	1267	With prefix ARG, enable Global Magit-File mode if ARG is positive;
	1268	otherwise, disable it. If called from Lisp, enable the mode if
	1269	ARG is omitted or nil.
	1270
	1271	Magit-File mode is enabled in all buffers where
	1272	`magit-file-mode-turn-on' would do it.
	1273	See `magit-file-mode' for more information on Magit-File mode.
	1274
	1275	\(fn &optional ARG)" t nil)
	1276
	1277	(autoload 'magit-file-checkout "magit-files" "\
	1278	Checkout FILE from REV.
	1279
	1280	\(fn REV FILE)" t nil)
	1281
	1282	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-files" '("magit-")))
	1283
	1284	;;;***
	1285
	1286	;;;### (autoloads nil "magit-git" "magit-git.el" (0 0 0 0))
	1287	;;; Generated autoloads from magit-git.el
	1288
	1289	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-git" '("magit-")))
	1290
	1291	;;;***
	1292
	1293	;;;### (autoloads nil "magit-gitignore" "magit-gitignore.el" (0 0
	1294	;;;;;; 0 0))
	1295	;;; Generated autoloads from magit-gitignore.el
	1296	(autoload 'magit-gitignore-popup "magit-gitignore" nil t)
	1297
	1298	(autoload 'magit-gitignore-globally "magit-gitignore" "\
	1299	Instruct Git to globally ignore FILE-OR-PATTERN.
	1300
	1301	\(fn FILE-OR-PATTERN)" t nil)
	1302
	1303	(autoload 'magit-gitignore-locally "magit-gitignore" "\
	1304	Instruct Git to locally ignore FILE-OR-PATTERN.
	1305
	1306	\(fn FILE-OR-PATTERN)" t nil)
	1307
	1308	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-gitignore" '("magit-")))
	1309
	1310	;;;***
	1311
	1312	;;;### (autoloads nil "magit-imenu" "magit-imenu.el" (0 0 0 0))
	1313	;;; Generated autoloads from magit-imenu.el
	1314
	1315	(autoload 'magit-imenu--log-prev-index-position-function "magit-imenu" "\
	1316	Move point to previous line in current buffer.
	1317	This function is used as a value for
	1318	`imenu-prev-index-position-function'.
	1319
	1320	\(fn)" nil nil)
	1321
	1322	(autoload 'magit-imenu--log-extract-index-name-function "magit-imenu" "\
	1323	Return imenu name for line at point.
	1324	This function is used as a value for
	1325	`imenu-extract-index-name-function'. Point should be at the
	1326	beginning of the line.
	1327
	1328	\(fn)" nil nil)
	1329
	1330	(autoload 'magit-imenu--diff-prev-index-position-function "magit-imenu" "\
	1331	Move point to previous file line in current buffer.
	1332	This function is used as a value for
	1333	`imenu-prev-index-position-function'.
	1334
	1335	\(fn)" nil nil)
	1336
	1337	(autoload 'magit-imenu--diff-extract-index-name-function "magit-imenu" "\
	1338	Return imenu name for line at point.
	1339	This function is used as a value for
	1340	`imenu-extract-index-name-function'. Point should be at the
	1341	beginning of the line.
	1342
	1343	\(fn)" nil nil)
	1344
	1345	(autoload 'magit-imenu--status-create-index-function "magit-imenu" "\
	1346	Return an alist of all imenu entries in current buffer.
	1347	This function is used as a value for
	1348	`imenu-create-index-function'.
	1349
	1350	\(fn)" nil nil)
	1351
	1352	(autoload 'magit-imenu--refs-create-index-function "magit-imenu" "\
	1353	Return an alist of all imenu entries in current buffer.
	1354	This function is used as a value for
	1355	`imenu-create-index-function'.
	1356
	1357	\(fn)" nil nil)
	1358
	1359	(autoload 'magit-imenu--cherry-create-index-function "magit-imenu" "\
	1360	Return an alist of all imenu entries in current buffer.
	1361	This function is used as a value for
	1362	`imenu-create-index-function'.
	1363
	1364	\(fn)" nil nil)
	1365
	1366	(autoload 'magit-imenu--submodule-prev-index-position-function "magit-imenu" "\
	1367	Move point to previous line in magit-submodule-list buffer.
	1368	This function is used as a value for
	1369	`imenu-prev-index-position-function'.
	1370
	1371	\(fn)" nil nil)
	1372
	1373	(autoload 'magit-imenu--submodule-extract-index-name-function "magit-imenu" "\
	1374	Return imenu name for line at point.
	1375	This function is used as a value for
	1376	`imenu-extract-index-name-function'. Point should be at the
	1377	beginning of the line.
	1378
	1379	\(fn)" nil nil)
	1380
	1381	(autoload 'magit-imenu--repolist-prev-index-position-function "magit-imenu" "\
	1382	Move point to previous line in magit-repolist buffer.
	1383	This function is used as a value for
	1384	`imenu-prev-index-position-function'.
	1385
	1386	\(fn)" nil nil)
	1387
	1388	(autoload 'magit-imenu--repolist-extract-index-name-function "magit-imenu" "\
	1389	Return imenu name for line at point.
	1390	This function is used as a value for
	1391	`imenu-extract-index-name-function'. Point should be at the
	1392	beginning of the line.
	1393
	1394	\(fn)" nil nil)
	1395
	1396	(autoload 'magit-imenu--process-prev-index-position-function "magit-imenu" "\
	1397	Move point to previous process in magit-process buffer.
	1398	This function is used as a value for
	1399	`imenu-prev-index-position-function'.
	1400
	1401	\(fn)" nil nil)
	1402
	1403	(autoload 'magit-imenu--process-extract-index-name-function "magit-imenu" "\
	1404	Return imenu name for line at point.
	1405	This function is used as a value for
	1406	`imenu-extract-index-name-function'. Point should be at the
	1407	beginning of the line.
	1408
	1409	\(fn)" nil nil)
	1410
	1411	(autoload 'magit-imenu--rebase-prev-index-position-function "magit-imenu" "\
	1412	Move point to previous commit in git-rebase buffer.
	1413	This function is used as a value for
	1414	`imenu-prev-index-position-function'.
	1415
	1416	\(fn)" nil nil)
	1417
	1418	(autoload 'magit-imenu--rebase-extract-index-name-function "magit-imenu" "\
	1419	Return imenu name for line at point.
	1420	This function is used as a value for
	1421	`imenu-extract-index-name-function'. Point should be at the
	1422	beginning of the line.
	1423
	1424	\(fn)" nil nil)
	1425
	1426	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-imenu" '("magit-imenu--index-function")))
	1427
	1428	;;;***
	1429
	1430	;;;### (autoloads nil "magit-log" "magit-log.el" (0 0 0 0))
	1431	;;; Generated autoloads from magit-log.el
	1432
	1433	(autoload 'magit-log-buffer-file-popup "magit-log" "\
	1434	Popup console for log commands.
	1435
	1436	This is a variant of `magit-log-popup' which shows the same popup
	1437	but which limits the log to the file being visited in the current
	1438	buffer.
	1439
	1440	\(fn)" t nil)
	1441
	1442	(autoload 'magit-log-current "magit-log" "\
	1443	Show log for the current branch.
	1444	When `HEAD' is detached or with a prefix argument show log for
	1445	one or more revs read from the minibuffer.
	1446
	1447	\(fn REVS &optional ARGS FILES)" t nil)
	1448
	1449	(autoload 'magit-log-other "magit-log" "\
	1450	Show log for one or more revs read from the minibuffer.
	1451	The user can input any revision or revisions separated by a
	1452	space, or even ranges, but only branches and tags, and a
	1453	representation of the commit at point, are available as
	1454	completion candidates.
	1455
	1456	\(fn REVS &optional ARGS FILES)" t nil)
	1457
	1458	(autoload 'magit-log-head "magit-log" "\
	1459	Show log for `HEAD'.
	1460
	1461	\(fn &optional ARGS FILES)" t nil)
	1462
	1463	(autoload 'magit-log-branches "magit-log" "\
	1464	Show log for all local branches and `HEAD'.
	1465
	1466	\(fn &optional ARGS FILES)" t nil)
	1467
	1468	(autoload 'magit-log-all-branches "magit-log" "\
	1469	Show log for all local and remote branches and `HEAD'.
	1470
	1471	\(fn &optional ARGS FILES)" t nil)
	1472
	1473	(autoload 'magit-log-all "magit-log" "\
	1474	Show log for all references and `HEAD'.
	1475
	1476	\(fn &optional ARGS FILES)" t nil)
	1477
	1478	(autoload 'magit-log-buffer-file "magit-log" "\
	1479	Show log for the blob or file visited in the current buffer.
	1480	With a prefix argument or when `--follow' is part of
	1481	`magit-log-arguments', then follow renames. When the region is
	1482	active, restrict the log to the lines that the region touches.
	1483
	1484	\(fn &optional FOLLOW BEG END)" t nil)
	1485
	1486	(autoload 'magit-log-trace-definition "magit-log" "\
	1487	Show log for the definition at point.
	1488
	1489	\(fn FILE FN REV)" t nil)
	1490
	1491	(autoload 'magit-log-merged "magit-log" "\
	1492	Show log for the merge of COMMIT into BRANCH.
	1493	More precisely, find merge commit M that brought COMMIT into
	1494	BRANCH, and show the log of the range \"M^..M\". This command
	1495	requires git-when-merged, which is available from
	1496	https://github.com/mhagger/git-when-merged.
	1497
	1498	\(fn COMMIT BRANCH &optional ARGS FILES)" t nil)
	1499
	1500	(autoload 'magit-reflog-current "magit-log" "\
	1501	Display the reflog of the current branch.
	1502
	1503	\(fn ARGS)" t nil)
	1504
	1505	(autoload 'magit-reflog-other "magit-log" "\
	1506	Display the reflog of a branch or another ref.
	1507
	1508	\(fn REF ARGS)" t nil)
	1509
	1510	(autoload 'magit-reflog-head "magit-log" "\
	1511	Display the `HEAD' reflog.
	1512
	1513	\(fn ARGS)" t nil)
	1514
	1515	(autoload 'magit-log-move-to-parent "magit-log" "\
	1516	Move to the Nth parent of the current commit.
	1517
	1518	\(fn &optional N)" t nil)
	1519
	1520	(autoload 'magit-cherry "magit-log" "\
	1521	Show commits in a branch that are not merged in the upstream branch.
	1522
	1523	\(fn HEAD UPSTREAM)" t nil)
	1524
	1525	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-log" '("magit-")))
	1526
	1527	;;;***
	1528
	1529	;;;### (autoloads nil "magit-margin" "magit-margin.el" (0 0 0 0))
	1530	;;; Generated autoloads from magit-margin.el
	1531
	1532	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-margin" '("magit-")))
	1533
	1534	;;;***
	1535
	1536	;;;### (autoloads nil "magit-merge" "magit-merge.el" (0 0 0 0))
	1537	;;; Generated autoloads from magit-merge.el
	1538	(autoload 'magit-merge-popup "magit" nil t)
	1539
	1540	(autoload 'magit-merge-plain "magit-merge" "\
	1541	Merge commit REV into the current branch; using default message.
	1542
	1543	Unless there are conflicts or a prefix argument is used create a
	1544	merge commit using a generic commit message and without letting
	1545	the user inspect the result. With a prefix argument pretend the
	1546	merge failed to give the user the opportunity to inspect the
	1547	merge.
	1548
	1549	\(git merge --no-edit\|--no-commit [ARGS] REV)
	1550
	1551	\(fn REV &optional ARGS NOCOMMIT)" t nil)
	1552
	1553	(autoload 'magit-merge-editmsg "magit-merge" "\
	1554	Merge commit REV into the current branch; and edit message.
	1555	Perform the merge and prepare a commit message but let the user
	1556	edit it.
	1557
	1558	\(git merge --edit --no-ff [ARGS] REV)
	1559
	1560	\(fn REV &optional ARGS)" t nil)
	1561
	1562	(autoload 'magit-merge-nocommit "magit-merge" "\
	1563	Merge commit REV into the current branch; pretending it failed.
	1564	Pretend the merge failed to give the user the opportunity to
	1565	inspect the merge and change the commit message.
	1566
	1567	\(git merge --no-commit --no-ff [ARGS] REV)
	1568
	1569	\(fn REV &optional ARGS)" t nil)
	1570
	1571	(autoload 'magit-merge-into "magit-merge" "\
	1572	Merge the current branch into BRANCH and remove the former.
	1573
	1574	Before merging, force push the source branch to its push-remote,
	1575	provided the respective remote branch already exists, ensuring
	1576	that the respective pull-request (if any) won't get stuck on some
	1577	obsolete version of the commits that are being merged. Finally
	1578	if `magit-branch-pull-request' was used to create the merged
	1579	branch, then also remove the respective remote branch.
	1580
	1581	\(fn BRANCH &optional ARGS)" t nil)
	1582
	1583	(autoload 'magit-merge-absorb "magit-merge" "\
	1584	Merge BRANCH into the current branch and remove the former.
	1585
	1586	Before merging, force push the source branch to its push-remote,
	1587	provided the respective remote branch already exists, ensuring
	1588	that the respective pull-request (if any) won't get stuck on some
	1589	obsolete version of the commits that are being merged. Finally
	1590	if `magit-branch-pull-request' was used to create the merged
	1591	branch, then also remove the respective remote branch.
	1592
	1593	\(fn BRANCH &optional ARGS)" t nil)
	1594
	1595	(autoload 'magit-merge-squash "magit-merge" "\
	1596	Squash commit REV into the current branch; don't create a commit.
	1597
	1598	\(git merge --squash REV)
	1599
	1600	\(fn REV)" t nil)
	1601
	1602	(autoload 'magit-merge-preview "magit-merge" "\
	1603	Preview result of merging REV into the current branch.
	1604
	1605	\(fn REV)" t nil)
	1606
	1607	(autoload 'magit-merge-abort "magit-merge" "\
	1608	Abort the current merge operation.
	1609
	1610	\(git merge --abort)
	1611
	1612	\(fn)" t nil)
	1613
	1614	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-merge" '("magit-")))
	1615
	1616	;;;***
	1617
	1618	;;;### (autoloads nil "magit-mode" "magit-mode.el" (0 0 0 0))
	1619	;;; Generated autoloads from magit-mode.el
	1620
	1621	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-mode" '("magit-" "disable-magit-save-buffers" "inhibit-magit-refresh")))
	1622
	1623	;;;***
	1624
	1625	;;;### (autoloads nil "magit-notes" "magit-notes.el" (0 0 0 0))
	1626	;;; Generated autoloads from magit-notes.el
	1627	(autoload 'magit-notes-popup "magit" nil t)
	1628
	1629	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-notes" '("magit-")))
	1630
	1631	;;;***
	1632
	1633	;;;### (autoloads nil "magit-patch" "magit-patch.el" (0 0 0 0))
	1634	;;; Generated autoloads from magit-patch.el
	1635	(autoload 'magit-patch-popup "magit-patch" nil t)
	1636
	1637	(autoload 'magit-format-patch "magit-patch" "\
	1638	Create patches for the commits in RANGE.
	1639	When a single commit is given for RANGE, create a patch for the
	1640	changes introduced by that commit (unlike 'git format-patch'
	1641	which creates patches for all commits that are reachable from
	1642	`HEAD' but not from the specified commit).
	1643
	1644	\(fn RANGE ARGS FILES)" t nil)
	1645
	1646	(autoload 'magit-request-pull "magit-patch" "\
	1647	Request upstream to pull from you public repository.
	1648
	1649	URL is the url of your publically accessible repository.
	1650	START is a commit that already is in the upstream repository.
	1651	END is the last commit, usually a branch name, which upstream
	1652	is asked to pull. START has to be reachable from that commit.
	1653
	1654	\(fn URL START END)" t nil)
	1655	(autoload 'magit-patch-apply-popup "magit-patch" nil t)
	1656
	1657	(autoload 'magit-patch-apply "magit-patch" "\
	1658	Apply the patch file FILE.
	1659
	1660	\(fn FILE &rest ARGS)" t nil)
	1661
	1662	(autoload 'magit-patch-save "magit-patch" "\
	1663	Write current diff into patch FILE.
	1664
	1665	What arguments are used to create the patch depends on the value
	1666	of `magit-patch-save-arguments' and whether a prefix argument is
	1667	used.
	1668
	1669	If the value is the symbol `buffer', then use the same arguments
	1670	as the buffer. With a prefix argument use no arguments.
	1671
	1672	If the value is a list beginning with the symbol `exclude', then
	1673	use the same arguments as the buffer except for those matched by
	1674	entries in the cdr of the list. The comparison is done using
	1675	`string-prefix-p'. With a prefix argument use the same arguments
	1676	as the buffer.
	1677
	1678	If the value is a list of strings (including the empty list),
	1679	then use those arguments. With a prefix argument use the same
	1680	arguments as the buffer.
	1681
	1682	Of course the arguments that are required to actually show the
	1683	same differences as those shown in the buffer are always used.
	1684
	1685	\(fn FILE &optional ARG)" t nil)
	1686
	1687	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-patch" '("magit-patch-save-arguments")))
	1688
	1689	;;;***
	1690
	1691	;;;### (autoloads nil "magit-process" "magit-process.el" (0 0 0 0))
	1692	;;; Generated autoloads from magit-process.el
	1693
	1694	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-process" '("magit-" "tramp-sh-handle-")))
	1695
	1696	;;;***
	1697
	1698	;;;### (autoloads nil "magit-pull" "magit-pull.el" (0 0 0 0))
	1699	;;; Generated autoloads from magit-pull.el
	1700	(autoload 'magit-pull-popup "magit-pull" nil t)
	1701	(autoload 'magit-pull-and-fetch-popup "magit-pull" nil t)
	1702
	1703	(autoload 'magit-pull-from-pushremote "magit-pull" "\
	1704	Pull from the push-remote of the current branch.
	1705
	1706	\(fn ARGS)" t nil)
	1707
	1708	(autoload 'magit-pull-from-upstream "magit-pull" "\
	1709	Pull from the upstream of the current branch.
	1710
	1711	\(fn ARGS)" t nil)
	1712
	1713	(autoload 'magit-pull-branch "magit-pull" "\
	1714	Pull from a branch read in the minibuffer.
	1715
	1716	\(fn SOURCE ARGS)" t nil)
	1717
	1718	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-pull" '("magit-")))
	1719
	1720	;;;***
	1721
	1722	;;;### (autoloads nil "magit-push" "magit-push.el" (0 0 0 0))
	1723	;;; Generated autoloads from magit-push.el
	1724	(autoload 'magit-push-popup "magit-push" nil t)
	1725
	1726	(autoload 'magit-push-current-to-pushremote "magit-push" "\
	1727	Push the current branch to `branch.<name>.pushRemote'.
	1728	If that variable is unset, then push to `remote.pushDefault'.
	1729
	1730	When `magit-push-current-set-remote-if-missing' is non-nil and
	1731	the push-remote is not configured, then read the push-remote from
	1732	the user, set it, and then push to it. With a prefix argument
	1733	the push-remote can be changed before pushed to it.
	1734
	1735	\(fn ARGS &optional PUSH-REMOTE)" t nil)
	1736
	1737	(autoload 'magit-push-current-to-upstream "magit-push" "\
	1738	Push the current branch to its upstream branch.
	1739
	1740	When `magit-push-current-set-remote-if-missing' is non-nil and
	1741	the upstream is not configured, then read the upstream from the
	1742	user, set it, and then push to it. With a prefix argument the
	1743	upstream can be changed before pushed to it.
	1744
	1745	\(fn ARGS &optional UPSTREAM)" t nil)
	1746
	1747	(autoload 'magit-push-current "magit-push" "\
	1748	Push the current branch to a branch read in the minibuffer.
	1749
	1750	\(fn TARGET ARGS)" t nil)
	1751
	1752	(autoload 'magit-push-other "magit-push" "\
	1753	Push an arbitrary branch or commit somewhere.
	1754	Both the source and the target are read in the minibuffer.
	1755
	1756	\(fn SOURCE TARGET ARGS)" t nil)
	1757
	1758	(autoload 'magit-push-refspecs "magit-push" "\
	1759	Push one or multiple REFSPECS to a REMOTE.
	1760	Both the REMOTE and the REFSPECS are read in the minibuffer. To
	1761	use multiple REFSPECS, separate them with commas. Completion is
	1762	only available for the part before the colon, or when no colon
	1763	is used.
	1764
	1765	\(fn REMOTE REFSPECS ARGS)" t nil)
	1766
	1767	(autoload 'magit-push-matching "magit-push" "\
	1768	Push all matching branches to another repository.
	1769	If multiple remotes exist, then read one from the user.
	1770	If just one exists, use that without requiring confirmation.
	1771
	1772	\(fn REMOTE &optional ARGS)" t nil)
	1773
	1774	(autoload 'magit-push-tags "magit-push" "\
	1775	Push all tags to another repository.
	1776	If only one remote exists, then push to that. Otherwise prompt
	1777	for a remote, offering the remote configured for the current
	1778	branch as default.
	1779
	1780	\(fn REMOTE &optional ARGS)" t nil)
	1781
	1782	(autoload 'magit-push-tag "magit-push" "\
	1783	Push a tag to another repository.
	1784
	1785	\(fn TAG REMOTE &optional ARGS)" t nil)
	1786
	1787	(autoload 'magit-push-implicitly "magit-push" "\
	1788	Push somewhere without using an explicit refspec.
	1789
	1790	This command simply runs \"git push -v [ARGS]\". ARGS are the
	1791	arguments specified in the popup buffer. No explicit refspec
	1792	arguments are used. Instead the behavior depends on at least
	1793	these Git variables: `push.default', `remote.pushDefault',
	1794	`branch.<branch>.pushRemote', `branch.<branch>.remote',
	1795	`branch.<branch>.merge', and `remote.<remote>.push'.
	1796
	1797	To add this command to the push popup add this to your init file:
	1798
	1799	(with-eval-after-load \\='magit-remote
	1800	(magit-define-popup-action \\='magit-push-popup ?P
	1801	\\='magit-push-implicitly--desc
	1802	\\='magit-push-implicitly ?p t))
	1803
	1804	The function `magit-push-implicitly--desc' attempts to predict
	1805	what this command will do. The value it returns is displayed in
	1806	the popup buffer.
	1807
	1808	\(fn ARGS)" t nil)
	1809
	1810	(autoload 'magit-push-to-remote "magit-push" "\
	1811	Push to REMOTE without using an explicit refspec.
	1812	The REMOTE is read in the minibuffer.
	1813
	1814	This command simply runs \"git push -v [ARGS] REMOTE\". ARGS
	1815	are the arguments specified in the popup buffer. No refspec
	1816	arguments are used. Instead the behavior depends on at least
	1817	these Git variables: `push.default', `remote.pushDefault',
	1818	`branch.<branch>.pushRemote', `branch.<branch>.remote',
	1819	`branch.<branch>.merge', and `remote.<remote>.push'.
	1820
	1821	To add this command to the push popup add this to your init file:
	1822
	1823	(with-eval-after-load \\='magit-remote
	1824	(magit-define-popup-action \\='magit-push-popup ?r
	1825	\\='magit-push-to-remote--desc
	1826	\\='magit-push-to-remote ?p t))
	1827
	1828	\(fn REMOTE ARGS)" t nil)
	1829
	1830	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-push" '("magit-")))
	1831
	1832	;;;***
	1833
	1834	;;;### (autoloads nil "magit-refs" "magit-refs.el" (0 0 0 0))
	1835	;;; Generated autoloads from magit-refs.el
	1836
	1837	(autoload 'magit-show-refs-popup "magit-refs" "\
	1838	Popup console for `magit-show-refs'.
	1839
	1840	\(fn &optional ARG)" t nil)
	1841
	1842	(autoload 'magit-show-refs-head "magit-refs" "\
	1843	List and compare references in a dedicated buffer.
	1844	Refs are compared with `HEAD'.
	1845
	1846	\(fn &optional ARGS)" t nil)
	1847
	1848	(autoload 'magit-show-refs-current "magit-refs" "\
	1849	List and compare references in a dedicated buffer.
	1850	Refs are compared with the current branch or `HEAD' if
	1851	it is detached.
	1852
	1853	\(fn &optional ARGS)" t nil)
	1854
	1855	(autoload 'magit-show-refs "magit-refs" "\
	1856	List and compare references in a dedicated buffer.
	1857	Refs are compared with a branch read from the user.
	1858
	1859	\(fn &optional REF ARGS)" t nil)
	1860
	1861	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-refs" '("magit-")))
	1862
	1863	;;;***
	1864
	1865	;;;### (autoloads nil "magit-remote" "magit-remote.el" (0 0 0 0))
	1866	;;; Generated autoloads from magit-remote.el
	1867	(autoload 'magit-remote-popup "magit-remote" nil t)
	1868
	1869	(autoload 'magit-remote-add "magit-remote" "\
	1870	Add a remote named REMOTE and fetch it.
	1871
	1872	\(fn REMOTE URL &optional ARGS)" t nil)
	1873
	1874	(autoload 'magit-remote-rename "magit-remote" "\
	1875	Rename the remote named OLD to NEW.
	1876
	1877	\(fn OLD NEW)" t nil)
	1878
	1879	(autoload 'magit-remote-remove "magit-remote" "\
	1880	Delete the remote named REMOTE.
	1881
	1882	\(fn REMOTE)" t nil)
	1883
	1884	(autoload 'magit-remote-prune "magit-remote" "\
	1885	Remove stale remote-tracking branches for REMOTE.
	1886
	1887	\(fn REMOTE)" t nil)
	1888
	1889	(autoload 'magit-remote-prune-refspecs "magit-remote" "\
	1890	Remove stale refspecs for REMOTE.
	1891
	1892	A refspec is stale if there no longer exists at least one branch
	1893	on the remote that would be fetched due to that refspec. A stale
	1894	refspec is problematic because its existence causes Git to refuse
	1895	to fetch according to the remaining non-stale refspecs.
	1896
	1897	If only stale refspecs remain, then offer to either delete the
	1898	remote or to replace the stale refspecs with the default refspec.
	1899
	1900	Also remove the remote-tracking branches that were created due to
	1901	the now stale refspecs. Other stale branches are not removed.
	1902
	1903	\(fn REMOTE)" t nil)
	1904
	1905	(autoload 'magit-remote-set-head "magit-remote" "\
	1906	Set the local representation of REMOTE's default branch.
	1907	Query REMOTE and set the symbolic-ref refs/remotes/<remote>/HEAD
	1908	accordingly. With a prefix argument query for the branch to be
	1909	used, which allows you to select an incorrect value if you fancy
	1910	doing that.
	1911
	1912	\(fn REMOTE &optional BRANCH)" t nil)
	1913
	1914	(autoload 'magit-remote-unset-head "magit-remote" "\
	1915	Unset the local representation of REMOTE's default branch.
	1916	Delete the symbolic-ref \"refs/remotes/<remote>/HEAD\".
	1917
	1918	\(fn REMOTE)" t nil)
	1919
	1920	(autoload 'magit-remote-config-popup "magit-remote" "\
	1921	Popup console for setting remote variables.
	1922
	1923	\(fn REMOTE)" t nil)
	1924
	1925	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-remote" '("magit-")))
	1926
	1927	;;;***
	1928
	1929	;;;### (autoloads nil "magit-repos" "magit-repos.el" (0 0 0 0))
	1930	;;; Generated autoloads from magit-repos.el
	1931
	1932	(autoload 'magit-list-repositories "magit-repos" "\
	1933	Display a list of repositories.
	1934
	1935	Use the options `magit-repository-directories' to control which
	1936	repositories are displayed.
	1937
	1938	\(fn)" t nil)
	1939
	1940	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-repos" '("magit-")))
	1941
	1942	;;;***
	1943
	1944	;;;### (autoloads nil "magit-reset" "magit-reset.el" (0 0 0 0))
	1945	;;; Generated autoloads from magit-reset.el
	1946	(autoload 'magit-reset-popup "magit" nil t)
	1947
	1948	(autoload 'magit-reset-mixed "magit-reset" "\
	1949	Reset the `HEAD' and index to COMMIT, but not the working tree.
	1950
	1951	\(git reset --mixed COMMIT)
	1952
	1953	\(fn COMMIT)" t nil)
	1954
	1955	(autoload 'magit-reset-soft "magit-reset" "\
	1956	Reset the `HEAD' to COMMIT, but not the index and working tree.
	1957
	1958	\(git reset --soft REVISION)
	1959
	1960	\(fn COMMIT)" t nil)
	1961
	1962	(autoload 'magit-reset-hard "magit-reset" "\
	1963	Reset the `HEAD', index, and working tree to COMMIT.
	1964
	1965	\(git reset --hard REVISION)
	1966
	1967	\(fn COMMIT)" t nil)
	1968
	1969	(autoload 'magit-reset-index "magit-reset" "\
	1970	Reset the index to COMMIT.
	1971	Keep the `HEAD' and working tree as-is, so if COMMIT refers to the
	1972	head this effectively unstages all changes.
	1973
	1974	\(git reset COMMIT .)
	1975
	1976	\(fn COMMIT)" t nil)
	1977
	1978	(autoload 'magit-reset-worktree "magit-reset" "\
	1979	Reset the worktree to COMMIT.
	1980	Keep the `HEAD' and index as-is.
	1981
	1982	\(fn COMMIT)" t nil)
	1983
	1984	(autoload 'magit-reset-quickly "magit-reset" "\
	1985	Reset the `HEAD' and index to COMMIT, and possibly the working tree.
	1986	With a prefix argument reset the working tree otherwise don't.
	1987
	1988	\(git reset --mixed\|--hard COMMIT)
	1989
	1990	\(fn COMMIT &optional HARD)" t nil)
	1991
	1992	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-reset" '("magit-reset-")))
	1993
	1994	;;;***
	1995
	1996	;;;### (autoloads nil "magit-section" "magit-section.el" (0 0 0 0))
	1997	;;; Generated autoloads from magit-section.el
	1998
	1999	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-section" '("magit-")))
	2000
	2001	;;;***
	2002
	2003	;;;### (autoloads nil "magit-sequence" "magit-sequence.el" (0 0 0
	2004	;;;;;; 0))
	2005	;;; Generated autoloads from magit-sequence.el
	2006
	2007	(autoload 'magit-sequencer-continue "magit-sequence" "\
	2008	Resume the current cherry-pick or revert sequence.
	2009
	2010	\(fn)" t nil)
	2011
	2012	(autoload 'magit-sequencer-skip "magit-sequence" "\
	2013	Skip the stopped at commit during a cherry-pick or revert sequence.
	2014
	2015	\(fn)" t nil)
	2016
	2017	(autoload 'magit-sequencer-abort "magit-sequence" "\
	2018	Abort the current cherry-pick or revert sequence.
	2019	This discards all changes made since the sequence started.
	2020
	2021	\(fn)" t nil)
	2022	(autoload 'magit-cherry-pick-popup "magit-sequence" nil t)
	2023
	2024	(autoload 'magit-cherry-copy "magit-sequence" "\
	2025	Copy COMMITS from another branch onto the current branch.
	2026	Prompt for a commit, defaulting to the commit at point. If
	2027	the region selects multiple commits, then pick all of them,
	2028	without prompting.
	2029
	2030	\(fn COMMITS &optional ARGS)" t nil)
	2031
	2032	(autoload 'magit-cherry-apply "magit-sequence" "\
	2033	Apply the changes in COMMITS but do not commit them.
	2034	Prompt for a commit, defaulting to the commit at point. If
	2035	the region selects multiple commits, then apply all of them,
	2036	without prompting.
	2037
	2038	\(fn COMMITS &optional ARGS)" t nil)
	2039
	2040	(autoload 'magit-cherry-harvest "magit-sequence" "\
	2041	Move COMMITS from another BRANCH onto the current branch.
	2042	Remove the COMMITS from BRANCH and stay on the current branch.
	2043	If a conflict occurs, then you have to fix that and finish the
	2044	process manually.
	2045
	2046	\(fn COMMITS BRANCH &optional ARGS)" t nil)
	2047
	2048	(autoload 'magit-cherry-donate "magit-sequence" "\
	2049	Move COMMITS from the current branch onto another existing BRANCH.
	2050	Remove COMMITS from the current branch and stay on that branch.
	2051	If a conflict occurs, then you have to fix that and finish the
	2052	process manually.
	2053
	2054	\(fn COMMITS BRANCH &optional ARGS)" t nil)
	2055
	2056	(autoload 'magit-cherry-spinout "magit-sequence" "\
	2057	Move COMMITS from the current branch onto a new BRANCH.
	2058	Remove COMMITS from the current branch and stay on that branch.
	2059	If a conflict occurs, then you have to fix that and finish the
	2060	process manually.
	2061
	2062	\(fn COMMITS BRANCH START-POINT &optional ARGS)" t nil)
	2063
	2064	(autoload 'magit-cherry-spinoff "magit-sequence" "\
	2065	Move COMMITS from the current branch onto a new BRANCH.
	2066	Remove COMMITS from the current branch and checkout BRANCH.
	2067	If a conflict occurs, then you have to fix that and finish
	2068	the process manually.
	2069
	2070	\(fn COMMITS BRANCH START-POINT &optional ARGS)" t nil)
	2071	(autoload 'magit-revert-popup "magit-sequence" nil t)
	2072
	2073	(autoload 'magit-revert-and-commit "magit-sequence" "\
	2074	Revert COMMIT by creating a new commit.
	2075	Prompt for a commit, defaulting to the commit at point. If
	2076	the region selects multiple commits, then revert all of them,
	2077	without prompting.
	2078
	2079	\(fn COMMIT &optional ARGS)" t nil)
	2080
	2081	(autoload 'magit-revert-no-commit "magit-sequence" "\
	2082	Revert COMMIT by applying it in reverse to the worktree.
	2083	Prompt for a commit, defaulting to the commit at point. If
	2084	the region selects multiple commits, then revert all of them,
	2085	without prompting.
	2086
	2087	\(fn COMMIT &optional ARGS)" t nil)
	2088	(autoload 'magit-am-popup "magit-sequence" nil t)
	2089
	2090	(autoload 'magit-am-apply-patches "magit-sequence" "\
	2091	Apply the patches FILES.
	2092
	2093	\(fn &optional FILES ARGS)" t nil)
	2094
	2095	(autoload 'magit-am-apply-maildir "magit-sequence" "\
	2096	Apply the patches from MAILDIR.
	2097
	2098	\(fn &optional MAILDIR ARGS)" t nil)
	2099
	2100	(autoload 'magit-am-continue "magit-sequence" "\
	2101	Resume the current patch applying sequence.
	2102
	2103	\(fn)" t nil)
	2104
	2105	(autoload 'magit-am-skip "magit-sequence" "\
	2106	Skip the stopped at patch during a patch applying sequence.
	2107
	2108	\(fn)" t nil)
	2109
	2110	(autoload 'magit-am-abort "magit-sequence" "\
	2111	Abort the current patch applying sequence.
	2112	This discards all changes made since the sequence started.
	2113
	2114	\(fn)" t nil)
	2115	(autoload 'magit-rebase-popup "magit-sequence" nil t)
	2116
	2117	(autoload 'magit-rebase-onto-pushremote "magit-sequence" "\
	2118	Rebase the current branch onto `branch.<name>.pushRemote'.
	2119	If that variable is unset, then rebase onto `remote.pushDefault'.
	2120
	2121	\(fn ARGS)" t nil)
	2122
	2123	(autoload 'magit-rebase-onto-upstream "magit-sequence" "\
	2124	Rebase the current branch onto its upstream branch.
	2125
	2126	\(fn ARGS)" t nil)
	2127
	2128	(autoload 'magit-rebase-branch "magit-sequence" "\
	2129	Rebase the current branch onto a branch read in the minibuffer.
	2130	All commits that are reachable from `HEAD' but not from the
	2131	selected branch TARGET are being rebased.
	2132
	2133	\(fn TARGET ARGS)" t nil)
	2134
	2135	(autoload 'magit-rebase-subset "magit-sequence" "\
	2136	Rebase a subset of the current branch's history onto a new base.
	2137	Rebase commits from START to `HEAD' onto NEWBASE.
	2138	START has to be selected from a list of recent commits.
	2139
	2140	\(fn NEWBASE START ARGS)" t nil)
	2141
	2142	(autoload 'magit-rebase-interactive "magit-sequence" "\
	2143	Start an interactive rebase sequence.
	2144
	2145	\(fn COMMIT ARGS)" t nil)
	2146
	2147	(autoload 'magit-rebase-autosquash "magit-sequence" "\
	2148	Combine squash and fixup commits with their intended targets.
	2149
	2150	\(fn ARGS)" t nil)
	2151
	2152	(autoload 'magit-rebase-edit-commit "magit-sequence" "\
	2153	Edit a single older commit using rebase.
	2154
	2155	\(fn COMMIT ARGS)" t nil)
	2156
	2157	(autoload 'magit-rebase-reword-commit "magit-sequence" "\
	2158	Reword a single older commit using rebase.
	2159
	2160	\(fn COMMIT ARGS)" t nil)
	2161
	2162	(autoload 'magit-rebase-remove-commit "magit-sequence" "\
	2163	Remove a single older commit using rebase.
	2164
	2165	\(fn COMMIT ARGS)" t nil)
	2166
	2167	(autoload 'magit-rebase-continue "magit-sequence" "\
	2168	Restart the current rebasing operation.
	2169	In some cases this pops up a commit message buffer for you do
	2170	edit. With a prefix argument the old message is reused as-is.
	2171
	2172	\(fn &optional NOEDIT)" t nil)
	2173
	2174	(autoload 'magit-rebase-skip "magit-sequence" "\
	2175	Skip the current commit and restart the current rebase operation.
	2176
	2177	\(fn)" t nil)
	2178
	2179	(autoload 'magit-rebase-edit "magit-sequence" "\
	2180	Edit the todo list of the current rebase operation.
	2181
	2182	\(fn)" t nil)
	2183
	2184	(autoload 'magit-rebase-abort "magit-sequence" "\
	2185	Abort the current rebase operation, restoring the original branch.
	2186
	2187	\(fn)" t nil)
	2188
	2189	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-sequence" '("magit-")))
	2190
	2191	;;;***
	2192
	2193	;;;### (autoloads nil "magit-stash" "magit-stash.el" (0 0 0 0))
	2194	;;; Generated autoloads from magit-stash.el
	2195	(autoload 'magit-stash-popup "magit-stash" nil t)
	2196
	2197	(autoload 'magit-stash-both "magit-stash" "\
	2198	Create a stash of the index and working tree.
	2199	Untracked files are included according to popup arguments.
	2200	One prefix argument is equivalent to `--include-untracked'
	2201	while two prefix arguments are equivalent to `--all'.
	2202
	2203	\(fn MESSAGE &optional INCLUDE-UNTRACKED)" t nil)
	2204
	2205	(autoload 'magit-stash-index "magit-stash" "\
	2206	Create a stash of the index only.
	2207	Unstaged and untracked changes are not stashed. The stashed
	2208	changes are applied in reverse to both the index and the
	2209	worktree. This command can fail when the worktree is not clean.
	2210	Applying the resulting stash has the inverse effect.
	2211
	2212	\(fn MESSAGE)" t nil)
	2213
	2214	(autoload 'magit-stash-worktree "magit-stash" "\
	2215	Create a stash of unstaged changes in the working tree.
	2216	Untracked files are included according to popup arguments.
	2217	One prefix argument is equivalent to `--include-untracked'
	2218	while two prefix arguments are equivalent to `--all'.
	2219
	2220	\(fn MESSAGE &optional INCLUDE-UNTRACKED)" t nil)
	2221
	2222	(autoload 'magit-stash-keep-index "magit-stash" "\
	2223	Create a stash of the index and working tree, keeping index intact.
	2224	Untracked files are included according to popup arguments.
	2225	One prefix argument is equivalent to `--include-untracked'
	2226	while two prefix arguments are equivalent to `--all'.
	2227
	2228	\(fn MESSAGE &optional INCLUDE-UNTRACKED)" t nil)
	2229
	2230	(autoload 'magit-snapshot-both "magit-stash" "\
	2231	Create a snapshot of the index and working tree.
	2232	Untracked files are included according to popup arguments.
	2233	One prefix argument is equivalent to `--include-untracked'
	2234	while two prefix arguments are equivalent to `--all'.
	2235
	2236	\(fn &optional INCLUDE-UNTRACKED)" t nil)
	2237
	2238	(autoload 'magit-snapshot-index "magit-stash" "\
	2239	Create a snapshot of the index only.
	2240	Unstaged and untracked changes are not stashed.
	2241
	2242	\(fn)" t nil)
	2243
	2244	(autoload 'magit-snapshot-worktree "magit-stash" "\
	2245	Create a snapshot of unstaged changes in the working tree.
	2246	Untracked files are included according to popup arguments.
	2247	One prefix argument is equivalent to `--include-untracked'
	2248	while two prefix arguments are equivalent to `--all'.
	2249
	2250	\(fn &optional INCLUDE-UNTRACKED)" t nil)
	2251
	2252	(autoload 'magit-stash-apply "magit-stash" "\
	2253	Apply a stash to the working tree.
	2254	Try to preserve the stash index. If that fails because there
	2255	are staged changes, apply without preserving the stash index.
	2256
	2257	\(fn STASH)" t nil)
	2258
	2259	(autoload 'magit-stash-drop "magit-stash" "\
	2260	Remove a stash from the stash list.
	2261	When the region is active offer to drop all contained stashes.
	2262
	2263	\(fn STASH)" t nil)
	2264
	2265	(autoload 'magit-stash-clear "magit-stash" "\
	2266	Remove all stashes saved in REF's reflog by deleting REF.
	2267
	2268	\(fn REF)" t nil)
	2269
	2270	(autoload 'magit-stash-branch "magit-stash" "\
	2271	Create and checkout a new BRANCH from STASH.
	2272
	2273	\(fn STASH BRANCH)" t nil)
	2274
	2275	(autoload 'magit-stash-branch-here "magit-stash" "\
	2276	Create and checkout a new BRANCH and apply STASH.
	2277	The branch is created using `magit-branch', using the current
	2278	branch or `HEAD' as the string-point.
	2279
	2280	\(fn STASH BRANCH)" t nil)
	2281
	2282	(autoload 'magit-stash-format-patch "magit-stash" "\
	2283	Create a patch from STASH
	2284
	2285	\(fn STASH)" t nil)
	2286
	2287	(autoload 'magit-stash-list "magit-stash" "\
	2288	List all stashes in a buffer.
	2289
	2290	\(fn)" t nil)
	2291
	2292	(autoload 'magit-stash-show "magit-stash" "\
	2293	Show all diffs of a stash in a buffer.
	2294
	2295	\(fn STASH &optional ARGS FILES)" t nil)
	2296
	2297	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-stash" '("magit-")))
	2298
	2299	;;;***
	2300
	2301	;;;### (autoloads nil "magit-status" "magit-status.el" (0 0 0 0))
	2302	;;; Generated autoloads from magit-status.el
	2303
	2304	(autoload 'magit-init "magit-status" "\
	2305	Initialize a Git repository, then show its status.
	2306
	2307	If the directory is below an existing repository, then the user
	2308	has to confirm that a new one should be created inside. If the
	2309	directory is the root of the existing repository, then the user
	2310	has to confirm that it should be reinitialized.
	2311
	2312	Non-interactively DIRECTORY is (re-)initialized unconditionally.
	2313
	2314	\(fn DIRECTORY)" t nil)
	2315
	2316	(autoload 'magit-status "magit-status" "\
	2317	Show the status of the current Git repository in a buffer.
	2318	With a prefix argument prompt for a repository to be shown.
	2319	With two prefix arguments prompt for an arbitrary directory.
	2320	If that directory isn't the root of an existing repository,
	2321	then offer to initialize it as a new repository.
	2322
	2323	\(fn &optional DIRECTORY CACHE)" t nil)
	2324
	2325	(autoload 'magit-status-internal "magit-status" "\
	2326
	2327
	2328	\(fn DIRECTORY)" nil nil)
	2329
	2330	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-status" '("magit")))
	2331
	2332	;;;***
	2333
	2334	;;;### (autoloads nil "magit-submodule" "magit-submodule.el" (0 0
	2335	;;;;;; 0 0))
	2336	;;; Generated autoloads from magit-submodule.el
	2337	(autoload 'magit-submodule-popup "magit-submodule" nil t)
	2338
	2339	(autoload 'magit-submodule-add "magit-submodule" "\
	2340	Add the repository at URL as a module.
	2341
	2342	Optional PATH is the path to the module relative to the root of
	2343	the superproject. If it is nil, then the path is determined
	2344	based on the URL. Optional NAME is the name of the module. If
	2345	it is nil, then PATH also becomes the name.
	2346
	2347	\(fn URL &optional PATH NAME ARGS)" t nil)
	2348
	2349	(autoload 'magit-submodule-read-name-for-path "magit-submodule" "\
	2350
	2351
	2352	\(fn PATH &optional PREFER-SHORT)" nil nil)
	2353
	2354	(autoload 'magit-submodule-register "magit-submodule" "\
	2355	Register MODULES.
	2356
	2357	With a prefix argument act on all suitable modules. Otherwise,
	2358	if the region selects modules, then act on those. Otherwise, if
	2359	there is a module at point, then act on that. Otherwise read a
	2360	single module from the user.
	2361
	2362	\(fn MODULES)" t nil)
	2363
	2364	(autoload 'magit-submodule-populate "magit-submodule" "\
	2365	Create MODULES working directories, checking out the recorded commits.
	2366
	2367	With a prefix argument act on all suitable modules. Otherwise,
	2368	if the region selects modules, then act on those. Otherwise, if
	2369	there is a module at point, then act on that. Otherwise read a
	2370	single module from the user.
	2371
	2372	\(fn MODULES)" t nil)
	2373
	2374	(autoload 'magit-submodule-update "magit-submodule" "\
	2375	Update MODULES by checking out the recorded commits.
	2376
	2377	With a prefix argument act on all suitable modules. Otherwise,
	2378	if the region selects modules, then act on those. Otherwise, if
	2379	there is a module at point, then act on that. Otherwise read a
	2380	single module from the user.
	2381
	2382	\(fn MODULES ARGS)" t nil)
	2383
	2384	(autoload 'magit-submodule-synchronize "magit-submodule" "\
	2385	Synchronize url configuration of MODULES.
	2386
	2387	With a prefix argument act on all suitable modules. Otherwise,
	2388	if the region selects modules, then act on those. Otherwise, if
	2389	there is a module at point, then act on that. Otherwise read a
	2390	single module from the user.
	2391
	2392	\(fn MODULES ARGS)" t nil)
	2393
	2394	(autoload 'magit-submodule-unpopulate "magit-submodule" "\
	2395	Remove working directories of MODULES.
	2396
	2397	With a prefix argument act on all suitable modules. Otherwise,
	2398	if the region selects modules, then act on those. Otherwise, if
	2399	there is a module at point, then act on that. Otherwise read a
	2400	single module from the user.
	2401
	2402	\(fn MODULES ARGS)" t nil)
	2403
	2404	(autoload 'magit-submodule-remove "magit-submodule" "\
	2405	Unregister MODULES and remove their working directories.
	2406
	2407	For safety reasons, do not remove the gitdirs and if a module has
	2408	uncomitted changes, then do not remove it at all. If a module's
	2409	gitdir is located inside the working directory, then move it into
	2410	the gitdir of the superproject first.
	2411
	2412	With the \"--force\" argument offer to remove dirty working
	2413	directories and with a prefix argument offer to delete gitdirs.
	2414	Both actions are very dangerous and have to be confirmed. There
	2415	are additional safety precautions in place, so you might be able
	2416	to recover from making a mistake here, but don't count on it.
	2417
	2418	\(fn MODULES ARGS TRASH-GITDIRS)" t nil)
	2419
	2420	(autoload 'magit-insert-modules "magit-submodule" "\
	2421	Insert submodule sections.
	2422	Hook `magit-module-sections-hook' controls which module sections
	2423	are inserted, and option `magit-module-sections-nested' controls
	2424	whether they are wrapped in an additional section.
	2425
	2426	\(fn)" nil nil)
	2427
	2428	(autoload 'magit-insert-modules-overview "magit-submodule" "\
	2429	Insert sections for all modules.
	2430	For each section insert the path and the output of `git describe --tags',
	2431	or, failing that, the abbreviated HEAD commit hash.
	2432
	2433	\(fn)" nil nil)
	2434
	2435	(autoload 'magit-insert-modules-unpulled-from-upstream "magit-submodule" "\
	2436	Insert sections for modules that haven't been pulled from the upstream.
	2437	These sections can be expanded to show the respective commits.
	2438
	2439	\(fn)" nil nil)
	2440
	2441	(autoload 'magit-insert-modules-unpulled-from-pushremote "magit-submodule" "\
	2442	Insert sections for modules that haven't been pulled from the push-remote.
	2443	These sections can be expanded to show the respective commits.
	2444
	2445	\(fn)" nil nil)
	2446
	2447	(autoload 'magit-insert-modules-unpushed-to-upstream "magit-submodule" "\
	2448	Insert sections for modules that haven't been pushed to the upstream.
	2449	These sections can be expanded to show the respective commits.
	2450
	2451	\(fn)" nil nil)
	2452
	2453	(autoload 'magit-insert-modules-unpushed-to-pushremote "magit-submodule" "\
	2454	Insert sections for modules that haven't been pushed to the push-remote.
	2455	These sections can be expanded to show the respective commits.
	2456
	2457	\(fn)" nil nil)
	2458
	2459	(autoload 'magit-list-submodules "magit-submodule" "\
	2460	Display a list of the current repository's submodules.
	2461
	2462	\(fn)" t nil)
	2463
	2464	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-submodule" '("magit-")))
	2465
	2466	;;;***
	2467
	2468	;;;### (autoloads nil "magit-subtree" "magit-subtree.el" (0 0 0 0))
	2469	;;; Generated autoloads from magit-subtree.el
	2470	(autoload 'magit-subtree-popup "magit-subtree" nil t)
	2471
	2472	(autoload 'magit-subtree-add "magit-subtree" "\
	2473	Add REF from REPOSITORY as a new subtree at PREFIX.
	2474
	2475	\(fn PREFIX REPOSITORY REF ARGS)" t nil)
	2476
	2477	(autoload 'magit-subtree-add-commit "magit-subtree" "\
	2478	Add COMMIT as a new subtree at PREFIX.
	2479
	2480	\(fn PREFIX COMMIT ARGS)" t nil)
	2481
	2482	(autoload 'magit-subtree-merge "magit-subtree" "\
	2483	Merge COMMIT into the PREFIX subtree.
	2484
	2485	\(fn PREFIX COMMIT ARGS)" t nil)
	2486
	2487	(autoload 'magit-subtree-pull "magit-subtree" "\
	2488	Pull REF from REPOSITORY into the PREFIX subtree.
	2489
	2490	\(fn PREFIX REPOSITORY REF ARGS)" t nil)
	2491
	2492	(autoload 'magit-subtree-push "magit-subtree" "\
	2493	Extract the history of the subtree PREFIX and push it to REF on REPOSITORY.
	2494
	2495	\(fn PREFIX REPOSITORY REF ARGS)" t nil)
	2496
	2497	(autoload 'magit-subtree-split "magit-subtree" "\
	2498	Extract the history of the subtree PREFIX.
	2499
	2500	\(fn PREFIX COMMIT ARGS)" t nil)
	2501
	2502	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-subtree" '("magit-")))
	2503
	2504	;;;***
	2505
	2506	;;;### (autoloads nil "magit-tag" "magit-tag.el" (0 0 0 0))
	2507	;;; Generated autoloads from magit-tag.el
	2508	(autoload 'magit-tag-popup "magit" nil t)
	2509
	2510	(autoload 'magit-tag-create "magit-tag" "\
	2511	Create a new tag with the given NAME at REV.
	2512	With a prefix argument annotate the tag.
	2513
	2514	\(git tag [--annotate] NAME REV)
	2515
	2516	\(fn NAME REV &optional ARGS)" t nil)
	2517
	2518	(autoload 'magit-tag-delete "magit-tag" "\
	2519	Delete one or more tags.
	2520	If the region marks multiple tags (and nothing else), then offer
	2521	to delete those, otherwise prompt for a single tag to be deleted,
	2522	defaulting to the tag at point.
	2523
	2524	\(git tag -d TAGS)
	2525
	2526	\(fn TAGS)" t nil)
	2527
	2528	(autoload 'magit-tag-prune "magit-tag" "\
	2529	Offer to delete tags missing locally from REMOTE, and vice versa.
	2530
	2531	\(fn TAGS REMOTE-TAGS REMOTE)" t nil)
	2532
	2533	(autoload 'magit-tag-release "magit-tag" "\
	2534	Create an opinionated release tag.
	2535
	2536	Assume version tags that match \"\\\\`v?[0-9]\\\$\\\\.[0-9]\\\$*\\\\'\".
	2537	Prompt for the name of the new tag using the highest existing tag
	2538	as initial input and call \"git tag --annotate --sign -m MSG\" TAG,
	2539	regardless of whether these arguments are enabled in the popup.
	2540	Given a TAG \"v1.2.3\" and a repository \"/path/to/foo-bar\", the
	2541	MESSAGE would be \"Foo-Bar 1.2.3\".
	2542
	2543	Because it is so opinionated, this command is not available from
	2544	the tag popup by default.
	2545
	2546	\(fn TAG)" t nil)
	2547
	2548	;;;***
	2549
	2550	;;;### (autoloads nil "magit-utils" "magit-utils.el" (0 0 0 0))
	2551	;;; Generated autoloads from magit-utils.el
	2552
	2553	(autoload 'magit-emacs-Q-command "magit-utils" "\
	2554	Show a shell command that runs an uncustomized Emacs with only Magit loaded.
	2555	See info node `(magit)Debugging Tools' for more information.
	2556
	2557	\(fn)" t nil)
	2558
	2559	(autoload 'Info-follow-nearest-node--magit-gitman "magit-utils" "\
	2560
	2561
	2562	\(fn FN &optional FORK)" nil nil)
	2563
	2564	(advice-add 'Info-follow-nearest-node :around 'Info-follow-nearest-node--magit-gitman)
	2565
	2566	(autoload 'org-man-export--magit-gitman "magit-utils" "\
	2567
	2568
	2569	\(fn FN LINK DESCRIPTION FORMAT)" nil nil)
	2570
	2571	(advice-add 'org-man-export :around 'org-man-export--magit-gitman)
	2572
	2573	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-utils" '("magit-" "whitespace-dont-turn-on-in-magit-mode")))
	2574
	2575	;;;***
	2576
	2577	;;;### (autoloads nil "magit-wip" "magit-wip.el" (0 0 0 0))
	2578	;;; Generated autoloads from magit-wip.el
	2579
	2580	(defvar magit-wip-after-save-mode nil "\
	2581	Non-nil if Magit-Wip-After-Save mode is enabled.
	2582	See the `magit-wip-after-save-mode' command
	2583	for a description of this minor mode.
	2584	Setting this variable directly does not take effect;
	2585	either customize it (see the info node `Easy Customization')
	2586	or call the function `magit-wip-after-save-mode'.")
	2587
	2588	(custom-autoload 'magit-wip-after-save-mode "magit-wip" nil)
	2589
	2590	(autoload 'magit-wip-after-save-mode "magit-wip" "\
	2591	Toggle Magit-Wip-After-Save-Local mode in all buffers.
	2592	With prefix ARG, enable Magit-Wip-After-Save mode if ARG is positive;
	2593	otherwise, disable it. If called from Lisp, enable the mode if
	2594	ARG is omitted or nil.
	2595
	2596	Magit-Wip-After-Save-Local mode is enabled in all buffers where
	2597	`magit-wip-after-save-local-mode-turn-on' would do it.
	2598	See `magit-wip-after-save-local-mode' for more information on Magit-Wip-After-Save-Local mode.
	2599
	2600	\(fn &optional ARG)" t nil)
	2601
	2602	(defvar magit-wip-after-apply-mode nil "\
	2603	Non-nil if Magit-Wip-After-Apply mode is enabled.
	2604	See the `magit-wip-after-apply-mode' command
	2605	for a description of this minor mode.")
	2606
	2607	(custom-autoload 'magit-wip-after-apply-mode "magit-wip" nil)
	2608
	2609	(autoload 'magit-wip-after-apply-mode "magit-wip" "\
	2610	Commit to work-in-progress refs.
	2611
	2612	After applying a change using any \"apply variant\"
	2613	command (apply, stage, unstage, discard, and reverse) commit the
	2614	affected files to the current wip refs. For each branch there
	2615	may be two wip refs; one contains snapshots of the files as found
	2616	in the worktree and the other contains snapshots of the entries
	2617	in the index.
	2618
	2619	\(fn &optional ARG)" t nil)
	2620
	2621	(defvar magit-wip-before-change-mode nil "\
	2622	Non-nil if Magit-Wip-Before-Change mode is enabled.
	2623	See the `magit-wip-before-change-mode' command
	2624	for a description of this minor mode.")
	2625
	2626	(custom-autoload 'magit-wip-before-change-mode "magit-wip" nil)
	2627
	2628	(autoload 'magit-wip-before-change-mode "magit-wip" "\
	2629	Commit to work-in-progress refs before certain destructive changes.
	2630
	2631	Before invoking a revert command or an \"apply variant\"
	2632	command (apply, stage, unstage, discard, and reverse) commit the
	2633	affected tracked files to the current wip refs. For each branch
	2634	there may be two wip refs; one contains snapshots of the files
	2635	as found in the worktree and the other contains snapshots of the
	2636	entries in the index.
	2637
	2638	Only changes to files which could potentially be affected by the
	2639	command which is about to be called are committed.
	2640
	2641	\(fn &optional ARG)" t nil)
	2642
	2643	(autoload 'magit-wip-commit-initial-backup "magit-wip" "\
	2644	Before saving, commit current file to a worktree wip ref.
	2645
	2646	The user has to add this function to `before-save-hook'.
	2647
	2648	Commit the current state of the visited file before saving the
	2649	current buffer to that file. This backs up the same version of
	2650	the file as `backup-buffer' would, but stores the backup in the
	2651	worktree wip ref, which is also used by the various Magit Wip
	2652	modes, instead of in a backup file as `backup-buffer' would.
	2653
	2654	This function ignores the variables that affect `backup-buffer'
	2655	and can be used along-side that function, which is recommended
	2656	because this function only backs up files that are tracked in
	2657	a Git repository.
	2658
	2659	\(fn)" nil nil)
	2660
	2661	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-wip" '("magit-")))
	2662
	2663	;;;***
	2664
	2665	;;;### (autoloads nil "magit-worktree" "magit-worktree.el" (0 0 0
	2666	;;;;;; 0))
	2667	;;; Generated autoloads from magit-worktree.el
	2668	(autoload 'magit-worktree-popup "magit-worktree" nil t)
	2669
	2670	(autoload 'magit-worktree-checkout "magit-worktree" "\
	2671	Checkout BRANCH in a new worktree at PATH.
	2672
	2673	\(fn PATH BRANCH)" t nil)
	2674
	2675	(autoload 'magit-worktree-branch "magit-worktree" "\
	2676	Create a new BRANCH and check it out in a new worktree at PATH.
	2677
	2678	\(fn PATH BRANCH START-POINT &optional FORCE)" t nil)
	2679
	2680	(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-worktree" '("magit-")))
	2681
	2682	;;;***
	2683
	2684	;;;### (autoloads nil nil ("magit-core.el" "magit-obsolete.el" "magit-pkg.el")
	2685	;;;;;; (0 0 0 0))
	2686
	2687	;;;***
	2688
	2689	;; Local Variables:
	2690	;; version-control: never
	2691	;; no-byte-compile: t
	2692	;; no-update-autoloads: t
	2693	;; coding: utf-8
	2694	;; End:
	2695	;;; magit-autoloads.el ends here