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

Chizi123
2018-11-17 5cb5f70b1872a757e93ea333b0e2dca50c6c8957
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
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
2271
2272
2273
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295
2296
2297
2298
2299
2300
2301
2302
2303
2304
2305
2306
2307
2308
2309
2310
2311
2312
2313
2314
2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
2330
2331
2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386
2387
2388
2389
2390
2391
2392
2393
2394
2395
2396
2397
2398
2399
2400
2401
2402
2403
2404
2405
2406
2407
2408
2409
2410
2411
2412
2413
2414
2415
2416
2417
2418
2419
2420
2421
2422
2423
2424
2425
2426
2427
2428
2429
2430
2431
2432
2433
2434
2435
2436
2437
2438
2439
2440
2441
2442
2443
2444
2445
2446
2447
2448
2449
2450
2451
2452
2453
2454
2455
2456
2457
2458
2459
2460
2461
2462
2463
2464
2465
2466
2467
2468
2469
2470
2471
2472
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482
2483
2484
2485
2486
2487
2488
2489
2490
2491
2492
2493
2494
2495
2496
2497
2498
2499
2500
2501
2502
2503
2504
2505
2506
2507
2508
2509
2510
2511
2512
2513
2514
2515
2516
2517
2518
2519
2520
2521
2522
2523
2524
2525
2526
2527
2528
2529
2530
2531
2532
2533
2534
2535
2536
2537
2538
2539
2540
2541
2542
2543
2544
2545
2546
2547
2548
2549
2550
2551
2552
2553
2554
2555
2556
2557
2558
2559
2560
2561
2562
2563
2564
2565
2566
2567
2568
2569
2570
2571
2572
2573
2574
2575
2576
2577
2578
2579
2580
2581
2582
2583
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593
2594
2595
2596
2597
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608
2609
2610
2611
2612
2613
2614
2615
2616
2617
2618
2619
2620
2621
2622
2623
2624
2625
2626
2627
2628
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
2641
2642
2643
2644
2645
2646
2647
2648
2649
2650
2651
2652
2653
2654
2655
2656
2657
2658
2659
2660
2661
2662
2663
2664
2665
2666
2667
2668
2669
2670
2671
2672
2673
2674
2675
2676
2677
2678
2679
2680
2681
2682
2683
2684
2685
2686
2687
2688
2689
2690
2691
2692
2693
2694
2695
;;; magit-autoloads.el --- automatically extracted autoloads
;;
;;; Code:
 
(add-to-list 'load-path (directory-file-name
                         (or (file-name-directory #$) (car load-path))))
 
 
;;;### (autoloads nil "git-rebase" "git-rebase.el" (0 0 0 0))
;;; Generated autoloads from git-rebase.el
 
(autoload 'git-rebase-mode "git-rebase" "\
Major mode for editing of a Git rebase file.
 
Rebase files are generated when you run 'git rebase -i' or run
`magit-interactive-rebase'.  They describe how Git should perform
the rebase.  See the documentation for git-rebase (e.g., by
running 'man git-rebase' at the command line) for details.
 
\(fn)" t nil)
 
(defconst git-rebase-filename-regexp "/git-rebase-todo\\'")
 
(add-to-list 'auto-mode-alist (cons git-rebase-filename-regexp 'git-rebase-mode))
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "git-rebase" '("git-rebase-")))
 
;;;***
 
;;;### (autoloads nil "magit" "magit.el" (0 0 0 0))
;;; Generated autoloads from magit.el
 (autoload 'magit-dispatch-popup "magit" nil t)
 (autoload 'magit-run-popup "magit" nil t)
 
(autoload 'magit-git-command "magit" "\
Execute COMMAND asynchronously; display output.
 
Interactively, prompt for COMMAND in the minibuffer. \"git \" is
used as initial input, but can be deleted to run another command.
 
With a prefix argument COMMAND is run in the top-level directory
of the current working tree, otherwise in `default-directory'.
 
\(fn COMMAND)" t nil)
 
(autoload 'magit-git-command-topdir "magit" "\
Execute COMMAND asynchronously; display output.
 
Interactively, prompt for COMMAND in the minibuffer. \"git \" is
used as initial input, but can be deleted to run another command.
 
COMMAND is run in the top-level directory of the current
working tree.
 
\(fn COMMAND)" t nil)
 
(autoload 'magit-shell-command "magit" "\
Execute COMMAND asynchronously; display output.
 
Interactively, prompt for COMMAND in the minibuffer.  With a
prefix argument COMMAND is run in the top-level directory of
the current working tree, otherwise in `default-directory'.
 
\(fn COMMAND)" t nil)
 
(autoload 'magit-shell-command-topdir "magit" "\
Execute COMMAND asynchronously; display output.
 
Interactively, prompt for COMMAND in the minibuffer.  COMMAND
is run in the top-level directory of the current working tree.
 
\(fn COMMAND)" t nil)
 
(autoload 'magit-version "magit" "\
Return the version of Magit currently in use.
If optional argument PRINT-DEST is non-nil, output
stream (interactively, the echo area, or the current buffer with
a prefix argument), also print the used versions of Magit, Git,
and Emacs to it.
 
\(fn &optional PRINT-DEST)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit" '("magit-")))
 
;;;***
 
;;;### (autoloads nil "magit-apply" "magit-apply.el" (0 0 0 0))
;;; Generated autoloads from magit-apply.el
 
(autoload 'magit-stage-file "magit-apply" "\
Stage all changes to FILE.
With a prefix argument or when there is no file at point ask for
the file to be staged.  Otherwise stage the file at point without
requiring confirmation.
 
\(fn FILE)" t nil)
 
(autoload 'magit-stage-modified "magit-apply" "\
Stage all changes to files modified in the worktree.
Stage all new content of tracked files and remove tracked files
that no longer exist in the working tree from the index also.
With a prefix argument also stage previously untracked (but not
ignored) files.
 
\(fn &optional ALL)" t nil)
 
(autoload 'magit-unstage-file "magit-apply" "\
Unstage all changes to FILE.
With a prefix argument or when there is no file at point ask for
the file to be unstaged.  Otherwise unstage the file at point
without requiring confirmation.
 
\(fn FILE)" t nil)
 
(autoload 'magit-unstage-all "magit-apply" "\
Remove all changes from the staging area.
 
\(fn)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-apply" '("magit-")))
 
;;;***
 
;;;### (autoloads nil "magit-autorevert" "magit-autorevert.el" (0
;;;;;;  0 0 0))
;;; Generated autoloads from magit-autorevert.el
 
(defvar magit-auto-revert-mode (and (not global-auto-revert-mode) (not noninteractive)) "\
Non-nil if Magit-Auto-Revert mode is enabled.
See the `magit-auto-revert-mode' command
for a description of this minor mode.
Setting this variable directly does not take effect;
either customize it (see the info node `Easy Customization')
or call the function `magit-auto-revert-mode'.")
 
(custom-autoload 'magit-auto-revert-mode "magit-autorevert" nil)
 
(autoload 'magit-auto-revert-mode "magit-autorevert" "\
Toggle Auto-Revert mode in all buffers.
With prefix ARG, enable Magit-Auto-Revert mode if ARG is positive;
otherwise, disable it.  If called from Lisp, enable the mode if
ARG is omitted or nil.
 
Auto-Revert mode is enabled in all buffers where
`magit-turn-on-auto-revert-mode-if-desired' would do it.
See `auto-revert-mode' for more information on Auto-Revert mode.
 
\(fn &optional ARG)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-autorevert" '("auto-revert-buffer" "magit-")))
 
;;;***
 
;;;### (autoloads nil "magit-bisect" "magit-bisect.el" (0 0 0 0))
;;; Generated autoloads from magit-bisect.el
 (autoload 'magit-bisect-popup "magit-bisect" nil t)
 
(autoload 'magit-bisect-start "magit-bisect" "\
Start a bisect session.
 
Bisecting a bug means to find the commit that introduced it.
This command starts such a bisect session by asking for a know
good and a bad commit.  To move the session forward use the
other actions from the bisect popup (\\<magit-status-mode-map>\\[magit-bisect-popup]).
 
\(fn BAD GOOD)" t nil)
 
(autoload 'magit-bisect-reset "magit-bisect" "\
After bisecting, cleanup bisection state and return to original `HEAD'.
 
\(fn)" t nil)
 
(autoload 'magit-bisect-good "magit-bisect" "\
While bisecting, mark the current commit as good.
Use this after you have asserted that the commit does not contain
the bug in question.
 
\(fn)" t nil)
 
(autoload 'magit-bisect-bad "magit-bisect" "\
While bisecting, mark the current commit as bad.
Use this after you have asserted that the commit does contain the
bug in question.
 
\(fn)" t nil)
 
(autoload 'magit-bisect-skip "magit-bisect" "\
While bisecting, skip the current commit.
Use this if for some reason the current commit is not a good one
to test.  This command lets Git choose a different one.
 
\(fn)" t nil)
 
(autoload 'magit-bisect-run "magit-bisect" "\
Bisect automatically by running commands after each step.
 
Unlike `git bisect run' this can be used before bisecting has
begun.  In that case it behaves like `git bisect start; git
bisect run'.
 
\(fn CMDLINE &optional BAD GOOD)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-bisect" '("magit-")))
 
;;;***
 
;;;### (autoloads nil "magit-blame" "magit-blame.el" (0 0 0 0))
;;; Generated autoloads from magit-blame.el
 
(autoload 'magit-blame-echo "magit-blame" "\
For each line show the revision in which it was added.
Show the information about the chunk at point in the echo area
when moving between chunks.  Unlike other blaming commands, do
not turn on `read-only-mode'.
 
\(fn)" t nil)
 
(autoload 'magit-blame-addition "magit-blame" "\
For each line show the revision in which it was added.
 
\(fn)" t nil)
 
(autoload 'magit-blame-removal "magit-blame" "\
For each line show the revision in which it was removed.
 
\(fn)" t nil)
 
(autoload 'magit-blame-reverse "magit-blame" "\
For each line show the last revision in which it still exists.
 
\(fn)" t nil)
 (autoload 'magit-blame-popup "magit-blame" nil t)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-blame" '("magit-")))
 
;;;***
 
;;;### (autoloads nil "magit-bookmark" "magit-bookmark.el" (0 0 0
;;;;;;  0))
;;; Generated autoloads from magit-bookmark.el
 
(autoload 'magit-bookmark--status-jump "magit-bookmark" "\
Handle a Magit status BOOKMARK.
 
\(fn BOOKMARK)" nil nil)
 
(autoload 'magit-bookmark--status-make-record "magit-bookmark" "\
Create a Magit status bookmark.
 
\(fn)" nil nil)
 
(autoload 'magit-bookmark--refs-jump "magit-bookmark" "\
Handle a Magit refs BOOKMARK.
 
\(fn BOOKMARK)" nil nil)
 
(autoload 'magit-bookmark--refs-make-record "magit-bookmark" "\
Create a Magit refs bookmark.
 
\(fn)" nil nil)
 
(autoload 'magit-bookmark--log-jump "magit-bookmark" "\
Handle a Magit log BOOKMARK.
 
\(fn BOOKMARK)" nil nil)
 
(autoload 'magit-bookmark--log-make-record "magit-bookmark" "\
Create a Magit log bookmark.
 
\(fn)" nil nil)
 
(autoload 'magit-bookmark--reflog-jump "magit-bookmark" "\
Handle a Magit reflog BOOKMARK.
 
\(fn BOOKMARK)" nil nil)
 
(autoload 'magit-bookmark--reflog-make-record "magit-bookmark" "\
Create a Magit reflog bookmark.
 
\(fn)" nil nil)
 
(autoload 'magit-bookmark--stashes-jump "magit-bookmark" "\
Handle a Magit stash list BOOKMARK.
 
\(fn BOOKMARK)" nil nil)
 
(autoload 'magit-bookmark--stashes-make-record "magit-bookmark" "\
Create a Magit stash list bookmark.
 
\(fn)" nil nil)
 
(autoload 'magit-bookmark--cherry-jump "magit-bookmark" "\
Handle a Magit cherry BOOKMARK.
 
\(fn BOOKMARK)" nil nil)
 
(autoload 'magit-bookmark--cherry-make-record "magit-bookmark" "\
Create a Magit cherry bookmark.
 
\(fn)" nil nil)
 
(autoload 'magit-bookmark--diff-jump "magit-bookmark" "\
Handle a Magit diff BOOKMARK.
 
\(fn BOOKMARK)" nil nil)
 
(autoload 'magit-bookmark--diff-make-record "magit-bookmark" "\
Create a Magit diff bookmark.
 
\(fn)" nil nil)
 
(autoload 'magit-bookmark--revision-jump "magit-bookmark" "\
Handle a Magit revision BOOKMARK.
 
\(fn BOOKMARK)" nil nil)
 
(autoload 'magit-bookmark--revision-make-record "magit-bookmark" "\
Create a Magit revision bookmark.
 
\(fn)" nil nil)
 
(autoload 'magit-bookmark--stash-jump "magit-bookmark" "\
Handle a Magit stash BOOKMARK.
 
\(fn BOOKMARK)" nil nil)
 
(autoload 'magit-bookmark--stash-make-record "magit-bookmark" "\
Create a Magit stash bookmark.
 
\(fn)" nil nil)
 
(autoload 'magit-bookmark--submodules-jump "magit-bookmark" "\
Handle a Magit submodule list BOOKMARK.
 
\(fn BOOKMARK)" nil nil)
 
(autoload 'magit-bookmark--submodules-make-record "magit-bookmark" "\
Create a Magit submodule list bookmark.
 
\(fn)" nil nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-bookmark" '("magit-bookmark--")))
 
;;;***
 
;;;### (autoloads nil "magit-branch" "magit-branch.el" (0 0 0 0))
;;; Generated autoloads from magit-branch.el
 (autoload 'magit-branch-popup "magit" nil t)
 
(autoload 'magit-checkout "magit-branch" "\
Checkout REVISION, updating the index and the working tree.
If REVISION is a local branch, then that becomes the current
branch.  If it is something else, then `HEAD' becomes detached.
Checkout fails if the working tree or the staging area contain
changes.
 
\(git checkout REVISION).
 
\(fn REVISION)" t nil)
 
(autoload 'magit-branch-create "magit-branch" "\
Create BRANCH at branch or revision START-POINT.
 
\(git branch [ARGS] BRANCH START-POINT).
 
\(fn BRANCH START-POINT &optional ARGS)" t nil)
 
(autoload 'magit-branch-and-checkout "magit-branch" "\
Create and checkout BRANCH at branch or revision START-POINT.
 
\(git checkout [ARGS] -b BRANCH START-POINT).
 
\(fn BRANCH START-POINT &optional ARGS)" t nil)
 
(autoload 'magit-branch-or-checkout "magit-branch" "\
Hybrid between `magit-checkout' and `magit-branch-and-checkout'.
 
Ask the user for an existing branch or revision.  If the user
input actually can be resolved as a branch or revision, then
check that out, just like `magit-checkout' would.
 
Otherwise create and checkout a new branch using the input as
its name.  Before doing so read the starting-point for the new
branch.  This is similar to what `magit-branch-and-checkout'
does.
 
\(fn ARG &optional START-POINT)" t nil)
 
(autoload 'magit-branch-checkout "magit-branch" "\
Checkout an existing or new local branch.
 
Read a branch name from the user offering all local branches and
a subset of remote branches as candidates.  Omit remote branches
for which a local branch by the same name exists from the list
of candidates.  The user can also enter a completely new branch
name.
 
- If the user selects an existing local branch, then check that
  out.
 
- If the user selects a remote branch, then create and checkout
  a new local branch with the same name.  Configure the selected
  remote branch as push target.
 
- If the user enters a new branch name, then create and check
  that out, after also reading the starting-point from the user.
 
In the latter two cases the upstream is also set.  Whether it is
set to the chosen START-POINT or something else depends on the
value of `magit-branch-adjust-remote-upstream-alist', just like
when using `magit-branch-and-checkout'.
 
\(fn BRANCH &optional START-POINT)" t nil)
 
(autoload 'magit-branch-orphan "magit-branch" "\
Create and checkout an orphan BRANCH with contents from revision START-POINT.
 
\(git checkout --orphan [ARGS] BRANCH START-POINT).
 
\(fn BRANCH START-POINT &optional ARGS)" t nil)
 
(autoload 'magit-branch-pull-request "magit-branch" "\
Create and configure a new branch from a pull-request.
Please see the manual for more information.
 
\(fn PR)" t nil)
 
(autoload 'magit-branch-spinoff "magit-branch" "\
Create new branch from the unpushed commits.
 
Create and checkout a new branch starting at and tracking the
current branch.  That branch in turn is reset to the last commit
it shares with its upstream.  If the current branch has no
upstream or no unpushed commits, then the new branch is created
anyway and the previously current branch is not touched.
 
This is useful to create a feature branch after work has already
began on the old branch (likely but not necessarily \"master\").
 
If the current branch is a member of the value of option
`magit-branch-prefer-remote-upstream' (which see), then the
current branch will be used as the starting point as usual, but
the upstream of the starting-point may be used as the upstream
of the new branch, instead of the starting-point itself.
 
If optional FROM is non-nil, then the source branch is reset
to `FROM~', instead of to the last commit it shares with its
upstream.  Interactively, FROM is only ever non-nil, if the
region selects some commits, and among those commits, FROM is
the commit that is the fewest commits ahead of the source
branch.
 
The commit at the other end of the selection actually does not
matter, all commits between FROM and `HEAD' are moved to the new
branch.  If FROM is not reachable from `HEAD' or is reachable
from the source branch's upstream, then an error is raised.
 
\(fn BRANCH &optional FROM &rest ARGS)" t nil)
 
(autoload 'magit-branch-reset "magit-branch" "\
Reset a branch to the tip of another branch or any other commit.
 
When the branch being reset is the current branch, then do a
hard reset.  If there are any uncommitted changes, then the user
has to confirm the reset because those changes would be lost.
 
This is useful when you have started work on a feature branch but
realize it's all crap and want to start over.
 
When resetting to another branch and a prefix argument is used,
then also set the target branch as the upstream of the branch
that is being reset.
 
\(fn BRANCH TO &optional ARGS SET-UPSTREAM)" t nil)
 
(autoload 'magit-branch-delete "magit-branch" "\
Delete one or multiple branches.
If the region marks multiple branches, then offer to delete
those, otherwise prompt for a single branch to be deleted,
defaulting to the branch at point.
 
\(fn BRANCHES &optional FORCE)" t nil)
 
(autoload 'magit-branch-rename "magit-branch" "\
Rename the branch named OLD to NEW.
 
With a prefix argument FORCE, rename even if a branch named NEW
already exists.
 
If `branch.OLD.pushRemote' is set, then unset it.  Depending on
the value of `magit-branch-rename-push-target' (which see) maybe
set `branch.NEW.pushRemote' and maybe rename the push-target on
the remote.
 
\(fn OLD NEW &optional FORCE)" t nil)
 
(autoload 'magit-branch-shelve "magit-branch" "\
Shelve a BRANCH.
Rename \"refs/heads/BRANCH\" to \"refs/shelved/BRANCH\",
and also rename the respective reflog file.
 
\(fn BRANCH)" t nil)
 
(autoload 'magit-branch-unshelve "magit-branch" "\
Unshelve a BRANCH
Rename \"refs/shelved/BRANCH\" to \"refs/heads/BRANCH\",
and also rename the respective reflog file.
 
\(fn BRANCH)" t nil)
 
(autoload 'magit-branch-config-popup "magit-branch" "\
Popup console for setting branch variables.
 
\(fn BRANCH)" t nil)
 
(autoload 'magit-edit-branch*description "magit-branch" "\
Edit the description of the current branch.
With a prefix argument edit the description of another branch.
 
The description for the branch named NAME is stored in the Git
variable `branch.<name>.description'.
 
\(fn BRANCH)" t nil)
 
(autoload 'magit-set-branch*merge/remote "magit-branch" "\
Set or unset the upstream of the current branch.
With a prefix argument do so for another branch.
 
When the branch in question already has an upstream then simply
unsets it.  Invoke this command again to set another upstream.
 
Together the Git variables `branch.<name>.remote' and
`branch.<name>.merge' define the upstream branch of the local
branch named NAME.  The value of `branch.<name>.remote' is the
name of the upstream remote.  The value of `branch.<name>.merge'
is the full reference of the upstream branch, on the remote.
 
Non-interactively, when UPSTREAM is non-nil, then always set it
as the new upstream, regardless of whether another upstream was
already set.  When nil, then always unset.
 
\(fn BRANCH UPSTREAM)" t nil)
 
(autoload 'magit-cycle-branch*rebase "magit-branch" "\
Cycle the value of `branch.<name>.rebase' for the current branch.
With a prefix argument cycle the value for another branch.
 
The Git variables `branch.<name>.rebase' controls whether pulling
into the branch named NAME is done by rebasing that branch onto
the fetched branch or by merging that branch.
 
When `true' then pulling is done by rebasing.
When `false' then pulling is done by merging.
 
When that variable is undefined then the value of `pull.rebase'
is used instead.  It defaults to `false'.
 
\(fn BRANCH)" t nil)
 
(autoload 'magit-cycle-branch*pushRemote "magit-branch" "\
Cycle the value of `branch.<name>.pushRemote' for the current branch.
With a prefix argument cycle the value for another branch.
 
The Git variable `branch.<name>.pushRemote' specifies the remote
that the branch named NAME is usually pushed to.  The value has
to be the name of an existing remote.
 
If that variable is undefined, then the value of the Git variable
`remote.pushDefault' is used instead, provided that it is defined,
which by default it is not.
 
\(fn BRANCH)" t nil)
 
(autoload 'magit-cycle-pull\.rebase "magit-branch" "\
Cycle the repository-local value of `pull.rebase'.
 
The Git variable `pull.rebase' specifies whether pulling is done
by rebasing or by merging.  It can be overwritten using the Git
variable `branch.<name>.rebase'.
 
When `true' then pulling is done by rebasing.
When `false' (the default) then pulling is done by merging.
 
\(fn)" t nil)
 
(autoload 'magit-cycle-remote\.pushDefault "magit-branch" "\
Cycle the repository-local value of `remote.pushDefault'.
 
The Git variable `remote.pushDefault' specifies the remote that
local branches are usually pushed to.  It can be overwritten
using the Git variable `branch.<name>.pushRemote'.
 
\(fn)" t nil)
 
(autoload 'magit-cycle-branch*autoSetupMerge "magit-branch" "\
Cycle the repository-local value of `branch.autoSetupMerge'.
 
The Git variable `branch.autoSetupMerge' under what circumstances
creating a branch (named NAME) should result in the variables
`branch.<name>.merge' and `branch.<name>.remote' being set
according to the starting point used to create the branch.  If
the starting point isn't a branch, then these variables are never
set.
 
When `always' then the variables are set regardless of whether
the starting point is a local or a remote branch.
 
When `true' (the default) then the variable are set when the
starting point is a remote branch, but not when it is a local
branch.
 
When `false' then the variables are never set.
 
\(fn)" t nil)
 
(autoload 'magit-cycle-branch*autoSetupRebase "magit-branch" "\
Cycle the repository-local value of `branch.autoSetupRebase'.
 
The Git variable `branch.autoSetupRebase' specifies whether
creating a branch (named NAME) should result in the variable
`branch.<name>.rebase' being set to `true'.
 
When `always' then the variable is set regardless of whether the
starting point is a local or a remote branch.
 
When `local' then the variable are set when the starting point
is a local branch, but not when it is a remote branch.
 
When `remote' then the variable are set when the starting point
is a remote branch, but not when it is a local branch.
 
When `never' (the default) then the variable is never set.
 
\(fn)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-branch" '("magit-")))
 
;;;***
 
;;;### (autoloads nil "magit-clone" "magit-clone.el" (0 0 0 0))
;;; Generated autoloads from magit-clone.el
 
(autoload 'magit-clone "magit-clone" "\
Clone the REPOSITORY to DIRECTORY.
Then show the status buffer for the new repository.
 
\(fn REPOSITORY DIRECTORY)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-clone" '("magit-clone-")))
 
;;;***
 
;;;### (autoloads nil "magit-collab" "magit-collab.el" (0 0 0 0))
;;; Generated autoloads from magit-collab.el
 
(autoload 'magit-browse-pull-request "magit-collab" "\
Visit pull-request PR using `browse-url'.
 
Currently this only supports Github, but that restriction will
be lifted eventually to support other Git forges.
 
\(fn PR)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-collab" '("magit-")))
 
;;;***
 
;;;### (autoloads nil "magit-commit" "magit-commit.el" (0 0 0 0))
;;; Generated autoloads from magit-commit.el
 
(autoload 'magit-commit-create "magit-commit" "\
Create a new commit on `HEAD'.
With a prefix argument, amend to the commit at `HEAD' instead.
 
\(git commit [--amend] ARGS)
 
\(fn &optional ARGS)" t nil)
 
(autoload 'magit-commit-amend "magit-commit" "\
Amend the last commit.
 
\(git commit --amend ARGS)
 
\(fn &optional ARGS)" t nil)
 
(autoload 'magit-commit-extend "magit-commit" "\
Amend the last commit, without editing the message.
 
With a prefix argument keep the committer date, otherwise change
it.  The option `magit-commit-extend-override-date' can be used
to inverse the meaning of the prefix argument.  
\(git commit
--amend --no-edit)
 
\(fn &optional ARGS OVERRIDE-DATE)" t nil)
 
(autoload 'magit-commit-reword "magit-commit" "\
Reword the last commit, ignoring staged changes.
 
With a prefix argument keep the committer date, otherwise change
it.  The option `magit-commit-reword-override-date' can be used
to inverse the meaning of the prefix argument.
 
Non-interactively respect the optional OVERRIDE-DATE argument
and ignore the option.
 
\(git commit --amend --only)
 
\(fn &optional ARGS OVERRIDE-DATE)" t nil)
 
(autoload 'magit-commit-fixup "magit-commit" "\
Create a fixup commit.
 
With a prefix argument the target COMMIT has to be confirmed.
Otherwise the commit at point may be used without confirmation
depending on the value of option `magit-commit-squash-confirm'.
 
\(fn &optional COMMIT ARGS)" t nil)
 
(autoload 'magit-commit-squash "magit-commit" "\
Create a squash commit, without editing the squash message.
 
With a prefix argument the target COMMIT has to be confirmed.
Otherwise the commit at point may be used without confirmation
depending on the value of option `magit-commit-squash-confirm'.
 
\(fn &optional COMMIT ARGS)" t nil)
 
(autoload 'magit-commit-augment "magit-commit" "\
Create a squash commit, editing the squash message.
 
With a prefix argument the target COMMIT has to be confirmed.
Otherwise the commit at point may be used without confirmation
depending on the value of option `magit-commit-squash-confirm'.
 
\(fn &optional COMMIT ARGS)" t nil)
 
(autoload 'magit-commit-instant-fixup "magit-commit" "\
Create a fixup commit targeting COMMIT and instantly rebase.
 
\(fn &optional COMMIT ARGS)" t nil)
 
(autoload 'magit-commit-instant-squash "magit-commit" "\
Create a squash commit targeting COMMIT and instantly rebase.
 
\(fn &optional COMMIT ARGS)" t nil)
 
(autoload 'magit-commit-reshelve "magit-commit" "\
Change the committer date and possibly the author date of `HEAD'.
 
If you are the author of `HEAD', then both dates are changed,
otherwise only the committer date.  The current time is used
as the initial minibuffer input and the original author (if
that is you) or committer date is available as the previous
history element.
 
\(fn DATE)" t nil)
 (autoload 'magit-commit-absorb-popup "magit-commit" nil t)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-commit" '("magit-")))
 
;;;***
 
;;;### (autoloads nil "magit-diff" "magit-diff.el" (0 0 0 0))
;;; Generated autoloads from magit-diff.el
 
(autoload 'magit-diff-popup "magit-diff" "\
Popup console for diff commands.
 
\(fn ARG)" t nil)
 
(autoload 'magit-diff-buffer-file-popup "magit-diff" "\
Popup console for diff commands.
 
This is a variant of `magit-diff-popup' which shows the same popup
but which limits the diff to the file being visited in the current
buffer.
 
\(fn)" t nil)
 
(autoload 'magit-diff-dwim "magit-diff" "\
Show changes for the thing at point.
 
\(fn &optional ARGS FILES)" t nil)
 
(autoload 'magit-diff-range "magit-diff" "\
Show differences between two commits.
 
REV-OR-RANGE should be a range or a single revision.  If it is a
revision, then show changes in the working tree relative to that
revision.  If it is a range, but one side is omitted, then show
changes relative to `HEAD'.
 
If the region is active, use the revisions on the first and last
line of the region as the two sides of the range.  With a prefix
argument, instead of diffing the revisions, choose a revision to
view changes along, starting at the common ancestor of both
revisions (i.e., use a \"...\" range).
 
\(fn REV-OR-RANGE &optional ARGS FILES)" t nil)
 
(autoload 'magit-diff-working-tree "magit-diff" "\
Show changes between the current working tree and the `HEAD' commit.
With a prefix argument show changes between the working tree and
a commit read from the minibuffer.
 
\(fn &optional REV ARGS FILES)" t nil)
 
(autoload 'magit-diff-staged "magit-diff" "\
Show changes between the index and the `HEAD' commit.
With a prefix argument show changes between the index and
a commit read from the minibuffer.
 
\(fn &optional REV ARGS FILES)" t nil)
 
(autoload 'magit-diff-unstaged "magit-diff" "\
Show changes between the working tree and the index.
 
\(fn &optional ARGS FILES)" t nil)
 
(autoload 'magit-diff-unmerged "magit-diff" "\
Show changes that are being merged.
 
\(fn &optional ARGS FILES)" t nil)
 
(autoload 'magit-diff-while-committing "magit-diff" "\
While committing, show the changes that are about to be committed.
While amending, invoking the command again toggles between
showing just the new changes or all the changes that will
be committed.
 
\(fn &optional ARGS)" t nil)
 
(autoload 'magit-diff-buffer-file "magit-diff" "\
Show diff for the blob or file visited in the current buffer.
 
\(fn)" t nil)
 
(autoload 'magit-diff-paths "magit-diff" "\
Show changes between any two files on disk.
 
\(fn A B)" t nil)
 
(autoload 'magit-show-commit "magit-diff" "\
Visit the revision at point in another buffer.
If there is no revision at point or with a prefix argument prompt
for a revision.
 
\(fn REV &optional ARGS FILES MODULE)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-diff" '("magit-")))
 
;;;***
 
;;;### (autoloads nil "magit-ediff" "magit-ediff.el" (0 0 0 0))
;;; Generated autoloads from magit-ediff.el
 (autoload 'magit-ediff-popup "magit-ediff" nil t)
 
(autoload 'magit-ediff-resolve "magit-ediff" "\
Resolve outstanding conflicts in FILE using Ediff.
FILE has to be relative to the top directory of the repository.
 
In the rare event that you want to manually resolve all
conflicts, including those already resolved by Git, use
`ediff-merge-revisions-with-ancestor'.
 
\(fn FILE)" t nil)
 
(autoload 'magit-ediff-stage "magit-ediff" "\
Stage and unstage changes to FILE using Ediff.
FILE has to be relative to the top directory of the repository.
 
\(fn FILE)" t nil)
 
(autoload 'magit-ediff-compare "magit-ediff" "\
Compare REVA:FILEA with REVB:FILEB using Ediff.
 
FILEA and FILEB have to be relative to the top directory of the
repository.  If REVA or REVB is nil, then this stands for the
working tree state.
 
If the region is active, use the revisions on the first and last
line of the region.  With a prefix argument, instead of diffing
the revisions, choose a revision to view changes along, starting
at the common ancestor of both revisions (i.e., use a \"...\"
range).
 
\(fn REVA REVB FILEA FILEB)" t nil)
 
(autoload 'magit-ediff-dwim "magit-ediff" "\
Compare, stage, or resolve using Ediff.
This command tries to guess what file, and what commit or range
the user wants to compare, stage, or resolve using Ediff.  It
might only be able to guess either the file, or range or commit,
in which case the user is asked about the other.  It might not
always guess right, in which case the appropriate `magit-ediff-*'
command has to be used explicitly.  If it cannot read the user's
mind at all, then it asks the user for a command to run.
 
\(fn)" t nil)
 
(autoload 'magit-ediff-show-staged "magit-ediff" "\
Show staged changes using Ediff.
 
This only allows looking at the changes; to stage, unstage,
and discard changes using Ediff, use `magit-ediff-stage'.
 
FILE must be relative to the top directory of the repository.
 
\(fn FILE)" t nil)
 
(autoload 'magit-ediff-show-unstaged "magit-ediff" "\
Show unstaged changes using Ediff.
 
This only allows looking at the changes; to stage, unstage,
and discard changes using Ediff, use `magit-ediff-stage'.
 
FILE must be relative to the top directory of the repository.
 
\(fn FILE)" t nil)
 
(autoload 'magit-ediff-show-working-tree "magit-ediff" "\
Show changes between `HEAD' and working tree using Ediff.
FILE must be relative to the top directory of the repository.
 
\(fn FILE)" t nil)
 
(autoload 'magit-ediff-show-commit "magit-ediff" "\
Show changes introduced by COMMIT using Ediff.
 
\(fn COMMIT)" t nil)
 
(autoload 'magit-ediff-show-stash "magit-ediff" "\
Show changes introduced by STASH using Ediff.
`magit-ediff-show-stash-with-index' controls whether a
three-buffer Ediff is used in order to distinguish changes in the
stash that were staged.
 
\(fn STASH)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-ediff" '("magit-ediff-")))
 
;;;***
 
;;;### (autoloads nil "magit-extras" "magit-extras.el" (0 0 0 0))
;;; Generated autoloads from magit-extras.el
 
(autoload 'magit-run-git-gui "magit-extras" "\
Run `git gui' for the current git repository.
 
\(fn)" t nil)
 
(autoload 'magit-run-git-gui-blame "magit-extras" "\
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)" t nil)
 
(autoload 'magit-run-gitk "magit-extras" "\
Run `gitk' in the current repository.
 
\(fn)" t nil)
 
(autoload 'magit-run-gitk-branches "magit-extras" "\
Run `gitk --branches' in the current repository.
 
\(fn)" t nil)
 
(autoload 'magit-run-gitk-all "magit-extras" "\
Run `gitk --all' in the current repository.
 
\(fn)" t nil)
 
(autoload 'ido-enter-magit-status "magit-extras" "\
Drop into `magit-status' from file switching.
 
This command does not work in Emacs 26.  It does work in Emacs 25
and Emacs 27.  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)
 
\(fn)" t nil)
 
(autoload 'magit-dired-jump "magit-extras" "\
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)" t nil)
 
(autoload 'magit-dired-log "magit-extras" "\
Show log for all marked files, or the current file.
 
\(fn &optional FOLLOW)" t nil)
 
(autoload 'magit-do-async-shell-command "magit-extras" "\
Open FILE with `dired-do-async-shell-command'.
Interactively, open the file at point.
 
\(fn FILE)" t nil)
 
(autoload 'magit-previous-line "magit-extras" "\
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)" t nil)
 
(function-put 'magit-previous-line 'interactive-only '"use `forward-line' with negative argument instead.")
 
(autoload 'magit-next-line "magit-extras" "\
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)" t nil)
 
(function-put 'magit-next-line 'interactive-only 'forward-line)
 
(autoload 'magit-clean "magit-extras" "\
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)" t nil)
 
(autoload 'magit-add-change-log-entry "magit-extras" "\
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)" t nil)
 
(autoload 'magit-add-change-log-entry-other-window "magit-extras" "\
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)" t nil)
 
(autoload 'magit-edit-line-commit "magit-extras" "\
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)" t nil)
 
(autoload 'magit-reshelve-since "magit-extras" "\
Change the author and committer dates of the commits since REV.
 
Ask the user for the first reachable commit whose dates should
be changed.  The 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.
 
\(fn REV)" t nil)
 
(autoload 'magit-pop-revision-stack "magit-extras" "\
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)" t nil)
 
(autoload 'magit-copy-section-value "magit-extras" "\
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 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.
 
\(fn)" t nil)
 
(autoload 'magit-copy-buffer-revision "magit-extras" "\
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.
 
\(fn)" t nil)
 
(autoload 'magit-abort-dwim "magit-extras" "\
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.
 
\(fn)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-extras" '("magit-")))
 
;;;***
 
;;;### (autoloads nil "magit-fetch" "magit-fetch.el" (0 0 0 0))
;;; Generated autoloads from magit-fetch.el
 (autoload 'magit-fetch-popup "magit-fetch" nil t)
 
(autoload 'magit-fetch-from-pushremote "magit-fetch" "\
Fetch from the push-remote of the current branch.
 
\(fn ARGS)" t nil)
 
(autoload 'magit-fetch-from-upstream "magit-fetch" "\
Fetch from the upstream repository of the current branch.
 
\(fn ARGS)" t nil)
 
(autoload 'magit-fetch-other "magit-fetch" "\
Fetch from another repository.
 
\(fn REMOTE ARGS)" t nil)
 
(autoload 'magit-fetch-branch "magit-fetch" "\
Fetch a BRANCH from a REMOTE.
 
\(fn REMOTE BRANCH ARGS)" t nil)
 
(autoload 'magit-fetch-refspec "magit-fetch" "\
Fetch a REFSPEC from a REMOTE.
 
\(fn REMOTE REFSPEC ARGS)" t nil)
 
(autoload 'magit-fetch-all "magit-fetch" "\
Fetch from all remotes.
 
\(fn ARGS)" t nil)
 
(autoload 'magit-fetch-all-prune "magit-fetch" "\
Fetch from all remotes, and prune.
Prune remote tracking branches for branches that have been
removed on the respective remote.
 
\(fn)" t nil)
 
(autoload 'magit-fetch-all-no-prune "magit-fetch" "\
Fetch from all remotes.
 
\(fn)" t nil)
 
(autoload 'magit-fetch-modules "magit-fetch" "\
Fetch all submodules.
 
Option `magit-fetch-modules-jobs' controls how many submodules
are being fetched in parallel.  Also fetch the super-repository,
because `git-fetch' does not support not doing that.  With a
prefix argument fetch all remotes.
 
\(fn &optional ALL)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-fetch" '("magit-")))
 
;;;***
 
;;;### (autoloads nil "magit-files" "magit-files.el" (0 0 0 0))
;;; Generated autoloads from magit-files.el
 
(autoload 'magit-find-file "magit-files" "\
View FILE from REV.
Switch to a buffer visiting blob REV:FILE,
creating one if none already exists.
 
\(fn REV FILE)" t nil)
 
(autoload 'magit-find-file-other-window "magit-files" "\
View FILE from REV, in another window.
Like `magit-find-file', but create a new window or reuse an
existing one.
 
\(fn REV FILE)" t nil)
 (autoload 'magit-file-popup "magit" nil t)
 
(defvar global-magit-file-mode t "\
Non-nil if Global Magit-File mode is enabled.
See the `global-magit-file-mode' command
for a description of this minor mode.
Setting this variable directly does not take effect;
either customize it (see the info node `Easy Customization')
or call the function `global-magit-file-mode'.")
 
(custom-autoload 'global-magit-file-mode "magit-files" nil)
 
(autoload 'global-magit-file-mode "magit-files" "\
Toggle Magit-File mode in all buffers.
With prefix ARG, enable Global Magit-File mode if ARG is positive;
otherwise, disable it.  If called from Lisp, enable the mode if
ARG is omitted or nil.
 
Magit-File mode is enabled in all buffers where
`magit-file-mode-turn-on' would do it.
See `magit-file-mode' for more information on Magit-File mode.
 
\(fn &optional ARG)" t nil)
 
(autoload 'magit-file-checkout "magit-files" "\
Checkout FILE from REV.
 
\(fn REV FILE)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-files" '("magit-")))
 
;;;***
 
;;;### (autoloads nil "magit-git" "magit-git.el" (0 0 0 0))
;;; Generated autoloads from magit-git.el
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-git" '("magit-")))
 
;;;***
 
;;;### (autoloads nil "magit-gitignore" "magit-gitignore.el" (0 0
;;;;;;  0 0))
;;; Generated autoloads from magit-gitignore.el
 (autoload 'magit-gitignore-popup "magit-gitignore" nil t)
 
(autoload 'magit-gitignore-globally "magit-gitignore" "\
Instruct Git to globally ignore FILE-OR-PATTERN.
 
\(fn FILE-OR-PATTERN)" t nil)
 
(autoload 'magit-gitignore-locally "magit-gitignore" "\
Instruct Git to locally ignore FILE-OR-PATTERN.
 
\(fn FILE-OR-PATTERN)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-gitignore" '("magit-")))
 
;;;***
 
;;;### (autoloads nil "magit-imenu" "magit-imenu.el" (0 0 0 0))
;;; Generated autoloads from magit-imenu.el
 
(autoload 'magit-imenu--log-prev-index-position-function "magit-imenu" "\
Move point to previous line in current buffer.
This function is used as a value for
`imenu-prev-index-position-function'.
 
\(fn)" nil nil)
 
(autoload 'magit-imenu--log-extract-index-name-function "magit-imenu" "\
Return imenu name for line at point.
This function is used as a value for
`imenu-extract-index-name-function'.  Point should be at the
beginning of the line.
 
\(fn)" nil nil)
 
(autoload 'magit-imenu--diff-prev-index-position-function "magit-imenu" "\
Move point to previous file line in current buffer.
This function is used as a value for
`imenu-prev-index-position-function'.
 
\(fn)" nil nil)
 
(autoload 'magit-imenu--diff-extract-index-name-function "magit-imenu" "\
Return imenu name for line at point.
This function is used as a value for
`imenu-extract-index-name-function'.  Point should be at the
beginning of the line.
 
\(fn)" nil nil)
 
(autoload 'magit-imenu--status-create-index-function "magit-imenu" "\
Return an alist of all imenu entries in current buffer.
This function is used as a value for
`imenu-create-index-function'.
 
\(fn)" nil nil)
 
(autoload 'magit-imenu--refs-create-index-function "magit-imenu" "\
Return an alist of all imenu entries in current buffer.
This function is used as a value for
`imenu-create-index-function'.
 
\(fn)" nil nil)
 
(autoload 'magit-imenu--cherry-create-index-function "magit-imenu" "\
Return an alist of all imenu entries in current buffer.
This function is used as a value for
`imenu-create-index-function'.
 
\(fn)" nil nil)
 
(autoload 'magit-imenu--submodule-prev-index-position-function "magit-imenu" "\
Move point to previous line in magit-submodule-list buffer.
This function is used as a value for
`imenu-prev-index-position-function'.
 
\(fn)" nil nil)
 
(autoload 'magit-imenu--submodule-extract-index-name-function "magit-imenu" "\
Return imenu name for line at point.
This function is used as a value for
`imenu-extract-index-name-function'.  Point should be at the
beginning of the line.
 
\(fn)" nil nil)
 
(autoload 'magit-imenu--repolist-prev-index-position-function "magit-imenu" "\
Move point to previous line in magit-repolist buffer.
This function is used as a value for
`imenu-prev-index-position-function'.
 
\(fn)" nil nil)
 
(autoload 'magit-imenu--repolist-extract-index-name-function "magit-imenu" "\
Return imenu name for line at point.
This function is used as a value for
`imenu-extract-index-name-function'.  Point should be at the
beginning of the line.
 
\(fn)" nil nil)
 
(autoload 'magit-imenu--process-prev-index-position-function "magit-imenu" "\
Move point to previous process in magit-process buffer.
This function is used as a value for
`imenu-prev-index-position-function'.
 
\(fn)" nil nil)
 
(autoload 'magit-imenu--process-extract-index-name-function "magit-imenu" "\
Return imenu name for line at point.
This function is used as a value for
`imenu-extract-index-name-function'.  Point should be at the
beginning of the line.
 
\(fn)" nil nil)
 
(autoload 'magit-imenu--rebase-prev-index-position-function "magit-imenu" "\
Move point to previous commit in git-rebase buffer.
This function is used as a value for
`imenu-prev-index-position-function'.
 
\(fn)" nil nil)
 
(autoload 'magit-imenu--rebase-extract-index-name-function "magit-imenu" "\
Return imenu name for line at point.
This function is used as a value for
`imenu-extract-index-name-function'.  Point should be at the
beginning of the line.
 
\(fn)" nil nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-imenu" '("magit-imenu--index-function")))
 
;;;***
 
;;;### (autoloads nil "magit-log" "magit-log.el" (0 0 0 0))
;;; Generated autoloads from magit-log.el
 
(autoload 'magit-log-buffer-file-popup "magit-log" "\
Popup console for log commands.
 
This is a variant of `magit-log-popup' which shows the same popup
but which limits the log to the file being visited in the current
buffer.
 
\(fn)" t nil)
 
(autoload 'magit-log-current "magit-log" "\
Show log for the current branch.
When `HEAD' is detached or with a prefix argument show log for
one or more revs read from the minibuffer.
 
\(fn REVS &optional ARGS FILES)" t nil)
 
(autoload 'magit-log-other "magit-log" "\
Show log for one or more revs read from the minibuffer.
The user can input any revision or revisions separated by a
space, or even ranges, but only branches and tags, and a
representation of the commit at point, are available as
completion candidates.
 
\(fn REVS &optional ARGS FILES)" t nil)
 
(autoload 'magit-log-head "magit-log" "\
Show log for `HEAD'.
 
\(fn &optional ARGS FILES)" t nil)
 
(autoload 'magit-log-branches "magit-log" "\
Show log for all local branches and `HEAD'.
 
\(fn &optional ARGS FILES)" t nil)
 
(autoload 'magit-log-all-branches "magit-log" "\
Show log for all local and remote branches and `HEAD'.
 
\(fn &optional ARGS FILES)" t nil)
 
(autoload 'magit-log-all "magit-log" "\
Show log for all references and `HEAD'.
 
\(fn &optional ARGS FILES)" t nil)
 
(autoload 'magit-log-buffer-file "magit-log" "\
Show log for the blob or file visited in the current buffer.
With a prefix argument or when `--follow' is part of
`magit-log-arguments', then follow renames.  When the region is
active, restrict the log to the lines that the region touches.
 
\(fn &optional FOLLOW BEG END)" t nil)
 
(autoload 'magit-log-trace-definition "magit-log" "\
Show log for the definition at point.
 
\(fn FILE FN REV)" t nil)
 
(autoload 'magit-log-merged "magit-log" "\
Show log for the merge of COMMIT into BRANCH.
More precisely, find merge commit M that brought COMMIT into
BRANCH, and show the log of the range \"M^..M\".  This command
requires git-when-merged, which is available from
https://github.com/mhagger/git-when-merged.
 
\(fn COMMIT BRANCH &optional ARGS FILES)" t nil)
 
(autoload 'magit-reflog-current "magit-log" "\
Display the reflog of the current branch.
 
\(fn ARGS)" t nil)
 
(autoload 'magit-reflog-other "magit-log" "\
Display the reflog of a branch or another ref.
 
\(fn REF ARGS)" t nil)
 
(autoload 'magit-reflog-head "magit-log" "\
Display the `HEAD' reflog.
 
\(fn ARGS)" t nil)
 
(autoload 'magit-log-move-to-parent "magit-log" "\
Move to the Nth parent of the current commit.
 
\(fn &optional N)" t nil)
 
(autoload 'magit-cherry "magit-log" "\
Show commits in a branch that are not merged in the upstream branch.
 
\(fn HEAD UPSTREAM)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-log" '("magit-")))
 
;;;***
 
;;;### (autoloads nil "magit-margin" "magit-margin.el" (0 0 0 0))
;;; Generated autoloads from magit-margin.el
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-margin" '("magit-")))
 
;;;***
 
;;;### (autoloads nil "magit-merge" "magit-merge.el" (0 0 0 0))
;;; Generated autoloads from magit-merge.el
 (autoload 'magit-merge-popup "magit" nil t)
 
(autoload 'magit-merge-plain "magit-merge" "\
Merge commit REV into the current branch; using default message.
 
Unless there are conflicts or a prefix argument is used create a
merge commit using a generic commit message and without letting
the user inspect the result.  With a prefix argument pretend the
merge failed to give the user the opportunity to inspect the
merge.
 
\(git merge --no-edit|--no-commit [ARGS] REV)
 
\(fn REV &optional ARGS NOCOMMIT)" t nil)
 
(autoload 'magit-merge-editmsg "magit-merge" "\
Merge commit REV into the current branch; and edit message.
Perform the merge and prepare a commit message but let the user
edit it.
 
\(git merge --edit --no-ff [ARGS] REV)
 
\(fn REV &optional ARGS)" t nil)
 
(autoload 'magit-merge-nocommit "magit-merge" "\
Merge commit REV into the current branch; pretending it failed.
Pretend the merge failed to give the user the opportunity to
inspect the merge and change the commit message.
 
\(git merge --no-commit --no-ff [ARGS] REV)
 
\(fn REV &optional ARGS)" t nil)
 
(autoload 'magit-merge-into "magit-merge" "\
Merge the current branch into BRANCH and remove the former.
 
Before merging, force push the source branch to its push-remote,
provided the respective remote branch already exists, ensuring
that the respective pull-request (if any) won't get stuck on some
obsolete version of the commits that are being merged.  Finally
if `magit-branch-pull-request' was used to create the merged
branch, then also remove the respective remote branch.
 
\(fn BRANCH &optional ARGS)" t nil)
 
(autoload 'magit-merge-absorb "magit-merge" "\
Merge BRANCH into the current branch and remove the former.
 
Before merging, force push the source branch to its push-remote,
provided the respective remote branch already exists, ensuring
that the respective pull-request (if any) won't get stuck on some
obsolete version of the commits that are being merged.  Finally
if `magit-branch-pull-request' was used to create the merged
branch, then also remove the respective remote branch.
 
\(fn BRANCH &optional ARGS)" t nil)
 
(autoload 'magit-merge-squash "magit-merge" "\
Squash commit REV into the current branch; don't create a commit.
 
\(git merge --squash REV)
 
\(fn REV)" t nil)
 
(autoload 'magit-merge-preview "magit-merge" "\
Preview result of merging REV into the current branch.
 
\(fn REV)" t nil)
 
(autoload 'magit-merge-abort "magit-merge" "\
Abort the current merge operation.
 
\(git merge --abort)
 
\(fn)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-merge" '("magit-")))
 
;;;***
 
;;;### (autoloads nil "magit-mode" "magit-mode.el" (0 0 0 0))
;;; Generated autoloads from magit-mode.el
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-mode" '("magit-" "disable-magit-save-buffers" "inhibit-magit-refresh")))
 
;;;***
 
;;;### (autoloads nil "magit-notes" "magit-notes.el" (0 0 0 0))
;;; Generated autoloads from magit-notes.el
 (autoload 'magit-notes-popup "magit" nil t)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-notes" '("magit-")))
 
;;;***
 
;;;### (autoloads nil "magit-patch" "magit-patch.el" (0 0 0 0))
;;; Generated autoloads from magit-patch.el
 (autoload 'magit-patch-popup "magit-patch" nil t)
 
(autoload 'magit-format-patch "magit-patch" "\
Create patches for the commits in RANGE.
When a single commit is given for RANGE, create a patch for the
changes introduced by that commit (unlike 'git format-patch'
which creates patches for all commits that are reachable from
`HEAD' but not from the specified commit).
 
\(fn RANGE ARGS FILES)" t nil)
 
(autoload 'magit-request-pull "magit-patch" "\
Request upstream to pull from you public repository.
 
URL is the url of your publically accessible repository.
START is a commit that already is in the upstream repository.
END is the last commit, usually a branch name, which upstream
is asked to pull.  START has to be reachable from that commit.
 
\(fn URL START END)" t nil)
 (autoload 'magit-patch-apply-popup "magit-patch" nil t)
 
(autoload 'magit-patch-apply "magit-patch" "\
Apply the patch file FILE.
 
\(fn FILE &rest ARGS)" t nil)
 
(autoload 'magit-patch-save "magit-patch" "\
Write current diff into patch FILE.
 
What arguments are used to create the patch depends on the value
of `magit-patch-save-arguments' and whether a prefix argument is
used.
 
If the value is the symbol `buffer', then use the same arguments
as the buffer.  With a prefix argument use no arguments.
 
If the value is a list beginning with the symbol `exclude', then
use the same arguments as the buffer except for those matched by
entries in the cdr of the list.  The comparison is done using
`string-prefix-p'.  With a prefix argument use the same arguments
as the buffer.
 
If the value is a list of strings (including the empty list),
then use those arguments.  With a prefix argument use the same
arguments as the buffer.
 
Of course the arguments that are required to actually show the
same differences as those shown in the buffer are always used.
 
\(fn FILE &optional ARG)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-patch" '("magit-patch-save-arguments")))
 
;;;***
 
;;;### (autoloads nil "magit-process" "magit-process.el" (0 0 0 0))
;;; Generated autoloads from magit-process.el
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-process" '("magit-" "tramp-sh-handle-")))
 
;;;***
 
;;;### (autoloads nil "magit-pull" "magit-pull.el" (0 0 0 0))
;;; Generated autoloads from magit-pull.el
 (autoload 'magit-pull-popup "magit-pull" nil t)
 (autoload 'magit-pull-and-fetch-popup "magit-pull" nil t)
 
(autoload 'magit-pull-from-pushremote "magit-pull" "\
Pull from the push-remote of the current branch.
 
\(fn ARGS)" t nil)
 
(autoload 'magit-pull-from-upstream "magit-pull" "\
Pull from the upstream of the current branch.
 
\(fn ARGS)" t nil)
 
(autoload 'magit-pull-branch "magit-pull" "\
Pull from a branch read in the minibuffer.
 
\(fn SOURCE ARGS)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-pull" '("magit-")))
 
;;;***
 
;;;### (autoloads nil "magit-push" "magit-push.el" (0 0 0 0))
;;; Generated autoloads from magit-push.el
 (autoload 'magit-push-popup "magit-push" nil t)
 
(autoload 'magit-push-current-to-pushremote "magit-push" "\
Push the current branch to `branch.<name>.pushRemote'.
If that variable is unset, then push to `remote.pushDefault'.
 
When `magit-push-current-set-remote-if-missing' is non-nil and
the push-remote is not configured, then read the push-remote from
the user, set it, and then push to it.  With a prefix argument
the push-remote can be changed before pushed to it.
 
\(fn ARGS &optional PUSH-REMOTE)" t nil)
 
(autoload 'magit-push-current-to-upstream "magit-push" "\
Push the current branch to its upstream branch.
 
When `magit-push-current-set-remote-if-missing' is non-nil and
the upstream is not configured, then read the upstream from the
user, set it, and then push to it.  With a prefix argument the
upstream can be changed before pushed to it.
 
\(fn ARGS &optional UPSTREAM)" t nil)
 
(autoload 'magit-push-current "magit-push" "\
Push the current branch to a branch read in the minibuffer.
 
\(fn TARGET ARGS)" t nil)
 
(autoload 'magit-push-other "magit-push" "\
Push an arbitrary branch or commit somewhere.
Both the source and the target are read in the minibuffer.
 
\(fn SOURCE TARGET ARGS)" t nil)
 
(autoload 'magit-push-refspecs "magit-push" "\
Push one or multiple REFSPECS to a REMOTE.
Both the REMOTE and the REFSPECS are read in the minibuffer.  To
use multiple REFSPECS, separate them with commas.  Completion is
only available for the part before the colon, or when no colon
is used.
 
\(fn REMOTE REFSPECS ARGS)" t nil)
 
(autoload 'magit-push-matching "magit-push" "\
Push all matching branches to another repository.
If multiple remotes exist, then read one from the user.
If just one exists, use that without requiring confirmation.
 
\(fn REMOTE &optional ARGS)" t nil)
 
(autoload 'magit-push-tags "magit-push" "\
Push all tags to another repository.
If only one remote exists, then push to that.  Otherwise prompt
for a remote, offering the remote configured for the current
branch as default.
 
\(fn REMOTE &optional ARGS)" t nil)
 
(autoload 'magit-push-tag "magit-push" "\
Push a tag to another repository.
 
\(fn TAG REMOTE &optional ARGS)" t nil)
 
(autoload 'magit-push-implicitly "magit-push" "\
Push somewhere without using an explicit refspec.
 
This command simply runs \"git push -v [ARGS]\".  ARGS are the
arguments specified in the popup buffer.  No explicit refspec
arguments are used.  Instead the behavior depends on at least
these Git variables: `push.default', `remote.pushDefault',
`branch.<branch>.pushRemote', `branch.<branch>.remote',
`branch.<branch>.merge', and `remote.<remote>.push'.
 
To add this command to the push popup add this to your init file:
 
  (with-eval-after-load \\='magit-remote
    (magit-define-popup-action \\='magit-push-popup ?P
      \\='magit-push-implicitly--desc
      \\='magit-push-implicitly ?p t))
 
The function `magit-push-implicitly--desc' attempts to predict
what this command will do.  The value it returns is displayed in
the popup buffer.
 
\(fn ARGS)" t nil)
 
(autoload 'magit-push-to-remote "magit-push" "\
Push to REMOTE without using an explicit refspec.
The REMOTE is read in the minibuffer.
 
This command simply runs \"git push -v [ARGS] REMOTE\".  ARGS
are the arguments specified in the popup buffer.  No refspec
arguments are used.  Instead the behavior depends on at least
these Git variables: `push.default', `remote.pushDefault',
`branch.<branch>.pushRemote', `branch.<branch>.remote',
`branch.<branch>.merge', and `remote.<remote>.push'.
 
To add this command to the push popup add this to your init file:
 
  (with-eval-after-load \\='magit-remote
    (magit-define-popup-action \\='magit-push-popup ?r
      \\='magit-push-to-remote--desc
      \\='magit-push-to-remote ?p t))
 
\(fn REMOTE ARGS)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-push" '("magit-")))
 
;;;***
 
;;;### (autoloads nil "magit-refs" "magit-refs.el" (0 0 0 0))
;;; Generated autoloads from magit-refs.el
 
(autoload 'magit-show-refs-popup "magit-refs" "\
Popup console for `magit-show-refs'.
 
\(fn &optional ARG)" t nil)
 
(autoload 'magit-show-refs-head "magit-refs" "\
List and compare references in a dedicated buffer.
Refs are compared with `HEAD'.
 
\(fn &optional ARGS)" t nil)
 
(autoload 'magit-show-refs-current "magit-refs" "\
List and compare references in a dedicated buffer.
Refs are compared with the current branch or `HEAD' if
it is detached.
 
\(fn &optional ARGS)" t nil)
 
(autoload 'magit-show-refs "magit-refs" "\
List and compare references in a dedicated buffer.
Refs are compared with a branch read from the user.
 
\(fn &optional REF ARGS)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-refs" '("magit-")))
 
;;;***
 
;;;### (autoloads nil "magit-remote" "magit-remote.el" (0 0 0 0))
;;; Generated autoloads from magit-remote.el
 (autoload 'magit-remote-popup "magit-remote" nil t)
 
(autoload 'magit-remote-add "magit-remote" "\
Add a remote named REMOTE and fetch it.
 
\(fn REMOTE URL &optional ARGS)" t nil)
 
(autoload 'magit-remote-rename "magit-remote" "\
Rename the remote named OLD to NEW.
 
\(fn OLD NEW)" t nil)
 
(autoload 'magit-remote-remove "magit-remote" "\
Delete the remote named REMOTE.
 
\(fn REMOTE)" t nil)
 
(autoload 'magit-remote-prune "magit-remote" "\
Remove stale remote-tracking branches for REMOTE.
 
\(fn REMOTE)" t nil)
 
(autoload 'magit-remote-prune-refspecs "magit-remote" "\
Remove stale refspecs for REMOTE.
 
A refspec is stale if there no longer exists at least one branch
on the remote that would be fetched due to that refspec.  A stale
refspec is problematic because its existence causes Git to refuse
to fetch according to the remaining non-stale refspecs.
 
If only stale refspecs remain, then offer to either delete the
remote or to replace the stale refspecs with the default refspec.
 
Also remove the remote-tracking branches that were created due to
the now stale refspecs.  Other stale branches are not removed.
 
\(fn REMOTE)" t nil)
 
(autoload 'magit-remote-set-head "magit-remote" "\
Set the local representation of REMOTE's default branch.
Query REMOTE and set the symbolic-ref refs/remotes/<remote>/HEAD
accordingly.  With a prefix argument query for the branch to be
used, which allows you to select an incorrect value if you fancy
doing that.
 
\(fn REMOTE &optional BRANCH)" t nil)
 
(autoload 'magit-remote-unset-head "magit-remote" "\
Unset the local representation of REMOTE's default branch.
Delete the symbolic-ref \"refs/remotes/<remote>/HEAD\".
 
\(fn REMOTE)" t nil)
 
(autoload 'magit-remote-config-popup "magit-remote" "\
Popup console for setting remote variables.
 
\(fn REMOTE)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-remote" '("magit-")))
 
;;;***
 
;;;### (autoloads nil "magit-repos" "magit-repos.el" (0 0 0 0))
;;; Generated autoloads from magit-repos.el
 
(autoload 'magit-list-repositories "magit-repos" "\
Display a list of repositories.
 
Use the options `magit-repository-directories' to control which
repositories are displayed.
 
\(fn)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-repos" '("magit-")))
 
;;;***
 
;;;### (autoloads nil "magit-reset" "magit-reset.el" (0 0 0 0))
;;; Generated autoloads from magit-reset.el
 (autoload 'magit-reset-popup "magit" nil t)
 
(autoload 'magit-reset-mixed "magit-reset" "\
Reset the `HEAD' and index to COMMIT, but not the working tree.
 
\(git reset --mixed COMMIT)
 
\(fn COMMIT)" t nil)
 
(autoload 'magit-reset-soft "magit-reset" "\
Reset the `HEAD' to COMMIT, but not the index and working tree.
 
\(git reset --soft REVISION)
 
\(fn COMMIT)" t nil)
 
(autoload 'magit-reset-hard "magit-reset" "\
Reset the `HEAD', index, and working tree to COMMIT.
 
\(git reset --hard REVISION)
 
\(fn COMMIT)" t nil)
 
(autoload 'magit-reset-index "magit-reset" "\
Reset the index to COMMIT.
Keep the `HEAD' and working tree as-is, so if COMMIT refers to the
head this effectively unstages all changes.
 
\(git reset COMMIT .)
 
\(fn COMMIT)" t nil)
 
(autoload 'magit-reset-worktree "magit-reset" "\
Reset the worktree to COMMIT.
Keep the `HEAD' and index as-is.
 
\(fn COMMIT)" t nil)
 
(autoload 'magit-reset-quickly "magit-reset" "\
Reset the `HEAD' and index to COMMIT, and possibly the working tree.
With a prefix argument reset the working tree otherwise don't.
 
\(git reset --mixed|--hard COMMIT)
 
\(fn COMMIT &optional HARD)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-reset" '("magit-reset-")))
 
;;;***
 
;;;### (autoloads nil "magit-section" "magit-section.el" (0 0 0 0))
;;; Generated autoloads from magit-section.el
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-section" '("magit-")))
 
;;;***
 
;;;### (autoloads nil "magit-sequence" "magit-sequence.el" (0 0 0
;;;;;;  0))
;;; Generated autoloads from magit-sequence.el
 
(autoload 'magit-sequencer-continue "magit-sequence" "\
Resume the current cherry-pick or revert sequence.
 
\(fn)" t nil)
 
(autoload 'magit-sequencer-skip "magit-sequence" "\
Skip the stopped at commit during a cherry-pick or revert sequence.
 
\(fn)" t nil)
 
(autoload 'magit-sequencer-abort "magit-sequence" "\
Abort the current cherry-pick or revert sequence.
This discards all changes made since the sequence started.
 
\(fn)" t nil)
 (autoload 'magit-cherry-pick-popup "magit-sequence" nil t)
 
(autoload 'magit-cherry-copy "magit-sequence" "\
Copy COMMITS from another branch onto the current branch.
Prompt for a commit, defaulting to the commit at point.  If
the region selects multiple commits, then pick all of them,
without prompting.
 
\(fn COMMITS &optional ARGS)" t nil)
 
(autoload 'magit-cherry-apply "magit-sequence" "\
Apply the changes in COMMITS but do not commit them.
Prompt for a commit, defaulting to the commit at point.  If
the region selects multiple commits, then apply all of them,
without prompting.
 
\(fn COMMITS &optional ARGS)" t nil)
 
(autoload 'magit-cherry-harvest "magit-sequence" "\
Move COMMITS from another BRANCH onto the current branch.
Remove the COMMITS from BRANCH and stay on the current branch.
If a conflict occurs, then you have to fix that and finish the
process manually.
 
\(fn COMMITS BRANCH &optional ARGS)" t nil)
 
(autoload 'magit-cherry-donate "magit-sequence" "\
Move COMMITS from the current branch onto another existing BRANCH.
Remove COMMITS from the current branch and stay on that branch.
If a conflict occurs, then you have to fix that and finish the
process manually.
 
\(fn COMMITS BRANCH &optional ARGS)" t nil)
 
(autoload 'magit-cherry-spinout "magit-sequence" "\
Move COMMITS from the current branch onto a new BRANCH.
Remove COMMITS from the current branch and stay on that branch.
If a conflict occurs, then you have to fix that and finish the
process manually.
 
\(fn COMMITS BRANCH START-POINT &optional ARGS)" t nil)
 
(autoload 'magit-cherry-spinoff "magit-sequence" "\
Move COMMITS from the current branch onto a new BRANCH.
Remove COMMITS from the current branch and checkout BRANCH.
If a conflict occurs, then you have to fix that and finish
the process manually.
 
\(fn COMMITS BRANCH START-POINT &optional ARGS)" t nil)
 (autoload 'magit-revert-popup "magit-sequence" nil t)
 
(autoload 'magit-revert-and-commit "magit-sequence" "\
Revert COMMIT by creating a new commit.
Prompt for a commit, defaulting to the commit at point.  If
the region selects multiple commits, then revert all of them,
without prompting.
 
\(fn COMMIT &optional ARGS)" t nil)
 
(autoload 'magit-revert-no-commit "magit-sequence" "\
Revert COMMIT by applying it in reverse to the worktree.
Prompt for a commit, defaulting to the commit at point.  If
the region selects multiple commits, then revert all of them,
without prompting.
 
\(fn COMMIT &optional ARGS)" t nil)
 (autoload 'magit-am-popup "magit-sequence" nil t)
 
(autoload 'magit-am-apply-patches "magit-sequence" "\
Apply the patches FILES.
 
\(fn &optional FILES ARGS)" t nil)
 
(autoload 'magit-am-apply-maildir "magit-sequence" "\
Apply the patches from MAILDIR.
 
\(fn &optional MAILDIR ARGS)" t nil)
 
(autoload 'magit-am-continue "magit-sequence" "\
Resume the current patch applying sequence.
 
\(fn)" t nil)
 
(autoload 'magit-am-skip "magit-sequence" "\
Skip the stopped at patch during a patch applying sequence.
 
\(fn)" t nil)
 
(autoload 'magit-am-abort "magit-sequence" "\
Abort the current patch applying sequence.
This discards all changes made since the sequence started.
 
\(fn)" t nil)
 (autoload 'magit-rebase-popup "magit-sequence" nil t)
 
(autoload 'magit-rebase-onto-pushremote "magit-sequence" "\
Rebase the current branch onto `branch.<name>.pushRemote'.
If that variable is unset, then rebase onto `remote.pushDefault'.
 
\(fn ARGS)" t nil)
 
(autoload 'magit-rebase-onto-upstream "magit-sequence" "\
Rebase the current branch onto its upstream branch.
 
\(fn ARGS)" t nil)
 
(autoload 'magit-rebase-branch "magit-sequence" "\
Rebase the current branch onto a branch read in the minibuffer.
All commits that are reachable from `HEAD' but not from the
selected branch TARGET are being rebased.
 
\(fn TARGET ARGS)" t nil)
 
(autoload 'magit-rebase-subset "magit-sequence" "\
Rebase a subset of the current branch's history onto a new base.
Rebase commits from START to `HEAD' onto NEWBASE.
START has to be selected from a list of recent commits.
 
\(fn NEWBASE START ARGS)" t nil)
 
(autoload 'magit-rebase-interactive "magit-sequence" "\
Start an interactive rebase sequence.
 
\(fn COMMIT ARGS)" t nil)
 
(autoload 'magit-rebase-autosquash "magit-sequence" "\
Combine squash and fixup commits with their intended targets.
 
\(fn ARGS)" t nil)
 
(autoload 'magit-rebase-edit-commit "magit-sequence" "\
Edit a single older commit using rebase.
 
\(fn COMMIT ARGS)" t nil)
 
(autoload 'magit-rebase-reword-commit "magit-sequence" "\
Reword a single older commit using rebase.
 
\(fn COMMIT ARGS)" t nil)
 
(autoload 'magit-rebase-remove-commit "magit-sequence" "\
Remove a single older commit using rebase.
 
\(fn COMMIT ARGS)" t nil)
 
(autoload 'magit-rebase-continue "magit-sequence" "\
Restart the current rebasing operation.
In some cases this pops up a commit message buffer for you do
edit.  With a prefix argument the old message is reused as-is.
 
\(fn &optional NOEDIT)" t nil)
 
(autoload 'magit-rebase-skip "magit-sequence" "\
Skip the current commit and restart the current rebase operation.
 
\(fn)" t nil)
 
(autoload 'magit-rebase-edit "magit-sequence" "\
Edit the todo list of the current rebase operation.
 
\(fn)" t nil)
 
(autoload 'magit-rebase-abort "magit-sequence" "\
Abort the current rebase operation, restoring the original branch.
 
\(fn)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-sequence" '("magit-")))
 
;;;***
 
;;;### (autoloads nil "magit-stash" "magit-stash.el" (0 0 0 0))
;;; Generated autoloads from magit-stash.el
 (autoload 'magit-stash-popup "magit-stash" nil t)
 
(autoload 'magit-stash-both "magit-stash" "\
Create a stash of the index and working tree.
Untracked files are included according to popup arguments.
One prefix argument is equivalent to `--include-untracked'
while two prefix arguments are equivalent to `--all'.
 
\(fn MESSAGE &optional INCLUDE-UNTRACKED)" t nil)
 
(autoload 'magit-stash-index "magit-stash" "\
Create a stash of the index only.
Unstaged and untracked changes are not stashed.  The stashed
changes are applied in reverse to both the index and the
worktree.  This command can fail when the worktree is not clean.
Applying the resulting stash has the inverse effect.
 
\(fn MESSAGE)" t nil)
 
(autoload 'magit-stash-worktree "magit-stash" "\
Create a stash of unstaged changes in the working tree.
Untracked files are included according to popup arguments.
One prefix argument is equivalent to `--include-untracked'
while two prefix arguments are equivalent to `--all'.
 
\(fn MESSAGE &optional INCLUDE-UNTRACKED)" t nil)
 
(autoload 'magit-stash-keep-index "magit-stash" "\
Create a stash of the index and working tree, keeping index intact.
Untracked files are included according to popup arguments.
One prefix argument is equivalent to `--include-untracked'
while two prefix arguments are equivalent to `--all'.
 
\(fn MESSAGE &optional INCLUDE-UNTRACKED)" t nil)
 
(autoload 'magit-snapshot-both "magit-stash" "\
Create a snapshot of the index and working tree.
Untracked files are included according to popup arguments.
One prefix argument is equivalent to `--include-untracked'
while two prefix arguments are equivalent to `--all'.
 
\(fn &optional INCLUDE-UNTRACKED)" t nil)
 
(autoload 'magit-snapshot-index "magit-stash" "\
Create a snapshot of the index only.
Unstaged and untracked changes are not stashed.
 
\(fn)" t nil)
 
(autoload 'magit-snapshot-worktree "magit-stash" "\
Create a snapshot of unstaged changes in the working tree.
Untracked files are included according to popup arguments.
One prefix argument is equivalent to `--include-untracked'
while two prefix arguments are equivalent to `--all'.
 
\(fn &optional INCLUDE-UNTRACKED)" t nil)
 
(autoload 'magit-stash-apply "magit-stash" "\
Apply a stash to the working tree.
Try to preserve the stash index.  If that fails because there
are staged changes, apply without preserving the stash index.
 
\(fn STASH)" t nil)
 
(autoload 'magit-stash-drop "magit-stash" "\
Remove a stash from the stash list.
When the region is active offer to drop all contained stashes.
 
\(fn STASH)" t nil)
 
(autoload 'magit-stash-clear "magit-stash" "\
Remove all stashes saved in REF's reflog by deleting REF.
 
\(fn REF)" t nil)
 
(autoload 'magit-stash-branch "magit-stash" "\
Create and checkout a new BRANCH from STASH.
 
\(fn STASH BRANCH)" t nil)
 
(autoload 'magit-stash-branch-here "magit-stash" "\
Create and checkout a new BRANCH and apply STASH.
The branch is created using `magit-branch', using the current
branch or `HEAD' as the string-point.
 
\(fn STASH BRANCH)" t nil)
 
(autoload 'magit-stash-format-patch "magit-stash" "\
Create a patch from STASH
 
\(fn STASH)" t nil)
 
(autoload 'magit-stash-list "magit-stash" "\
List all stashes in a buffer.
 
\(fn)" t nil)
 
(autoload 'magit-stash-show "magit-stash" "\
Show all diffs of a stash in a buffer.
 
\(fn STASH &optional ARGS FILES)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-stash" '("magit-")))
 
;;;***
 
;;;### (autoloads nil "magit-status" "magit-status.el" (0 0 0 0))
;;; Generated autoloads from magit-status.el
 
(autoload 'magit-init "magit-status" "\
Initialize a Git repository, then show its status.
 
If the directory is below an existing repository, then the user
has to confirm that a new one should be created inside.  If the
directory is the root of the existing repository, then the user
has to confirm that it should be reinitialized.
 
Non-interactively DIRECTORY is (re-)initialized unconditionally.
 
\(fn DIRECTORY)" t nil)
 
(autoload 'magit-status "magit-status" "\
Show the status of the current Git repository in a buffer.
With a prefix argument prompt for a repository to be shown.
With two prefix arguments prompt for an arbitrary directory.
If that directory isn't the root of an existing repository,
then offer to initialize it as a new repository.
 
\(fn &optional DIRECTORY CACHE)" t nil)
 
(autoload 'magit-status-internal "magit-status" "\
 
 
\(fn DIRECTORY)" nil nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-status" '("magit")))
 
;;;***
 
;;;### (autoloads nil "magit-submodule" "magit-submodule.el" (0 0
;;;;;;  0 0))
;;; Generated autoloads from magit-submodule.el
 (autoload 'magit-submodule-popup "magit-submodule" nil t)
 
(autoload 'magit-submodule-add "magit-submodule" "\
Add the repository at URL as a module.
 
Optional PATH is the path to the module relative to the root of
the superproject.  If it is nil, then the path is determined
based on the URL.  Optional NAME is the name of the module.  If
it is nil, then PATH also becomes the name.
 
\(fn URL &optional PATH NAME ARGS)" t nil)
 
(autoload 'magit-submodule-read-name-for-path "magit-submodule" "\
 
 
\(fn PATH &optional PREFER-SHORT)" nil nil)
 
(autoload 'magit-submodule-register "magit-submodule" "\
Register MODULES.
 
With a prefix argument act on all suitable modules.  Otherwise,
if the region selects modules, then act on those.  Otherwise, if
there is a module at point, then act on that.  Otherwise read a
single module from the user.
 
\(fn MODULES)" t nil)
 
(autoload 'magit-submodule-populate "magit-submodule" "\
Create MODULES working directories, checking out the recorded commits.
 
With a prefix argument act on all suitable modules.  Otherwise,
if the region selects modules, then act on those.  Otherwise, if
there is a module at point, then act on that.  Otherwise read a
single module from the user.
 
\(fn MODULES)" t nil)
 
(autoload 'magit-submodule-update "magit-submodule" "\
Update MODULES by checking out the recorded commits.
 
With a prefix argument act on all suitable modules.  Otherwise,
if the region selects modules, then act on those.  Otherwise, if
there is a module at point, then act on that.  Otherwise read a
single module from the user.
 
\(fn MODULES ARGS)" t nil)
 
(autoload 'magit-submodule-synchronize "magit-submodule" "\
Synchronize url configuration of MODULES.
 
With a prefix argument act on all suitable modules.  Otherwise,
if the region selects modules, then act on those.  Otherwise, if
there is a module at point, then act on that.  Otherwise read a
single module from the user.
 
\(fn MODULES ARGS)" t nil)
 
(autoload 'magit-submodule-unpopulate "magit-submodule" "\
Remove working directories of MODULES.
 
With a prefix argument act on all suitable modules.  Otherwise,
if the region selects modules, then act on those.  Otherwise, if
there is a module at point, then act on that.  Otherwise read a
single module from the user.
 
\(fn MODULES ARGS)" t nil)
 
(autoload 'magit-submodule-remove "magit-submodule" "\
Unregister MODULES and remove their working directories.
 
For safety reasons, do not remove the gitdirs and if a module has
uncomitted changes, then do not remove it at all.  If a module's
gitdir is located inside the working directory, then move it into
the gitdir of the superproject first.
 
With the \"--force\" argument offer to remove dirty working
directories and with a prefix argument offer to delete gitdirs.
Both actions are very dangerous and have to be confirmed.  There
are additional safety precautions in place, so you might be able
to recover from making a mistake here, but don't count on it.
 
\(fn MODULES ARGS TRASH-GITDIRS)" t nil)
 
(autoload 'magit-insert-modules "magit-submodule" "\
Insert submodule sections.
Hook `magit-module-sections-hook' controls which module sections
are inserted, and option `magit-module-sections-nested' controls
whether they are wrapped in an additional section.
 
\(fn)" nil nil)
 
(autoload 'magit-insert-modules-overview "magit-submodule" "\
Insert sections for all modules.
For each section insert the path and the output of `git describe --tags',
or, failing that, the abbreviated HEAD commit hash.
 
\(fn)" nil nil)
 
(autoload 'magit-insert-modules-unpulled-from-upstream "magit-submodule" "\
Insert sections for modules that haven't been pulled from the upstream.
These sections can be expanded to show the respective commits.
 
\(fn)" nil nil)
 
(autoload 'magit-insert-modules-unpulled-from-pushremote "magit-submodule" "\
Insert sections for modules that haven't been pulled from the push-remote.
These sections can be expanded to show the respective commits.
 
\(fn)" nil nil)
 
(autoload 'magit-insert-modules-unpushed-to-upstream "magit-submodule" "\
Insert sections for modules that haven't been pushed to the upstream.
These sections can be expanded to show the respective commits.
 
\(fn)" nil nil)
 
(autoload 'magit-insert-modules-unpushed-to-pushremote "magit-submodule" "\
Insert sections for modules that haven't been pushed to the push-remote.
These sections can be expanded to show the respective commits.
 
\(fn)" nil nil)
 
(autoload 'magit-list-submodules "magit-submodule" "\
Display a list of the current repository's submodules.
 
\(fn)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-submodule" '("magit-")))
 
;;;***
 
;;;### (autoloads nil "magit-subtree" "magit-subtree.el" (0 0 0 0))
;;; Generated autoloads from magit-subtree.el
 (autoload 'magit-subtree-popup "magit-subtree" nil t)
 
(autoload 'magit-subtree-add "magit-subtree" "\
Add REF from REPOSITORY as a new subtree at PREFIX.
 
\(fn PREFIX REPOSITORY REF ARGS)" t nil)
 
(autoload 'magit-subtree-add-commit "magit-subtree" "\
Add COMMIT as a new subtree at PREFIX.
 
\(fn PREFIX COMMIT ARGS)" t nil)
 
(autoload 'magit-subtree-merge "magit-subtree" "\
Merge COMMIT into the PREFIX subtree.
 
\(fn PREFIX COMMIT ARGS)" t nil)
 
(autoload 'magit-subtree-pull "magit-subtree" "\
Pull REF from REPOSITORY into the PREFIX subtree.
 
\(fn PREFIX REPOSITORY REF ARGS)" t nil)
 
(autoload 'magit-subtree-push "magit-subtree" "\
Extract the history of the subtree PREFIX and push it to REF on REPOSITORY.
 
\(fn PREFIX REPOSITORY REF ARGS)" t nil)
 
(autoload 'magit-subtree-split "magit-subtree" "\
Extract the history of the subtree PREFIX.
 
\(fn PREFIX COMMIT ARGS)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-subtree" '("magit-")))
 
;;;***
 
;;;### (autoloads nil "magit-tag" "magit-tag.el" (0 0 0 0))
;;; Generated autoloads from magit-tag.el
 (autoload 'magit-tag-popup "magit" nil t)
 
(autoload 'magit-tag-create "magit-tag" "\
Create a new tag with the given NAME at REV.
With a prefix argument annotate the tag.
 
\(git tag [--annotate] NAME REV)
 
\(fn NAME REV &optional ARGS)" t nil)
 
(autoload 'magit-tag-delete "magit-tag" "\
Delete one or more tags.
If the region marks multiple tags (and nothing else), then offer
to delete those, otherwise prompt for a single tag to be deleted,
defaulting to the tag at point.
 
\(git tag -d TAGS)
 
\(fn TAGS)" t nil)
 
(autoload 'magit-tag-prune "magit-tag" "\
Offer to delete tags missing locally from REMOTE, and vice versa.
 
\(fn TAGS REMOTE-TAGS REMOTE)" t nil)
 
(autoload 'magit-tag-release "magit-tag" "\
Create an opinionated release tag.
 
Assume version tags that match \"\\\\`v?[0-9]\\\\(\\\\.[0-9]\\\\)*\\\\'\".
Prompt for the name of the new tag using the highest existing tag
as initial input and call \"git tag --annotate --sign -m MSG\" TAG,
regardless of whether these arguments are enabled in the popup.
Given a TAG \"v1.2.3\" and a repository \"/path/to/foo-bar\", the
MESSAGE would be \"Foo-Bar 1.2.3\".
 
Because it is so opinionated, this command is not available from
the tag popup by default.
 
\(fn TAG)" t nil)
 
;;;***
 
;;;### (autoloads nil "magit-utils" "magit-utils.el" (0 0 0 0))
;;; Generated autoloads from magit-utils.el
 
(autoload 'magit-emacs-Q-command "magit-utils" "\
Show a shell command that runs an uncustomized Emacs with only Magit loaded.
See info node `(magit)Debugging Tools' for more information.
 
\(fn)" t nil)
 
(autoload 'Info-follow-nearest-node--magit-gitman "magit-utils" "\
 
 
\(fn FN &optional FORK)" nil nil)
 
(advice-add 'Info-follow-nearest-node :around 'Info-follow-nearest-node--magit-gitman)
 
(autoload 'org-man-export--magit-gitman "magit-utils" "\
 
 
\(fn FN LINK DESCRIPTION FORMAT)" nil nil)
 
(advice-add 'org-man-export :around 'org-man-export--magit-gitman)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-utils" '("magit-" "whitespace-dont-turn-on-in-magit-mode")))
 
;;;***
 
;;;### (autoloads nil "magit-wip" "magit-wip.el" (0 0 0 0))
;;; Generated autoloads from magit-wip.el
 
(defvar magit-wip-after-save-mode nil "\
Non-nil if Magit-Wip-After-Save mode is enabled.
See the `magit-wip-after-save-mode' command
for a description of this minor mode.
Setting this variable directly does not take effect;
either customize it (see the info node `Easy Customization')
or call the function `magit-wip-after-save-mode'.")
 
(custom-autoload 'magit-wip-after-save-mode "magit-wip" nil)
 
(autoload 'magit-wip-after-save-mode "magit-wip" "\
Toggle Magit-Wip-After-Save-Local mode in all buffers.
With prefix ARG, enable Magit-Wip-After-Save mode if ARG is positive;
otherwise, disable it.  If called from Lisp, enable the mode if
ARG is omitted or nil.
 
Magit-Wip-After-Save-Local mode is enabled in all buffers where
`magit-wip-after-save-local-mode-turn-on' would do it.
See `magit-wip-after-save-local-mode' for more information on Magit-Wip-After-Save-Local mode.
 
\(fn &optional ARG)" t nil)
 
(defvar magit-wip-after-apply-mode nil "\
Non-nil if Magit-Wip-After-Apply mode is enabled.
See the `magit-wip-after-apply-mode' command
for a description of this minor mode.")
 
(custom-autoload 'magit-wip-after-apply-mode "magit-wip" nil)
 
(autoload 'magit-wip-after-apply-mode "magit-wip" "\
Commit to work-in-progress refs.
 
After applying a change using any \"apply variant\"
command (apply, stage, unstage, discard, and reverse) commit the
affected files to the current wip refs.  For each branch there
may be two wip refs; one contains snapshots of the files as found
in the worktree and the other contains snapshots of the entries
in the index.
 
\(fn &optional ARG)" t nil)
 
(defvar magit-wip-before-change-mode nil "\
Non-nil if Magit-Wip-Before-Change mode is enabled.
See the `magit-wip-before-change-mode' command
for a description of this minor mode.")
 
(custom-autoload 'magit-wip-before-change-mode "magit-wip" nil)
 
(autoload 'magit-wip-before-change-mode "magit-wip" "\
Commit to work-in-progress refs before certain destructive changes.
 
Before invoking a revert command or an \"apply variant\"
command (apply, stage, unstage, discard, and reverse) commit the
affected tracked files to the current wip refs.  For each branch
there may be two wip refs; one contains snapshots of the files
as found in the worktree and the other contains snapshots of the
entries in the index.
 
Only changes to files which could potentially be affected by the
command which is about to be called are committed.
 
\(fn &optional ARG)" t nil)
 
(autoload 'magit-wip-commit-initial-backup "magit-wip" "\
Before saving, commit current file to a worktree wip ref.
 
The user has to add this function to `before-save-hook'.
 
Commit the current state of the visited file before saving the
current buffer to that file.  This backs up the same version of
the file as `backup-buffer' would, but stores the backup in the
worktree wip ref, which is also used by the various Magit Wip
modes, instead of in a backup file as `backup-buffer' would.
 
This function ignores the variables that affect `backup-buffer'
and can be used along-side that function, which is recommended
because this function only backs up files that are tracked in
a Git repository.
 
\(fn)" nil nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-wip" '("magit-")))
 
;;;***
 
;;;### (autoloads nil "magit-worktree" "magit-worktree.el" (0 0 0
;;;;;;  0))
;;; Generated autoloads from magit-worktree.el
 (autoload 'magit-worktree-popup "magit-worktree" nil t)
 
(autoload 'magit-worktree-checkout "magit-worktree" "\
Checkout BRANCH in a new worktree at PATH.
 
\(fn PATH BRANCH)" t nil)
 
(autoload 'magit-worktree-branch "magit-worktree" "\
Create a new BRANCH and check it out in a new worktree at PATH.
 
\(fn PATH BRANCH START-POINT &optional FORCE)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-worktree" '("magit-")))
 
;;;***
 
;;;### (autoloads nil nil ("magit-core.el" "magit-obsolete.el" "magit-pkg.el")
;;;;;;  (0 0 0 0))
 
;;;***
 
;; Local Variables:
;; version-control: never
;; no-byte-compile: t
;; no-update-autoloads: t
;; coding: utf-8
;; End:
;;; magit-autoloads.el ends here