;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:09:11 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/international/quail.el
;;; in Emacs version 24.3.1
;;; with all optimizations.

;;; This file contains utf-8 non-ASCII characters,
;;; and so cannot be loaded into Emacs 22 or earlier.
(and (boundp 'emacs-version)
     (< (aref emacs-version (1- (length emacs-version))) ?A)
     (string-lessp emacs-version "23")
     (error "`%s' was compiled for Emacs 23 or later" #$))

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


(byte-code "\300\301!\210\302\303\304\305\306\307%\207" [require help-mode custom-declare-group quail nil "Quail: multilingual input method." :group leim] 6)
#@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 (#$ . 721))
(byte-code "\300\301!\210\302\301\303\304#\207" [make-variable-buffer-local quail-current-package put permanent-local t] 4)
(defvar quail-guidance-str nil)
(defvar quail-completion-buf nil)
(defvar quail-guidance-buf nil)
(defvar quail-guidance-frame nil)
(byte-code "\300\301!\210\302\301\303\304#\207" [make-variable-buffer-local quail-guidance-str put permanent-local t] 4)
#@63 Overlay which covers the current translation region of Quail.
(defvar quail-overlay nil (#$ . 1283))
(make-variable-buffer-local 'quail-overlay)
#@62 Overlay which covers the text to be converted in Quail mode.
(defvar quail-conv-overlay nil (#$ . 1434))
(make-variable-buffer-local 'quail-conv-overlay)
#@44 Current key for translation in Quail mode.
(defvar quail-current-key nil (#$ . 1594))
(make-variable-buffer-local 'quail-current-key)
#@52 Currently selected translation of the current key.
(defvar quail-current-str nil (#$ . 1734))
(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 (#$ . 1883))
(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 (#$ . 2329))
(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 (#$ . 2696))
#@47 Return the name of the current Quail package.
(defalias 'quail-name #[nil "@\207" [quail-current-package] 1 (#$ . 3313)])
(put 'quail-name 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'quail-indent-to #[(col) "j\210`\212\302\303\304x!?\205\305`	\306\307\310E$*\207" [col end zerop "	 " nil put-text-property display space :align-to] 7])
#@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\3028\207\303\207" [x 3 2 #1=""] 2] title #1#) ((error #1#))] 4 (#$ . 3672)])
#@58 Return the translation map of the current Quail package.
(defalias 'quail-map #[nil "\3018\207" [quail-current-package 2] 2 (#$ . 3989)])
(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 "\3018\207" [quail-current-package 3] 2 (#$ . 4196)])
(put 'quail-guidance 'byte-optimizer 'byte-compile-inline-expand)
#@63 Return the documentation string of the current Quail package.
(defalias 'quail-docstring #[nil "\3018\207" [quail-current-package 4] 2 (#$ . 4484)])
(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 "\3018\207" [quail-current-package 5] 2 (#$ . 4708)])
(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 "\3018\207" [quail-current-package 6] 2 (#$ . 5016)])
(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 "\3018\207" [quail-current-package 7] 2 (#$ . 5322)])
(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 "\3018\207" [quail-current-package 8] 2 (#$ . 5604)])
(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 "\3018\207" [quail-current-package 9] 2 (#$ . 5886)])
(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 "\3018\207" [quail-current-package 10] 2 (#$ . 6162)])
(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 "\3018\207" [quail-current-package 11] 2 (#$ . 6430)])
(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 "\3018\207" [quail-current-package 12] 2 (#$ . 6721)])
(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 "\3018\207" [quail-current-package 13] 2 (#$ . 6960)])
(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 "\3018\207" [quail-current-package 14] 2 (#$ . 7232)])
(put 'quail-conversion-keymap 'byte-optimizer 'byte-compile-inline-expand)
#@50 Return t if the current Quail package is simple.
(defalias 'quail-simple #[nil "\3018\207" [quail-current-package 15] 2 (#$ . 7573)])
(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 (#$ . 7778)])
(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\203A\241\202\nB\211)\207" [package name quail-package-alist pac assoc] 4 (#$ . 7980)])
#@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 (#$ . 8194)])
#@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\204n\f\203n\307\f@\310\"\204g
r\311\312!q\210p\313 \210\314\211\310\211\310 \315 \210\316\317!\210+\211!\"\320\321!\210\320!\210\320\322!\210\320\f@!\210\320\323!\210\324!!\210+\325\326\"\210\202\f\fA\211\204)\327!\210\330 #\331 \210\332\314!\207" [package-name name quail-package-alist package libraries default-directory assoc load t get-buffer-create "*Help*" kill-all-local-variables nil erase-buffer run-hooks temp-buffer-setup-hook 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." internal-temp-output-buffer-show error "Can't use the Quail package `%s'" quail-select-package quail-title quail-activate message #1=#:old-dir buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only #2=#:buf standard-output current-input-method-title] 4 (#$ . 8490)])
#@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#\210T\211\202\310W\203/\305	\306!\311#\210T\211\202\312\211\313W\203F\305	\314!\311#\210T\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) (#$ . 9889))
(defvar quail-translation-docstring "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.")
(byte-code "\301\302@@\303@A#\210A\211\204)\302\207" [l ((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#\210T\211\202\310W\203/\305	\306!\311#\210T\211\202\312\211\313W\203F\305	\314!\311#\210T\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) (#$ . 12212))
#@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#\210T\211\202\310\211\311W\2031\305	\312!\307#\210T\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) (#$ . 12869))
(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\203B\310
\203\202!\f\306\211\203>@\311	@A#\210A\211\204&*\202N
\203K\202M\203|\310!\306\211\203{@\311@A#\210A\211\204c*\312\306C\206\213\313	\n\205\231\314C 
\257!\210\315!\"\"\316F#\211$\203\304$#\241\210\202\316#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 trans --dolist-tail-- conversion-keys quail-conversion-keymap conv 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 (#$ . 13843)])
(defalias 'quail-setup-overlays #[(conversion-mode) "`\306	!\203\307	\211#\210\202:\310\211\"\n\203 \311	\312\313#\210\3148\211\2039\311	\f@\fA@#\210\fAA\211\204()
\205f\306!\203V\315!?\205f\307\211#\202f\310\211\"\n\205f\311\312\313#)\207" [pos quail-overlay input-method-highlight-flag quail-current-package l conversion-mode overlayp move-overlay make-overlay overlay-put face underline 12 overlay-start quail-conv-overlay] 5])
(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])
#@93 Deactivate Quail input method.

This function runs the normal hook `quail-deactivate-hook'.
(defalias 'quail-deactivate #[nil "\300\301!\207" [quail-activate -1] 2 (#$ . 19464) nil])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias quail-inactivate quail-deactivate nil make-obsolete "24.3"] 4)
#@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-deactivate-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\313 \210\314\315\316\317#\210\320\321\322\")\207\n\204<\312\f\2033\f@@\2027\323\324!\210\325!\210)\326\327\311 \210\330\"\316 \210\331 \332 =\203]\333\334\335\"\210\333\315\316\312\317$\210\320\336!\210\337\340!\210\341\211 \207" [arg describe-current-input-method-function quail-current-package name quail-package-alist deactivate-current-input-method-function prefix-numeric-value 0 ((byte-code "\300\301!\207" [kill-local-variable input-method-function] 2)) quail-delete-overlays nil quail-hide-guidance remove-hook post-command-hook quail-show-guidance t run-hooks quail-inactivate-hook quail-deactivate-hook error "No Quail package loaded" quail-select-package quail-deactivate quail-help "" selected-window minibuffer-window add-hook minibuffer-exit-hook quail-exit-from-minibuffer quail-activate-hook make-local-variable input-method-function quail-input-method quail-guidance-str] 5 (#$ . 19783)])
(byte-code "\302\303\304\305#\210\306\305\211\203,	@\303N\203%\304N\204%\307\304\303N#\210	A\211\204*\310\303\304\311#\207" [prop --dolist-tail-- defvaralias quail-inactivate-hook quail-deactivate-hook nil (saved-value saved-variable-comment) put make-obsolete-variable "24.3"] 6)
(defalias 'quail-exit-from-minibuffer #[nil "\300 \210\301 \302X\205\303\304\305\"\207" [deactivate-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,<.>/?                                      " (#$ . 21635))
(defconst quail-keyboard-layout-len 180)
#@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 "\301B\302\303\304\305\306\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,<.>/?\\_                                    ") ("pc105-uk" . "                              `\2541!2\"3\2434$5%6^7&8*9(0)-_=+      qQwWeErRtTyYuUiIoOpP[{]}      aAsSdDfFgGhHjJkKlL;:'@#~    \\|zZxXcCvVbBnNmM,<.>/?                                      ")] 6) (#$ . 22206))
(byte-code "\301\302\303\304\305\306\307\310\311\312\313\"\314\"B&\207" [quail-keyboard-layout-alist custom-declare-variable quail-keyboard-layout quail-keyboard-layout-standard "A string which represents physical key layout of a particular keyboard.\nWe assume there are six rows and each row has 15 keys (columns),\n	the first row is above the `1' - `0' row,\n	the first column of the second row is left of key `1',\n	the first column of the third row is left of key `q',\n	the first column of the fourth row is left of key `a',\n	the first column of the fifth row is left of key `z',\n	the sixth row is below the `z' - `/' row.\nNth (N is even) and (N+1)th characters in the string are non-shifted\nand shifted characters respectively at the same location.\nThe location of Nth character is row (N / 30) and column ((N mod 30) / 2).\nThe command `quail-set-keyboard-layout' usually sets this variable." :group quail :type choice append mapcar #[(pair) "\301\302@AF\207" [pair const :tag] 4] ((string :tag "Other"))] 12)
(defvar quail-keyboard-layout-substitution nil)
(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
\311\211\205\224@\f\203~\f@A\203~\fA\211\f\204n\f\203\212\f@\241\210A\211\204d\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 missing --dolist-tail--] 4])
(byte-code "\301\302\303\304\305\306\307\310\311\312\"B\313\314&	\207" [quail-keyboard-layout-alist custom-declare-variable quail-keyboard-layout-type "standard" "Type of keyboard layout used in Quail base input method.\nAvailable types are listed in the variable `quail-keyboard-layout-alist'." :group quail :type choice mapcar #[(elt) "\301@D\207" [elt const] 2] :set #[(symbol value) "\302!\210	L\207" [value symbol quail-update-keyboard-layout] 2]] 11)
#@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 (#$ . 25690) (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\211\fW\203\nHU\204T\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 (#$ . 26339)])
(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\2115W\203y\f	H\31168\203'\312!\31368A\236A\2117\205>\3147@\315!\316#\2118\203f8:\203^8AG\310V\203[8A\310H\202\\\31788B\202k\f	H8\n	8I\210*	T\211\202`\320\306\211\2119:;<=\321\310\316\322\323<%\210\310	5W\203`
	\324\246\310U\203\271	\324\245\2119\316V\203\271\325\3269\211\313Z\313\245\\\"\210\n	H;\n	TH:<c\210;;\203\325\327;!\202\331\330;!\313W\203\341\317c\210\331;!\203
\332;\333\"\334=\203
\335\305;!\310\316\336\337;\"$\202
\305;!;\331:!\203/
\332:\333\"\334=\203)
\335\305:!\310\316\336\337:\"$\202-
\305:!:\340;!\341\317\342\343#\340:!\261\210\327:!\313W\203K
\317c\210	\313\\\211\324\246\310U\203\223<\344\261\210\202\223\214=`}\210=b\210\345\310\306\211>?@Am\204\346\347!\203\210
`\310\225|\210\202\247
\346\350!\203\226
\351`\310\225\352\326$\210\353\354\355 \343#\203\244
\310\224`|\210\356 \210l\203\266
A?@>\202\336
\357\306w\210i?\306\210i>?AW\203\317
?A>@V\203\333
>@\356 \210@\310V\203\n\325\326A\"\210`=\360c\210\325\361@AZ\313Z\"\210\360c\210\321=`\322\323$\210\344c\210?A>@\316y\210\202v
,\362y\210`=\363c\210\321=`\322\323$\210\364c\210.,\207" [ch i layout done-list kbd-layout string nil vconcat 0 8 quail-keyboard-translate 2 quail-get-translation char-to-string 1 " " "|" put-text-property face bold 30 insert-char 32 string-width char-width characterp get-char-code-property general-category Mn compose-string format "	%c	" bidi-string-mark-left-to-right propertize invisible t "\n" 100 looking-at "[| ‬‭]*$" "‭? *\\(|     \\)+" subst-char-in-region 124 re-search-forward "\\(     |\\)+‬?$" line-end-position 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] 8 (#$ . 26896)])
#@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) "\203G\306V\204
	\307\n\"\211\204\310\311\"\210\fr\312\313!q\210p\314 \210
\315\211\316\211\316\317 \210\320\321!\210+\211rq\210\322\323\261\210\324A!)\325!\210,\207" [keyboard-type quail-keyboard-layout-type quail-keyboard-layout-alist layout default-directory #1=#:old-dir 0 assoc error "Unknown keyboard type: %s" get-buffer-create "*Help*" kill-all-local-variables nil t erase-buffer run-hooks temp-buffer-setup-hook "Keyboard layout (keyboard type: " ")\n" quail-insert-kbd-layout internal-temp-output-buffer-show buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only #2=#:buf standard-output] 4 (#$ . 29059) (list (completing-read "Keyboard type (default current choice): " 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!?)\205AA\211<\203>\n@:\206@\n9)\207" [object translation alist vectorp] 3 (#$ . 30074)])
(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@@:\203X\f@\303
\236\211\203\"\307
\"A\302
\236\211\2032\307\n
\"\nA
\306\211\203S@\211@A	BBA\211\204<*\fA)\203{\310\311\312\fDD\313\314\315\316\317\nDED\320\312	DD\321BBBB\322BB\202\321\306C\n?\205\204\314C\306\211\f\f\306\211\203\276@\211@A@\323\324\f	&\210A\211\204\230*\325\326\327\330\312DDE\331\312\fDDE,,\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 prog1 (quail-decode-map) quail-install-map quail-install-decode-map annotation --dolist-tail-- trans key map el] 9 (#$ . 31178)]))
#@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;\20669\2066:\2056\307A!?)\205K\nA\211<\203H\f@:\206J\f9))\204T\305\310	\"\210AA	\240\207" [quail-current-package map object translation alist error "No current Quail package" vectorp "Invalid Quail map `%s'"] 4 (#$ . 33519)])
#@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=\202\304	!\203(\305	!\306=\203(\307\233	\240\207\302\310	\"\207" [quail-current-package decode-map error "No current Quail package" char-table-p char-table-subtype quail-decode-map 10 "Invalid Quail decode map `%s'"] 3 (#$ . 34099)])
#@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
\3128$\207" [name quail-package-alist package quail-current-package key translation assoc error "No Quail package `%s'" quail-defrule-internal 2 append] 6 (#$ . 34685)])
(defalias 'quail-vunion #[(v1 v2) "\302\303\304\305\306\"\305	\306\"\244!\"\207" [v1 v2 apply vector delete-dups append nil] 7])
#@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) ";\204\306!\204\307\310\"\210	\247\204v	;\204v\306	!\204v	:\204v	9\204v	\211:\205m\n@\211\250\206X?\206X\306!\206X;\206X9\206X:\205X\306A!?)\205m\nA\211<\203j\f@:\206l\f9))\204v\307\311	\"\210
\211:\205\271\n@\211\250\206\244?\206\244\306!\206\244;\206\2449\206\244:\205\244\306A!?)\205\271\nA\211<\203\266\f@:\206\270\f9))\204\302\307\312
\"\210G\313\314\211W\203


:\204\341\307\315\"\210H\211
A\236\211\204
\314CB

AB\241\210AT\211\202\321	9\203%

A\203
\307\316\"\202{	\241\202{	\211:\205h
\n@\211\250\206S
?\206S
\306!\206S
;\206S
9\206S
:\205S
\306A!?)\205h
\nA\211<\203e
\f@:\206g
\f9))\203\235

A<\204y
\307\316\"\202{	A<\204\222

A\203\213
\307\316\"\202{	\241\202{\317	
A\"\241\202{\204\247
\203	:\204	9\204	\250\203\275
\320	!\202\313
	;\203\313
	\321!)	G\314\313V\203S	H\211\250\203\357
\322!	I\210\203\323\313G$\210\203\322
BAB\241\210\202\322
*
@\203x\203x\324
@#\211\250\203:\320!\202=A	\250\203K\320	!\202Y	;\203Y	\321!)\325	\"\211 \232\203l\202v\313\211\211\211\314\257 B+
	\240,\207" [key trans object translation alist map vectorp error "Invalid Quail key `%s'" "Invalid Quail translation `%s'" "Invalid Quail map `%s'" 0 nil "Quail key %s is too long" "Quail key %s is too short" append vector vconcat char-to-string add-text-properties quail-get-translation quail-vunion entry ch idx len props decode-map string elt prev prevchars new] 6 (#$ . 36296)])
#@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) "\2039\203\304!\205	\n\":\203#\305A!\204#@\250\204-:\203/\207\2045\306\207;\203TG\307U\203E\310H\207\310\211\211\211\306\257\311!)B\207\305!\203zG\307U\203p\310HG\307U\203p\310H\310H\207\310\211\211\211\306\257B\207\312\313\"\207" [def key len string functionp vectorp nil 1 0 vconcat error "Invalid object in Quail map: %s"] 5 (#$ . 38303)])
#@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 not-reset-indices) "\204	G\306\307\n8\310\n8\311\211\211\211\203~W\203~\2037\312	H!\202;	HTA\203XA9\203X\211A	\"\241\210
A\236\211A\203uA9\203u\211A	\"\241\210A\211\204\"@\311\203\352\313	#\211\203\352:\203\277\314A!\204\277@\f\232\204\253\f\240\210\315A!\203\270A \202\272A\202\312\f\232\204\312\f\240\210\f:\203\352\314\fA!\203\352\f\204\352\316\n8\203\352@\306\240\210A\203

\315A!\203

\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 not-reset-indices] 8 (#$ . 39044)])
(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])
#@137 Convert input string STR to a list of events.
If STR has `advice' text property, append the following special event:
(quail-advice STR)
(defalias 'quail-input-string-to-events #[(str) "\302\303\"\304\305\306#\204\307\305\306#\203	\310DC\244	)\207" [str events mapcar #[(c) "\203\n	H\206	\207" [translation-table-for-input c] 2] get-text-property 0 advice next-single-property-change quail-advice] 4 (#$ . 40157)])
(defvar quail-translating nil)
(defvar quail-converting nil)
(defvar quail-conversion-str nil)
(defalias 'quail-input-method #[(key) "\204\f	\204\f\n\203C\207\306\307\f8!\210\310 \311\211\312\216\307\f8\203,\313!\202/\314!\315;\205SG\316V\205S\203O\316HC\202S\317!-\207" [buffer-read-only overriding-terminal-local-map overriding-local-map key quail-current-package inhibit-modification-hooks quail-setup-overlays 14 buffer-modified-p t ((byte-code "\302 \210\303!\210\304	8\204\305\306!\210\302\207" [modified-p quail-current-package quail-delete-overlays 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 buffer-undo-list modified-p input-string quail-guidance-str input-method-exit-on-first-char] 3])
(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 append nil] 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 (#$ . 41618)])
(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\333\311\312\313	8\312\211 \314 !\312\211\"#\312$\315\211%&\316'\203K(B('\203\305\317!!\210\320 \210)\205j\321\322*\206e\315&+$,\323,\312\211\316$-\324\313	8-\".\203\221\325.!\203\262.\326=?\202\225.\327=\203\262-\211GSH\"$#.$\316\330\331\332\217\210\202\301\333 /\334/\312\")(\312'+\202K\3350!\203\326\3350!\3360!|\210&.	\207\306	8\203\345\307!\337!\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 quail-show-guidance format "%s%s %s" read-key-sequence lookup-key commandp quail-other-command quail-self-insert-command err (call-interactively cmd) ((quail-error (byte-code "\301\302A\"\210\303 \207" [err message "%s" beep] 3))) this-single-command-raw-keys append 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 quail-guidance-str prompt keyseq cmd string quail-overlay] 6 (#$ . 41884)])
#@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\211 \314 !\312\211\"#\312$\315\211%&\316\211'(\315)\203Q*B*(\203
\317!!\210'\204m\315\211%&\316'\320\312!\210\321 \210+\205\204\322\323,\206}\315)&-%.\324.\312\211\316$/\325\313	8/\"0\203\243\3260!\202\2470\327=\203\362/\211GSH\"$#0$\316\330\331\332\217\210'\204

&\203\337)&;\203\330&\202\334\333&!P)1\204\354)G\311U\203

\312(\202

\334 2\3352\312\")*\312(+\202Q\312'\3363!\203
\3363!\3373!|\210)G\311V\205#
).	\207\306	8\2030
\307!\333!\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 quail-show-guidance format "%s%s%s %s" read-key-sequence lookup-key commandp quail-self-insert-command err (call-interactively cmd) ((quail-error (byte-code "\301\302A\"\210\303 \207" [err message "%s" beep] 3))) char-to-string this-single-command-raw-keys append 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 quail-guidance-str prompt keyseq cmd input-method-exit-on-first-char string quail-conv-overlay] 7 (#$ . 43289)])
#@47 Terminate the translation of the current key.
(defalias 'quail-terminate-translation #[nil "\302\303\211\207" [quail-translating quail-guidance-str nil " "] 2 (#$ . 44899)])
#@44 Accept the currently selected translation.
(defalias 'quail-select-current #[nil "\300 \207" [quail-terminate-translation] 1 (#$ . 45081) 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) "\3068\211\203	\n!\202k\n\247\203HG\n\307U\203+\3108\203)\311!\202*\204D\f\nV\203D\fS\fH B \2020)\202k\n\204k
\204k\3108\203\\\311!\202]\203k\3128\203k\313)!\204\377\314\"\315#!\203\205\315#!\316#!|\210`\"$\204\307\314%
;\203\234\317\320\215\210\202\251\321\322
!!
U\204\251
%%\203\306\323\324%\"\210\325 \210\326\327!\210\323\314!\210\314\330\331\314\"\210)
c\210\332#\"`#\210\333&!\203\376\315&!\204\353\332&\"`#\210\202\376\316&!`W\203\376\332&\315&!`#\210)\314\334 \210)
;\204
\335
!\n\205
\336 \207" [quail-current-package func control-flag quail-current-key len quail-current-str 13 0 8 quail-keyseq-translate 15 t nil overlay-start overlay-end tag (mapc #[(ch) "\302\303!!U?\205\304\305\306\"\207" [ch char unibyte-char-to-multibyte multibyte-char-to-unibyte throw tag nil] 3] quail-current-str) unibyte-char-to-multibyte multibyte-char-to-unibyte message "Can't input %c in the current unibyte buffer" ding sit-for 2 throw quail-tag move-overlay overlayp quail-update-guidance char-to-string quail-terminate-translation input-method-exit-on-first-char unread-command-events input-method-use-echo-area pos quail-overlay enable-multibyte-characters char quail-conv-overlay] 5 (#$ . 45232)])
#@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 (#$ . 46989) "*"])
#@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 (#$ . 47338)])
#@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) ":\203AG@@V\203A@@H\202\306\206s\206s	\307V\205s\310	S\311\312\n	S\"!\"\n	S	O\313
8\205G\310\307\311\312\f\307\"!\"
\205r;\203V\202Y\314!
\203p
;\203i
\202q\314
!\202q\fP+\207" [def len quail-current-key str substr1 quail-current-package "" 1 quail-get-current-str quail-map-definition quail-lookup-key 7 char-to-string str1] 6 (#$ . 47534)])
(defvar quail-guidance-translations-starting-column 20)
#@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.\nAGY\203.	AGS\211\240\210\f\203>\nW\204>\n\fY\203
AG\310 
Z\311	8\312\211\211\211\211\nW\203k\307\211\202q\f\203q\f\307\307W\203\352\n\fY\203\352\307U\203\234\307TAH\211\250\203\257\313!\202\263\314!\315\311#T\211\307V\203\341Y\204\330\316V\203\341\307\202|T\211\202~\311	\233\240\210Y\203
\317	\233\240\210	A\240\210	AA\f\240\210.\203-
\\\fY\203&
	\fS\240\210\202-
	\\\240\210A	@H\211;\206@
\320!\211,\207" [quail-current-translations indices cur start end quail-guidance-translations-starting-column 2 0 window-width 3 nil char-width string-width + 10 4 char-to-string num-items trans width idx col block maxcol len relative-index quail-current-str] 9 (#$ . 48180)])
#@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\211\n\203O\310\n!\311	\":\203&AG\312U\205K\nA?\205K\3138?\206K	\314W\206K\306	S\"?\206K\306\315\316O\312\"?)\202
\3138\203\200	\314Y\203\200\310\306	\317Z\"!\211\203\200\306\315\307O\317\"\203\200\311	\317Z\"	\317Z\202
	\320V\203\313\306\320\316O!\203\313\203\313\3218\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
\3218\203\374\307	\312V\203\350	S\310\306	\"!\211\203\324\203\364\311	\"\202\370\320H	\202
\310\306	S\"!\211\203
\311	S\"	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] 6 (#$ . 49203)])
#@61 Select next translation in the current batch of candidates.
(defalias 'quail-next-translation #[nil "\203$@\211@TAGU\203\304 \202\"	\211@T\240\210\305 \210\306\307!)\207\nB\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 (#$ . 50450) 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\nB\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 (#$ . 50844) nil])
#@45 Select from the next block of translations.
(defalias 'quail-next-translation-block #[nil "\203-@\211@	A@Z\305	8AGY\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 (#$ . 51243) 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 (#$ . 51649) 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 (#$ . 52112) 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 (#$ . 52379) 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 (#$ . 52731)])
(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 (#$ . 54754)])
#@61 Do no conversion of the current conversion region of Quail.
(defalias 'quail-no-conversion #[nil "\301\211\207" [quail-converting nil] 2 (#$ . 54999) nil])
#@47 Make a new one-line frame for Quail guidance.
(defalias 'quail-make-guidance-frame #[nil "\305 \301\236A\306\236A\307\236A\310	\311 \312_\n\312_$\211\313W\203,\314	\315 \n$\316\317\320\"\"\321\322\323\301\fBB\"!-\207" [fparam top border internal-border newtop frame-parameters border-width internal-border-width - frame-char-height 2 0 + frame-pixel-height delq assoc parent-id make-frame append ((user-position . t) (height . 1) (minibuffer) (menu-bar-lines . 0) (tool-bar-lines . 0))] 7 (#$ . 55162)])
#@32 Setup Quail completion buffer.
(defalias 'quail-setup-completion-buf #[nil "\305!?\205\"	\306\307!rq\210\310\n!\210\311\312ee\"\313\f\314\315#*\207" [quail-completion-buf enable-multibyte-characters mb buffer-read-only quail-overlay buffer-live-p get-buffer-create "*Quail Completions*" set-buffer-multibyte t make-overlay overlay-put face highlight] 4 (#$ . 55688)])
#@73 Return t if 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 (#$ . 56069)])
(defalias 'quail-minibuffer-message #[(string) "\305\306!\210d\307\212	b\210\nc\210)\310\311!\210	d|\210\205!\306\312\211*\207" [inhibit-quit point-max string quit-flag unread-command-events message nil t sit-for 1000000 (7)] 2])
#@225 Display a guidance for Quail input method in some window.
The guidance is normally displayed at the echo area,
or in a newly created frame (if the current buffer is a
minibuffer and the selected frame has no other windows).
(defalias 'quail-show-guidance #[nil "\306 \210\307!\210\310 \205~	?\205~\n?\205~?\205~\311 \203v\312 \313 =\203m\f\314!\2045\315 \316!\204A\317\320!rq\210\321 \210\322
c\210)\313!\323\"\210\324\325\"\210)\326\327\330 \"!)\207\326\327\331 \f#!\207\322!\332\333\f\")\207" [quail-completion-buf input-method-use-echo-area unread-command-events unread-post-input-method-events quail-guidance-str guidance quail-setup-completion-buf bury-buffer quail-require-guidance-buf minibufferp minibuffer-window frame-root-window frame-live-p quail-make-guidance-frame buffer-live-p get-buffer-create " *Quail-guidance*" erase-buffer nil set-window-buffer set-window-dedicated-p t quail-minibuffer-message format " [%s]" "  [%s]\n%s" message "%s" quail-guidance-frame quail-guidance-buf cursor-type win current-input-method-title message-log-max] 5 (#$ . 56637)])
#@26 Hide the Quail guidance.
(defalias 'quail-hide-guidance #[nil "\303 \205,\304 \305 =\204\205,\305 \306 =\205,\307	!\203#\310	!\210\311\n!\205,\312\n!\207" [input-method-use-echo-area quail-guidance-frame quail-guidance-buf quail-require-guidance-buf selected-window minibuffer-window frame-root-window frame-live-p delete-frame buffer-live-p kill-buffer] 2 (#$ . 57753)])
#@76 Update the Quail guidance buffer and completion buffer (if displayed now).
(defalias 'quail-update-guidance #[nil "\306 \203>\3078\211\310=\204	:\203\311 \202=	\204;\3128\203*\313\f!\f;\2033\f\2026\314\f!)\202=\315)\316
!\317\211\211\211\205\320\212;\203[\202e\247\205e\320!
q\210eb\210\321\315\f\322Q\317\310#\204\201\323!\202\317`\203\240\321\324P\317\310#\203\240\325\326\224T`#\210\202\250\325\326\224`#\210\327`\"?\205\317b\330 \210\331`\"\210\327\"?\205\317\331\"),\207" [quail-current-package guidance quail-guidance-str quail-current-key key quail-completion-buf quail-require-guidance-buf 3 t quail-get-translations 8 quail-keyseq-translate string " " get-buffer-window nil char-to-string search-forward ":" delete-overlay "." move-overlay 0 pos-visible-in-window-p beginning-of-line set-window-start pos str win quail-current-str quail-overlay] 5 (#$ . 58139)])
#@63 Return a string containing the current possible translations.
(defalias 'quail-get-translations #[nil "\306!\204\n\307!\310\311\312#\313!\203\314 \210\315\f8\211<\203U	G\316&'&'W\203T\317	&H
\"A\211(\203J	&(\316HI\210)&T\211&\202-*)G\316V\203q\nA\203q\320\321	\322\323\324\nA\"\325\"\260
#\203
\326\f8\204
@\211)@*)A@+\327)8,+-\330	!.\326ZW\203\254	\331\332.\326\330	!#\333\"P\320\334	\315)8\335)8\203\304\320\336\335)8\"\202\305\337$-,W\203
	GA-H/0/;\204\346\340/!/\320\341	-+Z\342U\203\367\316\202\375-+ZT/$-*U\203
\3430\315\\	G\344\345	%\210-T-*\202\307-	*\207" [quail-current-key str map quail-current-translations quail-current-package guidance multibyte-string-p string-to-multibyte quail-lookup-key nil t copy-sequence quail-update-current-translations 3 0 assoc format "%s[%s]" sort mapcar #[(x) "@\207" [x] 1] < 7 2 string-width make-string - 32 "%s(%02d/%s)" 4 "%02d" "??" string "%s %d.%s" 9 put-text-property face highlight i --dotimes-limit-- prompt-key indices cur start end idx quail-guidance-translations-starting-column trans len] 9 (#$ . 59095)])
#@45 The maximum depth of Quail completion list.
(defvar quail-completion-max-depth 5 (#$ . 60245))
#@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\313#\312rq\210
\203C\f	\232\203C\314=\203C\315d
\"\2036\316
e\"\210\202b\312\317 \210*\202b\f\313\320 \210\321c\210\322\f\323#\210\324\312!\210)eb\210\325p!\210\313)\n\203j\326 \210,\314\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 t quail-completion pos-visible-in-window-p set-window-start scroll-other-window erase-buffer "Possible completion and corresponding characters are:\n" quail-completion-1 1 set-buffer-modified-p display-buffer quail-update-guidance last-command minibuffer-scroll-window other-window-scroll-buffer inhibit-read-only this-command] 6 (#$ . 60347) nil])
#@61 List all completions of KEY in MAP with indentation INDENT.
(defalias 'quail-completion-1 #[(key map indent) "G\306\n!\210\307\261\2109\203\310!\203	\"@\203.\311\312\n	\313##\210\2021\314c\210\n\315\\A\205y\nS\315\245\fW\205yA\316
!\203O
 \317
!\320\211\205x@\321\322@!PA\n#\210A\211\204[\320+)\207" [key len indent map quail-completion-max-depth l quail-indent-to ":" fboundp quail-completion-list-translations + 1 " -\n" 2 functionp reverse nil quail-completion-1 string elt --dolist-tail--] 8 (#$ . 61322)])
#@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\202u\nA\211G\315\f
W\203r\316\f\317\246!\203T\f\317Y\203G\314c\210\320!\210\321\322\f\317\245T
\317\245T#c\210\321\323\fT\317\246\"c\210`\n\fHc\210\311`\312\313$\210\fT\211\202,\314c**\207" [map key translations beg i len nil quail-get-translation "(1/1) 1." put-text-property mouse-face highlight "\n" 0 zerop 10 quail-indent-to format "(%d/%d)" " %d." indent] 6 (#$ . 61884)])
#@75 Click on an alternative in the `*Quail Completions*' buffer to choose it.
(defalias 'quail-mouse-choose-completion #[(event) "\306\307!\210\310 \311r\310\312\n!\211@)!q\210\f\203\f\212\312\n!\3138\2067A@:\2034A@@\2027A@)b\210\311\211m\204P\314`\315\"\203P``To\204b\314`S\315\"\203b`S`\204k\316\317!\210\320\315\"\321
\315\"\206zd
{,\322!\203\222\322!\323!|\210\324	\"\210\325 *\207" [choice buffer event position completion-reference-buffer end run-hooks mouse-leave-buffer-hook window-buffer nil event-start 5 get-text-property mouse-face quail-error "No completion here" previous-single-property-change next-single-property-change overlay-start overlay-end choose-completion-string quail-terminate-translation beg quail-overlay quail-current-str] 4 (#$ . 62498) "e"])
#@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\nBAB\241\210T\202Y:\203YA\307\311\312\"\210\203X\nBAB\241\210G\\)\203lV\203l[\202\256	A	\203\254\313Y\203\254	@	A\f@\250\203o\fA:\203o\fA>\204o\314\fAB\315\316\n\f@#
&\202o+\207" [map-list map key translation elt ignores quail-get-translation nil 127 mapc #[(x) "\250\203\306V\202\307\310\311\312\n	#,\205'
\235?\205'\311\211\207" [x start string regexp inhibit-changing-match-data ignores 127 "[^[:ascii:]]" nil t string-match multibyte] 4] 0 quail-build-decode-map format "%s%c" decode-map num multibyte maxnum] 7 (#$ . 63325)])
#@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) "\306A\307\"\305\310p\311\"!\312\313\211\211\313'\211(\203q(@\211'A\314	!\2038	G\315U\2038	\316H\314	!\203F'\nB\202h'@	BB	;\203Y\317	!\202\\\320	!\211)\fV\203g))(A\211(\204*\203\315
G*\321\322!\211+@@)G],\323,\315\f\315$-
-\245.\313/*.\\.T\245\316)0.T\3161212W\203\3441T0_S8\206\310\322!@3)\323\3213@G]\315\f\315$\\))1T\2111\202\262*)
W*\203\365.T.\202\232\323*.\324#.\245/\321/S8@G]4\325c\210\3264T!\210\327c\210\326\323\3154\315\f\315%!\210)\330c\210`\31615\331\332/\333\\\"\210\203\310
5b\210\321/S8\206J
\322!@@G]4\3234\315\f\315$-\3341!\210\3261!\210\331\3354\"\210\336c\210\331\335\f\"\210\315y\210/\3166262W\203\274
\211A@\211'\203\262
\3341!\210\3261!\210\337'@\340\341#c\210\326\32314\315#!\210'Ac\210\315y\210)6T\2116\202|
*1-\\1*\2025
*db\210-\n\205:\321\322\n!\211+@@)G],\325c\210\326,T!\210\342c\210\331\335,\"\210\343c\210\n\313'\211(\2036(@'\337'@\340\341#c\210\326,!\210\314'A!\203#\344\345'A\"\210\202*\346'A\261\210\332c\210(A\211(\204\376
*\332c)-\207" [decode-map trans multiple-list single-list single-trans-width window-width sort #[(x y) "@	@G	GV\206G	GU\205	\231?\207" [x y] 2] get-buffer-window visible 4 nil vectorp 1 0 string-width char-width 3 last + -1 "key" quail-indent-to "char" "[type a key sequence to insert the corresponding character]\n" insert-char 10 2 move-to-column 45 32 propertize face font-lock-comment-face "character(s)  [type a key (sequence) and select one from the list]\n" " ------------\n" mapc #[(x) "\250\203\304!\202\305!\306i\307	#\nV\203 \310c\210\311!\210\312\261)\207" [x width window-width max-key-width char-width string-width + 1 "\n" quail-indent-to " "] 4] " " elt --dolist-tail-- width len x max-key-width col-width cols rows newrows col --dotimes-limit-- last-col-elt key-width pos row] 8 (#$ . 64588)])
(byte-code "\300\301\302\303\304\305\306\307\310!&\210\300\311\302\312\306\307\313!%\207" [define-button-type quail-keyboard-layout-button :supertype help-xref help-function #[(layout) "\301\302D\303\"\210\304!\207" [layout help-setup-xref quail-keyboard-layout-button nil quail-show-keyboard-layout] 3] help-echo purecopy "mouse-2, RET: show keyboard layout" quail-keyboard-customize-button help-customize-variable "mouse-2, RET: customize keyboard layout"] 9)
#@136 Show brief description of the current Quail package.
Optional arg PACKAGE specifies the name of alternative Quail
package to describe.
(defalias 'quail-help #[(&optional package) "\306\307!\210	\n\203\310\n\"\202\f@A\311BCDr\312\313 !q\210p\314 \210DC\311\211EF\315\211G\315HI\316 \210\317\320!\210+\211JKrKq\210\321@!\210
)\322J!\210,r\313 q\210\311E\323L\324\f@\325\326 \327\261\210\214``}\210\330\f8c\210eb\210\331 pMN\332\216\333O!\210\334\335\311\315#\203\271\336\337\224\340\\`S{!P\341P!\203\265PJ;\203\265\342PJ\315\211#\210)\202\214+db\210)n\204\305\343c\210\343c\210\311Q\344\f8\203\372\345c\210\346/\347/#\210\350c\210\351R!Q\352c\210\346\353\347\353#\210\354c\210\346\355\356\357#\210\343c\210\360C0\361\340\f8C\3620\337\363Q&\211S\337V\203.
\364c\210\344\f8\203#
\365c\210\202&
\366c\210\367c\210\3700!\210+\371\372\f8\373\"\210\374c\210\375\f8\203F
\371\375\f8\376\"\210\311\377 Tr\201U\216\201V\201Wp\315\"!\210\317\201B!.\207" [help-xref-mule-regexp-template enable-multibyte-characters package quail-package-alist quail-current-package package-def require help-mode assoc nil get-buffer-create help-buffer kill-all-local-variables t erase-buffer run-hooks temp-buffer-setup-hook set-buffer-multibyte internal-temp-output-buffer-show left-to-right "Input method: " " (mode line indicator:" quail-title ")\n\n" 4 syntax-table ((byte-code "rq\210\302	!\210)\302\207" [#1=#:buffer #2=#:table set-syntax-table] 2)) set-syntax-table re-search-forward "\\\\<\\sw\\(\\sw\\|\\s_\\)+>" 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-keyboard-layout-button "' 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]" quail-keyboard-customize-button quail-keyboard-layout-type decode-map quail-build-decode-map "" 5120 "\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" internal--before-save-selected-window mb help-xref-mule-regexp temp-buffer-show-hook default-directory #3=#:old-dir buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only #4=#:buf standard-output bidi-paragraph-direction #1# #2# emacs-lisp-mode-syntax-table sym done-list quail-keyboard-layout num save-selected-window--state ((internal--after-save-selected-window save-selected-window--state)) select-window get-buffer-window] 8 (#$ . 67226) nil])
(defalias 'quail-help-insert-keymap-description #[(keymap &optional header) "`\306\n\203\nc\210\212\307\310!c\210)\311y\210`\312 p\313\216\314
!\210\315\316\306\317#\203a\320\321\224`{!\211\203]\322!\203]\323N\324=\204V\3258\203]\323N\326=\203]\327 \330 T|\210)\202\"+b\210m\204~\331\332!\203x`\330 T|\210\202e\333y\210\202eb\210m\203\211	`|\210db*\207" [pos2 pos1 header #1=#:buffer #2=#:table emacs-lisp-mode-syntax-table nil substitute-command-keys "\\{keymap}" 3 syntax-table ((byte-code "rq\210\302	!\210)\302\207" [#1# #2# set-syntax-table] 2)) set-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 sym quail-current-package] 5])
#@60 Show help message while translating in Quail input method.
(defalias 'quail-translation-help #[nil "	=\204x\306\211\f\203&
G\307U\203&\310\311*+@#\312+8\2023\310\313
+@#\314+8,-r\315\316!q\210p\317 \210-,\306\211./\320\2110\32012\321 \210\322\323!\210+\21134r4q\210c\210\324\n\325\"\210\326 \210)\3273!\210-\3065\330 6r\331\216\332\333\316!!\210	=\203\250\334 dW\203\233\335 \210\202\250\336 eV\203\250\337\340 e\"\210\334\340 \341\"dW\203\266\342\202\276\336 eV\205\276\3435+5\205\330\344\345\3465!\"\210\347\350!\210\344\306!\210\351 )\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 get-buffer-create "*Help*" kill-all-local-variables t erase-buffer run-hooks temp-buffer-setup-hook quail-help-insert-keymap-description "-----------------------\n" help-mode internal-temp-output-buffer-show internal--before-save-selected-window ((internal--after-save-selected-window save-selected-window--state)) select-window get-buffer-window window-end scroll-up window-start set-window-start selected-window 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 default-directory #1=#:old-dir buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only #2=#:buf standard-output scroll-help save-selected-window--state] 5 (#$ . 71311) nil])
(defalias 'quail-store-decode-map-key #[(table char key) "	H\211\203-\n:\203\n\235\2042	\nBI\210\2022\n\230\2042	\nDI\210\2022	I\210\f\205F\f	H\211\205F\305\306	#))\207" [table char elt key translation-table-for-input nil quail-store-decode-map-key] 5])
(defalias 'quail-gen-decode-map1 #[(map key table) ":\205\337A<\205\337@\211\250\203\306\n	#\210\202\212	;\203?	G\307\f
W\203;\306\n	\fH#\210\fT\211\202'*\202\212\310	!\204Q	:\203\212	A\211\203\212	G\307\f
W\203\211	\fH\211;\203zG\311U\203\201\306\n\307H#\210\202\201\306\n#\210)\fT\211\202W*)G\311V\203\266A\312\211\205\264@\313A\n#\210A\211\204\235\312*\207A\312\211\205\336@\313A\314\315@#\n#\210A\211\204\301\312*\207" [map trans table key i --dotimes-limit-- quail-store-decode-map-key 0 vectorp 1 nil quail-gen-decode-map1 format "%s%c" elt --dolist-tail--] 7])
(put 'quail-decode-map 'char-table-extra-slots 0)
(defalias 'quail-gen-decode-map #[nil "\304\305\306\"\307	8A\306\211\203$@\310\nA\311\n@!#\210A\211\204*)\207" [table quail-current-package elt --dolist-tail-- make-char-table quail-decode-map nil 2 quail-gen-decode-map1 string] 5])
(defalias 'quail-char-equal-p #[(char target) "	U\206\n\205\nH\211\205	U\207" [char target translation-table-for-input] 2])
(put 'quail-char-equal-p 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'quail-find-key1 #[(map key char key-list) "@\306\211;\2031\nG\307U\205-\n\310H\211\fU\206,
\205,
H\211\205,\fU*\202k\311\n!\204<\n:\203K\n:\203D\nA\312\313\215\202k\n\250\203k\n\211\fU\206i
\205i
H\211\205i\fU*	\203vBG\307V\203\252A\306\211\203\251@\314A\315\316@#$A\211\204\211**\207" [map found-here trans char target translation-table-for-input nil 1 0 vectorp tag (byte-code "G\306	\nW\205l	H\211\250\2039\f\211U\206-
\205-
\fH\211\205-\fU*\203d\307\310\311\"\210\202dG\312U\203d\306H\f\211U\206[
\205[
\fH\211\205[\fU*\203d\307\310\311\"\210)	T\211\202*\207" [trans i --dotimes-limit-- target char translation-table-for-input 0 throw tag t 1] 4) quail-find-key1 format "%s%c" key key-list elt --dolist-tail--] 7])
(defvar quail-decode-map-generated nil)
#@149 Return a list of keys to type to input CHAR in the current input method.
If CHAR is an ASCII character and can be input by typing itself, return t.
(defalias 'quail-find-key #[(char) "\203@\306	8=\203A\n\206\307=\203\310	8\2063\311 \306	8\n\206)\307B\310	\233\240\210)\312\211:\203K\313!\314\315
A\"\210)\202n
H\211;\203g\316\317\312\307#\312$\202m\314\320\"\210)\f\206\201\321W\205\201\317\313!\322\"?*\207" [quail-decode-map-generated quail-current-package buffer-file-coding-system map key-list decode-map 2 t 10 quail-gen-decode-map nil string mapc #[(elt) "	@\230\205
	A\nB\211\207" [str elt key-list] 2] quail-find-key1 quail-lookup-key #[(elt) "\303\304\305\306#	\n$\211\207" [elt char key-list quail-find-key1 quail-lookup-key nil t] 5] 128 1 char str key-head] 6 (#$ . 75262)])
#@72 Show a list of key strings to type for inputting a character at point.
(defalias 'quail-show-key #[nil "\204\304\305!\210\306	\"\204\304\307!\210g\310\n!\211:\203*\311\312\n\313\314\315##\202=\316=\2039\311\317\320\n!\"\202=\311\321\n\"*\207" [current-input-method quail-package-alist char key-list error "No input method is activated" assoc "The current input method does not use Quail" quail-find-key message "To input `%c', type \"%s\"" mapconcat identity "\", \"" t "To input `%s', just type it" single-key-description "%c can't be input by the current input method"] 8 (#$ . 76107) nil])
#@939 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
corresponding 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@\"\210A\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 (#$ . 76721)])
(defalias 'quail-map-from-table-1 #[(state-alist state-info) "@\211\n\236A\306\f\205\202\f@\fA\306\211\211\211\f

:\2034
@J
AC
\2028
J\203~@@\f@AA;\203pG\307U\203e\310H\202p\311!)\312\f\306
%\210\2028,\202\f,\207" [state-info state state-alist map transitions elt nil 1 0 vconcat 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\211	\307V\203?\310	\311#	S\203\312!\211:\203,\fA\f@@H\202-\f\211\250\2037\313
!
\nB*\202\314\315\n\"+\207" [key len translation-list map def trans nil 0 quail-lookup-key t quail-map-definition char-to-string apply concat] 5])
#@99 Name of Quail directory which contains Quail packages.
This is a sub-directory of LEIM directory.
(defvar quail-directory-name "quail" (#$ . 78862))
#@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)\310)!\204\311\312)\"\210\313\314)\"\210\315)!r\fq\210\316b\210\317\320*!!\203A\321\225b\210\202E*c\210`\322+\307\323#\203u\321\224b\210\n`W\203^\n`|\210\322+\307\324#\203u\321\224b\210`\307\325\326\217\210\202^),B\211,\211-\203\267-\306-@!\240\210\306.-@\"\327!\203\241
B\202\256\313\330-@.#\210\307
B-A\211-\204\203
\237)
\203

@\211\203\273\331\332\333\334$\211\203
\313\335@\"\210\336\337!/r/q\210\340\216\341@!\210eb\210\322\342\307\323#\203\377\321\224b\210\307\343\344\217\210\202\353+A\211\204\321
A,A,\202\273r\fq\210\3450\346\321!\210*\347\f!\210\313\350)\"-\207" [dirname leim-list-file-name pos pkg-list list-buf quail-dirs 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\203l\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 ..." generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1=#:temp-buffer buffer-name kill-buffer] 2)) insert-file-contents "^[ 	]*(quail-define-package" (byte-code "\304p!r	q\210\305\306A@\3078\310\3118\312\313\3148\"\210\315\316\3148\"\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" [pkg-list message "Some part of \"%s\" is broken"] 3))) utf-8 save-buffer kill-buffer "Updating %s ... done" leim-list leim-list-header leim-list-entry-regexp dirnames l quail-directory-name #1# coding-system-for-write] 6 (#$ . 79018) "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 (#$ . 81631) "e"])
(byte-code "\300\301\302\"\210\303\304!\207" [global-set-key [quail-advice] quail-advice provide quail] 3)