;ELC   
;;; compiled by rms@mole.gnu.ai.mit.edu on Sun Sep 11 21:08:09 1994
;;; from file /home/fsf/rms/e19/lisp/ispell.el
;;; emacs version 19.26.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 "`/home/fsf/rms/e19/lisp/ispell.el' was compiled for Emacs 19"))

(defvar ispell-highlight-p t "\
*Highlight spelling errors when non-nil.")
(defvar ispell-highlight-face (quote highlight) "\
*The face used for Ispell highlighting.  For Emacses with overlays.
Possible values are `highlight', `modeline', `secondary-selection',
`region', and `underline'.
This variable can be set by the user to whatever face they desire.
It's most convenient if the cursor color and highlight color are
slightly different.")
(defvar ispell-check-comments nil "\
*Spelling of comments checked when non-nil.")
(defvar ispell-query-replace-choices nil "\
*Corrections made throughout region when non-nil.
Uses `query-replace' (\\[query-replace]) for corrections.")
(defvar ispell-skip-tib nil "\
*Does not spell check `tib' bibliography references when non-nil.
Skips any text between strings matching regular expressions
`ispell-tib-ref-beginning' and `ispell-tib-ref-end'.

TeX users beware:  Any field starting with [. will skip until a .] -- even
your whole buffer -- unless you set `ispell-skip-tib' to nil.  That includes
a [.5mm] type of number....")
(defvar ispell-tib-ref-beginning "[[<]\\." "\
Regexp matching the beginning of a Tib reference.")
(defvar ispell-tib-ref-end "\\.[]>]" "\
Regexp matching the end of a Tib reference.")
(defvar ispell-keep-choices-win t "\
*When not nil, the `*Choices*' window remains for spelling session.
This minimizes redisplay thrashing.")
(defvar ispell-choices-win-default-height 2 "\
*The default size of the `*Choices*' window, including status line.
Must be greater than 1.")
(defvar ispell-program-name "ispell" "\
Program invoked by \\[ispell-word] and \\[ispell-region] commands.")
(defvar ispell-alternate-dictionary (byte-code "ÀÁ!ƒ Á‡ÀÂ!ƒ Â‡ÀÃ!ƒ Ã‡ÀÄ!ƒ  Ä‡Â‡" [file-exists-p "/usr/dict/web2" "/usr/dict/words" "/usr/lib/dict/words" "/sys/dict"] 2) "\
*Alternate dictionary for spelling help.")
(defvar ispell-complete-word-dict ispell-alternate-dictionary "\
*Dictionary used for word completion.")
(defvar ispell-grep-command "/usr/bin/egrep" "\
Name of the grep command for search processes.")
(defvar ispell-grep-options "-i" "\
String of options to use when running the program in `ispell-grep-command'.
Should probably be \"-i\" or \"-e\".
Some machines (like the NeXT) don't support \"-i\"")
(defvar ispell-look-command "/usr/bin/look" "\
Name of the look command for search processes.
This must be an absolute file name.")
(defvar ispell-look-p (file-exists-p ispell-look-command) "\
*Non-nil means use `look; rather than `grep'.
Default is based on whether `look' seems to be available.")
(defvar ispell-have-new-look nil "\
*Non-nil means use the `-r' option (regexp) when running `look'.")
(defvar ispell-look-options (byte-code "ƒ Á‡Â‡" [ispell-have-new-look "-dfr" "-df"] 1) "\
String of command options for `ispell-look-command'.")
(defvar ispell-use-ptys-p nil "\
When non-nil, Emacs uses ptys to communicate with Ispell.
When nil, Emacs uses pipes.")
(defvar ispell-following-word nil "\
*Non-nil means `ispell-word' checks the word around or after point.
Otherwise `ispell-word' checks the preceding word.")
(defvar ispell-help-in-bufferp nil "\
*Non-nil means display interactive keymap help in a buffer.
Otherwise use the minibuffer.")
(defvar ispell-quietly nil "\
*Non-nil means suppress messages in `ispell-word'.")
(defvar ispell-format-word (quote upcase) "\
*Formatting function for displaying word being spell checked.
The function must take one string argument and return a string.")
(defvar ispell-personal-dictionary nil "\
*File name of your personal spelling dictionary.
If nil, default dictionary `~/.ispell_words' is used.")
(defvar ispell-silently-savep nil "\
*When non-nil, save the personal dictionary without confirmation.")
(defvar ispell-dictionary nil "\
If non-nil, a dictionary to use instead of the default one.
This is passed to the ispell process using the `-d' switch and is
used as key in `ispell-dictionary-alist' (which see).

You should set this variable before your first use of Emacs spell-checking
commands in the Emacs session, or else use the \\[ispell-change-dictionary] command to
change it.  Otherwise, this variable only takes effect in a newly
started Ispell process.")
(defvar ispell-extra-args nil "\
*If non-nil, a list of extra switches to pass to the Ispell program.
For example, '(\"-W\" \"3\") to cause it to accept all 1-3 character
words as correct.  See also `ispell-dictionary-alist', which may be used
for language-specific arguments.")
(byte-code "ÀÁ!„ ÂÀÃ!„ ÄÀ‡" [boundp ispell-dictionary-alist-1 ((nil "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B") nil) ("english" "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B") nil) ("deutsch" "[a-zA-Z\"]" "[^a-zA-Z\"]" "[---']" t ("-C") nil) ("deutsch8" "[a-zA-ZÄÖÜäößü]" "[^a-zA-ZÄÖÜäößü]" "[---']" t ("-C" "-d" "deutsch") "~latin1") ("nederlands8" "[A-Za-zÀ-ÅÇÈ-ÏÒ-ÖÙ-Üà-åçè-ïñò-öù-ü]" "[^A-Za-zÀ-ÅÇÈ-ÏÒ-ÖÙ-Üà-åçè-ïñò-öù-ü]" "[---']" t ("-C") nil)) ispell-dictionary-alist-2 (("svenska" "[A-Za-z}{|\\133\\135\\\\]" "[^A-Za-z}{|\\133\\135\\\\]" "[---']" nil ("-C") nil) ("svenska8" "[A-Za-zåäöÅÄö]" "[^A-Za-zåäöÅÄö]" "[---']" nil ("-C" "-d" "svenska") "~list") ("francais" "[A-Za-z]" "[^A-Za-z]" "[`'^-]" t nil nil) ("francais8" "[A-Za-zÀÂÆÇÈÉÊËÎÏÔÙÛÜàâæçèéêëîïôùûü]" "[^A-Za-zÀÂÄÆÇÈÉÊËÎÏÔÖÙÛÜàâäæçèéêëîïôöùûü]" "[---']" t nil "~list") ("dansk" "[A-ZÆØÅa-zæøå]" "[^A-ZÆØÅa-zæøå]" "[---]" nil ("-C") nil))] 2)
(defvar ispell-dictionary-alist (append ispell-dictionary-alist-1 ispell-dictionary-alist-2) "\
An alist of dictionaries and their associated parameters.

Each element of this list is also a list:

(DICTIONARY-NAME CASECHARS NOT-CASECHARS OTHERCHARS MANY-OTHERCHARS-P
        ISPELL-ARGS EXTENDED-CHARACTER-MODE)

DICTIONARY-NAME is a possible value of variable `ispell-dictionary', nil
means the default dictionary.

CASECHARS is a regular expression of valid characters that comprise a
word.

NOT-CASECHARS is the opposite regexp of CASECHARS.

OTHERCHARS is a regular expression of other characters that are valid
in word constructs.  Otherchars cannot be adjacent to each other in a
word, nor can they begin or end a word.  This implies we can't check
\"Stevens'\" as a correct possessive and other correct formations.

Hint: regexp syntax requires the hyphen to be declared first here.

MANY-OTHERCHARS-P is non-nil if many otherchars are to be allowed in a
word instead of only one.

ISPELL-ARGS is a list of additional arguments passed to the ispell
subprocess.

EXTENDED-CHARACTER-MODE should be used when dictionaries are used which
have been configured in Ispell's parse.y.  (For example, umlauts
can be encoded as \\\"a, a\\\", \"a, ...)  Defaults are ~tex and ~nroff
in English.  This has the same effect as the command-line `-T' option.
The buffer Major Mode controls Ispell's parsing in tex or nroff mode,
but the dictionary can control the extended character mode.
Both defaults can be overruled in a buffer-local fashion. See
`ispell-parsing-keyword' for details on this.

Note that the CASECHARS and OTHERCHARS slots of the alist should
contain the same character set as casechars and otherchars in the
language.aff file (e.g., english.aff).")
(byte-code "ÀÁ!„ Â	?… ÀÃ!‰ƒY ÅÆÂBB!Â	ÊË!	ƒX 	@@	A	;ƒ& Ì	ÍÎ!!ÏÐ!PÑÂÒÓDFB#ˆ‚& *\fƒ{ Ì	ÔÕ#ˆÌ	Ö×#ˆÌ	ØÙ#ˆÌ	ÚÛ#ˆÌ	ÜÝ#ˆ\fƒ— Ì	Þß#ˆÌ	àá#ˆÌ	âã#ˆÌ	äå#ˆ\fƒ­ Ì	æç#ˆÌ	èé#ˆêëìí#ˆÁ‰JMˆî/™ƒ&ðñ/\"ƒ&ÆÂBB2†Î 3ôÂ52		ƒ	@@	A	;ƒØ ö5ÍÏÐ!PÓD÷#C\"5‚Ø Àø!„58êøùú#ˆ2ƒ%ûü!ˆýþË8#ˆ,Â‡" [boundp ispell-menu-map nil system-key-alist ispell-menu-map-needed reverse "default" ispell-dictionary-alist name dicts make-sparse-keymap "Spell" define-key vector intern "Select " capitalize lambda (interactive) ispell-change-dictionary [ispell-change-dictionary] ("Change Dictionary" . ispell-change-dictionary) [ispell-kill-ispell] ("Kill Process" . ispell-kill-ispell) [ispell-pdict-save] ("Save Dictionary" lambda nil (interactive) (ispell-pdict-save t)) [ispell-complete-word] ("Complete Word" . ispell-complete-word) [ispell-complete-word-interior-frag] ("Complete Word Frag" . ispell-complete-word-interior-frag) [ispell-continue] ("Continue Check" . ispell-continue) [ispell-region] ("Check Region" . ispell-region) [ispell-word] ("Check Word" . ispell-word) [ispell-buffer] ("Check Buffer" . ispell-buffer) [ispell-message] ("Check Message" . ispell-message) [ispell-help] ("Help" lambda nil (interactive) (describe-function (quote ispell-help))) put ispell-region menu-enable mark-active "19" emacs-version string-match "Lucid" current-menubar default-menubar (["Help" (describe-function (quote ispell-help)) t] ["Check Message" ispell-message t] ["Check Buffer" ispell-buffer t] ["Check Word" ispell-word t] ["Check Region" ispell-region (or (not zmacs-regions) (mark))] ["Continue Check" ispell-continue t] ["Complete Word Frag" ispell-complete-word-interior-frag t] ["Complete Word" ispell-complete-word t] ["Kill Process" ispell-kill-ispell t] "-" ["Save Dictionary" (ispell-pdict-save t) t] ["Change Dictionary" ispell-change-dictionary t]) menu append t ispell-menu-lucid variable-documentation "Lucid's spelling menu." delete-menu-item ("Edit" "Spell") add-menu ("Edit")] 10)
(defconst ispell-required-versions (quote ("3.1." "3.0.09")) "\
Ispell versions with which this version of ispell.el is known to work.")
(byte-code "ÀÁÂ\"ˆÀÃÄ\"ˆÀÅÆ\"ˆÀÇÈ\"ˆÀÉÊ\"ˆÀËÌ\"‡" [defalias ispell-get-casechars #[nil "À	\n\"A@‡" [assoc ispell-dictionary ispell-dictionary-alist] 3] ispell-get-not-casechars #[nil "ÀÁ\n\"8‡" [2 assoc ispell-dictionary ispell-dictionary-alist] 4] ispell-get-otherchars #[nil "ÀÁ\n\"8‡" [3 assoc ispell-dictionary ispell-dictionary-alist] 4] ispell-get-many-otherchars-p #[nil "ÀÁ\n\"8‡" [4 assoc ispell-dictionary ispell-dictionary-alist] 4] ispell-get-ispell-args #[nil "ÀÁ\n\"8‡" [5 assoc ispell-dictionary ispell-dictionary-alist] 4] ispell-get-extended-character-mode #[nil "ÀÁ\n\"8‡" [6 assoc ispell-dictionary ispell-dictionary-alist] 4]] 3)
(defvar ispell-process nil "\
The process object for Ispell.")
(defvar ispell-pdict-modified-p nil "\
Non-nil means personal dictionary has modifications to be saved.")
(byte-code "ÀÁ!„ ÂÂ‡" [boundp ispell-quit nil] 2)
(defvar ispell-filter nil "\
Output filter from piped calls to Ispell.")
(defvar ispell-filter-continue nil "\
Control variable for Ispell filter function.")
(defvar ispell-process-directory nil "\
The directory where `ispell-process' was started.")
(defvar ispell-query-replace-marker (make-marker) "\
Marker for `query-replace' processing.")
(defvar ispell-checking-message nil "\
Non-nil when we're checking a mail message")
(byte-code "ÀÂ‡" ["*Choices*" ispell-choices-buffer nil] 1)
(defvar ispell-overlay nil "\
Overlay variable for Ispell highlighting.")
(defvar ispell-local-dictionary nil "\
If non-nil, a dictionary to use for Ispell commands in this buffer.
The value should be a string, which is a file name.
This variable becomes buffer-local when set in any fashion.

Setting ispell-local-dictionary to a value has the same effect as
calling \\[ispell-change-dictionary] with that value.  This variable
is automatically set when defined in the file with either
`ispell-dictionary-keyword' or the Local Variable syntax.")
(byte-code "ÀÁ!ˆÂÁÃ\"‡" [make-variable-buffer-local ispell-local-dictionary set-default nil] 3)
(defconst ispell-words-keyword "LocalWords: " "\
The keyword for local oddly-spelled words to accept.
The keyword will be followed by any number of local word spellings.
There can be multiple of these keywords in the file.")
(defconst ispell-dictionary-keyword "Local IspellDict: " "\
The keyword for local dictionary definitions.
There should be only one dictionary keyword definition per file, and it
should be followed by a correct dictionary name in `ispell-dictionary-alist'.")
(defconst ispell-parsing-keyword "Local IspellParsing: " "\
The keyword for overriding default Ispell parsing.
Determined by the buffer's major mode and extended-character mode as well as
the default dictionary.

The above keyword string should be followed by `latex-mode' or
`nroff-mode' to put the current buffer into the desired parsing mode.

Extended character mode can be changed for this buffer by placing
a `~' followed by an extended-character mode -- such as `~.tex'.")
(defvar ispell-local-pdict ispell-personal-dictionary "\
A buffer local variable containing the current personal dictionary.
If non-nil, the value must be a string, which is a file name.

If you specify a personal dictionary for the current buffer which is
different from the current personal dictionary, the effect is similar
to calling \\[ispell-change-dictionary].  This variable is automatically
set when defined in the file with either `ispell-pdict-keyword' or the
local variable syntax.")
(make-variable-buffer-local (quote ispell-local-pdict))
(defconst ispell-pdict-keyword "Local IspellPersDict: " "\
The keyword for defining buffer local dictionaries.")
(defvar ispell-buffer-local-name nil "\
Contains the buffer name if local word definitions were used.
Ispell is then restarted because the local words could conflict.")
(defvar ispell-parser (quote use-mode-name) "\
*Indicates whether ispell should parse the current buffer as TeX Code.
Special value `use-mode-name' tries to guess using the name of major-mode.
Default parser is 'nroff.
Currently the only other valid parser is 'tex.

You can set this variable in hooks in your init file -- eg:

(add-hook 'tex-mode-hook (function (lambda () (setq ispell-parser 'tex))))")
(defvar ispell-region-end (make-marker) "\
Marker that allows spelling continuations.")
(defalias (quote ispell) (quote ispell-buffer))
(defalias 'ispell-word #[(&optional following quietly continue) "ƒ Á ‡tƒ \n\fÆ ˆ`Ç!È‰‰‰	\n\fA@\fAA@@„E ÏÐ!\"ˆÒ ˆÓÕ\"ˆÓÖ×Q\"ˆØ!ˆ@Ú˜ƒX A‰<ƒv Û@!\n\nÜ=ƒ „ÏÝ!\"ˆ‚\n;ƒ¨ „ÏÞ!\n!#ˆ‚\n„´ Ïß!ˆ‚àŽ!ƒÃ â\fÜ#ˆã‹ˆ)	äšƒ× å\n@!ˆ‚	ƒ\f|ˆ	:„í 	‚ð 	@‰G\fZZ\\cˆ	:ƒbˆæ\"ˆç(!ƒé(!ˆbˆê+!ˆ,…0È‰,.‡" [continue ispell-continue ispell-following-word following ispell-quietly quietly ispell-buffer-local-dict ispell-get-word nil replace poss end start word cursor-location message "Checking spelling of %s..." ispell-format-word ispell-init-process process-send-string ispell-process "%\n" "^" "\n" accept-process-output ispell-filter "" ispell-parse-output t "%s is correct" "%s is correct because of root %s" "Error in ispell process" ((byte-code "ƒ	 Á\n\"ˆÁ‡" [ispell-highlight-p ispell-highlight-spelling-error start end] 3)) ispell-highlight-p ispell-highlight-spelling-error ((byte-code "À	AA@	AAA@	@#À‡" [ispell-command-loop poss replace] 4)) 0 ispell-add-per-file-word-list ispell-word get-buffer ispell-choices-buffer kill-buffer ispell-pdict-save ispell-silently-savep ispell-quit] 7 "\
Check spelling of word under or before the cursor.
If the word is not found in dictionary, display possible corrections
in a window and so you can choose one.

With a prefix argument (or if CONTINUE is non-nil),
resume interrupted spell-checking of a buffer or region.

If optional argument FOLLOWING is non-nil or if `ispell-following-word'
is non-nil when called interactively, then the following word
(rather than preceding) is checked when the cursor is not over a word.
When the optional argument QUIETLY is non-nil or `ispell-quietly' is non-nil
when called interactively, non-corrective messages are suppressed.

Word syntax described by `ispell-dictionary-alist' (which see).

This will check or reload the dictionary.  Use \\[ispell-change-dictionary]
or \\[ispell-region] to update the Ispell process." (list nil nil current-prefix-arg)])
(defalias 'ispell-get-word #[(following &optional extra-otherchars) "À Â Ä Æ 	ÈÉ\n… \nÉP	Ë„& \nƒ* Ì‚+ É°ÎÎÎÎÓ	!„U ƒO Õ	dÖ#ˆ‚U ×	eÖ#ˆ×eÐ#ˆÓ!„m \nƒ· Ó\n!ƒ· o„· ƒ{ ƒ· \nƒš Ó\n!ƒš ØÙ!ˆÓ	!ƒ[ ×eÚ#ˆ‚[ ÖØÙ!ˆÓ	!ƒ° ×eÚ#ˆ‚[ ØÛ!ˆ‚[ ÕdÖ#„Ä ÜÝ!ˆÞ”`{‰E.	‡" [ispell-get-casechars ispell-casechars ispell-get-not-casechars ispell-not-casechars ispell-get-otherchars ispell-otherchars ispell-get-many-otherchars-p ispell-many-otherchars-p "+\\(" "?" extra-otherchars "+\\)" "*" word-regexp nil did-it-once start end word looking-at following re-search-forward t re-search-backward backward-char 1 move -1 error "No word found to check!" 0] 9 "\
Return the word for spell-checking according to ispell syntax.
If optional argument FOLLOWING is non-nil or if `ispell-following-word'
is non-nil when called interactively, then the following word
(rather than preceeding) is checked when the cursor is not over a word.
Optional second argument contains otherchars that can be included in word
many times.

Word syntax described by `ispell-dictionary-alist' (which see)."])
(defalias 'ispell-pdict-save #[(&optional no-query force-save) "ƒ\f <ƒ\f @„ 	ƒ$ \n„ ÃÄ!ƒ$ ÅÇ\"ˆÈ‰‡" [ispell-pdict-modified-p force-save no-query y-or-n-p "Personal dictionary modified.  Save? " process-send-string ispell-process "#\n" nil] 3 "\
Check to see if the personal dictionary has been modified.
If so, ask if it needs to be saved." (list ispell-silently-savep t)])
(defalias 'ispell-command-loop #[(miss guess word) "ÀÁÂ ÃZ\f^ÇÈÉ‰‰\n\fŠÓ!qˆÕ× ˆƒy ÙÚ±ˆƒe i@GÃ\\\\Û VƒU ÜcˆT@Ý±ˆA‰„? Þß±ˆƒu à‚v Á\\ƒÚ i@GáVƒŽ à‚ Èâ\\\\\\Û Vƒ¥ ãcˆT‰‚§ WƒÚ >ƒÂ TT‚­ äå@æ±ˆAT‚y ZÀZ)ç!‰(ƒ.Â(!š„&Š`)êÂ(!Z!ˆ`)Xƒëì `\"ˆ*íî !ˆïÂ(!Z!ˆ‚;í(!ˆ‚;ð]!ˆñ!ˆ)ebˆíò !ˆó ˆôõöP!ˆ÷8ùú!ƒ[ú ‚]û \fÈ<„n\fâUƒtý\fÉ<)‰>ƒœ>@ÀVƒ“>@\fWƒ“T>A‰>„}\fZÀZ)\fÿUƒ±É‚f\f@ UƒÑA BC DãQ\"ˆE FÉ‚f\fG U„ã\fH UƒA BI DãQ\"ˆF„ûFCF\fH U…fÈ‚f\fJ U„\fK UƒD\fK U„(Lƒ6M N D\"÷D‚fM O D\"ÉB‚f\fP U„^\fQU„^\fR UƒgS  ˆ÷‚f\fT Uƒ„U V!ˆôW !ˆ÷XÉ‚f\fýUƒ­U V!ˆôY Z [ P!!ˆe`DGZ]XÉ‚f\f\\ UƒÚ] ^ !ƒÖ_ ÷!ˆ`?†Í`XÉ‰F‚f÷‚f\fa UƒµM b D\"Ác‰dƒ°ŠÓ!qˆ× ˆÀÈÕe d!‰ƒsi@GáVƒ'à‚(Èâ\\\\\\Û Vƒ>ãcˆcT‰c‚@cWƒs>ƒ[TT‚Fäå@æ±ˆAT‚ZÀZ)íî !ˆcU„«cVƒïcZ!ˆ‚§f cZ!ˆcíò !ˆ*÷‚f\fg UƒÖA BC D—ãQ\"ˆh FÉ‚f\fi Uƒ A BC M j D\"ãQ\"ˆk FDÉB‚fÈYƒ&Wƒ&Lƒ\f8l D‚f\f8‚f\fm Uƒ8n  ˆ÷‚f\fo UƒJp ‹ˆ÷‚f\fq Uƒ`r s ! ˆ÷‚ft  ˆ÷‰\n÷=„D\n.\n‡" [48 2 window-height 4 miss window-min-height ispell-choices-win-default-height (32 105 97 65 114 82 63 120 88 113 108 117 109) 0 nil result num char skipped command-characters choices max-lines line count get-buffer-create ispell-choices-buffer "--  %b  --" mode-line-format erase-buffer guess "Affix rules generate and capitalize " "this word as shown below:\n	" window-width "\n	" "    " "\nUse option `i' if this is a correct composition" " from the derivative root.\n" 3 126 7 "\n" "(" ") " "  " get-buffer-window choices-window cur-point move-to-window-line set-window-start selected-window select-window previous-window enlarge-window ispell-overlay-window switch-to-buffer next-window undo-boundary message "C-h or ? for more options; SPC to leave " "unchanged, Character to replace word" t inhibit-quit fboundp read-char-exclusive read-char quit-flag 88 com-chars 32 105 process-send-string ispell-process "*" word (t) ispell-pdict-modified-p 97 65 "@" 114 82 ispell-query-replace-choices read-string "Query-replacement for: " "Replacement for: " 63 help-char 8 ispell-help 120 ispell-pdict-save ispell-silently-savep "Exited spell-checking" ispell-quit substitute-command-keys "Spell-checking suspended;" " use C-u \\[ispell-word] to resume" 113 y-or-n-p "Really kill Ispell process? " ispell-kill-ispell ispell-checking-message 108 "Lookup string (`*' is wildcard): " new-line new-word lookup-words shrink-window 117 (t) 109 "Insert: " (t) query-replace 12 redraw-display 18 ((recursive-edit)) 26 key-binding "" ding] 11 "\
Display possible corrections from list MISS.
GUESS lists possibly valid affix construction of WORD.
Returns nil to keep word.
Returns 0 to insert locally into buffer-local dictionary.
Returns string for new chosen word.
Returns list for new replacement word (will be rechecked).
Global `ispell-pdict-modified-p' becomes a list where the only value
indicates whether the dictionary has been modified when option `a' or `i' is
used."])
(defalias 'ispell-help #[nil "ÀÁPÂÃPÄÅPÉ‹+‡" ["[r/R]eplace word; [a/A]ccept for this session; " "[i]nsert into private dictionary" "[l]ook a word up in alternate dictionary;  " "e[x/X]it;  [q]uit session" "[u]ncapitalized insert into dictionary.  " "Type 'C-h d ispell-help' for more help" help-3 help-2 help-1 ((byte-code "ƒ\" ÁÂ!ˆÃÄÅ!!ˆÇÇ	°cˆÊË!ˆÌÅ!‡ÍÎ !ˆÏ ˆÐÑ\"ƒO Ó	!ˆÔÕ!ˆÓ!ˆÔÕ!ˆÓ!ˆebˆ‚j Ö™ƒZ Ó×!ˆÔØ!ˆÇÇ	°cˆÊË!ˆÏ ‡" [ispell-help-in-bufferp ispell-overlay-window 4 switch-to-buffer get-buffer-create "*Ispell Help*" help-1 "\n" help-2 help-3 sit-for 5 kill-buffer select-window minibuffer-window erase-buffer string-match "Lucid" emacs-version message enlarge-window 1 "19" nil 2] 5))] 4 "\
Display a list of the options available when a misspelling is encountered.

Selections are:

DIGIT: Replace the word with a digit offered in the *Choices* buffer.
SPC:   Accept word this time.
`i':   Accept word and insert into private dictionary.
`a':   Accept word for this session.
`A':   Accept word and place in `buffer-local dictionary'.
`r':   Replace word with typed-in value.  Rechecked.
`R':   Replace word with typed-in value. Query-replaced in buffer. Rechecked.
`?':   Show these commands.
`x':   Exit spelling buffer.  Move cursor to original point.
`X':   Exit spelling buffer.  Leaves cursor at the current point, and permits
        the aborted check to be completed later.
`q':   Quit spelling session (Kills ispell process).
`l':   Look up typed-in replacement in alternate dictionary.  Wildcards okay.
`u':   Like `i', but the word is lower-cased first.
`m':   Like `i', but allows one to include dictionary completion information.
`C-l':  redraws screen
`C-r':  recursive edit
`C-z':  suspend emacs or iconify frame"])
(defalias 'lookup-words #[(word &optional lookup-dict) "„ 	\nÄÅ\"… 	† ?\nËÌ!\nƒ- ‚/ \nƒ; ‚= ÔÔÔØŽÙ‹ˆ).	‡" [lookup-dict ispell-alternate-dictionary ispell-use-ptys-p process-connection-type string-match "\\*" word wild-p ispell-look-p ispell-have-new-look look-p get-buffer-create "*Ispell-Temp*" ispell-grep-buffer ispell-look-command ispell-grep-command prog ispell-look-options ispell-grep-options args nil status results loc ((byte-code "À	!ˆ\nƒ ÃÄ\n@\"ƒ ÅÆ\n@#ˆÀ‡" [kill-buffer ispell-grep-buffer results string-match ".+: " error "%s error: %s" ispell-grep-command] 4)) ((byte-code "ÀÁÂ!\"ˆ\fqˆ„* ÆÈ±ˆÉÊËÌ#ƒ# Ícˆ‚ Î Ï ˆÐËÌË&‰;ƒN ÔÕÂ!#B‚u dbˆo„^ h×U„^ ×cˆo„u `Ùyˆ`S{B‚^ Ë‡" [message "Starting \"%s\" process..." file-name-nondirectory prog ispell-grep-buffer look-p "^" word "$" search-backward "*" nil t "." buffer-string erase-buffer call-process args lookup-dict status format "error: %s exited with signal %s" results 10 loc -1] 9))] 3 "\
Look up word in word-list dictionary.
A `*' serves as a wild card.  If no wild cards, `look' is used if it exists.
Otherwise the variable `ispell-grep-command' contains the command used to
search for the words (usually egrep).

Optional second argument contains the dictionary to use; the default is
`ispell-alternate-dictionary'."])
(defalias 'ispell-filter #[(process output) "ÀÁÂ\f…` ÆÇ#	ƒ0 \nƒ0 \n<ƒ0 \n‰@OP ˆ‚: O\nB\n„G Á	Â‰‚ Â	T‰GUƒ[ Â‰‚ ‚ +‡" [0 t nil end continue start string-match "\n" output ispell-filter-continue ispell-filter] 6 "\
Output filter function for ispell, grep, and look."])
(defalias 'ispell-highlight-spelling-error-generic #[(start end &optional highlight) "À Á\n{ÄÁ	\n|ˆÊË\nZ\"ˆÌÍ!ˆƒ* ?\n|ˆcˆÌÍ!ˆƒ@ ?Ð	!-‡" [buffer-modified-p nil start end t buffer-undo-list inhibit-quit text buffer-read-only modified insert-char 32 sit-for 0 highlight inverse-video set-buffer-modified-p] 5 "\
Highlight the word from START to END with a kludge using `inverse-video'.
When the optional third arg HIGHLIGHT is set, the word is highlighted;
otherwise it is displayed normally."])
(defalias 'ispell-highlight-spelling-error-lucid #[(start end &optional highlight) "ƒ	 Á\n\"‡ÄÅ!‡" [highlight isearch-highlight start end isearch-dehighlight t] 3 "\
Highlight the word from START to END using `isearch-highlight'.
When the optional third arg HIGHLIGHT is set, the word is highlighted
otherwise it is displayed normally."])
(defalias 'ispell-highlight-spelling-error-overlay #[(start end &optional highlight) "ƒ Á\n\"Å\fÆ#‡È\f!‡" [highlight make-overlay start end ispell-overlay overlay-put face ispell-highlight-face delete-overlay] 4 "\
Highlight the word from START to END using overlays.
When the optional third arg HIGHLIGHT is set, the word is highlighted
otherwise it is displayed normally.

The variable `ispell-highlight-face' selects the face to use for highlighting."])
(byte-code "ÀÁÂ\"ƒ\f Ä‚ Å™ƒ ÆÇ!ƒ È‚ ÉKM‡" [ispell-highlight-spelling-error string-match "Lucid" emacs-version ispell-highlight-spelling-error-lucid "19" featurep faces ispell-highlight-spelling-error-overlay ispell-highlight-spelling-error-generic] 4)
(defalias 'ispell-overlay-window #[(height) "ŠŠÀyˆ`)ŠÁ\n!ˆ`)‰Wƒ \fÅÆÇ \"ƒ# \nTÈÉ\n\"ˆÊË \"+‡" [-1 move-to-window-line height top oldot string-match "19.9.*Lucid" emacs-version split-window nil set-window-start next-window] 4 "\
Create a window covering the top HEIGHT lines of the current window.
Ensure that the line above point is still visible but otherwise avoid
scrolling the current window.  Leave the new window selected."])
(defalias 'ispell-parse-output #[(output) "Á˜ƒ Â‡Ã˜ƒ Â‡Ä˜ƒ Â‡ÅÆOÇ˜ƒ& ÈÉO‡ÅÆOÈÊËÈ#OÅÉ‰‰‰\fÅ•ÉOÓ˜ƒX Å‚g Ô!ÊËÆ#TÉOÔ!\fÓ˜ƒx É‚‚ ÊËÆ#TÉOƒÅ ÊÕ\"T‰Vƒ¥ ÅOB‚¯ ÅOBÆ•ƒ¹ É‚Á È\\ÉO)‚‚ \fF.‡" [output "" t "*" "-" 0 1 "+" 2 nil string-match " " offset guess-list miss-list count cur-count original-word type "#" string-to-int ", \\|\\($\\)" end] 8 "\
Parse the OUTPUT string from Ispell and return:
1: t for an exact match.
2: A string containing the root word for a match via suffix removal.
3: A list of possible correct spellings of the format:
   '(\"ORIGINAL-WORD\" OFFSET MISS-LIST GUESS-LIST)
   ORIGINAL-WORD is a string of the possibly misspelled word.
   OFFSET is an integer giving the line offset of the word.
   MISS-LIST and GUESS-LIST are possibly null lists of guesses and misses."])
(defalias (quote check-ispell-version) #[nil "ŠÀÁ!qˆÂ ˆÃ\fÅÆÅÇ%Æ	ebˆ	Ê>„4 ËÌ\f	;ƒ, Í‚- Î	$ˆ‚] ÏÐÑÒÔ#ÕQÅÆ#„] ËÖ@\fÏ×ÅÆ#ƒZ Ø”Ø•{‚[ Ù$ˆÚp!+‡" [get-buffer-create " *ispell-tmp*" erase-buffer call-process ispell-program-name nil t "-v" case-fold-search status (0 nil) error "%s exited with %s %s" "signal" "code" re-search-forward "\\b\\(" mapconcat regexp-quote ispell-required-versions "\\|" "\\)\\b" "version mismatch: ispell.el is for %s, %s is %s" "version \\([0-9][0-9.]+\\)\\b" 1 "an unknown version" kill-buffer] 8])
(defalias 'ispell-init-process #[nil "ƒ Á!Â=ƒ ƒ \fšƒ ÆÆ‰‡ÉÊ!ˆËÌ!ˆÍÎ!ˆÏ ˆÒÓÔÆÖ×ÆƒE Û ƒX ÜÝD\"ƒg ÜÞß!D\"Ü \"‰)&)ÆÆáÇ\"ˆâ!ˆ„’ ãä!ˆ‚¹ A„¨ @;ƒ¨ åæ@\"„¹ çè!ˆâ ˆãéêëì#\"ˆÆí ‰.ƒÌ ï.ìP\"ˆ)ð!‡" [ispell-process process-status run ispell-personal-dictionary ispell-process-directory default-directory nil ispell-filter ispell-filter-continue ispell-kill-ispell t message "Starting new Ispell process..." sit-for 0 check-ispell-version ispell-use-ptys-p process-connection-type apply start-process "ispell" ispell-program-name "-a" "-m" args ispell-local-dictionary ispell-dictionary ispell-get-ispell-args append "-d" "-p" expand-file-name ispell-extra-args set-process-filter accept-process-output error "%s did not output version line" string-match "^@(#) " sleep-for 1 "%s" mapconcat identity "\n" ispell-get-extended-character-mode extended-char-mode process-send-string process-kill-without-query] 13 "\
Check status of Ispell process and start if necessary."])
(defalias 'ispell-kill-ispell #[(&optional no-error) "ƒ\f Á!Â=„ † ÄÅ!‡Æ!ˆÇÈÉ!ˆÇ‡" [ispell-process process-status run no-error error "There is no ispell process running!" kill-process nil message "Ispell process killed"] 2 "\
Kill current Ispell process (so that you may start a fresh one).
With NO-ERROR, just return non-nil if there was no Ispell running." nil])
(defalias 'ispell-change-dictionary #[(dict &optional arg) "Ášƒ ÂÃšƒ ÄÅ† † Á\"‡šƒ4 šƒ4 ÄÈ†2 Á\"‡É\n\"ƒS „E „H „X ‚X ÌÍ\"ˆÎÏ!ˆÄÐšƒj Ã‚t ƒs Ñ‚t Òš„ „† ‚ˆ †Œ Á#‡" [dict "default" nil "" message "Using %s dictionary" ispell-local-dictionary ispell-dictionary "No change, using %s dictionary" assoc ispell-dictionary-alist arg error "Illegal dictionary: %s" ispell-kill-ispell t "(Next %sIspell command will use %s dictionary)" "global " "local "] 5 "\
Change `ispell-dictionary' (q.v.) and kill old Ispell process.
A new one will be started as soon as necessary.

By just answering RET you can find out what the current dictionary is.

With prefix argument, set the default directory." (list (completing-read "Use new dictionary (RET for current, SPC to complete): " (cons (cons "default" nil) ispell-dictionary-alist) nil t) current-prefix-arg)])
(defalias 'ispell-region #[(reg-start reg-end) "À ˆÁŽŠÂÃ\feUƒ dUƒ Æ ‚ Ç\"ˆÈ‹ˆ	*?‡" [ispell-accept-buffer-local-defs ((byte-code "À	!ƒ\n Â	!ˆƒ9 §„ \fÅ‰“ˆ‚$ \fÅ“ˆbˆƒ4 §ƒ4 ÅÈÉ!ˆÅ‚G \fÅ‰“ˆÊ!ˆÌÍ!ˆÅ‡" [get-buffer ispell-choices-buffer kill-buffer ispell-quit ispell-region-end nil reg-end ispell-checking-message error "Message send aborted." ispell-pdict-save ispell-silently-savep message "Spell-checking done"] 3)) message "Spell checking %s..." reg-start reg-end buffer-name "region" ((byte-code "bˆÁ„Þ`\fWƒÞ`ÅŠÁˆ`\f^)Æ Á	\nlƒ0 Ìuˆ‚P„¹ ƒ¹ Ï	Ð#ƒ¹ `ZGUƒf Ò˜ƒ\\ Ìyˆ‚PÏ\fÓ#ˆ‚P`GZ‰SbˆÔÕ!ƒ SUƒ‹ G\\‚ SbˆÖÐ#„§ Ö×Ð#ƒ± Ø{ÙQbˆ)‚PƒÖ	Ð#ƒ`ÜZUƒï Ö\fÐ#„PÞ!ˆà ˆáâãP!ˆ`ÜZ‚P`ÜZbˆÖÐ#„Ö×Ð#ƒØ{ÙQbˆ)‚PÔä!ƒ)Ìuˆ‚PÖ	Ð#„<Ö×	Ð#ƒMØ	{ÙQ	bˆ‚PÌyˆ`	ƒÖÁ%æ'\"ˆè'!ˆ)@Ò˜ƒb)AŸ)„Õ)ƒÕê)@!‰%<ƒÍ\n%A@\\\\‰+%@G\\,Á-+bˆî ˆ,bˆî ˆ+bˆî ˆ,Ï%@,Ð#ˆ`U„ÑïðñP%@+#ˆòŽ3ƒàô+,Ð#ˆõÅ!ˆ6ƒþ÷%AA@%AAA@%@#-‚ø‹ˆ)-ƒ]-<ƒ]Á)+,{-@G%@GZ9\f9\\\n9\\\n)+,|ˆ-@cˆ-A@ú=„Jû-@G!ˆ`	-A@ƒ¾üŽý‹ˆ)‚¾-ƒi-Åšƒ‘-Åšƒwþ%@\f\"?ƒ¾?<ƒ¾?@?Á)+	‚¾-ƒ¾+,|ˆ-cˆ-G%@GZ9\f9\\\n9\\\n	9\\	)„Èá@ !ˆõÅ!ˆ+)A)‚u)	bˆ-‚ )Á‡" [reg-start nil transient-mark-mode ispell-quit reg-end 0 ispell-get-casechars string ispell-casechars end offset-change start 1 ispell-check-comments comment-start search-forward t comment-end "" limit looking-at "\\\\" re-search-forward "[][()$]" "^" "\n" ispell-skip-tib ispell-tib-ref-beginning 2 ispell-tib-ref-end ispell-pdict-save ispell-silently-savep ding message "Open tib reference--set `ispell-skip-tib'" " to nil to avoid this error" "[---#@*+!%~^]" poss process-send-string ispell-process accept-process-output ispell-filter ispell-parse-output word-start word-end replace ispell-horiz-scroll error "Ispell misalignment: word " "`%s' point %d; please retry" ((byte-code "ƒ	 Á\n\"ˆÁ‡" [ispell-highlight-p ispell-highlight-spelling-error word-start word-end] 3)) ispell-highlight-p ispell-highlight-spelling-error sit-for ispell-keep-choices-win ispell-command-loop ((byte-code "À	AA@	AAA@	@#À‡" [ispell-command-loop poss replace] 4)) change query-replace backward-char ((byte-code "À	!	Ã‰“‡" [marker-position ispell-query-replace-marker reg-end nil] 3)) ((byte-code "	Â“ˆÃ\f@Æ#‡" [ispell-query-replace-marker reg-end nil query-replace string replace t] 4)) ispell-add-per-file-word-list ispell-pdict-modified-p "Continuing spelling check..."] 6)) ispell-quit] 4 "\
Interactively check a region for spelling errors." "r"])
(defalias 'ispell-buffer #[nil "Àed\"‡" [ispell-region] 3 "\
Check the current buffer for spelling errors interactively." nil])
(defalias (quote ispell-continue) #[nil "À	!„\n ÂÃ!‡Ä	!pš„ ÂÅÆÄ	!!\"‡Ç`À	!\"‡" [marker-position ispell-region-end message "No session to continue.  Use 'X' command when checking!" marker-buffer "Must continue ispell from buffer %s" buffer-name ispell-region] 5 nil nil])
(defalias 'ispell-horiz-scroll #[nil "…5 iÁ Â]Z‰ÄWƒ! Á ÄVƒ! Å[Æ]!‚4 Ç ÈZY…4 ÉÇ ZÊZÆ]!)‡" [truncate-lines window-hscroll 1 column 0 scroll-right 10 window-width 2 scroll-left -3] 4 "\
Places point within the horizontal visibility of its window area."])
(defalias 'ispell-complete-word #[(&optional interior-frag) "`ÀÁÀÂ\"À‰‰‰	A@AA@@‰Ê˜†: Ë\f…3 ÍÍQ\"‰Ï=ƒH ÐÑ!ˆ‚â \f„U ÐÒ\"ˆ‚â ÓÔ\"ƒe ÕÖ\f\"‚‚ Ó×\"ƒu ÕØ\f\"‚‚ ÓÙ\"ƒ‚ ÕÚ\f\"ÛŽƒ ÝÏ#ˆÞ‹ˆ)ßšƒ¢ à!ˆ‚Ö ƒÖ |ˆ:„´ ‚¶ @‰GZZ	\\	cˆ:ƒÖ 	bˆáÀÏ\"ˆâ#!ƒâ ä#!ˆå&!ˆ	b.‡" [nil ispell-get-word "\\*" replacement possibilities end start word case-fold-search cursor-location "" lookup-words interior-frag "*" ispell-complete-word-dict t message "No word to complete" "No match for \"%s\"" string-match "^[^A-Z]+$" mapcar downcase "^[^a-z]+$" upcase "^[A-Z]" capitalize ((byte-code "ƒ	 Á\n\"ˆÁ‡" [ispell-highlight-p ispell-highlight-spelling-error start end] 3)) ispell-highlight-p ispell-highlight-spelling-error ((byte-code "À	Â#Â‡" [ispell-command-loop possibilities nil word replacement] 4)) 0 ispell-add-per-file-word-list ispell-word get-buffer ispell-choices-buffer kill-buffer ispell-pdict-save ispell-silently-savep] 8 "\
Look up word before or under point in dictionary (see lookup-words command)
and try to complete it.  If optional INTERIOR-FRAG is non-nil then the word
may be a character sequence inside of a word.

Standard ispell choices are then available." "P"])
(defalias 'ispell-complete-word-interior-frag #[nil "ÀÁ!‡" [ispell-complete-word t] 2 "\
Completes word matching character sequence inside a word." nil])
(defvar ispell-message-text-end (mapconcat (quote identity) (quote ("^%!PS-Adobe-2.0" "^begin [0-9][0-9][0-9] .*\nM.*\nM.*\nM" "^#! /bin/sh" "\\(diff -c .*\\)?\n\\*\\*\\* .*\n--- .*\n\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*" "^[-=_]+\\s ?cut here")) "\\|") "\
*End of text which will be checked in ispell-message.
If it is a string, limit at first occurence of that regular expression.
Otherwise, it must be a function which is called to get the limit.")
(defalias 'ispell-message #[nil "ŠebˆŠÀÁÂ!ÄQÅÆ#)È	„ d‚: Ê	!ƒ5 À	ÅÆ#ƒ1 Ë”‚: d‚: d	 ^!\fÍÎ!ƒQ ÏÐ ÑÒÓ!°‚¹ ÍÕ!ƒe ÏÑÒÓ!°‚¹ ×šƒ ØÒƒz Ó!‚{ ÚQ‚¹ Ûšƒ Ó!‚¹ „œ ÝÒÞÒß°‚¹ àá!ƒ¬ âÒÓ!!Q‚¹ ƒ¸ Ó!‚¹ Ú#ä#P%æ#ÑQ'()Æ(Æ*ebˆƒá `W‚é ëì!ƒ!m?ƒ!ëí!ƒË•bˆëî!„ëï!„)(ð`Åˆëñ!ƒòˆ‚`\"ˆ)óyˆ‚Õ Å(ë!ƒ-óyˆ`\fWƒ‚ë%!ƒV`\fWƒV`4óyˆ4`=ƒRÅˆ)‚4`\fWƒ-ŠÀ'\fõ#ƒmË”‚qö\f!)5ð`5\"ˆ5bˆ)‚-\fÅ‰“.	‡" [re-search-forward "^" regexp-quote mail-header-separator "$" nil t internal-messagep copy-marker ispell-message-text-end char-or-string-p 0 limit featurep supercite "\\(" sc-cite-regexp "\\)" "\\|" ispell-non-empty-string sc-reference-tag-string sc major-mode news-reply-mode "In article <" mail-yank-prefix "^   \\|^	" mh-letter-mode mh-ins-buf-prefix "In [a-zA-Z.]+ you write:" "In <[^,;&+=]+> [^,;&+=]+ writes:" " *> *" boundp vm-included-text-prefix "[^,;&+=]+ writes:" cite-regexp "^[ 	]*$\\|" cite-regexp-start "^\\(" cite-regexp-end case-fold-search old-case-fold-search ispell-checking-message looking-at "[a-zA-Z---]+:\\|	\\| " "Subject: *" ".*Re\\>" "\\[" ispell-region "\n[ 	]" 2 1 point1 end marker-position] 6 "\
Check the spelling of a mail message or news post.
Don't check spelling of message headers except the Subject field.
Don't check included messages.

To abort spell checking of a message REGION and send the message anyway,
use the `x' or `q' command.  (Any subsequent regions will be checked.)
The `X' command aborts the message send so that you can edit the buffer.

To spell-check whenever a message is sent, include the appropriate lines
in your .emacs file:
   (add-hook 'news-inews-hook 'ispell-message)
   (add-hook 'mail-send-hook  'ispell-message)
   (add-hook 'mh-before-send-letter-hook 'ispell-message)

you can bind this to the key C-c i in GNUS or mail by adding to
`news-reply-mode-hook' or `mail-mode-hook' the following lambda expression:
   (function (lambda () (local-set-key \"\\C-ci\" 'ispell-message)))" nil])
(defalias (quote ispell-non-empty-string) #[(string) "ƒ\n Á˜ƒ\f Â‡Ã!‡" [string "" "\\'\\`" regexp-quote] 2])
(defalias 'ispell-accept-buffer-local-defs #[nil "À ˆÁ ˆÂ ‡" [ispell-buffer-local-dict ispell-buffer-local-words ispell-buffer-local-parsing] 1 "\
Load all buffer-local information, restarting ispell when necessary."])
(defalias 'ispell-buffer-local-parsing #[nil "À	Â\"ˆÄ=ƒ ÅÆÇ!\"„ É=ƒ# À	Ê\"ˆ‚( À	Ë\"ˆÌ ‰ƒ8 À	ÎP\"ˆ)ŠebˆÏÑÒ#…¦ ŠÑˆ`)ÒÑÖ×Ò#ƒ¢ Ø”Ø•{ÅÙ\"ƒt À	Ê\"ˆ‚T ÅÚ\"ƒ„ À	Ë\"ˆ‚T ÅÛ\"ƒ— À	ÎP\"ˆ‚T ÜÝ!ˆÞß!ˆ‚T +‚= )‡" [process-send-string ispell-process "!\n" ispell-parser use-mode-name string-match "[Tt][Ee][Xx]-mode" symbol-name major-mode tex "+\n" "-\n" ispell-get-extended-character-mode extended-char-mode "\n" search-forward ispell-parsing-keyword nil t string case-fold-search end re-search-forward " *\\([^ \"]+\\)" 1 "latex-mode" "nroff-mode" "~" message "Illegal Ispell Parsing argument!" sit-for 2] 5 "\
Place Ispell into parsing mode for this buffer.
Overrides the default parsing mode.
Includes latex/nroff modes and extended character mode."])
(defalias 'ispell-buffer-local-dict #[nil "ŠebˆÀÂÀÄ#ƒ' ŠÀˆ`)ÅÆ	Ä#ƒ Ç”Ç•{‚ ebˆÂ	ÀÄ#ƒL ŠÀˆ`)ÅÆ	Ä#ƒ* Ç”Ç•{\n‚* *\nƒb \nš„b ÌÄ!ˆ\n…t š?…t Î!‡" [nil end search-forward ispell-dictionary-keyword t re-search-forward " *\\([^ \"]+\\)" 1 ispell-local-dictionary ispell-pdict-keyword ispell-local-pdict ispell-personal-dictionary ispell-kill-ispell ispell-dictionary ispell-change-dictionary] 4 "\
Initializes local dictionary.
When a dictionary is defined in the buffer (see variable
`ispell-dictionary-keyword'), it will override the local setting
from \\[ispell-change-dictionary].
Both should not be used to define a buffer-local dictionary."])
(defalias 'ispell-buffer-local-words #[nil "ƒ Á š„ ÂÃ!ˆÄÅ ˆŠebˆÆÄÃ#…T „( Á ŠÄˆ`)Ä	ÊË	Ã#ƒP Ì”Ì•{ÍÏÐQ\"ˆ‚3 *‚ )‡" [ispell-buffer-local-name buffer-name ispell-kill-ispell t nil ispell-init-process search-forward ispell-words-keyword string end re-search-forward " *\\([^ ]+\\)" 1 process-send-string ispell-process "@" "\n"] 5 "\
Loads the buffer-local dictionary in the current buffer."])
(defalias 'ispell-add-per-file-word-list #[(word &optional reg-end) "„ Á \n„ ÃŠebˆÄ‰‰‰‰	„š ÊÄÌ#GÄˆiÎ\\\\ÏWƒD „I „ Ð„ƒ ÑÎ!ˆÓQ\n`Vƒg \nG\\cˆƒƒ Õš„ƒ ŠÑÎ!ˆÎyˆcˆ)\n`Vƒ‘ \nGÎ\\\\ÓPcˆ‚ .\n‡" [ispell-buffer-local-name buffer-name reg-end 0 nil string done search line-okay case-fold-search search-forward ispell-words-keyword move word 1 80 t open-line comment-start " " comment-end ""] 5 "\
Adds new word to the per-file word list."])
(byte-code "ÀÂÃ!‡" ["2.30 -- Fri May 20 15:58:52 MDT 1994" ispell-version provide ispell] 2)