;ELC
;;; Compiled
;;; in Emacs version 28.2
;;; with all optimizations.



(byte-code "\300\301\302\"\210\300\303\302\"\210\304\305\306\307\310\311\312\313\312\314&	\210\315\316\317\320\321DD\322\323\324%\210\315\325\317\320\326DD\327\323\324%\210\315\330\317\320\331DD\332\323\324%\210\315\333\317\320\334DD\335\323\324%\210\315\336\317\320\337DD\340\323\341\342\343&\210\315\344\317\320\345DD\346\310\347\323\350&\210\315\351\317\320\352DD\353\310\347\323\324&\210\315\354\317\320\355DD\356\310\347\323\357&\207" [autoload vc-find-revision "vc" vc-find-revision-no-save custom-declare-group diff-mode nil "Major mode for viewing/editing diffs." :version "21.1" :group tools diff custom-declare-variable diff-default-read-only funcall function #[0 "\300\207" [nil] 1 #1=""] "If non-nil, `diff-mode' buffers default to being read-only." :type boolean diff-jump-to-old-file #[0 "\300\207" [nil] 1 #1#] "Non-nil means `diff-goto-source' jumps to the old file.\nElse, it jumps to the new file." diff-update-on-the-fly #[0 "\300\207" [t] 1 #1#] "Non-nil means hunk headers are kept up-to-date on-the-fly.\nWhen editing a diff file, the line numbers in the hunk headers\nneed to be kept consistent with the actual diff.  This can\neither be done on the fly (but this sometimes interacts poorly with the\nundo mechanism) or whenever the file is written (can be slow\nwhen editing big diffs).\n\nIf this variable is nil, the hunk header numbers are updated when\nthe file is written instead." diff-advance-after-apply-hunk #[0 "\300\207" [t] 1 #1#] "Non-nil means `diff-apply-hunk' will move to the next hunk after applying." diff-mode-hook #[0 "\300\207" [nil] 1 #1#] "Run after setting up the `diff-mode' major mode." hook :options (diff-delete-empty-files diff-make-unified) diff-refine #[0 "\300\207" [font-lock] 1 #1#] "If non-nil, enable hunk refinement.\n\nThe value `font-lock' means to refine during font-lock.\nThe value `navigation' means to refine each hunk as you visit it\nwith `diff-hunk-next' or `diff-hunk-prev'.\n\nYou can always manually refine a hunk with `diff-refine-hunk'." "27.1" (choice (const :tag "Don't refine hunks" nil) (const :tag "Refine hunks during font-lock" font-lock) (const :tag "Refine hunks during navigation" navigation)) diff-font-lock-prettify #[0 "\300\207" [nil] 1 #1#] "If non-nil, font-lock will try and make the format prettier.\n\nThis mimics the Magit's diff format by making the hunk header\nless cryptic, and on GUI frames also displays insertion and\ndeletion indicators on the left fringe (if it's available)." diff-font-lock-syntax #[0 "\300\207" [t] 1 #1#] "If non-nil, diff hunk font-lock includes source language syntax highlighting.\nThis highlighting is the same as added by `font-lock-mode'\nwhen corresponding source files are visited normally.\nSyntax highlighting is added over diff-mode's own highlighted changes.\n\nIf t, the default, highlight syntax only in Diff buffers created by Diff\ncommands that compare files or by VC commands that compare revisions.\nThese provide all necessary context for reliable highlighting.  This value\nrequires support from a VC backend to find the files being compared.\nFor diffs against the working-tree version of a file, the highlighting is\nbased on the current file contents.  File-based fontification tries to\ninfer fontification from the compared files.\n\nIf `hunk-only' fontification is based on hunk alone, without full source.\nIt tries to highlight hunks without enough context that sometimes might result\nin wrong fontification.  This is the fastest option, but less reliable.\n\nIf `hunk-also', use reliable file-based syntax highlighting when available\nand hunk-based syntax highlighting otherwise as a fallback." (choice (const :tag "Don't highlight syntax" nil) (const :tag "Hunk-based only" hunk-only) (const :tag "Highlight syntax" t) (const :tag "Allow hunk-based fallback" hunk-also))] 10)
#@62 The VC backend that created the current Diff buffer, if any.
(defvar diff-vc-backend nil (#$ . 3923))
#@63 The VC revisions compared in the current Diff buffer, if any.
(defvar diff-vc-revisions nil (#$ . 4031))
#@66 The default directory where the current Diff buffer was created.
(defvar diff-default-directory nil (#$ . 4142))
(make-variable-buffer-local 'diff-default-directory)
(defvar diff-outline-regexp "\\([*+][*+][*+] [^0-9]\\|@@ ...\\|\\*\\*\\* [0-9].\\|--- [0-9]..\\)")
#@61 Basic keymap for `diff-mode', bound to various prefix keys.
(defconst diff-mode-shared-map (byte-code "\302\303\304\305\300!\205\n\306	D$\207" [diff-mode-shared-map special-mode-map easy-mmode-define-keymap (("n" . diff-hunk-next) ("N" . diff-file-next) ("p" . diff-hunk-prev) ("P" . diff-file-prev) ("	" . diff-hunk-next) ([backtab] . diff-hunk-prev) ("k" . diff-hunk-kill) ("K" . diff-file-kill) ("}" . diff-file-next) ("{" . diff-file-prev) ("
" . diff-goto-source) ([mouse-2] . diff-goto-source) ("W" . widen) ("o" . diff-goto-source) ("A" . diff-ediff-patch) ("r" . diff-restrict-view) ("R" . diff-reverse-direction) ([remap undo] . diff-undo)) nil boundp :inherit] 6) (#$ . 4413))
#@59 Keymap for `diff-mode'.  See also `diff-mode-shared-map'.
(defconst diff-mode-map (byte-code "\302\303\304 \305
\"\210\306\211\203\211@\307\310#\210
A\266\202\202\n\210\211\262
B\311B\310\312\301!\205,	\310$\207" [diff-mode-shared-map diff-mode-map easy-mmode-define-keymap "" make-sparse-keymap set-keymap-parent ("A" "r" "R" "g" "q" "W" "z") define-key nil (("" . diff-goto-source) ("4A" . diff-add-change-log-entries-other-window) ("
" . diff-apply-hunk) ("" . diff-ediff-patch) ("" . diff-restrict-view) ("" . diff-split-hunk) ("" . diff-test-hunk) ("" . diff-reverse-direction) ("" . diff-context->unified) ("" . diff-unified->context) ("" . diff-ignore-whitespace-hunk) ("\f" . diff-refresh-hunk) ("" . diff-refine-hunk) ("" . next-error-follow-minor-mode)) boundp] 9) (#$ . 5108))
#@23 Menu for `diff-mode'.
(defvar diff-mode-menu nil (#$ . 5935))
(byte-code "\301\302\303\304$\210\305\306\307\310\311DD\312\313\314%\207" [diff-mode-map easy-menu-do-define diff-mode-menu "Menu for `diff-mode'." ("Diff" ["Jump to Source" diff-goto-source :help "Jump to the corresponding source line"] ["Apply hunk" diff-apply-hunk :help "Apply the current hunk to the source file and go to the next"] ["Test applying hunk" diff-test-hunk :help "See whether it's possible to apply the current hunk"] ["Apply diff with Ediff" diff-ediff-patch :help "Call `ediff-patch-file' on the current buffer"] ["Create Change Log entries" diff-add-change-log-entries-other-window :help "Create ChangeLog entries for the changes in the diff buffer"] "-----" ["Reverse direction" diff-reverse-direction :help "Reverse the direction of the diffs"] ["Context -> Unified" diff-context->unified :help "Convert context diffs to unified diffs"] ["Unified -> Context" diff-unified->context :help "Convert unified diffs to context diffs"] ["Remove trailing whitespace" diff-delete-trailing-whitespace :help "Remove trailing whitespace problems introduced by the diff"] ["Show trailing whitespace" whitespace-mode :style toggle :selected (bound-and-true-p whitespace-mode) :help "Show trailing whitespace in modified lines"] "-----" ["Split hunk" diff-split-hunk :active (diff-splittable-p) :help "Split the current (unified diff) hunk at point into two hunks"] ["Ignore whitespace changes" diff-ignore-whitespace-hunk :help "Re-diff the current hunk, ignoring whitespace differences"] ["Recompute the hunk" diff-refresh-hunk :help "Re-diff the current hunk, keeping the whitespace differences"] ["Highlight fine changes" diff-refine-hunk :help "Highlight changes of hunk at point at a finer granularity"] ["Kill current hunk" diff-hunk-kill :help "Kill current hunk"] ["Kill current file's hunks" diff-file-kill :help "Kill all current file's hunks"] "-----" ["Previous Hunk" diff-hunk-prev :help "Go to the previous count'th hunk"] ["Next Hunk" diff-hunk-next :help "Go to the next count'th hunk"] ["Previous File" diff-file-prev :help "Go to the previous count'th file"] ["Next File" diff-file-next :help "Go to the next count'th file"]) custom-declare-variable diff-minor-mode-prefix funcall function #[0 "\300\207" ["="] 1 ""] "Prefix key for `diff-minor-mode' commands." :type (choice (string "") (string "C-c=") string)] 6)
#@65 Keymap for `diff-minor-mode'.  See also `diff-mode-shared-map'.
(defconst diff-minor-mode-map (byte-code "\303	BC\304\305\302!\205
\n\304$\207" [diff-minor-mode-prefix diff-mode-shared-map diff-minor-mode-map easy-mmode-define-keymap nil boundp] 5) (#$ . 8349))
#@111 Non-nil if Diff-Auto-Refine mode is enabled.
Use the command `diff-auto-refine-mode' to change this variable.
(defvar diff-auto-refine-mode nil (#$ . 8620))
(make-variable-buffer-local 'diff-auto-refine-mode)
#@896 Toggle automatic diff hunk finer highlighting (Diff Auto Refine mode).

This is a minor mode.  If called interactively, toggle the
`Diff-Auto-Refine mode' mode.  If the prefix argument is positive,
enable the mode, and if it is zero or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable the
mode if ARG is nil, omitted, or is a positive number.  Disable the
mode if ARG is a negative number.

To check whether the minor mode is enabled in the current buffer,
evaluate `diff-auto-refine-mode'.

The mode's hook is called both when the mode is enabled and when it is
disabled.

Diff Auto Refine mode is a buffer-local minor mode used with
`diff-mode'.  When enabled, Emacs automatically highlights
changes in detail as the user visits hunks.  When transitioning
from disabled to enabled, it tries to refine the current hunk, as
well.

(fn &optional ARG)
(defalias 'diff-auto-refine-mode #[256 "\302 
\303=\203
?\202
\247\203
\304W\203\305\202\306\307\301!\2031\310\300	\"\2031\300	B\203I\311\312\313\"\210\3141E\315 0\210\202N\210\202N\311\312\305\"\210\316\317\203X\320\202Y\321\"\210\322\323!\203{\302 \203m\211\302 \232\203{\324\325\203w\326\202x\327\330#\210\210\331 \210\207" [diff-auto-refine-mode local-minor-modes current-message toggle 1 nil t boundp delq customize-set-variable diff-refine navigation (debug error) diff-refine-hunk run-hooks diff-auto-refine-mode-hook diff-auto-refine-mode-on-hook diff-auto-refine-mode-off-hook called-interactively-p any message "Diff-Auto-Refine mode %sabled%s" "en" "dis" " in current buffer" force-mode-line-update] 6 (#$ . 8836) (byte-code "\203\n\301!\202\302C\207" [current-prefix-arg prefix-numeric-value toggle] 2)])
(defvar diff-auto-refine-mode-hook nil)
(byte-code "\301\302N\204\f\303\301\302\304#\210\303\301\305\306#\210\303\301\307\310C#\210\311\312\310\313\300!\205#\310\211%\210\314\312\315\316#\210\317\312\315\316#\210\320\321\322\323#\210\320\324\325\326#\210\320\327\330\331#\210\320\332\333\334#\210\320\335\336\337#\210\320\340\341\342#\210\320\343\344\345\346\347%\210\320\350\351\345\346\352%\210\320\353\354\355\346\356%\207" [diff-auto-refine-mode-map diff-auto-refine-mode-hook variable-documentation put "Hook run after entering or leaving `diff-auto-refine-mode'.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" custom-type hook standard-value nil add-minor-mode diff-auto-refine-mode boundp make-obsolete "set `diff-refine' instead." "27.1" make-obsolete-variable custom-declare-face diff-header ((((class color) (min-colors 88) (background light)) :background "grey85" :extend t) (((class color) (min-colors 88) (background dark)) :background "grey45" :extend t) (((class color)) :foreground "blue1" :weight bold :extend t) (t :weight bold :extend t)) "`diff-mode' face inherited by hunk and index header faces." diff-file-header ((((class color) (min-colors 88) (background light)) :background "grey75" :weight bold :extend t) (((class color) (min-colors 88) (background dark)) :background "grey60" :weight bold :extend t) (((class color)) :foreground "cyan" :weight bold :extend t) (t :weight bold :extend t)) "`diff-mode' face used to highlight file header lines." diff-index ((t :inherit diff-file-header)) "`diff-mode' face used to highlight index header lines." diff-hunk-header ((t :inherit diff-header)) "`diff-mode' face used to highlight hunk header lines." diff-removed ((default :inherit diff-changed) (((class color) (min-colors 257) (background light)) :background "#ffeeee" :extend t) (((class color) (min-colors 88) (background light)) :background "#ffdddd" :extend t) (((class color) (min-colors 88) (background dark)) :background "#553333" :extend t) (((class color)) :foreground "red" :extend t)) "`diff-mode' face used to highlight removed lines." diff-added ((default :inherit diff-changed) (((class color) (min-colors 257) (background light)) :background "#eeffee" :extend t) (((class color) (min-colors 88) (background light)) :background "#ddffdd" :extend t) (((class color) (min-colors 88) (background dark)) :background "#335533" :extend t) (((class color)) :foreground "green" :extend t)) "`diff-mode' face used to highlight added lines." diff-changed-unspecified ((default :inherit diff-changed) (((class color) (min-colors 88) (background light)) :background "grey90" :extend t) (((class color) (min-colors 88) (background dark)) :background "grey20" :extend t) (((class color)) :foreground "grey" :extend t)) "`diff-mode' face used to highlight changed lines." :version "28.1" diff-changed ((t nil)) "25.1" diff-indicator-removed ((default :inherit diff-removed) (((class color) (min-colors 88)) :foreground "#aa2222")) "`diff-mode' face used to highlight indicator of removed lines (-, <)." "22.1"] 6)
(defvar diff-indicator-removed-face 'diff-indicator-removed)
(custom-declare-face 'diff-indicator-added '((default :inherit diff-added) (((class color) (min-colors 88)) :foreground "#22aa22")) "`diff-mode' face used to highlight indicator of added lines (+, >)." :version "22.1")
(defvar diff-indicator-added-face 'diff-indicator-added)
(custom-declare-face 'diff-indicator-changed '((default :inherit diff-changed) (((class color) (min-colors 88)) :foreground "#aaaa22")) "`diff-mode' face used to highlight indicator of changed lines." :version "22.1")
(defvar diff-indicator-changed-face 'diff-indicator-changed)
(byte-code "\300\301\302\303#\210\300\304\305\306\307\310%\210\300\311\312\313#\210\300\314\315\316\307\317%\207" [custom-declare-face diff-function ((t :inherit diff-header)) "`diff-mode' face used to highlight function names produced by \"diff -p\"." diff-context ((t :extend t)) "`diff-mode' face used to highlight context and other side-information." :version "27.1" diff-nonexistent ((t :inherit diff-file-header)) "`diff-mode' face used to highlight nonexistent files in recursive diffs." diff-error ((((class color)) :foreground "red" :background "black" :weight bold) (t :weight bold)) "`diff-mode' face for error messages from diff." "28.1"] 6)
(defconst diff-yank-handler '(diff-yank-function))
#@13 

(fn TEXT)
(defalias 'diff-yank-function #[257 "\300\301\302#`c\210
\206\303\304!?\205F\305 \210\212\306\307\310#\203/\311f\312=\203+\313\2020\314\2020\315)\212\306
\310#\205C\316\317\310\211#\210\2022)\262
\207" [next-single-property-change 0 yank-handler derived-mode-p diff-mode undo-boundary re-search-backward "^[><!][ 	]" t nil 33 "^[!+- ][ 	]" "^[<>][ 	]" "^[ <>!+-]" replace-match ""] 8 (#$ . 15034)])
(defconst diff-hunk-header-re-unified "^@@ -\\([0-9]+\\)\\(?:,\\([0-9]+\\)\\)? \\+\\([0-9]+\\)\\(?:,\\([0-9]+\\)\\)? @@")
(defconst diff-context-mid-hunk-header-re "--- \\([0-9]+\\)\\(?:,\\([0-9]+\\)\\)? ----$")
#@215 Controls how changed lines are fontified in context diffs.
If non-nil, use the face `diff-changed-unspecified'.  Otherwise,
use the face `diff-removed' for removed lines, and the face
`diff-added' for added lines.
(defvar diff-use-changed-face (byte-code "\300\301!\205\302\301\303\"?\205\302\301\304\"?\207" [face-differs-from-default-p diff-changed face-equal diff-added diff-removed] 3) (#$ . 15677))
(defvar diff-font-lock-keywords (byte-code "\302\303Q\304B\305\306	\307B\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326C\327C\330C\257\207" [diff-hunk-header-re-unified diff-context-mid-hunk-header-re "\\(" "\\)\\(.*\\)$" ((1 'diff-hunk-header) (6 'diff-function)) ("^\\(\\*\\{15\\}\\)\\(.*\\)$" (1 'diff-hunk-header) (2 'diff-function)) ("^\\*\\*\\* .+ \\*\\*\\*\\*" quote diff-hunk-header) 'diff-hunk-header ("^[0-9,]+[acd][0-9,]+$" quote diff-hunk-header) ("^---$" quote diff-hunk-header) ("^\\(---\\|\\+\\+\\+\\|\\*\\*\\*\\) \\([^	\n]+?\\)\\(?:	.*\\| \\(\\*\\*\\*\\*\\|----\\)\\)?\n" (0 'diff-header) (2 (if (not (match-end 3)) 'diff-file-header) prepend)) ("^\\([-<]\\)\\(.*\n\\)" (1 diff-indicator-removed-face) (2 'diff-removed)) ("^\\([+>]\\)\\(.*\n\\)" (1 diff-indicator-added-face) (2 'diff-added)) ("^\\(!\\)\\(.*\n\\)" (1 (if diff-use-changed-face diff-indicator-changed-face (save-match-data (let ((limit (save-excursion (diff-beginning-of-hunk)))) (if (save-excursion (re-search-backward diff-context-mid-hunk-header-re limit t)) diff-indicator-added-face diff-indicator-removed-face))))) (2 (if diff-use-changed-face 'diff-changed-unspecified (save-match-data (let ((limit (save-excursion (diff-beginning-of-hunk)))) (if (save-excursion (re-search-backward diff-context-mid-hunk-header-re limit t)) 'diff-added 'diff-removed)))))) ("^\\(?:Index\\|revno\\): \\(.+\\).*\n" (0 'diff-header) (1 'diff-index prepend)) ("^\\(?:index .*\\.\\.\\|diff \\).*\n" quote diff-header) ("^\\(?:new\\|deleted\\) file mode .*\n" quote diff-header) ("^Only in .*\n" quote diff-nonexistent) ("^Binary files .* differ\n" quote diff-file-header) ("^\\(#\\)\\(.*\\)" (1 font-lock-comment-delimiter-face) (2 font-lock-comment-face)) ("^diff: .*" (0 'diff-error)) ("^[^-=+*!<>#].*\n" (0 'diff-context)) diff--font-lock-syntax diff--font-lock-prettify diff--font-lock-refined] 21))
(defconst diff-font-lock-defaults '(diff-font-lock-keywords t nil nil nil (font-lock-multiline)))
(defvar diff-imenu-generic-expression '((nil "\\+\\+\\+ \\([^	\n]+\\)[	\n]" 1) (nil "^--- \\([^	\n]+\\)	.*\n\\*" 1)))
#@259 If non-nil, empty lines are valid in unified diffs.
Some versions of diff replace all-blank context lines in unified format with
empty lines.  This makes the format less robust, but is tolerated.
See https://lists.gnu.org/r/emacs-devel/2007-11/msg01990.html
(defvar diff-valid-unified-empty-line t (#$ . 18195))
(defconst diff-hunk-header-re (concat "^\\(?:" diff-hunk-header-re-unified ".*\\|\\*\\{15\\}.*\n\\*\\*\\* .+ \\*\\*\\*\\*\\|[0-9]+\\(,[0-9]+\\)?[acd][0-9]+\\(,[0-9]+\\)?\\)$"))
(defconst diff-file-header-re (byte-code "\301\302\303OP\207" [diff-hunk-header-re "^\\(--- .+\n\\+\\+\\+ \\|\\*\\*\\* .+\n--- \\|[^-+!<>0-9@* \n]\\).+\n" 1 nil] 4))
(defconst diff-separator-re "^--+ ?$")
(defvar diff-narrowed-to nil)
(defvar diff-buffer-type nil)
#@24 

(fn &optional STYLE)
(defalias 'diff-hunk-style #[256 "\301!\203\302f\303\236A\262
\304\225b\210\207" [diff-hunk-header-re looking-at nil ((64 . unified) (42 . context)) 0] 3 (#$ . 18956)])
#@68 Return previous line if it has patch separator as produced by git.
(defalias 'diff-prev-line-if-patch-separator #[0 "\301=\203\212`\302y\210\303\304!\203`\202\211\262
)\207`\207" [diff-buffer-type git -1 looking-at "^-- $"] 3 (#$ . 19157)])
#@104 Advance to the end of the current hunk, and return its position.

(fn &optional STYLE DONTTRUSTHEADER)
(defalias 'diff-end-of-hunk #[512 "\303\304!\203l\305!\262\306\225b\210
\204l\307\225\203l\310\311\307!\206!\312!\310\311\313!\206*\312!\212\314	\2035\315\2026\316\303\317$\210\320\304\321!\203F\322\202G\307!)\212\314	\203S\323\202T\324\303\317$\210\320\304\321!\203d\322\202e\307!)

]\266\205\211\204\305\314\325\267\202\225	\203\326\202\200\327\nP\202\226	\203\215\330\202\226\331\202\226\332\202\226\333\303\317#\205\236\306\224\262
	\203\301\211\206\251db\210`S\206\261`Sf\334=\203\301\335u\210`\262
\202\253\336 \262
\211\206\312db\207" [diff-hunk-header-re diff-valid-unified-empty-line diff-file-header-re nil looking-at diff-hunk-style 0 2 string-to-number match-string "1" 4 re-search-forward "^[- \n]" "^[- ]" t line-beginning-position ".*\n\\\\" 3 "^[+ \n]" "^[+ ]" #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (unified 119 context 133 normal 145)) "^[^-+# \\\n]\\|" "^[^-+# \\]\\|" "^[^-+#! \n\\]" "^[^-+#! \\]" "^[^<>#\\]" "^[^-+#!<> \\]" 10 -1 diff-prev-line-if-patch-separator] 11 (#$ . 19412)])
(defconst diff-file-junk-re "Index: \\|Prereq: \\|=\\{20,\\}\\|diff \\|index \\|\\(?:deleted file\\|new\\(?: file\\)?\\|old\\) mode\\|=== modified file")
#@50 Return non-nil if point is inside a diff header.
(defalias 'diff--at-diff-header-p #[0 "	\n`\3032Y\212\304y\210\305!\203\306\303`\"\210\307y\210\310\311\312!\313#\203,\304y\210\306\303`\"\210\211b\210\304y\210\305!\203V\305!\203Ho\204H\307y\210\2028\310\314\313#\210\304y\210\306\303`\"\210)\3140\207" [diff-hunk-header-re diff-file-header-re diff-file-junk-re headerp 0 looking-at throw -1 re-search-forward point-at-eol 4 t nil] 8 (#$ . 20762)])
#@222 Move back to the previous hunk beginning, and return its position.
If point is in a file header rather than a hunk, advance to the
next hunk if TRY-HARDER is non-nil; otherwise signal an error.

(fn &optional TRY-HARDER)
(defalias 'diff-beginning-of-hunk #[256 "\301 \210\302!\203`\207\303 
\203\203
b\207\304\305!\207\306
\307\310#\2065\311
\307\310#\2032\312y\210`\207\304\305!\207" [diff-hunk-header-re beginning-of-line looking-at diff--at-diff-header-p error "Can't find the beginning of the hunk" re-search-backward nil t re-search-forward 0] 7 (#$ . 21231)])
(defalias 'diff-unified-hunk-p #[0 "\212\3001\301 \210\302\303!0\202\210\304)\207" [(error) diff-beginning-of-hunk looking-at "^@@" nil] 2])
(defalias 'diff-beginning-of-file #[0 "\301 \210\302!?\2054`\303\304y\210\305\303\306#\211\262\203,`X\204+\305\303\306#\211\262\203,\207
b\210\307\310!\266\202\207" [diff-file-header-re beginning-of-line looking-at nil 3 re-search-backward t error "Can't find the beginning of the file"] 6])
(defalias 'diff-end-of-file #[0 "\301\302\303\304#\210\301\305P\303\306#\210\307\224\203\307\224b\207\310 \207" [diff-file-header-re re-search-forward "^[-+#!<>0-9@* \\]" nil t "^[^-+#!<>0-9@* \\]\\|" move 1 beginning-of-line] 4])
(defvar diff--auto-refine-data nil)
#@125 Go to the next COUNT'th hunk.
Interactively, COUNT is the prefix numeric argument, and defaults to 1.

(fn &optional COUNT)
(defalias 'diff-hunk-next #[256 "\211\204\303\262
\211\304W\203\305
[!\207\306!\203\211T\262
deZ\307 U?~\210\310\311\312$\204G\306!\203?\313 \206:db\210\202|\314\315\316\"\210\202|\304\224b\210p\317 =\203|\320\321!\203|\212\313 )\206`d\322
\311\312#\204{\323 \324\325!\210\323 
W\203z\326\311\"\210\210\210\211\203\203\327 \210\210	\330=\205\237\320\321!\205\237\np\331 B?\205\237\332\333\311\334#\207" [diff-hunk-header-re diff-refine diff--auto-refine-data 1 0 diff-hunk-prev looking-at buffer-size re-search-forward nil t diff-end-of-hunk user-error "No next %s" "hunk" window-buffer called-interactively-p interactive pos-visible-in-window-p window-start recenter (0) set-window-start diff-restrict-view navigation point-marker run-at-time 0.0 #[0 "\205,@A\303\3041$\303\305!\205!r
q\210\212\211b\210\306 *)0\207\210\307\310\311!\266\202\207" [diff--auto-refine-data inhibit-quit quit-flag nil (quit) buffer-live-p diff-refine-hunk t eval (ignore nil)] 4]] 7 (#$ . 22532) "p"])
(put 'diff-hunk-next 'definition-name 'diff-hunk)
#@129 Go to the previous COUNT'th hunk.
Interactively, COUNT is the prefix numeric argument, and defaults to 1.

(fn &optional COUNT)
(defalias 'diff-hunk-prev #[256 "\211\204\303\262
\211\304W\203\305
[!\207deZ\306 U?~\210\307\310\311$\204)\312\313\314\"\210\211\2030\315 \210\210	\316=\205L\317\320!\205L\np\321 B?\205L\322\323\310\324#\207" [diff-hunk-header-re diff-refine diff--auto-refine-data 1 0 diff-hunk-next buffer-size re-search-backward nil t user-error "No previous %s" "hunk" diff-restrict-view navigation called-interactively-p interactive point-marker run-at-time 0.0 #[0 "\205,@A\303\3041$\303\305!\205!r
q\210\212\211b\210\306 *)0\207\210\307\310\311!\266\202\207" [diff--auto-refine-data inhibit-quit quit-flag nil (quit) buffer-live-p diff-refine-hunk t eval (ignore nil)] 4]] 7 (#$ . 23731) "p"])
(put 'diff-hunk-prev 'definition-name 'diff-hunk)
#@125 Go to the next COUNT'th file.
Interactively, COUNT is the prefix numeric argument, and defaults to 1.

(fn &optional COUNT)
(defalias 'diff-file-next #[256 "\211\204\301\262
\211\302W\203\303
[!\207\304!\203\211T\262
\305\306\307$\2048\304!\2033\310 \2061db\207\311\312\313\"\207\302\224b\210p\314 =\205o\315\316!\205o\212\310 )\206Qd\317
\306\307#?\205m\320 \321\322!\210\320 
W\205k\323\306\"\262
\262
\207" [diff-file-header-re 1 0 diff-file-prev looking-at re-search-forward nil t diff-end-of-file user-error "No next %s" "file" window-buffer called-interactively-p interactive pos-visible-in-window-p window-start recenter (0) set-window-start] 6 (#$ . 24623) "p"])
(put 'diff-file-next 'definition-name 'diff-file)
#@129 Go to the previous COUNT'th file.
Interactively, COUNT is the prefix numeric argument, and defaults to 1.

(fn &optional COUNT)
(defalias 'diff-file-prev #[256 "\211\204\301\262
\211\302W\203\303
[!\207\304\305\306$?\205 \307\310\311\"\207" [diff-file-header-re 1 0 diff-file-next re-search-backward nil t user-error "No previous %s" "file"] 6 (#$ . 25370) "p"])
(put 'diff-file-prev 'definition-name 'diff-file)
#@235 Return the bounds of the diff hunk at point.
The return value is a list (BEG END), which are the hunk's start
and end positions.  Signal an error if no hunk is found.  If
point is in a file header, return the bounds of the next hunk.
(defalias 'diff-bounds-of-hunk #[0 "\212`\301\302!\303 \211Y\203

D\202&\304\305\302#\203#\306\224\303 D\202&\307\310!\266\203)\207" [diff-hunk-header-re diff-beginning-of-hunk t diff-end-of-hunk re-search-forward nil 0 error "No hunk found"] 7 (#$ . 25797)])
#@136 Return the bounds of the file segment at point.
The return value is a list (BEG END), which are the segment's
start and end positions.
(defalias 'diff-bounds-of-file #[0 "\212`\300 \210`\301 \210\302\303!\203\304u\210\202	
`V\203\305\306!\210\211`D\266\202)\207" [diff-beginning-of-file-and-junk diff-end-of-file looking-at "^\n" 1 error "Not inside a file diff"] 4 (#$ . 26305)])
#@135 Restrict the view to the current hunk.
If the prefix ARG is given, restrict the view to the current file instead.

(fn &optional ARG)
(defalias 'diff-restrict-view #[256 "\301\302\203\303 \202
\304 \"\210\305\300!\210\211\203\306\202\307\211\207" [diff-narrowed-to apply narrow-to-region diff-bounds-of-file diff-bounds-of-hunk make-local-variable file hunk] 4 (#$ . 26698) "P"])
(defalias 'diff--some-hunks-p #[0 "\212eb\210\301\302\303#)\207" [diff-hunk-header-re re-search-forward nil t] 4])
#@25 Kill the hunk at point.
(defalias 'diff-hunk-kill #[0 "\301 \204	\302\303!\207\304\305!\210\306 \3071\310 0\202\210\311\211\203J\211@b\210\312 \210`@U\203J
A@b\210\313\314!\203>\315u\210\2022`
A@U\203J\211\202K
\305\316\317\"\210\211@b\210\3201a\304\305!0\202c\210\311)\207" [inhibit-read-only diff--some-hunks-p error "No hunks" diff-beginning-of-hunk t diff-bounds-of-hunk (error) diff-bounds-of-file nil diff-hunk-next looking-at "^\n" 1 apply kill-region (error)] 6 (#$ . 27209) nil])
#@164 Go to the beginning of file-related diff-info.
This is like `diff-beginning-of-file' except it tries to skip back over leading
data such as "Index: ..." and such.
(defalias 'diff-beginning-of-file-and-junk #[0 "`\301 \210\302!\203\303y\210\202\304`\3051 \212\306 \210`)0\202#\211\262
\211:\205)\211\3071:\212b\210\310 \210`)0\202<\210\304\212\3111Q\247\203Ib\210\312 \210`0\202S\210\304)\212\303y\210\313\314\315#)\247\203u\247\203r\211\203u\211V\203u\262\211\203\207\247\203\207\211W\203\207\211\262\247\203\253X\203\253b\210\212\316y\317U\205\241\302!)\205\265\316y\210\202\226b\210\320@A\"\207" [diff-file-junk-re beginning-of-line looking-at 1 nil (error) diff-beginning-of-file (error) diff-file-next (error) diff-hunk-prev re-search-backward "^Index: " t -1 0 signal] 11 (#$ . 27721)])
#@28 Kill current file's hunks.
(defalias 'diff-file-kill #[0 "\301 \204	\302\303!\207\304\305!\210\305\306\307\310 \"\210)\3111\304\305!0\207\210\312\207" [inhibit-read-only diff--some-hunks-p error "No hunks" diff-beginning-of-hunk t apply kill-region diff-bounds-of-file (error) nil] 3 (#$ . 28566) nil])
#@28 Kill spurious empty diffs.
(defalias 'diff-kill-junk #[0 "\212\302eb\210\303\304	\305Q\306\302#\205'\307\225\203\310\224\202\311\225\312\224|\210\313 \210\202*\207" [inhibit-read-only diff-file-header-re t re-search-forward "^\\(Index: .*\n\\)\\([^-+!* <>].*\n\\)*?\\(\\(Index:\\) \\|" "\\)" nil 4 0 1 3 beginning-of-line] 4 (#$ . 28879) nil])
#@21 

(fn RE START END)
(defalias 'diff-count-matches #[771 "\212\300b\210\301\302#\203\211T\262
\202\211\262
)\207" [0 re-search-forward t] 8 (#$ . 29237)])
(defalias 'diff-splittable-p #[0 "\212\300 \210\301\302!\205\303y\210\301\302!\205\304 )\207" [beginning-of-line looking-at "^[-+ ]" -1 diff-unified-hunk-p] 2])
#@64 Split the current (unified diff) hunk at point into two hunks.
(defalias 'diff-split-hunk #[0 "\302 \210`\303 \304!\204\305\306!\210\307y\210\310\311\307!!\310\311\312!!
\313\314`#\\
\313\315`#\\\316b\210\317\320!\321\320!\322\261\210\323\")\207" [diff-hunk-header-re-unified inhibit-read-only beginning-of-line diff-beginning-of-hunk looking-at error "diff-split-hunk only works on unified context diffs" 1 string-to-number match-string 3 diff-count-matches "^[- 	]" "^[+ 	]" t "@@ -" number-to-string ",1 +" ",1 @@\n" diff-fixup-modifs] 11 (#$ . 29569) nil])
(defvar diff-remembered-files-alist nil)
(defvar diff-remembered-defdir nil)
#@13 

(fn FILE)
(defalias 'diff-filename-drop-dir #[257 "\300\301\"\205\f\211\302\225\303O\207" [string-match "/" 0 nil] 4 (#$ . 30228)])
#@378 Merge the diff between ANCESTOR and FROM into TO.
Returns the merged string if successful or nil otherwise.
The strings are assumed not to contain any "\n" (i.e. end of line).
If ANCESTOR = FROM, returns TO.
If ANCESTOR = TO, returns FROM.
The heuristic is simplistic and only really works for cases
like (diff-merge-strings "b/foo" "b/bar" "/a/c/foo").

(fn ANCESTOR FROM TO)
(defalias 'diff-merge-strings #[771 "\300\300\260\301\302\"\205(
\303\304\"\232\205(\211\304\224\305\224O\303\306\"\305\225\304\225OQ\207" ["\n" string-match "\\`\\(.*?\\)\\(.*\\)\\(.*\\)\n\\1\\(.*\\)\\3\n\\(.*\\(\\2\\).*\\)\\'" match-string 5 6 4] 9 (#$ . 30371)])
#@148 Tell Emacs where the find the source file of the current hunk.
If the OLD prefix arg is passed, tell the file NAME of the old file.

(fn OLD NAME)
(defalias 'diff-tell-file-name #[514 "\301!\211\204\302\303!\210\211BB\211\207" [diff-remembered-files-alist diff-hunk-file-names error "No file name to look for"] 5 (#$ . 31031) (byte-code "\301!\211\204\f\302\303!\210
\304\305\306@\"\307\310\311\"\312$D\207" [current-prefix-arg diff-hunk-file-names error "No file name to look for" read-file-name format "File for %s: " nil diff-find-file-name noprompt t] 9)])
#@91 Give the list of file names textually mentioned for the current hunk.

(fn &optional OLD)
(defalias 'diff-hunk-file-names #[256 "\212\301!\204\3021\303 0\202\210\202\204\304\305\306#\210\212\3071+\310 \210`0\202-\210e)\301\311!\203R
\203>\312\313!\202A\312\314!\203K\312\314!\202N\312\313!D\202V\313y\210\305\315\305\316?\205m\212\317\320\306#)\205m\312\313!C\317\321\305\306#\205\231\301\322!\205\231\203\207\312\323!\202\212\312\324!\203\225\312\325!\202\230\312\323!D#\"\266\202)\207" [diff-file-header-re looking-at (error) diff-beginning-of-file re-search-forward nil t (error) diff-hunk-prev "[-*][-*][-*] \\([^	\n]+\\).*\n[-+][-+][-+] \\([^	\n]+\\)" match-string 1 2 delq append re-search-backward "^Index: \\(.+\\)" "^diff " "^diff \\(-[^ 	\nL]+ +\\)*\\(-L +\\S-+ +\\)*\\(\\S-+\\)\\( +\\(\\S-+\\)\\)?" 3 5 4] 12 (#$ . 31610)])
#@252 Return the file corresponding to the current patch.
Non-nil OLD means that we want the old file.
Non-nil NOPROMPT means to prefer returning nil than to prompt the user.
PREFIX is only used internally: don't use it.

(fn &optional OLD NOPROMPT PREFIX)
(defalias 'diff-find-file-name #[768 "	\232\204\306\300!\210	\306\302!\210\307\212\214~\210\310!\2043\3111&\312 0\202*\210\202-\2043\313\307\314#\210\315!
\203C\316\317\320\"\"\262
\321
\n\"A\206
\3222y\n\211\205v\211@\323
@@@A#\211\203n\324
!\203n\325\322\"\210\210
A\266\202\202P\262
0\206
\211\307
\203\261
\211@\211\203\232\326
!\204\232
A\262
@\262
\202\205\262
\211\262\204\261\327\307\316\330\"\"\262\307\262
\202~\262
\206
\331\332\f\206\275\333\"\203\322\f\334\211\224O\324
!\205\315\211\262
\206

\204\360\335\305!\203\360\212\336
\307\314#)\203\360\337\340\341!#\206
?\205
\342
@\206\374\333!\343\344\345\"\346!\314\347!%\262
\306\302!\210

B\nB\211\262
\262
*\207" [diff-remembered-defdir default-directory diff-remembered-files-alist diff-file-header-re buffer-file-name cvs-pcl-cvs-dirchange-re make-local-variable nil looking-at (error) diff-beginning-of-file re-search-forward t diff-hunk-file-names mapcar make-closure #[257 "\300
P\207" [V0] 3 "\n\n(fn F)"] assoc --cl-block-nil-- diff-merge-strings file-exists-p throw file-regular-p delq diff-filename-drop-dir string-match "\\.rej\\'" "" 0 boundp re-search-backward diff-find-file-name match-string 1 expand-file-name read-file-name format "Use file %s: " file-name-directory file-name-nondirectory] 12 (#$ . 32489)])
#@48 Call `ediff-patch-file' on the current buffer.
(defalias 'diff-ediff-patch #[0 "\3001\n\301\302p\"0\207\210\301 \207" [(wrong-number-of-arguments) ediff-patch-file nil] 3 (#$ . 34091) nil])
#@163 Convert unified diffs to context diffs.
START and END are either taken from the region (if a prefix arg is given) or
else cover the whole buffer.

(fn START END)
(defalias 'diff-unified->context #[514 "\304
!\204\f\305
\306\"\262
\306\212
b\210\307\310	\311Q\312\306#\205\342
`
W\205\342
\313\216\306\314\224\203?\315\316\306\211\312\317%\210\315\320\306\211\312\314%\210\202\336
\321\322!\321\323!\206I\324\321\325!\321\326!\206S\324\327!\330\224\306\315\331	\332\333\334
!\334
!\\S!\335\260!\210\214\336\314!\337\340!\210`}\210\341 eb\210\212\307\342\312\306#)\204\222`d|\210\202	
db\210\312\211`\262
\343y\330U\203
\312f\211\344\267\202
\345c\210\312\262\343u\266\202\227`|\210\306\262\210\202\227\204\316\346u\210\345c\210\202\325\347\346!\210\350c\210\351u\266\202\227\212\343y\210\312f\352U)\203
`|\210\306\262\210\202\227\353c\210\312\262\351u\266\202\227\312\262\210\202\227\266db\210\212\354\332\333\334!\334!\\S!\355\261\210)\346y\210\212\307\356\312\306#)\2048
`d|\266\202\301
\312\211\212\307\357\312\306#)\203G
\312\262m\204\277
\312f\211\360\267\202\250
\345c\210\312\262\343u\266\202\254
\306\262\306\262\210\202\254
\204w
\346u\210\345c\210\202~
\347\346!\210\350c\210\351u\266\202\254
\212\346y\210m)\204\253
\306\262\306\262\210\202\254
\353c\210\312\262\351u\210\312\262\210\202\254
\312\262\210`\346y\210
\203\273
\211`|\210\312\262\210\202G
\266\211\203\333
\306=\204\333
\361\nZd\362d\257B)\266*\202*\207" [inhibit-read-only diff-hunk-header-re-unified combine-after-change-calls buffer-undo-list markerp copy-marker t re-search-forward "^\\(\\(---\\) .+\n\\(\\+\\+\\+\\) .+\\|" ".*\\)$" nil #[0 "\300 \207" [combine-after-change-execute] 1] 2 replace-match "---" 3 "***" match-string 4 5 "1" 6 7 marker-position 0 "***************\n*** " "," number-to-string string-to-number " ****" line-beginning-position diff-end-of-hunk unified buffer-string "^-" -1 #s(hash-table size 5 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (32 169 43 182 45 193 92 220 10 243)) " " 1 delete-char "! " -2 43 "  " "--- " " ----\n" "^\\+" "^\\+.*\n-" #s(hash-table size 5 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (32 339 45 352 43 362 92 389 10 408)) apply diff-context->unified] 18 (#$ . 34289) (byte-code "\204	\301 \203\302 \303 D\207edD\207" [current-prefix-arg use-region-p region-beginning region-end] 2)])
#@248 Convert context diffs to unified diffs.
START and END are either taken from the region
(when it is highlighted) or else cover the whole buffer.
With a prefix argument, convert unified format to context format.

(fn START END &optional TO-CONTEXT)
(defalias 'diff-context->unified #[770 "\211\203	\304\"\207\305!\204\306\307\"\262\307\212b\210\310\311\312\307#\205|
`W\205|
\313\216\307\314\224\203E\315\316\307\211\312\317%\210\315\320\307\211\312\314%\210\202x
\321\322!\321\323!\324\224\n\325!\326\225?\315\327!\210\310\312\307#\204e\330\331!\210\321\332!\321\314!\333 \210`\332y\210`|\210\334 b\210\332y\210`
W\203
\312f\211\335\267\202\375\336\314!\210\337c\210\332y\266\202~\332u\210\336\332!\210\332y\266\202~\212
b\210\332y\210`)f\211\340\267\202\357\341\314\\{|\210\261\266\202~
Z\342\314!`ZU\204\331\312\262|\210\336\332!\210\332y\266\202~\332y\266\202~\312\262\336\332!\210\332y\266\202~\312\262\332y\266\202~\343\344!\203+
\312f\345U\204
\332u\210\202!
\336\332!\210\341c\210\336\332!\210\332y\210\202
\212b\210\346	\347\350\351\f!\351!ZT!\352\347\350\351\n!\351\f!ZT!\353\261	\210)\211\312\211\223\210\203v
\n\307=\204v
\354\fZ`\304`\257B\266	*\202*\207" [inhibit-read-only combine-after-change-calls buffer-undo-list diff-context-mid-hunk-header-re diff-unified->context markerp copy-marker t re-search-forward "^\\(\\(\\*\\*\\*\\) .+\n\\(---\\) .+\\|\\*\\{15\\}.*\n\\*\\*\\* \\([0-9]+\\),\\(-?[0-9]+\\) \\*\\*\\*\\*\\)\\(?: \\(.*\\)\\|$\\)" nil #[0 "\300 \207" [combine-after-change-execute] 1] 2 replace-match "+++" 3 "---" match-string 4 5 0 marker-position 6 "" error "Can't find matching `--- n1,n2 ----' line" 1 beginning-of-line point-marker #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (33 140 45 154 32 168)) delete-char "-" #s(hash-table size 4 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (43 185 33 185 32 202 92 232)) "+" line-beginning-position looking-at "[+! ] " 33 "@@ -" "," number-to-string string-to-number " +" " @@" apply] 23 (#$ . 36728) (byte-code "\301 \203\f\302 \303 E\207edE\207" [current-prefix-arg use-region-p region-beginning region-end] 3)])
#@159 Reverse the direction of the diffs.
START and END are either taken from the region (if a prefix arg is given) or
else cover the whole buffer.

(fn START END)
(defalias 'diff-reverse-direction #[514 "\304
!\204\f\305
\306\"\262
\306\212
b\210\307\310\311\306#\205@
`
W\205@
\312\216\306\313\224\2031\314\315\311\"\210\202<
\316\224\203\306\316\224\317\316!\314\320\311\211\211\316%\210\321y\210`\322\323!\203a\311f\324U\203[\325\321!\210\326c\210\321y\210\202G\327
`\"\322\n!\204r\211c\210\330\331!\210\313\225\206y\321\225\321\224
{
b\210c\210\321\224|\210\321y\210`\322\332!\203\246\311f\333U\203\240\325\321!\210\334c\210\321y\210\202\214\327
`\"\206\257\320c\210b\210\211\206\271\320c\266b\210\211c\266\202<
\335\224\203<
\314\336\311\"\210\321y\210\311f\311\211\311f\211\262\211\337\267\202\n
\206\347`\262\325\321!\210\326c\210\306\202/

\206\371`\262\325\321!\210\334c\210\306\202/
\306\202/
\203

\203
W\203
\327\"c\210\311\262\311\262\203-
\340\202.
\341>\262
\203:
\321y\210\202\327\266*\202*\207" [inhibit-read-only combine-after-change-calls diff-context-mid-hunk-header-re diff-valid-unified-empty-line markerp copy-marker t re-search-forward "^\\(\\([-*][-*][-*] \\)\\(.+\\)\n\\([-+][-+][-+] \\)\\(.+\\)\\|\\*\\{15\\}.*\n\\*\\*\\* \\(.+\\) \\*\\*\\*\\*\\|@@ -\\([0-9,]+\\) \\+\\([0-9,]+\\) @@.*\\)$" nil #[0 "\300 \207" [combine-after-change-execute] 1] 2 replace-match "\\2\\5\n\\4\\3" 6 match-string "" 1 looking-at "[-! \\][ 	]\\|#" 45 delete-char "+" delete-and-extract-region error "Can't find matching `--- n1,n2 ----' line" "[!+ \\][ 	]\\|#" 43 "-" 7 "@@ -\\8 +\\7 @@" #s(hash-table size 4 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (45 226 43 244 35 262 92 262)) (32 10) (32)] 12 (#$ . 38959) (byte-code "\204	\301 \203\302 \303 D\207edD\207" [current-prefix-arg use-region-p region-beginning region-end] 2)])
#@181 Fixup the hunk headers (in case the buffer was modified).
START and END are either taken from the region (if a prefix arg is given) or
else cover the whole buffer.

(fn START END)
(defalias 'diff-fixup-modifs #[514 "\305\212\211b\210\306\307\310\"\210\311\211\211\211\312y\311U\205d
`X\205d
\313	\314P!\204\216\307f\211\315\267\202WT\262\210\202T\262\210\202\n\316=\203H\313\317!\204\212T\262\210\202
T\266\202\202\211\320>\204\212\211\321=\203~\203oT\262\210\202\311\262\311\262\311\262\266\311\202\311\262\311\262\311\262\311\262\210\202\313	!\203\350\322\323!\322\324!\325\\!\325\\!\203\273\211\230\204\304\326
\305\211\307\324%\210\202\304\327\225b\210\330
\261\210\203\332
\230\204\343\326\305\211\307\323%\266\202U
\331\225b\210\330\261\210\266\202U
\313\f!\203


\\\\\311V\203U
\322\331!\322\323!\325\332	\312\333!%!\211\230\204
\326
\305\211\307\323%\210\266\202U
\313\334!\203U


\\\\\311V\203U
\322\331!\335\336\325G!\337Q\332\312\333!%\"\211\230\204S
\326
\305\211\307\323%\210\266\311\262\311\262\311\262\311\262
\202\266\204*\207" [inhibit-read-only diff-hunk-header-re-unified diff-buffer-type diff-valid-unified-empty-line diff-context-mid-hunk-header-re t diff-end-of-hunk nil donttrustheader 0 -1 looking-at "\\|[-*][-*][-*] [0-9,]+ [-*][-*][-*][-*]$\\|--- .+\n\\+\\+\\+ " #s(hash-table size 4 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (32 44 43 52 45 60 33 80)) git "^-- $" (35 92) 10 match-string 2 4 number-to-string replace-match 3 "," 1 + string-to-number "\\*\\*\\* \\([0-9]+\\),\\(-?[0-9]*\\) \\*\\*\\*\\*$" format "%0" "d"] 16 (#$ . 40866) (byte-code "\204	\301 \203\302 \303 D\207edD\207" [current-prefix-arg use-region-p region-beginning region-end] 2)])
#@34 Fixup hunk headers if necessary.
(defalias 'diff-write-contents-hooks #[0 "\300 \203\n\301ed\"\210\302\207" [buffer-modified-p diff-fixup-modifs nil] 3 (#$ . 42667)])
(defvar diff-unhandled-changes nil)
#@120 Remember to fixup the hunk header.
See `after-change-functions' for the meaning of BEG, END and LEN.

(fn BEG END LEN)
(defalias 'diff-after-change-function #[771 "?\205	?\205\n\203\n@^\nA]B\211\207B\211\207" [undo-in-progress inhibit-read-only diff-unhandled-changes] 6 (#$ . 42878)])
#@34 Fixup hunk headers if necessary.
(defalias 'diff-post-command-hook #[0 ":\205w\3021u\212@b\210n\203o\204\303u\210\304\305!\210\306\307!\205$\310\311
\310=\203/\312\2020\313!
\310=\205>\212\314	\315\305#)@Y\203m\211\203YA\316\224W\204Y@\316\225V\203m\212\317\315\320\"\210`AY)\203m\321`A\"\210\266)\315\2110\207\210\315\207" [diff-unhandled-changes diff-context-mid-hunk-header-re (error) -1 diff-beginning-of-hunk t looking-at "\\*\\*\\*" context line-beginning-position 3 2 re-search-forward nil 0 diff-end-of-hunk donttrustheader diff-fixup-modifs] 6 (#$ . 43183)])
#@18 

(fn ARG RESET)
(defalias 'diff-next-error #[514 "\300p!\210\211\203eb\210\301!\210\302 \207" [pop-to-buffer diff-hunk-next diff-goto-source] 4 (#$ . 43782)])
(defalias 'diff--font-lock-cleanup #[0 "\302\303\211\304\305$\210\302\303\211\304\306$\210\205#\307\301!\210\310	>\203	\207\310	B\211\207" [font-lock-mode font-lock-extra-managed-props remove-overlays nil diff-mode fine syntax make-local-variable display] 5])
(defvar diff-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [diff-mode-hook variable-documentation put "Hook run after entering Diff mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp diff-mode-map definition-name diff-mode] 4)
(defvar diff-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204\303\301\302\304\305!#\210\306\307!\204\303\307\310\311#\210\312\313 !\210\307\302N\204-\303\307\302\304\314!#\210\306\300!\204B\303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P\303\300\302\304\320!#\210\303\311\321\317#\207" [diff-mode-abbrev-table diff-mode-map variable-documentation put purecopy "Keymap for `diff-mode'." boundp diff-mode-syntax-table definition-name diff-mode (lambda (#1=#:def-tmp-var) (defvar diff-mode-syntax-table #1#)) make-syntax-table "Syntax table for `diff-mode'." (lambda (#1#) (defvar diff-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `diff-mode'." derived-mode-parent] 5)
#@625 Major mode for viewing/editing context diffs.
Supports unified and context diffs as well as (to a lesser extent)
normal diffs.

When the buffer is read-only, the ESC prefix is not necessary.
If you edit the buffer manually, `diff-mode' will try to update the hunk
headers for you on-the-fly.

You can also switch between context diff and unified diff with \[diff-context->unified],
or vice versa with \[diff-unified->context] and you can also reverse the direction of
a diff with \[diff-reverse-direction].

\{diff-mode-map}

This mode runs the hook `diff-mode-hook', as the final or penultimate
step during initialization.
(defalias 'diff-mode #[0 "\306\300!\210\307\310 \210\311\312\313!\210\314\f!\210
9\306\315!\210:
\316\317\320\321\322$\210\306\323!\210;\306\324!\210<\306\325!\210\326\306\327!\210\330\306\331!\210\332\333 \210=\203W\307#>\204f\316\334\335\321\307$\210\202x\306\336!\210\316\337\340\321\307$\210\316\341\342\321\307$\210\343?B\344\345\"\210\316\346\347\350\"\321\307$\266\306\351!\210\352)\306\353!\210\354+\355\356\357\360B\361\321$\210@\204\253\362 \210\212\306\363!\210\364\365\321\307#\205\271\3663*\367\370!\207" [delay-mode-hooks major-mode mode-name diff-mode-map diff-mode-syntax-table diff-mode-abbrev-table make-local-variable t kill-all-local-variables diff-mode "Diff" use-local-map set-syntax-table font-lock-defaults add-hook font-lock-mode-hook diff--font-lock-cleanup nil local outline-regexp imenu-generic-expression next-error-function diff-next-error beginning-of-defun-function diff-beginning-of-file-and-junk end-of-defun-function diff-end-of-file diff-setup-whitespace write-contents-functions diff-write-contents-hooks diff-unhandled-changes after-change-functions diff-after-change-function post-command-hook diff-post-command-hook buffer-read-only add-to-list minor-mode-overriding-map-alist view-mode-hook make-closure #[0 "\302\300	\"\211\207" [V0 minor-mode-overriding-map-alist delq] 3] add-log-current-defun-function diff-current-defun add-log-buffer-file-name-function #[0 "\300\301\302\"\207" [diff-find-file-name nil noprompt] 3] advice--add-function :filter-return #[0 "\300\301!\207" [advice--buffer-local filter-buffer-substring-function] 2] #[257 "\300\301\"\207" [advice--set-buffer-local filter-buffer-substring-function] 4 "\n\n(fn GV--VAL)"] diff--filter-substring hack-dir-local-variables-non-file-buffer diff-buffer-type re-search-forward "^diff --git" git run-mode-hooks diff-mode-hook local-abbrev-table diff-font-lock-defaults diff-outline-regexp diff-imenu-generic-expression diff-default-read-only diff-update-on-the-fly diff-mode-shared-map buffer-file-name] 6 (#$ . 45315) nil])
#@99 Non-nil if Diff minor mode is enabled.
Use the command `diff-minor-mode' to change this variable.
(defvar diff-minor-mode nil (#$ . 48011))
(make-variable-buffer-local 'diff-minor-mode)
#@604 Toggle Diff minor mode.

This is a minor mode.  If called interactively, toggle the `Diff minor
mode' mode.  If the prefix argument is positive, enable the mode, and
if it is zero or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable the
mode if ARG is nil, omitted, or is a positive number.  Disable the
mode if ARG is a negative number.

To check whether the minor mode is enabled in the current buffer,
evaluate `diff-minor-mode'.

The mode's hook is called both when the mode is enabled and when it is
disabled.

\{diff-minor-mode-map}

(fn &optional ARG)
(defalias 'diff-minor-mode #[256 "\303 
\304=\203
?\202
\247\203
\305W\203\306\202\307\310\301!\2031\311\300	\"\2031\300	B\n\204?\312\313\314\306\307$\210\202Q\315\316!\210\312\317\320\306\307$\210\312\321\322\306\307$\210\323\324\203[\325\202\\\326\"\210\327\330!\203~\303 \203p\211\303 \232\203~\331\332\203z\333\202{\334\335#\210\210\336 \210\207" [diff-minor-mode local-minor-modes diff-update-on-the-fly current-message toggle 1 nil t boundp delq add-hook write-contents-functions diff-write-contents-hooks make-local-variable diff-unhandled-changes after-change-functions diff-after-change-function post-command-hook diff-post-command-hook run-hooks diff-minor-mode-hook diff-minor-mode-on-hook diff-minor-mode-off-hook called-interactively-p any message "Diff minor mode %sabled%s" "en" "dis" " in current buffer" force-mode-line-update] 7 (#$ . 48204) (byte-code "\203\n\301!\202\302C\207" [current-prefix-arg prefix-numeric-value toggle] 2)])
(defvar diff-minor-mode-hook nil)
(byte-code "\301\302N\204\f\303\301\302\304#\210\303\301\305\306#\210\303\301\307\310C#\210\311\312\313\314\300!\205#\310\211%\207" [diff-minor-mode-map diff-minor-mode-hook variable-documentation put "Hook run after entering or leaving `diff-minor-mode'.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" custom-type hook standard-value nil add-minor-mode diff-minor-mode " Diff" boundp] 6)
#@224 Set up Whitespace mode variables for the current Diff mode buffer.
This sets `whitespace-style' and `whitespace-trailing-regexp' so
that Whitespace mode shows trailing whitespace problems on the
modified lines of the diff.
(defalias 'diff-setup-whitespace #[0 "\303\300!\210\304\212eb\210\305	\306\307#\205\310\224b\210\311 )\303\302!\210\211\312=\203'\313\202(\314\211\207" [whitespace-style diff-hunk-header-re whitespace-trailing-regexp make-local-variable (face trailing) re-search-forward nil t 0 diff-hunk-style context "^[-+!] .*?\\([	 ]+\\)$" "^[-+!<>].*?\\([	 ]+\\)$"] 4 (#$ . 50306)])
(defalias 'diff-delete-if-empty #[0 "\205\301!\302
8\262
\303=\205\304!\207" [buffer-file-name file-attributes 7 0 delete-file] 3])
#@45 Arrange for empty diff files to be removed.
(defalias 'diff-delete-empty-files #[0 "\300\301\302\303\304$\207" [add-hook after-save-hook diff-delete-if-empty nil t] 5 (#$ . 51052)])
#@54 Turn context diffs into unified diffs if applicable.
(defalias 'diff-make-unified #[0 "\212eb\210\301!\205\302f\303=)\205 \304 \305\306\"\216\307ed\")\262
\207" [diff-hunk-header-re looking-at nil 42 buffer-modified-p make-closure #[0 "\301\300!\207" [V0 restore-buffer-modified-p] 2] diff-context->unified] 4 (#$ . 51240)])
#@133 Jump to the next "complex" hunk.
"Complex" is approximated by "the hunk changes the number of lines".
Only works for unified diffs.
(defalias 'diff-next-complex-hunk #[0 "\301\302\303#\205\304\305!\304\306!\232\205\202\207" [diff-hunk-header-re-unified re-search-forward nil t match-string 2 4] 4 (#$ . 51577) nil])
#@14 

(fn LINES)
(defalias 'diff-sanity-check-context-hunk-half #[257 "\211\300f\301>\203`Tf\302>\203\211S\262
\202\211\303U\204#\211U\203%\300\207\300f\304>\203L`Tf\305=\203:\306\307!\204@\310\311!\202|\312u\210\313c\210\314y\210\202
\303W\203X\310\311!\202|\306\315!\204d\310\316!\202|l\203q\317c\210\314y\210\202\313c\210`\320Z`S|\210\321\205\205\300y\210\202
\207" [nil (32 33 43 45) (32 9) 0 (33 43 45) 10 y-or-n-p "Try to auto-fix whitespace loss damage? " error "End of hunk ambiguously marked" 1 " " -1 "Try to auto-fix whitespace loss and word-wrap damage? " "Abort!" "  " 2 t] 4 (#$ . 51906)])
(defalias 'diff-sanity-check-hunk #[0 "\306\212\307	!\204\310\311!\202z
\312f\313=\203f\307\314!\204\"\310\315!\202z
\316y\210\317\316\225\203:\320\321\316!!\320\321\322!!ZT\202;\322!\210\307\n!\204I\310\323!\202z
\312y\210\317\316\225\203a\320\321\316!!\320\321\322!!ZT\202b\322!\202z
\312f\324=\203y
\307!\204y\310\325!\202z
\320\321\316!\206\201\326!\320\321\327!\206\212\326!\312y\210\312f\211\330\267\202\343S\262
S\262\306\202i
\307\f!\203\270\331U\203\270
\331U\203\270\312\202i
\307
!\203\323\331U\203\323
\331U\203\323\212\332c\210)\312\202i
S\262\306\202i

S\262\306\202i
&\203
\312f\333=\203
\331V\203

\331V\203
S\262
S\262\306\202i
\331U\203

\331U\203
\312\202i
\331W\204#

\331W\2039
\310\331U\2040
\331U\2034
\334\2025
\335!\202i
\336\337l\203C
\340\202D
\341\342Q!\204P
\310\343!\202i
l\203^
\344c\210\345y\210\306\202i
\344c\210`\316Z`S|\210\306\262
\205t
\312y\210\202\216\266\202\202z
\306*\207" [inhibit-read-only diff-hunk-header-re diff-context-mid-hunk-header-re diff-hunk-header-re-unified diff-separator-re diff-file-header-re t looking-at error "Not recognizable hunk header" nil 42 "\\*\\{15\\}\\(?: .*\\)?\n\\*\\*\\* \\([0-9]+\\)\\(?:,\\([0-9]+\\)\\)? \\*\\*\\*\\*" "Unrecognized context diff first hunk header format" 2 diff-sanity-check-context-hunk-half string-to-number match-string 1 "Unrecognized context diff second hunk header format" 64 "Unrecognized unified diff hunk header format" "1" 4 #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (32 150 45 162 43 219)) 0 "\n" 10 "End of hunk ambiguously marked" "Hunk seriously messed up" y-or-n-p "Try to auto-fix " "whitespace loss" "word-wrap damage" "? " "Abort!" " " -1 diff-valid-unified-empty-line] 7])
#@251 Return the literal source text from HUNK as (TEXT . OFFSET).
If DESTP is nil, TEXT is the source, otherwise the destination text.
CHAR-OFFSET is a char-offset in HUNK, and OFFSET is the corresponding
char-offset in TEXT.

(fn HUNK DESTP CHAR-OFFSET)
(defalias 'diff-hunk-text #[771 "\301\302\303\"r\211q\210\304\305\"\216c\210eb\210\306\211\211\307\310\311!\203,\312\262
\312y\210`\262`\262\202\220\310\313!\203M\307y\210`\262\314\306\303#\210\315y\210`\262\312y\210`\262\202\220\310\316!\203\\\312y\210`\262\202\220\310\317!\203k\312y\210`\262\202\220\310\320!\203\214\312y\210`\262\314\321\306\303#\210\315y\210`\262\312y\210`\262\202\220\322\323!\210\203\232?\202\234?\203\257\203\251\266\324\202m
\266\325\202m
\232\203\273\262\202\304d\232\203\304\262\203\316e\\b\210\212\203\330\202\331\203\347
V\203\347d|\210e
|\266\203\365\326\202\366\327\330D\306\211eb\210m\204T
\306f\262
>\203G

\330=\203=
\211\n\203
\326\202
\327=\204=
\212\312y\210m\2062
\211\326=\2052
\306f\327=)\203=
`Se]\202>
`\312y\210`|\210\202N
\331!\210\312y\210
\262
\202\375\266)\332ed\"\203h
\211`eZB\202i
\211\262
\266\204*\207" [diff-context-mid-hunk-header-re generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205	\302\300!\207" [V0 buffer-name kill-buffer] 2] nil 2 looking-at "^@@" 1 "^\\*\\*" re-search-forward 0 "^[0-9]+a[0-9,]+$" "^[0-9,]+d[0-9]+$" "^[0-9,]+c[0-9,]+$" "^---$" error "Unknown diff hunk type" (#1="" . 0) #1# 45 43 92 delete-char buffer-substring-no-properties] 13 (#$ . 54310)])
#@124 Return the buffer position (BEG . END) of the nearest occurrence of TEXT.
If TEXT isn't found, nil is returned.

(fn TEXT)
(defalias 'diff-find-text #[257 "`\300\301\302#\205\303\224\303\225B
G\\b\205#\304\301\302#\205#\303\224\303\225B
\203:\211\203:
@Z@ZV\2038\207
\207\211\206?
\207" [search-forward nil t 0 search-backward] 7 (#$ . 55881)])
#@122 Return the buffer position (BEG . END) of the nearest occurrence of TEXT.
Whitespace differences are ignored.

(fn TEXT)
(defalias 'diff-find-approx-text #[257 "`\300\301\302\303!\304#\305Q\306
\307\310#\205\311\224\311\225BG\\b\205-\312\307\310#\205-\311\224\311\225B
\203D\211\203D
@Z@ZV\203B\207
\207\211\206I
\207" ["^[ 	\n\f]*" mapconcat regexp-quote split-string "[ 	\n\f]+" "[ 	\n\f]*\n" re-search-forward nil t 0 re-search-backward] 8 (#$ . 56247)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias diff-xor xor nil make-obsolete "27.1"] 4)
#@1031 Find current diff location within the source file.
OTHER-FILE, if non-nil, means to look at the diff's name and line
  numbers for the old file.  Furthermore, use `diff-vc-revisions'
  if it's available.  If `diff-jump-to-old-file' is non-nil, the
  sense of this parameter is reversed.  If the prefix argument is
  8 or more, `diff-jump-to-old-file' is set to OTHER-FILE.
REVERSE, if non-nil, switches the sense of SRC and DST (see below).
NOPROMPT, if non-nil, means not to prompt the user.
Return a list (BUF LINE-OFFSET (BEG . END) SRC DST SWITCHED).
BUF is the buffer corresponding to the source file.
LINE-OFFSET is the offset between the expected and actual positions
  of the text of the hunk or nil if the text was not found.
(BEG . END) is a pair indicating the position of the text in the buffer.
SRC and DST are the two variants of text as returned by `diff-hunk-text'.
  SRC is the variant that was found in the buffer.
SWITCHED is non-nil if the patch is already applied.

(fn &optional OTHER-FILE REVERSE NOPROMPT)
(defalias 'diff-find-source-location #[768 "\212
\204\f\262
\202\211?\205
\266\202`\305\306!Z\204 \307 \210\310`\212\311 \210`){\312
#\312?#\313\314!\204C\315\316!\202g\203M\317\320!\202g\321\225\203X\317\321!\202g\322	\310\306#\204d\315\323!\210\317\320!\324	\"\206s\315\325!\205\217\n\205\217	\203\207A@\202\217@\206\217\326
!\211\203\240\306\327\330!\n#)\202\245\331\"\332
!\333V\203\261	r\211q\210eb\210\334!Sy\210`\310\335@!\206
\306\262
\335@!\206
\310\262
\3361\343\337@!0\202\347\210\202\352\206
\306\262
\3401\372\337@!0\202\376\210\202

\206
\310\262
\310C
\203
\341@\"D\202
\310\211\f@G\\BD\244\203-
\n\306E\2022
		D\244\266\203)\266\212)\207" [diff-jump-to-old-file diff-context-mid-hunk-header-re diff-vc-backend diff-vc-revisions vc-find-revision-no-save diff-beginning-of-hunk t diff-sanity-check-hunk nil diff-end-of-hunk diff-hunk-text looking-at "\\(?:\\*\\{15\\}.*\n\\)?[-@* ]*\\([0-9,]+\\)\\([ acd+]+\\([0-9,]+\\)\\)?" error "Can't find the hunk header" match-string 1 3 re-search-forward "Can't find the hunk separator" diff-find-file-name "Can't find the file" vc-working-revision vc-find-revision expand-file-name find-file-noselect prefix-numeric-value 8 string-to-number diff-find-text (invalid-regexp) diff-find-approx-text (invalid-regexp) count-lines] 21 (#$ . 56836)])
#@37 

(fn LINE-OFFSET REVERSED DRY-RUN)
(defalias 'diff-hunk-status-msg #[771 "\211\203
\203\f\300\202\301\202
\203\302\202\303\304\204\"\305\2027\306U\203,\307\2027\310U\2036\311\2027\312#\207" ["already applied" "not yet applied" "undone" "applied" message "Hunk text not found" 0 "Hunk %s" 1 "Hunk %s at offset %d line" "Hunk %s at offset %d lines"] 8 (#$ . 59253)])
(defvar diff-apply-hunk-to-backup-file nil)
#@399 Apply the current hunk to the source file and go to the next.
By default, the new source file is patched, but if the variable
`diff-jump-to-old-file' is non-nil, then the old source file is
patched instead (some commands, such as `diff-goto-source' can change
the value of this variable when given an appropriate prefix argument).

With a prefix argument, REVERSE the hunk.

(fn &optional REVERSE)
(defalias 'diff-apply-hunk #[256 "\303\304!\210\305\306\"\211\242
\243\211\242
\243\211\242
\243\211\242
\243\211\242
\243\211\242
\243	\204)\307\310!\207rq\210\205L\311!\205L	?\205L\312\301!\210\313\314\315\316!\"!\211?)\203`\307\317\320\314\321?\205\\\322\"!\"\207
\203\217\323 \324\325\"\216\326
!\210@A\\b\210\327\203\203\330\202\204\331!)\262
\204\217\332\333!\207rq\210@b\210@A|\210@c\210)\334\335
!	@A\\\"\210\336\n
\204\303\262
\202\313\211?\205\311
\266\202\306#\210\n\205\324\337 \207" [buffer-file-name diff-apply-hunk-to-backup-file diff-advance-after-apply-hunk diff-beginning-of-hunk t diff-find-source-location nil error "Can't find the text to patch" backup-file-name-p make-local-variable yes-or-no-p format "Really apply this hunk to %s? " file-name-nondirectory "%s" substitute-command-keys "Use %s\\[diff-apply-hunk] to apply it to the other file" "\\[universal-argument] " current-window-configuration make-closure #[0 "\301\300!\207" [V0 set-window-configuration] 2] pop-to-buffer y-or-n-p "Hunk hasn't been applied yet; apply it now? " "Hunk has already been applied; undo it? " message "(Nothing done)" set-window-point display-buffer diff-hunk-status-msg diff-hunk-next] 20 (#$ . 59693) "P"])
#@127 See whether it's possible to apply the current hunk.
With a prefix argument, try to REVERSE the hunk.

(fn &optional REVERSE)
(defalias 'diff-test-hunk #[256 "\300\301\"\211\242
\243\211\242
\243\211\242
\243\211\242
\243\211\242
\243\211\242
\243\301\302\303!\n@	A\\\"\210\304
\204:\262
\202B\211?\205@
\266\202\305#\207" [diff-find-source-location nil set-window-point display-buffer diff-hunk-status-msg t] 20 (#$ . 61365) "P"])
#@66 Kill all hunks that have already been applied starting at point.
(defalias 'diff-kill-applied-hunks #[0 "m?\205<\300\301\211\"\211\242
\243\211\242
\243\211\242
\243\211\242
\243\211\242
\243\211\242
\243\301\211\211\211
\2035\2035\302 \266\202\303 \266\202\207" [diff-find-source-location nil diff-hunk-kill diff-hunk-next] 18 (#$ . 61816) nil])
(defalias 'diff-mouse-goto-source 'diff-goto-source)
#@549 Jump to the corresponding source line.
`diff-jump-to-old-file' (or its opposite if the OTHER-FILE prefix arg
is given) determines whether to jump to the old or the new file.
If the prefix arg is bigger than 8 (for example with \[universal-argument] \[universal-argument])
then `diff-jump-to-old-file' is also set, for the next invocations.

Under version control, the OTHER-FILE prefix arg means jump to the old
revision of the file if point is on an old changed line, or to the new
revision of the file otherwise.

(fn &optional OTHER-FILE EVENT)
(defalias 'diff-goto-source #[512 "\211\203\n\300\301!!\210\211\205p\212\302 \210\303\304!)?\305\"\211\242
\243\211\242
\243\211\242
\243\211\242
\243\211\242
\243\211\242
\243\306\211\211\307!\210\n@	A\\b\210\205O\310p\"\207" [posn-set-point event-end beginning-of-line looking-at "[-<]" diff-find-source-location nil pop-to-buffer next-error-found] 23 (#$ . 62234) (list current-prefix-arg last-input-event)])
#@82 Find the name of function at point.
For use in `add-log-current-defun-function'.
(defalias 'diff-current-defun #[0 "\301\302!\210\212\303!\203\304y\210\305\306\307\310#\210\3111!\312\307\211\313#0\202#\210\307\211\242
\243\211\242
\243\211\242
\243\211\242
\243\211\242
\243\211\242
\243\307\f\205\216\314 \210\307f\315>\203}\203S\202U\316\317\310\"r\211q\210\320\321\"\216
@c\210\322\323\" \210eA\\b\210\324 *\262
\262
\206\216r\fq\210@A\\b\210\324 )\262
\266\214\262
)\207" [diff-hunk-header-re kill-local-variable change-log-default-name looking-at 1 re-search-forward "^[^ ]" nil t (error) diff-find-source-location noprompt beginning-of-line (60 45) generate-new-buffer " *temp*" make-closure #[0 "\301\300!\205	\302\300!\207" [V0 buffer-name kill-buffer] 2] buffer-local-value major-mode add-log-current-defun] 19 (#$ . 63215)])
#@60 Re-diff the current hunk, ignoring whitespace differences.
(defalias 'diff-ignore-whitespace-hunk #[0 "\300\301!\207" [diff-refresh-hunk t] 2 (#$ . 64081) nil])
#@61 Re-diff the current hunk.

(fn &optional IGNORE-WHITESPACE)
(defalias 'diff-refresh-hunk #[256 "`\305\306!Z\307f\211\310\267\202\311\202\312\202\307\262
\313\314!\204$\315\316!\205)\317\320\321!!\306\322`\212\323 \210`)\"C\324S\325\"\326\327!\326\330!	\307\211\211\n\203M\331\262\203XB\262\332\333$\216\212\334\242\307\f#\262\334\242\306\f#\262
\335@P\307\307\336%\210\335@P\307\307\336%\210\337\340\306\"r\211q\210\332\341\"\216\342\343\307\306\307\344\n

D\"BBBB\"\211\345=\204\340\211\321=\203\321eb\210\346\f\307\306#\203\340e\345\224|\210\202\340db\210n\204\333\347c\210\242c\210\350 \240\210\211\351>?\205\361\315\352\"\262
*\262
,\207" [inhibit-read-only buffer-file-coding-system coding-system-for-read diff-command diff-hunk-header-re diff-beginning-of-hunk t nil #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (64 13 42 17)) "-u" "-c" looking-at "[^0-9]+\\([0-9]+\\)" error "Can't find line number" string-to-number match-string 1 delete-and-extract-region diff-end-of-hunk make-string 10 make-temp-file "diff1" "diff2" ("-b") make-closure #[0 "\300\242c\210\303\301!\210\303\302!\207" [V0 V1 V2 delete-file] 2] diff-hunk-text write-region nomessage generate-new-buffer " *temp*" #[0 "\301\300!\205	\302\300!\207" [V0 buffer-name kill-buffer] 2] apply call-process append 0 re-search-forward "\n" buffer-string (0 1) "Diff returned: %s"] 22 (#$ . 64248) nil])
(byte-code "\300\301\302\303#\210\300\304\305\306\307\310%\210\300\311\312\313\307\310%\207" [custom-declare-face diff-refine-changed ((((class color) (min-colors 88) (background light)) :background "#ffff55") (((class color) (min-colors 88) (background dark)) :background "#aaaa22") (t :inverse-video t)) "Face used for char-based changes shown by `diff-refine-hunk'." diff-refine-removed ((default :inherit diff-refine-changed) (((class color) (min-colors 257) (background light)) :background "#ffcccc") (((class color) (min-colors 88) (background light)) :background "#ffbbbb") (((class color) (min-colors 88) (background dark)) :background "#aa2222")) "Face used for removed characters shown by `diff-refine-hunk'." :version "24.3" diff-refine-added ((default :inherit diff-refine-changed) (((class color) (min-colors 257) (background light)) :background "#bbffbb") (((class color) (min-colors 88) (background light)) :background "#aaffaa") (((class color) (min-colors 88) (background dark)) :background "#22aa22")) "Face used for added characters shown by `diff-refine-hunk'."] 6)
(defalias 'diff-refine-preproc #[0 "\300\301\302\303#\205\304`Sf\305\236A!\210\202\207" [re-search-forward "^[+>]" nil t replace-match ((43 . "-") (62 . "<"))] 4])
#@110 Move point until reaching a line not starting with CHAR.
Return new point, if it was moved.

(fn CHAR BOUND)
(defalias 'diff--forward-while-leading-char #[514 "\300`W\203\301g\"\203\302y\210`\262
\202
\207" [nil eql 1] 6 (#$ . 66978)])
#@60 Highlight changes of hunk at point at a finer granularity.
(defalias 'diff-refine-hunk #[0 "\300 \205\212\301\302!\303 \210`\304\"\266\202)\207" [diff--some-hunks-p diff-beginning-of-hunk t diff-end-of-hunk diff--refine-hunk] 5 (#$ . 67227) nil])
#@18 

(fn START END)
(defalias 'diff--refine-hunk #[514 "\301\302!\210
b\210\303 `\304\305\306\307\310\311$\210b\210\312\267\202\263\313\314\315#\205\320\316 \210`\317\211\320\321\n\"\203e\320\322\n\"\210`\211\262\203e\320\323\n\"\203e\320\322\n\"\210`\211\262\203e\324\211\317\325&\210\266\202\207\212\313\326\315#)\211
\205\262\313\327\315#\205\262\324\330\224\330\225\212b\210\313\327\f\"\210\330\225\262\330\224)\205\235	\325?\205\245\n?\205\254\n&\210\202t\207`T\313\331\315#\205\316\324
\330\224\330\225\n\317\325		&\262
\207" [diff-use-changed-face require smerge-mode diff-hunk-style ((diff-mode . fine) (face . diff-refine-changed)) ((diff-mode . fine) (face . diff-refine-removed)) ((diff-mode . fine) (face . diff-refine-added)) remove-overlays diff-mode fine #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (unified 30 context 107)) re-search-forward "^-" t beginning-of-line nil diff--forward-while-leading-char 45 92 43 smerge-refine-regions diff-refine-preproc "^---" "^\\(?:!.*\n\\)+" 0 "^---.*\n"] 19 (#$ . 67484)])
#@113 Iterate over all hunks between point and MAX.
Call FUN with two args (BEG and END) for each hunk.

(fn MAX FUN)
(defalias 'diff--iterate-hunks #[514 "\212\3011\302 0\202\210\202\206&\3031\304 \210`0\202\"\210\202%\206&
\211W\205v\211b\210\305!\2049\306\307!\210\212\310 \210`)

W\204I\306\311!\210\"\210\211b\210\305!\203]\211\266\202\202&\3121i\304 \210`0\202m\210\202p\206q\266\202\202&\262
)\207" [diff-hunk-header-re (error) diff-beginning-of-hunk (error) diff-hunk-next looking-at cl--assertion-failed (looking-at diff-hunk-header-re) diff-end-of-hunk (< beg end) (error)] 7 (#$ . 68614)])
#@49 Apply hunk refinement from font-lock.

(fn MAX)
(defalias 'diff--font-lock-refined #[257 "\301=\205!\302`\303\"\203\304`\303\305$b\210\3061\307
\310\"0\207\210\305\207" [diff-refine font-lock get-char-property diff--font-lock-refined next-single-char-property-change nil (file-missing) diff--iterate-hunks #[514 "\300\301\"?\205*\302\"\210\303\"\304
\301\305#\210\304
\306\307#\210\304
\310\305#\210\304
\311\312#\262
\207" [get-char-property diff--font-lock-refined diff--refine-hunk make-overlay overlay-put t diff-mode fine evaporate modification-hooks (diff--overlay-auto-delete)] 7 "\n\n(fn BEG END)"]] 6 (#$ . 69244)])
#@39 

(fn OL AFTER BEG END &optional LEN)
(defalias 'diff--overlay-auto-delete #[1284 "\300!\207" [delete-overlay] 7 (#$ . 69888)])
#@77 Perform `undo', ignoring the buffer's read-only status.

(fn &optional ARG)
(defalias 'diff-undo #[256 "\301\302
!)\207" [inhibit-read-only t undo] 3 (#$ . 70023) "P"])
#@175 Return an alist of defun names for the current diff.
The elements of the alist are of the form (FILE . (DEFUN...)),
where DEFUN... is a list of function names found in FILE.
(defalias 'diff-add-log-current-defuns #[0 "\212eb\210\302\211C\302\303\304\302\305#\203\222
\212\306 )\240\210\307\310 !\311C\311C\311C\312	\313\305!@\232?!\211\242
\243\211\242
\243\211\242\211\242
\243\243\211\242\211\242
\243\243\211\242\211\242
\243\243\211\242
\243
\302\302	\302\302C\314\315   
\n		&	\314\316!!!	&\"%\"\211\242
\243\211\242
\243'*\203\236\202\240\"\211\242
\243\211\242
\243,/\203\267\f\202\271
\"\211\242
\243\211\242
\243)\311=\204\33503\235\203\3262\202\33303B\2623\31716\"\204\3560C5B\2625\314\320\"\216\302y\210`4\242W\203\214
\302f\211\321\267\202\"
/\211\242T\240\210\202\"
.\211\242T\240\210\202\"
0\211\242T\240\210r \210 \210	 \210\211\322=\203<
\f \210\302\202P
\f\305!\206P
\211\323=\203M
\202O
 \211\203\206
\31738\324#\211A
\235\203g
\211\202j

B\262

\203x


\241\266\202\207
4
B\211\2629B\2629\266\210)\210\202\364)\2661\202	
\203\237
\325\326\327\330\331#\"\210\211\203\263
\211@\211
A\237\241\210
A\266\202\202\240
\210\237\266\204)\207" [diff-hunk-header-re null-device nil #[514 "\300C\300C\301\302$\301\303%D\207" [nil make-closure #[0 "\301\242\205\300 \205`\301\242Y\205\302\303\240\210\301\303\240\207" [V0 V1 V2 nil] 2] #[256 "\211\203\303\242\207\302\242?\205\301 \205\304 \211\205)\212\3051%\306 \210`0\202(\210\300\242)\211\2054\302
\240\210\303\240\207" [V0 V1 V2 V3 add-log-current-defun (scan-error) end-of-defun] 5 "\n\n(fn &optional GET-CURRENT)"]] 11 "\n\n(fn HUNK-END GOLINE)"] re-search-forward t diff-end-of-hunk substring-no-properties diff-find-file-name 0 diff-find-source-location diff-hunk-file-names make-closure #[0 "\307\242\203\f\307\242q\210\202&\310\311!q\210\306\203\304\202\305c\210\312\313\303\" \210\307p\240\210eb\210\300\242S\306\2035\302\242\2027\301\242\\y\207" [V0 V1 V2 V3 V4 V5 V6 V7 generate-new-buffer " *diff-other-text*" buffer-local-value major-mode] 3] #[0 "\303q\210\304b\210\300\242S\305\203\301\242\202\302\242\\y\207" [V0 V1 V2 V3 V4 V5] 2] assoc #[0 "\301\300\242!\205\302\300\242!\207" [V0 buffer-live-p kill-buffer] 2] #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (43 263 45 273 32 283)) 32 43 equal message "Diff didn't match for %s." mapconcat identity ", "] 59 (#$ . 70200)])
#@136 Iterate through the current diff and create ChangeLog entries.
I.e. like `add-change-log-entry-other-window' but applied to all hunks.
(defalias 'diff-add-change-log-entries-other-window #[0 "\212eb\210\3001$\301 \210\302\303\304\305#\205 \212\306\304\211\305\304\305%\210)\2020\202&\210\304)\207" [(error) diff-hunk-next re-search-forward "\n[!+<>-]\\(-- [0-9]+\\(,[0-9]+\\)? ----\n\\( .*\n\\)*[+]\\)?" nil t add-change-log-entry] 6 (#$ . 72733) nil])
#@432 Remove trailing whitespace from lines modified in this diff.
This edits both the current Diff mode buffer and the patched
source file(s).  If `diff-jump-to-old-file' is non-nil, edit the
original (unpatched) source file instead.  With a prefix argument
OTHER-FILE, flip the choice of which source file to edit.

If a file referenced in the diff has no buffer and needs to be
fixed, visit it in a buffer.

(fn &optional OTHER-FILE)
(defalias 'diff-delete-trailing-whitespace #[256 "\212eb\210\211
\204\262
\202\211?\205
\266\202\304\212\305	\304\306#\205'\307\224b\210\310 )\311\2031\312\2022\313\314\315=\203=\316\202>\317\320\260\306\321 \304\305	\304\322#\210\212\305	\304\322#\210`\262
)`
W\203\376\315=\204k

\304\223\210\202\212\212\305\"\210`)\203\201
\304\223\266\202\212\211b\210\304\223\266\305\306#\203\370\323 \324!\211\242
\243\211\242
\243\211\242
\243\211\242
\243\211\242
\243\211\242
\243\304\211\203\363\325!\210\326\317\306\211\304\322%\210r
q\210\212	@A\\b\210\327 \210\305\330\331 \306#\203\362
>\204\356
B\262\326\317!\210*\266\202\212\211b\210\202L\203
\332\333\334\335\336#\"\202
\332\337!)\266\206)\207" [diff-jump-to-old-file diff-hunk-header-re inhibit-read-only diff-context-mid-hunk-header-re nil re-search-forward t 0 diff-hunk-style "^[" "-<" "+>" "!]" context " " "" ".*?\\([ 	]+\\)$" make-marker 1 match-data diff-find-source-location set-match-data replace-match beginning-of-line "\\([ 	]+\\)$" line-end-position message "Deleted trailing whitespace from %s." mapconcat #[257 "\300\301\302!\"\207" [format-message "`%s'" buffer-name] 5 "\n\n(fn BUF)"] ", " "No trailing whitespace to delete."] 29 (#$ . 73198) "P"])
(byte-code "\300\301\302\303\211\304%\210\300\305\306\303\211\304%\210\300\307\310\303\211\304%\210\300\311\312\303\211\304%\207" [define-fringe-bitmap diff-fringe-add [0 0 16 16 124 16 16 0 0] nil center diff-fringe-del [0 0 0 0 124 0 0 0 0] diff-fringe-rep [0 16 16 16 16 16 0 16 0] diff-fringe-nul [0 0 0 0 0 0 0 0 0]] 6)
#@14 

(fn LIMIT)
(defalias 'diff--font-lock-prettify #[257 "\203j\212\301\302\303#\203 \304`Sf\305\"\306\307\224\307\225\310$\266\202)\301\311\303#\203j\212\307y\210\312\313!)\203!\306\307\224\314\224\206>\315\224\310\316\315\224\204I\317\202S\314\224\204R\320\202S\321\322\323#$\210\314\224\204!\306\315\225\307\225S\310\324$\210\202!\325\207" [diff-font-lock-prettify re-search-forward "^[-+! ]" t alist-get ((43 left-fringe diff-fringe-add diff-indicator-added) (45 left-fringe diff-fringe-del diff-indicator-removed) (33 left-fringe diff-fringe-rep diff-indicator-changed) (32 left-fringe diff-fringe-nul fringe)) put-text-property 0 display "^diff " looking-at "diff.*\n\\(?:\\(?:new file\\|deleted\\).*\n\\)?\\(?:index.*\n\\)?--- \\(?:/dev/null\\|a/\\(.*\\)\\)\n\\+\\+\\+ \\(?:/dev/null\\|b/\\(.*\\)\\)\n" 2 1 propertize "new file  " "deleted   " "modified  " face (diff-file-header diff-header) "" nil] 9 (#$ . 75242)])
#@156 Apply source language syntax highlighting from font-lock.
Calls `diff-syntax-fontify' on every hunk found between point
and the position in MAX.

(fn MAX)
(defalias 'diff--font-lock-syntax #[257 "\205\301`\302\"\203\303`\302\304$b\210\305
\306\"\207" [diff-font-lock-syntax get-char-property diff--font-lock-syntax next-single-char-property-change nil diff--iterate-hunks #[514 "\300\301\"?\205*\302\"\210\303\"\304
\301\305#\210\304
\306\307#\210\304
\310\305#\210\304
\311\312#\262
\207" [get-char-property diff--font-lock-syntax diff-syntax-fontify make-overlay overlay-put t diff-mode syntax evaporate modification-hooks (diff--overlay-auto-delete)] 7 "\n\n(fn BEG END)"]] 6 (#$ . 76190)])
#@82 Highlight source language syntax in diff hunk between BEG and END.

(fn BEG END)
(defalias 'diff-syntax-fontify #[514 "\300\301\302$\210\212\303\304#\210\303\305#)\207" [remove-overlays diff-mode syntax diff-syntax-fontify-hunk t nil] 7 (#$ . 76902)])
(defvar diff--syntax-file-attributes nil nil)
(byte-code "\300\301!\210\302\301\303\304#\207" [make-variable-buffer-local diff--syntax-file-attributes put permanent-local t] 4)
#@147 Highlight source language syntax in diff hunk between BEG and END.
When OLD is non-nil, highlight the hunk from the old source.

(fn BEG END OLD)
(defalias 'diff-syntax-fontify-hunk #[771 "b\210\306\"\307\3101\311?\312#0\202\313\314\"\210\312\262
\206\"\315!\316\317!\205A\2033\320\321!\202A\322\225\203>\320\322!\202A\320\321!\211\205a\323\324\"\203\\\325\320\321\"!\325\320\326\"!D\202a\325
!\321D\203(
	\327=\204(
\330\331\"\211\205v\332
!\211\205\215\204\205\nA@\202\215\n@\206\215\333
!
\205#
\211\204\352?\205#
\334!\205#
\335!\205#
\336!\211\203\275r\211q\210\337\312#)\202\343r\340\341!q\210\342!
\232\203\323\312\262\210\202\333\343 \210\344!\210\337#)\262
\266\203\202%
\345\346#\347
!\211\203\374\312\262\202
\3501

\351\340!$0\202
\210\312\262
\211\205!
r\211q\210\337	#)\266\202\266\203\206\211
\352!@\211\203g
\f\203g
	\327=\204g
\204g
\334
!\203g
\335
!\203g
\353\354\331\"r\211q\210\355\356\"\216\344!\210\337#*\262
\202\207
	\357>\205\207
\353\354\331\"r\211q\210\355\360\"\216c\210\337\331$*\262
\262
b\210\211\205\361 \362=\205\321y\210`W\205\203\252
\363\202\253
\364\331\316
!)\262
\204\230
\203\315
\365\331\316
!)\262
\204\315
\211A\262
\202\230
\211
A\262\242`T
\211\203\211@\366@\\A@\\\312\367\312%\370
\371\372#\210\370
\373\331#\210\370
\374\3268#\266
A\266\202\202\326
\266\202\230
\207" [diff-vc-backend diff-font-lock-syntax diff-vc-revisions diff--syntax-file-attributes diff-default-directory inhibit-changing-match-data buffer-substring-no-properties string-trim-right (debug error) diff-hunk-text nil message "Error: %S" "" looking-at "\\(?:\\*\\{15\\}.*\n\\)?[-@* ]*\\([0-9,]+\\)\\([ acd+]+\\([0-9,]+\\)\\)?" match-string 1 3 string-match "\\([0-9]+\\),\\([0-9]+\\)" string-to-number 2 hunk-only diff-find-file-name t expand-file-name vc-working-revision file-readable-p file-regular-p get-file-buffer diff-syntax-fontify-props get-buffer-create " *diff-syntax-file*" file-attributes erase-buffer insert-file-contents format " *diff-syntax:%s.~%s~*" get-buffer (error) vc-find-revision-no-save diff-hunk-file-names generate-new-buffer " *temp*" make-closure #[0 "\301\300!\205	\302\300!\207" [V0 buffer-name kill-buffer] 2] (hunk-also hunk-only) #[0 "\301\300!\205	\302\300!\207" [V0 buffer-name kill-buffer] 2] diff-hunk-style unified "[+>\\]" "[-<\\]" "[-<]" make-overlay front-advance overlay-put diff-mode syntax evaporate face] 18 (#$ . 77344)])
#@511 Get font-lock properties from the source code.
FILE is the name of the source file.  If non-nil, it requests initialization
of the mode according to FILE.
TEXT is the literal source text from hunk.
LINE-NB is a pair of numbers: start line number and the number of
lines in the hunk.
When HUNK-ONLY is non-nil, then don't verify the existence of the
hunk text in the source file.  Otherwise, don't highlight the hunk if the
hunk text is not found in the source file.

(fn FILE TEXT LINE-NB &optional HUNK-ONLY)
(defalias 'diff-syntax-fontify-props #[1027 "\2031\203\f\304\305!\210\211?\205\306\307\302!\210\310\311 \210)\312\313!\2030\313\314\315!>\2030\313 \210*\2066\316\317\211\211eb\210\203Ke\262d\262
\202\200@Sy\210\320`	G\\\310#\203j`GZ\262`\262
\202\200eb\210\320\317\310#\203\200`GZ\262`\262

\203\362\211\203\362
b\210\321\"\210`
W\203\362`\322 \317\310`\317\323\324\"\203\326\325\324\317	$\262\211\203\300ZZEB\262\323\324\"\262

\262
W\204\241\317\262\202\241\211\203\343EB\262\237\nB\262\n\266\326y\210\202\220\237)\207" [buffer-file-name enable-local-variables delay-mode-hooks font-lock-defaults cl--assertion-failed (null buffer-file-name) :safe make-local-variable t set-auto-mode fboundp generic-mode-find-file-hook default-value find-file-hook (nil t) nil search-forward font-lock-ensure line-end-position get-text-property face next-single-property-change 1] 20 (#$ . 79848)])
#@12 

(fn STR)
(defalias 'diff--filter-substring #[257 "\203\f\301\302G\303$\210\207" [diff-font-lock-prettify remove-text-properties 0 (display nil)] 6 (#$ . 81324)])
#@154 Use `wiggle' to apply the whole current file diff by hook or by crook.
When a hunk can't cleanly be applied, it gets turned into a diff3-style
conflict.
(defalias 'diff-wiggle #[0 "\300 \301 p\302!\303\304\305\306!\"\307\310#\303\304\305\306!\"\307\311#\312\313#\216\314\315\316\"r\211q\210\312\317\"\216p\262q\210\320!\203P\321\307\312\322\"\"\210\320!\203P\323\324!\210\325@A@\307\326%\210\327\305\307D\307\n&\211\330>\204\206\331\332rq\210eb\210\333!\210\334 )\"\202\262rq\210\325\307\211	\307\326%\210rq\210\335\316\211\211#\210\212eb\210\336\337\307\316#\203\255\340\341!\210)\342!*\262
*\262
)\207" [diff-bounds-of-file diff-find-file-name find-buffer-visiting make-temp-file expand-file-name "wiggle" file-name-directory nil ".diff" ".error" make-closure #[0 "\302\300!\210\302\301!\207" [V0 V1 delete-file] 2] generate-new-buffer " *temp*" t #[0 "\301\300!\205	\302\300!\207" [V0 buffer-name kill-buffer] 2] buffer-modified-p save-some-buffers #[0 "p\300=\207" [V0] 2] user-error "Abort!" write-region silent call-process (0 1) message "diff-wiggle error: %s" insert-file-contents buffer-string revert-buffer re-search-forward "^<<<<<<<" smerge-mode 1 pop-to-buffer] 14 (#$ . 81499) nil])
(provide 'diff-mode)