;ELC   
;;; Compiled by pot@pot.cnuce.cnr.it on Tue Mar 18 15:46:51 2003
;;; from file /home/pot/gnu/emacs-pretest.new/lisp/international/quail.el
;;; in Emacs version 21.3
;;; with bytecomp version 2.85.4.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.
(if (and (boundp 'emacs-version)
	 (< (aref emacs-version (1- (length emacs-version))) ?A)
	 (or (and (boundp 'epoch::version) epoch::version)
	     (string-lessp emacs-version "19.29")))
    (error "`quail.el' was compiled for Emacs 19.29 or later"))

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


(custom-declare-group 'quail nil "Quail: multilingual input method." :group 'leim)
#@134 The current Quail package, which depends on the current input method.
See the documentation of `quail-package-alist' for the format.
(defvar quail-current-package nil (#$ . 710))
(byte-code "\304\305!\210\306\305\307\310#\210\301B\311\301!\204 \312\302B\311\302!\204\" \312\304\301!\210\306\301\307\310#\210\303B\311\303!\2048 \312\304\303!\207" [current-load-list quail-guidance-buf quail-completion-buf quail-guidance-win make-variable-buffer-local quail-current-package put permanent-local t boundp nil] 4)
#@63 Overlay which covers the current translation region of Quail.
(defvar quail-overlay nil (#$ . 1236))
(make-variable-buffer-local 'quail-overlay)
#@62 Overlay which covers the text to be converted in Quail mode.
(defvar quail-conv-overlay nil (#$ . 1387))
(make-variable-buffer-local 'quail-conv-overlay)
#@44 Current key for translation in Quail mode.
(defvar quail-current-key nil (#$ . 1547))
(make-variable-buffer-local 'quail-current-key)
#@52 Currently selected translation of the current key.
(defvar quail-current-str nil (#$ . 1687))
(make-variable-buffer-local 'quail-current-str)
#@331 Cons of indices and vector of possible translations of the current key.
Indices is a list of (CURRENT START END BLOCK BLOCKS), where
CURRENT is an index of the current translation,
START and END are indices of the start and end of the current block,
BLOCK is the current block index,
BLOCKS is a number of  blocks of translation.
(defvar quail-current-translations nil (#$ . 1836))
(make-variable-buffer-local 'quail-current-translations)
#@268 Any Lisp object holding information of current translation status.
When a key sequence is mapped to TRANS and TRANS is a cons
of actual translation and some Lisp object to be referred
for translating the longer key sequence, this variable is set
to that Lisp object.
(defvar quail-current-data nil (#$ . 2282))
(make-variable-buffer-local 'quail-current-data)
#@567 List of Quail packages.
A Quail package is a list of these elements:
  NAME, TITLE, QUAIL-MAP, GUIDANCE, DOCSTRING, TRANSLATION-KEYS,
  FORGET-LAST-SELECTION, DETERMINISTIC, KBD-TRANSLATE, SHOW-LAYOUT,
  DECODE-MAP, MAXIMUM-SHORTEST, OVERLAY-PLIST, UPDATE-TRANSLATION-FUNCTION,
  CONVERSION-KEYS, SIMPLE.

QUAIL-MAP is a data structure to map key strings to translations.  For
the format, see the documentation of `quail-map-p'.

DECODE-MAP is an alist of translations and corresponding keys.

See the documentation of `quail-define-package' for the other elements.
(defvar quail-package-alist nil (#$ . 2649))
#@47 Return the name of the current Quail package.
(defalias 'quail-name #[nil "@\207" [quail-current-package] 1 (#$ . 3266)])
(put 'quail-name 'byte-optimizer 'byte-compile-inline-expand)
#@48 Return the title of the current Quail package.
(defalias 'quail-title #[nil "A@\211;\203 	\202 \302\303\304\217)\207" [quail-current-package title nil (mapconcat #[(x) ";\203 \207<\203' @9\203' G\301U\203' @J\203# A@\207\3028\207\303\207" [x 3 2 ""] 2] title "") ((error ""))] 4 (#$ . 3457)])
#@58 Return the translation map of the current Quail package.
(defalias 'quail-map #[nil "\3018\207" [quail-current-package 2] 2 (#$ . 3769)])
(put 'quail-map 'byte-optimizer 'byte-compile-inline-expand)
#@130 Return an object used for `guidance' feature of the current Quail package.
See also the documentation of `quail-define-package'.
(defalias 'quail-guidance #[nil "\3018\207" [quail-current-package 3] 2 (#$ . 3976)])
(put 'quail-guidance 'byte-optimizer 'byte-compile-inline-expand)
#@63 Return the documentation string of the current Quail package.
(defalias 'quail-docstring #[nil "\3018\207" [quail-current-package 4] 2 (#$ . 4264)])
(put 'quail-docstring 'byte-optimizer 'byte-compile-inline-expand)
#@129 Return translation keymap in the current Quail package.
Translation keymap is a keymap used while translation region is active.
(defalias 'quail-translation-keymap #[nil "\3018\207" [quail-current-package 5] 2 (#$ . 4488)])
(put 'quail-translation-keymap 'byte-optimizer 'byte-compile-inline-expand)
#@121 Return `forget-last-selection' flag of the current Quail package.
See also the documentation of `quail-define-package'.
(defalias 'quail-forget-last-selection #[nil "\3018\207" [quail-current-package 6] 2 (#$ . 4796)])
(put 'quail-forget-last-selection 'byte-optimizer 'byte-compile-inline-expand)
#@113 Return `deterministic' flag of the current Quail package.
See also the documentation of `quail-define-package'.
(defalias 'quail-deterministic #[nil "\3018\207" [quail-current-package 7] 2 (#$ . 5102)])
(put 'quail-deterministic 'byte-optimizer 'byte-compile-inline-expand)
#@113 Return `kbd-translate' flag of the current Quail package.
See also the documentation of `quail-define-package'.
(defalias 'quail-kbd-translate #[nil "\3018\207" [quail-current-package 8] 2 (#$ . 5384)])
(put 'quail-kbd-translate 'byte-optimizer 'byte-compile-inline-expand)
#@111 Return `show-layout' flag of the current Quail package.
See also the documentation of `quail-define-package'.
(defalias 'quail-show-layout #[nil "\3018\207" [quail-current-package 9] 2 (#$ . 5666)])
(put 'quail-show-layout 'byte-optimizer 'byte-compile-inline-expand)
#@104 Return decode map of the current Quail package.
It is an alist of translations and corresponding keys.
(defalias 'quail-decode-map #[nil "\3018\207" [quail-current-package 10] 2 (#$ . 5942)])
(put 'quail-decode-map 'byte-optimizer 'byte-compile-inline-expand)
#@116 Return `maximum-shortest' flag of the current Quail package.
See also the documentation of `quail-define-package'.
(defalias 'quail-maximum-shortest #[nil "\3018\207" [quail-current-package 11] 2 (#$ . 6210)])
(put 'quail-maximum-shortest 'byte-optimizer 'byte-compile-inline-expand)
#@70 Return property list of an overly used in the current Quail package.
(defalias 'quail-overlay-plist #[nil "\3018\207" [quail-current-package 12] 2 (#$ . 6501)])
(put 'quail-overlay-plist 'byte-optimizer 'byte-compile-inline-expand)
#@74 Return a function for updating translation in the current Quail package.
(defalias 'quail-update-translation-function #[nil "\3018\207" [quail-current-package 13] 2 (#$ . 6740)])
(put 'quail-update-translation-function 'byte-optimizer 'byte-compile-inline-expand)
#@164 Return conversion keymap in the current Quail package.
Conversion keymap is a keymap used while conversion region is active
 but translation region is not active.
(defalias 'quail-conversion-keymap #[nil "\3018\207" [quail-current-package 14] 2 (#$ . 7012)])
(put 'quail-conversion-keymap 'byte-optimizer 'byte-compile-inline-expand)
#@50 Return t if the current Quail package is simple.
(defalias 'quail-simple #[nil "\3018\207" [quail-current-package 15] 2 (#$ . 7353)])
(put 'quail-simple 'byte-optimizer 'byte-compile-inline-expand)
#@34 Return Quail package named NAME.
(defalias 'quail-package #[(name) "\302	\"\207" [name quail-package-alist assoc] 3 (#$ . 7558)])
(put 'quail-package 'byte-optimizer 'byte-compile-inline-expand)
#@53 Add Quail package PACKAGE to `quail-package-alist'.
(defalias 'quail-add-package #[(package) "@\304	\n\")\211\203 A\241\202 \nB\211)\207" [package name quail-package-alist pac assoc] 4 (#$ . 7760)])
#@63 Select Quail package named NAME as the current Quail package.
(defalias 'quail-select-package #[(name) "\304	\")\211\204 \305\306\"\210\n\307\303\n\"\210)\207" [name quail-package-alist package quail-current-package assoc error "No Quail package `%s'" set-default] 4 (#$ . 7974)])
#@211 Start using Quail package PACKAGE-NAME.
The remaining arguments are libraries to be loaded before using the package.

This activates input method defined by PACKAGE-NAME by running
`quail-activate', which see.
(defalias 'quail-use-package #[(package-name &rest libraries) "\306	\n\")\211\204? \f\203? \307\f@\310\"\2048 \311\220\312\313!\210\312!\210\312\314!\210\312\f@!\210\312\315!\221\210\316\317\"\210\202\f \fA\211\204 )\320!\210\321 \322 \210\323\324!\207" [package-name name quail-package-alist package libraries current-input-method-title assoc load t "*Help*" princ "Quail package \"" "\" can't be activated\n  because library \"" "\" is not in `load-path'.\n\nThe most common case is that you have not yet installed appropriate\nlibraries in LEIM (Libraries of Emacs Input Method) which is\ndistributed separately from Emacs.\n\nLEIM is available from the same ftp directory as Emacs." error "Can't use the Quail package `%s'" quail-select-package quail-title quail-activate message nil] 4 (#$ . 8270)])
#@228 Keymap used processing translation in complex Quail modes.
Only a few especially complex input methods use this map;
most use `quail-simple-translation-keymap' instead.
This map is activated while translation region is active.
(defvar quail-translation-keymap (byte-code "\302 \303\304W\203 \305	\306!\307#\210T\211\202 \310W\203/ \305	\306!\311#\210T\211\202 \312\312\313W\203F \305	\314!\311#\210T\211\2022 \305	\315\316#\210\305	\317\320#\210\305	\321\322#\210\305	\323\324#\210\305	\325\326#\210\305	\327\320#\210\305	\330\322#\210\305	\331\324#\210\305	\332\326#\210\305	\333\334#\210\305	\335\336#\210\305	\337\336#\210\305	\340\341#\210\305	\342\343#\210\305	\344\345#\210\305	\346\336#\210\305	\347\334#\210\305	\350\316#\210\305	\351\316#\210	*\207" [i map make-keymap 0 32 define-key char-to-string quail-other-command 127 quail-self-insert-command 128 256 vector "" quail-delete-last-char "" quail-next-translation "" quail-prev-translation "" quail-next-translation-block "" quail-prev-translation-block [right] [left] [down] [up] "	" quail-completion " " quail-select-current [kp-enter] [mouse-2] quail-mouse-choose-completion [down-mouse-2] nil "" quail-translation-help [67108896] [tab] [delete] [backspace]] 5) (#$ . 9301))
(byte-code "\301B\303\301!\204\f \304\305\306\n@@\307\n@A#\210\nA\211\204 )\301\207" [current-load-list quail-translation-docstring l boundp "When you type keys, the echo area shows the possible characters\nwhich correspond to that key sequence, each preceded by a digit.  You\ncan select one of the characters shown by typing the corresponding\ndigit.  Alternatively, you can use C-f and C-b to move through the\nline to select the character you want, then type a letter to begin\nentering another Chinese character or type a space or punctuation\ncharacter.\n\nIf there are more than ten possible characters for the given spelling,\nthe echo area shows ten characters at a time; you can use C-n to move\nto the next group of ten, and C-p to move back to the previous group\nof ten." ((quail-other-command . hide) (quail-self-insert-command . hide) (quail-delete-last-char . hide) (quail-next-translation . non-deterministic) (quail-prev-translation . non-deterministic) (quail-next-translation-block . non-deterministic) (quail-prev-translation-block . non-deterministic)) put quail-help] 5)
#@202 Keymap used while processing translation in simple Quail modes.
A few especially complex input methods use `quail-translation-keymap' instead.
This map is activated while translation region is active.
(defvar quail-simple-translation-keymap (byte-code "\302 \303\304W\203 \305	\306!\307#\210T\211\202 \310W\203/ \305	\306!\311#\210T\211\202 \312\312\313W\203F \305	\314!\311#\210T\211\2022 \305	\315\316#\210\305	\317\316#\210\305	\320\316#\210	*\207" [i map make-keymap 0 32 define-key char-to-string quail-other-command 127 quail-self-insert-command 128 256 vector "" quail-delete-last-char [delete] [backspace]] 5) (#$ . 11671))
#@148 Keymap used for processing conversion in Quail mode.
This map is activated while conversion region is active but translation
region is not active.
(defvar quail-conversion-keymap (byte-code "\302 \303\304W\203 \305	\306!\307#\210T\211\202 \310\310\311W\2031 \305	\312!\307#\210T\211\202 \305	\313\314#\210\305	\315\316#\210\305	\317\320#\210\305	\321\322#\210\305	\323\324#\210\305	\325\326#\210\305	\327\330#\210\305	\331\332#\210\305	\333\332#\210\305	\334\332#\210	*\207" [i map make-keymap 32 127 define-key char-to-string quail-self-insert-command 128 256 vector "" quail-conversion-backward-char "" quail-conversion-forward-char "" quail-conversion-beginning-of-region "" quail-conversion-end-of-region "" quail-conversion-delete-char "" quail-conversion-delete-tail "" quail-translation-help "" quail-conversion-backward-delete-char [delete] [backspace]] 5) (#$ . 12328))
(defalias 'quail-other-command #[nil "\300\207" [nil] 1 nil nil])
#@3821 Define NAME as a new Quail package for input LANGUAGE.
TITLE is a string to be displayed at mode-line to indicate this package.
Optional arguments are GUIDANCE, DOCSTRING, TRANSLATION-KEYS,
 FORGET-LAST-SELECTION, DETERMINISTIC, KBD-TRANSLATE, SHOW-LAYOUT,
 CREATE-DECODE-MAP, MAXIMUM-SHORTEST, OVERLAY-PLIST,
 UPDATE-TRANSLATION-FUNCTION, CONVERSION-KEYS and SIMPLE.

GUIDANCE specifies how a guidance string is shown in echo area.
If it is t, list of all possible translations for the current key is shown
 with the currently selected translation being highlighted.
If it is an alist, the element has the form (CHAR . STRING).  Each character
 in the current key is searched in the list and the corresponding string is
 shown.
If it is nil, the current key is shown.

DOCSTRING is the documentation string of this package.  The command
`describe-input-method' shows this string while replacing the form
\=\<VAR> in the string by the value of VAR.  That value should be a
string.  For instance, the form \=\<quail-translation-docstring> is
replaced by a description about how to select a translation from a
list of candidates.

TRANSLATION-KEYS specifies additional key bindings used while translation
region is active.  It is an alist of single key character vs. corresponding
command to be called.

FORGET-LAST-SELECTION non-nil means a selected translation is not kept
for the future to translate the same key.  If this flag is nil, a
translation selected for a key is remembered so that it can be the
first candidate when the same key is entered later.

DETERMINISTIC non-nil means the first candidate of translation is
selected automatically without allowing users to select another
translation for a key.  In this case, unselected translations are of
no use for an interactive use of Quail but can be used by some other
programs.  If this flag is non-nil, FORGET-LAST-SELECTION is also set
to t.

KBD-TRANSLATE non-nil means input characters are translated from a
user's keyboard layout to the standard keyboard layout.  See the
documentation of `quail-keyboard-layout' and
`quail-keyboard-layout-standard' for more detail.

SHOW-LAYOUT non-nil means the `quail-help' command should show
the user's keyboard layout visually with translated characters.
If KBD-TRANSLATE is set, it is desirable to set also this flag unless
this package defines no translations for single character keys.

CREATE-DECODE-MAP non-nil means decode map is also created.  A decode
map is an alist of translations and corresponding original keys.
Although this map is not used by Quail itself, it can be used by some
other programs.  For instance, Vietnamese supporting needs this map to
convert Vietnamese text to VIQR format which uses only ASCII
characters to represent Vietnamese characters.

MAXIMUM-SHORTEST non-nil means break key sequence to get maximum
length of the shortest sequence.  When we don't have a translation of
key "..ABCD" but have translations of "..AB" and "CD..", break
the key at "..AB" and start translation of "CD..".  Hangul
packages, for instance, use this facility.  If this flag is nil, we
break the key just at "..ABC" and start translation of "D..".

OVERLAY-PLIST if non-nil is a property list put on an overlay which
covers Quail translation region.

UPDATE-TRANSLATION-FUNCTION if non-nil is a function to call to update
the current translation region according to a new translation data.  By
default, a translated text or a user's key sequence (if no translation
for it) is inserted.

CONVERSION-KEYS specifies additional key bindings used while
conversion region is active.  It is an alist of single key character
vs. corresponding command to be called.

If SIMPLE is non-nil, then we do not alter the meanings of
commands such as C-f, C-b, C-n, C-p and TAB; they are treated as
non-Quail commands.
(defalias 'quail-define-package #[(name language title &optional guidance docstring translation-keys forget-last-selection deterministic kbd-translate show-layout create-decode-map maximum-shortest overlay-plist update-translation-function conversion-keys simple) "\306\211\n\203\n \307\f\2031 \310\203 \202 !\f\203= \311	\f@@\f@A#\210\fA\211\202 \203: \202< \203a \310!\203a \311@@@A#\210A\211\204L \312\306C\206p \313	\n\205~ \314C\257!\210\315\"\316F \211!\203\251 ! \241\210\202\263  BB,\317!\207" [conversion-keymap translation-keymap deterministic forget-last-selection translation-keys simple nil t copy-keymap define-key quail-add-package "" decode-map assoc quail-use-package quail-select-package quail-simple-translation-keymap quail-translation-keymap conversion-keys quail-conversion-keymap name title guidance docstring kbd-translate show-layout create-decode-map maximum-shortest overlay-plist update-translation-function input-method-alist language val slot] 18 (#$ . 13302)])
(defalias 'quail-setup-overlays #[(conversion-mode) "`\306	!\203 \307	\211#\210\202= \310\211\311\211\312%\n\203# \313	\314\315#\210\3168\211\203< \313	\f@\fA@#\210\fAA\211\204+ )\205l \306!\203Y \317!?\205l \307\211#\202l \310\211\311\211\312%\n\205l \313\314\315#)\207" [pos quail-overlay input-method-highlight-flag quail-current-package l conversion-mode overlayp move-overlay make-overlay nil t overlay-put face underline 12 overlay-start quail-conv-overlay] 7])
(defalias 'quail-delete-overlays #[nil "\302!\203 \303!\203 \304!\210\302	!\205 \303	!\205 \304	!\207" [quail-overlay quail-conv-overlay overlayp overlay-start delete-overlay] 2])
(defalias 'quail-kill-guidance-buf #[nil "\301!\205	 \302!\207" [quail-guidance-buf buffer-live-p kill-buffer] 2])
#@93 Inactivate Quail input method.

This function runs the normal hook `quail-inactivate-hook'.
(defalias 'quail-inactivate #[nil "\300\301!\207" [quail-activate -1] 2 (#$ . 18995) nil])
#@342 Activate Quail input method.
With arg, activate Quail input method if and only if arg is positive.

This function runs `quail-activate-hook' if it activates the input
method, `quail-inactivate-hook' if it deactivates it.

While this input method is active, the variable
`input-method-function' is bound to the function `quail-input-method'.
(defalias 'quail-activate #[(&optional arg) "\203 \306!\307W\203 \310\216\311 \210\312 \210\313\314\315!)\207\n\2045 \313\f\203, \f@@\2020 \316\317!\210\320!\210)\321\322\312 \210\323 \210\324 \325 =\203L \326\327\330\"\210\326\331\332\313\333$\210\314\334!\210\335\336!\210\337\211\207" [arg describe-current-input-method-function quail-current-package name quail-package-alist inactivate-current-input-method-function prefix-numeric-value 0 ((byte-code "\300\301!\207" [kill-local-variable input-method-function] 2)) quail-hide-guidance-buf quail-delete-overlays nil run-hooks quail-inactivate-hook error "No Quail package loaded" quail-select-package quail-inactivate quail-help quail-show-guidance-buf selected-window minibuffer-window add-hook minibuffer-exit-hook quail-exit-from-minibuffer kill-buffer-hook quail-kill-guidance-buf t quail-activate-hook make-local-variable input-method-function quail-input-method] 5 (#$ . 19185)])
(defalias 'quail-exit-from-minibuffer #[nil "\300 \210\301 \302X\205 \303\304\305\"\207" [inactivate-input-method minibuffer-depth 1 remove-hook minibuffer-exit-hook quail-exit-from-minibuffer] 3])
#@284 Standard keyboard layout of printable characters Quail assumes.
See the documentation of `quail-keyboard-layout' for this format.
This layout is almost the same as that of VT100,
 but the location of key \ (backslash) is just right of key ' (single-quote),
 not right of RETURN key.
(defconst quail-keyboard-layout-standard "                                1!2@3#4$5%6^7&8*9(0)-_=+`~    qQwWeErRtTyYuUiIoOpP[{]}      aAsSdDfFgGhHjJkKlL;:'\"\\|      zZxXcCvVbBnNmM,<.>/?                                      " (#$ . 20683))
#@716 A string which represents physical key layout of a particular keyboard.
We assume there are six rows and each row has 15 keys (columns),
	the first row is above the `1' - `0' row,
	the first column of the second row is left of key `1',
	the first column of the third row is left of key `q',
	the first column of the fourth row is left of key `a',
	the first column of the fifth row is left of key `z',
	the sixth row is below the `z' - `/' row.
Nth (N is even) and (N+1)th characters in the string are non-shifted
and shifted characters respectively at the same location.
The location of Nth character is row (N / 30) and column ((N mod 30) / 2).
The command `quail-set-keyboard-layout' usually sets this variable.
(defvar quail-keyboard-layout quail-keyboard-layout-standard (#$ . 21213))
(byte-code "\301B\302\301\207" [current-load-list quail-keyboard-layout-len 180] 2)
#@145 Alist of keyboard names and corresponding layout strings.
See the documentation of `quail-keyboard-layout' for the format of
the layout string.
(defvar quail-keyboard-layout-alist (byte-code "\301B\302\303\304\305\257\207" [quail-keyboard-layout-standard "standard" ("sun-type3" . "                                1!2@3#4$5%6^7&8*9(0)-_=+\\|`~  qQwWeErRtTyYuUiIoOpP[{]}      aAsSdDfFgGhHjJkKlL;:'\"        zZxXcCvVbBnNmM,<.>/?                                      ") ("atari-german" . "                                1!2\"3\2474$5%6&7/8(9)0=\337?'`#^    qQwWeErRtTzZuUiIoOpP\374\334+*      aAsSdDfFgGhHjJkKlL\366\326\344\304~|    <>yYxXcCvVbBnNmM,;.:-_                                      ") ("pc102-de" . "                              ^\2601!2\"3\2474$5%6&7/8(9)0=\337?\264`#'    qQwWeErRtTzZuUiIoOpP\374\334+*      aAsSdDfFgGhHjJkKlL\366\326\344\304      <>yYxXcCvVbBnNmM,;.:-_                                      ") ("jp106" . "                                1!2\"3#4$5%6&7'8(9)0~-=^~\\|    qQwWeErRtTyYuUiIoOpP@`[{      aAsSdDfFgGhHjJkKlL;+:*]}      zZxXcCvVbBnNmM,<.>/?\\_                                    ")] 5) (#$ . 22097))
(byte-code "\301B\302\301!\204\f \303\303\207" [current-load-list quail-keyboard-layout-substitution boundp nil] 2)
(defalias 'quail-update-keyboard-layout #[(kbd-type) "\306	\"\211\204 \307\310\"\210\nA\f\311\211\f\312V\203V SH\313U\203@ H\313U\204 B\202 H\313U\203 \311B\fB\f\202 \f\205\207 \f\203s \f@A\203s \fA\211\f\204c \f\203 \f@@\241\210A\211\204^ \311,\207" [kbd-type quail-keyboard-layout-alist layout quail-keyboard-layout quail-keyboard-layout-len missing-list assoc error "Unknown keyboard type `%s'" nil 0 32 subst-list i quail-keyboard-layout-standard quail-keyboard-layout-substitution] 4])
#@132 Type of keyboard layout used in Quail base input method.
Available types are listed in the variable `quail-keyboard-layout-alist'.
(custom-declare-variable 'quail-keyboard-layout-type '"standard" '(#$ . 23907) :group 'quail :type 'string :set #'(lambda (symbol value) (quail-update-keyboard-layout value) (set symbol value)))
#@368 Set the current keyboard layout to the same as keyboard KBD-TYPE.

Since some Quail packages depends on a physical layout of keys (not
characters generated by them), those are created by assuming the
standard layout defined in `quail-keyboard-layout-standard'.  This
function tells Quail system the layout of your keyboard so that what
you type is correctly handled.
(defalias 'quail-set-keyboard-layout #[(kbd-type) "\302!\210\211\207" [kbd-type quail-keyboard-layout-type quail-update-keyboard-layout] 2 (#$ . 24240) (let* ((completion-ignore-case t) (type (completing-read "Keyboard type: " quail-keyboard-layout-alist))) (list type))])
#@60 Translate CHAR to the one in the standard keyboard layout.
(defalias 'quail-keyboard-translate #[(char) "	=\203 \n\207\306\306\fW\203 \nHU\204 T\211\202 \fU\203) \n\202I 	H\211\307U\203G \236A\211\203C 	H\202H \n\202H ))\207" [quail-keyboard-layout quail-keyboard-layout-standard char i quail-keyboard-layout-len ch 0 32 quail-keyboard-layout-substitution] 4 (#$ . 24889)])
(defalias 'quail-keyseq-translate #[(keyseq) "\301\302\303\304\"\"\207" [keyseq apply string mapcar #[(x) "\301!\207" [x quail-keyboard-translate] 2]] 5])
#@131 Insert the visual keyboard layout table according to KBD-LAYOUT.
The format of KBD-LAYOUT is the same as `quail-keyboard-layout'.
(defalias 'quail-insert-kbd-layout #[(kbd-layout) "\306\211\211\211\f\307\310\")\311\311.W\203k \f	H\312/8\203( \313!\314/8A\236A\2110\205? \3150@\316!\317#\2111\203Z 1:\203R 1A\311H11B\202] 1\n	1I\210*	T\211\202 `\320\306\211\21123456\321\311\317\322\3235%\210\311	.W\203<	\324\246\311U\203\253 	\324\245\2112\317V\203\253 \325\3262\211\314Z\314\245\\\"\210\n	H4\n	TH34\250\203\320 4\327Y\203\320 4\330W\203\320 \3314!43\250\203\352 3\327Y\203\352 3\330W\203\352 \3313!35c\2104;\203\373 \3324!\202\377 \3334!\317U\203\334c\21043\261\2103;\203\3323!\202\3333!\317U\203'\334c\210	\314\\\211\324\246\311U\203\205 5\335\261\210\202\205 \2146`}\2106b\210\336\311\306\211789:m\204\364\337\340!\203d`\311\225|\210\202\203\337\341!\203r\342`\311\225\343\326$\210\344\345\346 \347#\203\200\311\224`|\210\350 \210l\203\222:897\202\272\334\306w\210i8\306\210i78:W\203\2538:79V\203\26779\350 \2109\311V\203\346\325\326:\"\210`6\351c\210\325\3529:Z\314Z\"\210\351c\210\3216`\322\323$\210\335c\2108:79\317y\210\202R,\353y\210`6\354c\210\3216`\322\323$\210\355c\210.,\207" [ch i layout done-list kbd-layout string nil string-to-sequence vector 0 8 quail-keyboard-translate 2 quail-get-translation char-to-string 1 "|" put-text-property face bold 30 insert-char 32 128 256 unibyte-char-to-multibyte string-width char-width " " "\n" 100 looking-at "[| ]*$" " *\\(|    \\)+" subst-char-in-region 124 re-search-forward "\\(    |\\)+$" line-end-position t beginning-of-line "+" 45 -1 "		    +-----------------------------+\n		    |          space bar          |\n		    +-----------------------------+\n" 10 quail-keyboard-layout-len quail-current-package map translation row upper lower bar pos to2 from2 to1 from1] 7 (#$ . 25446)])
#@149 Show the physical layout of the keyboard type KEYBOARD-TYPE.

The variable `quail-keyboard-layout-type' holds the currently selected
keyboard type.
(defalias 'quail-show-keyboard-layout #[(&optional keyboard-type) "\203 G\305V\204 	\306\n\"\211\204 \307\310\"\210\311\220\212\fq\210\312\313\261\210\314A!)\221)\207" [keyboard-type quail-keyboard-layout-type quail-keyboard-layout-alist layout standard-output 0 assoc error "Unknown keyboard type: %s" "*Help*" "Keyboard layout (keyboard type: " ")\n" quail-insert-kbd-layout] 5 (#$ . 27416) (list (completing-read "Keyboard type (default, current choise): " quail-keyboard-layout-alist nil t))])
#@829 Return t if OBJECT is a Quail map.

A Quail map holds information how a particular key should be translated.
Its format is (TRANSLATION . ALIST).
TRANSLATION is either a character, or a cons (INDEX . VECTOR).
In the latter case, each element of VECTOR is a candidate for the translation,
and INDEX points the currently selected translation.

ALIST is normally a list of elements that look like (CHAR . DEFN),
where DEFN is another Quail map for a longer key (CHAR added to the
current key).  It may also be a symbol of a function which returns an
alist of the above format.

Just after a Quail package is read, TRANSLATION may be a string or a
vector.  Then each element of the string or vector is a candidate for
the translation.  These objects are transformed to cons cells in the
format (INDEX . VECTOR), as described above.
(defalias 'quail-map-p #[(object) ":\205A @\211\250\206, 	?\206, \303	!\206, 	;\206, 	9\206, 	:\205, \303	A!?)\205A A\211<\203> \n@:\206@ \n9)\207" [object translation alist vectorp] 3 (#$ . 28081)])
(put 'quail-map-p 'byte-optimizer 'byte-compile-inline-expand)
#@1405 Define translation rules of the current Quail package.
Each argument is a list of KEY and TRANSLATION.
KEY is a string meaning a sequence of keystrokes to be translated.
TRANSLATION is a character, a string, a vector, a Quail map, or a function.
If it is a character, it is the sole translation of KEY.
If it is a string, each character is a candidate for the translation.
If it is a vector, each element (string or character) is a candidate
  for the translation.
In these cases, a key specific Quail map is generated and assigned to KEY.

If TRANSLATION is a Quail map or a function symbol which returns a Quail map,
 it is used to handle KEY.

The first argument may be an alist of annotations for the following
rules.  Each element has the form (ANNOTATION . VALUE), where
ANNOTATION is a symbol indicating the annotation type.  Currently
the following annotation types are supported.

  append -- the value non-nil means that the following rules should
	be appended to the rules of the current Quail package.

  face -- the value is a face to use for displaying TRANSLATIONs in
	candidate list.

  advice -- the value is a function to call after one of RULES is
	selected.  The function is called with one argument, the
	selected TRANSLATION string, after the TRANSLATION is
	inserted.

  no-decode-map --- the value non-nil means that decoding map is not
	generated for the following translations.
(defalias 'quail-define-rules '(macro . #[(&rest rules) "\306\211\211\211@@:\203K \f@\303\236\211\203\" \307\"A\302\236\211\2032 \307\n\"\nA\203G @@@A	BBA\211\2046 \fA)\203n \310\311\312\fDD\313\314\315\316\317\nDED\320\312	DD\321BBBB\322BB\202\273 \306C\n?\205w \314C\306\211\f\f\203\244 \f@@\f@A@\fA\323\324\f	&\210\202\201 \325\326\327\312DD\327\312DD\330\312\fDD\257,,\207" [rules props no-decode-map append l annotations nil delete let tail quote (map (quail-map)) decode-map and (quail-decode-map) not properties (key trans) ((while tail (setq key (car (car tail)) trans (car (cdr (car tail))) tail (cdr tail)) (quail-defrule-internal key trans map t decode-map properties))) quail-defrule-internal t if (not (quail-decode-map)) quail-install-map quail-install-decode-map trans key map] 9 (#$ . 29185)]))
#@210 Install the Quail map MAP in the current Quail package.

Optional 2nd arg NAME, if non-nil, is a name of Quail package for
which to install MAP.

The installed map can be referred by the function `quail-map'.
(defalias 'quail-install-map #[(map &optional name) "\204 \305\306!\210	\211:\205K \n@\211\250\2066 ?\2066 \307!\2066 ;\2066 9\2066 :\2056 \307A!?)\205K \nA\211<\203H \f@:\206J \f9))\204T \305\310	\"\210AA	\240\207" [quail-current-package map object translation alist error "No current Quail package" vectorp "Invalid Quail map `%s'"] 4 (#$ . 31459)])
#@238 Install the Quail decode map DECODE-MAP in the current Quail package.

Optional 2nd arg NAME, if non-nil, is a name of Quail package for
which to install MAP.

The installed decode map can be referred by the function `quail-decode-map'.
(defalias 'quail-install-decode-map #[(decode-map &optional name) "\204 \302\303!\210	:\203 	@\301=\204 \302\304	\"\210\305\233	\240\207" [quail-current-package decode-map error "No current Quail package" "Invalid Quail decode map `%s'" 10] 3 (#$ . 32039)])
#@1179 Add one translation rule, KEY to TRANSLATION, in the current Quail package.
KEY is a string meaning a sequence of keystrokes to be translated.
TRANSLATION is a character, a string, a vector, a Quail map,
 a function, or a cons.
It it is a character, it is the sole translation of KEY.
If it is a string, each character is a candidate for the translation.
If it is a vector, each element (string or character) is a candidate
 for the translation.
If it is a cons, the car is one of the above and the cdr is a function
 to call when translating KEY (the return value is assigned to the
 variable `quail-current-data').  If the cdr part is not a function,
 the value itself is assigned to `quail-current-data'.
In these cases, a key specific Quail map is generated and assigned to KEY.

If TRANSLATION is a Quail map or a function symbol which returns a Quail map,
 it is used to handle KEY.

Optional 3rd argument NAME, if specified, says which Quail package
to define this translation rule in.  The default is to define it in the
current Quail package.

Optional 4th argument APPEND, if non-nil, appends TRANSLATION
to the current translations for KEY instead of replacing them.
(defalias 'quail-defrule #[(key translation &optional name append) "\203 \306	\")\211\204 \307\310\"\210\n)\311\f\3128$\207" [name quail-package-alist package quail-current-package key translation assoc error "No Quail package `%s'" quail-defrule-internal 2 append] 6 (#$ . 32547)])
#@330 Define KEY as TRANS in a Quail map MAP.

If Optional 4th arg APPEND is non-nil, TRANS is appended to the
current translations for KEY instead of replacing them.

Optional 5th arg DECODE-MAP is a Quail decode map.

Optional 6th arg PROPS is a property list annotating TRANS.  See the
function `quail-define-rules' for the detail.
(defalias 'quail-defrule-internal #[(key trans map &optional append decode-map props) ";\203 \210	\247\204m 	;\204m \306	!\204m 	:\204m 	9\204m 	\211:\205d \n@\211\250\206O ?\206O \306!\206O ;\206O 9\206O :\205O \306A!?)\205d \nA\211<\203a \f@:\206c \f9))\204m \307\310	\"\210\211:\205\260 \n@\211\250\206\233 ?\206\233 \306!\206\233 ;\206\233 9\206\233 :\205\233 \306A!?)\205\260 \nA\211<\203\255 \f@:\206\257 \f9))\204\271 \307\311\"\210G\312\313\211W\203:\204\330 \307\314\"\210H\211A\236\211\204\367 \313CBAB\241\210AT\211\202\310 	9\203A\203\307\315\"\202f	\241\202f	\211:\205_\n@\211\250\206J?\206J\306!\206J;\206J9\206J:\205J\306A!?)\205_\nA\211<\203\\\f@:\206^\f9))\203\224A<\204p\307\315\"\202f	A<\204\211A\203\202\307\315\"\202f	\241\202f\316	A\"\241\202f\204\236\203	:\204	9\204	\250\203\264\317	!\202\303	;\203\303	\320\317\")	G\313\312V\203S	H\211\250\203\347\321!	I\210\203\376\322\312G$\210\203\312BAB\241\210\202\312*@\203c\203c\323@#\211\250\2034\317!\2029A	\250\203E\317	!\202T	;\203T	\320\317\")\312\211\211\211\313\257\324	\"B)	\240,\207" [key trans object translation alist map vectorp error "Invalid Quail translation `%s'" "Invalid Quail map `%s'" 0 nil "Quail key %s is too long" "Quail key %s is too short" append vector string-to-sequence char-to-string add-text-properties quail-get-translation vconcat entry ch idx len props decode-map string elt prev] 6 (#$ . 34028)])
#@300 Return the translation specified as DEF for KEY of length LEN.
The translation is either a character or a cons of the form (INDEX . VECTOR),
where VECTOR is a vector of candidates (character or string) for
the translation, and INDEX points into VECTOR to specify the currently
selected translation.
(defalias 'quail-get-translation #[(def key len) "\203 9\203 \304!\203 	\n\"\202 \305:\203( \306A!\204( @\250\2042 :\2034 \207\204: \305\207;\203Z G\307U\203J \310H\207\310\211\211\211\305\257\311\312\")B\207\306!\203\200 G\307U\203v \310HG\307U\203v \310H\310H\207\310\211\211\211\305\257B\207\313\314\"\207" [def key len string functionp nil vectorp 1 0 string-to-sequence vector error "Invalid object in Quail map: %s"] 5 (#$ . 35971)])
#@129 Lookup KEY of length LEN in the current Quail map and return the definition.
The returned value is a Quail map specific to KEY.
(defalias 'quail-lookup-key #[(key &optional len) "\204 	G\306\307\n8\310\n8\311\211\211\211\203~ W\203~ \2037 \312	H!\202; 	HTA\203X A9\203X \211A	\"\241\210A\236\211A\203u A9\203u \211A	\"\241\210A\211\204\" @\311\203\345 \313	#\211\203\345 :\203\277 \314A!\204\277 @\f\232\204\253 \f\240\210\315A!\203\270 A \202\272 A\202\312 \f\232\204\312 \f\240\210\f:\203\345 \314\fA!\203\345 \f\316\n8\203\345 @\306\240\210A\203\374 \315A!\203\374 \211A	\"\241\210.\207" [len key quail-current-package def translation ch 0 2 8 nil quail-keyboard-translate quail-get-translation vectorp functionp 6 slot kbd-translate map idx quail-current-translations quail-current-data] 8 (#$ . 36749)])
(put 'quail-error 'error-conditions '(quail-error error))
(defalias 'quail-error #[(&rest args) "\301\302\303\304\"\"\207" [args signal quail-error apply format] 5])
#@171 Convert input string STR to a list of events.
Do so while interleaving with the following special events:
(compose-last-chars LEN COMPONENTS)
(quail-advice INPUT-STRING)
(defalias 'quail-input-string-to-events #[(str) "\306	\307\")G\211\310\310\310\f\311V\203S \312\f\311\313$\211\203S @A@\211S\n\233\314Z\3158?\205C \3168E\n\233B\241\210S\211\202 \317\311\320#\204c \321\311\320#\203j \n\322DC\244\n.\207" [str string events len idx composition string-to-sequence list nil 0 find-composition t compose-last-chars 3 2 get-text-property advice next-single-property-change quail-advice from to] 6 (#$ . 37821)])
(byte-code "\301B\304\301!\204\f \305\302B\304\302!\204 \305\303B\304\303!\204$ \305\305\207" [current-load-list quail-translating quail-converting quail-conversion-str boundp nil] 2)
(defalias 'quail-input-method #[(key) "\204\f 	\204\f \n\203 C\207\306\307\f8!\210\310 \311\2036 \312!\2036 \313!=\2036 \2039 \314 \210\315\216\307\f8\203G \316!\202J \317!\211;\205j G\320V\205j \203f \320HC\202j \321!,\207" [buffer-read-only overriding-terminal-local-map overriding-local-map key quail-current-package buffer-undo-list quail-setup-overlays 14 buffer-modified-p t window-live-p window-buffer quail-show-guidance-buf ((byte-code "\303 \210\304!\203 \212q\210\305 \210)\306 \210\307	!\210\310\n8\204\" \311\312!\210\303\207" [quail-guidance-buf modified-p quail-current-package quail-delete-overlays buffer-live-p erase-buffer quail-hide-guidance-buf set-buffer-modified-p 14 run-hooks input-method-after-insert-chunk-hook] 2)) quail-start-conversion quail-start-translation 0 quail-input-string-to-events modified-p quail-guidance-win quail-guidance-buf input-method-use-echo-area input-string input-method-exit-on-first-char] 4])
(defalias 'quail-overlay-region-events #[(overlay) "\304!\305!\211	W\205 \n	{\306\307\")\n	|\210*\207" [overlay end start string overlay-start overlay-end string-to-sequence list] 4])
#@61 Delete the text in the current translation region of Quail.
(defalias 'quail-delete-region #[nil "\301!\205 \301!\302!|\207" [quail-overlay overlay-start overlay-end] 3 (#$ . 39836)])
(put 'quail-delete-region 'byte-optimizer 'byte-compile-inline-expand)
#@101 Start translation of the typed character KEY by the current Quail package.
Return the input string.
(defalias 'quail-start-translation #[(key) "\250\203 \306	8\203 \307!\202 \310	8A\236\204 \204\314 \311\312\313	8\312\312\314 \312 \312!\312\"\315#\315$\316%\203K &B&%\203\266 \317!\210\320'\205` ($P\312\211\316$)\321\313	8)\"*\203\202 \322*!\203\243 *\323=?\202\206 *\324=\203\243 )\211GSH \"!*\"\316\325\326\327\217\210\202\262 \330 +\331+\332\")&\312%*\202K \333,!\203\307 \333,!\334,!|\210$.	\207\306	8\203\326 \307!\335!\207" [key quail-current-package echo-keystrokes help-char overriding-terminal-local-map generated-events 8 quail-keyboard-translate 2 0 nil 5 buffer-modified-p "" t set-buffer-modified-p read-key-sequence lookup-key commandp quail-other-command quail-self-insert-command err (call-interactively cmd) ((quail-error (byte-code "\301\302A\"\210\303 \207" [err message "%s" beep] 3))) this-single-command-raw-keys string-to-sequence list overlay-start overlay-end char-to-string input-method-function modified-p last-command-event last-command this-command quail-current-key quail-current-str quail-translating unread-command-events input-method-use-echo-area input-method-previous-message keyseq cmd string quail-overlay] 5 (#$ . 40102)])
#@100 Start conversion of the typed character KEY by the current Quail package.
Return the input string.
(defalias 'quail-start-conversion #[(key) "\250\203 \306	8\203 \307!\202 \310	8A\236\204 \204\311\312\313	8\312\312\314  \312!\312\"\312#\315$\315%\316&\316'\315(\203Q )B)'\203\372 \317 !\210&\204m \315$\315%\316&\320\312!\210\321\312!\210\322*\205~ +(%Q\312\211\316$,\323\313	8,\"-\203\230 \324-!\202\234 -\325=\203\347 ,\211GSH!#\"-#\316\326\327\330\217\210&\204\366 %\203\324 (%;\203\315 %\202\321 \331%!P(.\204\341 (G\311U\203\366 \312'\202\366 \332 /\333/\334\"))\312'*\202Q \312&\3350!\203\3350!\3360!|\210(G\311V\205(.	\207\306	8\203%\307!\331!\207" [key quail-current-package echo-keystrokes help-char overriding-terminal-local-map generated-events 8 quail-keyboard-translate 2 0 nil 14 buffer-modified-p "" t set-buffer-modified-p quail-setup-overlays message read-key-sequence lookup-key commandp quail-self-insert-command err (call-interactively cmd) ((quail-error (byte-code "\301\302A\"\210\303 \207" [err message "%s" beep] 3))) char-to-string this-single-command-raw-keys string-to-sequence list overlay-start overlay-end input-method-function modified-p last-command-event last-command this-command quail-current-key quail-current-str quail-translating quail-converting quail-conversion-str unread-command-events input-method-use-echo-area input-method-previous-message keyseq cmd input-method-exit-on-first-char string quail-conv-overlay] 5 (#$ . 41429)])
#@47 Terminate the translation of the current key.
(defalias 'quail-terminate-translation #[nil "\302\303	!\205 \212	q\210\304 )\207" [quail-translating quail-guidance-buf nil buffer-live-p erase-buffer] 2 (#$ . 42988)])
#@44 Accept the currently selected translation.
(defalias 'quail-select-current #[nil "\300 \207" [quail-terminate-translation] 1 (#$ . 43212) nil])
#@420 Update the current translation status according to CONTROL-FLAG.
If CONTROL-FLAG is integer value, it is the number of keys in the
head `quail-current-key' which can be translated.  The remaining keys
are put back to `unread-command-events' to be handled again.  If
CONTROL-FLAG is t, terminate the translation for the whole keys in
`quail-current-key'.  If CONTROL-FLAG is nil, proceed the translation
with more keys.
(defalias 'quail-update-translation #[(control-flag) "\3068\211\203 	\n!\202k \n\247\203H G\n\307U\203+ \3108\203) \311!\202* \204D \f\nV\203D \fS\fHB\2020 )\202k \n\204k \204k \3108\203\\ \311!\202] \203k \3128\203k \313)\204\205 \314!\203\202 \314!\315!|\210c\210\316\317 \210);\204\224 \320!\n\205\232 \321 \207" [quail-current-package func control-flag quail-current-key len quail-current-str 13 0 8 quail-keyseq-translate 15 t overlay-start overlay-end nil quail-update-guidance char-to-string quail-terminate-translation input-method-exit-on-first-char unread-command-events input-method-use-echo-area quail-overlay] 4 (#$ . 43363)])
#@63 Translate the typed key by the current Quail map, and insert.
(defalias 'quail-self-insert-command #[nil "\303	!P\304\305\215\206 \306\211\207" [quail-current-key last-command-event quail-translating char-to-string quail-tag (byte-code "\300\301 !\210\302\207" [quail-update-translation quail-translate-key t] 2) nil] 3 (#$ . 44468) "*"])
#@53 Return the actual definition part of Quail map MAP.
(defalias 'quail-map-definition #[(map) "@\211:\203 \302	A!\204 	@	\303=\203 \304	)\207" [map def vectorp t nil] 3 (#$ . 44817)])
#@163 Return string to be shown as current translation of key sequence.
LEN is the length of the sequence.  DEF is a definition part of the
Quail map for the sequence.
(defalias 'quail-get-current-str #[(len def) ":\203 A@@H\206; \206; 	\304V\205; \305	S\306\307\n	S\"!\"\211\205: ;\2031 \2024 \310!\n	S	OP)\207" [def len quail-current-key str 1 quail-get-current-str quail-map-definition quail-lookup-key char-to-string] 7 (#$ . 45013)])
(byte-code "\301B\302\301!\204\f \303\301\207" [current-load-list quail-guidance-translations-starting-column boundp 20] 2)
#@83 Update `quail-current-translations'.
Make RELATIVE-INDEX the current translation.
(defalias 'quail-update-current-translations #[(&optional relative-index) "@\211@	A@\306	8\n\307W\203 	\307\211\240\210\202. \nAGY\203. 	AGS\211\240\210\f\203> \nW\204> \n\fY\203AG\310!Z\311	8\312\211\211\211\211\211\nW\203p \307\307\202v \f\203v \f\307\307W\203\357 \n\fY\203\357 \307U\203\241 \307TAH\211\250\203\264 \313!\202\270 \314!\\\311\\T\211\307V\203\346 Y\204\335 \315V\203\346 \307\202\201 T\211\202\203 \311	\233\240\210Y\203\316	\233\240\210	A\240\210	AA\f\240\210.	\2032\\\fY\203+	\fS\240\210\2022	\\\240\210A	@H\211;\206E\317!\211,\207" [quail-current-translations indices cur start end quail-guidance-win 2 0 window-width 3 nil char-width string-width 10 4 char-to-string quail-guidance-translations-starting-column blocks num-items trans width idx col block maxcol len relative-index quail-current-str] 10 (#$ . 45588)])
#@351 Translate the current key sequence according to the current Quail map.
Return t if we can terminate the translation.
Return nil if the current key sequence may be followed by more keys.
Return number if we can't find any translation for the current key
sequence.  The number is the count of valid keys in the current
sequence counting from the head.
(defalias 'quail-translate-key #[nil "G\306	\"\307\307\n\203O \310\n!\311	\":\203& AG\312U\205K \nA?\205K \3138?\206K 	\314W\206K \306	S\"?\206K \306\315\316O\312\"?)\202\315 \3138\203\200 	\314Y\203\200 \310\306	\317Z\"!\211\203\200 \306\315\307O\317\"\203\200 \311	\317Z\"	\317Z\202\315 	\320V\203\313 \306\320\316O!\203\313 \203\313 \3218\204\313 	SH\211\203\313 \f\322Y\203\313 \f\323X\203\313 \320\316O\f\322U\203\277 \324\202\302 \f\325Z\326\f!\210\327\202\315 	S,\207" [quail-current-key len map def ch quail-current-str quail-lookup-key nil quail-map-definition quail-get-current-str 1 11 3 -2 -1 2 0 7 48 57 9 49 quail-update-current-translations t quail-current-package quail-current-translations] 5 (#$ . 46649)])
#@61 Select next translation in the current batch of candidates.
(defalias 'quail-next-translation #[nil "\203$ @\211@TAGU\203 \304 \202\" 	\211@T\240\210\305 \210\306\307!)\207\nB\310 \207" [quail-current-translations indices last-command-event unread-command-events beep quail-update-current-translations quail-update-translation nil quail-terminate-translation] 3 (#$ . 47762) nil])
#@65 Select previous translation in the current batch of candidates.
(defalias 'quail-prev-translation #[nil "\203! @\211@\304U\203 \305 \202 	\211@S\240\210\306 \210\307\310!)\207\nB\311 \207" [quail-current-translations indices last-command-event unread-command-events 0 beep quail-update-current-translations quail-update-translation nil quail-terminate-translation] 3 (#$ . 48156) nil])
#@45 Select from the next block of translations.
(defalias 'quail-next-translation-block #[nil "\203- @\211@	A@Z\305	8AGY\203 \306 \202+ 	\305	8\n\\\240\210\307 \210\310\311!*\207\fB\312 \207" [quail-current-translations indices offset last-command-event unread-command-events 2 beep quail-update-current-translations quail-update-translation nil quail-terminate-translation] 4 (#$ . 48555) nil])
#@57 Select the previous batch of 10 translation candidates.
(defalias 'quail-prev-translation-block #[nil "\203A @\211@	A@Z	A@\305U\203 \306 \202? 	\211A@S\240\210\307 \210	A@\n\\\310	8W\203< 	\211A@\n\\\240\210\307 \210\311\312!*\207\fB\313 \207" [quail-current-translations indices offset last-command-event unread-command-events 0 beep quail-update-current-translations 2 quail-update-translation nil quail-terminate-translation] 4 (#$ . 48961) nil])
#@62 Abort translation and delete the current Quail key sequence.
(defalias 'quail-abort-translation #[nil "\302!\203 \302!\303!|\210\304\305 \207" [quail-overlay quail-current-str overlay-start overlay-end nil quail-terminate-translation] 3 (#$ . 49424) nil])
#@70 Delete the last input character from the current Quail key sequence.
(defalias 'quail-delete-last-char #[nil "G\302U\203\n \303 \207\304\305O\306	!\203 \306	!\307	!|\210\310\311 !\207" [quail-current-key quail-overlay 1 quail-abort-translation 0 -1 overlay-start overlay-end quail-update-translation quail-translate-key] 3 (#$ . 49691) nil])
#@74 Return non-nil value if the point is in conversion region of Quail mode.
(defalias 'quail-point-in-conversion-region #[nil "\303\211\304\n!\211\205 `\211	Y\205 \305\n!X*\207" [pos start quail-conv-overlay nil overlay-start overlay-end] 3 (#$ . 50043)])
(put 'quail-point-in-conversion-region 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'quail-conversion-backward-char #[nil "`\302!X\203\f \303\304!\210\305\306u\207" [quail-conv-overlay quail-translating overlay-start quail-error "Beginning of conversion region" nil -1] 3 nil nil])
(defalias 'quail-conversion-forward-char #[nil "`\302!Y\203\f \303\304!\210\305\306u\207" [quail-conv-overlay quail-translating overlay-end quail-error "End of conversion region" nil 1] 3 nil nil])
(defalias 'quail-conversion-beginning-of-region #[nil "\302\303	!b\207" [quail-translating quail-conv-overlay nil overlay-start] 2 nil nil])
(defalias 'quail-conversion-end-of-region #[nil "\302\303	!b\207" [quail-translating quail-conv-overlay nil overlay-end] 2 nil nil])
(defalias 'quail-conversion-delete-char #[nil "\306`\307	!Y\203 \310\311!\210\312\313!\210\314	!\307	!\211\n{\nU\205' \306\211*\207" [quail-translating quail-conv-overlay end start quail-conversion-str quail-converting nil overlay-end quail-error "End of conversion region" delete-char 1 overlay-start] 4 nil nil])
(defalias 'quail-conversion-delete-tail #[nil "`\305!Y\203\f \306\307!\210`\305!|\210\310!\305!\211	{\n	U\205' \311\211*\207" [quail-conv-overlay end start quail-conversion-str quail-converting overlay-end quail-error "End of conversion region" overlay-start nil] 4 nil nil])
(defalias 'quail-conversion-backward-delete-char #[nil "G\306V\203\n \307 \207`\310	!X\203 \311\312!\210\313\314!\210\310	!\315	!\211\n{\nU\205/ \316\211*\207" [quail-current-key quail-conv-overlay end start quail-conversion-str quail-converting 0 quail-delete-last-char overlay-start quail-error "Beginning of conversion region" delete-char -1 overlay-end nil] 4 nil nil])
#@99 Call FUNC to convert text in the current conversion region of Quail.
Remaining args are for FUNC.
(defalias 'quail-do-conversion #[(func &rest args) "\303!\210\304	\n\"\207" [quail-overlay func args delete-overlay apply] 3 (#$ . 52066)])
#@61 Do no conversion of the current conversion region of Quail.
(defalias 'quail-no-conversion #[nil "\301\211\207" [quail-converting nil] 2 (#$ . 52311) nil])
#@54 Make a new one-line frame for Quail guidance buffer.
(defalias 'quail-make-guidance-frame #[(buf) "\306 \301\236A\307\236A\310\236A	\311 Z\211\\\312\\Z\n\211\\\312\\Z\211\312W\203. 	\313 \\\314\315\316\301\fBB\"!\317!\320\".\207" [fparam top border internal-border newtop frame frame-parameters border-width internal-border-width frame-char-height 0 frame-pixel-height make-frame append ((user-position . t) (height . 1) (minibuffer) (menu-bar-lines . 0)) frame-first-window set-window-buffer win buf] 6 (#$ . 52474)])
#@32 Setup Quail completion buffer.
(defalias 'quail-setup-completion-buf #[nil "\304!?\205 	\305\306!)\212q\210\307\310\211\"\311\312\313#)\207" [quail-completion-buf enable-multibyte-characters default-enable-multibyte-characters quail-overlay buffer-live-p get-buffer-create "*Quail Completions*" make-overlay 1 overlay-put face highlight] 4 (#$ . 53019)])
#@74 Return t iff the current Quail package requires showing guidance buffer.
(defalias 'quail-require-guidance-buf #[nil "\205# \302=\203 \303 \304 =\205 \305	8?\207\306=\203\" \305	8?\207\307\207" [input-method-verbose-flag quail-current-package default selected-window minibuffer-window 15 complex-only t] 2 (#$ . 53387)])
#@344 Display a guidance buffer for Quail input method in some window.
Create the buffer if it does not exist yet.
The buffer is normally displayed at the echo area,
but if the current buffer is a minibuffer, it is shown in
the bottom-most ordinary window of the same frame,
or in a newly created frame (if the selected frame has no other windows).
(defalias 'quail-show-guidance-buf #[nil "\306 \203\325 \307\n!\204 \310\311!)@\312 \212\nq\210*\f+\313 \210\314,!\2049 \315\316\211\",\317,\320\321#\210\322,!\210\323\324!\210+\325\n!\210\326\n\327\211#\211-\203f \330-@\331\332\333 \"\"\210-A\211-\204R )\334 .\335 .=\204x /\203\305 .\336 =\203\207 \337\n!\210\202\320 \340\341\342 \343.!ZS\".\343.!\3440\2111\345Y\203\255 \346.1\344Z\".\330.\n\"\210\212\nq\210\347.\324\343.!#\210+\202\320 \330.\n\"\210\350.!\210.2)\351 \210\3253!\207" [enable-multibyte-characters default-enable-multibyte-characters quail-guidance-buf quail-current-package title name quail-require-guidance-buf buffer-live-p generate-new-buffer " *Quail-guidance*" quail-title erase-buffer overlayp make-overlay 1 overlay-put face highlight delete-overlay set-buffer-modified-p nil bury-buffer get-buffer-window-list t set-window-buffer format " *Minibuf-%d*" minibuffer-depth minibuffer-window selected-window frame-root-window quail-make-guidance-frame window-at 0 frame-height window-height 2 4 split-window fit-window-to-buffer set-minibuffer-window quail-setup-completion-buf current-input-method current-input-method-title quail-overlay win-list win input-method-use-echo-area window-min-height height quail-guidance-win quail-completion-buf] 6 (#$ . 53720)])
#@33 Hide the Quail guidance buffer.
(defalias 'quail-hide-guidance-buf #[nil "\304!\205H \305\306\211#\307\n\203D \n@\nA\310	!\203* \311	\312\313\314 \"\"\210\202 	\315\316	!!=\203= \317\316	!!\210\202 \320	!\210\202 \307\211*\207" [quail-guidance-buf win win-list quail-guidance-win buffer-live-p get-buffer-window-list t nil window-minibuffer-p set-window-buffer format " *Minibuf-%d*" minibuffer-depth frame-root-window window-frame delete-frame delete-window] 5 (#$ . 55395)])
#@76 Update the Quail guidance buffer and completion buffer (if displayed now).
(defalias 'quail-update-guidance #[nil "\306 \203X \3078\310 \311\312 !=\203 \310 \311\n!=\204 \313 \210	\314=\204* 	:\2030 \315 \210\202K 	\204K \3168\203@ \317\f!\212q\210\320 \210\fc\210*\321\322!\210\323\n\324\325\n!#\210)\326!!\324\211\211\"#\211$\205\354 \212%;\203v %\202\200 %\247\205\200 \327%!#!q\210eb\210\330\331\f\332Q\324\314#\204\235 \333&!\202\353 `\"#\203\274 \330\334#P\324\314#\203\274 \335&\322\224T`#\210\202\304 \335&\322\224`#\210\336`$\"?\205\353 \"b\"\337 \210\340$`\"\210\336\"$\"?\205\353 \340$\"\"),\207" [quail-current-package guidance quail-guidance-win quail-current-key key quail-guidance-buf quail-require-guidance-buf 3 selected-frame window-frame minibuffer-window quail-show-guidance-buf t quail-show-translations 8 quail-keyseq-translate erase-buffer sit-for 0 fit-window-to-buffer nil window-height get-buffer-window char-to-string search-forward " " ":" delete-overlay "." move-overlay pos-visible-in-window-p beginning-of-line set-window-start quail-completion-buf pos str win quail-current-str quail-overlay] 6 (#$ . 55888)])
#@41 Show the current possible translations.
(defalias 'quail-show-translations #[nil "\306!\203 \307 \210\212q\210\310 \210\3118\211<\203T \312	G\313 \211! W\203P \314	!H\"A\211\206E 	!Hc\210!T\211!\202, +\202W 	c\210)	G\312V\203\214 \nA\203\214 \315\316\nA\"\"\317\"\320\"\"\321c\210\"\203\210 \"@c\210\"A\211\"\204z \322c\210)\f\205\3238?\205\f@\211#@$#A@%\324#8&%'(\323Zj\210\325\326\311#8\"\327#8\203\316 \325\330\327#8\"\202\317 \331\261\210'&W\205\325\332'%Z\333U\203\352 \312\202\360 '%ZT\"c\210`)\fA'Hc\210'$U\203\334*)`#\210)'T\211'\202\324 -,\207" [quail-current-key key map quail-current-translations current-translations quail-guidance-buf quail-lookup-key quail-update-current-translations erase-buffer 3 0 nil assoc mapcar #[(x) "@\207" [x] 1] sort < "[" "]" 7 2 format "(%02d/" 4 "%02d)" "??)" " %d." 9 move-overlay quail-current-package guidance prompt-key len i keys indices cur start end idx quail-guidance-translations-starting-column pos quail-overlay] 6 (#$ . 57072)])
#@45 The maximum depth of Quail completion list.
(defvar quail-completion-max-depth 5 (#$ . 58135))
#@192 List all completions for the current key.
All possible translations of the current key and whole possible longer keys
are shown (at most to the depth specified `quail-completion-max-depth').
(defalias 'quail-completion #[nil "\306 \210\307\310\"	\311	!\312\212q\210\203> \f	\232\203> \313=\203> \314d\"\2034 \315e\"\210\202U \316 \210)\202U \f\317 \210\320c\210\321\f\322#\210eb\210\323p!\210\324)\n\203] \325 \210,\313\211\207" [quail-completion-buf quail-current-key require-update map key win quail-setup-completion-buf get-buffer-window visible quail-lookup-key nil quail-completion pos-visible-in-window-p set-window-start scroll-other-window erase-buffer "Possible completion and corresponding translations are:\n" quail-completion-1 1 display-buffer t quail-update-guidance last-command other-window-scroll-buffer this-command] 4 (#$ . 58237) nil])
#@61 List all completions of KEY in MAP with indentation INDENT.
(defalias 'quail-completion-1 #[(key map indent) "G\nj\210\306\261\2109\203 \307!\203 	\"@\203- \310\n	\\\311\\#\210\2020 \312c\210\n\313\\A\205\230 \nS\313\245\fW\205\230 A\314	T\315\"\315\316!\203[  	W\203p HI\210T\211\202\\ \317!\211\205\227 	@@I\210\320@A\n#\210A\211\204z \321+)\207" [key len indent map quail-completion-max-depth i ":" fboundp quail-completion-list-translations 1 " -\n" 2 make-string 0 functionp reverse quail-completion-1 nil newkey l] 6 (#$ . 59118)])
#@77 List all possible translations of KEY in Quail MAP with indentation INDENT.
(defalias 'quail-completion-list-translations #[(map key indent) "\306\307@	\211G#\n\250\203# \310c\210`\nc\210\311`\312\313$\210\314c\202y \nA\211G\315\306W\203v \316\317\246!\203X \317Y\203J \314c\210j\210\320\321\317\245T\317\245T#c\210\320\322T\317\246\"c\210`\nHc\210\311`\312\313$\210T\211\202/ \314c+*\207" [map key translations beg num i nil quail-get-translation "(1/1) 1." put-text-property mouse-face highlight "\n" 0 zerop 10 format "(%d/%d)" " %d." len indent] 6 (#$ . 59714)])
#@75 Click on an alternative in the `*Quail Completions*' buffer to choose it.
(defalias 'quail-mouse-choose-completion #[(event) "\306\307!\210\310 \311\211\212\310\3128)\313\f8)!q\210\203! \212\3128)\312\f8:\203: \312\f8@\202= \312\f8)b\210\311\211m\204X \314`\315\"\203X ``To\204k \314`S\315\"\203k `S`\204t \316\317!\210\320\315\"\321\315\"\206\204 d{,\322!\203\236 \322!\323!|\210\324	\n#\210\325 +\207" [base-size choice buffer event position completion-reference-buffer run-hooks mouse-leave-buffer-hook window-buffer nil 1 0 get-text-property mouse-face quail-error "No completion here" previous-single-property-change next-single-property-change overlay-start overlay-end quail-choose-completion-string quail-terminate-translation completion-base-size end beg quail-overlay] 4 (#$ . 60313) "e"])
(defalias 'quail-choose-completion-string #[(choice &optional buffer base-size) "\206 	\306\307\310!\"\203# \311 \203 \312\311 !\232\204# \313\314!\202] q\210\n\315\316\"\317\f`\"\210)?\205] \312\320 !\232\205] \205] \321=\203[ \322\323 !\203[ \324\311 !\202] \325 )\207" [buffer completion-reference-buffer choice quail-current-str window completion-no-auto-exit string-match "\\` \\*Minibuf-[0-9]+\\*\\'" buffer-name active-minibuffer-window window-buffer quail-error "Minibuffer is not active for completion" get-buffer-window t set-window-point minibuffer-window read-file-name-internal file-directory-p buffer-string select-window exit-minibuffer minibuffer-completion-table] 4])
#@496 Build a decoding map.
Accumulate in the cdr part of DECODE-MAP all pairs of key sequences
vs the corresponding translations defined in the Quail map
specified by the first element MAP-LIST.  Each pair has the form
(KEYSEQ . TRANSLATION).  DECODE-MAP should have the form
(decode-map . ALIST), where ALIST is an alist of length NUM.  KEY
is a key sequence to reach MAP.
Optional 5th arg MAXNUM limits the number of accumulated pairs.
Optional 6th arg IGNORES is a list of translations to ignore.
(defalias 'quail-build-decode-map #[(map-list key decode-map num &optional maxnum ignores) "@\306	@\n\211G#\307\250\2031 \310V\203Y >\204Y \nBAB\241\210T\202Y :\203Y A\307\311\312\"\210\203X \nBAB\241\210G\\)\203l V\203l [\202\256 	A	\203\254 \313Y\203\254 	@	A\f@\250\203o \fA:\203o \fA>\204o \314\fAB\315\316\n\f@#&\202o +\207" [map-list map key translation elt ignores quail-get-translation nil 255 mapc #[(x) "\250\203 \303V\202 \304!GV\205 	\235?\205 \305\211\207" [x ignores multibyte 255 string-bytes t] 2] 0 quail-build-decode-map format "%s%c" decode-map num multibyte maxnum] 7 (#$ . 61872)])
#@191 Insert pairs of key sequences vs the corresponding translations.
These are stored in DECODE-MAP using the concise format.  DECODE-MAP
should be made by `quail-build-decode-map' (which see).
(defalias 'quail-insert-decode-map #[(decode-map) "\306A\307\"\310\311\312p\313\"!!\314\315\314\316\211\211\211\211\211\211\211\211\211\211\211#$%&'()*+,\203\267 @'A'A&\317&!\203] &G\320U\203] &\321H&\317&!\203n '(B(\202\227 '@&B)B)&;\203\206 \322&!\202\212 \323&!\211%+V\203\227 %+'@G\211%,V\203\250 %,%*V\2038 %*\2028 )\203],+\\\324\\	\245#)G#\245)G#\246\321V\203\337 T\325c\210,Tj\210\326c\210	Tj\210\327c\210`$\330\331\324\\\"\210$b\210	[\321)\203Z)@')A)\246\321U\203:$b\210\f	\\\332\f\333\"\210\330\334,\"\210\335c\210\330\334+\"\210\320y\210\332\f\333\"\210'@c\210\f,\\\320\\j\210'Ac\210\320y\210T\202db\210(\205\257\325c\210*Tj\210\336c\210\330\334*\"\210\337c\210(\203\255(@'(A('@c\210*j\210\317'A!\203\240\340\341'A\"\210\202\247\342'A\261\210\331c\210\202v\331c.\207" [decode-map col-width str row col rows sort #[(x y) "@	@G	GV\206 G	GU\205 	\231?\207" [x y] 2] frame-width window-frame get-buffer-window visible 3 4 nil vectorp 1 0 string-width char-width 2 "key" "char" "[type a key sequence to insert the corresponding character]\n" insert-char 10 move-to-column t 45 32 "character(s)  [type a key (sequence) and select one from the list]\n" " ------------\n" mapc #[(x) "\250\203 \304!\202 \305!i	\\\306\\\nV\203 \307c\210j\210\310\261)\207" [x width frame-width multiple-key-width char-width string-width 1 "\n" " "] 2] " " cols pos width trans elt multiple-list single-list multiple-key-width single-trans-width single-key-width] 17 (#$ . 63049)])
#@140 Show brief description of the current Quail package.
Optional 2nd arg PACKAGE specifies the name of alternative Quail
package to describe.
(defalias 'quail-help #[(&optional package) "\203\f \306	\"\202 \n\f@\307\220\212Aq\210\211)\221\210\212\310\307!q\210\311B\312\n@\313\314 \315\261\210\214``}\210\316\n8c\210eb\210\317 pCD\320\216\321\322E!!\210\323\324\311\325#\203} \326\327\224\330\\`S{!F\331F!\203y FJ;\203y \332FJ\325\211#\210)\202P +db\210)n\204\211 \333c\210\333c\210\311G\334\n8\203\301 \335c\210\336(\337(\340$\210\341c\210\342H!G\343c\210\336\344\337\344\340$\210\345c\210\336\346\347\350\351$\210\333c\210\352C\311\211\211IJK*\353\330\n8C\354*\327\355G&\211I\327V\203\376 \356c\210\334\n8\203\363 \357c\210\202\366 \360c\210\361c\210\362*!\210-\363\364\n8\365\"\210\366c\210\367\n8\203\363\367\n8\370\"\210\371\372\n@Dt\"\210\311\373 L\374\216\375\376p!!\210\377\201M !-\207" [package quail-package-alist quail-current-package help-xref-mule-regexp-template enable-multibyte-characters default-enable-multibyte-characters assoc "*Help*" get-buffer nil "Input method: " " (mode line indicator:" quail-title ")\n\n" 4 syntax-table ((byte-code "rq\210\302	!\210)\302\207" [#1=#:buffer #2=#:table set-syntax-table] 2)) set-syntax-table copy-syntax-table re-search-forward "\\\\<\\sw\\(\\sw\\|\\s_\\)+>" t intern-soft 0 2 boundp replace-match "\n" 9 "\nKEYBOARD LAYOUT\n---------------\nThis input method works by translating individual input characters.\nAssuming that your actual keyboard has the `" help-insert-xref-button quail-show-keyboard-layout "mouse-2, RET: show this layout" "' layout,\ntranslation results in the following \"virtual\" keyboard layout:\n" quail-insert-kbd-layout "If your keyboard has a different layout, rearranged from\n`" "standard" "', the \"virtual\" keyboard you get with this input method\nwill be rearranged in the same way.\n\nYou can set the variable `quail-keyboard-layout-type' to specify\nthe physical layout of your keyboard; the tables shown in\ndocumentation of input methods including this one are based on the\nphysical keyboard layout as specified with that variable.\n" "[customize keyboard layout]" customize-variable quail-keyboard-layout-type "mouse-2, RET: set keyboard layout type" decode-map quail-build-decode-map "" 512 "\nKEY SEQUENCE\n-----------\n" "You can also input more characters" "You can input characters" " by the following key sequences:\n" quail-insert-decode-map quail-help-insert-keymap-description 5 "KEY BINDINGS FOR TRANSLATION\n----------------------------\n" 10 14 "KEY BINDINGS FOR CONVERSION\n---------------------------\n" help-setup-xref quail-help selected-window ((byte-code "\301!\203\n \302!\210\301\207" [save-selected-window-window window-live-p select-window] 2)) select-window get-buffer-window run-hooks help-xref-mule-regexp standard-output buffer-read-only #1# #2# emacs-lisp-mode-syntax-table sym done-list quail-keyboard-layout num pos elt save-selected-window-window temp-buffer-show-hook] 8 (#$ . 64844) nil])
(defalias 'quail-help-insert-keymap-description #[(keymap &optional header) "\306\211\211`\203 c\210\212\307\310!c\210)\311y\210`\312 p\313\216\314\315!!\210\316\317\306\320#\203h \321\322\224`{!\211\203d \323!\203d \324N\325=\204] \3268\203d \324N\327=\203d \330 \331 T|\210)\202) +	b\210m\204\205 \332\333!\203 `\331 T|\210\202l \334y\210\202l 	b\210m\203\220 \n`|\210db+\207" [eol pos2 pos1 header #1=#:buffer #2=#:table nil substitute-command-keys "\\{keymap}" 3 syntax-table ((byte-code "rq\210\302	!\210)\302\207" [#1# #2# set-syntax-table] 2)) set-syntax-table copy-syntax-table re-search-forward "\\sw\\(\\sw\\|\\s_\\)+" t intern-soft 0 fboundp quail-help hide 7 non-deterministic line-beginning-position line-end-position looking-at "[ 	]*$" 1 emacs-lisp-mode-syntax-table sym quail-current-package] 5])
#@60 Show help message while translating in Quail input method.
(defalias 'quail-translation-help #[nil "	=\204H \306\211\f\203& G\307U\203& \310\311\"#@#\312#8\2023 \310\313#@#\314#8\315\220\212$q\210c\210\316\n\317\"\210\320 )\221\210*\306%\321 &\322\216\323\324\315!!\210	=\203w \325 dW\203j \326 \210\202w \327 eV\203w \330\321 e\"\210\325\321 \331\"dW\203\205 \332\202\215 \327 eV\205\215 \333%*%\205\247 \334\335\336%!\"\210\337\340!\210\334\306!\210\341 )\207" [this-command last-command keymap state-msg quail-converting quail-current-key nil 0 format "Converting string %S by input method %S.\n" 14 "Translating key sequence %S by input method %S.\n" 5 "*Help*" quail-help-insert-keymap-description "-----------------------\n" help-mode selected-window ((byte-code "\301!\203\n \302!\210\301\207" [save-selected-window-window window-live-p select-window] 2)) select-window get-buffer-window window-end scroll-up window-start set-window-start up-to-date "Type \\[quail-translation-help] to scroll up the help" "Type \\[quail-translation-help] to see the head of help" message "%s" substitute-command-keys sit-for 1 quail-update-guidance quail-conversion-str quail-current-package standard-output scroll-help save-selected-window-window] 4 (#$ . 68744) nil])
#@938 Make quail map from state transition table TABLE.

TABLE is an alist, the form is:
  ((STATE-0 TRANSITION-0-1 TRANSITION-0-2 ...) (STATE-1 ...) ...)

STATE-n are symbols to denote state.  STATE-0 is the initial state.

TRANSITION-n-m are transition rules from STATE-n, and have the form
(RULES . STATE-x) or RULES, where STATE-x is one of STATE-n above,
RULES is a symbol whose value is an alist of keys (string) vs the
correponding characters or strings.  The format of the symbol value of
RULES is the same as arguments to `quail-define-rules'.

If TRANSITION-n-m has the form (RULES . STATE-x), it means that
STATE-n transits to STATE-x when keys in RULES are input.  Recursive
transition is allowed, i.e. STATE-x may be STATE-n.

If TRANSITION-n-m has the form RULES, the transition terminates
when keys in RULES are input.

The generated map can be set for the current Quail package by the
function `quail-install-map' (which see).
(defalias 'quail-map-from-table #[(table) "\304\305\"\306\211\203 \307@\"\210A\211\204 \n\203. \n@\nA\310	\"\210\202 @+\207" [table elt tail state-alist mapcar #[(x) "@C\207" [x] 1] nil quail-map-from-table-1 quail-map-from-table-2] 4 (#$ . 70036)])
(defalias 'quail-map-from-table-1 #[(state-alist state-info) "@\211\n\236A\306\f\205\203 \f@\fA\306\211\211\211\f:\2034 @JAC\2028 J\203 @@@A\fA\f;\203q \fG\307U\203e \f\310H\f\202q \f\311\312\")\f\313\f\306%\210\2028 ,\202\f ,\207" [state-info state state-alist map transitions elt nil 1 0 string-to-sequence vector set-nested-alist trans key dst-state rules string] 7])
(defalias 'quail-map-from-table-2 #[(state-alist element) "\211A\305\nA\203 \n@\n\nA\306\f	A\"\210\202 \n@\211:\203- \306\f	A\"\2023 	\f\236A\241+\207" [element elt tail prev state-alist nil quail-map-from-table-2] 4])
(defalias 'quail-lookup-map-and-concat #[(key) "G\306\306	\307V\203> \310	\"	S\203 \311!\211:\203+ \fA\f@@H\202, \f\211\250\2036 \312!\nB*\202 \313\314\n\"+\207" [key len translation-list map def trans nil 0 quail-lookup-key quail-map-definition char-to-string apply concat] 4])
#@99 Name of Quail directory which contains Quail packages.
This is a sub-directory of LEIM directory.
(defvar quail-directory-name "quail" (#$ . 72200))
#@487 Update entries for Quail packages in `LEIM' list file in directory DIRNAME.
DIRNAME is a directory containing Emacs input methods;
normally, it should specify the `leim' subdirectory
of the Emacs source tree.

It searches for Quail packages under `quail' subdirectory of DIRNAME,
and update the file "leim-list.el" in DIRNAME.

When called from a program, the remaining arguments are additional
directory names to search for Quail packages under `quail' subdirectory
of each directory.
(defalias 'quail-update-leim-list-file #[(dirname &rest dirnames) "\306!\306	\"\307\211\211\211\211+,\310,!\204\" \311\312,\"\210\313\314,\"\210\315,!\212q\210\316b\210\317\320-!!\203D \321\225b\210\202H -c\210`\322.\307\323#\203x \321\224b\210\n`W\203a \n`|\210\322.\307\324#\203x \321\224b\210`\307\325\326\217\210\202a )/B\211/\2110\203\276 0\3060@!\240\210\30610@\"\327!\203\246 +B+\202\265 \313\3300@1#\210\307+B+0A\2110\204\206 +\237+)+\203!+@\211\203\304 \331\332\333\334$\211\203\313\335\f@\"\210\336\337\340!!2\341\216r2q\210\342\f@!\210eb\210\343\344\307\323#\203\f\321\224b\210\307\345\346\217\210\202\370 +\fA\211\204\334 +A+/A/\202\304 \212q\210\3473\350\321!\210)\351!\210\313\352,\".\207" [dirname leim-list-file-name pos pkg-buf pkg-list list-buf expand-file-name nil file-writable-p error "Can't write to file \"%s\"" message "Updating %s ..." find-file-noselect 1 looking-at regexp-quote 0 re-search-forward t move (byte-code "\303!\304	8\305\232\203 l\203 \306y\210\n`|\210)\303\207" [list-buf form pos read 3 'quail-use-package 1] 2) ((error (byte-code "\302\303\"\210	d|\207" [leim-list pos message "Garbage in %s deleted"] 3))) file-readable-p "%s doesn't have `%s' subdirectory, just ignored" directory-files full "\\.el$" nosort "Checking %s ..." get-buffer-create generate-new-buffer-name " *temp*" ((byte-code "\301!\203\n \302!\210\301\207" [#1=#:temp-buffer buffer-name kill-buffer] 2)) insert-file-contents search-forward "(quail-define-package" (byte-code "\304p!\212	q\210\305\306A@\3078\310\3118\312\313\3148\"\210\315\316\3148\"\317\320\n@!@\"&c\210*\304\207" [form list-buf pkg-list dirnames read format "(register-input-method\n %S %S '%s\n %S %S\n %S)\n" 2 quail-use-package 3 string-match ".*" 5 match-string 0 file-relative-name file-name-sans-extension] 10) ((error (byte-code "db\210\301\302\"\207" [dirname message "Some part of \"%s\" is broken"] 3))) iso-2022-7bit save-buffer kill-buffer "Updating %s ... done" quail-dirs leim-list leim-list-header leim-list-entry-regexp dirnames l quail-directory-name #1# buffer-file-coding-system] 7 (#$ . 72356) "FDirectory of LEIM: "])
#@300 Advise users about the characters input by the current Quail package.
The argument is a parameterized event of the form:
   (quail-advice STRING)
where STRING is a string containing the input characters.
If STRING has property `advice' and the value is a function,
call it with one argument STRING.
(defalias 'quail-advice #[(args) "A@\303\304\305	#\306\n!\205 \n	!*\207" [args string func get-text-property 0 advice functionp] 4 (#$ . 75047) "e"])
(byte-code "\300\301\302\"\210\303\304!\207" [global-set-key [quail-advice] quail-advice provide quail] 3)