;ELC   
;;; compiled by rms@mole.gnu.ai.mit.edu on Fri Jun 16 12:25:22 1995
;;; from file /home/fsf/rms/e19/lisp/ispell.el
;;; emacs version 19.28.94.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.28.90")))
    (error "`ispell.el' was compiled for Emacs 19.29 or later"))


#@42 *Highlight spelling errors when non-nil.
(defvar ispell-highlight-p t (#$ . -473))
#@316 *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-highlight-face (quote highlight) (#$ . -563))
#@45 *Spelling of comments checked when non-nil.
(defvar ispell-check-comments nil (#$ . -945))
#@108 *Corrections made throughout region when non-nil.
Uses `query-replace' (\[query-replace]) for corrections.
(defvar ispell-query-replace-choices nil (#$ . -1043))
#@361 *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-skip-tib nil (#$ . -1212))
#@51 Regexp matching the beginning of a Tib reference.
(defvar ispell-tib-ref-beginning "[[<]\\." (#$ . 1620))
#@45 Regexp matching the end of a Tib reference.
(defvar ispell-tib-ref-end "\\.[]>]" (#$ . 1732))
#@105 *When not nil, the `*Choices*' window remains for spelling session.
This minimizes redisplay thrashing.
(defvar ispell-keep-choices-win t (#$ . -1833))
#@93 *The default size of the `*Choices*' window, including status line.
Must be greater than 1.
(defvar ispell-choices-win-default-height 2 (#$ . -1991))
#@66 Program invoked by \[ispell-word] and \[ispell-region] commands.
(defvar ispell-program-name "ispell" (#$ . 2147))
#@42 *Alternate dictionary for spelling help.
(defvar ispell-alternate-dictionary (byte-code "АБ!ѓ Б‡АВ!ѓ В‡АГ!ѓ Г‡АД!ѓ  Д‡АЕ!ѓ( Е‡АЖ!ѓ0 Ж‡Г‡" [file-exists-p "/usr/dict/web2" "/usr/share/dict/web2" "/usr/dict/words" "/usr/lib/dict/words" "/usr/share/dict/words" "/sys/dict"] 2) (#$ . -2268))
#@39 *Dictionary used for word completion.
(defvar ispell-complete-word-dict ispell-alternate-dictionary (#$ . -2564))
#@48 Name of the grep command for search processes.
(defvar ispell-grep-command "egrep" (#$ . 2684))
#@159 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-grep-options "-i" (#$ . 2787))
#@84 Name of the look command for search processes.
This must be an absolute file name.
(defvar ispell-look-command "look" (#$ . 2997))
#@105 *Non-nil means use `look' rather than `grep'.
Default is based on whether `look' seems to be available.
(defvar ispell-look-p (file-exists-p ispell-look-command) (#$ . -3135))
#@66 *Non-nil means use the `-r' option (regexp) when running `look'.
(defvar ispell-have-new-look nil (#$ . -3317))
#@54 String of command options for `ispell-look-command'.
(defvar ispell-look-options (byte-code "ѓ Б‡В‡" [ispell-have-new-look "-dfr" "-df"] 1) (#$ . 3435))
#@87 When non-nil, Emacs uses ptys to communicate with Ispell.
When nil, Emacs uses pipes.
(defvar ispell-use-ptys-p nil (#$ . 3596))
#@120 *Non-nil means `ispell-word' checks the word around or after point.
Otherwise `ispell-word' checks the preceding word.
(defvar ispell-following-word nil (#$ . -3732))
#@91 *Non-nil means display interactive keymap help in a buffer.
Otherwise use the minibuffer.
(defvar ispell-help-in-bufferp nil (#$ . -3905))
#@52 *Non-nil means suppress messages in `ispell-word'.
(defvar ispell-quietly nil (#$ . -4050))
#@127 *Formatting function for displaying word being spell checked.
The function must take one string argument and return a string.
(defvar ispell-format-word (quote upcase) (#$ . -4149))
#@184 *File name of your personal spelling dictionary, or nil.
If nil, the default personal dictionary, "~/.ispell_DICTNAME" is used,
where DICTNAME is the name of your default dictionary.
(defvar ispell-personal-dictionary nil (#$ . -4338))
#@67 *When non-nil, save the personal dictionary without confirmation.
(defvar ispell-silently-savep nil (#$ . -4580))
#@433 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-dictionary nil (#$ . 4701))
#@241 *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-extra-args nil (#$ . -5183))
(byte-code "АБ!„ ВБBАД!„ ЕДBА‡" [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) ("british" "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B" "-d" "british") nil) ("deutsch" "[a-zA-Z\"]" "[^a-zA-Z\"]" "[']" t ("-C") "~tex") ("deutsch8" "[a-zA-ZДЦЬдцЯь]" "[^a-zA-ZДЦЬдцЯь]" "[']" t ("-C" "-d" "deutsch") "~latin1") ("nederlands" "[A-Za-zА-ЕЗИ-ПТ-ЦЩ-Ьа-ези-пст-цщ-ь]" "[^A-Za-zА-ЕЗИ-ПТ-ЦЩ-Ьа-ези-пст-цщ-ь]" "[']" t ("-C") nil) ("nederlands8" "[A-Za-zА-ЕЗИ-ПТ-ЦЩ-Ьа-ези-пст-цщ-ь]" "[^A-Za-zА-ЕЗИ-ПТ-ЦЩ-Ьа-ези-пст-цщ-ь]" "[']" t ("-C") nil)) current-load-list 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") ("francais7" "[A-Za-z]" "[^A-Za-z]" "[`'^---]" t nil nil) ("francais" "[A-Za-zАВЖЗИЙКЛОПФЩЫЬавзийклопфщыь]" "[^A-Za-zАВЖЗИЙКЛОПФЩЫЬавзийклопфщыь]" "[---']" t nil "~list") ("francais-tex" "[A-Za-zАВЖЗИЙКЛОПФЩЫЬавзийклопфщыь\\]" "[^A-Za-zАВЖЗИЙКЛОПФЩЫЬавзийклопфщыь\\]" "[---'^`\"]" t nil "~tex") ("dansk" "[A-ZЖШЕa-zжше]" "[^A-ZЖШЕa-zжше]" "" nil ("-C") nil))] 2)
#@1661 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 an Ispell affix file.  (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).
(defvar ispell-dictionary-alist (append ispell-dictionary-alist-1 ispell-dictionary-alist-2) (#$ . 6688))
#@25 Key map for ispell menu
(defvar ispell-menu-map nil (#$ . 8460))
#@32 Spelling menu for Lucid Emacs.
(defvar ispell-menu-lucid nil (#$ . 8531))
(byte-code "?…\n БВ\"?ДB\fѓW ЖЗИB	B!И\nМН!ѓV @@\nA\n;ѓ$ ОПР\n!!СТ\n!PУИФХ\nDFB#€‚$ *\fѓy ОЦЧ#€ОШЩ#€ОЪЫ#€ОЬЭ#€ОЮЯ#€\fѓ• Оаб#€Овг#€Оде#€Ожз#€\fѓ° Оий#€Окл#€мноп#€А‰JM€р™ѓБВ\"ѓЗИB	B1†К 2уИ\n41ѓ@@\nA\n;ѓФ х4ПСТ\n!PХ\nDц#C\"4‚Ф 471ѓшщ!€ъыН7#€,И‡" [ispell-menu-map string-match "Lucid" emacs-version ispell-menu-map-needed current-load-list reverse "default" nil 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 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-word] ("Check Word" . ispell-word) [ispell-region] ("Check Region" . ispell-region) [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" 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) t] ["Change Dictionary" ispell-change-dictionary t]) menu append t ispell-menu-lucid delete-menu-item ("Edit" "Spell") add-menu ("Edit")] 9)
#@72 Ispell versions with which this version of ispell.el is known to work.
(defconst ispell-required-version (quote ("3.1." 12)) (#$ . 10569))
#@68 Offset that maps protocol differences between ispell 3.1 versions.
(defvar ispell-offset 1 (#$ . 10714))
(defalias 'ispell-get-casechars #[nil "А	\n\"A@‡" [assoc ispell-dictionary ispell-dictionary-alist] 3])
(defalias 'ispell-get-not-casechars #[nil "АБ\n\"8‡" [2 assoc ispell-dictionary ispell-dictionary-alist] 4])
(defalias 'ispell-get-otherchars #[nil "АБ\n\"8‡" [3 assoc ispell-dictionary ispell-dictionary-alist] 4])
(defalias 'ispell-get-many-otherchars-p #[nil "АБ\n\"8‡" [4 assoc ispell-dictionary ispell-dictionary-alist] 4])
(defalias 'ispell-get-ispell-args #[nil "АБ\n\"8‡" [5 assoc ispell-dictionary ispell-dictionary-alist] 4])
(defalias 'ispell-get-extended-character-mode #[nil "АБ\n\"8‡" [6 assoc ispell-dictionary ispell-dictionary-alist] 4])
#@32 The process object for Ispell.
(defvar ispell-process nil (#$ . 11488))
#@66 Non-nil means personal dictionary has modifications to be saved.
(defvar ispell-pdict-modified-p nil (#$ . 11566))
(byte-code "АБ!„ ВБBВ‡" [boundp ispell-quit nil current-load-list] 2)
#@43 Output filter from piped calls to Ispell.
(defvar ispell-filter nil (#$ . 11761))
#@46 Control variable for Ispell filter function.
(defvar ispell-filter-continue nil (#$ . 11849))
#@51 The directory where `ispell-process' was started.
(defvar ispell-process-directory nil (#$ . 11949))
#@40 Marker for `query-replace' processing.
(defvar ispell-query-replace-marker (make-marker) (#$ . 12056))
#@44 Non-nil when we're checking a mail message
(defvar ispell-checking-message nil (#$ . 12165))
(byte-code "АБ\nBБ‡" ["*Choices*" ispell-choices-buffer current-load-list] 2)
#@43 Overlay variable for Ispell highlighting.
(defvar ispell-overlay nil (#$ . 12344))
#@453 If non-nil, a dictionary to use for Ispell commands in this buffer.
The value must be a string dictionary name in `ispell-dictionary-alist'.
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.
(defvar ispell-local-dictionary nil (#$ . 12434))
(byte-code "АБ!€ВБГ\"‡" [make-variable-buffer-local ispell-local-dictionary set-default nil] 3)
#@175 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-words-keyword "LocalWords: " (#$ . 13039))
#@197 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-dictionary-keyword "Local IspellDict: " (#$ . 13280))
#@419 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'.
(defconst ispell-parsing-keyword "Local IspellParsing: " (#$ . 13554))
#@135 Skips spell checking of SGML tags and entity references when non-nil.
This variable is set when major-mode is sgml-mode or html-mode.
(defvar ispell-skip-sgml nil (#$ . 14050))
#@437 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.
(defvar ispell-local-pdict ispell-personal-dictionary (#$ . 14234))
(make-variable-buffer-local (quote ispell-local-pdict))
#@53 The keyword for defining buffer local dictionaries.
(defconst ispell-pdict-keyword "Local IspellPersDict: " (#$ . 14800))
#@128 Contains the buffer name if local word definitions were used.
Ispell is then restarted because the local words could conflict.
(defvar ispell-buffer-local-name nil (#$ . 14929))
#@357 *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-parser (quote use-mode-name) (#$ . -15114))
#@44 Marker that allows spelling continuations.
(defvar ispell-region-end (make-marker) (#$ . 15535))
#@61 If non-nil, `ispell-word' does not try to correct the word.
(defvar ispell-check-only nil (#$ . 15638))
(byte-code "А	™ѓ ВГ!„ ДЕЖ\"€ЗЙК#‡" ["19" emacs-version boundp epoch::version defalias ispell ispell-buffer define-key global-map "¤" ispell-word] 4)
#@812 Check spelling of word under or before the cursor.
If the word is not found in dictionary, display possible corrections
in a window allowing you to 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.
(defalias 'ispell-word #[(&optional following quietly continue) "ѓ Б ‡tѓ \n\fЖ €`З!И‰‰‰	\n\fA@\fAA@@„E ПР!\"€ТФ\"€ТХЦQ\"€Ч!€@ЩѓU A‰<ѓs Ъ@!\n\nЫ=ѓЉ „ПЬ!\"€‚\n;ѓҐ „ПЭ!\n!#€‚\n„± ПЮ!€‚ѓј а €‚б‹€	вљѓП г\n@!€‚	ѓ	:„Я 	‚в 	@‰G\fZZ\\\n@љ„\f|€c€	:ѓb€д\"€е&!ѓз&!€b€и)!€*…1И‰*.‡" [continue ispell-continue ispell-following-word following ispell-quietly quietly ispell-accept-buffer-local-defs ispell-get-word nil replace poss end start word cursor-location message "Checking spelling of %s..." ispell-format-word 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" ispell-check-only beep ((byte-code "А	AA@	AAA@	@\n%А‡" [ispell-command-loop poss start end replace] 6)) 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 (#$ . 15902) (list nil nil current-prefix-arg)])
#@420 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 preceding) 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-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 (#$ . 17835)])
#@96 Check to see if the personal dictionary has been modified.
If so, ask if it needs to be saved.
(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" message "Personal dictionary saved." nil] 3 (#$ . 18954) (list ispell-silently-savep t)])
#@496 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).
Highlights the word, which is assumed to run from START to END.
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-command-loop #[(miss guess word start end) "pАБВ ГZ\f^ЗИЙ‰‰‰‰\n\fЉЦ!q€ШPЫ €ѓ… ЭЮ±€ѓq i@GГ\\\\Я Vѓa аc€T@б±€A‰„K вг±€ѓЃ д‚‚ Б\\ѓж i@GеVѓљ д‚› Иж\\\\\\Я Vѓ± зc€T‰‚і Wѓж >ѓО TT‚№ ий@к±€AT‚… ZАZ)л,!„ы нИ!€о!‰/ѓdВ/!Uѓр/!€‚lВ/!Zсy€`23Wѓ83Z\\3фИ!€3y€хц `2VѓO2‚P`\"€,b€рч !€ш3!€*‚lщ]!€ъ!€eb€)ры ‰!€ьЋ=ѓЋю?,Ѓ@ #€ЃA  €ЃB ЃC ЃD P!€Ѓ@ EЃF ЃG !ѓµЃG  ‚№ЃH  ИI„КжUѓТЃJ ЙI)‰KѓъK@АVѓсK@WѓсTKA‰K„ЫZАZ)ЃL UѓЙ‚ЃM Uѓ1ЃN OЃP зQ\"€ЃQ RЙ‚ЃS U„CЃT UѓhЃN OЃU зQ\"€R„[RCRЃT U…И‚ЃV U„zЃW Uѓ¦ЃW U„€XѓЃY ЃZ \"Ѓ@ D‚ЃY Ѓ[ \"ЙB‚Ѓ\\ U„А]U„АЃ^ UѓЛЃ_  €Ѓ@ ‚Ѓ` UѓмЃa b!€ЃB Ѓc !€Ѓ@ dЙ‚ЃJ UѓЃa b!€ЃB Ѓe Ѓf Ѓg P!!€e`GZ]dЙ‚Ѓh UѓJЃi Ѓj !ѓDЃk Ѓ@ !€l?†;`dЙ‰R‚Ѓ@ ‚Ѓm UѓfЃY Ѓn \"Бo‰pѓ_ЉЦ!q€Ы €АИШpPЃq p!‰ѓжi@GеVѓљд‚›Иж\\\\\\Я Vѓ±зc€oT‰o‚іoWѓж>ѓОTT‚№ий@к±€AT‚…ZАZ)рч !€oU„Zo]VѓZrrWѓrZ‚ИsorWѓ/roZ‚0ИtoVѓHшoZsZ!€‚UЃu oZtZ!€o+ры !€*Ѓ@ ‚Ѓv Uѓ‡ЃN OЃP —зQ\"€Ѓw RЙ‚Ѓx Uѓ±ЃN OЃP ЃY Ѓy \"зQ\"€Ѓz RЙB‚ИYѓЧWѓЧXѓР\f8Ѓ{ D‚\f8‚Ѓ| UѓлЃ}  €Ѓ@ ‚Ѓ~ UѓяЃ ‹€Ѓ@ ‚ЃЂ UѓЃЃ Ѓ‚ ! €Ѓ@ ‚Ѓѓ  €Ѓ@ ‰\fЃ@ =„Ћ\f.‡" [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 highlighted textwin result num char skipped command-characters choices max-lines line count textbuf get-buffer-create ispell-choices-buffer "--  %b  --  word: " word 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" "(" ") " "  " pos-visible-in-window-p end sit-for get-buffer-window choices-window select-window -1 visible window-line move-to-window-line set-window-start selected-window previous-window enlarge-window ispell-overlay-window switch-to-buffer next-window ((byte-code "ѓ Б‹€В‡" [ispell-highlight-p ((byte-code "А	!€В\f\"‡" [select-window textwin ispell-highlight-spelling-error start end] 3)) nil] 1)) ispell-highlight-p ispell-highlight-spelling-error start t undo-boundary message "C-h or ? for more options; SPC to leave " "unchanged, Character to replace word" inhibit-quit fboundp read-char-exclusive read-char quit-flag 88 com-chars 32 105 process-send-string ispell-process "*" (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 minh gr-bl shr-bl shrink-window 117 (t) 109 "Insert: " (t) query-replace 12 redraw-display 18 ((recursive-edit)) 26 key-binding "" ding] 14 (#$ . 19395)])
#@1038 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 '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 (#$ . 23171)])
#@332 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 '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 (#$ . 24948)])
#@52 Output filter function for ispell, grep, and look.
(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 (#$ . 26321)])
#@182 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-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 (#$ . 26638)])
#@172 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-lucid #[(start end &optional highlight) "ѓ	 Б\n\"‡ДЕ!‡" [highlight isearch-highlight start end isearch-dehighlight t] 3 (#$ . 27174)])
#@240 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.
(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 (#$ . 27532)])
(defalias 'ispell-highlight-spelling-error #[(start end &optional highlight) "АБ\n\"ѓ Г\f#‡З\n™ѓ& ИЙ!ѓ& \nѓ& Л\f#‡М\f#‡" [string-match "Lucid" emacs-version ispell-highlight-spelling-error-lucid start end highlight "19" featurep faces window-system ispell-highlight-spelling-error-overlay ispell-highlight-spelling-error-generic] 4])
#@202 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-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 (#$ . 28356)])
#@445 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 '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 (#$ . 28811)])
(defalias 'check-ispell-version #[nil "ЉАБВЖЗ!q€И €Й\nВАВЛ%eb€М>„2 НО\n;ѓ. П‚/ Р$€СТУ@!ХQВА#„M НЦ\n@#€‚` ЧШ”Ш•{!@A@Wѓ` ЩЫp!,‡" [t fundamental-mode nil status default-major-mode case-fold-search get-buffer-create " *ispell-tmp*" erase-buffer call-process ispell-program-name "-v" (0 nil) error "%s exited with %s %s" "signal" "code" re-search-forward "\\b\\(" regexp-quote ispell-required-version "\\)\\([0-9]*\\)\\b" "%s version %s* is required: try renaming ispell4.el to ispell.el" read-from-string 2 0 ispell-offset kill-buffer] 6])
#@56 Check status of Ispell process and start if necessary.
(defalias 'ispell-init-process #[nil "ѓ Б!В=ѓ ѓ \fљѓ ЖЖ‰‡ЙК!€ЛМ!€НО!€П €ТУФЖЦЧЖѓE Ы ѓX ЬЭD\"ѓg ЬЮЯ!D\"Ь \"‰)&)ЖЖбЗ\"€в!€„” гд\"€‚С @;ѓА еж@\"ѓ° вз\"€@;‚ґ A?ѓА еи@\"„С йк!€в €глмно#\"€Жп ‰0ѓд с0о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 "warning: " 5 "^@(#) " sleep-for 1 "%s" mapconcat identity "\n" ispell-get-extended-character-mode extended-char-mode process-send-string process-kill-without-query] 13 (#$ . 30244)])
#@133 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.
(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 (#$ . 31329) nil])
#@234 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.
(defalias 'ispell-change-dictionary #[(dict &optional arg) "Бљѓ ВГљѓ ДЕ† † Б\"‡љѓ= ѓ0 љѓ= t…– ДИ†; Б\"‡Й\n\"ѓ\\ „N „Q „a ‚a МН\"€ОП!€ДРљѓs Г‚} ѓ| С‚} Тљ„Љ „Џ ‚‘ †• Б#‡" [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 (#$ . 31716) (list (completing-read "Use new dictionary (RET for current, SPC to complete): " (cons (cons "default" nil) ispell-dictionary-alist) nil t) current-prefix-arg)])
#@51 Interactively check a region for spelling errors.
(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 using %s dictionary..." reg-start reg-end buffer-name "region" ispell-dictionary "default" ((byte-code "b€Б‰\f„f`Wѓf`ЖЉБ€`^)З Б	\n\flѓ2 Нu€‚ї„В ѓВ Р\nС#ѓВ `\fZGUѓh Уѓ^ Нy€‚їРФ#€‚ї`GZ‰Sb€ХЦ!ѓ’ \fSUѓЌ G\\‚’ S\fb€Ч	С#„© ЧШС#ѓє Щ\f{ЪQZb€)‚їХЬ!ѓО Нu€‚їѓг Ч\nС#ѓг Я‰„ч  ѓ‘Рб\nС#ѓ‘в‰ѓ‘\nЯ=ѓ`гZ\fU„\nв=ѓR`НZ\fUѓR\nЯ=ѓ$Ч$С#ѓ2\nв=ѓїРеС#„їж'!€и €йк\nЯ=ѓFл‚GмнQ!€`гZ‚ї`\nЯ=ѓ]г‚^НZ\fb€Ч	С#„xЧШС#ѓ‰Щ\f{ЪQZb€)‚їЧ	\nС#„¤ЧШ\nС#ѓјЩ\f\n{ЪQZ\nb€‚їНy€`\nѓ^Б.п0\"€с0!€2@УѓС2Aџ2\f„]2ѓ]у2@!‰.<ѓU\f.A@\\\\‰4.@G\\5Б64b€ч €5b€ч €4b€ч €5Р.@5С#€`U„@шщъP.@4#€ы „IьЖ!€=ѓgю.AA@.AAA@.@45%6‚jя‹€6ѓЧ6<ѓЧБ245{6@G.@GZ@@\\@\\)6@.@љ„¬45|€6@c€6A@ЃA =„АЃB 6@G!€`\n6A@ѓ:ЃC ЋЃD ‹€)‚:6ѓг6Жљѓ6ЖљѓуЃE .@\"Fѓ:F<ѓ:F@FБ24\n‚:6ѓ:45|€6c€6G.@GZ@@\\@\\\n@\\\n)\f„PйЃG H†JЃI ЃJ Q!€ьЖ!€+2A2‚д)\nb€-‚ *Б‡" [reg-start nil ref-type 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-offset "[---#@*+!%~^]" ispell-skip-tib ispell-tib-ref-beginning tib ispell-skip-sgml "[<&]" sgml 2 ispell-tib-ref-end "[>;]" ispell-pdict-save ispell-silently-savep ding message "Open tib or SGML command.  Fix buffer or set " "ispell-skip-tib" "ispell-skip-sgml" " to nil" 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" pos-visible-in-window-p sit-for ispell-keep-choices-win ispell-command-loop ((byte-code "А	AA@	AAA@	@\n%А‡" [ispell-command-loop poss word-start word-end replace] 6)) 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 using " ispell-dictionary "default" " dictionary..."] 7)) ispell-quit] 4 (#$ . 32634) "r"])
#@61 Check the current buffer for spelling errors interactively.
(defalias 'ispell-buffer #[nil "Аed\"‡" [ispell-region] 3 (#$ . 35499) nil])
(defalias '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])
#@67 Places point within the horizontal visibility of its window area.
(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 (#$ . 35907)])
#@244 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.
(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 "А	В\f%В‡" [ispell-command-loop possibilities nil word start end replacement] 6)) 0 ispell-add-per-file-word-list ispell-word get-buffer ispell-choices-buffer kill-buffer ispell-pdict-save ispell-silently-savep] 8 (#$ . 36180) "P"])
#@59 Completes word matching character sequence inside a word.
(defalias 'ispell-complete-word-interior-frag #[nil "АБ!‡" [ispell-complete-word t] 2 (#$ . 37274) nil])
#@42 Non-nil if Ispell minor mode is enabled.
(defvar ispell-minor-mode nil (#$ . 37443))
(byte-code "АБ!€Б\nћ„ Г\nBА‡" [make-variable-buffer-local ispell-minor-mode minor-mode-alist (ispell-minor-mode " Spell")] 2)
#@36 Keymap used for Ispell minor mode.
(defvar ispell-minor-keymap (byte-code "А В	ГД#€В	ЕД#€	)‡" [make-sparse-keymap map define-key " " ispell-minor-check ""] 4) (#$ . 37662))
(byte-code "АБ!ѓ ВГ	\"„ Г\fB	BА‡" [boundp minor-mode-map-alist assoc ispell-minor-mode ispell-minor-keymap] 3)
#@190 Toggle Ispell minor mode.
With prefix arg, turn Ispell minor mode on iff arg is positive.
 
In Ispell minor mode, pressing SPC or RET
warns you if the previous word is incorrectly spelled.
(defalias 'ispell-minor-mode #[(&optional arg) "„ 	† В!ГX?Д ‡" [arg ispell-minor-mode prefix-numeric-value 0 force-mode-line-update] 2 (#$ . 37958) "P"])
(defalias 'ispell-minor-check #[nil "АБЊe`}€ДАБ\"€)ЕЖЗ !!*‡" [nil t ispell-check-only ispell-minor-mode ispell-word call-interactively key-binding this-command-keys] 3 nil "*"])
#@195 *End of text which will be checked in ispell-message.
If it is a string, limit at first occurrence of that regular expression.
Otherwise, it must be a function which is called to get the limit.
(defvar ispell-message-text-end (mapconcat (quote identity) (quote ("^%!PS-Adobe-[123].0" "^begin [0-9][0-9][0-9] .*\nM.*\nM.*\nM" "^#! /bin/[ck]?sh" "\\(diff -c .*\\)?\n\\*\\*\\* .*\n--- .*\n\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*" "^[-=_]+\\s ?\\(cut here\\|Start of forwarded message\\)")) "\\|") (#$ . -38493))
#@118 Spelling is skipped inside these start/end groups by ispell-message.
Assumed that blocks are not mutually inclusive.
(defvar ispell-message-start-skip (mapconcat (quote identity) (quote ("^---* Forwarded Message" "^---*BEGIN PGP [A-Z ]*--*")) "\\|") (#$ . 39015))
#@118 Spelling is skipped inside these start/end groups by ispell-message.
Assumed that blocks are not mutually inclusive.
(defvar ispell-message-end-skip (mapconcat (quote identity) (quote ("^--- End of Forwarded Message" "^---*END PGP [A-Z ]*--*")) "\\|") (#$ . 39286))
#@821 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)))
(defalias 'ispell-message #[nil "Љeb€ЉАБВ!ДQЕЖ#)И	„ d‚: К	!ѓ5 А	ЕЖ#ѓ1 Л”‚: d‚: d	 ^!\fНО!ѓQ ПР СТУ!°‚№ НХ!ѓe ПСТУ!°‚№ Чљѓ ШТѓz У!‚{ ЪQ‚№ ЫљѓЌ У!‚№ „њ ЭТЮТЯ°‚№ аб!ѓ¬ вТУ!!Q‚№ ѓё У!‚№ Ъ#д#P%ж#СQ'()Ж(Ж*eb€ѓб `W‚й лм!ѓ!m?ѓ!лн!ѓЛ•b€ло!„лп!„)(р`Е€лс!ѓт€‚`\"€)уy€‚Х Е(лВ!ДP!ѓ1уy€`\fWѓМл%!ѓM`\fWѓMуyЛU„8`\fWѓ1`4А'\fх#…cЛ”64b…yА7\fх#…yЛy€`86ѓЌ8ѓЌ68^†›6†›8†›щ\f!54b€р45\"€8ѓД58UѓД5b€А:\fх#€‚И5b€,‚1\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 start end end-c ispell-message-start-skip end-fwd marker-position ispell-message-end-skip] 6 (#$ . 39559) nil])
(defalias 'ispell-non-empty-string #[(string) "ѓ\n Бѓ\f В‡Г!‡" [string "" "\\'\\`" regexp-quote] 2])
#@70 Load all buffer-local information, restarting ispell when necessary.
(defalias 'ispell-accept-buffer-local-defs #[nil "А €Б €В ‡" [ispell-buffer-local-dict ispell-buffer-local-words ispell-buffer-local-parsing] 1 (#$ . 41810)])
#@141 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-parsing #[nil "А	В\"€Д=ѓ ЕЖЗ!\"„ Й=ѓ# А	К\"€‚( А	Л\"€М>О ‰ѓ> А	РP\"€)Љeb€СУФ#…¬ ЉУ€`)ФУШЩФ#ѓЁ Ъ”Ъ•{ЕЫ\"ѓz А	Ь\"€‚Z ЕЭ\"ѓЉ А	Ю\"€‚Z ЕЯ\"ѓќ А	РP\"€‚Z аб!€вг!€‚Z +‚C )‡" [process-send-string ispell-process "!\n" ispell-parser use-mode-name string-match "[Tt][Ee][Xx]-mode" symbol-name major-mode tex "+\n" "-\n" (sgml-mode html-mode) ispell-skip-sgml 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" "+\n~tex\n" "nroff-mode" "-\n~nroff" "~" message "Illegal Ispell Parsing argument!" sit-for 2] 5 (#$ . 42045)])
#@248 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-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 (#$ . 42900)])
#@58 Loads the buffer-local dictionary in the current buffer.
(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 (#$ . 43580)])
#@42 Adds new word to the per-file word list.
(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 (#$ . 44004)])
(byte-code "АБ\nBГД!‡" ["2.37 -- Tue Jun 13 12:05:28 EDT 1995" ispell-version current-load-list provide ispell] 2)