mirror of https://github.com/Chizi123/.emacs.d.git

Chizi123
2018-11-18 c655eea759be1db69c5e6b45c228139d8390122a
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
;ELC
;;; Compiled
;;; in Emacs version 26.1
;;; with all optimizations.
 
;;; This file uses dynamic docstrings, first added in Emacs 19.29.
 
;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
(byte-code "\300\301!\210\300\302!\210\300\303!\210\300\304!\207" [require cl-lib dash magit-utils magit-section] 2)
(defvar magit-tramp-process-environment nil)
(custom-declare-group 'magit-process nil "Git and other external processes used by Magit." :group 'magit)
#@55 Prepended to `process-environment' while running git.
(defvar magit-git-environment (byte-code "\301\302\"C\207" [emacs-version format "INSIDE_EMACS=%s,magit"] 3) (#$ . 676))
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313&    \207" [custom-declare-variable magit-git-output-coding-system funcall function #[0 "\301=\205\302\207" [system-type windows-nt utf-8] 2] "Coding system for receiving output from Git.\n\nIf non-nil, the Git config value `i18n.logOutputEncoding' should\nbe set via `magit-git-global-arguments' to value consistent with\nthis." :package-version (magit . "2.9.0") :group magit-process :type (choice (coding-system :tag "Coding system to decode Git output") (const :tag "Use system default" nil))] 10)
#@174 Alist of (EXE . (PATHENTRY)).
This specifies what additional PATH setting needs to be added to
the environment in order to run the non-wrapper git executables
successfully.
(defvar magit-git-w32-path-hack nil (#$ . 1423))
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\210\300\312\302\303\313DD\314\315\316\306\317\306\307\310\320& \207" [custom-declare-variable magit-git-executable funcall function #[0 "\302=\203F\303\304!\211\205A\3051?\306\307\310\311\304%@\312    \"\313\306\307\314\315$@PC\2032\241\210\2028B    B\266\2030\202A\210\316\262\206G\304\207" [system-type magit-git-w32-path-hack windows-nt executable-find "git" (error) process-lines "-c" "alias.X=!x() { which \"$1\" | cygpath -mf -; }; x" "X" assoc "PATH=" "alias.P=!cygpath -wp \"$PATH\"" "P" nil] 9] "The Git executable used by Magit." :group magit-process :type string magit-git-global-arguments #[0 "\301\302\303\304\303\305\306=\205\303\307DBBBBBB\207" [system-type "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "log.showSignature=false" windows-nt "i18n.logOutputEncoding=UTF-8"] 8] "Global Git arguments.\n\nThe arguments set here are used every time the git executable is\nrun as a subprocess.  They are placed right after the executable\nitself and before the git command - as in `git HERE... COMMAND\nREST'.  See the manpage `git(1)' for valid arguments.\n\nBe careful what you add here, especially if you are using Tramp\nto connect to servers with ancient Git versions.  Never remove\nanything that is part of the default value, unless you really\nknow what you are doing.  And think very hard before adding\nsomething; it will be used every time Magit runs Git for any\npurpose." :package-version (magit . "2.9.0") magit-git-arguments (repeat string)] 12)
#@719 Whether to enable additional reporting of git errors.
 
Magit basically calls git for one of these two reasons: for
side-effects or to do something with its standard output.
 
When git is run for side-effects then its output, including error
messages, go into the process buffer which is shown when using \<magit-status-mode-map>\[magit-process].
 
When git's output is consumed in some way, then it would be too
expensive to also insert it into this buffer, but when this
option is non-nil and git returns with a non-zero exit status,
then at least its standard error is inserted into this buffer.
 
This is only intended for debugging purposes.  Do not enable this
permanently, that would negatively affect performance.
(defvar magit-git-debug nil (#$ . 3215))
(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-prefer-remote-upstream funcall function #[0 "\300\207" [nil] 1] "Whether to favor remote branches when reading the upstream branch.\n\nThis controls whether commands that read a branch from the user\nand then set it as the upstream branch, offer a local or a remote\nbranch as default completion candidate, when they have the choice.\n\nThis affects all commands that use `magit-read-upstream-branch'\nor `magit-read-starting-point', which includes all commands that\nchange the upstream and many which create new branches." :package-version (magit . "2.4.2") :group magit-commands :type boolean magit-list-refs-sortby #[0 "\300\207" [nil] 1] "How to sort the ref collection in the prompt.\n\nThis affects commands that read a ref.  More specifically, it\ncontrols the order of refs returned by `magit-list-refs', which\nis called by functions like `magit-list-branch-names' to generate\nthe collection of refs.  By default, refs are sorted according to\ntheir full refname (i.e., 'refs/...').\n\nAny value accepted by the `--sort' flag of `git for-each-ref' can\nbe used.  For example, \"-creatordate\" places refs with more\nrecent committer or tagger dates earlier in the list.  A list of\nstrings can also be given in order to pass multiple sort keys to\n`git for-each-ref'.\n\nNote that, depending on the completion framework you use, this\nmay not be sufficient to change the order in which the refs are\ndisplayed.  It only controls the order of the collection passed\nto `magit-completing-read' or, for commands that support reading\nmultiple strings, `read-from-minibuffer'.  The completion\nframework ultimately determines how the collection is displayed." (magit . "2.11.0") magit-miscellanous (choice string (repeat string))] 10)
(defvar magit--refresh-cache nil)
#@23 
 
(fn KEY &rest BODY)
(defalias 'magit--with-refresh-cache '(macro . #[385 "\300 \301\302\303DC\304\305\306BB\307\310\303\311\312\f!DC\313\314\f\315BB\316BB\317BBB\257EBBB\207" [cl-gensym if magit--refresh-cache let --if-let assoc ((cdr magit--refresh-cache)) (progn (cl-incf (caar magit--refresh-cache)) (cdr it)) (cl-incf (cdar magit--refresh-cache)) value macroexp-progn push cons (value) ((cdr magit--refresh-cache)) (value)] 17 (#$ . 5913)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put magit--with-refresh-cache lisp-indent-function 1 put edebug-form-spec (form body)] 5)
#@199 The environment variable exported by `magit-with-editor'.
Set this to "GIT_SEQUENCE_EDITOR" if you do not want to use
Emacs to edit commit messages but would like to do so to edit
rebase sequences.
(defvar magit-with-editor-envvar "GIT_EDITOR" (#$ . 6529))
#@125 Like `with-editor' but let-bind some more variables.
Also respect the value of `magit-with-editor-envvar'.
 
(fn &rest BODY)
(defalias 'magit-with-editor '(macro . #[128 "\300\301\302\303BBE\207" [let ((magit-process-popup-time -1) (shell-file-name (if (and (eq system-type 'windows-nt) (not magit-cygwin-mount-points)) "cmdproxy" shell-file-name))) with-editor* magit-with-editor-envvar] 6 (#$ . 6793)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put magit-with-editor lisp-indent-function 0 put edebug-form-spec (body)] 5)
#@347 Prepare ARGS for a function that invokes Git.
 
Magit has many specialized functions for running Git; they all
pass arguments through this function before handing them to Git,
to do the following.
 
* Flatten ARGS, removing nil arguments.
* Prepend `magit-git-global-arguments' to ARGS.
* On w32 systems, encode to `w32-ansi-code-page'.
 
(fn ARGS)
(defalias 'magit-process-git-arguments #[257 "\302\303!\"\262    \304=\203\305\306!\203\307\310\"\207\207" [magit-git-global-arguments system-type append -flatten windows-nt boundp w32-ansi-code-page mapcar #[257 "\301\302\303\304\"!\"\207" [w32-ansi-code-page encode-coding-string intern format "cp%d"] 7 "\n\n(fn ARG)"]] 5 (#$ . 7345)])
#@66 Execute Git with ARGS, returning its exit code.
 
(fn &rest ARGS)
(defalias 'magit-git-exit-code #[128 "\301\302\303\211\211\304!&\207" [magit-git-executable apply magit-process-file nil magit-process-git-arguments] 9 (#$ . 8043)])
#@76 Execute Git with ARGS, returning t if its exit code is 0.
 
(fn &rest ARGS)
(defalias 'magit-git-success #[128 "\300!\301U\207" [magit-git-exit-code 0] 3 (#$ . 8284)])
#@76 Execute Git with ARGS, returning t if its exit code is 1.
 
(fn &rest ARGS)
(defalias 'magit-git-failure #[128 "\300!\301U\207" [magit-git-exit-code 1] 3 (#$ . 8458)])
#@233 Execute Git with ARGS, returning the first line of its output.
If there is no output, return nil.  If the output begins with a
newline, return an empty string.  Like `magit-git-string' but
ignore `magit-git-debug'.
 
(fn &rest ARGS)
(defalias 'magit-git-str #[128 "\303!\262\203r    B\304A\"\211\203$\211@@@T\240\266\211A\202o\211@@AT\241\266\305\306!r\211q\210\307\310\311\312\313!\314\"\315$\216\316\317\n\320\321\320D\320\322\n!&\210o?\205]eb\210\323`\324 \"*\262B\211AB\241\266\211\262\262\207\305\306!r\211q\210\307\310\311\312\313!\325\"\315$\216\316\317\n\320\321\320D\320\322!&\210o?\205\241eb\210\323`\324 \"*\207" [magit--refresh-cache default-directory magit-git-executable -flatten assoc generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205    \302\300!\207" vconcat vector [buffer-name kill-buffer] 2 apply magit-process-file nil t magit-process-git-arguments buffer-substring-no-properties line-end-position [buffer-name kill-buffer]] 12 (#$ . 8633)])
#@63 Execute Git with ARGS, returning its output.
 
(fn &rest ARGS)
(defalias 'magit-git-output #[128 "\303!\262\203i    B\304A\"\211\203$\211@@@T\240\266\211A\202f\211@@AT\241\266\305\306!r\211q\210\307\310\311\312\313!\314\"\315$\216\316\317\n\320\321\320D\320\322\n!&\210\323ed\"*\262B\211AB\241\266\211\262\262\207\305\306!r\211q\210\307\310\311\312\313!\324\"\315$\216\316\317\n\320\321\320D\320\322!&\210\323ed\"*\207" [magit--refresh-cache default-directory magit-git-executable -flatten assoc generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205    \302\300!\207" vconcat vector [buffer-name kill-buffer] 2 apply magit-process-file nil t magit-process-git-arguments buffer-substring-no-properties [buffer-name kill-buffer]] 12 (#$ . 9641)])
(define-error 'magit-invalid-git-boolean "Not a Git boolean")
#@171 Execute Git with ARGS, returning t if it prints "true".
If it prints "false", then return nil.  For any other output
signal `magit-invalid-git-boolean'.
 
(fn &rest ARGS)
(defalias 'magit-git-true #[128 "\300!\211\301\235\203 \302\202\211\303\235\203\304\202\211\305\306\"\262\207" [magit-git-output ("true\n" "true") t ("false\n" "false") nil signal magit-invalid-git-boolean] 6 (#$ . 10488)])
#@171 Execute Git with ARGS, returning t if it prints "false".
If it prints "true", then return nil.  For any other output
signal `magit-invalid-git-boolean'.
 
(fn &rest ARGS)
(defalias 'magit-git-false #[128 "\300!\211\301\235\203 \302\202\211\303\235\203\304\202\211\305\306\"\262\207" [magit-git-output ("true\n" "true") nil ("false\n" "false") t signal magit-invalid-git-boolean] 6 (#$ . 10899)])
#@186 Execute Git with ARGS, inserting its output at point.
If Git exits with a non-zero exit status, then show a message and
add a section in the respective process buffer.
 
(fn &rest ARGS)
(defalias 'magit-git-insert #[128 "\303!\262\203\223\304C\305\306\307\310\311!\312\"\313$\216\211\314\315!\240\210\316\242!\210\317\320    \304\321\242D\304&\211\306V\203\216\322\323\242!\203\210\324\325!r\211q\210\305\306\326\310\311!\327\"\313$\216\330\242!\210db\210\331!\203e\332 !\202o\333\334\335\"\205o\336\337!*\262\262\304r\340\321!q\210\341\n    \242%\210*\342\343\"\266\211\262)\207\317\320    \304\321\304D\304&\207" [magit-git-debug magit-git-executable default-directory magit-process-git-arguments nil make-byte-code 0 "\3011\n\302\300\242!0\207\210\303\207" vconcat vector [(error) delete-file nil] 2 make-temp-file "magit-stderr" delete-file apply magit-process-file t "Git failed" file-exists-p generate-new-buffer " *temp*" "\301\300!\205    \302\300!\207" [buffer-name kill-buffer] insert-file-contents functionp buffer-string run-hook-wrapped magit-process-error-message-regexps #[257 "\300\301\302#\207" [re-search-backward nil t] 5 "\n\n(fn RE)"] match-string-no-properties 1 magit-process-buffer magit-process-insert-section message "%s"] 11 (#$ . 11311)])
#@178 Execute Git with ARGS, returning the first line of its output.
If there is no output, return nil.  If the output begins with a
newline, return an empty string.
 
(fn &rest ARGS)
(defalias 'magit-git-string #[128 "\302!\262\203h    B\303A\"\211\203$\211@@@T\240\266\211A\202e\211@@AT\241\266\304\305!r\211q\210\306\307\310\311\312!\313\"\314$\216\315\316\"\210o?\205Seb\210\317`\320 \"*\262B\211AB\241\266\211\262\262\207\304\305!r\211q\210\306\307\310\311\312!\321\"\314$\216\315\316\"\210o?\205\215eb\210\317`\320 \"*\207" [magit--refresh-cache default-directory -flatten assoc generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205    \302\300!\207" vconcat vector [buffer-name kill-buffer] 2 apply magit-git-insert buffer-substring-no-properties line-end-position [buffer-name kill-buffer]] 10 (#$ . 12609)])
#@252 Execute Git with ARGS, returning its output as a list of lines.
Empty lines anywhere in the output are omitted.
 
If Git exits with a non-zero exit status, then report show a
message and add a section in the respective process buffer.
 
(fn &rest ARGS)
(defalias 'magit-git-lines #[128 "\300\301!r\211q\210\302\303\304\305\306!\307\"\310$\216\311\312\"\210\313\314 \315\316#*\207" [generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205    \302\300!\207" vconcat vector [buffer-name kill-buffer] 2 apply magit-git-insert split-string buffer-string "\n" t] 8 (#$ . 13459)])
#@258 Execute Git with ARGS, returning its null-separated output as a list.
Empty items anywhere in the output are omitted.
 
If Git exits with a non-zero exit status, then report show a
message and add a section in the respective process buffer.
 
(fn &rest ARGS)
(defalias 'magit-git-items #[128 "\300\301!r\211q\210\302\303\304\305\306!\307\"\310$\216\311\312\"\210\313\314 \315\316#*\207" [generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205    \302\300!\207" vconcat vector [buffer-name kill-buffer] 2 apply magit-git-insert split-string buffer-string "" t] 8 (#$ . 14044)])
#@330 Execute Git with ARGS, inserting washed output at point.
Actually first insert the raw output at point.  If there is no
output, call `magit-cancel-section'.  Otherwise temporarily narrow
the buffer to the inserted text, move to its beginning, and then
call function WASHER with ARGS as its sole argument.
 
(fn WASHER &rest ARGS)
(defalias 'magit-git-wash #[385 "`\300!\262\301!\210`U\203\302 \202;n\204\303c\210\214\211`}\210\211b\210!\210)`U\2046`TU\2039\302 \210\304 \207" [-flatten magit-git-insert magit-cancel-section "\n" magit-maybe-make-margin-overlay] 5 (#$ . 14634)])
(byte-code "\300\301\302\303#\300\207" [function-put magit-git-wash lisp-indent-function 1] 4)
#@22 
 
(fn &optional RAW)
(defalias 'magit-git-version #[256 "\301\3021\303\304!\305\301O0\202\210\301)\211\205*\203\211\202*\306\307\"\205*\310\311\"\207" [magit-git-global-arguments nil (error) magit-git-string "version" 12 string-match "^\\([0-9]+\\.[0-9]+\\.[0-9]+\\)" match-string 1] 5 (#$ . 15328)])
#@12 
 
(fn KEY)
(defalias 'magit-config-get-from-cached-list #[257 "\301\302\303\304\305\211%\302\306\304\305\211%\262\262\203\222\307 \310B\311A\"\211\2034\211@@@T\240\266\211A\202\213\211@@AT\241\266\312\313\314\"\315\316\317\320#\211\203x\211@\321\322\"\323O\203aT\324O\202b\325\326\301    \"C\244#\266A\266\202\202G\210\211\262B\211AB\241\266\211\262\262\262\202\320\312\313\314\"\315\316\317\320#\211\203\314\211@\321\322\"\323O\203\265T\324O\202\266\325\326\301    \"C\244#\266A\266\202\202\233\210\211\262\"\207" [magit--refresh-cache gethash replace-regexp-in-string "\\`[^.]+" downcase t "[^.]+\\'" magit-toplevel config assoc make-hash-table :test equal magit-git-items "config" "--list" "-z" cl-position 10 0 nil "" puthash] 16 (#$ . 15648)])
#@74 Return the value of the Git variable specified by KEYS.
 
(fn &rest KEYS)
(defalias 'magit-get #[128 "\300\301\302\"!@\207" [last apply magit-get-all] 5 (#$ . 16462)])
#@75 Return all values of the Git variable specified by KEYS.
 
(fn &rest KEYS)
(defalias 'magit-get-all #[128 "\302@\203\303\304@\"\205\211A\262\242\305\306\307#    \203)\204)\310!\2020\311\312\313\314%)\207" [magit-git-debug magit--refresh-cache nil string-prefix-p "--" mapconcat identity "." magit-config-get-from-cached-list magit-git-items "config" "-z" "--get-all"] 10 (#$ . 16636)])
#@82 Return the boolean value of the Git variable specified by KEYS.
 
(fn &rest KEYS)
(defalias 'magit-get-boolean #[128 "\301\302\303#\203\304\305!!@\306\232\202\307\310\311#\306\232\207" [magit--refresh-cache mapconcat identity "." last magit-config-get-from-cached-list "true" magit-git-str "config" "--bool"] 6 (#$ . 17042)])
#@86 Set the value of the Git variable specified by KEYS to VALUE.
 
(fn VALUE &rest KEYS)
(defalias 'magit-set #[385 "\211@\203 \300\301@\"\205\211A\262\242\302\303\304#\203'\305\306$\210\202.\305\306\307$\210\207" [string-prefix-p "--" mapconcat identity "." magit-git-success "config" "--unset"] 9 (#$ . 17381)])
(byte-code "\300\301\302\303#\300\207" [function-put magit-get gv-expander #[385 "\300\301\302$\207" [gv--defsetter magit-get #[385 "\300BB\207" [magit-set] 5 "\n\n(fn VAL &rest KEYS)"]] 7 "\n\n(fn DO &rest ARGS)"]] 4)
#@89 Set all values of the Git variable specified by KEYS to VALUES.
 
(fn VALUES &rest KEYS)
(defalias 'magit-set-all #[385 "\211@\203 \300\301@\"\205\211A\262\242\302\303\304#\305!\203%\306\307\310$\210\211\205<\211@\306\307\311%\210A\266\202\202&\262\207" [string-prefix-p "--" mapconcat identity "." magit-get magit-call-git "config" "--unset-all" "--add"] 12 (#$ . 17937)])
#@23 
 
(fn &optional FILE)
(defalias 'magit--safe-default-directory #[256 "\30120\302\303\206 !!\304\305!\204,\306\307!!\262\232\203&\310\301\304\"\210\262\202\266\2020\207" [default-directory unsafe-default-dir file-name-as-directory expand-file-name nil magit-file-accessible-directory-p file-name-directory directory-file-name throw] 6 (#$ . 18336)])
#@24 
 
(fn FILE &rest BODY)
(defalias 'magit--with-safe-default-directory '(macro . #[385 "\300\301\302DDCBB\207" [when-let default-directory magit--safe-default-directory] 6 (#$ . 18707)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put magit--with-safe-default-directory lisp-indent-function 1 put edebug-form-spec (form body)] 5)
#@338 Return the absolute and resolved path of the .git directory.
 
If the `GIT_DIR' environment variable is define then return that.
Otherwise return the .git directory for DIRECTORY, or if that is
nil, then for `default-directory' instead.  If the directory is
not located inside a Git repository, then return nil.
 
(fn &optional DIRECTORY)
(defalias 'magit-gitdir #[256 "\211\206\301 )\207" [default-directory magit-git-dir] 2 (#$ . 19063)])
#@286 Return the absolute and resolved path of the .git directory.
 
If the `GIT_DIR' environment variable is define then return that.
Otherwise return the .git directory for `default-directory'.  If
the directory is not located inside a Git repository, then return
nil.
 
(fn &optional PATH)
(defalias 'magit-git-dir #[256 "\203p    \302E\303A\"\211\203 \211@@@T\240\266\211A\202m\211@@AT\241\266\304\305!\211\205]\306\307!\211\205[\310\311!!\262\312!\204M\312    !P\262\203Z\313\314!\"\202[\211\262)B\211AB\241\266\211\262\262\207\304\305!\211\205\243\306\307!\211\205\241\310\311!!\262\312!\204\223\312    !P\262\203\240\313\314!\"\202\241\211\262)\207" [magit--refresh-cache default-directory magit-git-dir assoc magit--safe-default-directory nil magit-rev-parse-safe "--git-dir" file-name-as-directory magit-expand-git-file-name file-remote-p expand-file-name convert-standard-filename] 10 (#$ . 19513)])
(defvar magit--separated-gitdirs nil)
(defalias 'magit--record-separated-gitdir #[0 "\301 \302 \303\304!!\203\305!\262\306\307\310\311\312&\313\314\315\"!\232?\205.BB\211\207" [magit--separated-gitdirs magit-toplevel magit-git-dir file-symlink-p directory-file-name file-truename cl-delete :key car :test equal file-name-as-directory expand-file-name ".git"] 9])
#@911 Return the absolute path to the toplevel of the current repository.
 
From within the working tree or control directory of a repository
return the absolute path to the toplevel directory of the working
tree.  As a special case, from within a bare repository return
the control directory instead.  When called outside a repository
then return nil.
 
When optional DIRECTORY is non-nil then return the toplevel for
that directory instead of the one for `default-directory'.
 
Try to respect the option `find-file-visit-truename', i.e.  when
the value of that option is nil, then avoid needlessly returning
the truename.  When a symlink to a sub-directory of the working
tree is involved, or when called from within a sub-directory of
the gitdir or from the toplevel of a gitdir, which itself is not
located within the working tree, then it is not possible to avoid
returning the truename.
 
(fn &optional DIRECTORY)
(defalias 'magit-toplevel #[256 "\203\374\211\206        \304B\305A\"\211\203#\211@@@T\240\266\211A\202\371\211@@AT\241\266\306!\211\205\351\307\310!\211\203\222\311\312!\262\n\204\206\313\314!\204\206\315\307\316!!\262\317!\203a\320    !P\202d\321!\262\211\307\316!\322\230\205~\307\310!\211\205|\312!\230\262)\203\206\211\202\215\320    !\315!P\262\202\347\307\323!\211\205\345\315\317!\203\252\320    !\312!P\202\255\321!!\262\324 \203\271\211\202\345\321\325\"\326!\205\306\327!\211\203\326\211\330\232\204\326\331!\202\343\332 \"@\206\343\331\333!!\266\202\262\262)B\211AB\241\266\211\262\262\207\306!\211\205\270\307\310!\211\203a\311\312!\262\n\204U\313\314!\204U\315\307\316!!\262\317!\2030\320    !P\2023\321!\262\211\307\316!\322\230\205M\307\310!\211\205K\312!\230\262)\203U\211\202\\\320    !\315!P\262\202\266\307\323!\211\205\264\315\317!\203y\320    !\312!P\202|\321!!\262\324 \203\210\211\202\264\321\325\"\326!\205\225\327!\211\203\245\211\330\232\204\245\331!\202\262\332 \"@\206\262\331\333!!\266\202\262\262)\207" [magit--refresh-cache default-directory find-file-visit-truename magit--separated-gitdirs magit-toplevel assoc magit--safe-default-directory magit-rev-parse-safe "--show-toplevel" nil magit-expand-git-file-name getenv "GIT_WORK_TREE" file-name-as-directory "--show-cdup" file-name-absolute-p file-remote-p expand-file-name "" "--git-dir" magit-bare-repo-p "gitdir" file-exists-p magit-file-line ".git" file-name-directory rassoc directory-file-name] 11 (#$ . 20843)])
#@19 
 
(fn &rest BODY)
(defalias 'magit-with-toplevel '(macro . #[128 "\300\301!\302\303BC\304\302\305DCBB\306BBBE\207" [cl-gensym "toplevel" let ((magit-toplevel)) if default-directory ((magit--not-inside-repository-error))] 9 (#$ . 23354)]))
(byte-code "\300\301\302\303#\304\301\305\306#\210\307\310\311\"\210\307\312\313\"\207" [function-put magit-with-toplevel lisp-indent-function defun put edebug-form-spec (body) define-error magit-outside-git-repo "Not inside Git repository" magit-git-executable-not-found "Git executable cannot be found (see https://magit.vc/goto/e6a78ed2)"] 5)
(defalias 'magit--not-inside-repository-error #[0 "\302!\203 \303\304    \"\207\303\305\"\207" [magit-git-executable default-directory executable-find signal magit-outside-git-repo magit-git-executable-not-found] 3])
#@246 Return t if `default-directory' is below the repository directory.
If it is below the working directory, then return nil.
If it isn't below either, then signal an error unless NOERROR
is non-nil, in which case return nil.
 
(fn &optioal NOERROR)
(defalias 'magit-inside-gitdir-p #[514 "\301!\205!\302 \211\203\303\"\202\203\304\202\305\306\"\262\207" [default-directory magit--assert-default-directory magit-git-dir file-in-directory-p nil signal magit-outside-git-repo] 6 (#$ . 24169)])
#@247 Return t if `default-directory' is below the working directory.
If it is below the repository directory, then return nil.
If it isn't below either, then signal an error unless NOERROR
is non-nil, in which case return nil.
 
(fn &optional NOERROR)
(defalias 'magit-inside-worktree-p #[256 "\301!\205\3021\303\304!0\207\210\211?\205\305\306\"\207" [default-directory magit--assert-default-directory (magit-invalid-git-boolean) magit-rev-parse-true "--is-inside-work-tree" signal magit-outside-git-repo] 4 (#$ . 24678)])
#@233 Return t if the current repository is bare.
If it is non-bare, then return nil.  If `default-directory'
isn't below a Git repository, then signal an error unless
NOERROR is non-nil, in which case return nil.
 
(fn &optional NOERROR)
(defalias 'magit-bare-repo-p #[256 "\301!\205\3021\303\304!0\207\210\211?\205\305\306\"\207" [default-directory magit--assert-default-directory (magit-invalid-git-boolean) magit-rev-parse-true "--is-bare-repository" signal magit-outside-git-repo] 4 (#$ . 25210)])
#@26 
 
(fn &optional NOERROR)
(defalias 'magit--assert-default-directory #[256 "\301!\206'\211?\205'\302!\303\203\304\202\305\306\203!\307\202\"\310E\"\262\207" [default-directory file-directory-p file-exists-p signal file-error file-missing "Running git in directory" "Not a directory" "No such file or directory"] 7 (#$ . 25720)])
#@164 Return t if DIRECTORY is a Git repository.
When optional NON-BARE is non-nil also return nil if DIRECTORY is
a bare repository.
 
(fn DIRECTORY &optional NON-BARE)
(defalias 'magit-git-repo-p #[513 "\300!\2055\301\302\303\"!\2065\300\302\303\"!\2065\211?\2055\301\302\304\"!\2055\300\302\305\"!\2055\300\302\306\"!\207" [file-directory-p file-regular-p expand-file-name ".git" "HEAD" "refs" "objects"] 6 (#$ . 26069)])
(defvar magit-buffer-revision nil nil)
(make-variable-buffer-local 'magit-buffer-revision)
(defvar magit-buffer-refname nil nil)
(make-variable-buffer-local 'magit-buffer-refname)
(defvar magit-buffer-file-name nil nil)
(byte-code "\300\301!\210\302\303\304\305#\210\302\306\304\305#\210\302\301\304\305#\207" [make-variable-buffer-local magit-buffer-file-name put magit-buffer-revision permanent-local t magit-buffer-refname] 4)
#@352 Return the path of FILE relative to the repository root.
 
If optional FILE is nil or omitted, return the relative path of
the file being visited in the current buffer, if any, else nil.
If the file is not inside a Git repository, then return nil.
 
If TRACKED is non-nil, return the path only if it matches a
tracked file.
 
(fn &optional FILE TRACKED)
(defalias 'magit-file-relative-name #[512 "\204r\303 \206 pq\210\206    \206\304\305!\205\n\262)\205B\211\203/\306\307!!\205B\310\311\312\313!!!!\211\205@\307\"\262\207" [magit-buffer-file-name buffer-file-name default-directory buffer-base-buffer derived-mode-p dired-mode magit-file-tracked-p file-relative-name magit-toplevel magit--safe-default-directory directory-file-name file-name-directory] 7 (#$ . 26936)])
#@13 
 
(fn FILE)
(defalias 'magit-file-tracked-p #[257 "\300\301\302#\207" [magit-git-success "ls-files" "--error-unmatch"] 5 (#$ . 27729)])
#@19 
 
(fn &rest ARGS)
(defalias 'magit-list-files #[128 "\300\301\302\303\304%\207" [apply magit-git-items "ls-files" "-z" "--full-name"] 7 (#$ . 27872)])
(defalias 'magit-tracked-files #[0 "\300\301!\207" [magit-list-files "--cached"] 2])
#@28 
 
(fn &optional ALL FILES)
(defalias 'magit-untracked-files #[512 "\300\301?\205\302\303$\207" [magit-list-files "--other" "--exclude-standard" "--"] 7 (#$ . 28115)])
#@34 
 
(fn &optional NOMODULES FILES)
(defalias 'magit-unstaged-files #[512 "\300\301\302\303\205    \304\305&\207" [magit-git-items "diff-files" "-z" "--name-only" "--ignore-submodules" "--"] 9 (#$ . 28292)])
#@34 
 
(fn &optional NOMODULES FILES)
(defalias 'magit-staged-files #[512 "\300\301\302\303\304\205 \305\306 \307&\207" [magit-git-items "diff-index" "-z" "--name-only" "--cached" "--ignore-submodules" magit-headish "--"] 11 (#$ . 28505)])
#@19 
 
(fn &rest ARGS)
(defalias 'magit-binary-files #[128 "\300\301\302\303\300\304\305\306\307\310\n&\"\"\207" [apply append mapcar #[257 "\300\301\"\205\f\302\303\"C\207" [string-match "^-    -    \\(.+\\)" match-string 1] 4 "\n\n(fn IT)"] magit-git-items "diff" "-z" "--numstat" "--ignore-submodules"] 12 (#$ . 28752)])
(defalias 'magit-unmerged-files #[0 "\300\301\302\303\304$\207" [magit-git-items "diff-files" "-z" "--name-only" "--diff-filter=U"] 5])
(defalias 'magit-ignored-files #[0 "\300\301\302\303\304\305\306&\207" [magit-git-items "ls-files" "-z" "--others" "--ignored" "--exclude-standard" "--directory"] 7])
#@12 
 
(fn REV)
(defalias 'magit-revision-files #[257 "\301 \211\203\211\302\303\304\305\306%)\202\307 \207" [default-directory magit-toplevel magit-git-items "ls-tree" "-z" "-r" "--name-only" magit--not-inside-repository-error] 8 (#$ . 29380)])
#@292 Return list of files the have changed between two revisions.
If OTHER-REV is non-nil, REV-OR-RANGE should be a revision, not a
range.  Otherwise, it can be any revision or range accepted by
"git diff" (i.e., <rev>, <revA>..<revB>, or <revA>...<revB>).
 
(fn REV-OR-RANGE &optional OTHER-REV)
(defalias 'magit-changed-files #[513 "\301 \211\203\211\302\303\304\305%)\202\306 \207" [default-directory magit-toplevel magit-git-items "diff" "-z" "--name-only" magit--not-inside-repository-error] 9 (#$ . 29635)])
#@18 
 
(fn REVA REVB)
(defalias 'magit-renamed-files #[514 "\300\301\302\303\304\305\306\307\310\311  &\"\"\207" [mapcar #[257 "\211A@\3008B\207" [2] 4 "\n\n(fn IT)"] -partition 3 magit-git-items "diff-tree" "-r" "--diff-filter=R" "-z" "-M"] 14 (#$ . 30158)])
#@19 
 
(fn &rest ARGS)
(defalias 'magit-file-status #[128 "\300\301!r\211q\210\302\303\304\305\306!\307\"\310$\216\212\311\312\313#\210)`\314\315\314w\303V\203afTf\316\\`{\314u\210\317>\203P`\262\315\314w\210\211`{FB\262\314u\210\202Y\211\314FB\262\266`\262\202\262*\207" [generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205    \302\300!\207" vconcat vector [buffer-name kill-buffer] 2 magit-git-insert "status" "-z" nil "[:print:]" 3 (82 67)] 11 (#$ . 30423)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313&    \207" [custom-declare-variable magit-cygwin-mount-points funcall function #[0 "\305=\2056\306\307\310\311    \n\"\312\313 \314\"@\315\316\317#)\266\203?\2050\3201.\313\321!0\2020\210\315)\"\322\323\324$\207" [system-type magit-git-environment process-environment magit-git-executable inhibit-changing-match-data windows-nt cl-sort mapcar #[257 "\300\301\"\203\302\303\304\"!\302\303\305\"!B\207\306\307\310\311$\207" [string-match "^\\(.*\\) on \\(.*\\) type" file-name-as-directory match-string 2 1 lwarn (magit) :error "Failed to parse Cygwin mount: %S"] 6 "\n\n(fn IT)"] append "\\`[a-zA-Z]:" process-lines "--exec-path" nil t string-match (error) "mount" > :key #[257 "\211@A\211\211G\266\202\207" [] 6 "\n\n(fn ARG0)"]] 10] "Alist of (CYGWIN . WIN32) directory names.\nSorted from longest to shortest CYGWIN name." :package-version (magit . "2.3.0") :group magit-process :type (alist :key-type string :value-type directory)] 10)
#@17 
 
(fn FILENAME)
(defalias 'magit-expand-git-file-name #[257 "\301!\204 \302!\262\303\304\305$\211\203:\211A\262\242\211\2034\211\203.\211G\306OP\202/\262\2025\262\202;\207" [magit-cygwin-mount-points file-name-absolute-p expand-file-name cl-assoc :test #[514 "\300\"\207" [string-prefix-p] 5 "\n\n(fn F CYG)"] nil] 8 (#$ . 31931)])
#@192 Convert FILENAME so that it can be passed to git.
1. If it's a remote filename, then remove the remote part.
2. Deal with an `windows-nt' Emacs vs. Cygwin Git incompatibility.
 
(fn FILENAME)
(defalias 'magit-convert-filename-for-git #[257 "\301!\203L\302\303\304$\211\203C\211A\262\242\211\2036\211\203)G\305OP\2021\306\307\"\2061\262\202>\306\307\"\206>\262\202K\306\307\"\206K\207\207" [magit-cygwin-mount-points file-name-absolute-p cl-rassoc :test #[514 "\300\"\207" [string-prefix-p] 5 "\n\n(fn F WIN)"] nil file-remote-p localname] 8 (#$ . 32294)])
#@13 
 
(fn PATH)
(defalias 'magit-decode-git-path #[257 "\211\302H\303=\203\304\305!\206    @\306#\207\207" [magit-git-output-coding-system default-process-coding-system 0 34 decode-coding-string read t] 5 (#$ . 32884)])
(defalias 'magit-file-at-point #[0 "\300 \211\203\301\302\"\203\303\304\"\202\"\211\205\"\301\305\"\205\"\306!\207" [magit-current-section magit-section-match-1 file eieio-oref value hunk magit-section-parent-value] 4])
(defalias 'magit-current-file #[0 "\301 \206\302 \206\303\304!\205\3058@\207" [magit-refresh-args magit-file-relative-name magit-file-at-point derived-mode-p magit-log-mode 2] 2])
#@63 Return t if there is no commit in the current Git repository.
(defalias 'magit-no-commit-p #[0 "\300\301!?\207" [magit-rev-verify "HEAD"] 2 (#$ . 33527)])
#@52 Return t if COMMIT is a merge commit.
 
(fn COMMIT)
(defalias 'magit-merge-commit-p #[257 "\300!G\301V\207" [magit-commit-parents 1] 3 (#$ . 33688)])
#@168 Return t if there are any staged changes.
If optional FILES is non-nil, then only changes to those files
are considered.
 
(fn &optional IGNORE-SUBMODULES &rest FILES)
(defalias 'magit-anything-staged-p #[384 "\300\301\302\303\205    \304\305&\207" [magit-git-failure "diff" "--quiet" "--cached" "--ignore-submodules" "--"] 9 (#$ . 33845)])
#@170 Return t if there are any unstaged changes.
If optional FILES is non-nil, then only changes to those files
are considered.
 
(fn &optional IGNORE-SUBMODULES &rest FILES)
(defalias 'magit-anything-unstaged-p #[384 "\300\301\302\205\303\304%\207" [magit-git-failure "diff" "--quiet" "--ignore-submodules" "--"] 8 (#$ . 34194)])
#@180 Return t if there are any staged or unstaged changes.
If optional FILES is non-nil, then only changes to those files
are considered.
 
(fn &optional IGNORE-SUBMODULES &rest FILES)
(defalias 'magit-anything-modified-p #[384 "\300\301#\206 \300\302#\207" [apply magit-anything-staged-p magit-anything-unstaged-p] 6 (#$ . 34530)])
#@143 Return t if there are any merge conflicts.
If optional FILES is non-nil, then only conflicts in those files
are considered.
 
(fn &rest FILES)
(defalias 'magit-anything-unmerged-p #[128 "\300\301\302#\205    \303\207" [magit-git-string "ls-files" "--unmerged" t] 5 (#$ . 34869)])
#@15 
 
(fn MODULE)
(defalias 'magit-module-worktree-p #[257 "\301 \211\203\211\302\303\211\304\"!!)\202\305 \207" [default-directory magit-toplevel file-exists-p expand-file-name ".git" magit--not-inside-repository-error] 7 (#$ . 35153)])
#@15 
 
(fn MODULE)
(defalias 'magit-module-no-worktree-p #[257 "\300!?\207" [magit-module-worktree-p] 3 (#$ . 35399)])
(defalias 'magit-ignore-submodules-p #[0 "\301\302\"\207" [magit-diff-section-arguments cl-find-if #[257 "\300\301\"\207" [string-prefix-p "--ignore-submodules"] 4 "\n\n(fn ARG)"]] 3])
#@115 Execute `git rev-parse ARGS', returning first line of output.
If there is no output, return nil.
 
(fn &rest ARGS)
(defalias 'magit-rev-parse #[128 "\300\301\302#\207" [apply magit-git-string "rev-parse"] 5 (#$ . 35708)])
#@169 Execute `git rev-parse ARGS', returning first line of output.
If there is no output, return nil.  Like `magit-rev-parse' but
ignore `magit-git-debug'.
 
(fn &rest ARGS)
(defalias 'magit-rev-parse-safe #[128 "\300\301\302#\207" [apply magit-git-str "rev-parse"] 5 (#$ . 35937)])
#@159 Execute `git rev-parse ARGS', returning t if it prints "true".
If it prints "false", then return nil.  For any other output
signal an error.
 
(fn &rest ARGS)
(defalias 'magit-rev-parse-true #[128 "\300\301\"\207" [magit-git-true "rev-parse"] 4 (#$ . 36222)])
#@159 Execute `git rev-parse ARGS', returning t if it prints "false".
If it prints "true", then return nil.  For any other output
signal an error.
 
(fn &rest ARGS)
(defalias 'magit-rev-parse-false #[128 "\300\301\"\207" [magit-git-false "rev-parse"] 4 (#$ . 36489)])
#@178 Execute `git rev-parse ARGS', returning t if it prints "true".
Return t if the first (and usually only) output line is the
string "true", otherwise return nil.
 
(fn &rest ARGS)
(defalias 'magit-rev-parse-p #[128 "\300\301\"\302\232\207" [magit-git-str "rev-parse" "true"] 4 (#$ . 36758)])
#@12 
 
(fn REV)
(defalias 'magit-rev-verify #[257 "\300\301\"\207" [magit-rev-parse-safe "--verify"] 4 (#$ . 37054)])
#@68 Return full hash for REV if it names an existing commit.
 
(fn REV)
(defalias 'magit-rev-verify-commit #[257 "\300\301P!\207" [magit-rev-verify "^{commit}"] 4 (#$ . 37174)])
#@12 
 
(fn A B)
(defalias 'magit-rev-equal #[514 "\300\301\302$\207" [magit-git-success "diff" "--quiet"] 7 (#$ . 37354)])
#@12 
 
(fn A B)
(defalias 'magit-rev-eq #[514 "\300!\300!\205\211\205\232\207" [magit-rev-verify] 6 (#$ . 37480)])
#@66 Return non-nil if commit A is an ancestor of commit B.
 
(fn A B)
(defalias 'magit-rev-ancestor-p #[514 "\300\301\302$\207" [magit-git-success "merge-base" "--is-ancestor"] 7 (#$ . 37605)])
#@12 
 
(fn REV)
(defalias 'magit-rev-head-p #[257 "\211\301\232\206\"\211\205\"\302\303\304\305#)\266\203?\205\"\306!\306\301!\232\207" [inhibit-changing-match-data "HEAD" "\\.\\." nil t string-match magit-rev-parse] 8 (#$ . 37802)])
#@185 Return t if the user is the author of REV.
More precisely return t if `user.name' is equal to the author
name of REV and/or `user.email' is equal to the author email
of REV.
 
(fn REV)
(defalias 'magit-rev-author-p #[257 "\300\301!\302\303\"\232\206\300\304!\302\305\"\232\207" [magit-get "user.name" magit-rev-format "%an" "user.email" "%ae"] 5 (#$ . 38047)])
#@362 Return a symbolic name for REV.
PATTERN is passed to the `--refs' flag of `git-name-rev' and can
be used to limit the result to a matching ref.  When structured
as "refs/<subdir>/*", PATTERN is taken as a namespace.  In this
case, the name returned by `git-name-rev' is discarded if it
corresponds to a ref outside of the namespace.
 
(fn REV &optional PATTERN)
(defalias 'magit-rev-name #[513 "\301\302\303\304\205 \305P%\211\205K\203J\306\307\310\311#)\266\203\203J\312\313O\211\307\310\311#)\266\203\205@\314P!??\205E\262\202K\211\207" [inhibit-changing-match-data magit-git-string "name-rev" "--name-only" "--no-undefined" "--refs=" "\\`refs/[^/]+/\\*\\'" nil t string-match 0 -1 magit-rev-verify] 11 (#$ . 38418)])
#@12 
 
(fn REV)
(defalias 'magit-rev-branch #[257 "\301\302\"\211\205\303\304\305\306#)\266\203?\205\211\207" [inhibit-changing-match-data magit-rev-name "refs/heads/*" "[~^]" nil t string-match] 9 (#$ . 39170)])
#@12 
 
(fn REV)
(defalias 'magit-get-shortname #[257 "\300\301\"\211\302!\206\211\303!\206\211\304!\211\204\305\306\"\202<\307\310\"\2039\311\312\313\"!\2032\211\202<\312\313\"\202<\314!\207" [apply-partially magit-rev-name "refs/tags/*" "refs/heads/*" "refs/remotes/*" magit-rev-parse "--short" string-match "^\\(?:tags\\|remotes\\)/\\(.+\\)" magit-ref-ambiguous-p match-string 1 magit-ref-maybe-qualify] 7 (#$ . 39394)])
#@26 
 
(fn REV &optional LAX)
(defalias 'magit-name-branch #[513 "\300!\206\301!\206\211\205\300\302\"\206\301\302\"\207" [magit-name-local-branch magit-name-remote-branch t] 5 (#$ . 39835)])
#@26 
 
(fn REV &optional LAX)
(defalias 'magit-name-local-branch #[513 "\301\302\"\211\205\204\303\304\305\306#)\266\203?\205\211\207" [inhibit-changing-match-data magit-rev-name "refs/heads/*" "[~^]" nil t string-match] 10 (#$ . 40040)])
#@26 
 
(fn REV &optional LAX)
(defalias 'magit-name-remote-branch #[513 "\301\302\"\211\205!\204\303\304\305\306#)\266\203?\205!\211\307\304O\207" [inhibit-changing-match-data magit-rev-name "refs/remotes/*" "[~^]" nil t string-match 8] 10 (#$ . 40293)])
#@26 
 
(fn REV &optional LAX)
(defalias 'magit-name-tag #[513 "\301\302\"\211\205!\204\303\304\305\306#)\266\203?\205!\211\307\304O\207" [inhibit-changing-match-data magit-rev-name "refs/tags/*" "[~^]" nil t string-match 5] 10 (#$ . 40560)])
#@139 Return fully qualified refname for NAME.
If NAME is ambiguous, return nil.  NAME may include suffixes such
as "^1" and "~3".  
 
(fn NAME)
(defalias 'magit-ref-fullname #[257 "\300 \301\302\303\304\305!\306\"\307$\216\310\311\"\203+\312\313\314\315\"\"\211\205&\211\314\316\"P\262\202.\317\320!)\207" [match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 string-match "\\`\\([^^~]+\\)\\(.*\\)" magit-rev-parse "--symbolic-full-name" match-string 1 2 error "`name' has an unrecognized format"] 8 (#$ . 40815)])
#@13 
 
(fn NAME)
(defalias 'magit-ref-ambiguous-p #[257 "\300!?\207" [magit-ref-fullname] 3 (#$ . 41378)])
#@84 If NAME is ambiguous, prepend PREFIX to it.
 
(fn NAME &optional (PREFIX "heads/"))
(defalias 'magit-ref-maybe-qualify #[385 "\211\203 \211A\262\242\202\300\203\301\302\303\304G\\D\"\210\305!\205#\211P\207" ["heads/" signal wrong-number-of-arguments magit-ref-maybe-qualify 2 magit-ref-ambiguous-p] 8 (#$ . 41487)])
#@12 
 
(fn REF)
(defalias 'magit-ref-exists-p #[257 "\300\301\302#\207" [magit-git-success "show-ref" "--verify"] 5 (#$ . 41820)])
#@165 Return t if the refs A and B are `equal'.
A symbolic-ref pointing to some ref, is `equal' to that ref,
as are two symbolic-refs pointing to the same ref.
 
(fn A B)
(defalias 'magit-ref-equal #[514 "\300!\300!\232\207" [magit-ref-fullname] 5 (#$ . 41954)])
#@176 Return t if the refs A and B are `eq'.
A symbolic-ref is `eq' to itself, but not to the ref it points
to, or to some other symbolic-ref that points to the same ref.
 
(fn A B)
(defalias 'magit-ref-eq #[514 "\300!\300!\203\211\203\232\206\"?\205\"\211?\205\"\301\"\207" [magit-symbolic-ref-p magit-ref-equal] 7 (#$ . 42219)])
#@68 Return "HEAD" or if that doesn't exist the hash of the empty tree.
(defalias 'magit-headish #[0 "\300 \203    \301\302!\207\303\207" [magit-no-commit-p magit-git-string "mktree" "HEAD"] 2 (#$ . 42564)])
(defalias 'magit-branch-at-point #[0 "\300 \211\203\301\302\"\203\303\304\"\202*\211\205*\301\305\"\205*\306 \206*\307\303\304\"!\207" [magit-current-section magit-section-match-1 branch eieio-oref value commit magit--painted-branch-at-point magit-name-branch] 5])
#@23 
 
(fn &optional TYPE)
(defalias 'magit--painted-branch-at-point #[256 "\211\300=\204\301`\302\"\303\304D>\203\305\306\307\310\"!A\2061\211\311=?\2051\301`\302\"\312\313D>\2051\306\307\310\"\207" [remote get-text-property face magit-branch-local magit-branch-current magit-split-branch-name thing-at-point git-revision t local magit-branch-remote magit-branch-remote-head] 5 (#$ . 43048)])
(defalias 'magit-local-branch-at-point #[0 "\300 \211\203 \301\302\"\203 \303\304\305\"!\211\306 \235\205\211\262\2027\211\2057\301\307\"\2057\310\311!\2067\312\304\305\"!\207" [magit-current-section magit-section-match-1 branch magit-ref-maybe-qualify eieio-oref value magit-list-local-branch-names commit magit--painted-branch-at-point local magit-name-local-branch] 5])
(defalias 'magit-remote-branch-at-point #[0 "\300 \211\203\301\302\"\203\303\304\"\211\305 \235\205\211\262\2025\211\2055\301\306\"\2055\307\310!\2065\311\303\304\"!\207" [magit-current-section magit-section-match-1 branch eieio-oref value magit-list-remote-branch-names commit magit--painted-branch-at-point remote magit-name-remote-branch] 5])
(defalias 'magit-commit-at-point #[0 "\301\302!\206\303\304!\205@\207" [magit-refresh-args magit-section-value-if commit derived-mode-p magit-revision-mode] 2])
(defalias 'magit-branch-or-commit-at-point #[0 "\206g\302 \211\203\303\304\"\203\305\306\307\"!\202R\211\203@\303\310\"\203@\311 \206R\306\307\"\312!\206;\313!\206;\211\262\202R\211\205R\303\314\"\205R\305\306\307\"\315\"\262\206g\316\317\320\"\206g\321\322\323\"\205g    @\207" [magit-buffer-refname magit-refresh-args magit-current-section magit-section-match-1 branch magit-ref-maybe-qualify eieio-oref value commit magit--painted-branch-at-point magit-name-branch magit-get-shortname tag "tags/" thing-at-point git-revision t derived-mode-p magit-revision-mode magit-merge-preview-mode] 5])
(defalias 'magit-tag-at-point #[0 "\300 \211\203\301\302\"\203\303\304\"\202%\211\205%\301\305\"\205%\306\303\304\"!\207" [magit-current-section magit-section-match-1 tag eieio-oref value commit magit-name-tag] 5])
(defalias 'magit-stash-at-point #[0 "\300\301!\207" [magit-section-value-if stash] 2])
(defalias 'magit-remote-at-point #[0 "\300 \211\203\301\302\"\203\303\304\"\202\"\211\205\"\301\305\"\205\"\306!\207" [magit-current-section magit-section-match-1 remote eieio-oref value branch magit-section-parent-value] 4])
#@28 
 
(fn &optional PREDICATE)
(defalias 'magit-module-at-point #[256 "\300\301!\205\302\303 \304\"\203!\205\211\262\207" [magit-section-match magit-module-section eieio-oref magit-current-section value] 4 (#$ . 45533)])
#@107 Return the refname of the currently checked out branch.
Return nil if no branch is currently checked out.
(defalias 'magit-get-current-branch #[0 "\300\301\302\303#\207" [magit-git-string "symbolic-ref" "--short" "HEAD"] 4 (#$ . 45767)])
#@85 Maximum time to spend in `magit-get-previous-branch'.
Given as a number of seconds.
(defvar magit-get-previous-branch-timeout 0.5 (#$ . 46011))
#@263 Return the refname of the previously checked out branch.
Return nil if no branch can be found in the `HEAD' reflog
which is different from the current branch and still exists.
The amount of time spent searching is limited by
`magit-get-previous-branch-timeout'.
(defalias 'magit-get-previous-branch #[0 "\301 \302 \303\304\301 ZV\203\304\211\262\202.\305\306\307\"!\211\262\2038\310!\211\262\2031\211\232\2038T\262\202\207" [magit-get-previous-branch-timeout float-time magit-get-current-branch 1 nil magit-rev-verify format "@{-%i}" magit-rev-branch] 8 (#$ . 46162)])
#@25 
 
(fn &optional BRANCH)
(defalias 'magit-get-upstream-ref #[256 "\211\204\f\300 \211\262\2059\301\302\303#\301\302\304#\2057\211\2057\305\230\203(\211\2027\306\307\"\2057\310\311\312\313OR\266\202\207" [magit-get-current-branch magit-get "branch" "remote" "merge" "." string-prefix-p "refs/heads/" "refs/remotes/" "/" 11 nil] 9 (#$ . 46755)])
#@24 
 
(fn BRANCH UPSTREAM)
(defalias 'magit-set-upstream-branch #[514 "\211\203(\300!\211@A\211\301\302\"\303\"\266\301\304\"\303\305P\"\262\266\202\207\306\307\310#\207" [magit-split-branch-name format "branch.%s.remote" magit-set "branch.%s.merge" "refs/heads/" magit-call-git "branch" "--unset-upstream"] 11 (#$ . 47119)])
#@32 
 
(fn &optional BRANCH VERIFY)
(defalias 'magit-get-upstream-branch #[512 "\204\f\301 \211\262\205i\302\303\304#\211\205\302\303\305#\211\205g\306\307\"\205g\211\310\311O\312\230\2037\313\314\315#\202Z\316\311\317\320#)\266\203\203R\313\321Q\314\322#\202Z\313\323Q\314\322#\203d\324!\205e\211\266\202\266\202\207" [inhibit-changing-match-data magit-get-current-branch magit-get "branch" "remote" "merge" string-prefix-p "refs/heads/" 11 nil "." propertize face magit-branch-local "[@:]" t string-match " " magit-branch-remote "/" magit-rev-verify] 12 (#$ . 47462)])
#@31 
 
(fn BRANCH &optional FORCE)
(defalias 'magit-get-indirect-upstream-branch #[513 "\302\303\304#\211\205{\211\305\232?\205{\204_\306\307\310\203W\203W@\203,\306\262\202K\311\312\313#\203;\211\232\202I\211\306\307\314#)\266\203\262\210\211T\262A\262\202\266\211\262\205{\315!\211\205y\211GT\306O\232\205y\316\"\205y\211\262\207" [magit-branch-prefer-remote-upstream inhibit-changing-match-data magit-get "branch" "remote" "." nil t 0 magit-git-success "check-ref-format" "--branch" string-match magit-get-upstream-branch magit-rev-ancestor-p] 15 (#$ . 48064)])
#@35 
 
(fn &optional BRANCH NON-LOCAL)
(defalias 'magit-get-upstream-remote #[512 "\204\300 \262\205\301\302\303#\205\211\304\232?\205\211\262\207" [magit-get-current-branch magit-get "branch" "remote" "."] 6 (#$ . 48674)])
#@25 
 
(fn &optional BRANCH)
(defalias 'magit-get-push-remote #[256 "\211\204\f\300 \211\262\203\301\302\303#\206\301\304!\207" [magit-get-current-branch magit-get "branch" "pushRemote" "remote.pushDefault"] 5 (#$ . 48913)])
#@32 
 
(fn &optional BRANCH VERIFY)
(defalias 'magit-get-push-branch #[512 "\204\f\300 \211\262\205,\301!\211\205\211\302Q\211\205*\203%\303!\205*\304\305\306#\266\202\207" [magit-get-current-branch magit-get-push-remote "/" magit-rev-verify propertize face magit-branch-remote] 8 (#$ . 49146)])
#@25 
 
(fn &optional BRANCH)
(defalias 'magit-get-@{push}-branch #[256 "\300\301\302P\"\211\205\303\304\"\205\211\305\306O\207" [magit-rev-parse "--symbolic-full-name" "@{push}" string-prefix-p "refs/remotes/" 13 nil] 5 (#$ . 49457)])
#@25 
 
(fn &optional BRANCH)
(defalias 'magit-get-remote #[256 "\211\204\f\300 \211\262\205\301\302\303#\211\304\232?\205\211\262\207" [magit-get-current-branch magit-get "branch" "remote" "."] 5 (#$ . 49699)])
#@25 
 
(fn &optional BRANCH)
(defalias 'magit-get-some-remote #[256 "\300!\206\301\302!\203\300\302!\206\303 \304\235@\206\211@\262\207" [magit-get-remote magit-branch-p "master" magit-list-remotes "origin"] 4 (#$ . 49919)])
#@475 Return non-nil if BRANCH is merged into its upstream and TARGET.
 
TARGET defaults to the current branch.  If `HEAD' is detached and
TARGET is nil, then always return nil.  As a special case, if
TARGET is t, then return non-nil if BRANCH is merged into any one
of the other local branches.
 
If, and only if, BRANCH has an upstream, then only return non-nil
if BRANCH is merged into both TARGET (as described above) as well
as into its upstream.
 
(fn BRANCH &optional TARGET)
(defalias 'magit-branch-merged-p #[513 "\300!\205    \301!\211\203\302\303\304$\202\305\262\205=\211\305=\203+\306\307!\310!\"\207\211\2061\311 \211\205;\302\303\304$\262\207" [magit-branch-p magit-get-upstream-branch magit-git-success "merge-base" "--is-ancestor" t delete magit-name-local-branch magit-list-containing-branches magit-get-current-branch] 8 (#$ . 50157)])
#@15 
 
(fn BRANCH)
(defalias 'magit-split-branch-name #[257 "\211\300 \235\203 \301B\207\302\303\"\203&\304\303\"\211@A\211@A\211B\266\202\207\302\305\"\205Z\211\306\211\224O\307 \310\306\311\312\313!\314\"\315$\216\316 \235)\262\203T\211\306\225\317OB\202X\320\321\"\262\207" [magit-list-local-branch-names "." string-match " " split-string "/" 0 match-data make-byte-code "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 magit-list-remotes nil error "Invalid branch name %s"] 10 (#$ . 51025)])
#@357 Return the closest tag reachable from REV.
 
If optional REV is nil, then default to `HEAD'.
If optional WITH-DISTANCE is non-nil then return (TAG COMMITS),
if it is `dirty' return (TAG COMMIT DIRTY). COMMITS is the number
of commits in `HEAD' but not in TAG and DIRTY is t if there are
uncommitted changes, nil otherwise.
 
(fn &optional REV WITH-DISTANCE)
(defalias 'magit-get-current-tag #[512 "\300\301\302\303\304=\205 \305%\211\205L\306 \307\310\311\312\313!\314\"\315$\216\316\317\"\210\203E\320\321\"\322\320\323\"\2066\324!\320\315\"\205@\325CBB\202I\320\321\")\262\207" [magit-git-str "describe" "--long" "--tags" dirty "--dirty" match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 string-match "\\(.+\\)-\\(?:0[0-9]*\\|\\([0-9]+\\)\\)-g[0-9a-z]+\\(-dirty\\)?$" match-string 1 string-to-number 2 "0" t] 10 (#$ . 51559)])
#@387 Return the closest tag from which REV is reachable.
 
If optional REV is nil, then default to `HEAD'.
If no such tag can be found or if the distance is 0 (in which
case it is the current tag, not the next), return nil instead.
If optional WITH-DISTANCE is non-nil, then return (TAG COMMITS)
where COMMITS is the number of commits in TAG but not in REV.
 
(fn &optional REV WITH-DISTANCE)
(defalias 'magit-get-next-tag #[512 "\300\301\302\206\303#\211\205D\304 \305\306\307\310\311!\312\"\313$\216\314\315\"\205A\316\306\"\262\317!\232?\205A\203@\320\"@D\202A)\262\207" [magit-git-str "describe" "--contains" "HEAD" match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 string-match "^[^^~]+" match-string magit-get-current-tag magit-rev-diff-count] 10 (#$ . 52453)])
(defvar magit-list-refs-namespaces '("refs/heads" "refs/remotes" "refs/tags" "refs/pull"))
#@490 Return list of references.
 
When NAMESPACES is non-nil, list refs from these namespaces
rather than those from `magit-list-refs-namespaces'.
 
FORMAT is passed to the `--format' flag of `git for-each-ref'
and defaults to "%(refname)".  If the format is "%(refname)"
or "%(refname:short)", then drop the symbolic-ref "HEAD".
 
SORTBY is a key or list of keys to pass to the `--sort' flag of
`git for-each-ref'.  When nil, use `magit-list-refs-sortby'
 
(fn &optional NAMESPACES FORMAT SORTBY)
(defalias 'magit-list-refs #[768 "\204\303\262\304\305\306P\307\310\206\211;\203 \211\211C\262\202-\211<\203,\211\211\262\202-\311\262\"\2066    $\312\235\203p\311\313\203g@\314\311\315\316#)\266\203\204[\211B\262\210\211T\262A\262\202@\266\211\237\262\202q\211\207" [magit-list-refs-sortby magit-list-refs-namespaces inhibit-changing-match-data "%(refname)" magit-git-lines "for-each-ref" "--format=" mapcar #[257 "\300P\207" ["--sort="] 3 "\n\n(fn IT)"] nil ("%(refname)" "%(refname:short)") 0 "\\(\\`\\|/\\)HEAD\\'" t string-match] 15 (#$ . 53376)])
(defalias 'magit-list-branches #[0 "\300\301\302D!\207" [magit-list-refs "refs/heads" "refs/remotes"] 3])
(defalias 'magit-list-local-branches #[0 "\300\301!\207" [magit-list-refs "refs/heads"] 2])
#@25 
 
(fn &optional REMOTE)
(defalias 'magit-list-remote-branches #[256 "\300\301P!\207" [magit-list-refs "refs/remotes/"] 4 (#$ . 54660)])
#@38 
 
(fn RELATION &optional COMMIT ARG)
(defalias 'magit-list-related-branches #[769 "\301\302\303\304\305$\"\306\2034@\307\301\310\311#)\266\203\204(\211B\262\210\211T\262A\262\202 \266\211\237\207" [inhibit-changing-match-data nil mapcar #[257 "\211\300\301O\207" [2 nil] 4 "\n\n(fn IT)"] magit-git-lines "branch" 0 "\\(\\`(HEAD\\|HEAD -> \\)" t string-match] 14 (#$ . 54803)])
#@29 
 
(fn &optional COMMIT ARG)
(defalias 'magit-list-containing-branches #[512 "\300\301#\207" [magit-list-related-branches "--contains"] 6 (#$ . 55207)])
#@25 
 
(fn &optional COMMIT)
(defalias 'magit-list-publishing-branches #[256 "\301\302\203!@\303\"\203\211B\262\210\211T\262A\262\202\266\211\237\207" [magit-published-branches nil 0 magit-rev-ancestor-p] 8 (#$ . 55367)])
#@29 
 
(fn &optional COMMIT ARG)
(defalias 'magit-list-merged-branches #[512 "\300\301#\207" [magit-list-related-branches "--merged"] 6 (#$ . 55606)])
#@29 
 
(fn &optional COMMIT ARG)
(defalias 'magit-list-unmerged-branches #[512 "\300\301#\207" [magit-list-related-branches "--no-merged"] 6 (#$ . 55760)])
(defalias 'magit-list-unmerged-to-upstream-branches #[0 "\300\301 \302\203,@\303!\211\205\304!\235\262\203 \211B\262\210\211T\262A\262\202\266\211\237\207" [nil magit-list-local-branch-names 0 magit-get-upstream-branch magit-list-unmerged-branches] 8])
#@15 
 
(fn COMMIT)
(defalias 'magit-list-branches-pointing-at #[257 "\300\301\302!\"\303\304\305!\306\203=@\307\"\205'\310\311\"\312\313\"?\205%\211\262\211\2030\211B\262\266\211T\262A\262\202 \266\211\237\262\207" [format "\\`%s refs/\\(heads\\|remotes\\)/\\(.*\\)\\'" magit-rev-verify nil magit-git-lines "show-ref" 0 string-match match-string 2 string-suffix-p "HEAD"] 10 (#$ . 56190)])
#@29 
 
(fn &optional NAMESPACES)
(defalias 'magit-list-refnames #[256 "\300\301\"\207" [magit-list-refs "%(refname:short)"] 4 (#$ . 56602)])
(defalias 'magit-list-branch-names #[0 "\300\301\302D!\207" [magit-list-refnames "refs/heads" "refs/remotes"] 3])
(defalias 'magit-list-local-branch-names #[0 "\300\301!\207" [magit-list-refnames "refs/heads"] 2])
#@34 
 
(fn &optional REMOTE RELATIVE)
(defalias 'magit-list-remote-branch-names #[512 "\203#\211\203#\300\301\"\302\303\304\305\306\307\310\311!\312\"\313\314%\315!\"\"\207\316\317P!\207" [format "^refs/remotes/%s/\\(.+\\)" apply append mapcar make-byte-code 257 "\301\300\"\205\f\302\303\"C\207" vconcat vector [string-match match-string 1] 4 "\n\n(fn IT)" magit-list-remote-branches magit-list-refnames "refs/remotes/"] 12 (#$ . 56959)])
#@26 
 
(fn FORMAT &rest ARGS)
(defalias 'magit-format-refs #[385 "\301\302\303P\206 \304\305\306E#\307\310\311\312#)\266\203\203%\313\314\"\202&\211\207" [inhibit-changing-match-data magit-git-lines "for-each-ref" "--format=" "refs/heads" "refs/remotes" "refs/tags" "\f" nil t string-match mapcar #[257 "\300\301\"\207" [split-string "\f"] 4 "\n\n(fn IT)"]] 10 (#$ . 57412)])
(defalias 'magit-list-remotes #[0 "\300\301!\207" [magit-git-lines "remote"] 2])
(defalias 'magit-list-tags #[0 "\300\301!\207" [magit-git-lines "tag"] 2])
#@25 
 
(fn &optional FORMAT)
(defalias 'magit-list-stashes #[256 "\300\301\302\303\206    \304P#\207" [magit-git-lines "stash" "list" "--format=" "%gd"] 6 (#$ . 57957)])
#@72 Return notes refs according to `core.notesRef' and `notes.displayRef'.
(defalias 'magit-list-active-notes-refs #[0 "\300\301\302\303\304!\206\n\305\306\307!$\207" [magit-git-lines "for-each-ref" "--format=%(refname)" magit-get "core.notesRef" "refs/notes/commits" magit-get-all "notes.displayRef"] 6 (#$ . 58127)])
(defalias 'magit-list-notes-refnames #[0 "\300\301\302\303!\"\207" [mapcar #[257 "\211\300\301O\207" [6 nil] 4 "\n\n(fn IT)"] magit-list-refnames "refs/notes"] 4])
#@15 
 
(fn REMOTE)
(defalias 'magit-remote-list-tags #[257 "\301\302\303\304#\305\2038@\306\301\307\310#)\266\203?\205\"\211\311\301O\211\203+\211B\262\266\211T\262A\262\202\266\211\237\207" [inhibit-changing-match-data nil magit-git-lines "ls-remote" "--tags" 0 "\\^{}$" t string-match 51] 12 (#$ . 58613)])
#@15 
 
(fn REMOTE)
(defalias 'magit-remote-list-branches #[257 "\301\302\303\304#\305\2038@\306\301\307\310#)\266\203?\205\"\211\311\301O\211\203+\211B\262\266\211T\262A\262\202\266\211\237\207" [inhibit-changing-match-data nil magit-git-lines "ls-remote" "--heads" 0 "\\^{}$" t string-match 52] 12 (#$ . 58943)])
#@15 
 
(fn REMOTE)
(defalias 'magit-remote-list-refs #[257 "\301\302\303\"\304\2037@\305\301\306\307#)\266\203?\205!\211\310\301O\211\203*\211B\262\266\211T\262A\262\202\266\211\237\207" [inhibit-changing-match-data nil magit-git-lines "ls-remote" 0 "\\^{}$" t string-match 41] 12 (#$ . 59278)])
(defalias 'magit-list-module-paths #[0 "\300\301\302\303\304\305\306\307#\"\"\207" [apply append mapcar #[257 "\300\301\"\205\f\302\303\"C\207" [string-match "^160000 [0-9a-z]\\{40\\} 0    \\(.+\\)$" match-string 1] 4 "\n\n(fn IT)"] magit-git-items "ls-files" "-z" "--stage"] 8])
#@103 Return the name of the submodule at PATH.
PATH has to be relative to the super-repository.
 
(fn PATH)
(defalias 'magit-get-submodule-name #[257 "\300\301\302\303\304\305\306\307 \"\310\311\312\313\314 !!\315Q&\206\316\317\"@\320\"A@\207" [split-string magit-git-items "config" "-z" "-f" expand-file-name ".gitmodules" magit-toplevel "--get-regexp" "^submodule\\..*\\.path$" "^" regexp-quote directory-file-name "$" error "No such submodule `%s'" "\n"] 13 (#$ . 59876)])
(defalias 'magit-list-worktrees #[0 "\302\211\303\304\"\305\306\307\310#)\211\203\252\211@\311\306\"\203,\211\312\302O\302\211\211F\211\262B\262\202\243\211\313\230\203u@\314\315!?\205?\316\317!\211\203i\320\321!!\203i\211\321!\240\266AA\211\322\323!\240\266\324\233\211\325 \240\266\202pA\211\326\240\266)\210\202\243\311\323\"\203\212AA\211\327\302O\240\266\202\243\311\330\"\203\237\324\233\211\331\302O\240\266\202\243\211\332\230\210A\266\202\202 \210\237\207" [magit-git-global-arguments default-directory nil remove "--no-pager" magit-git-lines "worktree" "list" "--porcelain" string-prefix-p 9 "bare" magit-get-boolean "core.bare" magit-get "core.worktree" file-exists-p expand-file-name magit-rev-parse "HEAD" 3 magit-get-current-branch t 5 "branch" 18 "detached"] 9])
#@13 
 
(fn NAME)
(defalias 'magit-symbolic-ref-p #[257 "\300\301\302#\207" [magit-git-success "symbolic-ref" "--quiet"] 5 (#$ . 61177)])
#@12 
 
(fn REV)
(defalias 'magit-ref-p #[257 "\211\300 \235@\206 \211\301 \235@\207" [magit-list-refs magit-list-refnames] 3 (#$ . 61316)])
#@12 
 
(fn REV)
(defalias 'magit-branch-p #[257 "\211\300 \235@\206 \211\301 \235@\207" [magit-list-branches magit-list-branch-names] 3 (#$ . 61458)])
#@12 
 
(fn REV)
(defalias 'magit-local-branch-p #[257 "\211\300 \235@\206 \211\301 \235@\207" [magit-list-local-branches magit-list-local-branch-names] 3 (#$ . 61611)])
#@12 
 
(fn REV)
(defalias 'magit-remote-branch-p #[257 "\211\300 \235@\206 \211\301 \235@\207" [magit-list-remote-branches magit-list-remote-branch-names] 3 (#$ . 61782)])
#@15 
 
(fn BRANCH)
(defalias 'magit-branch-set-face #[257 "\300\301\302!\203 \303\202\304#\207" [propertize face magit-local-branch-p magit-branch-local magit-branch-remote] 6 (#$ . 61956)])
#@12 
 
(fn REV)
(defalias 'magit-tag-p #[257 "\211\300 \235@\207" [magit-list-tags] 3 (#$ . 62153)])
#@15 
 
(fn STRING)
(defalias 'magit-remote-p #[257 "\211\300 \235@\207" [magit-list-remotes] 3 (#$ . 62255)])
#@103 Return the commits in A but not B and vice versa.
Return a list of two integers: (A>B B>A).
 
(fn A B)
(defalias 'magit-rev-diff-count #[514 "\300\301\302\303\304\305\306\307    Q$\310\"\"\207" [mapcar string-to-number split-string magit-git-string "rev-list" "--count" "--left-right" "..." "    "] 12 (#$ . 62367)])
(defalias 'magit-abbrev-length #[0 "\300\301!\211\203 \302!\202.\303\304\305\"\211\203\211G\202\306\262\303\304\307\"\211\203*\211G\202+\306\262^\207" [magit-get "core.abbrev" string-to-number magit-rev-parse "--short" "HEAD" 7 "HEAD~"] 5])
#@22 
 
(fn &optional ARG)
(defalias 'magit-abbrev-arg #[256 "\300\301\206\302\303 #\207" [format "--%s=%d" "abbrev" magit-abbrev-length] 5 (#$ . 62938)])
#@12 
 
(fn REV)
(defalias 'magit-rev-abbrev #[257 "\300\301\302!\"\207" [magit-rev-parse magit-abbrev-arg "short"] 4 (#$ . 63096)])
#@30 
 
(fn COMMIT &optional ARGS)
(defalias 'magit-commit-children #[513 "\300\301\302\300\303\304\305\306\206\307\310\311E\312 %\"\313\2036@A\235\203*\211B\262\210\211T\262A\262\202\266\211\237\262\"\207" [mapcar car nil #[257 "\300\301\"\207" [split-string " "] 4 "\n\n(fn IT)"] magit-git-lines "log" "--format=%H %P" "--branches" "--tags" "--remotes" "--not" 0] 13 (#$ . 63230)])
#@15 
 
(fn COMMIT)
(defalias 'magit-commit-parents #[257 "\300\301\302\303$\211\205\304!A\207" [magit-git-string "rev-list" "-1" "--parents" split-string] 6 (#$ . 63636)])
#@12 
 
(fn REV)
(defalias 'magit-patch-id #[257 "\303\304!r\211q\210\305\306\307\310\311!\312\"\313$\216\314\315\316\315    \317\n!\320\321 $\262&\210\322\323 !@*\207" [shell-file-name shell-command-switch magit-git-executable generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205    \302\300!\207" vconcat vector [buffer-name kill-buffer] 2 magit-process-file nil (t nil) shell-quote-argument format "%s diff-tree -u %s | %s patch-id" split-string buffer-string] 14 (#$ . 63813)])
#@34 
 
(fn FORMAT &optional REV ARGS)
(defalias 'magit-rev-format #[769 "\300\301\302\303P\203\304P\202\305\306&\211\307\230?\205 \211\207" [magit-git-string "show" "--no-patch" "--format=" "^{commit}" "HEAD" "--" ""] 10 (#$ . 64306)])
#@34 
 
(fn FORMAT &optional REV ARGS)
(defalias 'magit-rev-insert-format #[769 "\300\301\302\303P\203\304P\202\305\306&\207" [magit-git-insert "show" "--no-patch" "--format=" "^{commit}" "HEAD" "--"] 10 (#$ . 64556)])
#@12 
 
(fn REV)
(defalias 'magit-format-rev-summary #[257 "\300\301\"\211\205\302\303\"\210\304\305\211\224\306\307%\210\211\207" [magit-rev-format "%h %s" string-match " " put-text-property 0 face magit-hash] 8 (#$ . 64787)])
#@492 How refs are formatted for display.
 
Each entry controls how a certain type of ref is displayed, and
has the form (REGEXP . FACE).  REGEXP is a regular expression
used to match full refs.  The first entry whose REGEXP matches
the reference is used.
 
In log and revision buffers the first regexp submatch becomes the
"label" that represents the ref and is propertized with FONT.
In refs buffers the displayed text is controlled by other means
and this option only controls what face is used.
(defvar magit-ref-namespaces '(("\\`HEAD\\'" . magit-head) ("\\`refs/tags/\\(.+\\)" . magit-tag) ("\\`refs/heads/\\(.+\\)" . magit-branch-local) ("\\`refs/remotes/\\(.+\\)" . magit-branch-remote) ("\\`refs/bisect/\\(bad\\)" . magit-bisect-bad) ("\\`refs/bisect/\\(skip.*\\)" . magit-bisect-skip) ("\\`refs/bisect/\\(good.*\\)" . magit-bisect-good) ("\\`refs/stash$" . magit-refname-stash) ("\\`refs/wip/\\(.+\\)" . magit-refname-wip) ("\\`refs/pullreqs/\\(.+\\)" . magit-refname-pullreq) ("\\`\\(bad\\):" . magit-bisect-bad) ("\\`\\(skip\\):" . magit-bisect-skip) ("\\`\\(good\\):" . magit-bisect-good) ("\\`\\(.+\\)" . magit-refname)) (#$ . 65021))
#@15 
 
(fn STRING)
(defalias 'magit-format-ref-labels #[257 "\302\303\304\302\305\304##\262\306 \307\310\311\312\313!\314\"\315$\216\316\317\320\321!\203T\322A@\235\203T\323 \324\325\326\327 !\"\330\307\331\332\312\313\"\333\"\334\335%\336\302\337\340 #\341#\"\266\203\202[\336\341#\262\317\211\211\211\211\211\211\211\211\203\n\211@\317    \341\310\203\233\203\233@\203\203\317\262\202\217\342@\"\203\217\211\262\210\211T\262A\262\202o\266\211\262A\343\344\345\"\206\252\346#\347\350\"\203\272\211\262\f\202\351\352\"\203\313\343\353\346\352#\262 \202\351\354\"\203\333\211    B\262    \202\351\355\"\203\353\211B\262\202\351\356\"\203\373\211B\262\202\211B\262\266A\266\202\202e\210\357\360\"\262\361 \362\341\"\211\203p\211@\363!\235@\211\203<\364    \"\262\342\365\"\210\211\310\211\225O\262\232\203N\211\343\346\366#P\262\f\202h\232\203`\211\343\346\367#P\262 \202h\211PB\262\210A\266\202\202\210\211\203\261\204\261\211\235\203\226\370\310G\371\317%\210\211\262\364\"\262\202\261\211\235@\211\203\260\370\310G\371\317%\210\211\262    \364\"\262\210\266\372\373\374\n\n\n\375 \237\237 \237 $BBB!\376#\266\210\266\202)\207" [magit-refresh-args magit-ref-namespaces replace-regexp-in-string ")\\s-*\\'" "" "\\`\\s-*(" match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 "\\(, \\|tag: \\|HEAD -> \\)" nil derived-mode-p magit-log-mode "--simplify-by-decoration" magit-list-local-branch-names format "^%s/.+" regexp-opt magit-list-remotes mapcar 257 "\211\302\230\203\207\303\304\"\203\207\211\300\235\203\305P\207\306\301\"\203$\307P\207\304P\207" ["HEAD" string-prefix-p "refs/" "refs/heads/" string-match "refs/remotes/"] 4 "\n\n(fn IT)" split-string "tag: " "refs/tags/" t string-match propertize match-string 1 face memql (magit-bisect-bad magit-bisect-skip magit-bisect-good) eql magit-head "@" magit-tag magit-branch-local magit-branch-remote -keep #[257 "\300\301\"\203/\302\303\"\302\304\"\211\305\232?\205.\306P\307\310\311\312\"\"\232\203-\313\314\315#\202.\207\207" [string-match "\\`\\([^/]*\\)/\\(.*\\)\\'" match-string 1 2 "HEAD" "refs/remotes/" magit-git-string "symbolic-ref" format "refs/remotes/%s/HEAD" propertize face magit-branch-remote-head] 9 "\n\n(fn NAME)"] magit-get-current-branch magit-get-upstream-branch magit-get-push-branch delete "^[^/]*/" magit-branch-current (magit-branch-upstream magit-branch-local) add-face-text-property magit-branch-upstream mapconcat identity -flatten append " "] 23 (#$ . 66168)])
#@15 
 
(fn OBJECT)
(defalias 'magit-object-type #[257 "\300\301\302#\207" [magit-git-string "cat-file" "-t"] 5 (#$ . 68800)])
#@31 
 
(fn COMMIT FILE &rest BODY)
(defalias 'magit-with-blob '(macro . #[642 "\300\301\302DC\303\304\305\306\307\n\310BBFD\311BBBBD\207" [with-temp-buffer let buffer-file-name save-excursion magit-git-insert "cat-file" "-p" concat (":" buffer-file-name) (decode-coding-inserted-region (point-min) (point-max) buffer-file-name t nil nil t)] 13 (#$ . 68928)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put magit-with-blob lisp-indent-function 2 put edebug-form-spec (form form body)] 5)
#@28 
 
(fn TREE ARG &rest BODY)
(defalias 'magit-with-temp-index '(macro . #[642 "\300\301!\302\303\304BD\305\306\307\310\311\312 \313\314\315 E\257\316BBE\317\320\302\321\322\314\323\fE\324BBDC\nBB\302\325\322\314\323 E\326BBDC BBFE\327\330\314\331EDDEE\207" [cl-gensym "file" let (magit--refresh-cache nil) ((magit-convert-filename-for-git (make-temp-name (magit-git-dir "index.magit.")))) unwind-protect magit-with-toplevel --when-let or magit-git-success "read-tree" it concat "--index-output=" ((error "Cannot read tree %s" it)) if (file-remote-p default-directory) magit-tramp-process-environment cons "GIT_INDEX_FILE=" (magit-tramp-process-environment) process-environment (process-environment) ignore-errors delete-file (file-remote-p default-directory)] 18 (#$ . 69439)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put magit-with-temp-index lisp-indent-function 2 put edebug-form-spec (form form body)] 5)
#@45 
 
(fn MESSAGE &optional TREE &rest PARENTS)
(defalias 'magit-commit-tree #[641 "\300\301\302\303\304\305\306\307\310\311 \"\"\"\206\300\312!\206\313\314!&\207" [magit-git-string "commit-tree" "--no-gpg-sign" "-m" apply append mapcar #[257 "\300D\207" ["-p"] 3 "\n\n(fn IT)"] delq nil "write-tree" error "Cannot write tree"] 15 (#$ . 70387)])
#@50 
 
(fn MESSAGE &optional ARG &rest OTHER-PARENTS)
(defalias 'magit-commit-worktree #[641 "\304\305\306\307\310!!!\311\312\313\314\315!\316\"\317$\216\320 \211\203q\211\321\211\2035\322\323\324P$\2045\325\326\"\210\210\327    !\203V\330P\nB\331\332 !\205R\333\334\304\321%)\202m\330P B\331\332 !\205l\333\334\304\321%))\202s\335 \262*\207" [magit--refresh-cache default-directory magit-tramp-process-environment process-environment nil magit-convert-filename-for-git make-temp-name magit-git-dir "index.magit." make-byte-code 0 "\3021 \303\304    !\300P!0\207\210\305\207" vconcat vector [default-directory (error) delete-file file-remote-p nil] 3 magit-toplevel "HEAD" magit-git-success "read-tree" "--index-output=" error "Cannot read tree %s" file-remote-p "GIT_INDEX_FILE=" magit-update-files magit-unstaged-files apply magit-commit-tree magit--not-inside-repository-error] 13 (#$ . 70746)])
#@14 
 
(fn FILES)
(defalias 'magit-update-files #[257 "\300\301\302\303\304%\207" [magit-git-success "update-index" "--add" "--remove" "--"] 7 (#$ . 71672)])
#@43 
 
(fn REF MESSAGE REV &optional STASHISH)
(defalias 'magit-update-ref #[1027 "\301\302\303 \304\"\204#\305\306\307\310\311 !\206\312&\313U\202\223\311!\314\315P!\316!\204\203>\317\306\320$\210\321\322!\323\"\210\211\324\325\326!!\327\313\330\331\332!\333\"\334$\216r\211q\210)r\211q\210\335\301\211\301\313%\210*\266\203\204\317\306\310\336    \312&\210\266\317\306\310\311\n!\206\221\312&\206\233\337\340#)\207" [magit--refresh-cache nil version< magit-git-version "2.6.0" magit-call-git "update-ref" "--create-reflog" "-m" magit-rev-verify "" 0 magit-git-dir "logs/" file-exists-p magit-git-success "-d" make-directory file-name-directory t get-buffer-create generate-new-buffer-name " *temp file*" make-byte-code "\301\300!\205    \302\300!\207" vconcat vector [buffer-name kill-buffer] 2 write-region "enable reflog" error "Cannot update %s with %s"] 14 (#$ . 71832)])
(defconst magit-range-re "\\`\\([^     ]*[^.]\\)?\\(\\.\\.\\.?\\)\\([^.][^     ]*\\)?\\'")
#@14 
 
(fn RANGE)
(defalias 'magit-split-range #[257 "\301\"\205-\302\303\"\206\304\302\305\"\206\304\302\306\"\307\230\203(\310\311#\202)B\266\202\207" [magit-range-re string-match match-string 1 "HEAD" 3 2 "..." magit-git-string "merge-base"] 7 (#$ . 72841)])
#@63 Characters allowable in filenames, excluding space and colon.
(defvar magit-thingatpt--git-revision-chars "-_./[:alnum:]@{}^~!" (#$ . 73120))
(byte-code "\300\301\302\303#\210\300\301\304\305#\210\300\301\306\307#\207" [put git-revision end-op #[0 "\301\302\303Q\304\305#\207" [magit-thingatpt--git-revision-chars re-search-forward "\\=[" "]*" nil t] 4] beginning-op #[0 "\301\302\303Q\304\305#\203\304u\207eb\207" [magit-thingatpt--git-revision-chars re-search-backward "[^" "]" nil t] 4] thing-at-point magit-thingatpt--git-revision] 4)
(defalias 'magit-thingatpt--git-revision #[0 "\300\301!\211\205\302@A\"\303!\205\211\262\207" [bounds-of-thing-at-point git-revision buffer-substring-no-properties magit-rev-verify-commit] 4])
(defvar magit-revision-history nil)
#@43 
 
(fn PROMPT &optional SECONDARY-DEFAULT)
(defalias 'magit-read-branch #[513 "\300\301 \302\303\302\304\305 \206\206\306 &\207" [magit-completing-read magit-list-branch-names nil t magit-revision-history magit-branch-at-point magit-get-current-branch] 10 (#$ . 73906)])
#@43 
 
(fn PROMPT &optional SECONDARY-DEFAULT)
(defalias 'magit-read-branch-or-commit #[513 "\300\301\302 B\303\211\211\304\305 \206\206\306 &\206\307\310!\207" [magit-completing-read "HEAD" magit-list-refnames nil magit-revision-history magit-branch-or-commit-at-point magit-get-current-branch user-error "Nothing selected"] 10 (#$ . 74190)])
#@43 
 
(fn PROMPT &optional SECONDARY-DEFAULT)
(defalias 'magit-read-range-or-commit #[513 "\300\301\302\303\"\211\205\304 \210\305!@\306@Q\262\206%\307 \206%\206%\310 \"\207" [magit-read-range magit-region-values (commit branch) t deactivate-mark last ".." magit-branch-or-commit-at-point magit-get-current-branch] 8 (#$ . 74545)])
#@33 
 
(fn PROMPT &optional DEFAULT)
(defalias 'magit-read-range #[513 "\300\301 \302\303%\207" [magit-completing-read-multiple magit-list-refnames "\\.\\.\\.?" magit-revision-history] 8 (#$ . 74889)])
#@67 
 
(fn PROMPT &optional REMOTE DEFAULT LOCAL-BRANCH REQUIRE-MATCH)
(defalias 'magit-read-remote-branch #[1281 "\300\301\205&\203\302Q\202&\303\304\305\306\307\310\n!\311\"\312\313%\314 \"\315\316\"\"\317\317\320    &\204?\321\322\"\203C\211\202G\323\324\"\207" [magit-completing-read -union "/" mapcar make-byte-code 257 "\211\301\300Q\207" vconcat vector ["/"] 4 "\n\n(fn IT)" magit-list-remotes magit-list-remote-branch-names t nil magit-revision-history string-match "\\`\\([^/]+\\)/\\(.+\\)" user-error "`%s' doesn't have the form REMOTE/BRANCH"] 15 (#$ . 75094)])
#@22 
 
(fn PROMPT REMOTE)
(defalias 'magit-read-refspec #[514 "\300\301\302!\210\303!\301\304!\210\"\207" [magit-completing-read message "Determining available refs..." magit-remote-list-refs "Determining available refs...done"] 7 (#$ . 75689)])
#@43 
 
(fn PROMPT &optional SECONDARY-DEFAULT)
(defalias 'magit-read-local-branch #[513 "\300\301 \302\303\302\304\305 \206\206\306 &\207" [magit-completing-read magit-list-local-branch-names nil t magit-revision-history magit-local-branch-at-point magit-get-current-branch] 10 (#$ . 75938)])
#@15 
 
(fn PROMPT)
(defalias 'magit-read-local-branch-or-commit #[257 "\300 \301 \302\203B\202\303\211\211\304\305 \206&\206$\306\307!\207" [magit-list-local-branch-names magit-commit-at-point magit-completing-read nil magit-revision-history magit-local-branch-at-point user-error "Nothing selected"] 11 (#$ . 76240)])
#@43 
 
(fn PROMPT &optional SECONDARY-DEFAULT)
(defalias 'magit-read-local-branch-or-ref #[513 "\300\301 \302\303!\244\304\305\304\306\307 \206\206\310 &\207" [magit-completing-read magit-list-local-branch-names magit-list-refs "refs/" nil t magit-revision-history magit-local-branch-at-point magit-get-current-branch] 10 (#$ . 76575)])
#@68 
 
(fn PROMPT &optional EXCLUDE SECONDARY-DEFAULT NO-REQUIRE-MATCH)
(defalias 'magit-read-other-branch #[1025 "\300 \301 \206    \232\204\206#\232\204\206#\206#\302 \303\304\305 \"\306?\306\307&\207" [magit-get-current-branch magit-branch-at-point magit-get-previous-branch magit-completing-read delete magit-list-branch-names nil magit-revision-history] 16 (#$ . 76921)])
#@51 
 
(fn PROMPT &optional EXCLUDE SECONDARY-DEFAULT)
(defalias 'magit-read-other-branch-or-commit #[769 "\300 \301 \206    \232\204\206#\232\204\206#\206#\302 \303\304\305 \"\306\211\211\307&\2069\310\311!\207" [magit-get-current-branch magit-branch-or-commit-at-point magit-get-previous-branch magit-completing-read delete magit-list-refnames nil magit-revision-history user-error "Nothing selected"] 15 (#$ . 77321)])
#@68 
 
(fn PROMPT &optional EXCLUDE SECONDARY-DEFAULT NO-REQUIRE-MATCH)
(defalias 'magit-read-other-local-branch #[1025 "\300 \301 \206    \232\204\206#\232\204\206#\206#\302 \303\304\305 \"\306?\306\307&\207" [magit-get-current-branch magit-local-branch-at-point magit-get-previous-branch magit-completing-read delete magit-list-local-branch-names nil magit-revision-history] 16 (#$ . 77765)])
#@15 
 
(fn PROMPT)
(defalias 'magit-read-branch-prefer-other #[257 "\300 \301 \211\205 \302!\303 \304\305 \306\307\306\310\311\312!\206k\206kA\204,@\206k\306    \307\313\203[\203[@\203E\306\262\202O\211\232\204O\211\262\210\211T\262A\262\2021\266\211\262\206k\314 \206k@&\207" [magit-get-current-branch magit-commit-at-point magit-list-branches-pointing-at magit--painted-branch-at-point magit-completing-read magit-list-branch-names nil t magit-revision-history magit-section-value-if branch 0 magit-get-previous-branch] 19 (#$ . 78183)])
#@61 
 
(fn &optional (BRANCH (magit-get-current-branch)) PROMPT)
(defalias 'magit-read-upstream-branch #[128 "\211\203 \211A\262\242\202\301 \211A\262\242\203$\302\303\304\305G\\D\"\210\306\206-\307\310\"\311\312\313\314\315\316\317\n!\320\"\321\322%\323 \"\324\325 \"\"\326\211\211\327\330 \331 \211\203\\\211 \232\203\\\326\262\203h\206m\211\202m\211\206m\266\202\206\243\332\333!    \334\232?\205\200\332\334!\203\214\206\221\211\202\221\211\206\221\266\202\206\243\335 \211\n\232?\205\241\211\262&\207" [magit-prefer-remote-upstream magit-get-current-branch signal wrong-number-of-arguments magit-read-upstream-branch 2 magit-completing-read format "Change upstream of %s to" -union mapcar make-byte-code 257 "\211\301\300Q\207" vconcat vector ["/"] 4 "\n\n(fn IT)" magit-list-remotes delete magit-list-branch-names nil magit-revision-history magit-remote-branch-at-point magit-branch-at-point magit-branch-p "origin/master" "master" magit-get-previous-branch] 14 (#$ . 78759)])
#@32 
 
(fn PROMPT &optional BRANCH)
(defalias 'magit-read-starting-point #[513 "\301\205\302\300!\203\203\303\304\"\202\305\306\307\310#P\311Q\312C\313 \244\314\315 \316\317#\244\316\211\211\320\321 &\206:\322\323!\207" [ivy-mode magit-completing-read boundp format " `%s'" " " propertize face magit-branch-local " starting at" "HEAD" magit-list-refnames directory-files magit-git-dir nil "_HEAD\\'" magit-revision-history magit--default-starting-point user-error "Nothing selected"] 10 (#$ . 79783)])
(defalias 'magit--default-starting-point #[0 "\301 \302 \203\206\211\202\211\206\266\202\206&\303 \206&\304 \206&\305 \207" [magit-prefer-remote-upstream magit-remote-branch-at-point magit-local-branch-at-point magit-commit-at-point magit-stash-at-point magit-get-current-branch] 3])
#@39 
 
(fn PROMPT &optional REQUIRE-MATCH)
(defalias 'magit-read-tag #[513 "\300\301 \302\302\303\304 &\207" [magit-completing-read magit-list-tags nil magit-revision-history magit-tag-at-point] 10 (#$ . 80599)])
#@15 
 
(fn PROMPT)
(defalias 'magit-read-stash #[257 "\300 \301\302\303\302\211\304 @&\207" [magit-list-stashes magit-completing-read nil t magit-stash-at-point] 11 (#$ . 80816)])
#@42 
 
(fn PROMPT &optional DEFAULT USE-ONLY)
(defalias 'magit-read-remote #[769 "\300 \203\211G\301U\203\211@\202'\302\303\304\303\211    \206%\305 \206%\306 &\207" [magit-list-remotes 1 magit-completing-read nil t magit-remote-at-point magit-get-remote] 12 (#$ . 81002)])
#@33 
 
(fn PROMPT &optional DEFAULT)
(defalias 'magit-read-remote-or-url #[513 "\300\301 \302\303\304E\244\305\211\211\211\206\306 \206\307 &\207" [magit-completing-read magit-list-remotes "https://" "git://" "git@" nil magit-remote-at-point magit-get-remote] 10 (#$ . 81286)])
#@35 
 
(fn PROMPT &optional PREDICATE)
(defalias 'magit-read-module-path #[513 "\300\301 \302\303\211\304!&\207" [magit-completing-read magit-list-module-paths t nil magit-module-at-point] 11 (#$ . 81573)])
#@33 
 
(fn VERB &optional PREDICATE)
(defalias 'magit-module-confirm #[513 "\301\203*\302 \262\203\303\"\262\211\204F\203#\304\305\"\210\202F\304\306!\210\202F\307\310!\262\211\203F\203=\303\"\262\211\204F\304\311\"\210\211G\312V\203[\313\314\301\315\316\"\301%\202c\317\315\320\"\"C\207" [current-prefix-arg nil magit-list-module-paths -filter user-error "No modules satisfying %s available" "No modules available" magit-region-values magit-module-section "No modules satisfying %s selected" 1 magit-confirm t format "%s %%i modules" magit-read-module-path "%s module"] 9 (#$ . 81786)])
#@40 
 
(fn VARIABLE WIDTH &optional GLOBAL)
(defalias 'magit--format-popup-variable:value #[770 "\300\301\302\303G#]\304\"\305\205\306\"\211\203\"\307\310\311#\202'\307\312\310\313#\262Q\207" [make-string 1 - 3 32 magit-get "--global" propertize face magit-popup-option-value "unset" magit-popup-disabled-argument] 10 (#$ . 82406)])
#@40 
 
(fn VARIABLE WIDTH &optional GLOBAL)
(defalias 'magit--format-popup-variable:values #[770 "\300\301\302\303G#]\304\"\305\205\306\"\211\2036\307@\310\311#\312\313\314\315\316\317 !\320\"\321\322%A\323#P\202;\307\324\310\325#\262Q\207" [make-string 1 - 3 32 magit-get-all "--global" propertize face magit-popup-option-value mapconcat make-byte-code 257 "\301\302\300\303\"\304\305\306#Q\207" vconcat vector ["\n" make-string 32 propertize face magit-popup-option-value] 7 "\n\n(fn VALUE)" "" "unset" magit-popup-disabled-argument] 14 (#$ . 82753)])
#@49 
 
(fn VARIABLE CHOICES &optional DEFAULT OTHER)
(defalias 'magit--set-popup-variable #[1026 "\302\303\304\305#\211\203\211\235A@\202@\262\"\210\206    \211\203.r\211q\210\306 \210)\2021\306 \210\210\307\310\311$#\207" [magit-current-pre-popup-buffer magit-pre-popup-buffer magit-set magit-git-string "config" "--local" magit-refresh message "%s %s" magit--format-popup-variable:choices*] 12 (#$ . 83324)])
#@55 
 
(fn VARIABLE CHOICES &optional DEFAULT OTHER WIDTH)
(defalias 'magit--format-popup-variable:choices #[1282 "\203\300GZ\301\"\202\302\303$Q\207" [make-string 32 " " magit--format-popup-variable:choices*] 12 (#$ . 83757)])
#@49 
 
(fn VARIABLE CHOICES &optional DEFAULT OTHER)
(defalias 'magit--format-popup-variable:choices* #[1026 "\300\301\302#\300\301\303#\203\304!\211\205\305Q\262\262\306\307\310\311#\312\313\314\315\316\317!\320\"\321\322%\306\323\310\311##\204F\204F\205\233\306\323\310\311#\203n\306\324P\310\203]\311\202j \235\203i\325\202j\326#\202\232\203\204\306\310\203\311\202\200\325#\202\232\205\232\306\327P\310\203\230\311\202\231\325#P\306\330\310\311#R\207" [magit-git-string "config" "--local" "--global" magit-get ":" propertize "[" face magit-popup-disabled-argument mapconcat make-byte-code 257 "\301\302\300\232\203 \303\202\304#\207" vconcat vector [propertize face magit-popup-option-value magit-popup-disabled-argument] 6 "\n\n(fn CHOICE)" "|" "global:" magit-popup-option-value font-lock-warning-face "default:" "]"] 14 (#$ . 84003)])
(provide 'magit-git)