;ELC   
;;; Compiled
;;; in Emacs version 28.0.50
;;; with all optimizations.


(byte-code "\300\301!\210\302\303\304\305\306\307%\210\310\311\312\313\314DD\315\306\303\316\317\320\321&	\207" [require magit custom-declare-group magit-extras nil "Additional functionality for Magit." :group magit-extensions custom-declare-variable magit-gitk-executable funcall function #[0 "\301=\203 \302\303\304\305\306$\211\205 \307!\205 \211\262\206# \310\311!\206# \311\207" [system-type windows-nt magit-git-string "-c" "alias.X=!x() { which \"$1\" | cygpath -mf -; }; x" "X" "gitk.exe" file-executable-p executable-find "gitk"] 5] "The Gitk executable." :set-after (magit-git-executable) :type string] 10)
#@47 Run `git gui' for the current git repository.
(defalias 'magit-run-git-gui #[0 "\302 \211\203 \211\303	\304\305\304\306%)\207\307 \207" [default-directory magit-git-executable magit-toplevel magit-process-file nil 0 "gui" magit--not-inside-repository-error] 7 (#$ . 710) nil])
#@334 Run `git gui blame' on the given FILENAME and COMMIT.
Interactively run it for the current file and the `HEAD', with a
prefix or when the current file cannot be determined let the user
choose.  When the current buffer is visiting FILENAME instruct
blame to center around the line point is on.

(fn COMMIT FILENAME &optional LINENUM)
(defalias 'magit-run-git-gui-blame #[770 "\302 \211\203& \211\303\304	\305\306\305\307\310\311\n\205 \312\313\f\"CD\"&)\207\314 \207" [default-directory magit-git-executable magit-toplevel apply magit-process-file nil 0 "gui" "blame" append format "--line=%d" magit--not-inside-repository-error] 16 (#$ . 996) (byte-code "\302\211\204 \303\262\304\302\305\"\211\262\204 \306\307!\262\310\311\"\262\211\3121, \304	!0\202. \210\302\232\2054 \313 E\207" [current-prefix-arg buffer-file-name nil "HEAD" magit-file-relative-name tracked magit-read-branch-or-commit "Blame from revision" magit-read-file-from-rev "Blame file" (error) line-number-at-pos] 7)])
#@39 Run `gitk' in the current repository.
(defalias 'magit-run-gitk #[0 "\301\302\303#\207" [magit-gitk-executable magit-process-file nil 0] 4 (#$ . 2007) nil])
#@50 Run `gitk --branches' in the current repository.
(defalias 'magit-run-gitk-branches #[0 "\301\302\303\302\304%\207" [magit-gitk-executable magit-process-file nil 0 "--branches"] 6 (#$ . 2171) nil])
#@45 Run `gitk --all' in the current repository.
(defalias 'magit-run-gitk-all #[0 "\301\302\303\302\304%\207" [magit-gitk-executable magit-process-file nil 0 "--all"] 6 (#$ . 2376) nil])
#@654 Drop into `magit-status' from file switching.

This command does not work in Emacs 26.1.
See https://github.com/magit/magit/issues/3634
and https://debbugs.gnu.org/cgi/bugreport.cgi?bug=31707.

To make this command available use something like:

  (add-hook \='ido-setup-hook
            (lambda ()
              (define-key ido-completion-map
                (kbd "C-x g") \='ido-enter-magit-status)))

Starting with Emacs 25.1 the Ido keymaps are defined just once
instead of every time Ido is invoked, so now you can modify it
like pretty much every other keymap:

  (define-key ido-common-completion-map
    (kbd "C-x g") \='ido-enter-magit-status)
(defalias 'ido-enter-magit-status #[0 "\302\303\211\304 \207" [ido-exit ido-fallback fallback magit-status exit-minibuffer] 3 (#$ . 2567) nil])
#@51 Run `magit-status' in the current project's root.
(defalias 'magit-project-status #[0 "\300\301\302\303!!!\207" [magit-status-setup-buffer project-root project-current t] 4 (#$ . 3373) nil])
#@257 Whether to bind "m" to `magit-project-status' in `project-prefix-map'.
If so, then an entry is added to `project-switch-commands' as
well.  If you want to use another key, then you must set this
to nil before loading Magit to prevent "m" from being bound.
(defvar magit-bind-magit-project-status t (#$ . 3571))
(eval-after-load 'project #[0 "\205+ \303\302!\205+ 	\304\301\305N@\306\"\232\205+ \307\n\310\311#\210\312	\235\203$ 	\207\313	\312C\"\211\207" [magit-bind-magit-project-status project-switch-commands project-prefix-map boundp eval standard-value t define-key "m" magit-project-status (magit-project-status "Magit") append] 4])
#@183 Visit file at point using Dired.
With a prefix argument, visit in another window.  If there
is no file at point, then instead visit `default-directory'.

(fn &optional OTHER-WINDOW)
(defalias 'magit-dired-jump #[256 "\300\301 \211\205 \302\303!\203 \304!\202 !\262\"\207" [dired-jump magit-file-at-point expand-file-name file-directory-p file-name-as-directory] 7 (#$ . 4219) "P"])
#@76 Show log for all marked files, or the current file.

(fn &optional FOLLOW)
(defalias 'magit-dired-log #[256 "\302!\211\203> \303 @\304\305\211\306#\211\204 \307\310!\210\203+ \311\235\204+ \211A\204+ \311B\262\312\313 \2062 \314C\315\316\")	$\207\317 \207" [default-directory magit-log-buffer-file-locked magit-toplevel magit-log-arguments dired-get-marked-files nil magit-file-tracked-p user-error "No marked file is being tracked by Git" "--follow" magit-log-setup-buffer magit-get-current-branch "HEAD" mapcar file-relative-name magit--not-inside-repository-error] 10 (#$ . 4615) "P"])
#@98 Open FILE with `dired-do-async-shell-command'.
Interactively, open the file at point.

(fn FILE)
(defalias 'magit-do-async-shell-command #[257 "\301\302!\210\303\304\305C#\306C#\207" [current-prefix-arg require dired-aux dired-do-async-shell-command dired-read-shell-command "& on %s: " nil] 6 (#$ . 5220) (byte-code "\300 \206\n \301\302\303 \"C\207" [magit-file-at-point completing-read "Act on file: " magit-list-files] 3)])
(defalias 'magit--turn-on-shift-select-mode-p #[0 "\205 	\205 \n?\205 \242\304=?\207" [shift-select-mode this-command-keys-shift-translated mark-active transient-mark-mode only] 2])
#@511 Like `previous-line' but with Magit-specific shift-selection.

Magit's selection mechanism is based on the region but selects an
area that is larger than the region.  This causes `previous-line'
when invoked while holding the shift key to move up one line and
thereby select two lines.  When invoked inside a hunk body this
command does not move point on the first invocation and thereby
it only selects a single line.  Which inconsistency you prefer
is a matter of preference.

(fn &optional ARG TRY-VSCROLL)
(defalias 'magit-previous-line #[512 "\204 \300\262\301 \206 \302 \211\203# \300U\203# \303 \203# \304\305\211\306#\207\307 \210\310\2032 S\300]\2023 \"\207" [1 magit-diff-inside-hunk-body-p magit-section-position-in-heading-p magit--turn-on-shift-select-mode-p push-mark nil t handle-shift-selection previous-line] 7 (#$ . 5845) "p\np"])
(byte-code "\300\301\302\303#\300\207" [function-put magit-previous-line interactive-only "use `forward-line' with negative argument instead."] 4)
#@505 Like `next-line' but with Magit-specific shift-selection.

Magit's selection mechanism is based on the region but selects
an area that is larger than the region.  This causes `next-line'
when invoked while holding the shift key to move down one line
and thereby select two lines.  When invoked inside a hunk body
this command does not move point on the first invocation and
thereby it only selects a single line.  Which inconsistency you
prefer is a matter of preference.

(fn &optional ARG TRY-VSCROLL)
(defalias 'magit-next-line #[512 "\204 \300\262\301 \206 \302 \211\203# \300U\203# \303 \203# \304\305\211\306#\207\307 \210\310\2032 S\300]\2023 \"\207" [1 magit-diff-inside-hunk-body-p magit-section-position-in-heading-p magit--turn-on-shift-select-mode-p push-mark nil t handle-shift-selection next-line] 7 (#$ . 6857) "p\np"])
(byte-code "\300\301\302\303#\300\207" [function-put magit-next-line interactive-only forward-line] 4)
#@197 Remove untracked files from the working tree.
With a prefix argument also remove ignored files,
with two prefix arguments remove ignored files only.

(git clean -f -d [-x|-X])

(fn &optional ARG)
(defalias 'magit-clean #[256 "\300\301\302\303\267\202 \304\202 \305\202 \306\"!\205. \307 \210\310\311\312\313\314\267\202, \315\202- \316\202- \317$\207" [yes-or-no-p format "Remove %s files? " #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (1 9 4 13)) "untracked" "untracked and ignored" "ignored" magit-wip-commit-before-change magit-run-git "clean" "-f" "-d" #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (4 36 16 40)) "-x" "-X" nil] 7 (#$ . 7811) "p"])
(put 'magit-clean 'disabled t)
#@248 Insert ChangeLog entries into the current buffer.

The entries are generated from the diff being committed.
If prefix argument, AMENDING, is non-nil, include changes
in HEAD as well as staged changes in the diff to check.

(fn &optional AMENDING)
(defalias 'magit-generate-changelog #[256 "\303 \204	 \304\305!\210\306\307!\210\306\310!\210\306\311!\210\312\313!\203! \312\314!\204% \304\315!\210\316\317!\203A \320\321\322\"\204A \320\321\323\"\203A \324\325\317!!\202C \326 \211\203L \327\202M \330\331\332\333 \"\210\313\334\335\336\"r\211q\210\337\340\"\216\341p\342\343\344\345\346\347 \205n \350\n\351&	\210\352\301!\210\343D\352\302!\210\353\314 *\262!\207" [default-directory diff-vc-revisions diff-vc-backend magit-commit-message-buffer user-error "No commit in progress" require diff-mode vc-git add-log fboundp change-log-insert-entries diff-add-log-current-defuns "`magit-generate-changelog' requires Emacs 27 or better" file-regular-p "gitdir" magit-git-true "rev-parse" "--is-inside-work-tree" "--is-inside-git-dir" file-name-directory magit-file-line magit-toplevel "HEAD^1" "HEAD" mapc vc-file-clearprops magit-staged-files generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205	 \302\300!\207" [V0 buffer-name kill-buffer] 2] vc-git-command 1 nil "diff-index" "--exit-code" "--patch" magit-anything-staged-p "--cached" "--" make-local-variable Git] 14 (#$ . 8586) "P"])
#@275 Find change log file and add date entry and item for current change.
This differs from `add-change-log-entry' (which see) in that
it acts on the current hunk in a Magit buffer instead of on
a position in a file-visiting buffer.

(fn &optional WHOAMI FILE-NAME OTHER-WINDOW)
(defalias 'magit-add-change-log-entry #[768 "\301 \211\242\243\211\242\243rq\210\212\214~\210\211\206 \302b\210\303\304\n\n\n#,\207" [add-log-buffer-file-name-function magit-diff-visit-file--noselect 1 #[0 "\206 \301 \207" [magit-buffer-file-name buffer-file-name] 1] add-change-log-entry] 14 (#$ . 9996) (byte-code "\301 D\207" [current-prefix-arg prompt-for-change-log-name] 2)])
#@267 Find change log file in other window and add entry and item.
This differs from `add-change-log-entry-other-window' (which see)
in that it acts on the current hunk in a Magit buffer instead of
on a position in a file-visiting buffer.

(fn &optional WHOAMI FILE-NAME)
(defalias 'magit-add-change-log-entry-other-window #[512 "\300\301#\207" [magit-add-change-log-entry t] 6 (#$ . 10672) (byte-code "\205 \301 D\207" [current-prefix-arg prompt-for-change-log-name] 2)])
#@338 Edit the commit that added the current line.

With a prefix argument edit the commit that removes the line,
if any.  The commit is determined using `git blame' and made
editable using `git rebase --interactive' if it is reachable
from `HEAD', or by checking out the commit (or a branch that
points at it) otherwise.

(fn &optional TYPE)
(defalias 'magit-edit-line-commit #[256 "\305\206 \306!\307\310\"\211\311\232\203 \312\313!\207\314\315\"\316\307\317\"\320 \"\2031 \321\322\323 \"\210)\202; \324\325!\2069 !\210	\205C \326	\"?\205m \n\205L \203[ \327\f\330\331#\"\202k \332!\210\211\205k \333!\210\334\335 !\262\207" [magit--rebase-published-symbol buffer-file-name magit-blame-mode magit-blame-type magit-this-process magit-current-blame-chunk addition eieio-oref orig-rev "0000000000000000000000000000000000000000" message "This line has not been committed yet" magit-rev-ancestor-p "HEAD" expand-file-name orig-file magit-toplevel edit-published magit-rebase-edit-commit magit-rebase-arguments magit-checkout magit-rev-branch file-equal-p set-process-sentinel make-closure #[514 "\302\"\210\303!\304=\205 \305\300!\210\301\205 \306\301!\210\307\310 !\207" [V0 V1 magit-sequencer-process-sentinel process-status exit find-file magit-blame--pre-blame-setup magit-blame--run magit-blame-arguments] 5 "\n\n(fn PROCESS EVENT)"] find-file magit-blame--pre-blame-setup magit-blame--run magit-blame-arguments] 12 (#$ . 11151) (byte-code "\205 \301C\207" [current-prefix-arg removal] 1)])
(put 'magit-edit-line-commit 'disabled t)
#@778 From a hunk, edit the respective commit and visit the file.

First visit the file being modified by the hunk at the correct
location using `magit-diff-visit-file'.  This actually visits a
blob.  When point is on a diff header, not within an individual
hunk, then this visits the blob the first hunk is about.

Then invoke `magit-edit-line-commit', which uses an interactive
rebase to make the commit editable, or if that is not possible
because the commit is not reachable from `HEAD' by checking out
that commit directly.  This also causes the actual worktree file
to be visited.

Neither the blob nor the file buffer are killed when finishing
the rebase.  If that is undesirable, then it might be better to
use `magit-rebase-edit-command' instead of this command.

(fn FILE)
(defalias 'magit-diff-edit-hunk-commit #[257 "\301r\302\301\303#q\210\304 *\207" [magit-diff-visit-previous-blob nil magit-diff-visit-file--internal pop-to-buffer-same-window magit-edit-line-commit] 5 (#$ . 12713) (byte-code "\300\301\211\"C\207" [magit-file-at-point t] 3)])
(byte-code "\300\301\302\303#\210\304\305\306\307\310DD\311\312\313\314\315\316\317&	\207" [put magit-diff-edit-hunk-commit disabled t custom-declare-variable magit-reshelve-since-committer-only funcall function #[0 "\300\207" [nil] 1] "Whether `magit-reshelve-since' changes only the committer dates.\nOtherwise the author dates are also changed." :package-version (magit . "3.0.0") :group magit-commands :type boolean] 10)
#@634 Change the author and committer dates of the commits since REV.

Ask the user for the first reachable commit whose dates should
be changed.  Then read the new date for that commit.  The initial
minibuffer input and the previous history element offer good
values.  The next commit will be created one minute later and so
on.

This command is only intended for interactive use and should only
be used on highly rearranged and unpublished history.

If KEYID is non-nil, then use that to sign all reshelved commits.
Interactively use the value of the "--gpg-sign" option in the
list returned by `magit-rebase-arguments'.

(fn REV KEYID)
(defalias 'magit-reshelve-since #[514 "\304 \206 \305\306!\307P\204* \310!\203\" \311\312\313\"!\204\" \305\314!\210\315\316\317\"\320\"\207\321\322P\211\323Q\324\325\326\327\"!!\330\"\324 \325\331\332\333#![\"B\334\324\335\336\337\300#!!!C	\340	B\341 \211\203\225 \211\342\343\344\345\312\346\347\316\350\n\"\351\332\352#\353#\"\205\212 \354\312\355\"D\n\356&\210)\210\202\231 \357 \266\360\316\361\n\"\")\207" [magit--reshelve-history process-environment default-directory magit-this-process magit-get-current-branch user-error "Refusing to reshelve detached head" "refs/original/refs/heads/" magit-ref-p magit-y-or-n-p format "Backup ref %s already exists.  Override? " "Abort" magit-log-select make-closure #[257 "\301\300\"\207" [V0 magit-reshelve-since] 4 "\n\n(fn REV)"] "Type %p on a commit to reshelve it and the commits above it," #[514 "\300\301\302!\303_\\\304!@[\\\"\207" [format-time-string "%F %T %z" floor 60 decode-time] 7 "\n\n(fn TIME OFFSET)"] "^" ".." float-time string-to-number magit-rev-format "%at" 1 magit-git-string "rev-list" "--count" floor date-to-time read-string "Date for first commit: " "FILTER_BRANCH_SQUELCH_WARNING=1" magit-toplevel magit-run-git-async "filter-branch" "--force" "--env-filter" "case $GIT_COMMIT in %s\nesac" mapconcat #[257 "\302\303\"	?\205 \302\304\300\242\"\302\305\300\242\"Q\300\211\242\306\\\240\210\207" [V0 magit-reshelve-since-committer-only format "%s) " "export GIT_AUTHOR_DATE=\"%s\"; " "export GIT_COMMITTER_DATE=\"%s\";;" 60] 6 "\n\n(fn REV)"] magit-git-lines "--reverse" " " "--commit-filter" "git commit-tree --gpg-sign=%s \"$@\";" "--" magit--not-inside-repository-error set-process-sentinel #[514 "\301!\302>\205% \303!\304V\203 \305\"\207\306\307\310#\210\305\"\210\311\312\313\300#\207" [V0 process-status (exit signal) process-exit-status 0 magit-process-sentinel process-put inhibit-refresh t magit-run-git "update-ref" "-d"] 6 "\n\n(fn PROCESS EVENT)"]] 23 (#$ . 14200) (byte-code "\300\301\302\303 \"D\207" [nil transient-arg-value "--gpg-sign=" magit-rebase-arguments] 4)])
(defvar magit-revision-stack nil)
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313&	\210\300\314\302\303\315DD\316\306\317\310\320\312\321&	\207" [custom-declare-variable magit-pop-revision-stack-format funcall function #[0 "\300\207" [("[%N: %h] " "%N: %H\n   %s\n" "\\[\\([0-9]+\\)[]:]")] 1] "Control how `magit-pop-revision-stack' inserts a revision.\n\nThe command `magit-pop-revision-stack' inserts a representation\nof the revision last pushed to the `magit-revision-stack' into\nthe current buffer.  It inserts text at point and/or near the end\nof the buffer, and removes the consumed revision from the stack.\n\nThe entries on the stack have the format (HASH TOPLEVEL) and this\noption has the format (POINT-FORMAT EOB-FORMAT INDEX-REGEXP), all\nof which may be nil or a string (though either one of EOB-FORMAT\nor POINT-FORMAT should be a string, and if INDEX-REGEXP is\nnon-nil, then the two formats should be too).\n\nFirst INDEX-REGEXP is used to find the previously inserted entry,\nby searching backward from point.  The first submatch must match\nthe index number.  That number is incremented by one, and becomes\nthe index number of the entry to be inserted.  If you don't want\nto number the inserted revisions, then use nil for INDEX-REGEXP.\n\nIf INDEX-REGEXP is non-nil, then both POINT-FORMAT and EOB-FORMAT\nshould contain \"%N\", which is replaced with the number that was\ndetermined in the previous step.\n\nBoth formats, if non-nil and after removing %N, are then expanded\nusing `git show --format=FORMAT ...' inside TOPLEVEL.\n\nThe expansion of POINT-FORMAT is inserted at point, and the\nexpansion of EOB-FORMAT is inserted at the end of the buffer (if\nthe buffer ends with a comment, then it is inserted right before\nthat)." :package-version (magit . "2.3.0") :group magit-commands :type (list (choice (string :tag "Insert at point format") (cons (string :tag "Insert at point format") (repeat (string :tag "Argument to git show"))) (const :tag "Don't insert at point" nil)) (choice (string :tag "Insert at eob format") (cons (string :tag "Insert at eob format") (repeat (string :tag "Argument to git show"))) (const :tag "Don't insert at eob" nil)) (choice (regexp :tag "Find index regexp") (const :tag "Don't number entries" nil))) magit-copy-revision-abbreviated #[0 "\300\207" [nil] 1] "Whether to save abbreviated revision to `kill-ring' and `magit-revision-stack'." (magit . "3.0.0") magit-miscellaneous boolean] 10)
#@1112 Insert a representation of a revision into the current buffer.

Pop a revision from the `magit-revision-stack' and insert it into
the current buffer according to `magit-pop-revision-stack-format'.
Revisions can be put on the stack using `magit-copy-section-value'
and `magit-copy-buffer-revision'.

If the stack is empty or with a prefix argument, instead read a
revision in the minibuffer.  By using the minibuffer history this
allows selecting an item which was popped earlier or to insert an
arbitrary reference or revision without first pushing it onto the
stack.

When reading the revision from the minibuffer, then it might not
be possible to guess the correct repository.  When this command
is called inside a repository (e.g. while composing a commit
message), then that repository is used.  Otherwise (e.g. while
composing an email) then the repository recorded for the top
element of the stack is used (even though we insert another
revision).  If not called inside a repository and with an empty
stack, or with two prefix arguments, then read the repository in
the minibuffer too.

(fn REV TOPLEVEL)
(defalias 'magit-pop-revision-stack #[514 "\203\301 \210\242\243\211\242\243\211\242\243	\2051 \212\303\304\305#\203/ \306\307\310\311!!T!\2020 \312)\304\211<\203E A\262@\262<\203R A\262@\262\203q \203e \313\314	\305\211%\262\315#\210\316\311!\210\205\277 \203\203 \313\314\305\211%\262\212db\210\317\320!\210\321 \210\n\203\244 \322\n!\203\244 \322\n!\203\260 \323y\210\202\230 \304y\210i\324U\204\260 \325c\210\325c\210\315#\210\316\311!))\207\326\327!\207" [magit-pop-revision-stack-format default-directory comment-start re-search-backward nil t number-to-string string-to-number match-string 1 "1" replace-regexp-in-string "%N" magit-rev-insert-format backward-delete-char skip-syntax-backward ">s-" beginning-of-line looking-at -1 0 10 user-error "Revision stack is empty"] 21 (#$ . 19412) (byte-code "\204 	\204& \304!\305U\204 \306 \206 	@A@\206 \307 \310\311!\n)D\207	@@B	\211A\242\207" [current-prefix-arg magit-revision-stack default-directory magit-revision-history prefix-numeric-value 16 magit-toplevel magit-read-repository magit-read-branch-or-commit "Insert revision"] 2)])
(define-key git-commit-mode-map "" 'magit-pop-revision-stack)
#@906 Save the value of the current section for later use.

Save the section value to the `kill-ring', and, provided that
the current section is a commit, branch, or tag section, push
the (referenced) revision to the `magit-revision-stack' for use
with `magit-pop-revision-stack'.

When `magit-copy-revision-abbreviated' is non-nil, save the
abbreviated revision to the `kill-ring' and the
`magit-revision-stack'.

When the current section is a branch or a tag, and a prefix
argument is used, then save the revision at its tip to the
`kill-ring' instead of the reference name.

When the region is active, then save that to the `kill-ring',
like `kill-ring-save' would, instead of behaving as described
above.  If a prefix argument is used and the region is within
a hunk, then strip the diff marker column and keep only either
the added or removed lines, depending on the sign of the prefix
argument.

(fn ARG)
(defalias 'magit-copy-section-value #[257 "\211\2033 \304 \2033 \305\306!\2033 \307\310\311\312\310\313\314\315!\316W\203# \317\202$ \320\"\312\321\322 \323 \"##!\210\324 \207\325 \203< \326\327!\207\330 \211\205F \331\332\"\211\205\262 \330 \211\203\252 \333\334\"\203\252 \335\330 \211\203n \333\336\"\203n \266\202\202\205 \211\203\204 \333\337\"\203\204 \340\341\342!\343 \"!\210\344	\205\213 \345\"\262D\nB\307\346\347\203\240 \206\242 \"!)\266\202\202\260 \307\346\347\"!\262\207" [default-directory magit-copy-revision-abbreviated magit-revision-stack current-prefix-arg magit-section-internal-region-p magit-section-match hunk kill-new replace-regexp-in-string "^[ \\+\\-]" "" format "^\\%c.*\n?" prefix-numeric-value 0 43 45 buffer-substring-no-properties region-beginning region-end deactivate-mark use-region-p call-interactively copy-region-as-kill magit-current-section eieio-oref value magit-section-match-1 (branch commit module-commit tag) nil (branch tag) module-commit file-name-as-directory expand-file-name magit-section-parent-value magit-toplevel magit-rev-parse "--short" message "%s"] 11 (#$ . 21744) "P"])
#@933 Save the revision of the current buffer for later use.

Save the revision shown in the current buffer to the `kill-ring'
and push it to the `magit-revision-stack'.

This command is mainly intended for use in `magit-revision-mode'
buffers, the only buffers where it is always unambiguous exactly
which revision should be saved.

Most other Magit buffers usually show more than one revision, in
some way or another, so this command has to select one of them,
and that choice might not always be the one you think would have
been the best pick.

In such buffers it is often more useful to save the value of
the current section instead, using `magit-copy-section-value'.

When the region is active, then save that to the `kill-ring',
like `kill-ring-save' would, instead of behaving as described
above.

When `magit-copy-revision-abbreviated' is non-nil, save the
abbreviated revision to the `kill-ring' and the
`magit-revision-stack'.
(defalias 'magit-copy-buffer-revision #[0 "\306 \203	 \307\310!\207\206* 	\311\267\202) \312\313\n\"\203! \314\315\n\"\202* \n\202* \316\202* \317\211\205J \320!\205J \321\205: \322\"\262\211\fDB\323\324\325\"!\207" [magit-buffer-revision major-mode magit-buffer-range magit-copy-revision-abbreviated default-directory magit-revision-stack use-region-p call-interactively copy-region-as-kill #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (magit-diff-mode 19 magit-status-mode 37)) string-match "\\.\\.\\.?\\(.+\\)" match-string 1 "HEAD" nil magit-commit-p magit-rev-parse "--short" kill-new message "%s"] 5 (#$ . 23811) nil])
#@146 Abort current operation.
Depending on the context, this will abort a merge, a rebase, a
patch application, a cherry-pick, a revert, or a bisect.
(defalias 'magit-abort-dwim #[0 "\300 \203 \301 \207\302 \203 \303 \207\304 \203 \305 \207\306 \203  \307 \207\310 \205' \311 \207" [magit-merge-in-progress-p magit-merge-abort magit-rebase-in-progress-p magit-rebase-abort magit-am-in-progress-p magit-am-abort magit-sequencer-in-progress-p magit-sequencer-abort magit-bisect-in-progress-p magit-bisect-reset] 1 (#$ . 25423) nil])
(provide 'magit-extras)