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

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

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


(autoload 'widget-value "wid-edit")
#@63 Keymap for Mule (Multilingual environment) specific commands.
(defvar mule-keymap (byte-code "\301 \302\303\304#\210\302\305\306#\210\302\307\310#\210\302\311\312#\210\302\313\314#\210\302\315\316#\210\302\317\320#\210\302\321\322#\210\302\323\324#\210\302\325\326#\210\302\327\330#\210)\207" [map make-sparse-keymap define-key "f" set-buffer-file-coding-system "r" revert-buffer-with-coding-system "F" set-file-name-coding-system "t" set-terminal-coding-system "k" set-keyboard-coding-system "p" set-buffer-process-coding-system "x" set-selection-coding-system "X" set-next-selection-coding-system "" set-input-method "c" universal-coding-system-argument "l" set-language-environment] 4) (#$ . 600))
(define-key ctl-x-map "
" mule-keymap)
(defvar describe-language-environment-map (byte-code "\301\302!\303\304\305#\210)\207" [map make-sparse-keymap "Describe Language Environment" bindings--define-key [Default] (menu-item "Default" describe-specified-language-support)] 4))
(defvar setup-language-environment-map (byte-code "\301\302!\303\304\305#\210)\207" [map make-sparse-keymap "Set Language Environment" bindings--define-key [Default] (menu-item "Default" setup-specified-language-environment)] 4))
(defvar set-coding-system-map (byte-code "\302\303!\304\305\306#\210\304\307\310#\210\304\311\312#\210\304\313	#\210\304\314\315#\210\304\316\317#\210\304\320	#\210\304\321\322#\210\304\323\324#\210\304\325\326#\210\304\327	#\210\304\330\331#\210)\207" [map menu-bar-separator make-sparse-keymap "Set Coding System" bindings--define-key [set-buffer-process-coding-system] (menu-item "For I/O with Subprocess" set-buffer-process-coding-system :visible (fboundp 'start-process) :enable (get-buffer-process (current-buffer)) :help "How to en/decode I/O from/to subprocess connected to this buffer") [set-next-selection-coding-system] (menu-item "For Next X Selection" set-next-selection-coding-system :visible (display-selections-p) :help "How to en/decode next selection/clipboard operation") [set-selection-coding-system] (menu-item "For X Selections/Clipboard" set-selection-coding-system :visible (display-selections-p) :help "How to en/decode data to/from selection/clipboard") [separator-3] [set-terminal-coding-system] (menu-item "For Terminal" set-terminal-coding-system :enable (null (memq initial-window-system '(x w32 ns))) :help "How to encode terminal output") [set-keyboard-coding-system] (menu-item "For Keyboard" set-keyboard-coding-system :help "How to decode keyboard input") [separator-2] [set-file-name-coding-system] (menu-item "For File Name" set-file-name-coding-system :help "How to decode/encode file names") [revert-buffer-with-coding-system] (menu-item "For Reverting This File Now" revert-buffer-with-coding-system :enable buffer-file-name :help "Revisit this file immediately using specified coding system") [set-buffer-file-coding-system] (menu-item "For Saving This Buffer" set-buffer-file-coding-system :help "How to encode this buffer when saved") [separator-1] [universal-coding-system-argument] (menu-item "For Next Command" universal-coding-system-argument :help "Coding system to be used by next command")] 4))
#@68 Keymap for Mule (Multilingual environment) menu specific commands.
(defvar mule-menu-keymap (byte-code "\305\306!\307\310\311#\210\307\312\313#\210\307\314\315#\210\307\316\317#\210\307\320\321\322	\323BBB#\210\307\324\n#\210\307\325\326#\210\307\327\321\330\331BBB#\210\307\332\n#\210\307\333\334#\210\307\335\336#\210\307\337\340#\210\307\341\n#\210\307\342\321\343\fE#\210)\207" [map describe-language-environment-map menu-bar-separator set-coding-system-map setup-language-environment-map make-sparse-keymap "Mule (Multilingual Environment)" bindings--define-key [mule-diag] (menu-item "Show All Multilingual Settings" mule-diag :help "Display multilingual environment settings") [list-character-sets] (menu-item "List Character Sets" list-character-sets :help "Show table of available character sets") [describe-coding-system] (menu-item "Describe Coding System..." describe-coding-system) [describe-input-method] (menu-item "Describe Input Method..." describe-input-method :help "Keyboard layout for a specific input method") [describe-language-environment] menu-item "Describe Language Environment" (:help "Show multilingual settings for a specific language") [separator-coding-system] [view-hello-file] (menu-item "Show Multilingual Sample Text" view-hello-file :enable (file-readable-p (expand-file-name "HELLO" data-directory)) :help "Demonstrate various character sets") [set-various-coding-system] "Set Coding Systems" (:enable (default-value 'enable-multibyte-characters)) [separator-input-method] [describe-input-method] (menu-item "Describe Input Method" describe-input-method) [set-input-method] (menu-item "Select Input Method..." set-input-method) [toggle-input-method] (menu-item "Toggle Input Method" toggle-input-method) [separator-mule] [set-language-environment] "Set Language Environment"] 7) (#$ . 3792))
(define-key global-map "" 'toggle-input-method)
(defconst help-xref-mule-regexp-template (purecopy "\\(\\<\\(\\(coding system\\)\\|\\(input method\\)\\|\\(character set\\)\\|\\(charset\\)\\)\\s-+\\)?`\\(\\sw\\(\\sw\\|\\s_\\)+\\)'"))
#@445 Return a coding system which differs from CODING-SYSTEM in EOL conversion.
The returned coding system converts end-of-line by EOL-TYPE
but text as the same way as CODING-SYSTEM.
EOL-TYPE should be `unix', `dos', `mac', or nil.
If EOL-TYPE is nil, the returned coding system detects
how end-of-line is formatted automatically while decoding.

EOL-TYPE can be specified by an integer 0, 1, or 2.
They means `unix', `dos', and `mac' respectively.
(defalias 'coding-system-change-eol-conversion #[(coding-system eol-type) "9\203%\304=\203\305\202$\306=\203\307\202$\310=\203#\311\202$\312	!\313	!\314!\203A\204;	\202`H\202`\204I\n\202`U\203S	\202`\313\n!\314!\205`H*\207" [eol-type coding-system base orig-eol-type unix 0 dos 1 mac 2 coding-system-base coding-system-eol-type vectorp] 2 (#$ . 5880)])
#@283 Return a coding system which differs from CODING-SYSTEM in text conversion.
The returned coding system converts text by CODING
but end-of-line as the same way as CODING-SYSTEM.
If CODING is nil, the returned coding system detects
how text is formatted automatically while decoding.
(defalias 'coding-system-change-text-conversion #[(coding-system coding) "\303!\304\n\203
\n\202\305	\247\205\306	H\")\207" [coding-system eol-type coding coding-system-eol-type coding-system-change-eol-conversion undecided [unix dos mac]] 4 (#$ . 6721)])
(defalias 'canonicalize-coding-system-name #[(name) "\302\303\"\203\304\305\306\"P\207\302\307\"\203\310\225S\311O\302\312\"\211\203Y	\306Y\203D\302\313	\306Z#	\306Z=\203D\302\312\310\225#\211\202\"\310	O	T\311OP\302\312	#\211\204%)\207" [name idx string-match "^\\(ms\\|ibm\\|windows-\\)\\([0-9]+\\)$" "cp" match-string 2 "^iso[-_ ]?[0-9]" 0 nil "[-_ /]" "16-[lb]e$"] 6])
#@73 Return a coding system whose name matches with NAME (string or symbol).
(defalias 'coding-system-from-name #[(name) "\303	;\203\304	!\202	\305	!\306!\203\202;\307\310	\"\2051\304\311\312	\"!	\313\211\224O\314	\227!\315\316\215))\207" [sym name eol-type nil intern symbol-name coding-system-p string-match "-\\(unix\\|dos\\|mac\\)$" match-string 1 0 canonicalize-coding-system-name tag (byte-code "\304 \305\211\205.	@\306\307!!\n\230\203&\310\311\203#\312\"\202$\"\210	A\211\204	\305*\207" [elt --dolist-tail-- name eol-type coding-system-list nil canonicalize-coding-system-name symbol-name throw tag coding-system-change-eol-conversion] 6)] 4 (#$ . 7670)])
#@548 Change whether this buffer uses multibyte characters.
With ARG, use multibyte characters if the ARG is positive.

Note that this command does not convert the byte contents of
the buffer; it only changes the way those bytes are interpreted.
In general, therefore, this command *changes* the sequence of
characters that the current buffer contains.

We suggest you avoid using this command unless you know what you are
doing.  If you use it by mistake, and the buffer is now displayed
wrong, use this command again to toggle back to the right mode.
(defalias 'toggle-enable-multibyte-characters #[(&optional arg) "\204		?\202\303!\304V\305\n!\210)\306 \207" [arg enable-multibyte-characters new-flag prefix-numeric-value 0 set-buffer-multibyte force-mode-line-update] 2 (#$ . 8367) "P"])
#@68 Display the HELLO file, which lists many languages and characters.
(defalias 'view-hello-file #[nil "\302\303\304\305	\"!)\207" [coding-system-for-read data-directory iso-2022-7bit view-file expand-file-name "HELLO"] 4 (#$ . 9165) nil])
#@59 Execute an I/O command using the specified coding system.
(defalias 'universal-coding-system-argument #[(coding-system) "\306\307\310\"!\311	!\312\f\313\232\203\314 \210\n\315>\203S\316\n!\210\306\312\317\"\311	\317\"\211\320=\204@
	\321H\316\n!\210*\202 
\316\n!\210)
\306\312\317\"\311	!\211\317\322\323!\210\316\n!.\207" [coding-system keyseq cmd prefix last-input-event prefix-arg read-key-sequence format "Command to execute with %s:" key-binding nil 7 keyboard-quit (universal-argument digit-argument) call-interactively t universal-argument-other-key 0 message "" last-command-event current-prefix-arg coding-system-require-warning coding-system-for-write coding-system-for-read] 5 (#$ . 9409) (let ((default (and buffer-file-coding-system (not (eq (coding-system-type buffer-file-coding-system) 'undecided)) buffer-file-coding-system))) (list (read-coding-system (if default (format "Coding system for following command (default %s): " default) "Coding system for following command: ") default)))])
#@519 Set default value of various coding systems to CODING-SYSTEM.
This sets the following coding systems:
  o coding system of a newly created buffer
  o default coding system for subprocess I/O
This also sets the following values:
  o default value used as `file-name-coding-system' for converting file names
      if CODING-SYSTEM is ASCII-compatible
  o default value for the command `set-terminal-coding-system'
  o default value for the command `set-keyboard-coding-system'
      if CODING-SYSTEM is ASCII-compatible
(defalias 'set-default-coding-systems #[(coding-system) "\306!\210\307\310\"\210	\311=\203\312\202'\313\314!\203'\203%\315\316\"\203'\317\320\"\321
@\"\321
A\"\211B\211*\207" [coding-system system-type default-file-name-coding-system default-terminal-coding-system default-keyboard-coding-system default-process-coding-system check-coding-system set-default buffer-file-coding-system darwin utf-8 default-value enable-multibyte-characters coding-system-get ascii-compatible-p coding-system-change-eol-conversion unix coding-system-change-text-conversion input-coding output-coding] 5 (#$ . 10454)])
#@789 Add CODING-SYSTEM at the front of the priority list for automatic detection.
This also sets the following coding systems:
  o coding system of a newly created buffer
  o default coding system for subprocess I/O
This also sets the following values:
  o default value used as `file-name-coding-system' for converting file names
  o default value for the command `set-terminal-coding-system'
  o default value for the command `set-keyboard-coding-system'

If CODING-SYSTEM specifies a certain type of EOL conversion, the coding
systems set by this function will use that type of EOL conversion.

A coding system that requires automatic detection of text+encoding
(e.g. undecided, unix) can't be preferred.

To prefer, for instance, utf-8, say the following:

  (prefer-coding-system 'utf-8)
(defalias 'prefer-coding-system #[(coding-system) "\203\n\304!\204\305\306\"\210\307!\310>\203\305\311\"\210\312!\313!\314\n!\210\315\316!\203:\n=\204:\317\320\n#\210	\321>\203E\322\n	\"\323\n!\210\315\316!\205X\n=\206X\317\324!*\207" [coding-system eol-type base default-file-name-coding-system coding-system-p error "Invalid coding system `%s'" coding-system-type (raw-text undecided) "Can't prefer the coding system `%s'" coding-system-base coding-system-eol-type set-coding-system-priority called-interactively-p interactive message "Highest priority is set to %s (base of %s)" (0 1 2) coding-system-change-eol-conversion set-default-coding-systems "The default value of `file-name-coding-system' was not changed because the specified coding system is not suitable for file names."] 4 (#$ . 11604) "zPrefer coding system: "])
#@205 If non-nil, a predicate function to sort coding systems.

It is called with two coding systems, and should return t if the first
one is "less" than the second.

The function `sort-coding-systems' use it.
(defvar sort-coding-systems-predicate nil (#$ . 13252))
#@568 Sort coding system list CODINGS by a priority of each coding system.
Return the sorted list.  CODINGS is modified by side effects.

If a coding system is most preferred, it has the highest priority.
Otherwise, coding systems that correspond to MIME charsets have
higher priorities.  Among them, a coding system included in the
`coding-system' key of the current language environment has higher
priority.  See also the documentation of `language-info-alist'.

If the variable `sort-coding-systems-predicate' (which see) is
non-nil, it is used to sort CODINGS instead.
(defalias 'sort-coding-systems #[(codings) "\203	\306	\"\207\307 \211@\310\f\311\"\312\f\306	\313\",\207" [sort-coding-systems-predicate codings from-priority most-preferred current-language-environment lang-preferred sort coding-system-priority-list get-language-info coding-system #[(x) "\306!\307\310	\n=\203\311\202\312\313\"\310\314	\315\"\211\203U\316\317!\320 \321!\322 
\f#,\2037\323\202V\324\317!\320 \321!\322 
\f#,\203Q\311\202V\325\202V\312)\326\"\310	\">\203e\311\202f\312\327\"\310	#>\203t\311\202u\312\325\"\310\330\317	!\320 \321!\322 
\f#,\203\222\312\202\223\311\323\"\331	!\332=\203\312\333	!\211$\334=\204\257$\335=\203\263\323\202\306$\336=\204\301$\337=\203\305\311\202\306\312)\202\313\311&)\207" [x base most-preferred mime start string coding-system-base logior lsh 1 0 7 coding-system-get :mime-charset "utf-16" symbol-name nil t string-match 2 "^x-" 3 5 4 "-with-esc\\'" coding-system-type iso-2022 coding-system-category coding-category-iso-8-1 coding-category-iso-8-2 coding-category-iso-7-tight coding-category-iso-7 regexp inhibit-changing-match-data lang-preferred from-priority category] 11] #[(x y) "	!\n!V\207" [func x y] 3] func] 4 (#$ . 13519)])
#@332 Return a list of proper coding systems to encode a text between FROM and TO.

If FROM is a string, find coding systems in that instead of the buffer.
All coding systems in the list can safely encode any multibyte characters
in the text.

If the text contains no multibyte characters, return a list of a single
element `undecided'.
(defalias 'find-coding-systems-region #[(from to) "\303	\"\211\304=\203\305\202\306\307\n!!)\207" [from to codings find-coding-systems-region-internal t (undecided) sort-coding-systems copy-sequence] 4 (#$ . 15336)])
#@235 Return a list of proper coding systems to encode STRING.
All coding systems in the list can safely encode any multibyte characters
in STRING.

If STRING contains no multibyte characters, return a list of a single
element `undecided'.
(defalias 'find-coding-systems-string #[(string) "\301\302\"\207" [string find-coding-systems-region nil] 3 (#$ . 15897)])
#@360 Return a list of proper coding systems to encode characters of CHARSETS.
CHARSETS is a list of character sets.

This only finds coding systems of type `charset', whose
`:charset-list' property includes all of CHARSETS (plus `ascii' for
ASCII-compatible coding systems).  It was used in older versions of
Emacs, but is unlikely to be what you really want now.
(defalias 'find-coding-systems-for-charsets #[(charsets) "\305\306\"\211\203G\307U\203@\310=\203\311\207\312>\204%\313>\203'\314\207\315\316\317!\315\211\203b@\320\n!\321=\205A\322\n!\323\n\324\"\203P\325\304\310\"\210\326\327\215\203Z\n	B*A\211\2043*	\237)\207" [charsets codings cs --dolist-tail-- cs-charsets mapcar #[(c) "\301\302\"\207" [c get-charset-property :name] 3] 1 ascii (undecided) eight-bit-control eight-bit-graphic (raw-text utf-8-emacs) nil coding-system-list t coding-system-type charset coding-system-charset-list coding-system-get :ascii-compatible-p add-to-list ok (byte-code "\205	\203	\211A@>\204\302\303\304\"\210\202\305\207" [cs-charsets charsets throw ok nil t] 3)] 4 (#$ . 16262)])
#@488 Find multibyte characters in the region specified by FROM and TO.
If FROM is a string, find multibyte characters in the string.
The return value is an alist of the following format:
  ((CHARSET COUNT CHAR ...) ...)
where
  CHARSET is a character set,
  COUNT is a number of characters,
  CHARs are the characters found from the character set.
Optional 3rd arg MAXCOUNT limits how many CHARs are put in the above list.
Optional 4th arg EXCLUDES is a list of character sets to be ignored.
(defalias 'find-multibyte-characters #[(from to &optional maxcount excludes) "\306\211\211;\203\203\307!\203\345\310\311\f\312\313
#,\211\203\fH\314!\211>\204y	\n\236\211\203qAA>\204xA@AT\240\210\203gW\203mC\244\210)\202x	\315E\nB)\fT\202)\202\345\203\345\212b\210\316\311\312#\203\344h\314!\211>\204\214	\n\236\211\203\331AA\235\204\340A@AT\240\210\203\317W\203\325C\244\210)\202\340	\315E\nB)\202\214)\n\237+\207" [char charset chars from idx start nil multibyte-string-p 0 "[^-]" t string-match char-charset 1 re-search-forward string regexp inhibit-changing-match-data excludes slot count maxcount enable-multibyte-characters to] 5 (#$ . 17381)])
#@326 Search forward from point for a character that is not encodable.
It asks which coding system to check.
If such a character is found, set point after that character.
Otherwise, don't move point.

When called from a program, the value is the position of the unencodable
character found, or nil if all characters are encodable.
(defalias 'search-unencodable-char #[(coding-system) "\302`d#\211\203	Tb\210\202\303\304\"\210	)\207" [coding-system pos unencodable-char-position message "All following characters are encodable by %s"] 5 (#$ . 18634) (list (let ((default (or buffer-file-coding-system 'us-ascii))) (read-coding-system (format "Coding-system (default %s): " default) default)))])
#@349 Most recent coding system explicitly specified by the user when asked.
This variable is set whenever Emacs asks the user which coding system
to use in order to write a file.  If you set it to nil explicitly,
then call `write-region', then afterward this variable will be non-nil
only if the user was explicitly asked and specified a coding system.
(defvar last-coding-system-specified nil (#$ . 19336))
#@230 If non-nil, a function to control the behavior of coding system selection.
The meaning is the same as the argument ACCEPT-DEFAULT-P of the
function `select-safe-coding-system' (which see).  This variable
overrides that argument.
(defvar select-safe-coding-system-accept-default-p nil (#$ . 19746))
#@498 Select interactively a coding system for the region FROM ... TO.
FROM can be a string, as in `write-region'.
CODINGS is the list of base coding systems known to be safe for this region,
  typically obtained with `find-coding-systems-region'.
UNSAFE is a list of coding systems known to be unsafe for this region.
REJECTED is a list of coding systems which were safe but for some reason
  were not recommended in the particular context.
DEFAULT is the coding system to use by default in the query.
(defalias 'select-safe-coding-system-interactively #[(from to codings unsafe &optional rejected default) "\203	\306\307\"	\310\211\2034\311@\312\"\211\203-\313\n!\203-\314@\n\"\203-\n\240\210A\211\204*\310	\310\211\203]
@\315\f!\316=\204V\315\f!\317=\204V\fB
A\211\204?\310\237+\320\321\320\322\320\323	\"\"\"\206q\324\325 \326 \310@AB\212\203\226C;\204\226\327A!\210\330\331\306\332\"\"b\210DEr\333\334!q\210p\335 \210ED\310\211FG\336\211H\336IJ\337 \210\340\341!\210+\211KLrLq\210M\204\354\204\354\342C;\203\341\343\344C\"\202\346\343\345A\"\261\210\2026\346C;\203
\347CG\350V\203
C\351\350O\352P\202\n
C\353PP\202
\343\354A\"\355\261\210`\356NO\357M\"\310P\211\203>

@P\360\356!\210\360P!\210
A\211\204*
*\361c\210\362O`\"\210*M\203s
\363c\210M\310P\211\203o

@P\360\364!\210\360P!\210
A\211\204[
*\361c\210\2036M\203\200
\365\202\201
\366\367\261\210\310Q\211\203,
@Q\343\370Q@\"c\210\351\371\372RSTQA\310\211\203!
@\364c\210C;\203\313
T\350W\203\305
\fA\202\306
\373c\210\202T\350W\203\364
\374\fA\375\376\377\201W\201X\201Y\201ZS\201[A\f@D&\210\202\374\373\375\376\377\201W\201X\201\\\201ZR\201[A\f@Q@E&\210TTT
A\211\204\255
-\361c\210
A\211\204\216
*\201]\201^!c\210\201]\201_!c\210`\356NO	\310P\211\203b
@P\360\356!\210\360P!\210
A\211\204N*\361c\210\362O`\"\210+\201`K!\210+\201a\343\201bU\"U\"\211@V)\201c\334!\210\201dB!\210@+\207" [unsafe codings mime-charset l elt --dolist-tail-- mapcar #[(coding) "	;\203\303\304\305\306	G\307	%\"\202\303\310\305	\n\307$\"B\207" [coding from to mapcar #[(pos) "	HB\207" [pos from] 3] unencodable-char-position 0 11 #[(pos) "\211fB\207" [pos] 2]] 9] nil coding-system-get :mime-charset coding-system-p coding-system-equal coding-system-category coding-category-iso-7-else coding-category-iso-8-else delq raw-text emacs-mule no-conversion (raw-text emacs-mule no-conversion) current-window-configuration buffer-name pop-to-buffer apply min #[(x) "\211A@)@\207" [x] 2] get-buffer-create "*Warning*" kill-all-local-variables t erase-buffer run-hooks temp-buffer-setup-hook "No default coding systems to try for " format "string \"%s\"." "buffer `%s'." "These default coding systems were tried to encode" " \"" 10 0 "...\"" "\"" " text\nin the buffer `%s'" ":\n" "  " append princ "\n" fill-region-as-paragraph "These safely encode the text in the buffer,\nbut are not recommended for encoding text in this context,\ne.g., for sending an email message.\n " " " "The other coding systems" "However, each of them" " encountered characters it couldn't encode:\n" "  %s cannot encode these:" #[(bufname pos) "\302\303!!\205\304!\210	b\207" [bufname pos buffer-live-p get-buffer pop-to-buffer] 3] #[(bufname pos coding) "\303\304!!\205\305!\210`	W\203	b\207\306u\210\307\n!\210\310u\207" [bufname pos coding buffer-live-p get-buffer pop-to-buffer 1 search-unencodable-char -1] 3] "..." insert-text-button :type help-xref face coding-system bufname window-configuration from default-directory #1=#:old-dir buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only #2=#:buf standard-output rejected fill-prefix pos x coding func2 func1 i default last-coding-system-specified link help-echo "mouse-2, RET: jump to this character" help-function help-args "mouse-2, RET: next unencodable character" substitute-command-keys "\nClick on a character (or switch to this window by `\\[other-window]'\nand select the characters by RET) to jump to the place it appears,\nwhere `\\[universal-argument] \\[what-cursor-position]' will give information about it.\n" "\nSelect one of the safe coding systems listed below,\nor cancel the writing with \\[keyboard-quit] and edit the buffer\n   to remove or modify the problematic characters,\nor specify any other coding system (and risk losing\n   the problematic characters).\n\n" internal-temp-output-buffer-show read-coding-system "Select coding system (default %s): " kill-buffer set-window-configuration] 15 (#$ . 20051)])
#@1934 Ask a user to select a safe coding system from candidates.
The candidates of coding systems which can safely encode a text
between FROM and TO are shown in a popup window.  Among them, the most
proper one is suggested as the default.

The list of `buffer-file-coding-system' of the current buffer, the
default `buffer-file-coding-system', and the most preferred coding
system (if it corresponds to a MIME charset) is treated as the
default coding system list.  Among them, the first one that safely
encodes the text is normally selected silently and returned without
any user interaction.  See also the command `prefer-coding-system'.

However, the user is queried if the chosen coding system is
inconsistent with what would be selected by `find-auto-coding' from
coding cookies &c. if the contents of the region were read from a
file.  (That could lead to data corruption in a file subsequently
re-visited and edited.)

Optional 3rd arg DEFAULT-CODING-SYSTEM specifies a coding system or a
list of coding systems to be prepended to the default coding system
list.  However, if DEFAULT-CODING-SYSTEM is a list and the first
element is t, the cdr part is used as the default coding system list,
i.e. current `buffer-file-coding-system', default `buffer-file-coding-system',
and the most preferred coding system are not used.

Optional 4th arg ACCEPT-DEFAULT-P, if non-nil, is a function to
determine the acceptability of the silently selected coding system.
It is called with that coding system, and should return nil if it
should not be silently selected and thus user interaction is required.

Optional 5th arg FILE is the file name to use for this purpose.
That is different from `buffer-file-name' when handling `write-region'
(for example).

The variable `select-safe-coding-system-accept-default-p', if non-nil,
overrides ACCEPT-DEFAULT-P.

Kludgy feature: if FROM is a string, the string is the target text,
and TO is ignored.
(defalias 'select-safe-coding-system #[(from to &optional default-coding-system accept-default-p file) "<\204C\306\211;\204e\f\204e\212\214~\210b\210\307
\206'1\206'\3102Z\"\211\203d\311	@!\203>	@\202d\312\313\314\315	@	A\316=\203O\317\202T\314\320	A\"#\321#\210\322\323!\204b\324\325!\210\306*@\326=\203q\326A\327\330\"	\203\222\n\204\222\331	!\2113\332>\204\221	3BC\326)\n\204 
\203\272\331!\2113\333=\204\271\3343\"\204\271\3353BC\")4\203\3054A\204 
\336\337!\203\354\331\336\337!!\2113\333=\204\353\3343\"\204\353\335\336\337!3BC\")\340\326!\30635\3115!\203
\3315!\2113\203
\3415\342\"\203
\3343\"\204
\33553BC\"*6\203)
67\203\216
\343\2118@@)!9\3449!\203J
\203J
\343!9\3449!\203^
\336\337!\203^
\343\336\337!!99\203\215
\3449!\204\215
\306:\211;\203\214
;@\211:\345:@9\"\240\210;A\211;\204t
*)\3462\"\306;?\205\234
\347 \306\211\211<=>?@\211A@\333=\203\276
\2118@@)@\202#\237\211\306:\211;\203;@:A@\333=\204\341
:AA>\203\3507!\203\374
7:A!\204\374
:@=B=\202:@>B>\202:@<B<;A\211;\204\313
*>\203#>@@@\2049\3512A<=A@&@	\203\335@\203K\352@!\353>\204\335@\204V	@\202\263	\204`@\202\263\343@!\343	!BC\331@!\333=\203~\354@	\"@\202\214\331	!\333=\203\214\354	@\"\344C!\203\245\344B!\204\262\345@B\"@\202\262\344B!\203\262\345	C\"*	\203\335\355
\206\3021\206\302\310!\204\335\356@	\"\204\335\322\314\357@	#!\204\335\324\325!\210?\203\356?\347 U\204\356\324\360!\210@.\207" [default-coding-system auto-cs no-other-defaults from find-file-literally file nil find-auto-coding "" coding-system-p display-warning mule format "Invalid coding system `%s' is specified\nfor the current buffer/file by the %s.\nIt is highly recommended to fix it before writing to a file." :coding ":coding tag" "variable `%s'" :warning yes-or-no-p "Really proceed with writing? " error "Save aborted" t mapcar #[(x) "\301!B\207" [x coding-system-base] 3] coding-system-base (nil undecided) undecided rassq append default-value buffer-file-coding-system coding-system-priority-list coding-system-get :mime-charset coding-system-eol-type vectorp coding-system-change-eol-conversion find-coding-systems-region buffer-chars-modified-tick functionp select-safe-coding-system-interactively coding-system-type (0 5) coding-system-change-text-conversion auto-coding-alist-lookup coding-system-equal "Selected encoding %s disagrees with %s specified by file contents.  Really save (else edit coding cookies and try again)? " "Canceled because the buffer was modified" buffer-file-name to base buffer-file-coding-system-explicit preferred select-safe-coding-system-accept-default-p accept-default-p x default-eol-type elt --dolist-tail-- unsafe rejected safe tick coding-system codings eol-type-2 eol-type-1] 9 (#$ . 24679)])
(byte-code "\301\211\207" [select-safe-coding-system-function select-safe-coding-system] 2)
#@505 Return a coding system to encode the outgoing message of the current buffer.
It at first tries the first coding system found in these variables
in this order:
  (1) local value of `buffer-file-coding-system'
  (2) value of `sendmail-coding-system'
  (3) value of `default-sendmail-coding-system'
  (4) default value of `buffer-file-coding-system'
If the found coding system can't encode the current buffer,
or none of them are bound to a coding system,
it asks the user to select a proper coding system.
(defalias 'select-message-coding-system #[nil "\305\300!\203\n\206	\206\n\206\306\300!\211\307=\203\310\311\f!\203-\fed\312$\202.)\207" [buffer-file-coding-system sendmail-coding-system default-sendmail-coding-system coding select-safe-coding-system-function local-variable-p default-value no-conversion nil fboundp #[(x) "\301\302\"\207" [x coding-system-get :mime-charset] 3]] 6 (#$ . 29618)])
#@2280 Alist of language environment definitions.
Each element looks like:
	(LANGUAGE-NAME . ((KEY . INFO) ...))
where LANGUAGE-NAME is a string, the name of the language environment,
KEY is a symbol denoting the kind of information, and
INFO is the data associated with KEY.
Meaningful values for KEY include

  documentation      value is documentation of what this language environment
			is meant for, and how to use it.
  charset	     value is a list of the character sets mainly used
			by this language environment.
  sample-text	     value is an expression which is evalled to generate
                        a line of text written using characters appropriate
                        for this language environment.
  setup-function     value is a function to call to switch to this
			language environment.
  exit-function      value is a function to call to leave this
		        language environment.
  coding-system      value is a list of coding systems that are good for
			saving text written in this language environment.
			This list serves as suggestions to the user;
			in effect, as a kind of documentation.
  coding-priority    value is a list of coding systems for this language
			environment, in order of decreasing priority.
			This is used to set up the coding system priority
			list when you switch to this language environment.
  nonascii-translation
		     value is a charset of dimension one to use for
			converting a unibyte character to multibyte
			and vice versa.
  input-method       value is a default input method for this language
			environment.
  features           value is a list of features requested in this
			language environment.
  ctext-non-standard-encodings
		     value is a list of non-standard encoding names used
			in extended segments of CTEXT.  See the variable
			`ctext-non-standard-encodings' for more detail.

The following key takes effect only when multibyte characters are
globally disabled, i.e. the default value of `enable-multibyte-characters'
is nil (which is an obsolete and deprecated use):

  unibyte-display    value is a coding system to encode characters for
			the terminal.  Characters in the range of 160 to
			255 display not as octal escapes, but as non-ASCII
			characters in this language environment.
(defvar language-info-alist nil (#$ . 30543))
#@205 Return information listed under KEY for language environment LANG-ENV.
KEY is a symbol denoting the kind of information.
For a list of useful values for KEY and their meanings,
see `language-info-alist'.
(defalias 'get-language-info #[(lang-env key) "9\203	\304!\305	\306#\211\205\nA\236A)\207" [lang-env language-info-alist lang-slot key symbol-name assoc-string t] 5 (#$ . 32875)])
#@344 Modify part of the definition of language environment LANG-ENV.
Specifically, this stores the information INFO under KEY
in the definition of this language environment.
KEY is a symbol denoting the kind of information.
INFO is the value for that information.

For a list of useful values for KEY and their meanings,
see `language-info-alist'.
(defalias 'set-language-info #[(lang-env key info) "9\203	\304!\305	\n#\210\232\205W	\306=\203#\307!\210\310!\207	\311=\203-\312!\207	\313=\2037\314!\207	\315=\203A\310!\207\316\317!?\205W	\320=\204T	\321=\205W\322!\207" [lang-env key info current-language-environment symbol-name set-language-info-internal coding-priority set-language-environment-coding-systems set-language-environment-charset input-method set-language-environment-input-method nonascii-translation set-language-environment-nonascii-translation charset default-value enable-multibyte-characters unibyte-syntax unibyte-display set-language-environment-unibyte] 4 (#$ . 33275)])
#@67 Internal use only.
Arguments are the same as `set-language-info'.
(defalias 'set-language-info-internal #[(lang-env key info) "\306\211\307\n\"\211\204\nC\211B\f	\236\211\204&\fC		AB\241\210\310
!\241\210\311\312\313\314\315\316\317\315\320\"\321\"\"B#*\207" [key-slot lang-slot lang-env language-info-alist key info nil assoc purecopy put current-language-environment custom-type choice mapcar #[(lang) "\301D\207" [lang const] 2] sort car string<] 11 (#$ . 34292)])
#@485 Store ALIST as the definition of language environment LANG-ENV.
ALIST is an alist of KEY and INFO values.  See the documentation of
`language-info-alist' for the meanings of KEY and INFO.

Optional arg PARENTS is a list of parent menu names; it specifies
where to put this language environment in the
Describe Language Environment and Set Language Environment menus.
For example, ("European") means to put this language environment
in the European submenu in each of those two menus.
(defalias 'set-language-info-alist #[(lang-env alist &optional parents) "9\203\f\306!\202;\203\307!	\n
\203\303
\310\211\211\211\211\203\302@\2119\203C\306!\202M\311!\312\f\313!\"\211\204a\314\315\"\204\205\311\314\316\227\"!\317\310#\210\320\f\313!B#\210J\312\313!\"\211\204\265\311\314\321\227\"!\317\310#\210\320\313!B#\210JA\211\2040-\322\236\211\203\331\320\f\313\311!!\323B#\210)\320\313\311!!\324B#\210\310\211\203	
@\325@A#\210A\211\204\361* \232\205
\326!*\207" [lang-env describe-language-environment-map setup-language-environment-map setup-map describe-map parents symbol-name purecopy nil intern lookup-key vector format "%s Environment" "describe-%s-environment-map" define-prefix-command define-key-after "setup-%s-environment-map" documentation describe-specified-language-support setup-specified-language-environment set-language-info-internal set-language-environment prompt parent parent-symbol map l alist doc elt --dolist-tail-- current-language-environment] 6 (#$ . 34783)])
#@241 Read a language environment name which has information for KEY.
If KEY is nil, read any language environment.
Prompt with PROMPT.  DEFAULT is the default choice of language environment.
This returns a language environment name as a string.
(defalias 'read-language-name #[(key prompt &optional default) "\306\307	\n\205\n\310\306\311\211\f&\211G\312V\205$\203#\313
\"\205$
*\207" [completion-ignore-case prompt language-info-alist key default name t completing-read #[(elm) "<\205	\236\207" [elm key] 2] nil 0 get-language-info] 9 (#$ . 36406)])
(custom-declare-group 'leim nil "LEIM: Libraries of Emacs Input Methods." :group 'mule)
#@201 Name of LEIM list file.
This file contains a list of libraries of Emacs input methods (LEIM)
in the format of Lisp expression for registering each input method.
Emacs loads this file at startup time.
(defconst leim-list-file-name "leim-list.el" (#$ . 37061))
#@42 Header to be inserted in LEIM list file.
(defconst leim-list-header (format ";;; %s -- list of LEIM (Library of Emacs Input Method) -*-coding: utf-8;-*-\n;;\n;; This file is automatically generated.\n;;\n;; This file contains a list of LEIM (Library of Emacs Input Method)\n;; methods in the same directory as this file.  Loading this file\n;; registers all the input methods in Emacs.\n;;\n;; Each entry has the form:\n;;   (register-input-method\n;;    INPUT-METHOD LANGUAGE-NAME ACTIVATE-FUNC\n;;    TITLE DESCRIPTION\n;;    ARG ...)\n;; See the function `register-input-method' for the meanings of the arguments.\n;;\n;; If this directory is included in `load-path', Emacs automatically\n;; loads this file at startup time.\n\n" leim-list-file-name) (#$ . 37326))
#@97 Regexp matching head of each entry in LEIM list file.
See also the variable `leim-list-header'.
(defconst leim-list-entry-regexp "^(register-input-method" (#$ . 38100))
#@112 List of functions to call to update LEIM list file.
Each function is called with one arg, LEIM directory name.
(defvar update-leim-list-functions '(quail-update-leim-list-file) (#$ . 38276))
#@44 Update LEIM list file in directories DIRS.
(defalias 'update-leim-list-file #[(&rest dirs) "\304\211\205\n@\305	\"\210\nA\211\204\304*\207" [update-leim-list-functions function --dolist-tail-- dirs nil apply] 4 (#$ . 38473)])
#@102 The current input method for multilingual text.
If nil, that means no input method is activated now.
(defvar current-input-method nil (#$ . 38716))
(byte-code "\300\301!\210\302\301\303\304#\207" [make-variable-buffer-local current-input-method put permanent-local t] 4)
#@62 Title string of the current input method shown in mode line.
(defvar current-input-method-title nil (#$ . 38993))
(byte-code "\300\301!\210\302\301\303\304#\210\305\306\307\310\311\312\313\314&\210\315\316\317\320\321\322\323\324\325\326\327\330&\210\302\331\303\304#\207" [make-variable-buffer-local current-input-method-title put permanent-local t define-widget mule-input-method-string string "String widget with completion for input method." :completions #[(string pred action) "\305\306	\n\f$)\207" [completion-ignore-case action input-method-alist string pred t complete-with-action] 5] :prompt-history input-method-history custom-declare-variable default-input-method nil "Default input method for multilingual text (a string).\nThis is the input method activated automatically by the command\n`toggle-input-method' (\\[toggle-input-method])." :link (custom-manual "(emacs)Input Methods") :group mule :type (choice (const nil) mule-input-method-string) :set-after (current-language-environment) input-method-function] 12)
#@152 History list of input methods read from the minibuffer.

Maximum length of the history list is determined by the value
of `history-length', which see.
(defvar input-method-history nil (#$ . 40033))
(byte-code "\302\303!\210\304\303\305\306#\210\307\310\311\312#\210\313\312\211\2036	@\310N\203/\311N\204/\304\311\310N#\210	A\211\204*\314\310\311\315#\207" [prop --dolist-tail-- make-variable-buffer-local input-method-history put permanent-local t defvaralias inactivate-current-input-method-function deactivate-current-input-method-function nil (saved-value saved-variable-comment) make-obsolete-variable "24.3"] 6)
#@310 Function to call for deactivating the current input method.
Every input method should set this to an appropriate value when activated.
This function is called with no argument.

This function should never change the value of `current-input-method'.
It is set to nil by the function `deactivate-input-method'.
(defvar deactivate-current-input-method-function nil (#$ . 40670))
(byte-code "\300\301!\210\302\301\303\304#\207" [make-variable-buffer-local deactivate-current-input-method-function put permanent-local t] 4)
#@101 Function to call for describing the current input method.
This function is called with no argument.
(defvar describe-current-input-method-function nil (#$ . 41196))
(byte-code "\300\301!\210\302\301\303\304#\207" [make-variable-buffer-local describe-current-input-method-function put permanent-local t] 4)
#@222 Alist of input method names vs how to use them.
Each element has the form:
   (INPUT-METHOD LANGUAGE-ENV ACTIVATE-FUNC TITLE DESCRIPTION ARGS...)
See the function `register-input-method' for the meanings of the elements.
(defvar input-method-alist nil (#$ . 41509))
(put 'input-method-alist 'risky-local-variable t)
#@1146 Register INPUT-METHOD as an input method for language environment LANG-ENV.

INPUT-METHOD and LANG-ENV are symbols or strings.
ACTIVATE-FUNC is a function to call to activate this method.
TITLE is a string to show in the mode line when this method is active.
DESCRIPTION is a string describing this method and what it is good for.
The ARGS, if any, are passed as arguments to ACTIVATE-FUNC.
All told, the arguments to ACTIVATE-FUNC are INPUT-METHOD and the ARGS.

This function is mainly used in the file "leim-list.el" which is
created at Emacs build time, registering all Quail input methods
contained in the Emacs distribution.

In case you want to register a new Quail input method by yourself, be
careful to use the same input method title as given in the third
parameter of `quail-define-package'.  (If the values are different, the
string specified in this function takes precedence.)

The commands `describe-input-method' and `list-input-methods' need
these duplicated values to show some information about input methods
without loading the relevant Quail packages.

(fn INPUT-METHOD LANG-ENV ACTIVATE-FUNC TITLE DESCRIPTION &rest ARGS)
(defalias 'register-input-method #[(input-method lang-env &rest args) "9\203\f\306!\202\307!	9\203\306	!\202 \307	!\310\307\n\"\nB\311	\"\f\2038\f
\241\202A	
B\211B\211*\207" [lang-env input-method args input-method-alist slot info symbol-name purecopy mapcar assoc] 5 (#$ . 41833)])
#@255 Read a name of input method from a minibuffer prompting with PROMPT.
If DEFAULT is non-nil, use that as the default,
and substitute it into PROMPT at the first `%s'.
If INHIBIT-NULL is non-nil, null input signals an error.

The return value is a string.
(defalias 'read-input-method-name #[(prompt &optional default inhibit-null) "\203	\306	\"\307\211\310	\f\311\307\311\312&\211\203%
9\203%\313
!
G\314V\2030
\2028\2058\315\316!+\207" [default prompt completion-ignore-case enable-recursive-minibuffers input-method-alist input-method format t completing-read nil input-method-history symbol-name 0 error "No valid input method is specified" inhibit-null] 9 (#$ . 43292)])
#@187 Switch to input method INPUT-METHOD for the current buffer.
If some other input method is already active, turn it off first.
If INPUT-METHOD is nil, deactivate any current input method.
(defalias 'activate-input-method #[(input-method) "\203
9\203
\306!	\203	\230\204\307 \210	\206 ??\205\204\310\n\"\211\2042\311\312\"\210\313\3148\315
!\203K\316\3148\317\233#\210\202r
:\203m
@9\203m
A9\203m\320
A!\210\316
@\317\233#\210\202r\311\312\"\210)\f;\204~\3218\322\216\323\324!*\207" [input-method current-input-method input-method-alist slot current-input-method-title func symbol-name deactivate-input-method assoc error "Can't activate input method `%s'" nil 2 functionp apply 5 require 3 ((force-mode-line-update)) run-hooks input-method-activate-hook] 6 (#$ . 43990)])
#@36 Turn off the current input method.
(defalias 'deactivate-input-method #[nil "\205%	\203	@\230\204\305	\"B\202C\306\216\307\211\f )\207" [current-input-method input-method-history input-method-function current-input-method-title deactivate-current-input-method-function delete ((byte-code "\300\216\301\302\303\"\210)\301\207" [((byte-code "\301\302 \207" [current-input-method nil force-mode-line-update] 1)) run-hooks input-method-inactivate-hook input-method-deactivate-hook] 3)) nil] 5 (#$ . 44804)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias inactivate-input-method deactivate-input-method nil make-obsolete "24.3"] 4)
#@599 Select and activate input method INPUT-METHOD for the current buffer.
This also sets the default input method to the one you specify.
If INPUT-METHOD is nil, this function turns off the input method, and
also causes you to be prompted for a name of an input method the next
time you invoke \[toggle-input-method].
When called interactively, the optional arg INTERACTIVE is non-nil,
which marks the variable `default-input-method' as set for Custom buffers.

To deactivate the input method interactively, use \[toggle-input-method].
To deactivate it programmatically, use `deactivate-input-method'.
(defalias 'set-input-method #[(input-method &optional interactive) "\303!\210\n\203\304\301!\210	\207" [input-method default-input-method interactive activate-input-method customize-mark-as-set] 2 (#$ . 45475) (let* ((default (or (car input-method-history) default-input-method))) (list (read-input-method-name (if default "Select input method (default %s): " "Select input method: ") default t) t))])
#@39 Non-nil inside `toggle-input-method'.
(defvar toggle-input-method-active nil (#$ . 46486))
#@835 Enable or disable multilingual text input method for the current buffer.
Only one input method can be enabled at any time in a given buffer.

The normal action is to enable an input method if none was enabled,
and disable the current one otherwise.  Which input method to enable
can be determined in various ways--either the one most recently used,
or the one specified by `default-input-method', or as a last resort
by reading the name of an input method in the minibuffer.

With a prefix argument ARG, read an input method name with the minibuffer
and enable that one.  The default is the most recent input method specified
(not including the currently active input method, if any).

When called interactively, the optional argument INTERACTIVE is non-nil,
which marks the variable `default-input-method' as set for Custom buffers.
(defalias 'toggle-input-method #[(&optional arg interactive) "\203\306\307!\210	\203\n\204\310 \207\311@\206\f\n\2035
\2035	
\232\2035G\312V\2035A@\313\n\204>
\204N\314
\203G\315\202H\316
\311#\202O
!\210\f?\205b	\211\203b\317\304!\210*\207" [toggle-input-method-active current-input-method arg input-method-history default-input-method default error "Recursive use of `toggle-input-method'" deactivate-input-method t 1 activate-input-method read-input-method-name "Input method (default %s): " "Input method: " customize-mark-as-set interactive] 5 (#$ . 46584) "P\np"])
(autoload 'help-buffer "help-mode")
#@37 Describe input method INPUT-METHOD.
(defalias 'describe-input-method #[(input-method) "\203
9\203
\303!\304\305\206	D\306\307!\"\210\204!\310 \207	\311\312\313\217)\207" [input-method current-input-method current symbol-name help-setup-xref describe-input-method called-interactively-p interactive describe-current-input-method nil (byte-code "\212\302!\210\303 \210)\302	!\207" [input-method current activate-input-method describe-current-input-method] 2) ((error (byte-code "\306!\210\307\310	D\311\312!\"\210\nr\313\314 !q\210p\315 \210\316\211\317\211\317\320 \210\321\322!\210+\211\323	\" \324\325\326	\327 8 A@\330 8%!)\331!\210+\207" [current input-method default-directory #1=#:old-dir buffer-read-only buffer-file-name activate-input-method help-setup-xref describe-input-method called-interactively-p interactive get-buffer-create help-buffer kill-all-local-variables nil t erase-buffer run-hooks temp-buffer-setup-hook assoc princ format "Input method: %s (`%s' in mode line) for %s\n  %s\n" 3 4 internal-temp-output-buffer-show buffer-undo-list inhibit-modification-hooks inhibit-read-only #2=#:buf standard-output input-method-alist elt] 9)))] 4 (#$ . 48060) (list (read-input-method-name "Describe input method (default current choice): "))])
#@95 Describe the input method currently in use.
This is a subroutine for `describe-input-method'.
(defalias 'describe-current-input-method #[nil "\203	9\203\302	!\203	 \207\303\304\"\210\305 \207\306\307!\207" [current-input-method describe-current-input-method-function fboundp message "No way to describe the current input method `%s'" ding error "No input method is activated now"] 3 (#$ . 49360)])
#@378 Read a multilingual string from minibuffer, prompting with string PROMPT.
The input method selected last time is activated in minibuffer.
If optional second argument INITIAL-INPUT is non-nil, insert it in the
minibuffer initially.
Optional 3rd argument INPUT-METHOD specifies the input method to be activated
instead of the one selected last time.  It is a symbol or a string.
(defalias 'read-multilingual-string #[(prompt &optional initial-input input-method) "\206	\206\n\206\306\307\310\311#\211\2039\203\312!	\313\216\314!\210\315\f
\310\211\311%*\207" [input-method current-input-method default-input-method prev-input-method prompt initial-input read-input-method-name "Input method: " nil t symbol-name ((activate-input-method prev-input-method)) activate-input-method read-string] 7 (#$ . 49773)])
(byte-code "\302\303\304\305\306\307\310\311&\210\302\312\313\314\306\315\310\311&\210\302\316\317\320\306\321\310\311&\210\322\323\324\317#\210\325\317\211\203M	@\323N\203F\324N\204F\326\324\323N#\210	A\211\204/*\327\323\324\330#\210\302\324\317\331\306\321\310\311\332\330&	\210\302\333\317\334\306\321\310\311&\207" [prop --dolist-tail-- custom-declare-variable input-method-verbose-flag 'default "A flag to control extra guidance given by input methods.\nThe value should be nil, t, `complex-only', or `default'.\n\nThe extra guidance is done by showing list of available keys in echo\narea.  When you use the input method in the minibuffer, the guidance\nis shown at the bottom short window (split from the existing window).\n\nIf the value is t, extra guidance is always given, if the value is\nnil, extra guidance is always suppressed.\n\nIf the value is `complex-only', only complex input methods such as\n`chinese-py' and `japanese' give extra guidance.\n\nIf the value is `default', complex input methods always give extra\nguidance, but simple input methods give it only when you are not in\nthe minibuffer.\n\nSee also the variable `input-method-highlight-flag'." :type (choice (const :tag "Always" t) (const :tag "Never" nil) (const complex-only) (const default)) :group mule input-method-highlight-flag t "If this flag is non-nil, input methods highlight partially-entered text.\nFor instance, while you are in the middle of a Quail input method sequence,\nthe text inserted so far is temporarily underlined.\nThe underlining goes away when you finish or abort the input method sequence.\nSee also the variable `input-method-verbose-flag'." boolean input-method-activate-hook nil "Normal hook run just after an input method is activated.\n\nThe variable `current-input-method' keeps the input method name\njust activated." hook defvaralias input-method-inactivate-hook input-method-deactivate-hook (saved-value saved-variable-comment) put make-obsolete-variable "24.3" "Normal hook run just after an input method is deactivated.\n\nThe variable `current-input-method' still keeps the input method name\njust deactivated." :version input-method-after-insert-chunk-hook "Normal hook run just after an input method insert some chunk of text."] 11)
#@330 This flag controls when an input method returns.
Usually, the input method does not return while there's a possibility
that it may find a different translation if a user types another key.
But, if this flag is non-nil, the input method returns as soon as the
current key sequence gets long enough to have some valid translation.
(defvar input-method-exit-on-first-char nil (#$ . 52878))
#@299 This flag controls how an input method shows an intermediate key sequence.
Usually, the input method inserts the intermediate key sequence,
or candidate translations corresponding to the sequence,
at point in the current buffer.
But, if this flag is non-nil, it displays them in echo area instead.
(custom-declare-variable 'input-method-use-echo-area nil '(#$ . 53272) :type 'hook :group 'mule)
#@348 This flag controls the behavior of an input method on invalid key input.
Usually, when a user types a key which doesn't start any character
handled by the input method, the key is handled by turning off the
input method temporarily.  After that key, the input method is re-enabled.
But, if this flag is non-nil, the input method is never back on.
(defvar input-method-exit-on-invalid-key nil (#$ . 53674))
(byte-code "\300\301\302\303\304\305\306\307&\210\300\310\302\311\304\305\306\307&\210\312\313\314\315#\207" [custom-declare-variable set-language-environment-hook nil "Normal hook run after some language environment is set.\n\nWhen you set some hook function here, that effect usually should not\nbe inherited to another language environment.  So, you had better set\nanother function in `exit-language-environment-hook' (which see) to\ncancel the effect." :type hook :group mule exit-language-environment-hook "Normal hook run after exiting from some language environment.\nWhen this hook is run, the variable `current-language-environment'\nis still bound to the language environment being exited.\n\nThis hook is mainly used for canceling the effect of\n`set-language-environment-hook' (which see)." put setup-specified-language-environment apropos-inhibit t] 8)
#@45 Switch to a specified language environment.
(defalias 'setup-specified-language-environment #[nil "\302	9\203%	\303=\203\304\211\203%\305	!\211\203%\306!\307\310!\210\202(\311\312!)\207" [language-name last-command-event nil Default English symbol-name set-language-environment customize-mark-as-set current-language-environment error "Bogus calling sequence"] 3 (#$ . 54955) nil])
(byte-code "\301\302\303\304\305\306\307\310\311\312\313\203\314\315\316\317\315\320\"\321\"\"B\202\322\323\324\325\326&\207" [language-info-alist custom-declare-variable current-language-environment "English" "The last language environment specified with `set-language-environment'.\nThis variable should be set only with \\[customize], which is equivalent\nto using the function `set-language-environment'." :link (custom-manual "(emacs)Language Environments") :set #[(symbol value) "\301!\207" [value set-language-environment] 2] :get #[(x) "\3029\203\f\303!\202
	\304#\242\206\305\207" [current-language-environment language-info-alist assoc-string symbol-name t "English"] 4] :type choice mapcar #[(lang) "\301D\207" [lang const] 2] sort car string< string :initialize custom-initialize-default :group mule] 18)
#@514 Reset multilingual environment of Emacs to the default status.

The default status is as follows:

  The default value of `buffer-file-coding-system' is nil.
  The default coding system for process I/O is nil.
  The default value for the command `set-terminal-coding-system' is nil.
  The default value for the command `set-keyboard-coding-system' is nil.

  The order of priorities of coding systems are as follows:
	utf-8
	iso-2022-7bit
	iso-latin-1
	iso-2022-7bit-lock
	iso-2022-8bit-ss2
	emacs-mule
	raw-text
(defalias 'reset-language-environment #[nil "\305\306\307\310\311\312\313\314&\210\315\316!\210\310\211\316\317\320\217\316\321\322\217\211\nB*\323\324!\207" [default-sendmail-coding-system default-file-name-coding-system input-coding output-coding default-process-coding-system set-coding-system-priority utf-8 iso-2022-7bit iso-latin-1 iso-2022-7bit-lock iso-2022-8bit-ss2 emacs-mule raw-text set-default-coding-systems nil (byte-code "\301@\302\"\207" [default-process-coding-system coding-system-change-text-conversion undecided] 3) ((coding-system-error 'undecided)) (byte-code "\301A\302\"\207" [default-process-coding-system coding-system-change-text-conversion iso-latin-1] 3) ((coding-system-error 'iso-latin-1)) set-charset-priority iso-8859-1] 9 (#$ . 56187) nil])
(reset-language-environment)
#@72 Set up the display table and terminal coding system for LANGUAGE-NAME.
(defalias 'set-display-table-and-terminal-coding-system #[(language-name &optional coding-system display) "\306\307\"\211\203\n\203\310	\n\"\203\311 \210\2027\2037\312\313\f
W\2036\f\312\\\314I\210\fT\211\202#*\315\n\206=	\")\207" [language-name coding coding-system standard-display-table i --dotimes-limit-- get-language-info unibyte-display coding-system-equal standard-display-european-internal 128 0 nil set-terminal-coding-system display] 4 (#$ . 57519)])
#@531 Set up multilingual environment for using LANGUAGE-NAME.
This sets the coding system priority and the default input method
and sometimes other things.  LANGUAGE-NAME should be a string
which is the name of a language environment.  For example, "Latin-1"
specifies the character set for the major languages of Western Europe.

If there is a prior value for `current-language-environment', this
runs the hook `exit-language-environment-hook'.  After setting up
the new language environment, it runs `set-language-environment-hook'.
(defalias 'set-language-environment #[(language-name) "\2039\203\306!\202\307\310	\311#\211\204!\312\313\"\210\n@)\203<\314\315\"\316\317!\210\320\f!\203;\f \210)\321 \210\314\322\"\211\203T\323
@!\210
A\211\204H)\324!\210\325!\210\326!\210\327!\210\330\331!\204q\332!\210\314\333\"\320\f!\203\f \210)\314\334\"\206\211\316\335!\210\336\311!\207" [language-name language-info-alist slot current-language-environment func required-features symbol-name "English" assoc-string t error "Language environment not defined: %S" get-language-info exit-function run-hooks exit-language-environment-hook functionp reset-language-environment features require set-language-environment-coding-systems set-language-environment-input-method set-language-environment-nonascii-translation set-language-environment-charset default-value enable-multibyte-characters set-language-environment-unibyte setup-function iso639-language set-language-environment-hook force-mode-line-update current-iso639-language] 5 (#$ . 58079) (list (read-language-name nil "Set language environment (default English): "))])
(byte-code "\300\301\302\303\304\305\306\307\310\311\312\313\314\315&
\210\316\317\320\321\322\323\324\325\326\327\330\331&\207" [define-widget charset symbol "An Emacs charset." :tag "Charset" :completions #[(string pred action) "\305\306	\307\310\n\f&)\207" [completion-ignore-case obarray string pred action t completion-table-with-predicate charsetp strict] 7] :value ascii :validate #[(widget) "\301\302!!?\205\303\304\305\306\302!\"#\210\207" [widget charsetp widget-value widget-put :error format "Invalid charset: %S"] 7] :prompt-history charset-history custom-declare-variable language-info-custom-alist nil "Customizations of language environment parameters.\nValue is an alist with elements like those of `language-info-alist'.\nThese are used to set values in `language-info-alist' which replace\nthe defaults.  A typical use is replacing the default input method for\nthe environment.  Use \\[describe-language-environment] to find the environment's settings.\n\nThis option is intended for use at startup.  Removing items doesn't\nremove them from the language info until you next restart Emacs.\n\nSetting this variable directly does not take effect.\nSee `set-language-info-alist' for use in programs." :group mule :version "23.1" :set #[(s v) "\305	\"\210	\205&	\306\211\203\"@\307\n@\nA\"\210A\211\204*\310\f!\207" [s v elt --dolist-tail-- current-language-environment custom-set-default nil set-language-info-alist set-language-environment] 4] :type (alist :key-type (string :tag "Language environment" :completions (lambda (string pred action) (let ((completion-ignore-case t)) (complete-with-action action language-info-alist string pred)))) :value-type (alist :key-type symbol :options ((documentation string) (charset (repeat charset)) (sample-text string) (setup-function function) (exit-function function) (coding-system (repeat coding-system)) (coding-priority (repeat coding-system)) (nonascii-translation charset) (input-method mule-input-method-string) (features (repeat symbol)) (unibyte-display coding-system))))] 14)
(defalias 'standard-display-european-internal #[nil "\302\303=\203\304\202\f\305\306\"\210\303=\203\307\310!?\206C\311=\2036\312 \313\230\2036\314\315\316 8!\317H\320V\204=	\321\305!\322I\210	\321\323!\324I\207" [window-system standard-display-table standard-display-8bit pc 128 160 255 default-value enable-multibyte-characters x x-server-vendor "The XFree86 Project, Inc" number-to-string 2 x-server-version 0 51 unibyte-char-to-multibyte [32] 146 [39]] 3])
#@73 Do various coding system setups for language environment LANGUAGE-NAME.
(defalias 'set-language-environment-coding-systems #[(language-name) "\306\307\"\211@\310\311\312!\206\313>\203\314\202\315!	\2057\316\f\317>\203.\320\n\f\"\202/\n!\210\n\321\322	\"+\207" [language-name priority default-coding system-type eol-type default-sendmail-coding-system get-language-info coding-priority coding-system-eol-type default-value buffer-file-coding-system (windows-nt ms-dos) dos unix set-default-coding-systems (0 1 2 unix dos mac) coding-system-change-eol-conversion apply set-coding-system-priority] 5 (#$ . 62286)])
#@72 Do various input method setups for language environment LANGUAGE-NAME.
(defalias 'set-language-environment-input-method #[(language-name) "\304\301\"\211\205	\205	\305	\"B\211)\207" [language-name input-method default-input-method input-method-history get-language-info delete] 5 (#$ . 62919)])
#@80 Do unibyte/multibyte translation setup for language environment LANGUAGE-NAME.
(defalias 'set-language-environment-nonascii-translation #[(language-name) "\304\305\"\n\306=\203\307\310\311\"!\312	!\203\313	\314\"\206\"\315\211)\207" [language-name nonascii window-system dos-codepage get-language-info nonascii-translation pc intern format "cp%d" charsetp get-charset-property :ascii-compatible-p iso-8859-1] 4 (#$ . 63230)])
#@67 Do various charset setups for language environment LANGUAGE-NAME.
(defalias 'set-language-environment-charset #[(language-name) "\305\306\"\305\307\"\310\211\203)@\311\n!\211:\203!\312	\f\")A\211\204*	\2052\313\314	\")\207" [language-name charsets coding --dolist-tail-- list get-language-info charset coding-priority nil coding-system-charset-list append apply set-charset-priority] 4 (#$ . 63672)])
#@72 Do various unibyte-mode setups for language environment LANGUAGE-NAME.
(defalias 'set-language-environment-unibyte #[(language-name) "\301!\207" [language-name set-display-table-and-terminal-coding-system] 2 (#$ . 64095)])
#@52 Print all arguments with `princ', then print "\n".
(defalias 'princ-list #[(&rest args) "\301\302\"\210\302\303!\207" [args mapc princ "\n"] 3 (#$ . 64325)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [make-obsolete princ-list "use mapc and princ instead." "23.3" put describe-specified-language-support apropos-inhibit t] 4)
#@65 Describe how Emacs supports the specified language environment.
(defalias 'describe-specified-language-support #[nil "\302	9\203	\303=\203\304\211\203\305	!\211\204\306\307!\210\310!)\207" [language-name last-command-event nil Default English symbol-name error "This command should only be called from the menu bar" describe-language-environment] 2 (#$ . 64671) nil])
#@65 Describe how Emacs supports language environment LANGUAGE-NAME.
(defalias 'describe-language-environment #[(language-name) "\204	\203\306\307\"\204\310\311!\2109\203\312!\306\313\"\314\211\2037@\315\n!\210A\211\204)*\306\307\"\316\317D\320\321!\"\210
?r\322\323 !q\210p\324 \210?\314\211@A\325\211B\325CD\326 \210\327\330!\210+\211EFrFq\210\331\261\210\f;\203\207\f\332\261\210\314\333\334\217\210\306\335\"\336G!\325HI\211\203\301\337I\"\211\203\301\340@\341\261\210\342I\"BI\314HI\314J\211\203,
@JJ=\204\351\343\314\211JA@\314\211\325&\325=\203%
H\203\364\344c\210\314H\345J@\261\210\346J@!\210\347\350\351J@#\210db\210\352\353J8;\203
\353J8\202!
\353J8@\354\261\210A\211\204\313*H\2045
\355c\210+\356c\210\306\357\"\211I\204L
\360\355\261\210\202\200
I\203\200
\345\312I@!\261\210\346\312I@!!\210\347\350\361I@#\210db\210\362\363I@!\355\261\210IA\211I\204Q
)\355c\210\364c\210\306\365\"\211I\204\231
\360\355\261\202\375
I\205\375
\345\312I@!\261\210\346\312I@!!\210\347\350\366I@#\210db\210\367\370I@!\371\372I@!\355\261\210\373I@!\211K\203\362
\374c\210K\203\357
\375\312K@!\261\210KA\211K\204\335
\341c\210)IA\211I\204\236
\314*\376E!\210,\207" [language-name current-language-environment feature --dolist-tail-- doc default-directory get-language-info documentation error "No documentation for the specified language" symbol-name features nil require help-setup-xref describe-language-environment called-interactively-p interactive get-buffer-create help-buffer kill-all-local-variables t erase-buffer run-hooks temp-buffer-setup-hook " language environment\n\n" "\n\n" (byte-code "\302\303\304\"!\211;\203\305\306\307\310	#\311\261\210)\302\207" [language-name str eval get-language-info sample-text "Sample text:\n  " replace-regexp-in-string "\n" "\n  " "\n\n"] 6) ((error)) input-method copy-sequence assoc "Input methods (default " ")\n" delete compare-strings "Input methods:\n" "  " search-backward help-xref-button 0 help-input-method " (\"" 3 "\" in mode line)\n" "\n" "Character sets:\n" charset "  nothing specific to " help-character-set ": " charset-description "Coding systems:\n" coding-system help-coding-system " (`" coding-system-mnemonic "' in mode line):\n	" coding-system-doc-string coding-system-aliases "	(alias:" " " internal-temp-output-buffer-show #1=#:old-dir buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only #2=#:buf standard-output input-method-alist first l elt aliases] 9 (#$ . 65057) (list (read-language-name 'documentation "Describe language environment (default current choice): "))])
#@73 File name for the system's file of locale-name aliases, or nil if none.
(defvar locale-translation-file-name nil (#$ . 67770))
#@547 Alist of locale regexps vs the corresponding languages and coding systems.
Each element has this form:
  (LOCALE-REGEXP LANG-ENV CODING-SYSTEM)
The first element whose LOCALE-REGEXP matches the start of a
downcased locale specifies the LANG-ENV (language environment)
and CODING-SYSTEM corresponding to that locale.  If there is no
appropriate language environment, the element may have this form:
  (LOCALE-REGEXP . LANG-ENV)
In this case, LANG-ENV is one of generic language environments for an
specific encoding such as "Latin-1" and "UTF-8".
(defconst locale-language-names (purecopy '(("aa_DJ" . "Latin-1") ("aa" . "UTF-8") ("af" . "Latin-1") ("am" "Ethiopic" utf-8) ("an" . "Latin-9") ("ar" . "Arabic") ("az" . "UTF-8") ("be" "Belarusian" cp1251) ("bg" "Bulgarian" cp1251) ("bn" . "UTF-8") ("bo" . "Tibetan") ("br" . "Latin-1") ("bs" . "Latin-2") ("byn" . "UTF-8") ("ca" . "Latin-1") ("cs" "Czech" iso-8859-2) ("cy" "Welsh" iso-8859-14) ("da" . "Latin-1") ("de" "German" iso-8859-1) ("el" "Greek" iso-8859-7) ("en_IN" "English" utf-8) ("en" "English" iso-8859-1) ("eo" . "Esperanto") ("es" "Spanish" iso-8859-1) ("et" . "Latin-1") ("eu" . "Latin-1") ("fa" . "UTF-8") ("fi" . "Latin-1") ("fj" . "Latin-1") ("fo" . "Latin-1") ("fr" "French" iso-8859-1) ("fy" . "Latin-1") ("ga" . "Latin-1") ("gd" . "Latin-9") ("gez" "Ethiopic" utf-8) ("gl" . "Latin-1") ("gu" . "UTF-8") ("gv" . "Latin-1") ("he" "Hebrew" iso-8859-8) ("hi" "Devanagari" utf-8) ("hr" "Croatian" iso-8859-2) ("hu" . "Latin-2") ("id" . "Latin-1") ("is" . "Latin-1") ("it" "Italian" iso-8859-1) ("iw" "Hebrew" iso-8859-8) ("ja" "Japanese" euc-jp) ("ka" "Georgian" georgian-ps) ("kl" . "Latin-1") ("kn" "Kannada" utf-8) ("ko" "Korean" euc-kr) ("kw" . "Latin-1") ("la" . "Latin-1") ("lb" . "Latin-1") ("lg" . "Laint-6") ("lo" "Lao" utf-8) ("lt" "Lithuanian" iso-8859-13) ("lv" . "Latvian") ("mi" . "Latin-7") ("mk" "Cyrillic-ISO" iso-8859-5) ("ml" "Malayalam" utf-8) ("mn" . "UTF-8") ("mr" "Devanagari" utf-8) ("ms" . "Latin-1") ("mt" . "Latin-3") ("nb" . "Latin-1") ("ne" "Devanagari" utf-8) ("nl" "Dutch" iso-8859-1) ("no" . "Latin-1") ("oc" . "Latin-1") ("om_ET" . "UTF-8") ("om" . "Latin-1") ("pa" . "UTF-8") ("pl" . "Latin-2") ("pt" . "Latin-1") ("rm" . "Latin-1") ("ro" "Romanian" iso-8859-2) ("ru_RU" "Russian" iso-8859-5) ("ru_UA" "Russian" koi8-u) ("sa" . "Devanagari") ("se" . "UTF-8") ("sh" . "Latin-2") ("sid" . "UTF-8") ("sk" "Slovak" iso-8859-2) ("sl" "Slovenian" iso-8859-2) ("so_ET" "UTF-8") ("so" "Latin-1") ("sq" . "Latin-1") ("sr" . "Latin-2") ("st" . "Latin-1") ("sv" "Swedish" iso-8859-1) ("sw" . "Latin-1") ("ta" "Tamil" utf-8) ("te" . "UTF-8") ("tg" "Tajik" koi8-t) ("th" "Thai" tis-620) ("ti" "Ethiopic" utf-8) ("tig_ER" . "UTF-8") ("tl" . "Latin-1") ("tr" "Turkish" iso-8859-9) ("tt" . "UTF-8") ("uk" "Ukrainian" koi8-u) ("ur" . "UTF-8") ("uz_UZ@cyrillic" . "UTF-8") ("uz" . "Latin-1") ("vi" "Vietnamese" utf-8) ("wa" . "Latin-1") ("xh" . "Latin-1") ("yi" . "Windows-1255") ("zh_HK" . "Chinese-Big5") ("zh_TW" . "Chinese-Big5") ("zh_CN.GB2312" "Chinese-GB") ("zh_CN.GBK" "Chinese-GBK") ("zh_CN.GB18030" "Chinese-GB18030") ("zh_CN.UTF-8" . "Chinese-GBK") ("zh_CN" . "Chinese-GB") ("zh" . "Chinese-GB") ("zu" . "Latin-1") ("c$" . "ASCII") ("posix$" . "ASCII") ("ipa$" . "IPA") ("cz" . "Czech") ("ee" . "Latin-4") ("iw" . "Hebrew") ("sp" . "Cyrillic-ISO") ("su" . "Latin-1") ("jp" . "Japanese") ("chs" . "Chinese-GBK") ("cht" . "Chinese-BIG5") ("gbz" . "UTF-8") ("div" . "UTF-8") ("wee" . "Latin-2") ("wen" . "Latin-2"))) (#$ . 67904))
#@292 List of pairs of locale regexps and charset language names.
The first element whose locale regexp matches the start of a downcased locale
specifies the language name whose charset corresponds to that locale.
This language name is used if the locale is not listed in
`locale-language-names'.
(defconst locale-charset-language-names (purecopy '((".*8859[-_]?1\\>" . "Latin-1") (".*8859[-_]?2\\>" . "Latin-2") (".*8859[-_]?3\\>" . "Latin-3") (".*8859[-_]?4\\>" . "Latin-4") (".*8859[-_]?9\\>" . "Latin-5") (".*8859[-_]?14\\>" . "Latin-8") (".*8859[-_]?15\\>" . "Latin-9") (".*utf\\(?:-?8\\)?\\>" . "UTF-8") (".*@euro\\>" . "Latin-9"))) (#$ . 71433))
#@274 List of pairs of locale regexps and preferred coding systems.
The first element whose locale regexp matches the start of a downcased locale
specifies the coding system to prefer when using that locale.
This coding system is used if the locale specifies a specific charset.
(defconst locale-preferred-coding-systems (purecopy '((".*8859[-_]?1\\>" . iso-8859-1) (".*8859[-_]?2\\>" . iso-8859-2) (".*8859[-_]?3\\>" . iso-8859-3) (".*8859[-_]?4\\>" . iso-8859-4) (".*8859[-_]?9\\>" . iso-8859-9) (".*8859[-_]?14\\>" . iso-8859-14) (".*8859[-_]?15\\>" . iso-8859-15) (".*utf\\(?:-?8\\)?" . utf-8) (".*@euro" . iso-8859-15) ("koi8-?r" . koi8-r) ("koi8-?u" . koi8-u) ("tcvn" . tcvn) ("big5[-_]?hkscs" . big5-hkscs) ("big5" . big5) ("euc-?tw" . euc-tw) ("euc-?cn" . euc-cn) ("gb2312" . gb2312) ("gbk" . gbk) ("gb18030" . gb18030) ("ja.*[._]euc" . japanese-iso-8bit) ("ja.*[._]jis7" . iso-2022-jp) ("ja.*[._]pck" . japanese-shift-jis) ("ja.*[._]sjis" . japanese-shift-jis) ("jpn" . japanese-shift-jis))) (#$ . 72087))
#@183 Search for KEY in ALIST, which should be a list of regexp-value pairs.
Return the value corresponding to the first regexp that matches the
start of KEY, or nil if there is no match.
(defalias 'locale-name-match #[(key alist) "\306	\203+\204+\307	@@\310Q\n\306\311\312
\f#,\203$	@	A\211\204A)\207" [element alist key start string regexp nil "\\`\\(?:" "\\)" t string-match inhibit-changing-match-data] 5 (#$ . 73103)])
#@207 Whether charset names (strings) CHARSET1 and CHARSET2 are equivalent.
Matching is done ignoring case and any hyphens and underscores in the
names.  E.g. `ISO_8859-1' and `iso88591' both match `iso-8859-1'.
(defalias 'locale-charset-match-p #[(charset1 charset2) "\302\303\304#\302\303\304	#\305\306\211	\306\211\307&\307=\207" [charset1 charset2 replace-regexp-in-string "[-_]" "" compare-strings nil t] 8 (#$ . 73544)])
#@100 Coding system alist keyed on locale-style charset name.
Used by `locale-charset-to-coding-system'.
(defvar locale-charset-alist nil (#$ . 73977))
#@472 Find coding system corresponding to CHARSET.
CHARSET is any sort of non-Emacs charset name, such as might be used
in a locale codeset, or elsewhere.  It is matched to a coding system
first by case-insensitive lookup in `locale-charset-alist'.  Then
matches are looked for in the coding system list, treating case and
the characters `-' and `_' as insignificant.  The coding system base
is returned.  Thus, for instance, if charset "ISO8859-2",
`iso-latin-2' is returned.
(defalias 'locale-charset-to-coding-system #[(charset) "\306	\307#@\206?\n\310\2047\f\2037\311\f\211@@)\"\203.\312\f\211@@)!\211\202\f\211A@\210\202
\205>\313!*\207" [charset locale-charset-alist coding-system-alist c cs x assoc-string t nil locale-charset-match-p intern coding-system-base] 5 (#$ . 74130)])
#@130 Expand LOCALE according to `locale-translation-file-name', if possible.
For example, translate "swedish" into "sv_SE.ISO8859-1".
(defalias 'locale-translate #[(locale) "\203-\303\304!r	q\210\305\216\306\307!\210\310!\210\311\312\313\n!\314Q\307\315#\203*`\316 {\202+\n+\207\n\207" [locale-translation-file-name #1=#:temp-buffer locale generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) set-buffer-multibyte nil insert-file-contents re-search-forward "^" regexp-quote ":?[ 	]+" t line-end-position] 4 (#$ . 74936)])
#@1275 Set up multilingual environment for using LOCALE-NAME.
This sets the language environment, the coding system priority,
the default input method and sometimes other things.

LOCALE-NAME should be a string which is the name of a locale supported
by the system.  Often it is of the form xx_XX.CODE, where xx is a
language, XX is a country, and CODE specifies a character set and
coding system.  For example, the locale name "ja_JP.EUC" might name
a locale for Japanese in Japan using the `japanese-iso-8bit'
coding-system.  The name may also have a modifier suffix, e.g. `@euro'
or `@cyrillic'.

If LOCALE-NAME is nil, its value is taken from the environment
variables LC_ALL, LC_CTYPE and LANG (the first one that is set).

The locale names supported by your system can typically be found in a
directory named `/usr/share/locale' or `/usr/lib/locale'.  LOCALE-NAME
will be translated according to the table specified by
`locale-translation-file-name'.

If FRAME is non-nil, only set the keyboard coding system and the
terminal coding system for the terminal of that frame, and don't
touch session-global parameters like the language environment.

See also `locale-charset-language-names', `locale-language-names',
`locale-preferred-coding-systems' and `locale-coding-system'.
(defalias 'set-locale-environment #[(&optional locale-name frame) "\306\307@!\204A\211\204@)\n\211\2044\310\f\2033G\311U\2033\312\f\211A@
\"\202)\203U\313!\n\203F89\314\315\"\203U\316\317\311\"!:8\206q\312\320
\";\321;G!\203l\202p\313;!)<\203F
\227\322=\"\322>\"\323\324\325!!\322?\"\206\242\205\242\314\326\"\205\242\327\317\330\"! @A\211B:\203\302 \206\270BA@ B@B\202\313B\204\313AB@\331>\203\346 \203\346\332 !\203\346\333 @\" B\203&

\204\364\334B!\210\324\335!\203
\336B 
#\210 \206

\337B\340\"@\211C\203
\341C
\"\210)
\204&
\337B\342\"@D
\204E
 \203E
\343 D\"\204E
\344 !\210 E D,F\345=\203|
\346\347!\203|
\316\350\351'\"!G\332G!\203{

\204k
GD\341G
\"\210\352G
\"\210GH)F\353=\203\234
\354HI\204\234
\312\355
\"\356\232\203\234
\352\354!\210\341\354!\210
\204\357
\357\360!00\203\306
0\361\232\203\271
\362J\202\356
0\363\232\203\356
\364J\202\356
\365\f\203\337
G\311U\203\337
\312\f\211A@
\"\202\310
)\203\356
\322\366\"\206\354
\364J*)\367\207" [files locale-translation-file-name locale-name locale vars frame ("/usr/share/X11/locale/locale.alias" "/usr/lib/X11/locale/locale.alias" "/usr/X11R6/lib/X11/locale/locale.alias" "/usr/openwin/lib/locale/locale.alias" "/usr/share/locale/locale.alias") file-exists-p ("LC_ALL" "LC_CTYPE" "LANG") 0 getenv locale-translate string-match "^[a-z][a-z]" intern match-string "LC_MESSAGES" zerop locale-name-match coding-system-eol-type default-value buffer-file-coding-system "\\.\\([^@]+\\)" locale-charset-to-coding-system 1 (0 1 2 unix dos mac) coding-system-p coding-system-change-eol-conversion set-language-environment enable-multibyte-characters set-display-table-and-terminal-coding-system get-language-info coding-system set-keyboard-coding-system coding-priority coding-system-equal prefer-coding-system windows-nt boundp w32-ansi-code-page format "cp%d" set-terminal-coding-system darwin utf-8 "TERM_PROGRAM" "Apple_Terminal" locale-info paper (216 279) letter (210 297) a4 ("LC_ALL" "LC_PAPER" "LANG") (("c$" . letter) ("posix$" . letter) (".._us" . letter) (".._pr" . letter) (".._ca" . letter) ("enu$" . letter) ("esu$" . letter) ("enc$" . letter) ("frc$" . letter)) nil system-messages-locale system-time-locale current-iso639-language msglocale woman-locale locale-language-names locale-charset-language-names locale-preferred-coding-systems default-eol-type charset-language-name language-name kcs locale-coding-system default-sendmail-coding-system system-type code-page-coding default-file-name-coding-system window-system ps-paper-type] 8 (#$ . 75524) "sSet environment for locale: "])
(put 'char-code-property-table 'char-table-extra-slots 5)
#@1057 Define NAME as a character code property given by TABLE.
TABLE is a char-table of purpose `char-code-property-table' with
these extra slots:
  1st: NAME.
  2nd: Function to call to get a property value of a character.
    It is called with three arguments CHAR, VAL, and TABLE, where
    CHAR is a character, VAL is the value of (aref TABLE CHAR).
  3rd: Function to call to put a property value of a character.
    It is called with the same arguments as above.
  4th: Function to call to get a description string of a property value.
    It is called with one argument VALUE, a property value.
  5th: Data used by the above functions.

TABLE may be a name of file to load to build a char-table.  The
file should contain a call of `define-char-code-property' with a
char-table of the above format as the argument TABLE.

TABLE may also be nil, in which case no property value is pre-assigned.

Optional 3rd argument DOCSTRING is a documentation string of the property.

See also the documentation of `get-char-code-property' and
`put-char-code-property'.
(defalias 'define-char-code-property #[(name table &optional docstring) "9\204\n\305\306\"\210\307	!\203)\310	!\311=\203!\312	\313\"=\2043\305\314	\"\210\2023	;\2043\305\315	\"\210	;\203<\316	!\n\236\211\203K	\241\210\202Q	B\nB)\317\320\316\f!#\207" [name table char-code-property-alist slot docstring error "Not a symbol: %s" char-table-p char-table-subtype char-code-property-table char-table-extra-slot 0 "Invalid char-table: %s" "Not a char-table nor a file name: %s" purecopy put char-code-property-documentation] 6 (#$ . 79552)])
#@224 Char-table containing a property list of each character code.
This table is used for properties not listed in `char-code-property-alist'.
See also the documentation of `get-char-code-property' and
`put-char-code-property'.
(defvar char-code-property-table (make-char-table 'char-code-property-table) (#$ . 81170))
#@47 Return the value of CHAR's PROPNAME property.
(defalias 'get-char-code-property #[(char propname) "\305!\211\203%\306	\307\"\310\n!\203\n	H	#\202!\311	\")\202+\312\fH\")\207" [propname table func char char-code-property-table unicode-property-table-internal char-table-extra-slot 1 functionp get-unicode-property-internal plist-get] 5 (#$ . 81490)])
#@111 Store CHAR's PROPNAME property with VALUE.
It can be retrieved with `(get-char-code-property CHAR PROPNAME)'.
(defalias 'put-char-code-property #[(char propname value) "\306!\211\203&\307	\310\"\311\n!\203\n\f	#\210\202\"\312	\f#\210)\202A
H\f\313\f\f#\211
\f=\204@

I\210*\f)\207" [propname table func char value char-code-property-table unicode-property-table-internal char-table-extra-slot 2 functionp put-unicode-property-internal plist-put plist x] 5 (#$ . 81860)])
#@127 Return a description string of character property PROP's value VALUE.
If there's no description string for VALUE, return nil.
(defalias 'char-code-property-description #[(prop value) "\304!\211\205\305	\306\"\307\n!\205\n!))\207" [prop table func value unicode-property-table-internal char-table-extra-slot 3 functionp] 4 (#$ . 82357)])
(defconst iso-2022-control-alist '((27 . "ESC") (14 . "SO") (15 . "SI") (142 . "SS2") (143 . "SS3") (155 . "CSI")))
#@70 Return a pretty description of STR that is encoded by CODING-SYSTEM.
(defalias 'encoded-string-description #[(str coding-system) "\302!\303	\203\304	!\305=\203\306\202\307\310#\207" [str coding-system string-as-unibyte mapconcat coding-system-type iso-2022 #[(x) "	\236A\206\302\303\"\207" [x iso-2022-control-alist format "#x%02X"] 3] #[(x) "\301\302\"\207" [x format "#x%02X"] 3] " "] 4 (#$ . 82824)])
#@201 Encode CHAR by CODING-SYSTEM and return the resulting string.
If CODING-SYSTEM can't safely encode CHAR, return nil.
The 3rd optional argument CHARSET, if non-nil, is a charset preferred
on encoding.
(defalias 'encode-coding-char #[(char coding-system &optional charset) "\306\307!!\306\307\211\"!\310	!\311\211\311\211:\203+@\312=\203+	\202\206\313!>\205\206\203K\314\315\316\317	%\210\314\315\320\317\n%\210\321	\"\211G\321\n\"\211G\315V\203\201\fSH
SHU\203\201SS\202_
\315O.\207" [char str1 str2 found enc1 enc2 string-as-multibyte string find-coding-systems-string nil undecided coding-system-base put-text-property 0 1 charset 2 encode-coding-string i1 i2 coding-system] 7 (#$ . 83249)])
#@136 Non-nil if Unify-8859-On-Encoding mode is enabled.
See the command `unify-8859-on-encoding-mode' for a description of this minor mode.
(custom-declare-variable 'unify-8859-on-encoding-mode nil '(#$ . 84006) :set 'custom-set-minor-mode :initialize 'custom-initialize-default :group 'mule :type 'boolean)
#@42 Exists only for backwards compatibility.
(defalias 'unify-8859-on-encoding-mode #[(&optional arg) "\303 	\304=\203\n?\202\305	!\306V\307\310\n\203\311\202\312\"\210\313\314!\203D\315\302!\210\303 \2037\303 \232\203D\316\317\n\203A\320\202B\321\"\210)\322 \210\n\207" [#1=#:last-message arg unify-8859-on-encoding-mode current-message toggle prefix-numeric-value 0 run-hooks unify-8859-on-encoding-mode-hook unify-8859-on-encoding-mode-on-hook unify-8859-on-encoding-mode-off-hook called-interactively-p any customize-mark-as-set message "Unify-8859-On-Encoding mode %sabled" "en" "dis" force-mode-line-update] 3 (#$ . 84315) (list (or current-prefix-arg 'toggle))])
(byte-code "\301\302\303\304\300!\205\n\303\211%\210\305\302\306\307#\210\310\311\303\312\313\314\315\316\317\320\321\322&\207" [unify-8859-on-encoding-mode-map add-minor-mode unify-8859-on-encoding-mode nil boundp make-obsolete "don't use it." "23.1" custom-declare-variable unify-8859-on-decoding-mode "Non-nil if Unify-8859-On-Decoding mode is enabled.\nSee the command `unify-8859-on-decoding-mode' for a description of this minor mode." :set custom-set-minor-mode :initialize custom-initialize-default :group mule :type boolean] 12)
#@42 Exists only for backwards compatibility.
(defalias 'unify-8859-on-decoding-mode #[(&optional arg) "\303 	\304=\203\n?\202\305	!\306V\307\310\n\203\311\202\312\"\210\313\314!\203D\315\302!\210\303 \2037\303 \232\203D\316\317\n\203A\320\202B\321\"\210)\322 \210\n\207" [#1=#:last-message arg unify-8859-on-decoding-mode current-message toggle prefix-numeric-value 0 run-hooks unify-8859-on-decoding-mode-hook unify-8859-on-decoding-mode-on-hook unify-8859-on-decoding-mode-off-hook called-interactively-p any customize-mark-as-set message "Unify-8859-On-Decoding mode %sabled" "en" "dis" force-mode-line-update] 3 (#$ . 85544) (list (or current-prefix-arg 'toggle))])
(byte-code "\301\302\303\304\300!\205\n\303\211%\210\305\302\306\307#\207" [unify-8859-on-decoding-mode-map add-minor-mode unify-8859-on-decoding-mode nil boundp make-obsolete "don't use it." "23.1"] 6)
(defvar nonascii-insert-offset 0)
(make-obsolete-variable 'nonascii-insert-offset "do not use it." "23.1")
(defvar nonascii-translation-table nil)
(make-obsolete-variable 'nonascii-translation-table "do not use it." "23.1")
#@48 Alist of cached (CHAR-NAME . CHAR-CODE) pairs.
(defvar ucs-names nil (#$ . 86661))
#@70 Return alist of (CHAR-NAME . CHAR-CODE) pairs cached in `ucs-names'.
(defalias 'ucs-names #[nil "\206\241\306\307\310\311\211\211\211\f\211
\311\211\203^@\211@A\fX\203U\312\f\302\"\211\203?\n\fB	B\312\f\313\"\211\203N\n\fB	B\fT\211\202+A\211\204*\f\311\211\203\233@\211@A\fX\203\222\312\f\302\"\211\203\213\n\fB	B\fT\211\202wA\211\204j*	\211.\207" [ucs-names names name end c gc-cons-threshold ((0 . 13311) (19904 . 19967) (40960 . 55295) (64256 . 65533)) ((65536 . 79103) (92160 . 92735) (110592 . 110847) (118784 . 131071) (917504 . 918015)) 10000000 nil get-char-code-property old-name upper-ranges bmp-ranges range --dolist-tail--] 8 (#$ . 86750)])
#@671 Read a character by its Unicode name or hex number string.
Display PROMPT and read a string that represents a character by its
Unicode property `name' or `old-name'.

This function returns the character as a number.

You can type a few of the first letters of the Unicode name and
use completion.  If you type a substring of the Unicode name
preceded by an asterisk `*' and use completion, it will show all
the characters whose names include that substring, not necessarily
at the beginning of the name.

This function also accepts a hexadecimal number of Unicode code
point or a number in hash notation, e.g. #o21430 for octal,
#x2318 for hex, or #10r8984 for decimal.
(defalias 'read-char-by-name #[(prompt) "\306\307	\310\"\311\n\312\306\313
\f#,\203 \314\n\315\"\202?\316\n\312\306\313
\f#,\2038\317\n!\202?\320\n\321 \306#A*\207" [completion-ignore-case prompt input start string regexp t completing-read #[(string pred action) "\303=\203\304\207\305\306 	\n$\207" [action string pred metadata (metadata (category . unicode-name)) complete-with-action ucs-names] 5] "\\`[0-9a-fA-F]+\\'" nil string-match string-to-number 16 "\\`#" read assoc-string ucs-names inhibit-changing-match-data] 4 (#$ . 87476)])
(byte-code "\301\302\303\304#\210\305\302\303\306#\210\307\310\303#\207" [ctl-x-map defalias ucs-insert insert-char nil make-obsolete "24.3" define-key "8
"] 4)