;ELC   
;;; compiled by root@fuzzy on Sat Aug 27 10:49:53 1994
;;; from file /usr/lib/emacs/site-lisp/ispell.el
;;; emacs version 19.25.2.
;;; 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 "`/usr/lib/emacs/site-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.
Common values for GNU emacs 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(1) bibliography references when non-nil.
Skips any text between strings matching regular expressions
ispell-tib-ref-beginning and ispell-tib-ref-end is ignored.

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" "\
Options for 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.
Must contain complete path!")
(defvar ispell-look-p (file-exists-p ispell-look-command) "\
*Use look rather than grep when non-nil.
Attempts to automatically reset if look not available")
(defvar ispell-have-new-look nil "\
*Non-nil uses the `-r' option (regexp) when running look.")
(defvar ispell-look-options (byte-code "ƒ Á‡Â‡" [ispell-have-new-look "-dfr" "-df"] 1) "\
Options for ispell-look-command.")
(defvar ispell-use-ptys-p nil "\
When non-nil, emacs will use pty's to communicate with ispell.
When nil, emacs will use pipes.")
(defvar ispell-following-word nil "\
*Check word under or following cursor when non-nil.
Otherwise the preceding word is checked by ispell-word (\\[ispell-word]).")
(defvar ispell-help-in-bufferp nil "\
*Interactive keymap help is displayed in a buffer when non-nil.
Otherwise help is shown in the minibuffer.")
(defvar ispell-quietly nil "\
*Messages suppressed in ispell-word when non-nil and interactive.")
(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 "\
*A string or nil.  If nil, the default directory ~/.ispell_words is used.")
(defvar ispell-silently-savep nil "\
*When non-nil, save the personal dictionary without user verification.")
(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 call to ispell (e.g. in
your .emacs), or use the \\[ispell-change-dictionary] command to
change it, as changing 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.")
(defvar ispell-dictionary-alist (quote ((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) ("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))) "\
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 "À	™ƒu ÂÃ	\"ƒu ÄÅBB† ÉÅ\n\f\fƒQ \f@@\n\fA\f\n;ƒ$ ÍÎÏÐ\n!PÑ\nDÒ#C\"‚$ ÓÔ!„[ ÕÔÖ×#ˆƒq ØÙ!ˆÚÛÜ#ˆ,‚)ÝÞ!ƒ)À	™ƒ)ßÄÅBB!Å\n\fÓà!„— Å áÜ! \fƒÏ \f@@\n\fA\f\n;ƒœ â Îã\n!!ÏÐ\n!PäÅåÑ\nDFB#ˆ‚œ æà \"ˆâ çè#ˆâ éê#ˆâ ëì#ˆâ íî#ˆâ ïð#ˆâ ñò#ˆâ óô#ˆâ õö#ˆâ ÷ø#ˆâ ùú#ˆâ ûü#ˆ*Õýþÿ#ˆÅ‡" ["19" emacs-version string-match "Lucid" "default" nil ispell-dictionary-alist 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]) name menu dicts append vector "Select " capitalize ispell-change-dictionary t boundp ispell-menu-lucid put variable-documentation "Lucid's spelling menu." delete-menu-item ("Edit" "Spell") add-menu ("Edit") "Spell" featurep menu-bar reverse ispell-menu-map make-sparse-keymap define-key intern lambda (interactive) defalias [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))) ispell-region menu-enable mark-active] 9)
(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 "\
T when the personal dictionary has modifications that need to be written.")
(defvar ispell-quit nil "\
When non-nil the spell session is terminated.
When numeric, contains cursor location in buffer, and cursor remains there.")
(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")
(defvar ispell-local-dictionary nil "\
A buffer local variable. If non-nil, a dictionary to be used when running
an ispell-command in this buffer. 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.
If using Local Variable syntax, the dictionary must be a string.")
(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 a personal dictionary is specified for the current buffer which is
different from the current personal dictionary, the effect will be 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.

If using Local variable syntax, the dictionary must be nil or a string.")
(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) "tƒ \nÄ ˆ`ÅÆ	!Å‰‰‰	\n\fA@\nAA@	@„A ÎÏ!\"ˆÑ ˆÒÔ\"ˆÒÕÖQ\"ˆ×!ˆ@Ù˜ƒT A‰<ƒr Ú@!Û=ƒ‰ „)ÎÜ!\"ˆ‚);ƒ¤ „)ÎÝ!!#ˆ‚)„° ÎÞ!ˆ‚)ßŽ ƒ¿ á\n	Û#ˆâAA@AAA@@#)ãšƒâ ä@!ˆ‚ƒ\n	|ˆ:„ø ‚û @‰G	\nZZ\\cˆ:ƒbˆå	\"ˆæ'!ƒ)è'!ˆbˆé*!ˆ+…;Å‰+.‡" [ispell-following-word following ispell-quietly quietly ispell-buffer-local-dict nil ispell-get-word replace poss end start word ispell-keep-choices-win 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 ispell-command-loop 0 ispell-add-per-file-word-list ispell-word get-buffer ispell-choices-buffer kill-buffer ispell-pdict-save ispell-silently-savep ispell-quit] 8 "\
Check spelling of word under or before the cursor.
If word not found in dictionary, display possible corrections in a window
and let user select.
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) will be 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." nil])
(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) will be 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) "ÀŽÁ‹)‡" [((byte-code "„ Á\n!ˆÁ‡" [ispell-keep-choices-win bury-buffer ispell-choices-buffer] 2)) ((byte-code "ÀÁÂ ÃZ\f^ÇÈÉ‰‰\n\fŠƒ1 ÔÕ !ˆ‚: Ö!qˆØÚ!pšƒI Û ˆ‚O ÜÝÞP!ˆƒ˜ àá±ˆƒ„ i@GÃ\\\\â Vƒt ãcˆT@ä±ˆA‰„^ åæ±ˆƒ” ç‚• Á\\ƒù i@GèVƒ­ ç‚® Èé\\\\\\â VƒÄ êcˆT‰‚Æ Wƒù >ƒá TT‚Ì ëì@í±ˆAT‚˜ ZÀZ)ƒGVƒOî!ˆÔï !ˆŠ`0ñZ!ˆ`0Xƒ3òó `\"ˆ*ÔÕ !ˆôZ!ˆebˆ‚Oõ]!ˆî!ˆebˆÔï !ˆö ˆ÷øùP!ˆú;üý!ƒsý ‚uþ \f?„ƒ\féUƒ‹@ \fÉ?)È‰Aƒ¶A@ÀVƒ­A@\fWƒ­TAA‰A„—\fZÀZ)\fB UƒÍÉ‚k\fC UƒíD EF GêQ\"ˆH IÉ‚k\fJ U„ÿ\fK Uƒ$D EL GêQ\"ˆI„ICI\fK U…kÈ‚k\fM U„6\fN Uƒ`\fN U„DOƒRP Q G\"úD‚kP R G\"ÉB‚k\fS U„z\fTU„z\fU UƒƒV  ˆú‚k\fW U„•\fX Uƒ¶Y Z!ˆ÷[ !ˆ\fX Uƒ¯`‚°ú\\É‚k\f@ Uƒã] ^ !ƒß_ ú!ˆ`?†Ö`\\É‰I‚kú‚k\fa Uƒ¾P b G\"Ác‰dƒ¹ŠÖ!qˆÛ ˆÀÈØe d!‰ƒ|i@GèVƒ0ç‚1Èé\\\\\\â VƒGêcˆcT‰c‚IcWƒ|>ƒdTT‚Oëì@í±ˆAT‚ZÀZ)ÔÕ !ˆcU„´cVƒ¦ôcZ!ˆ‚°f cZ!ˆcÔï !ˆ*ú‚k\fg UƒßD EF G—êQ\"ˆh IÉ‚k\fi Uƒ	D EF P j G\"êQ\"ˆk IGÉB‚kÈYƒ/Wƒ/Oƒ(\f8l D‚k\f8‚k\fm UƒAn  ˆú‚k\fo UƒSp ‹ˆú‚k\fq Uƒer  ˆú‚ks  ˆú‰\nú=„\\\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 ispell-keep-choices-win select-window previous-window get-buffer-create ispell-choices-buffer "--  %b  --" mode-line-format get-buffer erase-buffer error "Bogus, dude! I should be in the *Choices*" " buffer, but I'm not!" 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" "(" ") " "  " switch-to-buffer next-window cur-point move-to-window-line set-window-start selected-window enlarge-window ispell-overlay-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 113 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 88 ispell-pdict-save ispell-silently-savep "exited ispell" ispell-quit y-or-n-p "Really quit ignoring changes? " 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 suspend-emacs ding] 11))] 1 "\
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 "\
This gives a list of available options when a misspelling is encountered.

Selections are:

DIGIT: Replace the word with a digit offered in the *Choices* buffer.
' ':   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"])
(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 '*' is used for wild cards.  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 by deleting and reinserting it
while toggling the variable \"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 that will be used
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 (usually small) 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.  Should leave the old
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 of '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 "Killed ispell process."] 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 done."] 3)) message "Spelling %s..." reg-start reg-end buffer-name "region" sit-for 0 ((byte-code "ƒ= p	‰ÄÅ !=„ ÆÇ\"ˆ	È	!ˆÉÊ!!ˆÌÎ ˆÏÐ !ˆp=„8 ÆÑ!ˆÒÓ!ˆ*bˆÕ„:`Wƒ:`ÓŠÕˆ`^)Ù Õlƒr ßuˆ‚• „ü !ƒü â!ã#ƒü `Z!GUƒ© $å˜ƒž ßyˆ‚•â$æ#ˆ‚•`!GZ‰&Sbˆçè!ƒÓ &SUƒÎ &!G\\&‚Ó &S&bˆé&ã#„ê éê&ã#ƒô ë&{ìQ&bˆ)‚•-ƒbé.ã#ƒb`ïZUƒ4é0ã#„•ñ2!ˆó ˆôõöP!ˆ`ïZ‚•`ïZ&bˆé&ã#„Péê&ã#ƒZë&{ìQ&bˆ)‚•ç÷!ƒnßuˆ‚•éã#„éêã#ƒ’ë{ìQbˆ‚•ßyˆ`ƒ2Õ8ù:\"ˆû:!ˆ<@å˜ƒ§<AŸ<„1<ƒ1ý<@!‰8<ƒ)8A@\\\\‰>8@G\\?Õ@>bˆA  ˆ?bˆA  ˆ>bˆA  ˆ?â8@?ã#ˆ`U„!ÆB C P8@>#ˆD ŽEƒ4F >?ã#ˆÒÓ!ˆG 8AA@8AAA@8@#@)@ƒ²@<ƒ²Õ<>?{@@G8@GZHH\\H\\)>?|ˆ@@cˆ@A@I =„›J @@G!ˆ`@A@ƒK ŽL ‹ˆ)‚@ƒ¾@Óšƒê@ÓšƒÐM 8@\"NƒN<ƒN@NÕ<>‚@ƒ>?|ˆ@cˆ@G8@GZHH\\H\\H\\)„$ôO !ˆÒÓ!ˆ+<A<‚º)bˆ-‚D )Õ‡" [ispell-keep-choices-win ispell-choices-win-default-height window-min-height ocb window-buffer selected-window error "current buffer is not visible in selected window: %s" ispell-overlay-window switch-to-buffer get-buffer-create ispell-choices-buffer "--  %b  --" mode-line-format erase-buffer select-window next-window "ispell is confused about current buffer!" sit-for 0 reg-start nil transient-mark-mode ispell-quit reg-end 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 "***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 ispell-command-loop 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) "`À‰ÁÀÂ\"À‰‰‰	\nA@AA@@‰Ë˜†= Ì…6 ÎÎQ\"‰Ð=ƒK ÑÒ!ˆ‚é \f„X ÑÓ\"ˆ‚é ÔÕ\"ƒh Ö×\f\"‚… ÔØ\"ƒx ÖÙ\f\"‚… ÔÚ\"ƒ… ÖÛ\f\"ÜŽƒ“ ÞÐ#ˆß\fÀ#)àšƒ© á!ˆ‚Ý ƒÝ |ˆ:„» ‚½ @‰GZZ\n\\\ncˆ:ƒÝ \nbˆâÀÐ\"ˆã$!ƒé å$!ˆæ'!ˆ\nb.‡" [nil ispell-get-word "\\*" replacement possibilities end start word ispell-keep-choices-win 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 ispell-command-loop 0 ispell-add-per-file-word-list ispell-word get-buffer ispell-choices-buffer kill-buffer ispell-pdict-save ispell-silently-savep] 9 "\
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--- " "^[-=_]+\\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ƒtë%!ƒH`\fWƒHóyˆ‚4`\fWƒ-ŠÀ'\fô#ƒ_Ë”‚cõ\f!)4ð`4\"ˆ4bˆ)‚-\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 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)

Or you can bind the function C-c i in gnus or mail by setting
news-reply-mode-hook or mail-mode-hook to 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 "\
Load 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 "\
Add new word to the per-file word list."])
(byte-code "ÀÂÃ!‡" ["2.29 -- Thu May 12 09:44:33 MDT 1994" ispell-version provide ispell] 2)