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



(byte-code "\300\301\302\303\304\305\306\307&\210\310\311\312\313\314DD\315\316\317%\210\310\320\312\313\321DD\322\316\323%\210\310\324\312\313\325DD\326\316\327%\210\310\330\312\313\331DD\332\316\3331B\334 0\202F\210\202M\203M\335\202N\336%\210\310\337\312\313\340DD\341\316\342%\210\343\344\345\"\210\310\345\312\313\346DD\347\316\350%\210\310\351\312\313\352DD\353\316\354%\210\310\355\312\313\356DD\357\316\360\304\361&\210\310\362\312\313\363DD\364\316\365%\207" [custom-declare-group jit-lock nil "Font Lock support mode to fontify just-in-time." :version "21.1" :group font-lock custom-declare-variable jit-lock-chunk-size funcall function #[0 "\300\207" [1500] 1 #1=""] "Jit-lock asks to fontify chunks of at most this many characters at a time.\n\nThe actual size of the fontified chunk of text can be different,\ndepending on what the `fontification-functions' actually decide to do.\n\nThis variable controls both display-time and stealth fontifications.\n\nThe optimum value is a little over the typical number of buffer\ncharacters which fit in a typical window." :type integer jit-lock-stealth-time #[0 "\300\207" [nil] 1 #1#] "Time in seconds to wait before beginning stealth fontification.\nStealth fontification occurs if there is no input within this time.\nIf nil, stealth fontification is never performed.\n\nThe value of this variable is used when JIT Lock mode is turned on." (choice (const :tag "never" nil) (number :tag "seconds" :value 16)) jit-lock-stealth-nice #[0 "\300\207" [0.5] 1 #1#] "Time in seconds to pause between chunks of stealth fontification.\nEach iteration of stealth fontification is separated by this amount of time,\nthus reducing the demand that stealth fontification makes on the system.\nIf nil, means stealth fontification is never paused.\nTo reduce machine load during stealth fontification, at the cost of stealth\ntaking longer to fontify, you could increase the value of this variable.\nSee also `jit-lock-stealth-load'." (choice (const :tag "never" nil) (number :tag "seconds")) jit-lock-stealth-load #[0 "\3001\n\301 0\202
\210\302\207\205\303\207" [(error) load-average nil 200] 1 #1#] "Load in percentage above which stealth fontification is suspended.\nStealth fontification pauses when the system short-term load average (as\nreturned by the function `load-average' if supported) goes above this level,\nthus reducing the demand that stealth fontification makes on the system.\nIf nil, means stealth fontification is never suspended.\nTo reduce machine load during stealth fontification, at the cost of stealth\ntaking longer to fontify, you could reduce the value of this variable.\nSee also `jit-lock-stealth-nice'." (error) load-average (choice (const :tag "never" nil) (integer :tag "load")) (const :format "%t: unsupported\n" nil) jit-lock-stealth-verbose #[0 "\300\207" [nil] 1 #1#] "If non-nil, means stealth fontification should show status messages." boolean defvaralias jit-lock-defer-contextually jit-lock-contextually #[0 "\300\207" [syntax-driven] 1 #1#] "If non-nil, fontification should be syntactically true.\nIf nil, refontification occurs only on lines that were modified.  This\nmeans where modification on a line causes syntactic change on subsequent lines,\nthose subsequent lines are not refontified to reflect their new context.\nIf t, fontification occurs on those lines modified and all subsequent lines.\nThis means those subsequent lines are refontified to reflect their new\nsyntactic context, after `jit-lock-context-time' seconds.\nIf any other value, e.g., `syntax-driven', it means refontification of\nsubsequent lines to reflect their new syntactic context may or may not\noccur after `jit-lock-context-time', depending on the font-lock\ndefinitions of the buffer.  Specifically, if `font-lock-keywords-only'\nis nil in a buffer, which generally means the syntactic fontification\nis done using the buffer mode's syntax table, the syntactic\nrefontification will be triggered (because in that case font-lock\ncalls `jit-lock-register' to set up for syntactic refontification,\nand sets the buffer-local value of `jit-lock-contextually' to t).\n\nThe value of this variable is used when JIT Lock mode is turned on." (choice (const :tag "never" nil) (const :tag "always" t) (other :tag "syntax-driven" syntax-driven)) jit-lock-context-time #[0 "\300\207" [0.5] 1 #1#] "Idle time after which text is contextually refontified, if applicable." (number :tag "seconds") jit-lock-antiblink-grace #[0 "\300\207" [2] 1 #1#] "Delay after which to refontify unterminated strings and comments.\nIf nil, no grace period is given; unterminated strings and comments\nare refontified immediately.  If a number, a newly created\nunterminated string or comment is fontified only to the end of the\ncurrent line, after which fontification waits that many seconds of idle\ntime before refontifying the remaining lines.  When typing strings\nand comments, the delay helps avoid unpleasant \"blinking\", between\nstring/comment and non-string/non-comment fontification." (choice (const :tag "never" nil) (number :tag "seconds")) "27.1" jit-lock-defer-time #[0 "\300\207" [nil] 1 #1#] "Idle time after which deferred fontification should take place.\nIf nil, fontification is not deferred.\nIf 0, then fontification is only deferred while there is input pending." (choice (const :tag "never" nil) (number :tag "seconds"))] 8)
#@49 Non-nil means Just-in-time Lock mode is active.
(defvar jit-lock-mode nil (#$ . 5490))
(make-variable-buffer-local 'jit-lock-mode)
#@342 Special hook run to do the actual fontification.
The functions are called with two arguments:
the START and END of the region to fontify.
Each function can return a list of the form (jit-lock-bounds BEG . END),
to indicate the bounds of the region it actually fontified;
JIT font-lock will use this information to optimize redisplay cycles.
(defvar jit-lock-functions nil (#$ . 5628))
#@110 Consider text after this position as contextually unfontified.
If nil, contextual fontification is disabled.
(defvar jit-lock-context-unfontify-pos nil (#$ . 6020))
(make-variable-buffer-local 'jit-lock-context-unfontify-pos)
#@60 Timer for stealth fontification in Just-in-time Lock mode.
(defvar jit-lock-stealth-timer nil (#$ . 6252))
#@69 Timer for repeated stealth fontification in Just-in-time Lock mode.
(defvar jit-lock-stealth-repeat-timer nil (#$ . 6365))
#@60 Timer for context fontification in Just-in-time Lock mode.
(defvar jit-lock-context-timer nil (#$ . 6494))
#@61 Timer for deferred fontification in Just-in-time Lock mode.
(defvar jit-lock-defer-timer nil (#$ . 6607))
#@54 List of buffers with pending deferred fontification.
(defvar jit-lock-defer-buffers nil (#$ . 6719))
#@54 List of buffers that are being fontified stealthily.
(defvar jit-lock-stealth-buffers nil (#$ . 6826))
#@67 Idle timer for fontifying unterminated string or comment, or nil.
(defvar jit-lock--antiblink-grace-timer nil (#$ . 6935))
#@61 Last line beginning position after last command (a marker).
(defvar jit-lock--antiblink-line-beginning-position (make-marker) (#$ . 7064))
#@65 Non-nil if in string or comment after last command (a boolean).
(defvar jit-lock--antiblink-string-or-comment nil (#$ . 7209))
#@1671 Toggle Just-in-time Lock mode.
Turn Just-in-time Lock mode on if and only if ARG is non-nil.
Enable it automatically by customizing group `font-lock'.

When Just-in-time Lock mode is enabled, fontification is different in the
following ways:

- Demand-driven buffer fontification triggered by Emacs C code.
  This means initial fontification of the whole buffer does not occur.
  Instead, fontification occurs when necessary, such as when scrolling
  through the buffer would otherwise reveal unfontified areas.  This is
  useful if buffer fontification is too slow for large buffers.

- Stealthy buffer fontification if `jit-lock-stealth-time' is non-nil.
  This means remaining unfontified areas of buffers are fontified if Emacs has
  been idle for `jit-lock-stealth-time' seconds, while Emacs remains idle.
  This is useful if any buffer has any deferred fontification.

- Deferred context fontification if `jit-lock-contextually' is
  non-nil.  This means fontification updates the buffer corresponding to
  true syntactic context, after `jit-lock-context-time' seconds of Emacs
  idle time, while Emacs remains idle.  Otherwise, fontification occurs
  on modified lines only, and subsequent lines can remain fontified
  corresponding to previous syntactic contexts.  This is useful where
  strings or comments span lines.

Stealth fontification only occurs while the system remains unloaded.
If the system load rises above `jit-lock-stealth-load' percent, stealth
fontification is suspended.  Stealth fontification intensity is controlled via
the variable `jit-lock-stealth-nice'.

If you need to debug code run from jit-lock, see `jit-lock-debug-mode'.

(fn ARG)
(defalias 'jit-lock-mode #[257 "\211\306 \203\203\307\310\311!\207\203v\312 \210	\203&\n\204&\313	\314\315#	\2037\2047\316 \317\315\320#\210\f\203E
\204E\313\f\314\321#\314=\203h \204Y\313!\314\322# \323\324\325\307\314$\210\"\206fd\"\323\326\327\307\314$\210\323\330\331\307\314$\207\n\204\203
\204\203 \203\313\3322\247\333 \211\205\244\211@r\211q\210\203\234\334\332\314\"\210)
A\266\202\202\211\262
0\204\313\n\203\264\335\n!\210\307 \203\301\335 !\210\307 
\203\313\335
!\210\307\336\326\327\314#\210\336\330\331\"\207" [jit-lock-mode jit-lock-stealth-time jit-lock-stealth-timer jit-lock-stealth-repeat-timer jit-lock-defer-time jit-lock-defer-timer buffer-base-buffer nil message "Not enabling jit-lock: it does not work in indirect buffer" jit-lock-refontify run-with-idle-timer t jit-lock-stealth-fontify timer-create timer-set-function (t) jit-lock-deferred-fontify #[0 "?\205\301 \207" [jit-lock--antiblink-grace-timer jit-lock-context-fontify] 1] add-hook post-command-hook jit-lock--antiblink-post-command after-change-functions jit-lock-after-change fontification-functions jit-lock-function found buffer-list throw cancel-timer remove-hook jit-lock-contextually jit-lock-context-timer jit-lock-context-time jit-lock-context-unfontify-pos] 6 (#$ . 7344)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313&	\207" [custom-declare-variable jit-lock-debug-mode funcall function #[0 "\300\207" [nil] 1 ""] "Non-nil if Jit-Lock-Debug mode is enabled.\nSee the `jit-lock-debug-mode' command\nfor a description of this minor mode.\nSetting this variable directly does not take effect;\neither customize it (see the info node `Easy Customization')\nor call the function `jit-lock-debug-mode'." :set custom-set-minor-mode :initialize custom-initialize-default :type boolean] 10)
#@814 Minor mode to help debug code run from jit-lock.

This is a minor mode.  If called interactively, toggle the
`Jit-Lock-Debug 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 `(default-value \='jit-lock-debug-mode)'.

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

When this minor mode is enabled, jit-lock runs as little code as possible
during redisplay and moves the rest to a timer, where things
like `debug-on-error' and Edebug can be used.

(fn &optional ARG)
(defalias 'jit-lock-debug-mode #[256 "\303 \304\302\305=\203\306\302!?\202!\247\203 \307W\203 \310\202!\311\"\210\312\300!\2038\313\302\"\306\302!\2038\302B	\203B\314	!\210\310\n\203L\315\316\311\317#\320\321\306\302!\203X\322\202Y\323\"\210\324\325!\203\201\326\302!\210\303 \203q\211\303 \232\203\201\327\330\306\302!\203}\331\202~\332\333#\210\210\334 \210\306\302!\207" [global-minor-modes jit-lock-defer-timer jit-lock-debug-mode current-message set-default toggle default-value 1 nil t boundp delq cancel-timer run-with-idle-timer 0 jit-lock--debug-fontify run-hooks jit-lock-debug-mode-hook jit-lock-debug-mode-on-hook jit-lock-debug-mode-off-hook called-interactively-p any customize-mark-as-set message "Jit-Lock-Debug mode %sabled%s" "en" "dis" "" force-mode-line-update] 6 (#$ . 10869) (byte-code "\203\n\301!\202\302C\207" [current-prefix-arg prefix-numeric-value toggle] 2)])
(defvar jit-lock-debug-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%\207" [jit-lock-debug-mode-map jit-lock-debug-mode-hook variable-documentation put "Hook run after entering or leaving `jit-lock-debug-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 jit-lock-debug-mode boundp] 6)
(defvar jit-lock--debug-fontifying nil)
#@42 Fontify what was deferred for debugging.
(defalias 'jit-lock--debug-fontify #[0 "?\205n	\205n\n?\205n\306\307	\211\203i\211@\310
!\203br\211q\210\306\311 \306\211\306\312\313\"\216e\314
\315\"\316=\203T\317
\315\307d$\211\262\320\315\307$\210\321\"\266\317
\315\"\211\262\2045\210,\210*
A\266\202\202\210\307\211*\207" [jit-lock--debug-fontifying jit-lock-defer-buffers memory-full inhibit-debugger inhibit-point-motion-hooks buffer-undo-list t nil buffer-live-p buffer-modified-p make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] get-text-property fontified defer next-single-property-change put-text-property jit-lock-fontify-now inhibit-read-only inhibit-modification-hooks] 11 (#$ . 13167)])
#@479 Register FUN as a fontification function to be called in this buffer.
FUN will be called with two arguments START and END indicating the region
that needs to be (re)fontified.
If non-nil, CONTEXTUAL means that a contextual fontification would be useful.
FUN can return a list of the form (jit-lock-bounds BEG . END),
to indicate the bounds of the region it actually fontified; JIT
font-lock will use this information to optimize redisplay cycles.

(fn FUN &optional CONTEXTUAL)
(defalias 'jit-lock-register #[513 "\301\302\303\304$\210\211\203\203\305\300!\210\304\306\304!\207" [jit-lock-contextually add-hook jit-lock-functions nil t make-local-variable jit-lock-mode] 7 (#$ . 13929)])
#@91 Unregister FUN as a fontification function.
Only applies to the current buffer.

(fn FUN)
(defalias 'jit-lock-unregister #[257 "\301\300\302#\210\303\235\205\304\305!\207" [jit-lock-functions remove-hook t (nil '(t)) jit-lock-mode nil] 5 (#$ . 14630)])
#@94 Force refontification of the region BEG..END (default whole buffer).

(fn &optional BEG END)
(defalias 'jit-lock-refontify #[512 "\304\305 \304\211\304\306\307\"\216\214~\210\310\206e\206d\311\312$-\262
)\207" [inhibit-point-motion-hooks buffer-undo-list inhibit-read-only inhibit-modification-hooks t buffer-modified-p make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] put-text-property fontified nil] 9 (#$ . 14893)])
#@148 Fontify current buffer starting at position START.
This function is added to `fontification-functions' when `jit-lock-mode'
is active.

(fn START)
(defalias 'jit-lock-function #[257 "\205P	?\205P\n\203\306=\203\307 \204\310
\211\f\\\"\207p
>\204)p
B\311\312 \311\211\311\313\314\"\216\315\316\317\320d\f\\^$\317\321$,\262
)\207" [jit-lock-mode memory-full jit-lock-defer-timer jit-lock-defer-time jit-lock-chunk-size jit-lock-defer-buffers 0 input-pending-p jit-lock-fontify-now t buffer-modified-p make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] put-text-property next-single-property-change fontified nil defer inhibit-point-motion-hooks buffer-undo-list inhibit-read-only inhibit-modification-hooks] 12 (#$ . 15363)])
#@16 

(fn BEG END)
(defalias 'jit-lock--run-functions #[514 "\300C\300CCC\301\302\303\304						&\"\210\242^\242]\242\242F\207" [nil run-hook-wrapped jit-lock-functions make-closure #[257 "\211\300\301\"\211\242\306=\203\211A\202\300\301B\211\242
\243\302\211\242\206e]\240\210\303\211\242\206)d^\240\210\304\211\242^\240\210\305\211\242]\240\266\307\207" [V0 V1 V2 V3 V4 V5 jit-lock-bounds nil] 8 "\n\n(fn FUN)"]] 16 (#$ . 16149)])
#@126 Fontify current buffer from START to END.
Defaults to the whole buffer.  END can be out of bounds.

(fn &optional START END)
(defalias 'jit-lock-fontify-now #[512 "\305\306 \305\211\305\307\310\"\216\212\204e\262
\203!
d^\202\"d\262\311\312 \307\313\"\216\205\340W\205\340\314\315\305$\206C\262
V\203\323\316\315\305$\210\3171a\320\"0\202q\316\315\311$\210\321
@A\"\262
\211\242
\243\211\242
\243\211\242
\243\211\242
\243\311W\204\222\fV\203\233\316	\315\305$\210\f\203\270\fW\203\270\f	Y\203\270\322	\323\"\204\270
W\203\315\324\325\311\326\327	!\327!%\210\262\266\n\314\315\311$\262\202-)\262
\266\202-\262
)\207" [inhibit-point-motion-hooks buffer-undo-list inhibit-read-only inhibit-modification-hooks jit-lock-context-unfontify-pos t buffer-modified-p make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] nil match-data #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] text-property-any fontified put-text-property (quit) jit-lock--run-functions signal get-text-property jit-lock-defer-multiline run-with-timer 0 jit-lock-force-redisplay copy-marker] 24 (#$ . 16613)])
#@146 Force the display engine to re-render START's buffer from START to END.
This applies to the buffer associated with marker START.

(fn START END)
(defalias 'jit-lock-force-redisplay #[514 "\304!\205Ar\304!q\210\305\306 \305\211\305\307\310\"\216
dV\203)d\262^\262eW\2037e\262]\262\311\312\305$,\262
*\207" [inhibit-point-motion-hooks buffer-undo-list inhibit-read-only inhibit-modification-hooks marker-buffer t buffer-modified-p make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] put-text-property fontified] 9 (#$ . 17812)])
#@134 Return the start of the next chunk to fontify around position AROUND.
Value is nil if there is nothing more to fontify.

(fn AROUND)
(defalias 'jit-lock-stealth-chunk-start #[257 "\301 \302U?\205b\303
d\304\305$\306\304\"\307eS]\304\"
\204.\211\305=?\205He\310\245Z]\202H\211\305=\203C\306\304\"\206<eZ]\202H
Z]\211\204N\207\204S\207
ZZW\203_\207\266\204\207" [jit-lock-chunk-size buffer-size 0 text-property-not-all fontified t previous-single-property-change get-text-property 2] 8 (#$ . 18397)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put jit-lock-stealth-chunk-start speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@241 Fontify buffers stealthily.
This function is called repeatedly after Emacs has become idle for
`jit-lock-stealth-time' seconds.  Optional argument REPEAT is expected
non-nil in a repeated invocation of this function.

(fn &optional REPEAT)
(defalias 'jit-lock-stealth-fontify #[256 "\211\204\306!\210	\206\"\n\206\"\307 \206\"\211\203\202!\310 \211??\205'
@\311\312\211\211
 \203I\313 @\206<\311 V\203I!\262\202
\314!\203
rq\210\"\203
`\315 \311U?\205\312\316
d\317\320$\321\317\"\322eS]\317\"
\204\210\211\320=?\205\244e#\323\245Z]\202\244\211\320=\203\236\321\317\"\206\226e#Z]\202\244
#Z]\211\204\256\266\205\202\314\204\267\266\204\202\314
ZZW\203\307\266\204\202\314\266\204\262
\211\262\203
$\205\333\324\325 P\312C\326\327#\216
\203\361\211\330 \240\210\331\332\"\210\333\211#\\\"\210%\206\377\311\262)\266\202\n
A)\202
A\205$
\334\335 \"\210\336\"\210\337\320\"*\266\205\207" [jit-lock-stealth-repeat-timer executing-kbd-macro memory-full jit-lock-stealth-buffers message-log-max minibuffer-auto-raise cancel-timer window-minibuffer-p buffer-list 0 nil load-average buffer-live-p buffer-size text-property-not-all fontified t previous-single-property-change get-text-property 2 "JIT stealth lock " buffer-name make-closure #[0 "\300\205\301\242\203\302\303\301\242\"\207\302\304!\207" [V0 V1 message "%s" nil] 3] current-message message "%s" jit-lock-fontify-now timer-set-idle-time current-idle-time timer-inc-time timer-activate-when-idle jit-lock-stealth-load jit-lock-stealth-time jit-lock-mode jit-lock-chunk-size jit-lock-stealth-verbose jit-lock-stealth-nice] 14 (#$ . 19083)])
#@28 Fontify what was deferred.
(defalias 'jit-lock-deferred-fontify #[0 "\205j	?\205j\211\203W\211@\306
!\203Pr\211q\210\307\310 \307\211\307\311\312\"\216e\313
\314\"\315=\203B\316
\317\314\320d$\211\262\314\320$\210\317
\314\"\211\262\204*\210,\210*
A\266\202\202\n\210\320\211\321 ?\205g\211\211)\262
\207" [jit-lock-defer-buffers memory-full inhibit-point-motion-hooks buffer-undo-list inhibit-read-only inhibit-modification-hooks buffer-live-p t buffer-modified-p make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] get-text-property fontified defer put-text-property next-single-property-change nil redisplay jit-lock-defer-timer] 12 (#$ . 20767)])
#@57 Refresh fontification to take new context into account.
(defalias 'jit-lock-context-fontify #[0 "?\205Y\306 \211\205W\211@r\211q\210	\203O\214~\210	eY\203N	dW\203N\307	\310\"\2034\311	\310\"\2063e\312\313 \312\211\312\314\315\"\216\316	d\317#\210,\210)d))
A\266\202\202\262
\207" [memory-full jit-lock-context-unfontify-pos inhibit-point-motion-hooks buffer-undo-list inhibit-read-only inhibit-modification-hooks buffer-list get-text-property jit-lock-defer-multiline previous-single-property-change t buffer-modified-p make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] remove-text-properties (fontified nil jit-lock-defer-multiline nil)] 8 (#$ . 21477)])
#@611 Hook that can extend the text to refontify after a change.
This is run after every buffer change.  The functions are called with
the three arguments of `after-change-functions': START END OLD-LEN.
The extended region to refontify is returned indirectly by modifying
the variables `jit-lock-start' and `jit-lock-end'.

Note that extending the region this way is not strictly necessary, except
that the nature of the redisplay code tends to otherwise leave some of
the rehighlighted text displayed with the old highlight until the next
redisplay (see comment about repeated redisplay in `jit-lock-fontify-now').
(defvar jit-lock-after-change-extend-region-functions nil (#$ . 22189))
#@406 Mark the rest of the buffer as not fontified after a change.
Installed on `after-change-functions'.
START and END are the start and end of the changed text.  OLD-LEN
is the pre-change length.
This function ensures that lines following the change will be refontified
in case the syntax of those lines has changed.  Refontification
will take place when text is fontified stealthily.

(fn START END OLD-LEN)
(defalias 'jit-lock-after-change #[771 "\205F	?\205F\306\307 \306\211\306\310\311\"\216\312\313$\210\nT]d^\214~\210\314\n\315\316$\210-\210)\205E^\211*\207" [jit-lock-mode memory-full jit-lock-end jit-lock-start inhibit-point-motion-hooks buffer-undo-list t buffer-modified-p make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] run-hook-with-args jit-lock-after-change-extend-region-functions put-text-property fontified nil inhibit-read-only inhibit-modification-hooks jit-lock-context-unfontify-pos] 10 (#$ . 22878)])
(defalias 'jit-lock--antiblink-post-command #[0 "\304\305 !\305\306!\205

U?\205\307	!p=\205
	U\211\205(\310\212\311!)8
\203=\n\204=\211\203=\312\313\314#\202g
\203V\211\204V\n\203V\203g\315!\210\313\202g
\204g\203g\316 \210\315!\210\313	\313\211\223\210\211\211\207" [jit-lock-antiblink-grace jit-lock--antiblink-line-beginning-position jit-lock--antiblink-string-or-comment jit-lock--antiblink-grace-timer copy-marker line-beginning-position 2 marker-buffer 8 syntax-ppss run-with-idle-timer nil #[0 "\301 \210\302\211\207" [jit-lock--antiblink-grace-timer jit-lock-context-fontify nil] 2] cancel-timer jit-lock-context-fontify] 8])
(provide 'jit-lock)