HOME

Mini Shell 1.0
DIR:/proc/self/root/usr/share/emacs/26.1/lisp/
Current File : //proc/self/root/usr/share/emacs/26.1/lisp/isearch.elc
;ELC
;;; Compiled
;;; in Emacs version 26.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(byte-code "\300\301\302\303\304\305\304\306\307\310\307\311\312\313&
\210\314\315\316\317\320DD\321\322\323%\210\314\324\316\317\325DD\326\322\327%\210\314\330\316\317\331DD\332\322\327%\210\314\333\316\317\334DD\335\322\336%\210\314\337\316\317\340DD\341\322\323%\210\314\342\316\317\343DD\344\322\345\346\347&\210\314\350\316\317\351DD\352\322\353%\210\314\354\316\317\355DD\356\322\323%\210\314\357\316\317\360DD\361\322\323%\207" [custom-declare-group isearch nil "Incremental search minor mode." :link (emacs-commentary-link "isearch") (custom-manual "(emacs)Incremental Search") :prefix "isearch-" "search-" :group matching custom-declare-variable search-exit-option funcall function #[0 "\300\207" [t] 1] "Non-nil means random control characters terminate incremental search." :type boolean search-slow-window-lines #[0 "\300\207" [1] 1] "Number of lines in slow search display windows.\nThese are the short windows used during incremental search on slow terminals.\nNegative means put the slow search window at the top (normally it's at bottom)\nand the value is minus the number of lines." integer search-slow-speed #[0 "\300\207" [1200] 1] "Highest terminal speed at which to use \"slow\" style incremental search.\nThis is the style where a one-line window is created to show the line\nthat the search has reached." search-upper-case #[0 "\300\207" [not-yanks] 1] "If non-nil, upper case chars disable case fold searching.\nThat is, upper and lower case chars must match exactly.\nThis applies no matter where the chars come from, but does not\napply to chars in regexps that are prefixed with `\\'.\nIf this value is `not-yanks', text yanked into the search string\nin Isearch mode is always downcased." (choice (const :tag "off" nil) (const not-yanks) (other :tag "on" t)) search-nonincremental-instead #[0 "\300\207" [t] 1] "If non-nil, do a nonincremental search instead of exiting immediately.\nThis affects the behavior of `isearch-exit' and any key bound to that\ncommand: if this variable is nil, `isearch-exit' always exits the search;\nif the value is non-nil, and the search string is empty, `isearch-exit'\nstarts a nonincremental search instead.  (Actually, `isearch-edit-string'\nis called to let you enter the search string, and RET terminates editing\nand does a nonincremental search.)" search-whitespace-regexp #[0 "\300\301!\207" [purecopy "\\s-+"] 2] "If non-nil, regular expression to match a sequence of whitespace chars.\nWhen you enter a space or spaces in the incremental search, it\nwill match any sequence matched by this regexp.  As an exception,\nspaces are treated normally in regexp incremental search if they\noccur in a regexp construct like [...] or *, + or ?.\n\nIf the value is a string, it applies to both ordinary and\nregexp incremental search.  If the value is nil, or\n`isearch-lax-whitespace' is nil for ordinary incremental search, or\n`isearch-regexp-lax-whitespace' is nil for regexp incremental search,\nthen each space you type matches literally, against one space.\n\nYou might want to use something like \"[ \\t\\r\\n]+\" instead.\nIn the Customization buffer, that is `[' followed by a space,\na tab, a carriage return (control-M), a newline, and `]+'." (choice (const :tag "Match Spaces Literally" nil) regexp) :version "24.3" search-invisible #[0 "\300\207" [open] 1] "If t incremental search/query-replace can match hidden text.\nA nil value means don't match invisible text.\nWhen the value is `open', if the text matched is made invisible by\nan overlay having a non-nil `invisible' property, and that overlay\nhas a non-nil property `isearch-open-invisible', then incremental\nsearch will show the hidden text.  (This applies when using `outline.el'\nand `hideshow.el'.)\n\nTo temporarily change the value for an active incremental search,\nuse \\<isearch-mode-map>\\[isearch-toggle-invisible].\n\nSee also the related option `isearch-hide-immediately'.\n\nSee also `reveal-mode' if you want overlays to automatically be opened\nwhenever point is in one of them." (choice (const :tag "Match hidden text" t) (const :tag "Open overlays" open) (const :tag "Don't match hidden text" nil)) isearch-hide-immediately #[0 "\300\207" [t] 1] "If non-nil, re-hide an invisible match right away.\nThis variable makes a difference when `search-invisible' is set to `open'.\nIf non-nil, invisible matches are re-hidden as soon as the match moves\noff the invisible text surrounding the match.\nIf nil then do not re-hide opened invisible text when the match moves.\nWhatever the value, all opened invisible text is hidden again after exiting\nthe search, with the exception of the last successful match, if any." isearch-resume-in-command-history #[0 "\300\207" [nil] 1] "If non-nil, `isearch-resume' commands are added to the command history.\nThis allows you to resume earlier Isearch sessions through the\ncommand history."] 14)
#@62 Function(s) to call after starting up an incremental search.
(defvar isearch-mode-hook nil (#$ . 5295))
#@68 Function(s) to call after isearch has found matches in the buffer.
(defvar isearch-update-post-hook nil (#$ . 5405))
#@165 Function(s) to call after terminating an incremental search.
When these functions are called, `isearch-mode-end-hook-quit'
is non-nil if the user quits the search.
(defvar isearch-mode-end-hook nil (#$ . 5529))
#@77 Non-nil while running `isearch-mode-end-hook' if the user quits the search.
(defvar isearch-mode-end-hook-quit nil (#$ . 5746))
#@88 Function to call to display the search prompt.
If nil, use function `isearch-message'.
(defvar isearch-message-function nil (#$ . 5880))
#@183 Function to call to wrap the search when search is failed.
If nil, move point to the beginning of the buffer for a forward search,
or to the end of the buffer for a backward search.
(defvar isearch-wrap-function nil (#$ . 6024))
#@99 Function to save a function restoring the mode-specific Isearch state
to the search status stack.
(defvar isearch-push-state-function nil (#$ . 6259))
#@476 Predicate that filters the search hits that would normally be available.
Search hits that dissatisfy the predicate are skipped.  The function
has two arguments: the positions of start and end of text matched by
the search.  If this function returns nil, continue searching without
stopping at this match.
If you use `add-function' to modify this variable, you can use the
`isearch-message-prefix' advice property to specify the prefix string
displayed in the search message.
(defvar isearch-filter-predicate 'isearch-filter-visible (#$ . 6417))
#@34 List of search string sequences.
(defvar search-ring nil (#$ . 6968))
#@53 List of regular expression search string sequences.
(defvar regexp-search-ring nil (#$ . 7044))
(byte-code "\300\301\302\303\304DD\305\306\307%\210\300\310\302\303\311DD\312\306\307%\207" [custom-declare-variable search-ring-max funcall function #[0 "\300\207" [16] 1] "Maximum length of search ring before oldest elements are thrown away." :type integer regexp-search-ring-max #[0 "\300\207" [16] 1] "Maximum length of regexp search ring before oldest elements are thrown away."] 6)
#@70 Index in `search-ring' of last string reused.
It is nil if none yet.
(defvar search-ring-yank-pointer nil (#$ . 7534))
#@77 Index in `regexp-search-ring' of last string reused.
It is nil if none yet.
(defvar regexp-search-ring-yank-pointer nil (#$ . 7659))
(byte-code "\300\301\302\303\304DD\305\306\307%\210\310\311\312\"\210\300\313\302\303\314DD\315\306\316\317\320&\210\300\321\302\303\322DD\323\306\307%\210\324\325\326\327\330\325\330\331&\207" [custom-declare-variable search-ring-update funcall function #[0 "\300\207" [nil] 1] "Non-nil if advancing or retreating in the search ring should cause search.\nDefault value, nil, means edit the string instead." :type boolean autoload char-fold-to-regexp "char-fold" search-default-mode #[0 "\300\207" [nil] 1] "Default mode to use when starting isearch.\nValue is nil, t, or a function.\n\nIf nil, default to literal searches (note that `case-fold-search'\nand `isearch-lax-whitespace' may still be applied).\\<isearch-mode-map>\nIf t, default to regexp searches (as if typing `\\[isearch-toggle-regexp]' during\nisearch).\n\nIf a function, use that function as an `isearch-regexp-function'.\nExample functions (and the keys to toggle them during isearch)\nare `word-search-regexp' (`\\[isearch-toggle-word]'), `isearch-symbol-regexp'\n(`\\[isearch-toggle-symbol]'), and `char-fold-to-regexp' (`\\[isearch-toggle-char-fold]')." (choice (const :tag "Literal search" nil) (const :tag "Regexp search" t) (function :tag "Other")) :version "25.1" search-highlight #[0 "\300\207" [t] 1] "Non-nil means incremental search highlights the current match." custom-declare-face isearch ((((class color) (min-colors 88) (background light)) (:background "magenta3" :foreground "lightskyblue1")) (((class color) (min-colors 88) (background dark)) (:background "palevioletred2" :foreground "brown4")) (((class color) (min-colors 16)) (:background "magenta4" :foreground "cyan1")) (((class color) (min-colors 8)) (:background "magenta4" :foreground "cyan1")) (t (:inverse-video t))) "Face for highlighting Isearch matches." :group basic-faces] 8)
(defvar isearch-face 'isearch)
(byte-code "\300\301\302\303\304\305%\210\306\307\310\311\312DD\313\314\315\316\317\316\320&	\210\321\317\322\323\324\325\304\326\316\320\316\327&\210\330\331\332\322#\210\333\211\203P\211@\331N\203I\332N\204I\334\332\331N#\210A\266\202\202/\210\335\331\332\336#\210\306\332\310\311\337DD\340\314\341\316\317&\210\330\342\343\322#\210\344\211\203\216\211@\342N\203\207\343N\204\207\334\343\342N#\210A\266\202\202m\210\335\342\343\336#\210\306\343\310\311\345DD\346\314\347\316\317&\210\330\350\351\322#\210\352\211\203\314\211@\350N\203\305\351N\204\305\334\351\350N#\210A\266\202\202\253\210\335\350\351\336#\210\306\351\310\311\353DD\354\314\347\316\317&\210\330\355\356\322#\210\357\211\203\n\211@\355N\203\356N\204\334\356\355N#\210A\266\202\202\351\210\335\355\356\336#\210\306\356\310\311\360DD\361\314\362\316\317&\210\300\317\363\364\316\317\316\365&\207" [custom-declare-face isearch-fail ((((class color) (min-colors 88) (background light)) (:background "RosyBrown1")) (((class color) (min-colors 88) (background dark)) (:background "red4")) (((class color) (min-colors 16)) (:background "red")) (((class color) (min-colors 8)) (:background "red")) (((class color grayscale)) :foreground "grey") (t (:inverse-video t))) "Face for highlighting failed part in Isearch echo-area message." :version "23.1" custom-declare-variable isearch-lazy-highlight funcall function #[0 "\300\207" [t] 1] "Controls the lazy-highlighting during incremental search.\nWhen non-nil, all text in the buffer matching the current search\nstring is highlighted lazily (see `lazy-highlight-initial-delay'\nand `lazy-highlight-interval').\n\nWhen multiple windows display the current buffer, the\nhighlighting is displayed only on the selected window, unless\nthis variable is set to the symbol `all-windows'." :type (choice boolean (const :tag "On, and applied to all windows" all-windows)) :group lazy-highlight isearch custom-declare-group nil "Lazy highlighting feature for matching strings." :prefix "lazy-highlight-" "21.1" matching defvaralias isearch-lazy-highlight-cleanup lazy-highlight-cleanup (saved-value saved-variable-comment) put make-obsolete-variable "22.1" #[0 "\300\207" [t] 1] "Controls whether to remove extra highlighting after a search.\nIf this is nil, extra highlighting can be \"manually\" removed with\n\\[lazy-highlight-cleanup]." boolean isearch-lazy-highlight-initial-delay lazy-highlight-initial-delay (saved-value saved-variable-comment) #[0 "\300\207" [0.25] 1] "Seconds to wait before beginning to lazily highlight all matches." number isearch-lazy-highlight-interval lazy-highlight-interval (saved-value saved-variable-comment) #[0 "\300\207" [0] 1] "Seconds between lazily highlighting successive matches." isearch-lazy-highlight-max-at-a-time lazy-highlight-max-at-a-time (saved-value saved-variable-comment) #[0 "\300\207" [nil] 1] "Maximum matches to highlight at a time (for `lazy-highlight').\nLarger values may reduce Isearch's responsiveness to user input;\nsmaller values make matches highlight slowly.\nA value of nil means highlight all matches shown on the screen." (choice (const :tag "All" nil) (integer :tag "Some")) ((((class color) (min-colors 88) (background light)) (:background "paleturquoise")) (((class color) (min-colors 88) (background dark)) (:background "paleturquoise4")) (((class color) (min-colors 16)) (:background "turquoise3")) (((class color) (min-colors 8)) (:background "turquoise3")) (t (:underline t))) "Face for lazy highlighting of matches other than the current one." basic-faces] 12)
#@64 Keymap for characters following the Help key for Isearch mode.
(defvar isearch-help-map (byte-code "\301 \302\303!\304#\210\302\305\304#\210\302\306\304#\210\302\307\304#\210\302\310\311#\210\302\312\313#\210\302\314\315#\210\302\316\317#\210\211\207" [help-char make-sparse-keymap define-key char-to-string isearch-help-for-help [help] [f1] "?" "b" isearch-describe-bindings "k" isearch-describe-key "m" isearch-describe-mode "q" help-quit] 5) (#$ . 13246))
#@481 You have typed %THIS-KEY%, the help character.  Type a Help option:
(Type \<help-map>\[help-quit] to exit the Help command.)

b           Display all Isearch key bindings.
k KEYS      Display full documentation of Isearch key sequence.
m           Display documentation of Isearch mode.

You can't type here other help keys available in the global help map,
but outside of this help window when you type them in Isearch mode,
they exit Isearch mode before displaying global help.
(defalias 'isearch-help-for-help-internal-doc #[0 "\300\207" [nil] 1 (#$ . 13721)])
#@15 Help command.
(defalias 'isearch-help-for-help-internal #[0 "\306\307\310!!\203\311\312\"\210\313\314!\315 	C\316 \317C\317C\317\211\320\321	\"\2034\322\323\324 \325\326O!\327\211$\262\330\325\331\332\333\n		#\334\"\335$\216\317\n\241\210\336\337\340#\210\336\341\342\343\"#\210\203\344\317!)\262\342
\"\203w\342
\"\262\325H\262\202\202\345\262\211\345=\204\226\211@=\204\226\211A>\203Q\346 \240\210\347\350\317\327#\210\351\352!\203\267\353 =\204\267\353 \240\210\317\240\210\317B\327C\354 \210c\210)\242\355 \210	\240\210)eb\210\211\356A@\357B\">\204\355\211\242\360=\204\355\361\232\203Q\3621\211\242\360=\203\376\363!\202\211\364>\203	\365 \202\211\366>\204\361\232\205\367 0\202\210\202 \210\327D\344\370\371\372d!\2033\373\2024\374\"!\262\325H\262*\211\375=\203\323\376\342\"\317#\210\202\323\311\373!\210\211<\203f\211EBE\317\240\202\250\342\"\211\203\242\242\203}\377\242!\210\317\240\210\242\201F!\210)\242\205\246\242\316 =\204\234\201G\242!\210\317\240\202\246\201H \262*\266\210\207" [three-step-help minor-mode-map-alist isearch-help-map global-map overriding-local-map function-key-map substitute-command-keys purecopy "Type a help option: [bkm] or ?" message "%s" documentation isearch-help-for-help-internal-doc make-sparse-keymap selected-frame nil string-match "%THIS-KEY%" replace-match key-description this-command-keys 0 -1 t make-byte-code "\301\242\203\n\304\301\242!\210\302\242\203\305\302\242!\210\300\242\211\207" vconcat vector [minor-mode-map-alist set-window-configuration iconify-frame] 2 define-key [t] undefined [vertical-scroll-bar] lookup-key [vertical-scroll-bar] read-key-sequence 63 current-window-configuration pop-to-buffer " *Metahelp*" fboundp make-frame window-frame erase-buffer help-mode append (63 22 32 127 delete backspace vertical-scroll-bar 134217846) switch-frame "\366" (error) handle-switch-frame (22 32) scroll-up (127 134217846 delete backspace) scroll-down format "Type one of the options listed%s: " pos-visible-in-window-p "" ", or SPACE or DEL to scroll" vertical-scroll-bar command-execute set-window-configuration help-char help-event-list buffer-read-only inhibit-read-only cursor-in-echo-area unread-command-events call-interactively iconify-frame ding] 17 (#$ . 14291) nil])
(defvar isearch--display-help-action '(nil (inhibit-same-window . t)))
#@28 Display Isearch help menu.
(defalias 'isearch-help-for-help #[0 "\302 \210)\303 \207" [isearch--display-help-action display-buffer-overriding-action isearch-help-for-help-internal isearch-update] 1 (#$ . 16730) nil])
#@139 Show a list of all keys defined in Isearch mode, and their definitions.
This is like `describe-bindings', but displays only Isearch keys.
(defalias 'isearch-describe-bindings #[0 "\n\306\211\223\210\307B\310\fB\311 \312\313!\211\306\211rq\210\314\315!\210\314\316\317!!)\262rq\210\320\306\"\262)\321\322!\203C\322\"\202D\211)\266\203+\207" [isearch--display-help-action display-buffer-overriding-action help-window-point-marker temp-buffer-window-setup-hook temp-buffer-window-show-hook help-window-old-frame nil help-mode-setup help-mode-finish selected-frame temp-buffer-window-setup "*Help*" princ "Isearch Mode Bindings:\n" substitute-command-keys "\\{isearch-mode-map}" temp-buffer-window-show functionp help-window-setup standard-output] 6 (#$ . 16956) nil])
#@63 Display documentation of the function invoked by isearch key.
(defalias 'isearch-describe-key #[0 "\302\303!\210)\304 \207" [isearch--display-help-action display-buffer-overriding-action call-interactively describe-key isearch-update] 2 (#$ . 17745) nil])
#@40 Display documentation of Isearch mode.
(defalias 'isearch-describe-mode #[0 "\302\303!\210)\304 \207" [isearch--display-help-action display-buffer-overriding-action describe-function isearch-forward isearch-update] 2 (#$ . 18009) nil])
(defalias 'isearch-mode-help 'isearch-describe-mode)
#@28 Keymap for `isearch-mode'.
(defvar isearch-mode-map (byte-code "\303\304 \305A@!\204\306\307!\210\310A@\311\312 B\313#\210\314\262\311W\2032\315\316!\313#\210T\262\202\317 \315\320!#\266\315\321\322#\210\315\323\324#\210\315\325\322#\210\315\326\324#\210\315\327\330#\210\315\331\332#\210\315\333\334#\210\335U\204q\306\336!\210\315\337\340#\210\315\341\342#\210\315\343\344#\210\315\345\344#\210\315\346\313#\210\315\347\313#\210\315\350\313#\210\315\351\352#\210\315\353\354#\210\315\355\356#\210\315\357\360#\210\315\361\362#\210\315\320	!\n#\210\315\363\n#\210\315\364\n#\210\315\365\366#\210\315\367\370#\210\315\371\372#\210\315\373\374#\210\315\375\376#\210\315\377\376#\210\315\201@\376#\210\315\201A\376#\210\315\201B\376#\210\315\201C\376#\210\315\201D\201E#\210\315\201F\201G#\210\315\201H\201I#\210\315\201J\376#\210\315\201K\201L#\210\315\201M\201N#\210\315\201O\201P#\210\315\201Q\201R#\210\201S\201R\201T\201U#\210\315\201U\201R#\210\315\201V\201W#\210\315\201X\201Y#\210\315\201Z\201[#\210\315\201\\\201]#\210\315\201^\201_#\210\207" [meta-prefix-char help-char isearch-help-map 0 make-keymap char-table-p error "The initialization of isearch-mode-map must be updated" set-char-table-range 256 max-char isearch-printing-char 32 define-key vector make-sparse-keymap char-to-string "" isearch-repeat-forward "" isearch-repeat-backward "\223" "\222" "" isearch-delete-char [backspace] undefined "" isearch-abort 27 "Inconsistency in isearch.el" "" isearch-cancel "" isearch-quote-char "
" isearch-exit [return] "\n" "	" [33554464] "" isearch-yank-word-or-char "\227" isearch-del-char "\231" isearch-yank-char "" isearch-yank-kill "\363" isearch-yank-line [help] [f1] "\356" isearch-ring-advance "\360" isearch-ring-retreat "\371" isearch-yank-pop "\211" isearch-complete [switch-frame] nil [delete-frame] [iconify-frame] [make-frame-visible] [mouse-movement] [language-change] "" isearch-toggle-input-method "" isearch-toggle-specified-input-method [mouse-2] isearch-mouse-2 [down-mouse-2] [xterm-paste] isearch-xterm-paste "\343" isearch-toggle-case-fold "\362" isearch-toggle-regexp "\345" isearch-edit-string put :advertised-binding "\363e" [134217765] isearch-query-replace [201326629] isearch-query-replace-regexp "\363o" isearch-occur "\363hr" isearch-highlight-regexp "8
" isearch-char-by-name] 7) (#$ . 18306))
#@55 Keymap for editing Isearch strings in the minibuffer.
(defvar minibuffer-local-isearch-map (byte-code "\301 \302\"\210\303\304\305#\210\303\306\307#\210\303\310\311#\210\303\312\313#\210\303\314\315#\210\303\316\315#\210\211\207" [minibuffer-local-map make-sparse-keymap set-keymap-parent define-key "
" exit-minibuffer "\211" isearch-complete-edit "" isearch-forward-exit-minibuffer "" isearch-reverse-exit-minibuffer "" isearch-yank-char-in-minibuffer [right]] 5) (#$ . 20758))
(defvar isearch-forward nil)
(defvar isearch-regexp nil)
#@458 Regexp-based search mode for words/symbols.
If the value is a function (e.g. `isearch-symbol-regexp'), it is
called to convert a plain search string to a regexp used by
regexp search functions.
The symbol property `isearch-message-prefix' put on this function
specifies the prefix string displayed in the search message.

This variable is set and changed during isearch.  To change the
default behavior used for searches, see `search-default-mode'
instead.
(defvar isearch-regexp-function nil (#$ . 21313))
(byte-code "\300\301\302\303#\210\304\211\203(\211@\301N\203!\302N\204!\305\302\301N#\210A\266\202\202\210\306\301\302\307#\207" [defvaralias isearch-word isearch-regexp-function nil (saved-value saved-variable-comment) put make-obsolete-variable "25.1"] 7)
#@401 If non-nil, a space will match a sequence of whitespace chars.
When you enter a space or spaces in ordinary incremental search, it
will match any sequence matched by the regexp defined by the variable
`search-whitespace-regexp'.  If the value is nil, each space you type
matches literally, against one space.  You can toggle the value of this
variable by the command `isearch-toggle-lax-whitespace'.
(defvar isearch-lax-whitespace t (#$ . 22095))
#@399 If non-nil, a space will match a sequence of whitespace chars.
When you enter a space or spaces in regexp incremental search, it
will match any sequence matched by the regexp defined by the variable
`search-whitespace-regexp'.  If the value is nil, each space you type
matches literally, against one space.  You can toggle the value of this
variable by the command `isearch-toggle-lax-whitespace'.
(defvar isearch-regexp-lax-whitespace nil (#$ . 22549))
#@193 Stack of search status elements.
Each element is an `isearch--state' struct where the slots are
 [STRING MESSAGE POINT SUCCESS FORWARD OTHER-END WORD
  ERROR WRAPPED BARRIER CASE-FOLD-SEARCH]
(defvar isearch-cmds nil (#$ . 23010))
(defvar isearch-string "")
(defvar isearch-message "")
(defvar isearch-message-prefix-add nil)
(defvar isearch-message-suffix-add nil)
(defvar isearch-success t)
(defvar isearch-error nil)
(defvar isearch-other-end nil)
(defvar isearch-wrapped nil)
#@56 Recorded minimum/maximal point for the current search.
(defvar isearch-barrier 0 (#$ . 23496))
(defvar isearch-just-started nil)
(defvar isearch-start-hscroll 0)
(defvar isearch-case-fold-search nil)
(defvar isearch-invisible search-invisible)
(defvar isearch-last-case-fold-search nil)
(defvar isearch-original-minibuffer-message-timeout nil)
(defvar isearch-adjusted nil)
(defvar isearch-slow-terminal-mode nil)
(defvar isearch-small-window nil)
(defvar isearch-opoint 0)
(defvar isearch-window-configuration nil)
(defvar isearch-yank-flag nil)
(defvar isearch-op-fun nil)
(defvar isearch-recursive-edit nil)
(defvar isearch-nonincremental nil)
(defvar isearch-new-nonincremental nil)
(defvar isearch-new-forward nil)
(defvar isearch-opened-overlays nil)
(defvar isearch-hidden nil)
(defvar isearch-input-method-function nil)
(defvar isearch-input-method-local-p nil)
(defvar isearch--saved-overriding-local-map nil)
(byte-code "\301\236\204\302C\244\210\301\207" [minor-mode-alist isearch-mode (isearch-mode isearch-mode)] 2)
(defvar isearch-mode nil nil)
(byte-code "\303\304!\210\305\306\307#\210\305	\306\310#\210\305\311\312#\210\305	\311\313#\210\305\n\314\315#\210\305\n\316\317#\210\305\n\320\321#\207" [global-map esc-map search-map make-variable-buffer-local isearch-mode define-key "" isearch-forward isearch-forward-regexp "" isearch-backward isearch-backward-regexp "w" isearch-forward-word "_" isearch-forward-symbol "." isearch-forward-symbol-at-point] 4)
#@4115 Do incremental search forward.
With a prefix argument, do an incremental regular expression search instead.
\<isearch-mode-map>
As you type characters, they add to the search string and are found.
The following non-printing keys are bound in `isearch-mode-map'.

Type \[isearch-delete-char] to cancel last input item from end of search string.
Type \[isearch-exit] to exit, leaving point at location found.
Type LFD (C-j) to match end of line.
Type \[isearch-repeat-forward] to search again forward, \[isearch-repeat-backward] to search again backward.
Type \[isearch-yank-word-or-char] to yank next word or character in buffer
  onto the end of the search string, and search for it.
Type \[isearch-del-char] to delete character from end of search string.
Type \[isearch-yank-char] to yank char from buffer onto end of search string and search for it.
Type \[isearch-yank-line] to yank rest of line onto end of search string and search for it.
Type \[isearch-yank-kill] to yank the last string of killed text.
Type \[isearch-yank-pop] to replace string just yanked into search prompt
 with string killed before it.
Type \[isearch-quote-char] to quote control character to search for it.
Type \[isearch-char-by-name] to add a character to search by Unicode name, with completion.
\[isearch-abort] while searching or when search has failed cancels input back to what has
 been found successfully.
\[isearch-abort] when search is successful aborts and moves point to starting point.

If you try to exit with the search string still empty, it invokes
 nonincremental search.

Type \[isearch-toggle-case-fold] to toggle search case-sensitivity.
Type \[isearch-toggle-invisible] to toggle search in invisible text.
Type \[isearch-toggle-regexp] to toggle regular-expression mode.
Type \[isearch-toggle-word] to toggle word mode.
Type \[isearch-toggle-symbol] to toggle symbol mode.
Type \[isearch-toggle-char-fold] to toggle character folding.

Type \[isearch-toggle-lax-whitespace] to toggle whitespace matching.
In incremental searches, a space or spaces normally matches any whitespace
defined by the variable `search-whitespace-regexp'; see also the variables
`isearch-lax-whitespace' and `isearch-regexp-lax-whitespace'.

Type \[isearch-edit-string] to edit the search string in the minibuffer.

Also supported is a search ring of the previous 16 search strings.
Type \[isearch-ring-advance] to search for the next item in the search ring.
Type \[isearch-ring-retreat] to search for the previous item in the search ring.
Type \[isearch-complete] to complete the search string using the search ring.

Type \[isearch-query-replace] to run `query-replace' with string to replace from last search string.
Type \[isearch-query-replace-regexp] to run `query-replace-regexp' with the last search string.
Type \[isearch-occur] to run `occur' that shows the last search string.
Type \[isearch-highlight-regexp] to run `highlight-regexp' that highlights the last search string.

Type \[isearch-describe-bindings] to display all Isearch key bindings.
Type \[isearch-describe-key] to display documentation of Isearch key.
Type \[isearch-describe-mode] to display documentation of Isearch mode.

If an input method is turned on in the current buffer, that input
method is also active while you are typing characters to search.
To toggle the input method, type \[isearch-toggle-input-method].  It also toggles the input
method in the current buffer.

To use a different input method for searching, type \[isearch-toggle-specified-input-method],
and specify an input method you want to use.

The above keys, bound in `isearch-mode-map', are often controlled by
 options; do \[apropos] on search-.* to find them.
Other control and meta characters terminate the search
 and are then executed normally (depending on `search-exit-option').
Likewise for function keys and mouse button events.

If this function is called non-interactively with a nil NO-RECURSIVE-EDIT,
it does not return to the calling function until the search is done.
See the function `isearch-mode' for more information.

(fn &optional REGEXP-P NO-RECURSIVE-EDIT)
(defalias 'isearch-forward #[512 "\300\301??\302?$\207" [isearch-mode t nil] 7 (#$ . 24985) "P\np"])
#@605 Do incremental search forward for regular expression.
With a prefix argument, do a regular string search instead.
Like ordinary incremental search except that your input is treated
as a regexp.  See the command `isearch-forward' for more information.

In incremental searches, a space or spaces normally matches any
whitespace defined by the variable `search-whitespace-regexp'.
To search for a literal space and nothing else, enter C-q SPC.
To toggle whitespace matching, use `isearch-toggle-lax-whitespace'.
This command does not support character folding.

(fn &optional NOT-REGEXP NO-RECURSIVE-EDIT)
(defalias 'isearch-forward-regexp #[512 "\300\301?\302?$\207" [isearch-mode t nil] 7 (#$ . 29209) "P\np"])
#@445 Do incremental search forward for a sequence of words.
With a prefix argument, do a regular string search instead.
Like ordinary incremental search except that your input is treated
as a sequence of words without regard to how the words are separated.
See the command `isearch-forward' for more information.
This command does not support character folding, and lax space matching
has no effect on it.

(fn &optional NOT-WORD NO-RECURSIVE-EDIT)
(defalias 'isearch-forward-word #[512 "\300\301\302\211??%\207" [isearch-mode t nil] 8 (#$ . 29929) "P\np"])
#@413 Do incremental search forward for a symbol.
The prefix argument is currently unused.
Like ordinary incremental search except that your input is treated
as a symbol surrounded by symbol boundary constructs \_< and \_>.
See the command `isearch-forward' for more information.
This command does not support character folding, and lax space matching
has no effect on it.

(fn &optional NOT-SYMBOL NO-RECURSIVE-EDIT)
(defalias 'isearch-forward-symbol #[512 "\300\301\302\211?\303%\207" [isearch-mode t nil isearch-symbol-regexp] 8 (#$ . 30492) "P\np"])
#@196 Do incremental search backward.
With a prefix argument, do a regular expression search instead.
See the command `isearch-forward' for more information.

(fn &optional REGEXP-P NO-RECURSIVE-EDIT)
(defalias 'isearch-backward #[512 "\300\301??\301?$\207" [isearch-mode nil] 7 (#$ . 31048) "P\np"])
#@305 Do incremental search backward for regular expression.
With a prefix argument, do a regular string search instead.
Like ordinary incremental search except that your input is treated
as a regexp.  See the command `isearch-forward-regexp' for more information.

(fn &optional NOT-REGEXP NO-RECURSIVE-EDIT)
(defalias 'isearch-backward-regexp #[512 "\300\301?\301?$\207" [isearch-mode nil] 7 (#$ . 31352) "P\np"])
#@302 Do incremental search forward for a symbol found near point.
Like ordinary incremental search except that the symbol found at point
is added to the search string initially as a regexp surrounded
by symbol boundary constructs \_< and \_>.
See the command `isearch-forward-symbol' for more information.
(defalias 'isearch-forward-symbol-at-point #[0 "\301\302\303\"\210\304 \211\203!\211@`W\203\211@b\210\305\306@A\"!\202(\307\310 \210\311 \207" [isearch-error isearch-forward-symbol nil 1 find-tag-default-bounds isearch-yank-string buffer-substring-no-properties "No symbol at point" isearch-push-state isearch-update] 5 (#$ . 31771) nil])
#@799 Start Isearch minor mode.
It is called by the function `isearch-forward' and other related functions.

The non-nil arg FORWARD means searching in the forward direction.

The non-nil arg REGEXP does an incremental regular expression search.

The arg OP-FUN is a function to be called after each input character
is processed.  (It is not called after characters that exit the search.)

When the arg RECURSIVE-EDIT is non-nil, this function behaves modally and
does not return to the calling function until the search is completed.
To behave this way it enters a recursive-edit and exits it when done
isearching.

The arg REGEXP-FUNCTION, if non-nil, should be a function.  It is
used to set the value of `isearch-regexp-function'.

(fn FORWARD &optional REGEXP OP-FUN RECURSIVE-EDIT REGEXP-FUNCTION)
(defalias 'isearch-mode #[1281 "\206\211?\205	\306=\211\206\307	!\205?\205	
)*+,\310\211-.\311/\3060\3111`2\311\21134\311567X\205X\312 \3138!\314_V9\311\211:;\306<\315 =`>\311\211?@A\316\317!B\311CDE\311DB\204\214\320\317!\210\311\321\310!\2109\205\232\322 F\323\324 !\325!\326>\204\273\327!\204\262\330!\210G\203\273\331!\210\210\332H\333 \210IJ\334\335!\210JK\336 \210\337 \210\340\341\342\"\210\340\343\344\"\210\340\345\346\"\210\340\347\346\"\210\203\363\306L\350 \210)0\207" [isearch-forward search-default-mode isearch-regexp isearch-regexp-function isearch-op-fun isearch-case-fold-search t functionp "" nil window-height abs 4 window-hscroll local-variable-p input-method-function make-local-variable looking-at current-window-configuration window-frame minibuffer-window frame-live-p (nil t) frame-visible-p make-frame-visible raise-frame " Isearch" force-mode-line-update run-hooks isearch-mode-hook isearch-push-state isearch-update add-hook pre-command-hook isearch-pre-command-hook post-command-hook isearch-post-command-hook mouse-leave-buffer-hook isearch-done kbd-macro-termination-hook recursive-edit isearch-last-case-fold-search case-fold-search search-invisible isearch-invisible isearch-string isearch-message isearch-cmds isearch-success isearch-wrapped isearch-barrier isearch-adjusted isearch-yank-flag isearch-error baud-rate search-slow-speed search-slow-window-lines isearch-slow-terminal-mode isearch-other-end isearch-small-window isearch-just-started isearch-start-hscroll isearch-opoint search-ring-yank-pointer isearch-opened-overlays isearch-input-method-function isearch-input-method-local-p regexp-search-ring-yank-pointer minibuffer-message-timeout isearch-original-minibuffer-message-timeout isearch-window-configuration minibuffer-auto-raise isearch-mode isearch-mode-map overriding-terminal-local-map isearch--saved-overriding-local-map isearch-recursive-edit] 9 (#$ . 32425)])
(defvar isearch--current-buffer nil)
#@198 This is called after every isearch command to update the display.
The second last thing it does is to run `isearch-update-post-hook'.
The last thing is to trigger a new round of lazy highlighting.
(defalias 'isearch-update #[0 "p=\204 \306!\203rq\210\307\310	\")p\311\301!\210\310	B\n\204\336\204\336\312 \2044\f\2062\313 \210
\203\225\"\204\225\314 \204\225`\315\"\316\317!\210\320#\321\322$\317W\203]$[T\202c\323 $TZ\"\210)$\317W\203\212\324\320$Z!\210\325\326 `\"\210\327\326 \330 \"\210\327\331 \317\"\210\202\216\332\320!\210\211b\266\202\275\330 \322\327\331 %\"\210\314\322\211\315#\262\211\203\265\211@\333 \334 _Y\203\273\327\331 \"\210\266&\203\333&`W\203\322\335&`\"\210\202\336\335`&\"\210\202\336\336 \210\322\211'(\315)\337\340!\210*\205\362\341 \207" [isearch--current-buffer cursor-sensor-inhibit unread-command-events executing-kbd-macro isearch-message-function isearch-slow-terminal-mode buffer-live-p delq isearch make-local-variable input-pending-p isearch-message pos-visible-in-window-group-p t move-to-window-line 0 1 split-window nil window-height vertical-motion set-window-start next-window set-window-hscroll window-hscroll selected-window other-window window-max-chars-per-line frame-char-width isearch-highlight isearch-dehighlight run-hooks isearch-update-post-hook isearch-lazy-highlight-new-loop isearch-small-window window-min-height search-slow-window-lines isearch-start-hscroll isearch-other-end isearch-adjusted isearch-yank-flag disable-point-adjustment isearch-lazy-highlight] 7 (#$ . 35261)])
#@202 Exit Isearch mode.
For successful search, pass no args.
For a failing search, NOPUSH is t.
For going to the minibuffer to edit the search string,
NOPUSH is t and EDIT is t.

(fn &optional NOPUSH EDIT)
(defalias 'isearch-done #[512 "\203\306	\n\f
\307+D\257,@\232\204\211,B,\210\310\311\312\"\210\310\313\314\"\210\310\315\316\"\210\310\317\316\"\210\320-\321.!\203Mr.q\210\320.\322\323/\"/)\320012\324 \210\325!\210\326 `3\203{\3273!\2104\203t\211b\210\202{\330\331 \332#\210\266\32056\203\2147\202\220\333\334!\210\335 \210m?\205\234\336`\337\"o?\205\246\336`S\337\"\211\203\305\203\305\211=\203\305\f\203\277\340`\337\"\202\303\341`\337\"b\210\266	G\342V\203\327\204\327\343	\n\"\210\205\335\211?8\344\345!\210)`9U\204:\203\365;\204\3469\332\"\210<\204\347 \342V\204\211\204\350\351!\210\211?\205=\205\352 \207" [isearch-resume-in-command-history isearch-string isearch-regexp isearch-regexp-function isearch-forward isearch-message isearch-resume quote remove-hook pre-command-hook isearch-pre-command-hook post-command-hook isearch-post-command-hook mouse-leave-buffer-hook isearch-done kbd-macro-termination-hook nil buffer-live-p delq isearch isearch-dehighlight lazy-highlight-cleanup window-group-start set-window-configuration set-window-group-start selected-window t kill-local-variable input-method-function force-mode-line-update get-text-property intangible next-single-property-change previous-single-property-change 0 isearch-update-ring run-hooks isearch-mode-end-hook push-mark minibuffer-depth message "Mark saved where search started" exit-recursive-edit isearch-case-fold-search command-history isearch-lazy-highlight-start isearch--current-buffer cursor-sensor-inhibit overriding-terminal-local-map isearch-original-minibuffer-message-timeout minibuffer-message-timeout isearch-window-configuration isearch-small-window isearch-mode isearch-input-method-local-p isearch-input-method-function isearch-mode-end-hook-quit isearch-opoint transient-mark-mode mark-active executing-kbd-macro isearch-recursive-edit] 10 (#$ . 36852)])
#@130 Add STRING to the beginning of the search ring.
REGEXP if non-nil says use the regexp search ring.

(fn STRING &optional REGEXP)
(defalias 'isearch-update-ring #[513 "\302\203	\303\202\n\304\203\202	#\207" [regexp-search-ring-max search-ring-max add-to-history regexp-search-ring search-ring] 6 (#$ . 38984)])
#@73 compiler-macro for inlining `isearch--state-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'isearch--state-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block isearch--state-p (and (memq (type-of cl-x) cl-struct-isearch--state-tags) t)) nil] 9 (#$ . 39310)])
(put 'isearch--state-p 'compiler-macro 'isearch--state-p--cmacro)
#@13 

(fn CL-X)
(defalias 'isearch--state-p #[257 "\301!>\205	\302\207" [cl-struct-isearch--state-tags type-of t] 3 (#$ . 39669)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put isearch--state-p side-effect-free error-free put isearch--state cl-deftype-satisfies] 5)
#@78 compiler-macro for inlining `isearch--state-string'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'isearch--state-string--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block isearch--state-string (or (isearch--state-p cl-x) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 1)) nil] 9 (#$ . 39960)])
(put 'isearch--state-string 'compiler-macro 'isearch--state-string--cmacro)
#@520 Access slot "string" of `(isearch--state (:constructor nil) (:copier nil) (:constructor isearch--get-state (&aux (string isearch-string) (message isearch-message) (point (point)) (success isearch-success) (forward isearch-forward) (other-end isearch-other-end) (word isearch-regexp-function) (error isearch-error) (wrapped isearch-wrapped) (barrier isearch-barrier) (case-fold-search isearch-case-fold-search) (pop-fun (if isearch-push-state-function (funcall isearch-push-state-function))))))' struct CL-X.

(fn CL-X)
(defalias 'isearch--state-string #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-isearch--state-tags type-of signal wrong-type-argument isearch--state 1] 5 (#$ . 40386)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put isearch--state-string side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" isearch--state-string] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@79 compiler-macro for inlining `isearch--state-message'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'isearch--state-message--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block isearch--state-message (or (isearch--state-p cl-x) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 2)) nil] 9 (#$ . 41335)])
(put 'isearch--state-message 'compiler-macro 'isearch--state-message--cmacro)
#@521 Access slot "message" of `(isearch--state (:constructor nil) (:copier nil) (:constructor isearch--get-state (&aux (string isearch-string) (message isearch-message) (point (point)) (success isearch-success) (forward isearch-forward) (other-end isearch-other-end) (word isearch-regexp-function) (error isearch-error) (wrapped isearch-wrapped) (barrier isearch-barrier) (case-fold-search isearch-case-fold-search) (pop-fun (if isearch-push-state-function (funcall isearch-push-state-function))))))' struct CL-X.

(fn CL-X)
(defalias 'isearch--state-message #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-isearch--state-tags type-of signal wrong-type-argument isearch--state 2] 5 (#$ . 41766)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put isearch--state-message side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" isearch--state-message] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@77 compiler-macro for inlining `isearch--state-point'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'isearch--state-point--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block isearch--state-point (or (isearch--state-p cl-x) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 3)) nil] 9 (#$ . 42719)])
(put 'isearch--state-point 'compiler-macro 'isearch--state-point--cmacro)
#@519 Access slot "point" of `(isearch--state (:constructor nil) (:copier nil) (:constructor isearch--get-state (&aux (string isearch-string) (message isearch-message) (point (point)) (success isearch-success) (forward isearch-forward) (other-end isearch-other-end) (word isearch-regexp-function) (error isearch-error) (wrapped isearch-wrapped) (barrier isearch-barrier) (case-fold-search isearch-case-fold-search) (pop-fun (if isearch-push-state-function (funcall isearch-push-state-function))))))' struct CL-X.

(fn CL-X)
(defalias 'isearch--state-point #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-isearch--state-tags type-of signal wrong-type-argument isearch--state 3] 5 (#$ . 43140)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put isearch--state-point side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" isearch--state-point] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@79 compiler-macro for inlining `isearch--state-success'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'isearch--state-success--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block isearch--state-success (or (isearch--state-p cl-x) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 4)) nil] 9 (#$ . 44085)])
(put 'isearch--state-success 'compiler-macro 'isearch--state-success--cmacro)
#@521 Access slot "success" of `(isearch--state (:constructor nil) (:copier nil) (:constructor isearch--get-state (&aux (string isearch-string) (message isearch-message) (point (point)) (success isearch-success) (forward isearch-forward) (other-end isearch-other-end) (word isearch-regexp-function) (error isearch-error) (wrapped isearch-wrapped) (barrier isearch-barrier) (case-fold-search isearch-case-fold-search) (pop-fun (if isearch-push-state-function (funcall isearch-push-state-function))))))' struct CL-X.

(fn CL-X)
(defalias 'isearch--state-success #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-isearch--state-tags type-of signal wrong-type-argument isearch--state 4] 5 (#$ . 44516)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put isearch--state-success side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" isearch--state-success] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@79 compiler-macro for inlining `isearch--state-forward'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'isearch--state-forward--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block isearch--state-forward (or (isearch--state-p cl-x) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 5)) nil] 9 (#$ . 45469)])
(put 'isearch--state-forward 'compiler-macro 'isearch--state-forward--cmacro)
#@521 Access slot "forward" of `(isearch--state (:constructor nil) (:copier nil) (:constructor isearch--get-state (&aux (string isearch-string) (message isearch-message) (point (point)) (success isearch-success) (forward isearch-forward) (other-end isearch-other-end) (word isearch-regexp-function) (error isearch-error) (wrapped isearch-wrapped) (barrier isearch-barrier) (case-fold-search isearch-case-fold-search) (pop-fun (if isearch-push-state-function (funcall isearch-push-state-function))))))' struct CL-X.

(fn CL-X)
(defalias 'isearch--state-forward #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-isearch--state-tags type-of signal wrong-type-argument isearch--state 5] 5 (#$ . 45900)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put isearch--state-forward side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" isearch--state-forward] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@81 compiler-macro for inlining `isearch--state-other-end'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'isearch--state-other-end--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block isearch--state-other-end (or (isearch--state-p cl-x) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 6)) nil] 9 (#$ . 46853)])
(put 'isearch--state-other-end 'compiler-macro 'isearch--state-other-end--cmacro)
#@523 Access slot "other-end" of `(isearch--state (:constructor nil) (:copier nil) (:constructor isearch--get-state (&aux (string isearch-string) (message isearch-message) (point (point)) (success isearch-success) (forward isearch-forward) (other-end isearch-other-end) (word isearch-regexp-function) (error isearch-error) (wrapped isearch-wrapped) (barrier isearch-barrier) (case-fold-search isearch-case-fold-search) (pop-fun (if isearch-push-state-function (funcall isearch-push-state-function))))))' struct CL-X.

(fn CL-X)
(defalias 'isearch--state-other-end #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-isearch--state-tags type-of signal wrong-type-argument isearch--state 6] 5 (#$ . 47294)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put isearch--state-other-end side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" isearch--state-other-end] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@76 compiler-macro for inlining `isearch--state-word'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'isearch--state-word--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block isearch--state-word (or (isearch--state-p cl-x) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 7)) nil] 9 (#$ . 48255)])
(put 'isearch--state-word 'compiler-macro 'isearch--state-word--cmacro)
#@518 Access slot "word" of `(isearch--state (:constructor nil) (:copier nil) (:constructor isearch--get-state (&aux (string isearch-string) (message isearch-message) (point (point)) (success isearch-success) (forward isearch-forward) (other-end isearch-other-end) (word isearch-regexp-function) (error isearch-error) (wrapped isearch-wrapped) (barrier isearch-barrier) (case-fold-search isearch-case-fold-search) (pop-fun (if isearch-push-state-function (funcall isearch-push-state-function))))))' struct CL-X.

(fn CL-X)
(defalias 'isearch--state-word #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-isearch--state-tags type-of signal wrong-type-argument isearch--state 7] 5 (#$ . 48671)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put isearch--state-word side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" isearch--state-word] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@77 compiler-macro for inlining `isearch--state-error'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'isearch--state-error--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block isearch--state-error (or (isearch--state-p cl-x) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 8)) nil] 9 (#$ . 49612)])
(put 'isearch--state-error 'compiler-macro 'isearch--state-error--cmacro)
#@519 Access slot "error" of `(isearch--state (:constructor nil) (:copier nil) (:constructor isearch--get-state (&aux (string isearch-string) (message isearch-message) (point (point)) (success isearch-success) (forward isearch-forward) (other-end isearch-other-end) (word isearch-regexp-function) (error isearch-error) (wrapped isearch-wrapped) (barrier isearch-barrier) (case-fold-search isearch-case-fold-search) (pop-fun (if isearch-push-state-function (funcall isearch-push-state-function))))))' struct CL-X.

(fn CL-X)
(defalias 'isearch--state-error #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-isearch--state-tags type-of signal wrong-type-argument isearch--state 8] 5 (#$ . 50033)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put isearch--state-error side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" isearch--state-error] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@79 compiler-macro for inlining `isearch--state-wrapped'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'isearch--state-wrapped--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block isearch--state-wrapped (or (isearch--state-p cl-x) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 9)) nil] 9 (#$ . 50978)])
(put 'isearch--state-wrapped 'compiler-macro 'isearch--state-wrapped--cmacro)
#@521 Access slot "wrapped" of `(isearch--state (:constructor nil) (:copier nil) (:constructor isearch--get-state (&aux (string isearch-string) (message isearch-message) (point (point)) (success isearch-success) (forward isearch-forward) (other-end isearch-other-end) (word isearch-regexp-function) (error isearch-error) (wrapped isearch-wrapped) (barrier isearch-barrier) (case-fold-search isearch-case-fold-search) (pop-fun (if isearch-push-state-function (funcall isearch-push-state-function))))))' struct CL-X.

(fn CL-X)
(defalias 'isearch--state-wrapped #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-isearch--state-tags type-of signal wrong-type-argument isearch--state 9] 5 (#$ . 51409)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put isearch--state-wrapped side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" isearch--state-wrapped] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@79 compiler-macro for inlining `isearch--state-barrier'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'isearch--state-barrier--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block isearch--state-barrier (or (isearch--state-p cl-x) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 10)) nil] 9 (#$ . 52362)])
(put 'isearch--state-barrier 'compiler-macro 'isearch--state-barrier--cmacro)
#@521 Access slot "barrier" of `(isearch--state (:constructor nil) (:copier nil) (:constructor isearch--get-state (&aux (string isearch-string) (message isearch-message) (point (point)) (success isearch-success) (forward isearch-forward) (other-end isearch-other-end) (word isearch-regexp-function) (error isearch-error) (wrapped isearch-wrapped) (barrier isearch-barrier) (case-fold-search isearch-case-fold-search) (pop-fun (if isearch-push-state-function (funcall isearch-push-state-function))))))' struct CL-X.

(fn CL-X)
(defalias 'isearch--state-barrier #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-isearch--state-tags type-of signal wrong-type-argument isearch--state 10] 5 (#$ . 52794)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put isearch--state-barrier side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" isearch--state-barrier] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@88 compiler-macro for inlining `isearch--state-case-fold-search'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'isearch--state-case-fold-search--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block isearch--state-case-fold-search (or (isearch--state-p cl-x) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 11)) nil] 9 (#$ . 53748)])
(put 'isearch--state-case-fold-search 'compiler-macro 'isearch--state-case-fold-search--cmacro)
#@530 Access slot "case-fold-search" of `(isearch--state (:constructor nil) (:copier nil) (:constructor isearch--get-state (&aux (string isearch-string) (message isearch-message) (point (point)) (success isearch-success) (forward isearch-forward) (other-end isearch-other-end) (word isearch-regexp-function) (error isearch-error) (wrapped isearch-wrapped) (barrier isearch-barrier) (case-fold-search isearch-case-fold-search) (pop-fun (if isearch-push-state-function (funcall isearch-push-state-function))))))' struct CL-X.

(fn CL-X)
(defalias 'isearch--state-case-fold-search #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-isearch--state-tags type-of signal wrong-type-argument isearch--state 11] 5 (#$ . 54225)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put isearch--state-case-fold-search side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" isearch--state-case-fold-search] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@79 compiler-macro for inlining `isearch--state-pop-fun'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'isearch--state-pop-fun--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block isearch--state-pop-fun (or (isearch--state-p cl-x) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 12)) nil] 9 (#$ . 55215)])
(put 'isearch--state-pop-fun 'compiler-macro 'isearch--state-pop-fun--cmacro)
#@521 Access slot "pop-fun" of `(isearch--state (:constructor nil) (:copier nil) (:constructor isearch--get-state (&aux (string isearch-string) (message isearch-message) (point (point)) (success isearch-success) (forward isearch-forward) (other-end isearch-other-end) (word isearch-regexp-function) (error isearch-error) (wrapped isearch-wrapped) (barrier isearch-barrier) (case-fold-search isearch-case-fold-search) (pop-fun (if isearch-push-state-function (funcall isearch-push-state-function))))))' struct CL-X.

(fn CL-X)
(defalias 'isearch--state-pop-fun #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-isearch--state-tags type-of signal wrong-type-argument isearch--state 12] 5 (#$ . 55647)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put isearch--state-pop-fun side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" isearch--state-pop-fun] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@51 Constructor for objects of type `isearch--state'.
(defalias 'isearch--get-state #[0 "	`\n\f
	\n\f
\205
 \306\307\f\f\f\f\f\f\f\f\f\f\f
&
)\207" [isearch-string isearch-message isearch-success isearch-forward isearch-other-end isearch-regexp-function record isearch--state isearch-error isearch-wrapped isearch-barrier isearch-case-fold-search case-fold-search isearch-push-state-function] 25 (#$ . 56601)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put isearch--get-state side-effect-free t cl-struct-define isearch--state nil cl-structure-object record ((cl-tag-slot) (string nil :read-only t) (message nil :read-only t) (point nil :read-only t) (success nil :read-only t) (forward nil :read-only t) (other-end nil :read-only t) (word nil :read-only t) (error nil :read-only t) (wrapped nil :read-only t) (barrier nil :read-only t) (case-fold-search nil :read-only t) (pop-fun nil :read-only t)) cl-struct-isearch--state-tags] 11)
#@12 

(fn CMD)
(defalias 'isearch--set-state #[257 "\306!>\204\307\310\311D\"\210\211\312H\306!>\204\"\307\310\311D\"\210\211\313H\306!>\2045\307\310\311D\"\210\211\314H\306!>\204H\307\310\311D\"\210\211\315H\306!>\204[\307\310\311D\"\210\211\316H\306!>\204n\307\310\311D\"\210\211\317H\306!>\204\202\307\310\311D\"\210\211\320H\306!>\204\226\307\310\311D\"\210\211\321H\306!>\204\252\307\310\311D\"\210\211\322H\306!>\204\276\307\310\311D\"\210\211\323H\324\306!>\204\323\307\310\311D\"\210\325H!\203\357\306!>\204\351\307\310\311D\"\210\211\325H!\210\306!>\204\376\307\310\311D\"\210\211\326Hb\207" [cl-struct-isearch--state-tags isearch-string isearch-message isearch-success isearch-forward isearch-other-end type-of signal wrong-type-argument isearch--state 1 2 4 5 6 7 8 9 10 11 functionp 12 3 isearch-regexp-function isearch-error isearch-wrapped isearch-barrier isearch-case-fold-search] 6 (#$ . 57609)])
(defalias 'isearch-pop-state #[0 "A\301@!\207" [isearch-cmds isearch--set-state] 2])
(defalias 'isearch-push-state #[0 "\301 B\211\207" [isearch-cmds isearch--get-state] 2])
#@205 Exit search normally.
However, if this is the first command after starting incremental
search and `search-nonincremental-instead' is non-nil, do a
nonincremental search instead via `isearch-edit-string'.
(defalias 'isearch-exit #[0 "\203	G\303U\203\304\305 \210)\202\306 \210\307 \207" [search-nonincremental-instead isearch-string isearch-nonincremental 0 t isearch-edit-string isearch-done isearch-clean-overlays] 2 (#$ . 58775) nil])
#@168 Return position of first mismatch in search string, or nil if none.
If MSG is non-nil, use variable `isearch-message', otherwise `isearch-string'.

(fn &optional MSG)
(defalias 'isearch-fail-pos #[256 "\203		\202\n\n\306\203\f\205\244\203P\307@!
>\204(\310\311\312@D\"\210@\313H\203G\307@!
>\204@\310\311\312@D\"\210@\314H\203P\211A\262\210\202\205\205\203p\307@!
>\204i\310\311\312@D\"\210@\315H\202\205\307@!
>\204\201\310\311\312@D\"\210@\316H\262\211;\203\243\211GGW\203\243\211\317GO\232\203\243\211G\202\244\317\207" [isearch-cmds isearch-message isearch-string isearch-success isearch-error cl-struct-isearch--state-tags nil type-of signal wrong-type-argument isearch--state 4 8 2 1 0] 8 (#$ . 59227)])
#@236 Holds the next `isearch-regexp-function' inside `with-isearch-suspended'.
If this is set inside code wrapped by the macro
`with-isearch-suspended', then the value set will be used as the
`isearch-regexp-function' once isearch resumes.
(defvar isearch-new-regexp-function nil (#$ . 59989))
(byte-code "\300\301\302\303#\210\304\211\203(\211@\301N\203!\302N\204!\305\302\301N#\210A\266\202\202\210\306\301\302\307#\207" [defvaralias isearch-new-word isearch-new-regexp-function nil (saved-value saved-variable-comment) put make-obsolete-variable "25.1"] 7)
#@303 Exit Isearch mode, run BODY, and reinvoke the pending search.
You can update the global isearch variables by setting new values to
`isearch-new-string', `isearch-new-message', `isearch-new-forward',
`isearch-new-regexp-function', `isearch-new-case-fold', `isearch-new-nonincremental'.

(fn &rest BODY)
(defalias 'with-isearch-suspended '(macro . #[128 "\300\301\302\303\304\305\306\307\302	B\310BB\311BBBBB\312BB\313BBB\207" [condition-case nil progn let ((isearch-new-nonincremental isearch-nonincremental) (isearch-new-string isearch-string) (isearch-new-message isearch-message) (isearch-new-forward isearch-forward) (isearch-new-regexp-function isearch-regexp-function) (isearch-new-case-fold isearch-case-fold-search) (isearch-regexp isearch-regexp) (isearch-op-fun isearch-op-fun) (isearch-cmds isearch-cmds) (isearch-success isearch-success) (isearch-wrapped isearch-wrapped) (isearch-barrier isearch-barrier) (isearch-adjusted isearch-adjusted) (isearch-yank-flag isearch-yank-flag) (isearch-error isearch-error) (multi-isearch-file-list-new multi-isearch-file-list) (multi-isearch-buffer-list-new multi-isearch-buffer-list) (multi-isearch-next-buffer-function multi-isearch-next-buffer-current-function) (multi-isearch-current-buffer-new multi-isearch-current-buffer) (isearch-opoint isearch-opoint) (isearch-slow-terminal-mode isearch-slow-terminal-mode) (isearch-small-window isearch-small-window) (isearch-recursive-edit isearch-recursive-edit) (isearch-window-configuration (current-window-configuration)) (minibuffer-message-timeout isearch-original-minibuffer-message-timeout) (isearch-original-minibuffer-message-timeout isearch-original-minibuffer-message-timeout) old-point old-other-end) (condition-case nil (isearch-done t t) (exit nil)) (setq old-point (point) old-other-end isearch-other-end) unwind-protect ((isearch-mode isearch-forward isearch-regexp isearch-op-fun nil isearch-regexp-function) (setq isearch-string isearch-new-string isearch-message isearch-new-message isearch-forward isearch-new-forward isearch-nonincremental isearch-new-nonincremental isearch-regexp-function isearch-new-regexp-function isearch-case-fold-search isearch-new-case-fold multi-isearch-current-buffer multi-isearch-current-buffer-new multi-isearch-file-list multi-isearch-file-list-new multi-isearch-buffer-list multi-isearch-buffer-list-new) (funcall (or isearch-message-function #'isearch-message) nil t) (if (and old-other-end (eq old-point (point)) (eq isearch-forward isearch-new-forward)) (goto-char old-other-end))) ((when (= 0 (length isearch-string)) (setq isearch-string (or (car (if isearch-regexp regexp-search-ring search-ring)) #1="") isearch-message (mapconcat 'isearch-text-char-description isearch-string #1#)) (isearch-ring-adjust1 nil))) ((isearch-search) (isearch-push-state) (isearch-update) (if isearch-nonincremental (progn (isearch-done) (if (equal isearch-string #1#) (message #1#))))) ((quit (isearch-abort)))] 11 (#$ . 60561)]))
#@423 Edit the search string in the minibuffer.
The following additional command keys are active while editing.
\<minibuffer-local-isearch-map>
\[exit-minibuffer] to resume incremental searching with the edited string.
\[isearch-forward-exit-minibuffer] to resume isearching forward.
\[isearch-reverse-exit-minibuffer] to resume isearching backward.
\[isearch-complete-edit] to complete the search string using the search ring.
(defalias 'isearch-edit-string #[0 "\3061D	C\nC\f
\"#$%&'()*+,-./012\307 3\211\310C\310C345210/\n6
*)('&%$#\"789\3111\217\312\313\211\"0\202\223\210\202\224\210`\240\210\211:\240\210\314\315\316\317\320\f\f&\321\"\322$\216\310\211;<\310=\323\324\310\"	\325 \206\321	GTB>\310\"\203\347\326?\206\342\327TB\202\360\330@\206\356\327TB\310\313&\240\210\331\332\242\333#\240\210,	G\315U\203%\"\203\202@\206\333\331\332	\333#\334\310!\210.\266\335 \210\336 \210\337 \210\205B\312 \210	\333\232\205B\340\333!0\207\210\341 \207" [isearch-nonincremental isearch-string isearch-message isearch-forward isearch-regexp-function isearch-case-fold-search (quit) current-window-configuration nil (exit) isearch-done t make-byte-code 0 "\310\f
\311%\210\300\242\301\242\n\f\302\305\303\304\2062\312\311\313\"\210\307\242\205M\306\242`=\205M\f=\205M\307\242b\207" vconcat vector [isearch-mode nil isearch-message t isearch-forward isearch-regexp isearch-op-fun isearch-regexp-function isearch-string isearch-new-forward isearch-new-nonincremental isearch-nonincremental isearch-new-regexp-function isearch-case-fold-search multi-isearch-current-buffer multi-isearch-file-list multi-isearch-buffer-list isearch-message-function] 6 read-from-minibuffer isearch-message-prefix isearch-fail-pos regexp-search-ring -1 search-ring mapconcat isearch-text-char-description "" isearch-ring-adjust1 isearch-search isearch-push-state isearch-update message isearch-abort isearch-regexp isearch-op-fun isearch-cmds isearch-success isearch-wrapped isearch-barrier isearch-adjusted isearch-yank-flag isearch-error multi-isearch-file-list multi-isearch-buffer-list multi-isearch-next-buffer-current-function multi-isearch-current-buffer isearch-opoint isearch-slow-terminal-mode isearch-small-window isearch-recursive-edit isearch-original-minibuffer-message-timeout minibuffer-message-timeout isearch-window-configuration multi-isearch-next-buffer-function isearch-new-regexp-function isearch-new-forward isearch-new-nonincremental isearch-other-end message-log-max history-add-new-input minibuffer-history-symbol minibuffer-local-isearch-map regexp-search-ring-yank-pointer search-ring-yank-pointer] 42 (#$ . 63534) nil])
(defalias 'isearch-nonincremental-exit-minibuffer #[0 "\301\302 \207" [isearch-new-nonincremental t exit-minibuffer] 1 nil nil])
(make-obsolete 'isearch-nonincremental-exit-minibuffer 'exit-minibuffer "24.4")
#@77 Resume isearching forward from the minibuffer that edits the search string.
(defalias 'isearch-forward-exit-minibuffer #[0 "\302\303\304 \207" [isearch-new-forward isearch-new-nonincremental t nil exit-minibuffer] 1 (#$ . 66534) nil])
#@78 Resume isearching backward from the minibuffer that edits the search string.
(defalias 'isearch-reverse-exit-minibuffer #[0 "\302\211\303 \207" [isearch-new-forward isearch-new-nonincremental nil exit-minibuffer] 2 (#$ . 66777) nil])
#@57 Terminate the search and go back to the starting point.
(defalias 'isearch-cancel #[0 "\203	\203\303	!\304	@!\210)\202\nb\210\305\306!\210\307 \210\310\311\312\"\207" [isearch-push-state-function isearch-cmds isearch-opoint last isearch--set-state isearch-done t isearch-clean-overlays signal quit nil] 3 (#$ . 67019) nil])
#@193 Abort incremental search mode if searching is successful, signaling quit.
Otherwise, revert to previous successful search and continue searching.
Use `isearch-exit' to quit without signaling.
(defalias 'isearch-abort #[0 "\302 \210\203	\204\303\304 \207\203	\203\305 \210\202\306 \207" [isearch-success isearch-error discard-input nil isearch-cancel isearch-pop-state isearch-update] 1 (#$ . 67358) nil])
#@18 

(fn DIRECTION)
(defalias 'isearch-repeat #[257 "\306==\203^	\307\232\203<\n\203\202\f\204\310\202d\n\203'\202(\f@\311\312	\307#\313\314!\210\202d\204d\315\203P \210\202d\203Xe\202Ydb\210\202d?\315`	\307\232\203s\315\202\255\203\252`\232\203\252\204\252\203\214m\202\215o\203\231\314\316 \210\202\255\203\241\317\202\242\320u\210\321 \210\202\255\321 \210\322 \210\323 \207" [isearch-forward isearch-string isearch-regexp regexp-search-ring search-ring isearch-error forward "" "No previous search string" mapconcat isearch-text-char-description isearch-ring-adjust1 nil t ding 1 -1 isearch-search isearch-push-state isearch-update isearch-message isearch-last-case-fold-search isearch-case-fold-search isearch-success isearch-wrapped isearch-wrap-function isearch-barrier isearch-other-end isearch-just-started] 5 (#$ . 67782)])
#@37 Repeat incremental search forwards.
(defalias 'isearch-repeat-forward #[0 "\300\301!\207" [isearch-repeat forward] 2 (#$ . 68688) nil])
#@38 Repeat incremental search backwards.
(defalias 'isearch-repeat-backward #[0 "\300\301!\207" [isearch-repeat backward] 2 (#$ . 68830) nil])
#@474 Define a command called `isearch-toggle-MODE' and bind it to `M-s KEY'.
The first line of the command's docstring is auto-generated, the
remainder may be provided in DOCSTRING.
If FUNCTION is a symbol, this command first toggles the value of
`isearch-regexp-function' between nil and FUNCTION.  Also set the
`isearch-message-prefix' property of FUNCTION.
The command then executes BODY and updates the isearch prompt.

(fn MODE KEY FUNCTION &optional DOCSTRING &rest BODY)
(defalias 'isearch-define-mode-toggle '(macro . #[1155 "\300\301\302\"!\303P\304\305\306\301\307\f\n\203\310P\202\311#\312\313\2059\314\315\316\317\315\320DE\320DEE\321B\n\322#BBBBB\323\324\320DF\205\2079\205\207\325\326	D\327\301\330\"F\325\326\nD\331F\332\333\334\335\336\335\326\337\340\341\301\342\"!FD\343BBEE\344BBEBBB\207" [intern format "isearch-toggle-%s" "\363" progn defun nil "Toggle %s searching on or off.%s" "\n" "" (interactive) append setq isearch-regexp-function unless eq function ((setq isearch-regexp nil)) ((setq isearch-success t isearch-adjusted t) (isearch-update)) define-key isearch-mode-map put quote 'isearch-message-prefix "%s " :advertised-binding cl-callf lambda (types) cons 'choice const :tag capitalize "%s search" ((cdr types)) ((get 'search-default-mode 'custom-type))] 25 (#$ . 68976)]))
(byte-code "\300\301\302\303#\300\207" [function-put isearch-define-mode-toggle lisp-indent-function defun] 4)
#@80 Toggle word searching on or off.
Turning on word search turns off regexp mode.
(defalias 'isearch-toggle-word #[0 "\304=?\205\304\305\306\211\307 \207" [isearch-regexp-function isearch-regexp isearch-success isearch-adjusted word-search-regexp nil t isearch-update] 3 (#$ . 70431) nil])
(byte-code "\301\302\303#\210\304\305\306\307#\210\304\305\310\302#\210\304\311\312\311\312N\313\314ABB\262#\207" [isearch-mode-map define-key "\363w" isearch-toggle-word put word-search-regexp isearch-message-prefix "word " :advertised-binding search-default-mode custom-type choice (const :tag "Word Search" word-search-regexp)] 7)
#@84 Toggle symbol searching on or off.
Turning on symbol search turns off regexp mode.
(defalias 'isearch-toggle-symbol #[0 "\304=?\205\304\305\306\211\307 \207" [isearch-regexp-function isearch-regexp isearch-success isearch-adjusted isearch-symbol-regexp nil t isearch-update] 3 (#$ . 71068) nil])
(byte-code "\301\302\303#\210\304\305\306\307#\210\304\305\310\302#\210\304\311\312\311\312N\313\314ABB\262#\207" [isearch-mode-map define-key "\363_" isearch-toggle-symbol put isearch-symbol-regexp isearch-message-prefix "symbol " :advertised-binding search-default-mode custom-type choice (const :tag "Symbol Search" isearch-symbol-regexp)] 7)
#@91 Toggle char-fold searching on or off.
Turning on character-folding turns off regexp mode.
(defalias 'isearch-toggle-char-fold #[0 "\304=?\205\304\305\306\211\307 \207" [isearch-regexp-function isearch-regexp isearch-success isearch-adjusted char-fold-to-regexp nil t isearch-update] 3 (#$ . 71726) nil])
(byte-code "\301\302\303#\210\304\305\306\307#\210\304\305\310\302#\210\304\311\312\311\312N\313\314ABB\262#\210\304\305\306\307#\207" [isearch-mode-map define-key "\363'" isearch-toggle-char-fold put char-fold-to-regexp isearch-message-prefix "char-fold " :advertised-binding search-default-mode custom-type choice (const :tag "Char-Fold Search" char-fold-to-regexp)] 7)
#@36 Toggle regexp searching on or off.
(defalias 'isearch-toggle-regexp #[0 "?\211\203	\304\305\211\306 \207" [isearch-regexp isearch-regexp-function isearch-success isearch-adjusted nil t isearch-update] 2 (#$ . 72418) nil])
(define-key isearch-mode-map "\363r" 'isearch-toggle-regexp)
#@73 Print STRING at the end of the isearch prompt for 1 second

(fn STRING)
(defalias 'isearch--momentary-message #[257 "\303\304\305\306\303	\"\n$\210)\307\310!\207" [message-log-max isearch-nonincremental isearch-message nil message "%s%s [%s]" isearch-message-prefix sit-for 1] 6 (#$ . 72713)])
#@210 Toggle lax-whitespace searching on or off.
In ordinary search, toggles the value of the variable
`isearch-lax-whitespace'.  In regexp search, toggles the
value of the variable `isearch-regexp-lax-whitespace'.
(defalias 'isearch-toggle-lax-whitespace #[0 "\305\203\f	?\211\202\n?\211\203\306\202\307!\210\310\211\311 \207" [isearch-regexp isearch-regexp-lax-whitespace isearch-lax-whitespace isearch-success isearch-adjusted isearch--momentary-message "match spaces loosely" "match spaces literally" t isearch-update] 4 (#$ . 73016) nil])
(define-key isearch-mode-map "\363 " 'isearch-toggle-lax-whitespace)
#@101 Toggle case-fold searching on or off.
Toggles the value of the variable `isearch-case-fold-search'.
(defalias 'isearch-toggle-case-fold #[0 "\303?\205\304\211\203\305\202\306!\210\307\211\310 \207" [isearch-case-fold-search isearch-success isearch-adjusted isearch--momentary-message yes "case insensitive" "case sensitive" t isearch-update] 4 (#$ . 73642) nil])
(define-key isearch-mode-map "\363c" 'isearch-toggle-case-fold)
#@258 Toggle invisible searching on or off.
This determines whether to search inside invisible text or not.
Toggles the variable `isearch-invisible' between values
nil and a non-nil value of the option `search-invisible'
(or `open' if `search-invisible' is nil).
(defalias 'isearch-toggle-invisible #[0 "\304?\205	\206\305\211\203\306\202\307!\210\310\211\311 \207" [isearch-invisible search-invisible isearch-success isearch-adjusted isearch--momentary-message open "match invisible text" "match visible text" t isearch-update] 4 (#$ . 74086) nil])
(define-key isearch-mode-map "\363i" 'isearch-toggle-invisible)
#@558 Return a regexp which matches words, ignoring punctuation.
Given STRING, a string of words separated by word delimiters,
compute a regexp that matches those exact words separated by
arbitrary punctuation.  If the string begins or ends in whitespace,
the beginning or the end of the string matches arbitrary whitespace.
Otherwise if LAX is non-nil, the beginning or the end of the string
need not match a word boundary.

Used in `word-search-forward', `word-search-backward',
`word-search-forward-lax', `word-search-backward-lax'.

(fn STRING &optional LAX)
(defalias 'word-search-regexp #[513 "\301\232\203\301\207\302\303\304\305#)\266\203\203\306\207\307\303\304\305#)\266\203\203.\306\202/\310\311\312\313\306\304#\306#\314\303\304\305#)\266\203\203L\306\202R?\205R\315Q\207" [inhibit-changing-match-data "" "\\`\\W+\\'" nil t string-match "\\W+" "\\`\\W" "\\<" mapconcat regexp-quote split-string "\\W\\'" "\\>"] 11 (#$ . 74713)])
#@1222 Search backward from point for STRING, ignoring differences in punctuation.
Set point to the beginning of the occurrence found, and return point.
An optional second argument bounds the search; it is a buffer position.
  The match found must not begin before that position.  A value of nil
  means search to the beginning of the accessible portion of the buffer.
Optional third argument, if t, means if fail just return nil (no error).
  If not nil and not t, position at limit of search and return nil.
Optional fourth argument COUNT, if a positive number, means to search
  for COUNT successive occurrences.  If COUNT is negative, search
  forward, instead of backward, for -COUNT occurrences.  A value of
  nil means the same as 1.
With COUNT positive, the match found is the COUNTth to last one (or
  last, if COUNT is 1 or nil) in the buffer located entirely before
  the origin of the search; correspondingly with COUNT negative.

Relies on the function `word-search-regexp' to convert a sequence
of words in STRING to a regexp used to search words without regard
to punctuation.
This command does not support character folding, and lax space matching
has no effect on it.

(fn STRING &optional BOUND NOERROR COUNT)
(defalias 'word-search-backward #[1025 "\300\301\302\"$\207" [re-search-backward word-search-regexp nil] 9 (#$ . 75683) "sWord search backward: "])
#@1194 Search forward from point for STRING, ignoring differences in punctuation.
Set point to the end of the occurrence found, and return point.
An optional second argument bounds the search; it is a buffer position.
  The match found must not end after that position.  A value of nil
  means search to the end of the accessible portion of the buffer.
Optional third argument, if t, means if fail just return nil (no error).
  If not nil and not t, move to limit of search and return nil.
Optional fourth argument COUNT, if a positive number, means to search
  for COUNT successive occurrences.  If COUNT is negative, search
  backward, instead of forward, for -COUNT occurrences.  A value of
  nil means the same as 1.
With COUNT positive, the match found is the COUNTth one (or first,
  if COUNT is 1 or nil) in the buffer located entirely after the
  origin of the search; correspondingly with COUNT negative.

Relies on the function `word-search-regexp' to convert a sequence
of words in STRING to a regexp used to search words without regard
to punctuation.
This command does not support character folding, and lax space matching
has no effect on it.

(fn STRING &optional BOUND NOERROR COUNT)
(defalias 'word-search-forward #[1025 "\300\301\302\"$\207" [re-search-forward word-search-regexp nil] 9 (#$ . 77064) "sWord search: "])
#@1339 Search backward from point for STRING, ignoring differences in punctuation.
Set point to the beginning of the occurrence found, and return point.

Unlike `word-search-backward', the end of STRING need not match a word
boundary, unless STRING ends in whitespace.

An optional second argument bounds the search; it is a buffer position.
  The match found must not begin before that position.  A value of nil
  means search to the beginning of the accessible portion of the buffer.
Optional third argument, if t, means if fail just return nil (no error).
  If not nil and not t, position at limit of search and return nil.
Optional fourth argument COUNT, if a positive number, means to search
  for COUNT successive occurrences.  If COUNT is negative, search
  forward, instead of backward, for -COUNT occurrences.  A value of
  nil means the same as 1.
With COUNT positive, the match found is the COUNTth to last one (or
  last, if COUNT is 1 or nil) in the buffer located entirely before
  the origin of the search; correspondingly with COUNT negative.

Relies on the function `word-search-regexp' to convert a sequence
of words in STRING to a regexp used to search words without regard
to punctuation.
This command does not support character folding, and lax space matching
has no effect on it.

(fn STRING &optional BOUND NOERROR COUNT)
(defalias 'word-search-backward-lax #[1025 "\300\301\302\"$\207" [re-search-backward word-search-regexp t] 9 (#$ . 78406) "sWord search backward: "])
#@1310 Search forward from point for STRING, ignoring differences in punctuation.
Set point to the end of the occurrence found, and return point.

Unlike `word-search-forward', the end of STRING need not match a word
boundary, unless STRING ends in whitespace.

An optional second argument bounds the search; it is a buffer position.
  The match found must not end after that position.  A value of nil
  means search to the end of the accessible portion of the buffer.
Optional third argument, if t, means if fail just return nil (no error).
  If not nil and not t, move to limit of search and return nil.
Optional fourth argument COUNT, if a positive number, means to search
  for COUNT successive occurrences.  If COUNT is negative, search
  backward, instead of forward, for -COUNT occurrences.  A value of
  nil means the same as 1.
With COUNT positive, the match found is the COUNTth one (or first,
  if COUNT is 1 or nil) in the buffer located entirely after the
  origin of the search; correspondingly with COUNT negative.

Relies on the function `word-search-regexp' to convert a sequence
of words in STRING to a regexp used to search words without regard
to punctuation.
This command does not support character folding, and lax space matching
has no effect on it.

(fn STRING &optional BOUND NOERROR COUNT)
(defalias 'word-search-forward-lax #[1025 "\300\301\302\"$\207" [re-search-forward word-search-regexp t] 9 (#$ . 79906) "sWord search: "])
#@510 Return a regexp which matches STRING as a symbol.
Creates a regexp where STRING is surrounded by symbol delimiters \_< and \_>.
If there are more than one symbol, then compute a regexp that matches
those exact symbols separated by non-symbol characters.  If the string
begins or ends in whitespace, the beginning or the end of the string
matches arbitrary non-symbol whitespace.  Otherwise if LAX is non-nil,
the beginning or the end of the string need not match a symbol boundary.

(fn STRING &optional LAX)
(defalias 'isearch-symbol-regexp #[513 "\301\302\232\203\302\202b\303\304\"\305\306\307#)\266\203\203\"\211\202b\303\310\"\305\306\307#)\266\203\2039\211\202:\311\312\313\314\306##\303\315\"\305\306\307#)\266\203\203[\202a?\205a\316Q\207" [inhibit-changing-match-data "\\(?:\\s-\\|\\s.\\|\\s(\\|\\s)\\|\\s\"\\|\\s\\\\|\\s/\\|\\s$\\|\\s'\\|\\s<\\|\\s>\\|\\s@\\|\\s!\\|\\s|\\)+" "" format "\\`%s\\'" nil t string-match "\\`%s" "\\_<" mapconcat regexp-quote split-string "%s\\'" "\\_>"] 12 (#$ . 81365)])
(put 'isearch-symbol-regexp 'isearch-message-prefix "symbol ")
#@112 Search forward for STRING, matching a sequence of whitespace chars.

(fn STRING &optional BOUND NOERROR COUNT)
(defalias 'search-forward-lax-whitespace #[1025 "\302\303!$)\207" [search-whitespace-regexp search-spaces-regexp re-search-forward regexp-quote] 9 (#$ . 82481)])
#@113 Search backward for STRING, matching a sequence of whitespace chars.

(fn STRING &optional BOUND NOERROR COUNT)
(defalias 'search-backward-lax-whitespace #[1025 "\302\303!$)\207" [search-whitespace-regexp search-spaces-regexp re-search-backward regexp-quote] 9 (#$ . 82767)])
#@112 Search forward for REGEXP, matching a sequence of whitespace chars.

(fn REGEXP &optional BOUND NOERROR COUNT)
(defalias 're-search-forward-lax-whitespace #[1025 "\302$)\207" [search-whitespace-regexp search-spaces-regexp re-search-forward] 9 (#$ . 83056)])
#@113 Search backward for REGEXP, matching a sequence of whitespace chars.

(fn REGEXP &optional BOUND NOERROR COUNT)
(defalias 're-search-backward-lax-whitespace #[1025 "\302$)\207" [search-whitespace-regexp search-spaces-regexp re-search-backward] 9 (#$ . 83327)])
(byte-code "\300\211\203\211@\301\302\303#\210A\266\202\202\207" [(re-search-forward-lax-whitespace search-backward-lax-whitespace search-forward-lax-whitespace re-search-backward-lax-whitespace) make-obsolete "instead, use (let ((search-spaces-regexp search-whitespace-regexp))\n               (re-search-... ...))" "25.1"] 6)
#@533 Start `query-replace' with string to replace from last search string.
The ARG (prefix arg if interactive), if non-nil, means replace
only matches surrounded by word boundaries.  A negative prefix
arg means replace backward.  Note that using the prefix arg
is possible only when `isearch-allow-scroll' is non-nil or
`isearch-allow-prefix' is non-nil, and it doesn't always provide the
correct matches for `query-replace', so the preferred way to run word
replacements from Isearch is `M-s w ... M-%'.

(fn &optional ARG REGEXP-FLAG)
(defalias 'isearch-query-replace #[512 "\306 \210\211\203	\307	\310\n\f\205\311=?\205!\311=\310\312\310\307\"\210\313 \210\203r\211\203K`V\202O`W\203r\203n\203n\211\203g\314 `V\202k\314 `W\204rb\210 JBL\210\315 \316 \317\320\206\213!\307\"\203\226\321\202\227\322\203\245\203\245\323\202\246\322R#\307\206\262!\310\211\205\300\205\300\324 \205\314\205\314\325 \n&\n\210.\266
\205\333\326 \207" [isearch-regexp isearch-case-fold-search isearch-invisible isearch-lax-whitespace isearch-regexp-lax-whitespace isearch-recursive-edit barf-if-buffer-read-only t nil - isearch-done isearch-clean-overlays mark perform-replace query-replace-read-to "Query replace" isearch--describe-regexp-mode " backward" "" " in region" region-beginning region-end exit-recursive-edit replace-regexp-lax-whitespace replace-lax-whitespace search-invisible search-upper-case case-fold-search isearch-other-end transient-mark-mode mark-active query-replace-from-history-variable isearch-string isearch-regexp-function] 20 (#$ . 83935) (list current-prefix-arg)])
#@148 Start `query-replace-regexp' with string to replace from last search string.
See `isearch-query-replace' for more information.

(fn &optional ARG)
(defalias 'isearch-query-replace-regexp #[256 "\300\301\"\207" [isearch-query-replace t] 4 (#$ . 85608) (list current-prefix-arg)])
#@583 Run `occur' using the last search string as the regexp.
Interactively, REGEXP is constructed using the search string from the
last search command.  NLINES has the same meaning as in `occur'.

If the last search command was a word search, REGEXP is computed from
the search words, ignoring punctuation.  If the last search
command was a regular expression search, REGEXP is the regular
expression used in that search.  If the last search command searched
for a literal string, REGEXP is constructed by quoting all the special
characters in that string.

(fn REGEXP &optional NLINES)
(defalias 'isearch-occur #[513 "\306	\203\n\n\202\205\f\f
\307\203(\310\311	\312\313!%\202)\"+\207" [isearch-case-fold-search isearch-regexp isearch-regexp-lax-whitespace isearch-lax-whitespace search-whitespace-regexp search-spaces-regexp nil occur propertize isearch-string isearch-regexp-function-descr isearch--describe-regexp-mode search-upper-case case-fold-search isearch-regexp-function] 10 (#$ . 85895) (byte-code ":\306	!\203	\n!\202#	\203\307\n!\202#\203 \n\202#\310\n!\211\203I\311!\312U\2034\313\202P\f@\314\3151@
\n%&	'()*+,-./01234567\316 8\211\314C\314C89:7654\n;
/.-,+*)(<=>\3171\305\320\321\211\"0\202\311\210\202\312\210`\240\210\211?\240\210\322\312\323\324\325\f\f&\326\"\327$\216\330\331\332 \"\304#\262)\nG\312U\203\203\f@\202A@\206\333\334\335\n\333#%\336\314!\210.\266\337 \210\340 \210\341 \210
\205<\320 \210\n\333\232\205<\342\333!0\202C\210\343 \210\262\202P\205P\344!D\207" [current-prefix-arg isearch-regexp-function isearch-string isearch-regexp occur-collect-regexp-history isearch-nonincremental functionp word-search-regexp regexp-quote regexp-opt-depth 0 "\\&" nil (quit) current-window-configuration (exit) isearch-done t make-byte-code "\310\f
\311%\210\300\301\n\f\302\305\303\304\2060\312\311\313\"\210\307\242\205K\306\242`=\205K\f=\205K\307\242b\207" vconcat vector [isearch-mode nil isearch-message t isearch-forward isearch-regexp isearch-op-fun isearch-regexp-function isearch-string isearch-new-forward isearch-new-nonincremental isearch-nonincremental isearch-new-regexp-function isearch-case-fold-search multi-isearch-current-buffer multi-isearch-file-list multi-isearch-buffer-list isearch-message-function] 6 read-regexp format "Regexp to collect (default %s): " "" mapconcat isearch-text-char-description isearch-ring-adjust1 isearch-search isearch-push-state isearch-update message isearch-abort prefix-numeric-value isearch-message isearch-forward isearch-case-fold-search isearch-op-fun isearch-cmds isearch-success isearch-wrapped isearch-barrier isearch-adjusted isearch-yank-flag isearch-error multi-isearch-file-list multi-isearch-buffer-list multi-isearch-next-buffer-current-function multi-isearch-current-buffer isearch-opoint isearch-slow-terminal-mode isearch-small-window isearch-recursive-edit isearch-original-minibuffer-message-timeout minibuffer-message-timeout isearch-window-configuration multi-isearch-next-buffer-function isearch-new-regexp-function isearch-new-forward isearch-new-nonincremental isearch-other-end regexp-search-ring search-ring] 46)])
#@262 Run `highlight-regexp' with regexp from the current search string.
It exits Isearch mode and calls `hi-lock-face-buffer' with its regexp
argument from the last search regexp or a quoted search string,
and reads its face argument using `hi-lock-read-face-name'.
(defalias 'isearch-highlight-regexp #[0 "\306\307\306\310\"\210\311 \210)\312\313\306\310#\210\314	!\203	\n!\202O	\203'\315\n!\202O\203/\n\202O\f\310=\203@
\203@\316\n\"\202A\f\203L\317\320\n\321#\202O\322\n!\323\324 \"\266\205\\\325 \207" [isearch-recursive-edit isearch-regexp-function isearch-string isearch-regexp isearch-case-fold-search search-upper-case nil isearch-done t isearch-clean-overlays require hi-lock functionp word-search-regexp isearch-no-upper-case-p mapconcat #[257 "\300!\301\302\"\203\303\304\226\227#\202\305!\207" [string string-match "[[:alpha:]]" format "[%s%s]" regexp-quote] 6 "\n\n(fn C)"] "" regexp-quote hi-lock-face-buffer hi-lock-read-face-name exit-recursive-edit] 4 (#$ . 89203) nil])
#@268 Discard last input item and move point back.
Last input means the last character or the last isearch command
that added or deleted characters from the search string,
moved point, toggled regexp mode or case-sensitivity, etc.
If no previous match was done, just beep.
(defalias 'isearch-delete-char #[0 "A\204\301 \210\202\302 \210\303 \207" [isearch-cmds ding isearch-pop-state isearch-update] 1 (#$ . 90221) nil])
#@242 Delete character from end of search string and search again.
Unlike `isearch-delete-char', it only deletes the last character,
but doesn't cancel the effect of other isearch command.
If search string is empty, just beep.

(fn &optional ARG)
(defalias 'isearch-del-char #[256 "G\304U\203
\305 \210\202 \304\206\306G^[O\307\310\311#\n\206%\301\312\313\"\210\2030b\210\314 \210\315 \210\316 \207" [isearch-string isearch-message isearch-message-function isearch-other-end 0 ding 1 mapconcat isearch-text-char-description "" nil t isearch-search isearch-push-state isearch-update] 5 (#$ . 90648) "p"])
#@46 Pull STRING into search string.

(fn STRING)
(defalias 'isearch-yank-string #[257 "\203	\304=\203\211\227\262\n\203\305!\262\306\307\310\311\312#\"\207" [isearch-case-fold-search search-upper-case isearch-regexp isearch-yank-flag not-yanks regexp-quote t isearch-process-search-string mapconcat isearch-text-char-description ""] 7 (#$ . 91267)])
#@48 Pull string from kill ring into search string.
(defalias 'isearch-yank-kill #[0 "\300\301\302!!\207" [isearch-yank-string current-kill 0] 3 (#$ . 91632) nil])
#@66 Replace just-yanked search string with previously killed string.
(defalias 'isearch-yank-pop #[0 "\301>\204	\302 \207\303 \210\304\305\306!!\207" [last-command (isearch-yank-kill isearch-yank-pop) isearch-yank-kill isearch-pop-state isearch-yank-string current-kill 1] 3 (#$ . 91797) nil])
#@46 Pull current X selection into search string.
(defalias 'isearch-yank-x-selection #[0 "\301\302 !\210\205\303 \207" [select-active-regions isearch-yank-string gui-get-selection deactivate-mark] 2 (#$ . 92095) nil])
#@205 Handle mouse-2 in Isearch mode.
For a click in the echo area, invoke `isearch-yank-x-selection'.
Otherwise invoke whatever the calling mouse-2 command sequence
is bound to outside of Isearch.

(fn CLICK)
(defalias 'isearch-mouse-2 #[257 "\301!\211@\262\302\303\304 \305\")\306!\203 \307!\204 \310 \202)\311!\205)\312!\207" [overriding-terminal-local-map event-start nil key-binding this-command-keys-vector t window-minibuffer-p minibuffer-window-active-p isearch-yank-x-selection functionp call-interactively] 5 (#$ . 92319) "e"])
#@41 Pull terminal paste into search string.
(defalias 'isearch-xterm-paste #[0 "\300\301 !\207" [isearch-yank-string xterm--pasted-text] 2 (#$ . 92868) nil])
#@333 Pull the text from point to the point reached by JUMPFORM.
JUMPFORM is a lambda expression that takes no arguments and returns
a buffer position, possibly having moved point to that position.
For example, it might move point forward by a word and return point,
or it might return the position of the end of the line.

(fn JUMPFORM)
(defalias 'isearch-yank-internal #[257 "\302\212\204
	\203
	b\210\303` \")!\207" [isearch-forward isearch-other-end isearch-yank-string buffer-substring-no-properties] 5 (#$ . 93029)])
#@94 Pull next character from buffer into end of search string in minibuffer.

(fn &optional ARG)
(defalias 'isearch-yank-char-in-minibuffer #[256 "m\203r\300 A@q\210\301`u\210`\")c\207\211u\207" [buffer-list buffer-substring-no-properties] 4 (#$ . 93556) "p"])
#@134 Pull next character from buffer into search string.
If optional ARG is non-nil, pull in the next ARG characters.

(fn &optional ARG)
(defalias 'isearch-yank-char #[256 "\300\301\302\303\304\305!\306\"\307$!\207" [isearch-yank-internal make-byte-code 0 "\300u\210`\207" vconcat vector [] 1] 8 (#$ . 93823) "p"])
#@121 Pull next character, subword or word from buffer into search string.
Subword is used when `subword-mode' is activated. 
(defalias 'isearch-yank-word-or-char #[0 "\300\301!\207" [isearch-yank-internal #[0 "\302f\206\303z\304U\204`Tf\206\303z\304U\203:\305\300!\203#\204-\305\301!\2034	\2034\306\307!\210\202=\307v\210\202=\307u\210`\207" [subword-mode superword-mode nil 0 119 boundp subword-forward 1] 2]] 2 (#$ . 94143) nil])
#@124 Pull next word from buffer into search string.
If optional ARG is non-nil, pull in the next ARG words.

(fn &optional ARG)
(defalias 'isearch-yank-word #[256 "\300\301\302\303\304\305!\306\"\307$!\207" [isearch-yank-internal make-byte-code 0 "\300v\210`\207" vconcat vector [] 1] 8 (#$ . 94591) "p"])
#@124 Pull rest of line from buffer into search string.
If optional ARG is non-nil, yank the next ARG lines.

(fn &optional ARG)
(defalias 'isearch-yank-line #[256 "\300\301\302\303\304\305!\306\"\307$!\207" [isearch-yank-internal make-byte-code 0 "\302\303l\203\f\300T\202
\300!)\207" vconcat vector [inhibit-field-text-motion t line-end-position] 2] 8 (#$ . 94901) "p"])
#@218 Read a character by its Unicode name and add it to the search string.
Completion is available like in `read-char-by-name' used by `insert-char'.
With argument, add COUNT copies of the character.

(fn &optional COUNT)
(defalias 'isearch-char-by-name #[256 "\3061/	C\nC\f
!\"#$%&'()*+,-./01\307 2\211\310C\310C23410/.\n5
)('&%$#\"!678\3111\217\312\313\211\"0\202\223\210\202\224\210`\240\210\2119\240\210\314\315\316\317\320\f\f&\321\"\322$\216\323\324!\211\203\353\250\203\325\325V\203\325\326\"\202\330\327!	P\240\210\n\330\331\332#P\240\266\210)	G\315U\203!\203\376:\202;@\206\332\330\331	\332#\333\310!\210.\266\334 \210\335 \210\336 \210\205-\312 \210	\332\232\205-\337\332!0\207\210\340 \207" [isearch-nonincremental isearch-string isearch-message isearch-forward isearch-regexp-function isearch-case-fold-search (quit) current-window-configuration nil (exit) isearch-done t make-byte-code 0 "\310\f
\311%\210\300\242\301\242\n\f\302\305\303\304\2062\312\311\313\"\210\307\242\205M\306\242`=\205M\f=\205M\307\242b\207" vconcat vector [isearch-mode nil isearch-message t isearch-forward isearch-regexp isearch-op-fun isearch-regexp-function isearch-string isearch-new-forward isearch-new-nonincremental isearch-nonincremental isearch-new-regexp-function isearch-case-fold-search multi-isearch-current-buffer multi-isearch-file-list multi-isearch-buffer-list isearch-message-function] 6 read-char-by-name "Add character to search (Unicode name or hex): " 1 make-string char-to-string mapconcat isearch-text-char-description "" isearch-ring-adjust1 isearch-search isearch-push-state isearch-update message isearch-abort isearch-regexp isearch-op-fun isearch-cmds isearch-success isearch-wrapped isearch-barrier isearch-adjusted isearch-yank-flag isearch-error multi-isearch-file-list multi-isearch-buffer-list multi-isearch-next-buffer-current-function multi-isearch-current-buffer isearch-opoint isearch-slow-terminal-mode isearch-small-window isearch-recursive-edit isearch-original-minibuffer-message-timeout minibuffer-message-timeout isearch-window-configuration multi-isearch-next-buffer-function isearch-new-regexp-function isearch-new-forward isearch-new-nonincremental isearch-other-end regexp-search-ring search-ring] 42 (#$ . 95280) "p"])
(defalias 'isearch-search-and-update #[0 "\204	\204\n\306\203\276\204\224\f\204\224\3071`
\211\310=\203/\203/\311	\"\312\313!\203@\310\"\202Z\203M\314\310\"\202Z	\203V\202Z\315!!)0\202d\210\202\224\203\224\204w\316\225^X\203\224\310\306\316\225
\310=\203\276\203\276\311	\"\202\276\206\232\317\306\310\"\210\203\273\f\204\273\203\260\202\271^T^b\210\320 \210\321 \210\203\312 \210\322 \207" [isearch-success isearch-regexp isearch-hidden isearch-forward isearch-adjusted isearch-case-fold-search nil (error) t isearch-no-upper-case-p looking-at functionp word-search-regexp regexp-quote 0 isearch-message isearch-search isearch-push-state isearch-update case-fold-search search-upper-case isearch-string isearch-regexp-function isearch-yank-flag isearch-opoint isearch-barrier isearch-error isearch-other-end isearch-message-function isearch-op-fun] 5])
#@65 Return t if STR ends in an odd number of backslashes.

(fn STR)
(defalias 'isearch-backslash #[257 "\300G\301\302\"Z\303\"\304U\207" [mod string-match "\\\\*\\'" 2 1] 6 (#$ . 98647)])
#@571 Return point to previous successful match to allow regexp liberalization.
\<isearch-mode-map>
Respects \[isearch-repeat-forward] and \[isearch-repeat-backward] by stopping at `isearch-barrier' as needed.

Do nothing if a backslash is escaping the liberalizing character.
If WANT-BACKSLASH is non-nil, invert this behavior (for \} and \|).

Do nothing if regexp has recently been invalid unless optional
ALLOW-INVALID non-nil.

If optional TO-BARRIER non-nil, ignore previous matches and go exactly
to the barrier.

(fn WANT-BACKSLASH &optional ALLOW-INVALID TO-BARRIER)
(defalias 'isearch-fallback #[769 "\205\342\306	!??=\205\342\n\2030A@\307!\f>\204$\310\311\312D\"\210\211\313H\262\2030\205\342\211\203<
b\210\314\211\207\211A@\203\250\307!\f>\204T\310\311\312D\"\210\211\313H\204\232\307!\f>\204i\310\311\312D\"\210\211\315H\211GSH\306\307@!\f>\204\204\310\311\312@D\"\210@\315H!\203\222\211\316=\202\225\211\317>\266\202\203\250\262A\262@\262\202A\205\340@\203\311\307@!\f>\204\302\310\311\312@D\"\210@\320H\206\312
\203\325\211
]\202\330\211
^b\210\314\211\262\266\203\207" [isearch-regexp isearch-string isearch-error isearch-cmds cl-struct-isearch--state-tags isearch-barrier isearch-backslash type-of signal wrong-type-argument isearch--state 8 t 1 125 (42 63 43) 6 isearch-adjusted isearch-forward] 13 (#$ . 98840)])
(byte-code "\300\301!\203\f\302\301\303\304#\210\300\305!\203\302\305\303\304#\210\302\306\303\304#\210\302\307\303\304#\210\302\310\303\304#\210\302\311\303\304#\210\302\312\303\304#\210\302\313\303\304#\210\302\314\303\304#\210\302\315\303\304#\210\302\316\303\304#\210\302\317\303\304#\210\302\320\303\304#\210\302\321\303\304#\210\302\322\303\304#\210\302\323\303\304#\210\302\324\303\304#\210\302\325\303\304#\210\302\326\303\304#\210\302\327\303\304#\210\302\330\303\304#\210\331\332\333\334\335DD\336\337\340\341\342&\210\331\343\333\334\344DD\345\346\347\337\340\341\342&	\207" [fboundp scroll-bar-toolkit-scroll put isearch-scroll t w32-handle-scroll-bar-event recenter recenter-top-bottom reposition-window list-buffers scroll-other-window scroll-other-window-down beginning-of-buffer-other-window end-of-buffer-other-window delete-other-windows balance-windows split-window-right split-window-below enlarge-window split-window-vertically split-window-horizontally universal-argument universal-argument-more negative-argument digit-argument custom-declare-variable isearch-allow-scroll funcall function #[0 "\300\207" [nil] 1] "Whether scrolling is allowed during incremental search.\nIf non-nil, scrolling commands can be used in Isearch mode.\nHowever, the current match will never scroll offscreen.\nIf nil, scrolling commands will first cancel Isearch mode." :type boolean :group isearch isearch-allow-prefix #[0 "\300\207" [t] 1] "Whether prefix arguments are allowed during incremental search.\nIf non-nil, entering a prefix argument will not terminate the\nsearch.  This option is ignored (presumed t) when\n`isearch-allow-scroll' is set." :version "24.4"] 10)
#@299 Test whether the search string is currently outside of the window.
Return nil if it's completely visible, or if point is visible,
together with as much of the search string as will fit; the symbol
`above' if we need to scroll the text downwards; the symbol `below',
if upwards.

(fn ISEARCH-POINT)
(defalias 'isearch-string-out-of-window #[257 "\302 \303\304\305\"\212\306 r\307\310\311\312\313!\314\"\315$\216\316\317!\210`*\262)\212\306 r\307\310\311\312\313!\320\"\315$\216\316\321!\210`*\262)\304\211\203M\262	\206H\262\202Y\262	\206W\262Y\203f\211X\204\207\203xY\203\213W\202\204Y\203\213W\203\213\304\202\236W\203\235W\203\235\322\202\236\323\207" [isearch-forward isearch-other-end window-group-start window-group-end nil t internal--before-save-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-save-selected-window] 2 move-to-window-group-line 1 [internal--after-save-selected-window] -1 above below] 11 (#$ . 101915)])
#@237 Scroll the window to bring the search string back into view.
Restore point to ISEARCH-POINT in the process.  ABOVE is t when the
search string is above the top of the window, nil when it is beneath
the bottom.

(fn ABOVE ISEARCH-POINT)
(defalias 'isearch-back-into-window #[514 "\302\211\203\262	\206\262\202\262	\206\262\203;b\210\303\304!\210\305\302\306\"Y\203Pb\210\303\307!\210\202P\211b\210\303\307!\210\310 W\203Pb\210\303\304!\210\266\211b\207" [isearch-forward isearch-other-end nil recenter-window-group 0 window-group-end t -1 window-group-start] 8 (#$ . 102938)])
(defvar isearch-pre-scroll-point nil)
#@460 Decide whether to exit Isearch mode before executing the command.
Don't exit Isearch if the key sequence that invoked this command
is bound in `isearch-mode-map', or if the invoked command is
a prefix argument command (when `isearch-allow-prefix' is non-nil),
or it is a scrolling command (when `isearch-allow-scroll' is non-nil).
Otherwise, exit Isearch (when `search-exit-option' is non-nil)
before the command is executed globally with terminated Isearch.
(defalias 'isearch-pre-command-hook #[0 "\306 \211\307H	=?\206~\310\311\n\312#!\206~\313=\203\"\314\211\202~
\203,\f\315>\204F\203R\f9\203R\f\316N\317=\204F\f\320N\317=\203R\205~`\211\202~\211\242\321=\203n\322\323!\211@\262!\203n\324 \210\314\211\202~\203z\325 \210\326 \202~\327\211\"\207" [overriding-terminal-local-map isearch--saved-overriding-local-map isearch-mode-map search-exit-option this-command isearch-allow-prefix this-single-command-keys 0 commandp lookup-key nil edit isearch-edit-string (universal-argument universal-argument-more digit-argument negative-argument) isearch-scroll t scroll-command down-mouse-1 window-minibuffer-p event-start read-event isearch-done isearch-clean-overlays isearch-process-search-string isearch-allow-scroll isearch-pre-scroll-point] 7 (#$ . 103587)])
(defalias 'isearch-post-command-hook #[0 "\205\301!\211\203\302\303=\"\210\202b\210\210\304\305 \207" [isearch-pre-scroll-point isearch-string-out-of-window isearch-back-into-window above nil isearch-update] 4])
#@122 Quote special characters for incremental search.
With argument, add COUNT copies of the character.

(fn &optional COUNT)
(defalias 'isearch-quote-char #[256 "\303\304\305!!\306!\204\307\310\311\312!!\"\210\2038	\2038\211\313U\2038\314\n\211G\"\2031\315\316\317\"\202<\320\"\202<\320\"\207" [isearch-regexp isearch-regexp-lax-whitespace isearch-string read-quoted-char isearch-message t characterp user-error "%s is not a valid character" key-description vector 32 subregexp-context-p isearch-process-search-string "[ ]" " " isearch-process-search-char] 7 (#$ . 105111) "p"])
#@143 Add this ordinary printing CHAR to the search string and search.
With argument, add COUNT copies of the character.

(fn &optional CHAR COUNT)
(defalias 'isearch-printing-char #[512 "\206\211\302U\203\303\262	\203\304\"\202\305\"\207" [last-command-event current-input-method 33554464 32 isearch-process-search-multibyte-characters isearch-process-search-char] 6 (#$ . 105708) (byte-code "\302	!D\207" [last-command-event current-prefix-arg prefix-numeric-value] 3)])
#@103 Add CHAR to the search string, COUNT times.
Search is updated accordingly.

(fn CHAR &optional COUNT)
(defalias 'isearch-process-search-char #[513 "\300>\203
\301\302!\210\202'\303=\203\301\304\211\"\210\202'\305=\203'\301\304\302\304#\210\211\250\2039\211\306V\2039\307\"\202<\310!\311Y\203F\211\202K\312\313\314#\315\"\207" [(42 63) isearch-fallback nil 125 t 124 1 make-string char-to-string 128 mapconcat isearch-text-char-description "" isearch-process-search-string] 7 (#$ . 106198)])
#@23 

(fn STRING MESSAGE)
(defalias 'isearch-process-search-string #[514 "P	P\302 \207" [isearch-string isearch-message isearch-search-and-update] 4 (#$ . 106716)])
#@16 

(fn ADVANCE)
(defalias 'isearch-ring-adjust1 #[257 "\203	\202	\n\211G\203\305\202\306\307!\310U?\205K\311\206.\203-\310\202.\312\2037\312\2028\313\\\"\211\262L\210\2118\314\315\316#\211\207" [isearch-regexp regexp-search-ring search-ring isearch-string isearch-message regexp-search-ring-yank-pointer search-ring-yank-pointer eval 0 mod -1 1 mapconcat isearch-text-char-description ""] 9 (#$ . 106888)])
#@16 

(fn ADVANCE)
(defalias 'isearch-ring-adjust #[257 "\302!\210\203	\206
\303\304\305\"\210\306 \210\307 \210\310 \207\311 \207" [search-ring-update isearch-message-function isearch-ring-adjust1 isearch-message nil t isearch-search isearch-push-state isearch-update isearch-edit-string] 4 (#$ . 107329)])
#@48 Advance to the next search string in the ring.
(defalias 'isearch-ring-advance #[0 "\300\301!\207" [isearch-ring-adjust advance] 2 (#$ . 107644) nil])
#@52 Retreat to the previous search string in the ring.
(defalias 'isearch-ring-retreat #[0 "\300\301!\207" [isearch-ring-adjust nil] 2 (#$ . 107801) nil])
(defalias 'isearch-complete1 #[0 "\203	\202	\n\306
\"\211\307=\203\307\202z\211\204$
G\310U\203u\211
\232\203k\203gr\311\312!q\210p\313 \210\314\211\307\211\307\315 \210\316\317!\210+\211\320\321
\"!\210\322!\210)\266\307\202z\211\205z\211\211\202z\323\324!\210\314)\207" [isearch-regexp regexp-search-ring search-ring case-fold-search completion-ignore-case isearch-string try-completion t 0 get-buffer-create "*Isearch completions*" kill-all-local-variables nil erase-buffer run-hooks temp-buffer-setup-hook display-completion-list all-completions internal-temp-output-buffer-show message "No completion" completion-auto-help default-directory buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only standard-output] 9])
#@189 Complete the search string from the strings on the search ring.
The completed string is then editable in the minibuffer.
If there is no completion possible, say so and continue searching.
(defalias 'isearch-complete #[0 "\302 \203\303\304\305#\306 \207\307\310!\210\311 \207" [isearch-string isearch-message isearch-complete1 mapconcat isearch-text-char-description "" isearch-edit-string sit-for 1 isearch-update] 4 (#$ . 108763) nil])
#@54 Same as `isearch-complete' except in the minibuffer.
(defalias 'isearch-complete-edit #[0 "\301 \302 \205
\303 \210c\207" [isearch-string field-string isearch-complete1 delete-field] 1 (#$ . 109210) nil])
#@36 

(fn &optional C-Q-HACK ELLIPSIS)
(defalias 'isearch-message #[512 "\211\304\305!\211\203(\306!\262\307G\310$\210\311\312\"\203(\307\313\224\313\225\314$\210\315\n\"\316!Q\262\203<\202C\317\320\321\"))\207" [isearch-message cursor-in-echo-area isearch-nonincremental message-log-max isearch-fail-pos t copy-sequence add-text-properties (face isearch-fail) string-match " +$" 0 (face trailing-whitespace) isearch-message-prefix isearch-message-suffix nil message "%s"] 10 (#$ . 109424)])
#@173 Make a string for describing REGEXP-FUNCTION.
If SPACE-BEFORE is non-nil, put a space before, instead of after,
the word mode.

(fn REGEXP-FUNCTION &optional SPACE-BEFORE)
(defalias 'isearch--describe-regexp-mode #[513 "\302=\203	\303\262\203\232\204\302=\203#	=\203#\304\202I\20369\205I\305N\206I\304\202I	\203>\306\202I\307!\203H\310\202I\304\203U\311\312\313#\202V\211\207" [search-default-mode isearch-regexp t word-search-regexp "" isearch-message-prefix "regexp " functionp "literal " replace-regexp-in-string "\\(.*\\) \\'" " \\1"] 7 (#$ . 109942)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias isearch--describe-word-mode isearch--describe-regexp-mode nil make-obsolete "25.1"] 4)
#@42 

(fn &optional ELLIPSIS NONINCREMENTAL)
(defalias 'isearch-message-prefix #[512 "\203\203\3061\307	`\310#\210\311\2110\202\210\202\210\n\204%\311\262\n\203-\312\202.\313\2036\314\2027\312\f\205T
?\205T'\203L`(V\202P`(W\205T\315\f\205Y\316\312C\317\320\321\322\323\324!\325\"\326\327%)\"\210\211\242\262\330*!+\203~\331\202\210,\203\207\332\202\210\312-\206\216\312\203\227\333\202\230\334'\203\241\312\202\242\335.\203\261\336\337/\340Q!\202\262\341\260\342\343\344O\226\344\311OP\345\346#\207" [isearch-error isearch-string isearch-success isearch-adjusted isearch-wrapped isearch-wrap-function (error) re-search-forward t nil "" "failing " "pending " "over" "wrapped " advice-function-mapc make-byte-code 514 "\301\236A\211\205\300\300\242P\240\207" vconcat vector [isearch-message-prefix] 6 "\n\n(fn _ PROPS)" isearch--describe-regexp-mode "multi-file " "multi-buffer " "search" "I-search" " backward" bidi-string-mark-left-to-right " [" "]: " ": " propertize 0 1 face minibuffer-prompt isearch-forward isearch-opoint isearch-filter-predicate isearch-regexp-function multi-isearch-file-list multi-isearch-buffer-list isearch-message-prefix-add current-input-method current-input-method-title] 16 (#$ . 110689)])
#@27 

(fn &optional C-Q-HACK)
(defalias 'isearch-message-suffix #[256 "\211\203\302\202	\303\203\304\305Q\202\303	\206\303Q\207" [isearch-error isearch-message-suffix-add "^Q" "" " [" "]"] 5 (#$ . 111971)])
#@469 Non-default value overrides the behavior of `isearch-search-fun-default'.
This variable's value should be a function, which will be called
with no arguments, and should return a function that takes three
arguments: STRING, BOUND, and NOERROR.  STRING is the string to
be searched for.  See `re-search-forward' for the meaning of
BOUND and NOERROR arguments.

This returned function will be used by `isearch-search-string' to
search for the first occurrence of STRING.
(defvar isearch-search-fun-function 'isearch-search-fun-default (#$ . 112192))
#@112 Return the function to use for the search.
Can be changed via `isearch-search-fun-function' for special needs.
(defalias 'isearch-search-fun #[0 "\206\301 \207" [isearch-search-fun-function isearch-search-fun-default] 1 (#$ . 112746)])
#@53 Non-nil if next regexp-function call should be lax.
(defalias 'isearch--lax-regexp-function-p #[0 "\206#	@?\206#\nG\304	@!>\204\305\306\307	@D\"\210	@\310HG=?\207" [isearch-nonincremental isearch-cmds isearch-string cl-struct-isearch--state-tags type-of signal wrong-type-argument isearch--state 1] 5 (#$ . 112991)])
#@49 Return default functions to use for the search.
(defalias 'isearch-search-fun-default #[0 "\300\207" [#[1025 "\203	\202	\n\205
\3061[
\203\307\202\310\203H?\205'\311 \211\203.\312\313!\203>\"\202C\314\"\262\202S\203P\202S\315!$0\202}\316@\317N\203v\211;\203v\320\321	#C\202xA\262\"\262)\207" [isearch-regexp isearch-regexp-lax-whitespace isearch-lax-whitespace search-whitespace-regexp search-spaces-regexp isearch-forward (search-failed) re-search-forward re-search-backward isearch--lax-regexp-function-p t functionp word-search-regexp regexp-quote signal isearch-message-prefix format "%s   [using %ssearch]" isearch-regexp-function isearch-adjusted] 12 "\n\n(fn STRING &optional BOUND NOERROR COUNT)"]] 1 (#$ . 113320)])
#@535 Search for the first occurrence of STRING or its translation.
STRING's characters are translated using `translation-table-for-input'
if that is non-nil.
If found, move point to the end of the occurrence,
update the match data, and return point.
An optional second argument bounds the search; it is a buffer position.
The match found must not extend after that position.
Optional third argument, if t, means if fail just return nil (no error).
  If not nil and not t, move to limit of search and return nil.

(fn STRING BOUND NOERROR)
(defalias 'isearch-search-string #[771 "\305 \212\211#)\306\307!\203y\310!\203y\311\306\312\313#)\266\203\203y\314\315\316\317	\"\"\306\203w\320 \321\322\323\324\325!\326\"\327$\216\212		#\211\262\203V\320\312!\262*\210\203w\203p\n\203jW\202mV\203w\262\330!\210\266\205\217\203\213\331\f!\203\213\332\f!\210b\210\207" [translation-table-for-input inhibit-changing-match-data isearch-forward multi-isearch-next-buffer-current-function multi-isearch-current-buffer isearch-search-fun nil char-table-p multibyte-string-p "[^[:ascii:]]" t string-match apply string mapcar #[257 "H\206\211\207" [translation-table-for-input] 3 "\n\n(fn C)"] match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 set-match-data buffer-live-p switch-to-buffer] 15 (#$ . 114108)])
(defalias 'isearch-search #[0 "\306=\203	\203\307\n\"\3101\343\3111\324\3121\222\3131\202\f\314\f\306#$%\314&\211\203a\315\n\314\306#\211'\203[o\204[m\204[\316\224\316\225U\204[(\316\224\316\225\"\2032\314\262\2022\314)'\205x*\203s\316\224\202u\316\225\211+,\266\2050000\202\354000\317\320!\210\314\211'\262\202\35400\211A@&\321\322&\"\203\250\323\211&\202\317?\205\317\321\324&\"\205\317,\203\301\325\211&\202\317-\205\317.\205\317\326\211&\262\202\3540\314'\3278\211&\262\202\354\330\331\"\211&\262\210'?\205h\332/@!0>\204\333\334\335/@D\"\210/@\336H\203\337 \210\340\332/@!0>\204'\333\334\335/@D\"\210/@\341H!\203N\332/@!0>\204D\333\334\335/@D\"\210/@\341H/@!\210\332/@!0>\204b\333\334\335/@D\"\210/@\342Hb\207" [isearch-case-fold-search search-upper-case isearch-string isearch-regexp isearch-invisible search-invisible t isearch-no-upper-case-p (error) (search-failed) (invalid-regexp) (quit) nil isearch-search-string 0 isearch-unread 7 string-match "\\`Premature \\|\\`Unmatched \\|\\`Invalid " "incomplete input" "\\`Regular expression too big" "Too many words" "Too many spaces for whitespace matching" 2 format "%s" type-of signal wrong-type-argument isearch--state 4 ding functionp 12 3 case-fold-search inhibit-quit inhibit-point-motion-hooks isearch-error isearch-success isearch-filter-predicate isearch-just-started isearch-forward isearch-other-end isearch-regexp-function isearch-lax-whitespace search-whitespace-regexp isearch-cmds cl-struct-isearch--state-tags] 10])
#@11 

(fn OV)
(defalias 'isearch-open-overlay-temporary #[257 "\300\301\"\203\300\301\"\302\"\207\303\304\300\305\"#\210\303\305\302#\207" [overlay-get isearch-open-invisible-temporary nil overlay-put isearch-invisible invisible] 7 (#$ . 117078)])
#@11 

(fn OV)
(defalias 'isearch-open-necessary-overlays #[257 "`\300!V\205
`\301!X\302\303\"\204\211\204)\304\305\302\306\"#\210\304\306\307#\210\2036\302\310\"!\202>\211\205>\211\311\"\207" [overlay-start overlay-end overlay-get isearch-open-invisible-temporary overlay-put invisible isearch-invisible nil isearch-open-invisible t] 9 (#$ . 117336)])
(defalias 'isearch-clean-overlays #[0 "\205\f\301\302\"\210\303\211\207" [isearch-opened-overlays mapc isearch-open-necessary-overlays nil] 3])
#@92 Return t if regions START0..END0 and START1..END1 intersect.

(fn START0 END0 START1 END1)
(defalias 'isearch-intersects-p #[1028 "Y\203\fW\206-V\203X\206-Y\203$W\206-\211V\205-\211X\207" [] 6 (#$ . 117857)])
#@18 

(fn BEGIN END)
(defalias 'isearch-close-unnecessary-overlays #[514 "\301\211\211\205E\211@\302\303!\304!$\203\211B\202>\305\306\"\211\203.\211\307\"\210\202=\310\311\305\312\"#\210\310\312\301#\210\210A\266\202\202\262\207" [isearch-opened-overlays nil isearch-intersects-p overlay-start overlay-end overlay-get isearch-open-invisible-temporary t overlay-put invisible isearch-invisible] 12 (#$ . 118094)])
#@70 Return t if all the text from BEG to END is invisible.

(fn BEG END)
(defalias 'isearch-range-invisible #[514 "U?\205\257\212b\210\304=\305\203	\203\306\"\210`W\203\214\307`!\203\214\307\310`\311\"!\203@\312`\311\305$b\210\305\262\202\203\204\313`!\305\211\211\203w@\262\314\311\"\262\307!\203p\314\315\"\203mB\262\202p\305\262A\262\202J\203\202\316\"\262\266\317`!b\210\202`Y\205\254\203\251\211:\203\251\316\n\"\320\321\"\210\305\202\254\322\211\266\202)\207" [search-invisible isearch-hide-immediately isearch-opened-overlays isearch-hidden open nil isearch-close-unnecessary-overlays invisible-p get-text-property invisible next-single-property-change overlays-at overlay-get isearch-open-invisible append next-overlay-change mapc isearch-open-overlay-temporary t] 11 (#$ . 118532)])
#@262 Test whether the current search hit is visible at least partially.
Return non-nil if the text from BEG to END is visible to Isearch as
determined by `isearch-range-invisible' unless invisible text can be
searched too when `search-invisible' is t.

(fn BEG END)
(defalias 'isearch-filter-visible #[514 "\301=\206\302\"?\207" [search-invisible t isearch-range-invisible] 5 (#$ . 119387)])
#@200 Return t if there are no upper case chars in STRING.
If REGEXP-FLAG is non-nil, disregard letters preceded by `\' (but not `\\')
since they have special meaning in a regexp.

(fn STRING REGEXP-FLAG)
(defalias 'isearch-no-upper-case-p #[514 "\300\301G\300\211\204<W\203<H\203#\211\302=\203#?\262\2024\2041\211\227=\2041\303\262\300\262\210T\262\202\211\206f\205f\304\305\"\205f\3061_\304\301\211\224O\307\"\210\3000\202f\211A@\310\232\262?\207" [nil 0 92 t string-match "\\[:\\(upp\\|low\\)er:]" (invalid-regexp) "" "Unmatched [ or [^"] 10 (#$ . 119786)])
#@10 

(fn C)
(defalias 'isearch-text-char-description #[257 "\211\300W\203\301\302!\303\301\304\305\306\\\"\307\310##\207\211\311U\203*\301\302!\303\301\312\307\310##\207\302!\207" [32 propertize char-to-string display format "^%c" 64 face escape-glyph 127 "^?"] 9 (#$ . 120381)])
#@29 

(fn &rest CHAR-OR-EVENTS)
(defalias 'isearch-unread #[128 "\301\302\"\210\303\"\211\207" [unread-command-events mapc store-kbd-macro-event append] 4 (#$ . 120672)])
(defvar isearch-overlay nil)
#@16 

(fn BEG END)
(defalias 'isearch-highlight #[514 "\205	\203\303	p$\207\304\"\305	\306\307#\210\305	\310\n#\207" [search-highlight isearch-overlay isearch-face move-overlay make-overlay overlay-put priority 1001 face] 7 (#$ . 120878)])
(defalias 'isearch-dehighlight #[0 "\205\301!\207" [isearch-overlay delete-overlay] 2])
(defvar isearch-lazy-highlight-overlays nil)
(defvar isearch-lazy-highlight-wrapped nil)
(defvar isearch-lazy-highlight-start-limit nil)
(defvar isearch-lazy-highlight-end-limit nil)
(defvar isearch-lazy-highlight-start nil)
(defvar isearch-lazy-highlight-end nil)
(defvar isearch-lazy-highlight-timer nil)
(defvar isearch-lazy-highlight-last-string nil)
(defvar isearch-lazy-highlight-window nil)
(defvar isearch-lazy-highlight-window-group nil)
(defvar isearch-lazy-highlight-window-start nil)
(defvar isearch-lazy-highlight-window-end nil)
(defvar isearch-lazy-highlight-case-fold-search nil)
(defvar isearch-lazy-highlight-regexp nil)
(defvar isearch-lazy-highlight-lax-whitespace nil)
(defvar isearch-lazy-highlight-regexp-lax-whitespace nil)
(defvar isearch-lazy-highlight-regexp-function nil)
(byte-code "\300\301\302\303#\210\304\211\203(\211@\301N\203!\302N\204!\305\302\301N#\210A\266\202\202\210\306\301\302\307#\207" [defvaralias isearch-lazy-highlight-word isearch-lazy-highlight-regexp-function nil (saved-value saved-variable-comment) put make-obsolete-variable "25.1"] 7)
(defvar isearch-lazy-highlight-forward nil)
(defvar isearch-lazy-highlight-error nil)
#@346 Stop lazy highlighting and remove extra highlighting from current buffer.
FORCE non-nil means do it whether or not `lazy-highlight-cleanup' is nil.
PROCRASTINATE non-nil means postpone cleanup to a later time.
This function is called when exiting an incremental search if
`lazy-highlight-cleanup' is non-nil.

(fn &optional FORCE PROCRASTINATE)
(defalias 'lazy-highlight-cleanup #[512 "\204\203\211\204	\203\303	@!\210	A\211\204\n\205'\304\n!\210\305\211\207" [lazy-highlight-cleanup isearch-lazy-highlight-overlays isearch-lazy-highlight-timer delete-overlay cancel-timer nil] 5 (#$ . 122407) '(t)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias isearch-lazy-highlight-cleanup lazy-highlight-cleanup nil make-obsolete "22.1"] 4)
#@321 Cleanup any previous `lazy-highlight' loop and begin a new one.
BEG and END specify the bounds within which highlighting should occur.
This is called when `isearch-update' is invoked (which can cause the
search string to change or the window to scroll).  It is also used
by other Emacs features.

(fn &optional BEG END)
(defalias 'isearch-lazy-highlight-new-loop #[512 "?\205\273\306\307!\205\273	\n\232\203_\310 >\203_\f
=\203_=\203_=\203_=\203_=\203_\311 U\203_\312 U\203_=\203_\232?\205\273\313\314	\315\232?\"\210 \211!\310 \"\316 \311 \312 #\206\206`#\206\216`$\317%	
	\315\232?\205\273\320&\317\321#\211'\207" [executing-kbd-macro isearch-string isearch-lazy-highlight-last-string isearch-lazy-highlight-window-group isearch-lazy-highlight-case-fold-search isearch-case-fold-search sit-for 0 selected-window window-group-start window-group-end lazy-highlight-cleanup t "" selected-window-group nil run-with-idle-timer isearch-lazy-highlight-start isearch-lazy-highlight-regexp isearch-regexp isearch-lazy-highlight-regexp-function isearch-regexp-function isearch-lazy-highlight-lax-whitespace isearch-lax-whitespace isearch-lazy-highlight-regexp-lax-whitespace isearch-regexp-lax-whitespace isearch-lazy-highlight-window-start isearch-lazy-highlight-window-end isearch-forward isearch-lazy-highlight-forward isearch-error isearch-lazy-highlight-error isearch-lazy-highlight-start-limit isearch-lazy-highlight-end-limit isearch-lazy-highlight-window isearch-other-end isearch-lazy-highlight-end isearch-lazy-highlight-wrapped lazy-highlight-initial-delay isearch-lazy-highlight-timer] 6 (#$ . 123179)])
#@137 Search ahead for the next or previous match, for lazy highlighting.
Attempt to do the search exactly the way the pending Isearch would.
(defalias 'isearch-lazy-highlight-search #[0 "\3061\222	\n\f
\307\310\307
\203,
\206d\203&GS\\\202(\311 ^\202D\2062e\203AGSZ\202C\312 ]	\203\213\313\310#\262\203\205`U\204\205\314\224\314\225U\204\205\314\224\314\225\"\203]\307\262\202].\266\2120\207\210\307\207" [isearch-lazy-highlight-case-fold-search isearch-lazy-highlight-regexp isearch-lazy-highlight-regexp-function isearch-lazy-highlight-lax-whitespace isearch-lazy-highlight-regexp-lax-whitespace isearch-lazy-highlight-forward (error) nil t window-group-end window-group-start isearch-search-string 0 isearch-lazy-highlight-end-limit isearch-lazy-highlight-wrapped isearch-lazy-highlight-start isearch-lazy-highlight-last-string isearch-lazy-highlight-start-limit isearch-lazy-highlight-end search-invisible isearch-forward isearch-regexp-lax-whitespace isearch-lax-whitespace isearch-regexp-function isearch-regexp case-fold-search isearch-filter-predicate] 14 (#$ . 124883)])
#@43 Start a new lazy-highlight updating loop.
(defalias 'isearch-lazy-highlight-start #[0 "\300\301!\210\302 \207" [lazy-highlight-cleanup t isearch-lazy-highlight-update] 2 (#$ . 126033)])
#@58 Update highlighting of other matches for current search.
(defalias 'isearch-lazy-highlight-update #[0 "\306\307\3101/\307\311 r\312\313\314\315\316!\317\"\320$\216\321\n!\203)\322 >\204)\323\n!\210\212\324 \312\313\325\315\316!\326\"\327$\216\f\203@
\202B)b\210\203\330 \203[S\262\313X\203[\307\262\211\203\331\313\224\313\225U\203\246\f\203\212*\203x)\202z\331 U\203\204\307\262\202\313\332u\210\202\313*\203\224
\202\226\333 U\203\240\307\262\202\313\334u\210\202\313\335\"\211+B+\336\337\340#\210\336\341\342#\210,\343=\204\312\336\344\322 #\210\210\f\203\324`\202\327`)\266\211\204*\203\353\307\262\306\262\202\306*\f\203\333 -\206\373e\333 ]b\210\202\331 ).\206
d\331 ^b\210\210\202D?\205$\345/\307\346#\2110)\262+\262)0\2026\210\3061\347\350!\207" [lazy-highlight-max-at-a-time inhibit-quit isearch-lazy-highlight-window isearch-lazy-highlight-window-group isearch-lazy-highlight-forward isearch-lazy-highlight-end t nil (quit) internal--before-save-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-save-selected-window] 2 window-live-p selected-window select-window match-data "\301\300\302\"\207" [set-match-data evaporate] 3 isearch-lazy-highlight-search window-group-end 1 window-group-start -1 make-overlay overlay-put priority 1000 face lazy-highlight all-windows window run-at-time isearch-lazy-highlight-update eval (ignore nil) isearch-lazy-highlight-start isearch-lazy-highlight-wrapped isearch-lazy-highlight-overlays isearch-lazy-highlight isearch-lazy-highlight-start-limit isearch-lazy-highlight-end-limit lazy-highlight-interval isearch-lazy-highlight-timer quit-flag] 13 (#$ . 126225)])
#@399 Resume an incremental search.
STRING is the string or regexp searched for.
REGEXP non-nil means the resumed search was a regexp search.
WORD non-nil means resume a word search.
FORWARD non-nil means resume a forward search.
MESSAGE is the echo-area message recorded for the search resumed.
CASE-FOLD non-nil means the search was case-insensitive.

(fn STRING REGEXP WORD FORWARD MESSAGE CASE-FOLD)
(defalias 'isearch-resume #[1542 "\303\304\211%\210\211\305 \210\306 \207" [isearch-string isearch-message isearch-case-fold-search isearch-mode nil isearch-search isearch-update] 12 (#$ . 127958)])
(provide 'isearch)