;ELC   
;;; compiled by kwzh@hal.gnu.ai.mit.edu on Tue Aug 30 22:33:21 1994
;;; from file /amd/churchy/home/gd/gnu/emacs/19.0/lisp/isearch.el
;;; emacs version 19.25.95.1.
;;; bytecomp version FSF 2.10
;;; optimization is on.
;;; this file uses opcodes which do not exist in Emacs 18.

(if (and (boundp 'emacs-version)
	 (or (and (boundp 'epoch::version) epoch::version)
	     (string-lessp emacs-version "19")))
    (error "`/amd/churchy/home/gd/gnu/emacs/19.0/lisp/isearch.el' was compiled for Emacs 19"))

(byte-code "ÀÁ!ÃÄ!ÆÆ‡" [fboundp set-frame-height isearch-gnu-emacs-events boundp pre-command-hook isearch-pre-command-hook-exists nil isearch-event-data-type] 2)
(defconst search-exit-option t "\
*Non-nil means random control characters terminate incremental search.")
(defvar search-slow-window-lines 1 "\
*Number of lines in slow search display windows.
These are the short windows used during incremental search on slow terminals.
Negative means put the slow search window at the top (normally it's at bottom)
and the value is minus the number of lines.")
(defvar search-slow-speed 1200 "\
*Highest terminal speed at which to use \"slow\" style incremental search.
This is the style where a one-line window is created to show the line
that the search has reached.")
(defvar search-upper-case (quote not-yanks) "\
*If non-nil, upper case chars disable case fold searching.
That is, upper and lower case chars must match exactly.
This applies no matter where the chars come from, but does not
apply to chars in regexps that are prefixed with `\\'.
If this value is `not-yanks', yanked text is always downcased.")
(defvar search-nonincremental-instead t "\
*If non-nil, do a nonincremental search instead if exiting immediately.
Actually, `isearch-edit-string' is called to let you enter the search
string, and RET terminates editing and does a nonincremental search.")
(defconst search-whitespace-regexp "\\s-+" "\
*If non-nil, regular expression to match a sequence of whitespace chars.
You might want to use something like \"[ \\t\\r\\n]+\" instead.")
(defvar search-highlight nil "\
*Non-nil means incremental search highlights the current match.")
(defvar isearch-mode-hook nil "\
Function(s) to call after starting up an incremental search.")
(defvar isearch-mode-end-hook nil "\
Function(s) to call after terminating an incremental search.")
(defvar search-ring nil "\
List of search string sequences.")
(defvar regexp-search-ring nil "\
List of regular expression search string sequences.")
(defconst search-ring-max 16 "\
*Maximum length of search ring before oldest elements are thrown away.")
(defconst regexp-search-ring-max 16 "\
*Maximum length of regexp search ring before oldest elements are thrown away.")
(defvar search-ring-yank-pointer nil "\
Index in `search-ring' of last string reused.
nil if none yet.")
(defvar regexp-search-ring-yank-pointer nil "\
Index in `regexp-search-ring' of last string reused.
nil if none yet.")
(defvar search-ring-update nil "\
*Non-nil if advancing or retreating in the search ring should cause search.
Default value, nil, means edit the string instead.")
(defvar isearch-mode-map nil "\
Keymap for isearch-mode.")
(byte-code "„­ÁÃ ÅÆ\f8!„ ÇÈ!ˆ\fAÉÊË\" ˆÌ\fÍÎ#ˆ\nÏWƒ9 Ì\fÐÆ\n\"Î#ˆ\nT‰‚$ ÏÏ\fA@GWƒS Ì\fÑ\n!Ò#ˆ\nT‰‚< Ì\fÓÔ#ˆÌ\fÕÖ#ˆÌ\f×Ø#ˆÌ\fÙÚ#ˆÌ\fÛÜ#ˆÌ\fÝÞ#ˆÌ\fßÒ#ˆÌ\fàÒ#ˆÌ\fáâ#ˆÌ\fãä#ˆÌ\fåæ#ˆÌ\fçË#ˆÌ\fèË#ˆÌ\féË#ˆÌ\fêË#ˆÌ\fëË#ˆÌ\fìË#ˆÌ\fíË#ˆÌ\fîË#ˆÌ\fïË#ˆÌ\fðË#ˆÌ\fñË#ˆÌ\fòË#ˆÌ\fóË#ˆÌ\fôË#ˆÌ\fõË#ˆÌ\föË#ˆÌ\f÷Ë#ˆÌ\føË#ˆÌ\fùË#ˆÌ\fúË#ˆÌ\fûË#ˆÌ\füË#ˆÌ\fýË#ˆÌ\fþË#ˆÌ\fÿË#ˆÌ\f@ A #ˆÌ\fB A #ˆÌ\fC D #ˆE  FÌ\fG H!F#ˆÌ\fI F#ˆ)Ì\fÑHJ \"K #ˆÌ\fL M #ˆÌ\fN O #ˆÌ\fP Q #ˆÌ\fR S #ˆTƒªÌ\fU V #ˆ\f*Ë‡" [isearch-mode-map 0 i make-keymap map vectorp 1 error "The initialization of isearch-mode-map must be updated" make-vector 256 nil define-key [t] isearch-other-control-char 32 make-string vector isearch-printing-char "" isearch-repeat-forward "" isearch-repeat-backward "" isearch-delete-char "" isearch-abort "" isearch-quote-char "" isearch-exit "\n" "	" " " isearch-whitespace-chars "" isearch-yank-word "" isearch-yank-line [tab] [kp-0] [kp-1] [kp-2] [kp-3] [kp-4] [kp-5] [kp-6] [kp-7] [kp-8] [kp-9] [kp-add] [kp-subtract] [kp-multiply] [kp-divide] [kp-decimal] [kp-separator] [kp-equal] [kp-tab] [kp-space] [kp-enter] [delete] [backspace] [return] [newline] "*" isearch-*-char "?" "|" isearch-|-char make-sparse-keymap meta-map char-to-string meta-prefix-char [escape] t isearch-other-meta-char "î" isearch-ring-advance "ð" isearch-ring-retreat "ù" isearch-yank-kill "‰" isearch-complete isearch-gnu-emacs-events [switch-frame] isearch-switch-frame-handler] 6)
(defvar minibuffer-local-isearch-map nil "\
Keymap for editing isearch strings in the minibuffer.")
(byte-code "„/ Á\n!ÄÅÆ#ˆÄÇÈ#ˆÄÉÊ#ˆÄËÌ#ˆÄÍÎ#ˆÄÏÐ#ˆ)ÑÒ!„8 ÓÑÔ!„A ÓÑÕ!„J ÓÑÖ!„S ÓÑ×!„\\ ØÑÙ!„e ØÑÚ!„n ÛÑÜ!„w ÓÑÝ!„€ ÓÑÞ!„‰ ÓÑß!„’ ÓÑà!„› á Ñâ!„¤ Ó\"Ñã!„­ Ó#Ñä!„¶ Ó$Ñå!„¿ Ó%Ñæ!„È á&Ñç!„Ñ Ó'Ñè!„Ú Ó(Ñé!„ã Ó)Ñê!„ì Ó*Ñë!„õ Ó+Ñì!„þ Ó,í.ž„.ïC¤ˆÑí!„Ó-ðí!ˆÄ1ÍÒ#ˆÄ2Íó#ˆÄ1Ïô#ˆÄ2Ïõ#‡" [minibuffer-local-isearch-map copy-keymap minibuffer-local-map map define-key "" isearch-nonincremental-exit-minibuffer "î" isearch-ring-advance-edit "ð" isearch-ring-retreat-edit "‰" isearch-complete-edit "" isearch-forward-exit-minibuffer "" isearch-reverse-exit-minibuffer boundp isearch-forward nil isearch-regexp isearch-word isearch-cmds isearch-string "" isearch-message isearch-success t isearch-invalid-regexp isearch-within-brackets isearch-other-end isearch-wrapped isearch-barrier 0 isearch-case-fold-search isearch-adjusted isearch-slow-terminal-mode isearch-small-window isearch-opoint isearch-window-configuration isearch-yank-flag isearch-op-fun isearch-recursive-edit isearch-nonincremental isearch-new-forward isearch-mode minor-mode-alist (isearch-mode isearch-mode) make-variable-buffer-local global-map esc-map isearch-forward-regexp isearch-backward isearch-backward-regexp] 4)
(defalias 'isearch-forward #[(&optional regexp-p no-recursive-edit) "ÀÁ\n??Ã\f?$‡" [isearch-mode t regexp-p nil no-recursive-edit] 5 "\
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 characters 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] to yank word 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-quote-char] to quote control character to search for it.
\\[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.

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.

The above keys, bound in `isearch-mode-map', are often controlled by 
 options; do M-x apropos on search-.* to find them.
Other control and meta characters terminate the search
 and are then executed normally (depending on `search-exit-option').

If this function is called non-interactively, it does not return to
the calling function until the search is done." "P\np"])
(defalias 'isearch-forward-regexp #[(&optional not-regexp no-recursive-edit) "ÀÁ\n?Ã\f?$‡" [isearch-mode t not-regexp nil no-recursive-edit] 5 "\
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 \\[isearch-forward] for more info." "P\np"])
(defalias 'isearch-backward #[(&optional regexp-p no-recursive-edit) "ÀÁ\n??Á?$‡" [isearch-mode nil regexp-p no-recursive-edit] 5 "\
Do incremental search backward.
With a prefix argument, do a regular expression search instead.
See \\[isearch-forward] for more information." "P\np"])
(defalias 'isearch-backward-regexp #[(&optional not-regexp no-recursive-edit) "ÀÁ\n?Á?$‡" [isearch-mode nil not-regexp no-recursive-edit] 5 "\
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 \\[isearch-forward] for more info." "P\np"])
(defalias (quote isearch-mode-help) #[nil "ÀÁ!ˆÂ ‡" [describe-function isearch-forward isearch-update] 2 nil nil])
(defalias 'isearch-mode #[(forward &optional regexp op-fun recursive-edit word-p) "\n\f	ÊÊ\fÍÏÍ`ÍÍÍÍ× X…; Ù Û_VÍÍ`Í Í!…S â #ä%æç !ˆÏ(é ˆêë!ˆ,+í ˆîï!ˆ0ƒ~ Ï1ð ˆ)‡" [forward isearch-forward regexp isearch-regexp word-p isearch-word op-fun isearch-op-fun case-fold-search isearch-case-fold-search "" isearch-string isearch-message nil isearch-cmds t isearch-success isearch-wrapped isearch-barrier isearch-adjusted isearch-yank-flag isearch-invalid-regexp isearch-within-brackets baud-rate search-slow-speed window-height search-slow-window-lines 4 isearch-slow-terminal-mode isearch-other-end isearch-small-window isearch-opoint search-ring-yank-pointer regexp-search-ring-yank-pointer current-window-configuration isearch-window-configuration " Isearch" isearch-mode set-buffer-modified-p buffer-modified-p deactivate-mark isearch-push-state make-local-variable overriding-local-map isearch-mode-map isearch-update run-hooks isearch-mode-hook recursive-edit isearch-recursive-edit] 3 "\
Start isearch minor mode.  Called by isearch-forward, etc."])
(byte-code "ÀÁÂ\"ˆÀÃÄ\"ˆÀÅÆ\"‡" [defalias isearch-update #[nil "ƒ	 	?‚ \nƒ ?‚ \fÅWƒ¤ Æ „  Ç ˆƒ‚ 	„‚ Ê „‚ `Ì	ÍÅ!ˆÎÐÑÅWƒL [T‚R Ó TZ\"ˆ)ÅWƒy ÔÎZ!ˆÕÖ `\"ˆ×Ö Ø \"ˆ×Ù Å\"ˆ‚} ÚÎ!ˆbˆ)ƒ  `Wƒ— Ü`\"ˆ‚¤ Ü`\"ˆ‚¤ ÝÑ!ˆÑÑ‰‡" [isearch-event-data-type unread-command-event isearch-gnu-emacs-events unread-command-events unread-command-char 0 input-pending-p isearch-message isearch-slow-terminal-mode isearch-small-window pos-visible-in-window-p found-point t move-to-window-line 1 window-min-height split-window nil search-slow-window-lines window-height vertical-motion set-window-start next-window set-window-hscroll window-hscroll selected-window other-window isearch-other-end isearch-highlight isearch-dehighlight isearch-adjusted isearch-yank-flag] 4] isearch-done #[(&optional nopush edit) "ÀÂÃ!ˆÄÅ !`ƒ É!ˆ\nƒ% bˆ‚- ËÅ Ã#ˆ*`\fU„K Í\fÃ\"ˆ„K Ï ÐV„K ÑÒ!ˆÀÔÕ !ˆGÐVƒ´ „´ ƒŽ ƒs @˜„´ B‰GVƒ´ S›À¡ˆ‚´ ƒœ @˜„´ B‰GVƒ´ S›À¡ˆÝÞ!ˆ?…Å  …Å á ‡" [nil overriding-local-map isearch-dehighlight t window-start selected-window found-point found-start isearch-window-configuration set-window-configuration isearch-small-window set-window-start isearch-opoint push-mark executing-macro minibuffer-depth 0 message "Mark saved where search started" isearch-mode set-buffer-modified-p buffer-modified-p isearch-string nopush isearch-regexp regexp-search-ring regexp-search-ring-max search-ring-max search-ring run-hooks isearch-mode-end-hook edit isearch-recursive-edit exit-recursive-edit] 5] isearch-switch-frame-handler #[nil "À ˆÁÂ A@!‡" [isearch-done handle-switch-frame isearch-last-command-char] 2 nil nil]] 3)
(defalias 'isearch-exit #[nil "ƒ 	GÂUƒ ÃÅ ˆ)Æ ‡" [search-nonincremental-instead isearch-string 0 t isearch-nonincremental isearch-edit-string isearch-done] 2 "\
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'." nil])
(defalias 'isearch-edit-string #[nil "ÀÁÂ‡" [err (byte-code "	\n\f	\n\fÔ \f\n	ÚÛÜˆÂ ˆÝŽÞà )!â#äåâ‰Þ#!ˆæ'è!!\"é=ƒ~ ÞÞ‚ƒ ê!!ˆââ+ìå 	-âë%)îïð#+	GñUƒ² ƒ® 2‚° 3@ô ˆõ ˆö ˆ…Á ÷ .‡" [isearch-nonincremental isearch-string isearch-message isearch-forward isearch-word isearch-regexp isearch-op-fun isearch-cmds isearch-success isearch-wrapped isearch-barrier isearch-adjusted isearch-yank-flag isearch-invalid-regexp isearch-within-brackets isearch-other-end isearch-opoint isearch-slow-terminal-mode isearch-small-window isearch-recursive-edit current-window-configuration isearch-window-configuration isearch-new-word isearch-new-forward isearch-new-message isearch-new-string err (byte-code "ÀÁ‰\"‡" [isearch-done t] 3) ((exit)) ((byte-code "À	\nÄ%ˆ	\nÄ‡" [isearch-mode isearch-forward isearch-regexp isearch-op-fun nil isearch-word isearch-new-string isearch-string isearch-new-message isearch-message isearch-new-forward isearch-new-word] 6)) t cursor-in-echo-area read-event e nil minibuffer-history-symbol message isearch-message-prefix lookup-key isearch-mode-map vector isearch-yank-word isearch-unread junk-ring read-from-minibuffer minibuffer-local-isearch-map mapconcat isearch-text-char-description "" 0 regexp-search-ring search-ring isearch-push-state isearch-search isearch-update isearch-done] 21) ((quit (isearch-abort)))] 3 "\
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-nonincremental-exit-minibuffer] to do one nonincremental search.
\\[isearch-forward-exit-minibuffer] to resume isearching forward.
\\[isearch-reverse-exit-minibuffer] to resume isearching backward.
\\[isearch-ring-advance-edit] to replace the search string with the next item in the search ring.
\\[isearch-ring-retreat-edit] to replace the search string with the previous item in the search ring.
\\[isearch-complete-edit] to complete the search string using the search ring.
\\<isearch-mode-map>
If first char entered is \\[isearch-yank-word], then do word search instead." nil])
(byte-code "ÀÁÂ\"ˆÀÃÄ\"ˆÀÅÆ\"‡" [defalias isearch-nonincremental-exit-minibuffer #[nil "ÀÂ ‡" [t isearch-nonincremental exit-minibuffer] 1 nil nil] isearch-forward-exit-minibuffer #[nil "ÀÂ ‡" [t isearch-new-forward exit-minibuffer] 1 nil nil] isearch-reverse-exit-minibuffer #[nil "ÀÂ ‡" [nil isearch-new-forward exit-minibuffer] 1 nil nil]] 3)
(defalias 'isearch-abort #[nil "À ˆ	ƒ \nbˆÃÄ!ˆÅÆÇ\"‡	„ È ˆ‚ É ‡" [discard-input isearch-success isearch-opoint isearch-done t signal quit nil isearch-pop-state isearch-update] 3 "\
Abort incremental search mode if searching is successful, signalling quit.
Otherwise, revert to previous successful search and continue searching.
Use `isearch-exit' to quit without signalling." nil])
(defalias (quote isearch-repeat) #[(direction) "	Â==ƒ@ Äšƒ* ƒ @‚ @† ÄÈÉÄ#\n‚C „C ƒ7 e‚8 dbˆÌ‚C ?`ÄšƒR Ì‚ˆ ƒ… Ï•Ï”šƒ… ƒg m‚h oƒt ÐÑ ˆ‚ˆ ƒ| Ò‚} ÓuˆÔ ˆ‚ˆ Ô ˆÕ ˆÖ ‡" [isearch-forward direction forward isearch-string "" isearch-regexp regexp-search-ring search-ring mapconcat isearch-text-char-description isearch-message isearch-success t isearch-wrapped isearch-barrier 0 nil ding 1 -1 isearch-search isearch-push-state isearch-update] 4])
(defalias 'isearch-repeat-forward #[nil "ÀÁ!‡" [isearch-repeat forward] 2 "\
Repeat incremental search forwards." nil])
(defalias 'isearch-repeat-backward #[nil "ÀÁ!‡" [isearch-repeat backward] 2 "\
Repeat incremental search backwards." nil])
(defalias 'isearch-toggle-regexp #[nil "?‰ƒ	 ÁÃ ‡" [isearch-regexp nil isearch-word isearch-update] 2 "\
Toggle regexp searching on or off." nil])
(defalias 'isearch-toggle-case-fold #[nil "?… ÁÂÃÄ ƒ Æ‚ Ç$ˆÈ	ÊË!ˆÌ ‡" [isearch-case-fold-search yes message "%s%s [case %ssensitive]" isearch-message-prefix isearch-message "in" "" t isearch-adjusted sit-for 1 isearch-update] 5 "\
Toggle case folding in searching on or off." nil])
(defalias 'isearch-delete-char #[nil "A„ Á ˆ‚ Â ˆÃ ‡" [isearch-cmds ding isearch-pop-state isearch-update] 1 "\
Discard last input item and move point back.  
If no previous match was done, just beep." nil])
(defalias (quote isearch-yank) #[(chunk) "Á=ƒ\f ÂÃ!‚3 Š\f„ ƒ bˆ`ŠÆ=ƒ& Çvˆ‚/ È=ƒ/ Éˆ`){)\nƒF \fÍ=ƒF \n—\nƒQ Ï\n!\n\nPÒÓ\nÔ#PÕ)× ‡" [chunk kill current-kill 0 isearch-forward isearch-other-end word 1 line nil string isearch-case-fold-search search-upper-case not-yanks isearch-regexp regexp-quote isearch-string isearch-message mapconcat isearch-text-char-description "" t isearch-yank-flag isearch-search-and-update] 5])
(defalias 'isearch-yank-kill #[nil "ÀÁ!‡" [isearch-yank kill] 2 "\
Pull string from kill ring into search string." nil])
(defalias 'isearch-yank-word #[nil "ÀÁ!‡" [isearch-yank word] 2 "\
Pull next word from buffer into search string." nil])
(defalias 'isearch-yank-line #[nil "ÀÁ!‡" [isearch-yank line] 2 "\
Pull rest of line from buffer into search string." nil])
(defalias (quote isearch-search-and-update) #[nil "„ 	ƒV \n„6 „6 ÄÅÆƒ6 „' È•	\n^Xƒ6 ËÄ\fÄÈ•‚V ƒS „S \nƒH ‚Q 	\nT^^bˆÏ ˆÐ ˆƒb  ˆÒ ‡" [isearch-success isearch-regexp isearch-forward isearch-adjusted nil (byte-code "À	ƒ	 \n‚\f Ã\n!!‡" [looking-at isearch-regexp isearch-string regexp-quote] 3) ((error)) isearch-yank-flag 0 isearch-opoint isearch-barrier t isearch-invalid-regexp isearch-within-brackets isearch-other-end isearch-search isearch-push-state isearch-op-fun isearch-update] 3])
(defalias 'isearch-*-char #[nil "ƒ2 Áƒ Ä‚ ÅA@8‰† ƒ* ]‚/ ^bˆ)ÉÊ !‡" [isearch-regexp t isearch-adjusted isearch-forward 5 2 isearch-cmds cs isearch-barrier isearch-process-search-char isearch-last-command-char] 3 "\
Handle * and ? specially in regexps." nil])
(defalias 'isearch-|-char #[nil "ƒ	 ÁbˆÄÅ !‡" [isearch-regexp t isearch-adjusted isearch-barrier isearch-process-search-char isearch-last-command-char] 2 "\
If in regexp search, jump to the barrier." nil])
(defalias (quote isearch-other-control-char) (quote isearch-other-meta-char))
(defalias 'isearch-other-meta-char #[nil "Á=ƒ Â ÄÅÆ!\"ˆ)Ç ‡ƒ€ Â ÈÉ\nÄÅÆ!\"ˆGÌVƒK ÈH9ƒK ÌH<ƒK ÍÎÌH!!§„K ÌH<ƒ| H‰A@)‰@)‰\nƒ| Ñ\n!ƒ| ŠÒ\n!qˆÓ )‚~ Ó +‡ÔÂ Â \"‡" [search-exit-option edit this-command-keys key apply isearch-unread listify-key-sequence isearch-edit-string 0 nil window index 1 posn-point event-start event position windowp window-buffer isearch-done isearch-process-search-string] 5 "\
Exit the search normally and reread this key sequence.
But only if `search-exit-option' is non-nil, the default.
If it is the symbol `edit', the search string is edited in the minibuffer
and the meta character is unread so that it applies to editing the string." nil])
(defalias 'isearch-quote-char #[nil "ÀÁÂÃ!!!‡" [isearch-process-search-char read-quoted-char isearch-message t] 4 "\
Quote special characters for incremental search." nil])
(defalias 'isearch-return-char #[nil "ÀÁ!‡" [isearch-process-search-char 10] 2 "\
Convert return into newline for incremental search.
Obsolete." nil])
(defalias 'isearch-printing-char #[nil "ÀÁ !‡" [isearch-process-search-char isearch-last-command-char] 2 "\
Add this ordinary printing character to the search string and search." nil])
(defalias 'isearch-whitespace-chars #[nil "ƒ 	ƒ \n„ Ã	Ä\"‡Å ‡Å ‡" [isearch-regexp search-whitespace-regexp isearch-within-brackets isearch-process-search-string " " isearch-printing-char] 3 "\
Match all whitespace chars, if in regexp mode.
If you want to search for just a space, type C-q SPC." nil])
(byte-code "ÀÁÂ\"ˆÀÃÄ\"ˆÀÅÆ\"ˆÀÇÈ\"‡" [defalias isearch-process-search-char #[(char) "ÀÁ\n!Ã\n!\"‡" [isearch-process-search-string isearch-char-to-string char isearch-text-char-description] 4] isearch-process-search-string #[(string message) "	P\nPÄ ‡" [isearch-string string isearch-message message isearch-search-and-update] 2] isearch-ring-adjust1 #[(advance) "ƒ 	‚	 \n‰Gƒ Å‚ ÆÈ!	\fÊU?…O Ë	†. Ê\fƒ7 Í‚8 Î\\\f\"‰	Lˆ	8ÐÑÒ#‰,‡" [isearch-regexp regexp-search-ring search-ring ring length regexp-search-ring-yank-pointer search-ring-yank-pointer yank-pointer-name eval yank-pointer 0 mod advance -1 1 isearch-string mapconcat isearch-text-char-description "" isearch-message] 5] isearch-ring-adjust #[(advance) "Aƒ Á ˆÂ!ˆÄ ˆƒ Æ ˆÇ ‡È ‡" [isearch-cmds isearch-pop-state isearch-ring-adjust1 advance isearch-push-state search-ring-update isearch-search isearch-update isearch-edit-string] 2]] 3)
(defalias 'isearch-ring-advance #[nil "ÀÁ!‡" [isearch-ring-adjust advance] 2 "\
Advance to the next search string in the ring." nil])
(defalias 'isearch-ring-retreat #[nil "ÀÁ!‡" [isearch-ring-adjust nil] 2 "\
Retreat to the previous search string in the ring." nil])
(defalias 'isearch-ring-advance-edit #[(n) "ƒ Á‚	 ÂÄ!ƒ ‚ ‰G‰	ÊU?…B Ë†- Ê\fZ	\"‰LˆÍ ˆ8cˆdb,‡" [isearch-regexp regexp-search-ring-yank-pointer search-ring-yank-pointer yank-pointer-name eval yank-pointer regexp-search-ring search-ring ring length 0 mod n erase-buffer] 5 "\
Insert the next element of the search history into the minibuffer." "p"])
(defalias 'isearch-ring-retreat-edit #[(n) "À	[!‡" [isearch-ring-advance-edit n] 2 "\
Inserts the previous element of the search history into the minibuffer." "p"])
(defalias (quote isearch-complete1) #[nil "ƒ 	‚	 \nÄÅ\"É\n\"‰Ì=ƒ& Ì‚\\ „3 \nGÍUƒW \nšƒO ƒS ÏÐÑ\n\"!‘ˆ‚S \nÌ‚\\ ÒÓ!ˆÔ,‡" [isearch-regexp regexp-search-ring search-ring ring mapcar #[(string) "C‡" [string] 1] alist case-fold-search completion-ignore-case try-completion isearch-string completion t 0 completion-auto-help "*Isearch completions*" display-completion-list all-completions message "No completion" nil] 6])
(defalias 'isearch-complete #[nil "À ƒ Á ‡ÂÃ!ˆÄ ‡" [isearch-complete1 isearch-edit-string sit-for 1 isearch-update] 2 "\
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." nil])
(defalias 'isearch-complete-edit #[nil "À Â … Ã ˆ	c‡" [buffer-string isearch-string isearch-complete1 erase-buffer] 1 "\
Same as `isearch-complete' except in the minibuffer." nil])
(byte-code "ÀÁÂ\"ˆÀÃÄ\"ˆÀÅÆ\"ˆÀÇÈ\"ˆÀÉÊ\"ˆÀËÌ\"ˆÀÍÎ\"ˆÏÐ!„, ÑÀÒÓ\"ˆÀÔÕ\"‡" [defalias isearch-top-state #[nil "@‰@	A@Ä	8Æ	8È	8	Ê	8Ì	8Î	8Ð	8Ò	8Ô	8	AA@b)‡" [isearch-cmds cmd isearch-string isearch-message 3 isearch-success 4 isearch-forward 5 isearch-other-end 6 isearch-word 7 isearch-invalid-regexp 8 isearch-wrapped 9 isearch-barrier 10 isearch-within-brackets 11 isearch-case-fold-search] 3] isearch-pop-state #[nil "AÁ ‡" [isearch-cmds isearch-top-state] 1] isearch-push-state #[nil "	`\n\f	\n¯\fB‰‡" [isearch-string isearch-message isearch-success isearch-forward isearch-other-end isearch-word isearch-invalid-regexp isearch-wrapped isearch-barrier isearch-within-brackets isearch-case-fold-search isearch-cmds] 12] isearch-message #[(&optional c-q-hack ellipsis) "Á\n#\fÅ\n\"Q\nƒ ‚ ÈÉ\"*‡" [ellipsis isearch-message-prefix c-q-hack isearch-nonincremental isearch-message isearch-message-suffix m cursor-in-echo-area message "%s"] 6] isearch-message-prefix #[(&optional c-q-hack ellipsis nonincremental) "ƒ 	ƒ ÂÃÄˆ„ Âƒ Æ‚ Ç…\" É\nƒ+ Ë‚, Æ\fƒ5 Í‚6 Æƒ? Ï‚@ ÐƒI Ò‚J Ó°‰ÕÕH–Iˆ)‡" [isearch-invalid-regexp ellipsis nil (byte-code "À	`Â#ˆÃÃÃ‡" [re-search-forward isearch-string t nil isearch-invalid-regexp isearch-within-brackets] 4) ((error)) isearch-success "" "failing " isearch-wrapped "wrapped " isearch-word "word " isearch-regexp "regexp " nonincremental "search" "I-search" isearch-forward ": " " backward: " m 0] 7] isearch-message-suffix #[(&optional c-q-hack ellipsis) "ƒ Á‚	 Âƒ ÄÅQ‚ ÂP‡" [c-q-hack "^Q" "" isearch-invalid-regexp " [" "]"] 4] isearch-search #[nil "ÀÁÂ\"ˆÂ=ƒ \fƒ Å\"ÈÉÊˆ?…2 Ì@8ƒ, Î ˆÏ@8b‡" [isearch-message nil t isearch-case-fold-search search-upper-case isearch-no-upper-case-p isearch-string isearch-regexp lossage (byte-code "À	\fƒ\n ÀÀƒ ƒ É‚: Ê‚: \fƒ0 ƒ, Ë‚: Ì‚: ƒ9 Í‚: ÎÀÐ#‰ƒS ƒO Ò”‚Q Ò•*À‡" [nil isearch-case-fold-search case-fold-search inhibit-quit isearch-regexp isearch-invalid-regexp isearch-within-brackets isearch-word isearch-forward word-search-forward word-search-backward re-search-forward re-search-backward search-forward search-backward isearch-string t isearch-success 0 isearch-other-end] 5) ((quit (byte-code "ÀÁ!ˆÂÂ‡" [isearch-unread 7 nil isearch-success] 2)) (invalid-regexp (byte-code "A@ÂÃ	\"ÂÅ	\"ƒ ÆÂ‡" [lossage isearch-invalid-regexp string-match "\\`Unmatched \\[" isearch-within-brackets "\\`Premature \\|\\`Unmatched \\|\\`Invalid " "incomplete input"] 3)) (error (byte-code "A@Â‡" [lossage isearch-invalid-regexp nil] 1))) isearch-success 3 isearch-cmds ding 2] 3] boundp isearch-overlay nil isearch-highlight #[(beg end) "?† 	??…+ \n„ Ã\f\"Æ\n\fp$ˆÇ\nÈÉÊË\"ƒ) Ê‚* Ì#‡" [search-highlight window-system isearch-overlay make-overlay beg end move-overlay overlay-put face internal-find-face isearch nil region] 6] isearch-dehighlight #[(totally) "… Á!‡" [isearch-overlay delete-overlay] 2]] 3)
(defalias 'isearch-no-upper-case-p #[(string regexp-flag) "ÀÂƒ Ä‚\f Å\")?‡" [nil case-fold-search string-match regexp-flag "\\(^\\|\\\\\\\\\\|[^\\]\\)[A-Z]" "[A-Z]" string] 3 "\
Return t if there are no upper case chars in STRING.
If REGEXP-FLAG is non-nil, disregard letters preceeded by `\\' (but not `\\\\')
since they have special meaning in a regexp."])
(byte-code "ÀÁÂ\"ˆÀÃÄ\"ˆÀÅÆ\"ˆÀÇÈ\"‡" [defalias isearch-char-to-string #[(c) "¨ƒ\n ÁÂ\"‡9ƒ ÃNƒ ÁÂÃN\"‡ÁÂÄ!\"‡" [c make-string 1 ascii-character event-to-character] 4] isearch-text-char-description #[(c) "¨ƒ ÁW„ ÂUƒ Ã!‡Ä!‡" [c 32 127 text-char-description isearch-char-to-string] 2] isearch-unread #[(&rest char-or-events) "ƒ Á\n\"‰‡\nAƒ# \nAƒ \nA‰‚ \n@Ä\\‚% \n@ƒ2 ‰‚6 ‰)‡" [isearch-gnu-emacs-events append char-or-events unread-command-events 128 char isearch-event-data-type unread-command-event unread-command-char] 4] isearch-last-command-char #[nil "ƒ 	‡\n‡" [isearch-event-data-type last-command-event last-command-char] 1]] 3)