egg-980217.

diff --git a/AUTHORS b/AUTHORS
index 162e024..bae7fd0 100644 (file)
--- a/AUTHORS
+++ b/AUTHORS
@@ -1,3 +1,9 @@
+KAWABATA, Taichi
+       Menudiag improvement.
+
+MORIOKA Tomohiko  <morioka@jaist.ac.jp>
+       Use of custom.
+
 NIIBE Yutaka <gniibe@mri.co.jp>
        Design a part of ITS programming.
        Wrote ITS:

diff --git a/ChangeLog b/ChangeLog
index 832d252..88dda3c 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,190 @@
+1998-02-17  NIIBE Yutaka  <gniibe@mri.co.jp>
+
+       * Makefile (SRCS): Add its/pinyin.el, its/hangul.el and
+       its-keydef.el.
+
+       * egg-com.el (ccl-encode-fixed-euc-kr): Fixed the name.
+       
+1998-02-17  KATAYAMA Yoshio <kate@pfu.co.jp>
+       
+       * its-keydef.el: New file.
+       * its/hangul.el, its/pinyin.el: New version.
+
+       * egg/wnnrpc.el (load-library "egg/wnn"): Comment it out.
+       (wnnrpc-get-error-message): Support multiple languages.
+       (wnnrpc-call-with-environment): Chinese support.
+
+       * egg/wnn.el (wnn-support-languages): New const.
+       (<env>): Add <server-type>, <dic-set>, and <rev-flag>.
+       (wnnenv-get-server-type, wnnenv-get-dictionary-set,
+        wnnenv-get-reverse-flag): New substs.
+       (wnnenv-get-daibunsetsu-info, wnnenv-set-daibunsetsu-info): Changed.
+       (wnn-server): Removed.
+       (wnn-jserver, wnn-cserver, wnn-tserver, wnn-kserver): New custom.
+       (wnn-server-info-list): New const.
+       (wnn-get-server-info): New function.
+       (wnn-server-locale, wnn-server-type, wnn-server-port,
+        wnn-server-stream-name, wnn-server-buffer-name,
+        wnn-server-coding-system, wnn-server-hostname): New substs.
+       (wnn-start-conversion): Add new arguments.
+       (wnn-uniq-candidates): Initialize 'n'.
+       (wnn-change-bunsetsu-length): Simplefied.
+       (wnn-change-bunsetsu-length): Call renbunsetsu-conversion,
+       instead.
+       (wnn-fini, wnn-comm-sentinel): back to 971009 version.
+       (wnn-jserver-port): Removed.
+       (wnn-open): Argument change.  Support languages.
+
+       (wnn-dictionary-specification): Removed.
+       (wnn-dictionary-specification-list): New variable.
+       (wnn-get-dic-spec, wnn-dic-spec-dic-set, wnn-dic-spec-reverse,
+       wnn-dic-spec-name, wnn-dic-spec-param, wnn-dic-spec-fuzokugo,
+        wnn-dic-spec-dic-list): New substs.
+       (wnn-get-environment): Rewrite.
+       (wnn-create-environment): Rewrite.
+
+       (egg-activate-wnn): Support languages.
+
+       * egg/sj3rpc.el (load-library "egg/sj3"): Don't load it.
+
+       * egg/sj3.el (sj3-support-languages): New const.
+       (sj3-start-conversion, sj3-fini): Add lang.
+       (sj3-change-bunsetsu-length): Simplified.
+       (egg-activate-sj3): Support language.
+
+       * its/hira.el (its/hira): Packagefy. (?)
+       (its-hira-map): Add language spec.  Move here the escape keys
+       ("Z", "~").
+
+       * leim-list-egg.el ("chinese-gb-egg-wnn-py", "chinese-gb-egg-wnn-zy",
+        "chinese-cns-egg-wnn-py", "chinese-cns-egg-wnn-zy",
+        "korean-egg-wnn"): New input methods.
+
+       * its.el (its-current-language): New Local Variables.
+       <map>: Change the structure.  Add <language>.
+       (its-get-language): New substitution.
+       (its-set-indicator): Removed.
+       (its-get-indicator, its-get-start-state): New implementation.
+       (its-reset-start-state): Removed.
+       (its-buffer-ins/del-SYL): Add new properties, its-map and its-lang.
+       (its-exit-mode-internal): Change for its-map and its-lang.
+       (its-in-fence-p): New function.
+
+       ("its-keydef.el"): Load it.
+
+       (its-select-map-menu): Removed.
+       (its-select-map-from-menu): Removed.
+       (its-select-hiragana, its-select-katakana, its-select-downcase,
+       its-select-upcase, its-select-zenkaku-downcase,
+       its-select-zenkaku-upcase, its-select-map, its-zenkaku-escape,
+       its-hankaku-escape): Removed.
+
+       (define-its-state-machine): Rewrite.
+       (define-its-compiled-map): New macro.
+       (its-define-state-machine): Removed.
+
+       (its-forward-SYL): Cleanup.
+
+       (its-beginning-of-input-buffer): Fix.
+       (its-end-of-input-buffer): Likewise.
+
+       * egg-com.el (egg-fixed-euc, egg-mb-euc): New Local Variables.
+       (ccl-decode-fixed-euc-kr, ccl-encode-fixed-euc-kr): New CCLs.
+       (fixed-euc-kr): New coding system.
+       (comm-format-mb-string, comm-format-u16-string): Support EUC-KR.
+       (comm-unpack-u16-string, comm-unpack-mb-string): Likewise.
+
+       * egg-cnv.el (egg-get-bunsetsu-info): New function.
+       (egg-conversion-backend-alist, egg-finalize-backend-alist): 
+       New Variables.
+       Make egg-conversion-backend buffer local.
+       (egg-set-current-backend): New function.
+       (egg-initialize-backend): Call egg-set-current-backend.
+       (egg-start-conversion): Add new argument LANGUAGE.
+       (egg-finalize-backend): Finalize for all backend(s).
+       (egg-set-conversion-backend-internal): New Macro.
+       (egg-convert-region): Support multiple languages in the region.
+       (egg-separate-languages, egg-char-to-language, egg-next-part-lang,
+       egg-next-chinese-lang): New functions.
+       (egg-insert-bunsetsu-list): Change the meaning of last argument.
+       (egg-shrink-bunsetsu): Simplified.  Just call egg-enlarge-bunsetsu.
+       (egg-enlarge-bunsetsu): Support shrink.
+
+       (egg-decide-bunsetsu, egg-next-candidate, egg-select-candidate): 
+       Use egg-get-bunsetsu-info.
+
+       (egg-insert-bunsetsu): The property now includes
+       egg-conversion-backend.
+
+       * egg.el: Don't load its/hira and don't set its-current-map.
+
+       * egg.el (egg-default-language, egg-support-languages): New Variables.
+       (egg-last-method-name, egg-mode-line-title): New Local Variables.
+       (egg-set-mode-line-title, egg-check-language): New functions.
+       (egg-set-support-languages): New function.
+       (egg-mode): Final processing: call its-exit-mode, call
+       egg-exit-conversion.
+       Changing the arguments, remember last input method.
+
+       Bug fix. Don't set its-hira-period and its-hira-comma.
+
+1998-02-17  KAWABATA, Taichi
+
+       * menudiag.el (menudiag-mode-map): New binds for new commands.
+       (menudiag-beginning-of-items, menudiag-end-of-items): New commands.
+       (menudiag-make-menu-formatted-string): Bug fix.  Use 
+       menudiag-item-num-to-char.
+       (menudiag-goto-item): Rewrite.  Better user interface.
+       (menudiag-char-to-item-num, menudiag-item-num-to-char): New
+       functions.
+
+1998-02-07  MORIOKA Tomohiko  <morioka@jaist.ac.jp>
+
+       * leim-list-egg.el: Delete autoload setting for `egg-mode'.
+       Delete input method registration for "japanese-egg".
+
+       * egg.el: Comment out setting for Wnn.
+
+       * leim-list-egg.el: Add autoload setting for
+       `egg-activate-{wnn|sj3}'.
+
+       * egg/sj3.el (egg-activate-sj3): Add DOC-string.
+
+       * egg/sj3.el (egg-activate-sj3): New function.
+       Require egg.
+       Load egg/sj3rpc.el.
+
+       * egg/wnn.el (egg-activate-wnn): New function.
+       Require egg.
+       Load egg/wnnrpc.el.
+
+1998-02-07  MORIOKA Tomohiko  <morioka@jaist.ac.jp>
+
+       * leim-list-egg.el (japanese-egg-wnn): New input method.
+       (japanese-egg-sj3): New input method.
+
+1997-11-20  MORIOKA Tomohiko  <morioka@jaist.ac.jp>
+
+       * leim-list-egg.el: Rename `egg-ja' -> `japanese-egg'.
+
+1997-11-20  MORIOKA Tomohiko  <morioka@jaist.ac.jp>
+
+       * egg/wnn.el (wnn): New group.
+       (wnn-server): Use `defcustom'.
+       (wnn-usr-dic-dir): Use `defcustom'.
+
+       * egg.el (egg): New group.
+
+1997-11-20  MORIOKA Tomohiko  <morioka@jaist.ac.jp>
+
+       * menudiag.el (menudiag-mode-map): Swap binding for left and
+       right.
+
+       * egg.el (egg-toroku-region): `wnn-get-environment' requires
+       dictionary-specification.
+
+       * leim-list-egg.el: add autoload setting for egg-mode.
+
 1997-11-03  KATAYAMA Yoshio <kate@pfu.co.jp>
 
        * euc-cn.el: New file.  Original name was yincoding.el.

diff --git a/Makefile b/Makefile
index fb6696f..94358ef 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -21,6 +21,9 @@ ETCS = Makefile leim-list-egg.el AUTHORS ChangeLog README TODO docomp.el
 
 SRCS = menudiag.el its.el egg.el \
        its/hira.el \
+       its/pinyin.el \
+       its/hangul.el \
+       its-keydef.el \
        egg-mlh.el egg-cnv.el egg-com.el \
        euc-cn.el \
        egg/sj3.el egg/sj3rpc.el \

diff --git a/egg-cnv.el b/egg-cnv.el
index 249ff9d..76a748b 100644 (file)
--- a/egg-cnv.el
+++ b/egg-cnv.el
@@ -1,21 +1,22 @@
 ;;; egg-cnv.el --- Conversion Backend in Egg Input Method Architecture
 
-;; Copyright (C) 1997 Mule Project,
+;; Copyright (C) 1997, 1998 Mule Project,
 ;; Powered by Electrotechnical Laboratory, JAPAN.
 ;; Project Leader: Satoru Tomura <tomura@etl.go.jp>
 
 ;; Author: NIIBE Yutaka <gniibe@mri.co.jp>
+;;         KATAYAMA Yoshio <kate@pfu.co.jp>
 ;; Maintainer: NIIBE Yutaka <gniibe@mri.co.jp>
 ;; Keywords: mule, multilingual, input method
 
 ;; This file will be part of GNU Emacs (in future).
 
-;; GNU Emacs is free software; you can redistribute it and/or modify
+;; EGG is free software; you can redistribute it and/or modify
 ;; it under the terms of the GNU General Public License as published by
 ;; the Free Software Foundation; either version 2, or (at your option)
 ;; any later version.
 
-;; GNU Emacs is distributed in the hope that it will be useful,
+;; EGG is distributed in the hope that it will be useful,
 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 ;; GNU General Public License for more details.
@@ -31,15 +32,35 @@
 ;;; Code:
 
 (defsubst egg-bunsetsu-info () 'intangible)
+
+(defun egg-get-bunsetsu-info (p)
+  (let ((info (get-text-property p (egg-bunsetsu-info))))
+    (cond
+     ((consp info)
+      (setq egg-conversion-backend (car info))
+      (cdr info)))))
 ;;
 
+(defvar egg-conversion-backend-alist nil)
+(make-variable-buffer-local 'egg-conversion-backend-alist)
 (defvar egg-conversion-backend nil)
+(make-variable-buffer-local 'egg-conversion-backend)
+
+(defvar egg-finalize-backend-alist nil)
 
-(defun egg-initialize-backend ()
+(defun egg-set-current-backend (language)
+  (let ((backend (assoc lang  egg-conversion-backend-alist)))
+    (if (null backend)
+       (error "%S is not supported" lang)
+      (setq egg-conversion-backend (cdr backend)))))
+
+(defun egg-initialize-backend (language)
+  (egg-set-current-backend language)
   (funcall (aref egg-conversion-backend 0)))
 
-(defun egg-start-conversion (yomi-string)
-  (funcall (aref egg-conversion-backend 1) yomi-string))
+(defun egg-start-conversion (yomi-string language)
+  (egg-set-current-backend language)
+  (funcall (aref egg-conversion-backend 1) yomi-string language))
 (defun egg-get-bunsetsu-converted (bunsetsu-info)
   (funcall (aref egg-conversion-backend 2) bunsetsu-info))
 (defun egg-get-bunsetsu-source (bunsetsu-info)
@@ -60,7 +81,29 @@
   (funcall (aref egg-conversion-backend 10) bunsetsu-info-list))
 
 (defun egg-finalize-backend ()
-  (funcall (aref egg-conversion-backend 11)))
+  (let ((alist egg-finalize-backend-alist))
+    (while alist
+      (funcall (car (car (car alist))) (cdr (car (car alist))))
+      (setq alist (cdr alist)))))
+
+(defmacro egg-set-conversion-backend-internal (backend langs &optional force)
+  `(let ((l ,langs) pair)
+     (while l
+       (setq pair (assoc (car l) egg-conversion-backend-alist))
+       (if (null pair)
+          (setq egg-conversion-backend-alist 
+                (cons (cons (car l) ,backend)
+                      egg-conversion-backend-alist))
+        ,(if force `(setcdr pair ,backend)))
+       (setq pair (cons (aref ,backend 11) (car l)))
+       (if (null (assoc pair egg-finalize-backend-alist))
+          (setq egg-finalize-backend-alist
+                (cons (list pair) egg-finalize-backend-alist)))
+       (setq l (cdr l)))))
+
+(defun egg-set-conversion-backend (backend curent-langs other-langs)
+  (egg-set-conversion-backend-internal backend curent-langs t)
+  (egg-set-conversion-backend-internal backend other-langs))
 \f
 (defvar egg-conversion-open "|")
 (defvar egg-conversion-close "|")
@@ -69,25 +112,112 @@
 ;;
 (defun egg-convert-region (start end)
   (interactive "r")
-  (let ((bunsetsu-info-list
-        (egg-start-conversion (buffer-substring start end)))
-       p)
-    (delete-region start end)
-    (setq p (point))
-    (insert egg-conversion-open)
-    (put-text-property p (point) 'egg-start t)
-    (if egg-conversion-face
-       (put-text-property p (point) 'invisible t))
-    ;;
-    (egg-insert-bunsetsu-list bunsetsu-info-list)
-    ;;
+  (let (bunsetsu-info-list lang contin p s e)
+    (save-restriction
+      (narrow-to-region start end)
+      (goto-char start)
+      (insert egg-conversion-open)
+      (put-text-property start (point) 'egg-start t)
+      (if egg-conversion-face
+          (put-text-property start (point) 'invisible t))
+      (setq start (point))
+      (egg-separate-languages start (point-max))
+      (goto-char start)
+      (while (< (point) (point-max))
+       (setq lang (get-text-property (point) 'egg-lang))
+       (setq s (point)
+             e (next-single-property-change s 'egg-lang nil (point-max)))
+       (setq bunsetsu-info-list
+             (egg-start-conversion (buffer-substring s e) lang))
+       (setq contin (< e (point-max)))
+       (delete-region s e)
+       (egg-insert-bunsetsu-list bunsetsu-info-list
+                                 (if (< (point) (point-max)) 'contine t))))
     (setq p (point))
     (insert egg-conversion-close)
     (put-text-property p (point) 'egg-end t)
     (if egg-conversion-face
        (put-text-property p (point) 'invisible t))
-    (goto-char (1+ start))))
+    (goto-char start)))
+
+(defun egg-separate-languages (start end)
+  (let (lang last-lang last-chinese p l c cset)
+    (goto-char start)
+    (while (< (point) end)
+      (setq p (next-single-property-change (point) 'its-lang nil end))
+      (cond
+       ((get-text-property (point) 'its-lang)
+       (goto-char p))
+       ((setq l (egg-chinese-syllable (buffer-substring (point) p)))
+       (setq p (point))
+       (goto-char (+ (point) l))
+       (put-text-property p (point) 'its-lang "Chinese"))
+       ((progn
+         (setq c (following-char)
+               cset (char-charset c))
+         (eq cset 'chinese-sisheng))
+       (setq p (point))
+       (forward-char)
+       (put-text-property p (point) 'its-lang "Chinese"))
+       ((eq cset 'ascii)
+       (forward-char))
+       (t
+       (setq p (point))
+       (forward-char)
+       (put-text-property p (point) 'its-lang (egg-char-to-language c)))))
+    (goto-char start)
+    (while (< (point) end)
+      (setq lang (get-text-property (point) 'its-lang))
+      (cond
+       ((null lang)
+       (setq lang (or last-lang
+                      (egg-next-part-lang end))))
+       ((equal lang "Chinese")
+       (setq lang (or last-chinese
+                      (egg-next-chinese-lang end)))))
+      (setq last-lang lang)
+      (if (or (equal lang "Chinese-GB") (equal lang "Chinese-CNS"))
+         (setq last-chinese lang))
+      (setq p (point))
+      (goto-char (next-single-property-change (point) 'its-lang nil end))
+      (set-text-properties p (point) (list 'egg-lang lang)))))
+
+(defun egg-char-to-language (c)
+  (let ((charset (char-charset c))
+       (list language-info-alist))
+    (while (and list
+               (null (memq charset (assq 'charset (car list)))))
+      (setq list (cdr list)))
+    (car (car list))))
+
+(defun egg-next-part-lang (end)
+  (let* ((p (next-single-property-change (point) 'its-lang nil end))
+        (lang (get-text-property p 'its-lang)))
+    (if (equal lang "Chinese")
+       (egg-next-chinese-lang end)
+      (or lang
+         its-current-language
+         egg-default-language))))
 
+(defun egg-next-chinese-lang (end)
+  (let (p lang)
+    (setq p (point))
+    (while (and (< p end) (null lang))
+      (setq p (next-single-property-change p 'its-lang nil end))
+      (setq lang (get-text-property p 'its-lang))
+      (if (null (or (equal lang "Chinese-GB")
+                   (equal lang "Chinese-CNS")))
+         (setq lang nil)))
+    (cond
+     (lang lang)
+     ((or (equal its-current-language "Chinese-GB")
+         (equal its-current-language "Chinese-CNS"))
+      its-current-language)
+     ((or (equal egg-default-language "Chinese-GB")
+         (equal egg-default-language "Chinese-CNS"))
+      egg-default-language)
+     (t "Chinese-GB"))))
+\f
 (defvar egg-conversion-face nil)
 (defvar egg-conversion-map
   (let ((map (make-sparse-keymap))
@@ -128,22 +258,23 @@
   (let ((bunsetsu (egg-get-bunsetsu-converted bunsetsu-info))
        (p (point)))
     (insert bunsetsu)
-    (if (not last)
+    (if (null (eq last t))
        (insert egg-conversion-separator))
     (add-text-properties p (point)
                         (list 'face      egg-conversion-face
                               'local-map egg-conversion-map
-                              (egg-bunsetsu-info) bunsetsu-info
+                              (egg-bunsetsu-info) (cons egg-conversion-backend
+                                                        bunsetsu-info)
                               'egg-bunsetsu-last last))))
 
-(defun egg-insert-bunsetsu-list (bunsetsu-info-list &optional contin)
+(defun egg-insert-bunsetsu-list (bunsetsu-info-list &optional last)
   (let ((l bunsetsu-info-list)
        bunsetsu-info bunsetsu p)
     (while l
       (setq bunsetsu-info (car l)
            l (cdr l)
            p (point))
-      (egg-insert-bunsetsu bunsetsu-info (and (null l) (null contin))))))
+      (egg-insert-bunsetsu bunsetsu-info (and (null l) last)))))
 
 (defun egg-backward-bunsetsu (n)
   (interactive "p")
@@ -170,56 +301,59 @@
 (defun egg-get-previous-bunsetsu (p)
   (if (get-text-property (1- p) 'egg-start)
       nil
-    (get-text-property (- p 2) (egg-bunsetsu-info))))
+    (egg-get-bunsetsu-info (- p 2))))
+
+(defun egg-separate-characters (str)
+  (let* ((v (string-to-vector str))
+        (len (length v))
+        (i 0) (j 0) m n (nchar 0))
+    (while (< i len)
+      (if (setq n (egg-chinese-syllable str j))
+         (setq m (chars-in-string (substring str j (+ j n))))
+       (setq m 1 n (char-bytes (aref v i))))
+      (put-text-property j (+ j n) 'egg-char-size n str)
+      (setq nchar (1+ nchar) i (+ i m) j (+ j n)))
+    nchar))
 
 (defun egg-shrink-bunsetsu (n)
   (interactive "p")
-  (let* ((b0 (egg-get-previous-bunsetsu (point)))
-        (b1 (get-text-property (point) (egg-bunsetsu-info)))
-        (last (get-text-property (point) 'egg-bunsetsu-last))
-        (slen (chars-in-string (egg-get-bunsetsu-source b1)))
-        (newlen (- slen n))
-        b2 bunsetsu-info-list beep)
-    (if (< newlen 1)
-       (setq beep t
-             newlen 1))
-    (if (not last)
-       (let ((p2 (save-excursion (forward-char) (point))))
-         (setq b2 (get-text-property p2 (egg-bunsetsu-info))
-               last (get-text-property p2 'egg-bunsetsu-last))))
-    (setq bunsetsu-info-list (egg-change-bunsetsu-length b0 b1 b2 newlen))
-    (delete-region (point)
-                  (progn (forward-char) (if b2 (forward-char)) (point)))
-    (let ((p (point)))
-      (egg-insert-bunsetsu-list bunsetsu-info-list (not last))
-      (goto-char p))
-    (if beep
-       (ding))))
+  (egg-enlarge-bunsetsu (- n)))
 
 (defun egg-enlarge-bunsetsu (n)
   (interactive "p")
   (let* ((b0 (egg-get-previous-bunsetsu (point)))
-        (b1 (get-text-property (point) (egg-bunsetsu-info)))
+        (b1 (egg-get-bunsetsu-info (point)))
+        (s1 (egg-get-bunsetsu-source b1))
+        (s1len (egg-separate-characters s1))
+        (s2len 0)
+        (chrs (length s1))
         (last (get-text-property (point) 'egg-bunsetsu-last))
-        (slen (chars-in-string (egg-get-bunsetsu-source b1)))
-        (newlen (+ slen n))
-        b2 maxlen bunsetsu-info-list beep)
+        b2 s2 source bunsetsu-info-list beep)
     (if (not last)
        (let ((p2 (save-excursion (forward-char) (point))))
-         (setq b2 (get-text-property p2 (egg-bunsetsu-info))
+         (setq b2 (egg-get-bunsetsu-info p2)
+               s2 (egg-get-bunsetsu-source b2)
+               s2len (egg-separate-characters s2)
                last (get-text-property p2 'egg-bunsetsu-last))))
-    (setq maxlen (+ slen
-                   (if b2
-                       (chars-in-string (egg-get-bunsetsu-source b2))
-                     0)))
-    (if (> newlen maxlen)
-       (setq beep t
-             newlen maxlen))
-    (setq bunsetsu-info-list (egg-change-bunsetsu-length b0 b1 b2 newlen))
+    (setq source (concat s1 s2))
+    (cond
+     ((<= n (- s1len))
+      (setq beep t chrs (get-text-property 0 'egg-char-size source)))
+     ((> n s2len)
+      (setq beep t chrs (length source)))
+     ((< n 0)
+      (while (< n 0)
+       (setq chrs (- chrs (get-text-property (1- chrs) 'egg-char-size source))
+             n (1+ n))))
+     (t
+      (while (> n 0)
+       (setq chrs (+ chrs (get-text-property chrs 'egg-char-size source))
+             n (1- n)))))
+    (setq bunsetsu-info-list (egg-change-bunsetsu-length b0 b1 b2 chrs))
     (delete-region (point)
                   (progn (forward-char) (if b2 (forward-char)) (point)))
     (let ((p (point)))
-      (egg-insert-bunsetsu-list bunsetsu-info-list (not last))
+      (egg-insert-bunsetsu-list bunsetsu-info-list last)
       (goto-char p))
     (if beep
        (ding))))
@@ -227,7 +361,7 @@
 (defun egg-next-candidate (n)
   (interactive "p")
   (let ((last (get-text-property (point) 'egg-bunsetsu-last))
-       (b (get-text-property (point) (egg-bunsetsu-info)))
+       (b (egg-get-bunsetsu-info (point)))
        new i max+ p beep)
     (setq max+ (egg-get-number-of-candidates b))
     (if (null max+)
@@ -262,7 +396,7 @@
        p bunsetsu-info-list bl)
     (setq p (point))
     (while in-loop
-      (let ((bl1 (cons (get-text-property p (egg-bunsetsu-info)) nil)))
+      (let ((bl1 (cons (egg-get-bunsetsu-info p) nil)))
        (if bl
            (setq bl (setcdr bl bl1))
          (setq bunsetsu-info-list (setq bl bl1))))
@@ -320,7 +454,7 @@
 (defun egg-select-candidate ()
   (interactive)
   (let ((last (get-text-property (point) 'egg-bunsetsu-last))
-       (b (get-text-property (point) (egg-bunsetsu-info)))
+       (b (egg-get-bunsetsu-info (point)))
        (in-loop t)
        new i max+ p)
     (setq max+ (egg-get-number-of-candidates b))

diff --git a/egg-com.el b/egg-com.el
index 9604fe9..cf5b401 100644 (file)
--- a/egg-com.el
+++ b/egg-com.el
@@ -1,22 +1,23 @@
 ;;; egg-com.el --- Communication Routines in Egg Input
 ;;;                   Method Architecture
 
-;; Copyright (C) 1997 Mule Project, Powered by Electrotechnical
+;; Copyright (C) 1997, 1998 Mule Project, Powered by Electrotechnical
 ;; Laboratory, JAPAN.
 ;; Project Leader: Satoru Tomura <tomura@etl.go.jp>
 
 ;; Author: Hisashi Miyashita <himi@bird.scphys.kyoto-u.ac.jp>
 ;;         NIIBE Yutaka <gniibe@mri.co.jp>
+;;        KATAYAMA Yoshio <kate@pfu.co.jp>  ; Korean, Chinese support.
 ;; Maintainer: NIIBE Yutaka <gniibe@mri.co.jp>
 
 ;; This file will be part of GNU Emacs (in future).
 
-;; GNU Emacs is free software; you can redistribute it and/or modify
+;; EGG is free software; you can redistribute it and/or modify
 ;; it under the terms of the GNU General Public License as published by
 ;; the Free Software Foundation; either version 2, or (at your option)
 ;; any later version.
 
-;; GNU Emacs is distributed in the hope that it will be useful,
+;; EGG is distributed in the hope that it will be useful,
 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 ;; GNU General Public License for more details.
@@ -30,6 +31,12 @@
 
 ;;; Code:
 
+(defvar egg-fixed-euc 'fixed-euc-jp)
+(make-variable-buffer-local 'egg-fixed-euc)
+
+(defvar egg-mb-euc 'euc-japan)
+(make-variable-buffer-local 'egg-mb-euc)
+
 (eval-and-compile
 (define-ccl-program ccl-decode-fixed-euc-jp
   `(2
@@ -92,6 +99,42 @@
 
 (make-coding-system 'fixed-euc-jp 4 ?W "Coding System for fixed EUC Japanese"
                    (cons ccl-decode-fixed-euc-jp ccl-encode-fixed-euc))
+
+(eval-and-compile
+(define-ccl-program ccl-decode-fixed-euc-kr
+  `(2
+    ((r2 = ,(charset-id 'korean-ksc5601))
+     (read r0)
+     (loop
+      (read r1)
+      (if (r0 < ?\x80)
+         (r0 = r1 & ?\x7f)
+       ((write r2 r0)
+        (r0 = r1 | ?\x80)))
+      (write-read-repeat r0)))))
+
+(define-ccl-program ccl-encode-fixed-euc-kr
+  `(2
+    ((read r0)
+     (loop
+;      (if (r0 < ?\x20)
+;        (write-read-repeat r0))
+      (if (r0 < ?\x80)
+         ((write 0)
+          (write-read-repeat r0)))
+      (if (r0 == ,(charset-id 'korean-ksc5601))
+         ((read r0)
+          (r0 |= ?\x80)
+          (write r0)
+          (read r0)
+          (r0 |= ?\x80)
+          (write-read-repeat r0)))
+      (read r0)
+      (repeat)))))
+)
+
+(make-coding-system 'fixed-euc-kr 4 ?W "Coding System for fixed EUC Korean"
+                   (cons ccl-decode-fixed-euc-kr ccl-encode-fixed-euc-kr))
 \f
 (defsubst comm-format-u32c (uint32c)
   (let ((h0 (car uint32c))
@@ -137,14 +180,14 @@
 
 ;;; XXX should support other code conversion
 (defsubst comm-format-u16-string (s)
-  (let ((euc-string (encode-coding-string s 'fixed-euc-jp)))
+  (let ((euc-string (encode-coding-string s egg-fixed-euc)))
     (insert euc-string)
     (insert-char 0 1)
     (insert-char 0 1)))
 
 ;;; XXX should support other code conversion
 (defsubst comm-format-mb-string (s)
-  (let ((euc-string (encode-coding-string s 'euc-japan)))
+  (let ((euc-string (encode-coding-string s egg-mb-euc)))
     (insert euc-string)
     (insert-char 0 1)))
 
@@ -245,7 +288,7 @@ s means 8-bit string (0x00 terminated)."
     (set s (buffer-substring start
                             (+ start
                                (decode-coding-region start (- (point) 2)
-                                                     'fixed-euc-jp))))))
+                                                     egg-fixed-euc))))))
 
 ;;; XXX should support other conversion (euc-kr, cns)
 (defsubst comm-unpack-mb-string (proc s)
@@ -255,7 +298,7 @@ s means 8-bit string (0x00 terminated)."
     (set s (buffer-substring start
                             (+ start
                                (decode-coding-region start (- (point) 1)
-                                                     'euc-japan))))))
+                                                     egg-mb-euc))))))
 
 (defsubst comm-unpack-u8-string (proc s)
   (let ((start (point)))

diff --git a/egg.el b/egg.el
index c386176..bf53fce 100644 (file)
--- a/egg.el
+++ b/egg.el
@@ -1,21 +1,22 @@
 ;;; egg.el --- EGG Input Method Architecture
 
-;; Copyright (C) 1997 Mule Project, Powered by Electrotechnical
+;; Copyright (C) 1997, 1998 Mule Project, Powered by Electrotechnical
 ;; Laboratory, JAPAN.
 ;; Project Leader: Satoru Tomura <tomura@etl.go.jp>
 
 ;; Author: NIIBE Yutaka <gniibe@mri.co.jp>
+;;         KATAYAMA Yoshio <kate@pfu.co.jp>
 ;; Maintainer: NIIBE Yutaka <gniibe@mri.co.jp>
 ;; Keywords: mule, multilingual, input method
 
 ;; This file will be part of GNU Emacs (in future).
 
-;; GNU Emacs is free software; you can redistribute it and/or modify
+;; EGG is free software; you can redistribute it and/or modify
 ;; it under the terms of the GNU General Public License as published by
 ;; the Free Software Foundation; either version 2, or (at your option)
 ;; any later version.
 
-;; GNU Emacs is distributed in the hope that it will be useful,
+;; EGG is distributed in the hope that it will be useful,
 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 ;; GNU General Public License for more details.
@@ -31,8 +32,14 @@
 (defvar egg-mode-preference t
   "Non-nil if modefull.")
 
+(defvar egg-default-language "Japanese")
+(defvar egg-last-method-name)
+(make-variable-buffer-local 'egg-last-method-name)
+(defvar egg-mode-line-title)
+(make-variable-buffer-local 'egg-mode-line-title)
+
 ;;;###autoload
-(defun egg-mode (&optional arg)
+(defun egg-mode (&rest arg)
   "Toggle EGG  mode.
 \\[describe-bindings]
 "
@@ -40,12 +47,21 @@
   (if (null arg)
       ;; Turn off
       (progn
+       (cond
+        ((its-in-fence-p)
+         (its-exit-mode))
+        ((egg-get-bunsetsu-info (point))))
        (setq describe-current-input-method-function nil)
        (setq current-input-method nil)
        (let ((orig-local-map (keymap-parent (current-local-map))))
          (use-local-map orig-local-map))
        (run-hooks 'input-method-inactivate-hook))
     ;; Turn on
+    (if (null (string= (car arg) egg-last-method-name))
+       (progn
+        (funcall (nth 1 arg))
+        (setq egg-default-language its-current-language)))
+    (setq egg-last-method-name (car arg))
     (use-local-map (if egg-mode-preference
                       (egg-modefull-map)
                     (egg-modeless-map)))
@@ -54,6 +70,14 @@
     (run-hooks 'input-method-activate-hook))
   (force-mode-line-update))
 
+(defun egg-set-mode-line-title (title)
+  (setq egg-mode-line-title title)
+  (force-mode-line-update))
+
+(defun egg-check-language (lang)
+  (if (null (member lang egg-support-languages))
+      (error "%S is not supported" lang)))
+
 (defun egg-modefull-map ()
   "Generate modefull keymap for EGG mode."  
   (let ((map (make-sparse-keymap))
@@ -103,7 +127,7 @@
 ;; XXX: Should use backend interface
 (defun egg-toroku-region (start end)
   (interactive "r")
-  (let* ((env (wnn-get-environment))   ; XXX
+  (let* ((env (wnn-get-environment wnn-dictionary-specification)) ; XXX
         (kanji (buffer-substring start end))
         (yomi (read-multilingual-string 
                (format "\e$B<-=qEPO?!X\e(B%s\e$B!Y\e(B  \e$BFI$_\e(B:" kanji)))
@@ -138,26 +162,35 @@
          (setq ocolumn (current-column))
          (funcall auto-fill-function)))))
 
-(setq its-hira-period "\e$B!#\e(B")    ; ". " "\e$B!%\e(B" "\e$B!#\e(B"
-(setq its-hira-comma  ", ")    ; ", " "\e$B!$\e(B" "\e$B!"\e(B"
-
 (require 'its)
 (require 'menudiag)
 (require 'egg-mlh)
 (require 'egg-cnv)
 (require 'egg-com)
+(require 'custom)
+
+(defgroup egg nil
+  "Tamagotchy --- EGG Versio 4.0")
 
-(load-library "its/hira")
-(setq-default its-current-map its-hira-map)
+;;(load-library "its/hira")
+;;(setq-default its-current-map its-hira-map)
 
-(load-library "egg/wnn")
-(load-library "egg/wnnrpc")
-(setq egg-conversion-backend wnn-conversion-backend)
+;;(load-library "egg/wnn")
+;;(load-library "egg/wnnrpc")
+;;(setq egg-conversion-backend wnn-conversion-backend)
 
 ;;(load-library "egg/sj3rpc")
 ;;(load-library "egg/sj3")
 ;;(setq egg-conversion-backend sj3-conversion-backend)
 
+(defvar egg-support-languages nil)
+
+(defun egg-set-support-languages (langs)
+  (while langs
+    (if (null (member (car langs) egg-support-languages))
+       (setq egg-support-languages (cons (car langs) egg-support-languages)))
+    (setq langs (cdr langs))))
+
 (add-hook 'kill-emacs-hook 'egg-kill-emacs-function)
 (defun egg-kill-emacs-function ()
   (egg-finalize-backend))

diff --git a/egg/sj3.el b/egg/sj3.el
index c5ad963..4e57742 100644 (file)
--- a/egg/sj3.el
+++ b/egg/sj3.el
@@ -10,12 +10,12 @@
 
 ;; This file will be part of GNU Emacs (in future).
 
-;; GNU Emacs is free software; you can redistribute it and/or modify
+;; EGG is free software; you can redistribute it and/or modify
 ;; it under the terms of the GNU General Public License as published by
 ;; the Free Software Foundation; either version 2, or (at your option)
 ;; any later version.
 
-;; GNU Emacs is distributed in the hope that it will be useful,
+;; EGG is distributed in the hope that it will be useful,
 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 ;; GNU General Public License for more details.
@@ -29,6 +29,8 @@
 
 ;;; Code:
 
+(defconst sj3-support-languages '("Japanese"))
+
 (defconst sj3-conversion-backend
   [ sj3-init
 
@@ -166,7 +168,7 @@
 (defun sj3-init ()
   )
 
-(defun sj3-start-conversion (yomi)
+(defun sj3-start-conversion (yomi lang)
   "Convert YOMI string to kanji, and enter conversion mode.
 Return the list of bunsetsu."
   (let ((env (sj3-get-environment)))
@@ -220,10 +222,8 @@ Return the list of bunsetsu."
        (env (sj3bunsetsu-get-env b1))
        yomi1 yomi2
        bunsetsu1 bunsetsu2)
-    (save-match-data
-      (string-match (concat "^\\(" (make-string len ?.) "\\)\\(.*$\\)") yomi)
-      (setq yomi1 (match-string 1 yomi))
-      (setq yomi2 (match-string 2 yomi)))
+    (setq yomi1 (substring yomi 0 len)
+         yomi2 (substring yomi len))
     (setq bunsetsu1
          (sj3rpc-tanbunsetsu-conversion env yomi1))
     ;; Only set once.
@@ -240,7 +240,21 @@ Return the list of bunsetsu."
       (list bunsetsu1))))
 
 ;; XXX: Not implemented yet
-(defun sj3-fini ()
+(defun sj3-fini (lang)
   )
 
+;;; setup
+
+(require 'egg)
+(load "egg/sj3rpc")
+
+;;;###autoload
+(defun egg-activate-sj3 (&optional arg)
+  "Activate SJ3 backend of Tamagotchy."
+  (egg-set-support-languages sj3-support-languages)
+  (egg-set-conversion-backend sj3-conversion-backend 
+                             sj3-support-languages
+                             nil)
+  (apply 'egg-mode arg))
+
 ;;; egg/sj3.el ends here.

diff --git a/egg/sj3rpc.el b/egg/sj3rpc.el
index 6ae09aa..c92dbb7 100644 (file)
--- a/egg/sj3rpc.el
+++ b/egg/sj3rpc.el
@@ -10,12 +10,12 @@
 
 ;; This file will be part of GNU Emacs (in future).
 
-;; GNU Emacs is free software; you can redistribute it and/or modify
+;; EGG is free software; you can redistribute it and/or modify
 ;; it under the terms of the GNU General Public License as published by
 ;; the Free Software Foundation; either version 2, or (at your option)
 ;; any later version.
 
-;; GNU Emacs is distributed in the hope that it will be useful,
+;; EGG is distributed in the hope that it will be useful,
 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 ;; GNU General Public License for more details.
@@ -33,7 +33,7 @@
 
 (eval-when-compile
   (require 'egg-com)
-  (load-library "egg/sj3")
+;;  (load-library "egg/sj3")
   (defmacro sj3-const (c)
     (cond ((eq c 'OPEN)            1)
          ((eq c 'CLOSE)           2)

diff --git a/egg/wnn.el b/egg/wnn.el
index 6474eb9..96d7472 100644 (file)
--- a/egg/wnn.el
+++ b/egg/wnn.el
@@ -1,21 +1,23 @@
 ;;; egg/wnn.el --- WNN Support (high level interface) in Egg
 ;;;                Input Method Architecture
 
-;; Copyright (C) 1997 Mule Project, Powered by Electrotechnical
+;; Copyright (C) 1997, 1998 Mule Project, Powered by Electrotechnical
 ;; Laboratory, JAPAN.
 ;; Project Leader: Satoru Tomura <tomura@etl.go.jp>
 
 ;; Author: NIIBE Yutaka <gniibe@mri.co.jp>
+;;         KATAYAMA Yoshio <kate@pfu.co.jp> ; Korean, Chinese support.
+;;
 ;; Maintainer: NIIBE Yutaka <gniibe@mri.co.jp>
 
-;; This file will be part of GNU Emacs (in future).
+;; This file will be part of EGG (in future).
 
-;; GNU Emacs is free software; you can redistribute it and/or modify
+;; EGG is free software; you can redistribute it and/or modify
 ;; it under the terms of the GNU General Public License as published by
 ;; the Free Software Foundation; either version 2, or (at your option)
 ;; any later version.
 
-;; GNU Emacs is distributed in the hope that it will be useful,
+;; EGG is distributed in the hope that it will be useful,
 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 ;; GNU General Public License for more details.
@@ -28,6 +30,12 @@
 ;;; Commentary:
 
 ;;; Code:
+(defgroup wnn nil
+  "Wnn interface for Tamagotchy"
+  :group 'egg)
+
+(defconst wnn-support-languages
+  '("Japanese" "Chinese-GB" "Chinese-CNS" "Korean"))
 
 (eval-when-compile
   (defmacro WNN-const (c)
@@ -56,10 +64,11 @@
     wnn-fini
  ])
 
-;; <env> ::= [ <proc> <env-id> <daibunsetsu-info> ]
+;; <env> ::= [ <proc> <env-id> <server-type> <dic-set> <rev-flag>
+;;             <daibunsetsu-info> ]
 
-(defsubst wnnenv-create (proc env-id)
-  (vector proc env-id nil))
+(defsubst wnnenv-create (proc env-id server-type dic-set rev-flag)
+  (vector proc env-id server-type dic-set rev-flag nil))
 
 (defsubst wnnenv-get-proc (env)
   (aref env 0))
@@ -67,10 +76,19 @@
 (defsubst wnnenv-get-env-id (env)
   (aref env 1))
 
-(defsubst wnnenv-get-daibunsetsu-info (env)
+(defsubst wnnenv-get-server-type (env)
   (aref env 2))
+
+(defsubst wnnenv-get-dictionary-set (env)
+  (aref env 3))
+
+(defsubst wnnenv-get-reverse-flag (env)
+  (aref env 4))
+
+(defsubst wnnenv-get-daibunsetsu-info (env)
+  (aref env 5))
 (defsubst wnnenv-set-daibunsetsu-info (env d)
-  (aset env 2 d))
+  (aset env 5 d))
 
 ;; <bunsetsu> ::= [ <env> <end> <start> <jiritsugo-end> <dic-no>
 ;;                  <entry> <freq> <right-now> <hinshi> <status>
@@ -132,19 +150,58 @@
 (defsubst wnn-bunsetsu-set-zenkouho-pos (bunsetsu zp)
   (aset bunsetsu 18 zp))
 \f
-(defvar wnn-server "localhost"
-  "Hostname of wnn server")
-
-(defvar wnn-environment nil
+(defvar wnn-environments nil
   "Environment for WNN kana-kanji conversion")
 
+(defcustom wnn-jserver "localhost" "jserver host" :group 'wnn :type 'string)
+(defcustom wnn-cserver "localhost" "cserver host" :group 'wnn :type 'string)
+(defcustom wnn-tserver "localhost" "tserver host" :group 'wnn :type 'string)
+(defcustom wnn-kserver "localhost" "kserver host" :group 'wnn :type 'string)
+
+;; The port number should be initialized from $WNNLIB/serverdefs by wnn-init
+(defconst wnn-server-info-list
+  ;; language      locale  server  port  stream coding-system hostname
+  '(("Japanese"    "ja_JP" jserver 22273 "Wnn"  fixed-euc-jp wnn-jserver)
+    ("Chinese-GB"  "zh_CN" cserver 22289 "cWnn" fixed-euc-cn wnn-cserver)
+    ("Chinese-CNS" "zh_TW" tserver 22321 "tWnn" fixed-euc-tw wnn-tserver)
+    ("Korean"      "ko_KR" kserver 22305 "kWnn" fixed-euc-kr wnn-kserver)))
+
+(defun wnn-get-server-info (lang)
+  (let (info)
+    (if (null lang)
+       (setq lang its-current-language))
+    (if (setq info (assoc lang wnn-server-info-list)) info
+      (assoc "Japanese" wnn-server-info-list))))
+
+(defsubst wnn-server-locale (info)
+  (nth 1 info))
+
+(defsubst wnn-server-type (info)
+  (nth 2 info))
+
+(defsubst wnn-server-port (info)
+  (nth 3 info))
+
+(defsubst wnn-server-stream-name (info)
+  (nth 4 info))
+
+(defsubst wnn-server-buffer-name (info)
+  (concat " *" (wnn-server-stream-name info) "*"))
+
+(defsubst wnn-server-coding-system (info)
+  (nth 5 info))
+
+(defsubst wnn-server-hostname (info)
+  (symbol-value (nth 6 info)))
+
 (defun wnn-init ()
   )
 
-(defun wnn-start-conversion (yomi)
+(defun wnn-start-conversion (yomi &optional language dic-set reverse)
   "Convert YOMI string to kanji, and enter conversion mode.
 Return the list of bunsetsu."
-  (let* ((env (wnn-get-environment wnn-dictionary-specification))
+  (let* ((server-info (wnn-get-server-info language))
+        (env (wnn-get-environment server-info dic-set reverse))
         (result (wnnrpc-renbunsetsu-conversion env yomi
                                                (WNN-const BUN_SENTOU) "")))
     (wnnenv-set-daibunsetsu-info env (car result))
@@ -171,7 +228,7 @@ Return the list of bunsetsu."
   (let ((hash-table (make-vector 31 0)) ; XXX why 31?
        (l bunsetsu-list)
        (i 0)
-       n sym0 result p b sym)
+       (n 0) sym0 result p b sym)
     (setq sym0 (intern (wnn-get-bunsetsu-converted bunsetsu) hash-table))
     (while l
       (setq b (car l)
@@ -255,10 +312,8 @@ Return the list of bunsetsu."
              prev-fuzokugo "")
       (setq prev-hinshi (wnn-bunsetsu-get-hinshi b0)
            prev-fuzokugo (wnn-bunsetsu-get-fuzokugo b0)))
-    (save-match-data
-      (string-match (concat "^\\(" (make-string len ?.) "\\)\\(.*$\\)") yomi)
-      (setq yomi1 (match-string 1 yomi))
-      (setq yomi2 (match-string 2 yomi)))
+    (setq yomi1 (substring yomi 0 len)
+         yomi2 (substring yomi len))
     (setq bunsetsu1
          (car (wnnrpc-tanbunsetsu-conversion env yomi1
                                              prev-hinshi prev-fuzokugo)))
@@ -269,15 +324,14 @@ Return the list of bunsetsu."
                                        (list b1 b2)
                                      (list b1))))
     (if (< 0 (length yomi2))
-       ;; RENBUNSETSU? XXX
        (setq bunsetsu2
-             (car (wnnrpc-tanbunsetsu-conversion
+             (cdr (wnnrpc-renbunsetsu-conversion
                    env yomi2
                    (wnn-bunsetsu-get-hinshi bunsetsu1)
                    (wnn-bunsetsu-get-fuzokugo bunsetsu1))))
       (setq bunsetsu2 nil))
     (if bunsetsu2
-       (list bunsetsu1 bunsetsu2)
+       (append (list bunsetsu1) bunsetsu2)
       (list bunsetsu1))))
 
 
@@ -293,42 +347,60 @@ Return the list of bunsetsu."
 (defvar wnn-sticky-environment-flag nil
   "*Flag which specifies sticky environment.")
 
-(defun wnn-fini ()                     ; XXX
-  (if (null wnn-environment)
-      nil
-    (condition-case nil
-       (progn
-         (if wnn-sticky-environment-flag
-             (wnnrpc-make-env-sticky wnn-environment)
-           (wnnrpc-make-env-unsticky wnn-environment))
-         (wnnrpc-disconnect wnn-environment))
-      (error nil))
-    (let ((proc (wnnenv-get-proc wnn-environment)))
-      (if (eq (process-status proc) 'open)
-         (progn
-           (wnnrpc-close proc)
-           (kill-buffer (process-buffer proc))
-           (delete-process proc))))
-    (setq wnn-environment nil)))
+(defun wnn-fini (lang)                 ; XXX
+                                       ; tamago-971009 version
+                                       ; argument LANG is still dummy
+  (if wnn-environments
+      (let ((l wnn-environments))
+       (condition-case nil
+           (while l
+             (let ((env (car l)))
+               (if wnn-sticky-environment-flag
+                   (wnnrpc-make-env-sticky env)
+                 (wnnrpc-make-env-unsticky env))
+               (wnnrpc-disconnect env)
+               (setq l (cdr l))))
+         (error nil))
+       (setq l wnn-environments)
+       (while l
+         (let ((proc (wnnenv-get-proc (car l))))
+           (if (eq (process-status proc) 'open)
+               (progn
+                 (wnnrpc-close proc)
+                 (kill-buffer (process-buffer proc)))
+             (setq l (cdr l)))))
+       (setq wnn-environments nil))))
 \f
-;; XXX should be array (index: server) of {C,J,K}server
-(defconst wnn-jserver-port 22273)
 ;;
 (defun wnn-comm-sentinel (proc reason) ; assume it is close
-  (kill-buffer (process-buffer proc))
-  (delete-process proc)
-  (setq wnn-environment nil)
-  (message "WNN: connection closed"))
+                                       ; tamago-971009 version
+  (let ((l wnn-environments)
+       env l1)
+    (kill-buffer (process-buffer proc))
+    ;; delete env from the list.
+    (while l
+      (setq env (car l))
+      (if (eq proc (wnnenv-get-proc env))
+         (progn
+           (if l1
+               (setcdr l1 (cdr l))
+             (setq wnn-environments (cdr l)))
+           (setq l (cdr l)))
+       (setq l1 l
+             l (cdr l))))))
 
 ;;
-(defun wnn-open (hostname language)
+(defun wnn-open (server-info)
   "Establish the connection to WNN server.  Return process object."
-  ;; Specifying language (jserver/cserver/kserver),
-  ;; open the session to WNN server, 
-  (let ((buf (generate-new-buffer " *WNN*"))
-       proc result)
+  ;; Open the session to WNN server, 
+  (let ((buf (generate-new-buffer (wnn-server-buffer-name server-info)))
+       (hostname (wnn-server-hostname server-info))
+       proc result)
     (condition-case result
-       (setq proc (open-network-stream "WNN" buf hostname wnn-jserver-port))
+       (setq proc (open-network-stream (wnn-server-stream-name server-info)
+                                       buf
+                                       hostname
+                                       (wnn-server-port server-info)))
       (error (progn
               (kill-buffer buf)
               (signal (car result) (cdr result)))))
@@ -340,36 +412,146 @@ Return the list of bunsetsu."
       (set-buffer buf)
       (erase-buffer)
       (buffer-disable-undo)
-      (setq enable-multibyte-characters nil))
-    (setq result (wnnrpc-open proc (system-name) (user-login-name)))
+      (setq enable-multibyte-characters nil
+           egg-fixed-euc (wnn-server-coding-system server-info)))
+    (setq result (wnnrpc-open proc
+                             (if (equal hostname "localhost")
+                                 "unix"
+                               (system-name))
+                             (user-login-name)))
     (if (< result 0)
        (let ((msg (wnnrpc-get-error-message (- result))))
          (delete-process proc)
          (kill-buffer buf)
-         (error "Can't open WNN session (%s %s): %s" hostname language msg))
+         (error "Can't open WNN session (%s %S): %s"
+                hostname
+                (wnn-server-type server-info) msg))
       proc)))
 
-(defvar wnn-dictionary-specification
-  '([2 10 2 45 100 200 5 1 40 0 -100 200 -100  200 80 200 200]
-    "pubdic/full.fzk"
-    ["pubdic/kihon.dic"     ("kihon.h")    5 nil t]
-    ["pubdic/setsuji.dic"   ("setsuji.h")  5 nil t]
-    ["pubdic/koyuu.dic"     ("koyuu.h")    1 nil t]
-    ["pubdic/chimei.dic"    ("chimei.h")   1 nil t]
-    ["pubdic/jinmei.dic"    ("jinmei.h")   1 nil t]
-    ["pubdic/special.dic"   ("special.h")  5 nil t]
-    ["pubdic/computer.dic"  ("computer.h") 5 nil t]
-    ["pubdic/symbol.dic"    ("symbol.h")   1 nil t]
-    ["pubdic/tankan.dic"    ("tankan.h")   1 nil t]
-    ["pubdic/bio.dic"       ("bio.h")      1 nil t]
-    ["gerodic/g-jinmei.dic" ("g-jinmei.h") 1 nil t]
-    ["wnncons/tankan2.dic"  ("tankan2.h")  1 nil t]
-    ["wnncons/tankan3.dic"  ("tankan3.h")  1 nil t]
-    [("ud")                 nil            5 t t])
-  "")
-
-(defvar wnn-usr-dic-dir (concat "usr/" (user-login-name))
-  "*Directory of user dictionary for Wnn.")
+(defvar wnn-dictionary-specification-list
+  '((jserver
+     (nil nil ""
+         [2 10 2 45 100 200 5 1 40 -100 200 -100 200 80 200 200 200]
+         "pubdic/full.fzk"
+         ["pubdic/kihon.dic"     ("kihon.h")    5 nil t]
+         ["pubdic/setsuji.dic"   ("setsuji.h")  5 nil t]
+         ["pubdic/koyuu.dic"     ("koyuu.h")    1 nil t]
+         ["pubdic/chimei.dic"    ("chimei.h")   1 nil t]
+         ["pubdic/jinmei.dic"    ("jinmei.h")   1 nil t]
+         ["pubdic/special.dic"   ("special.h")  5 nil t]
+         ["pubdic/computer.dic"  ("computer.h") 5 nil t]
+         ["pubdic/symbol.dic"    ("symbol.h")   1 nil t]
+         ["pubdic/tankan.dic"    nil            1 nil nil]
+         ["pubdic/bio.dic"       ("bio.h")      1 nil t]
+         ["gerodic/g-jinmei.dic" ("g-jinmei.h") 1 nil t]
+         ["wnncons/tankan2.dic"  nil            1 nil nil]
+         ["wnncons/tankan3.dic"  nil            1 nil nil]
+         [("ud")                 nil            5 t   t])
+     (nil t "R"
+         [2 10 2 45 1 80 5 1 50 -20 400 -10 100 -100 200 0 200]
+         "pubdic/full.fzk"
+         ["pubdic/kihon.dic"     ("kihon.h")    5 nil t]
+         ["pubdic/setsuji.dic"   ("setsuji.h")  5 nil t]
+         ["pubdic/koyuu.dic"     ("koyuu.h")    1 nil t]
+         ["pubdic/chimei.dic"    ("chimei.h")   1 nil t]
+         ["pubdic/jinmei.dic"    ("jinmei.h")   1 nil t]
+         ["pubdic/special.dic"   ("special.h")  5 nil t]
+         ["pubdic/computer.dic"  ("computer.h") 5 nil t]
+         ["pubdic/symbol.dic"    ("symbol.h")   1 nil t]
+         ["pubdic/tankan.dic"    nil            1 nil nil]
+         ["pubdic/bio.dic"       ("bio.h")      1 nil t]
+         ["gerodic/g-jinmei.dic" ("g-jinmei.h") 1 nil t]
+         ["wnncons/tankan2.dic"  nil            1 nil nil]
+         ["wnncons/tankan3.dic"  nil            1 nil nil]
+         [("ud")                 nil            5 t   t]))
+    (cserver
+     (Q   nil "Q"
+         nil
+         "sys/full.con"
+         ["sys/QianMa.dic"       nil            1 nil nil])
+     (W   nil "W"
+         nil
+         "sys/full.con"
+         ["sys/WuBi.dic"         nil            1 nil nil])
+     (nil nil "PZ"
+         [1 5 2 750 10 80 10 5 1000 50 0 -200 0 0 0 16 0]
+         "sys/full.con"
+         ["sys/level_1.dic"      ("level_1.h")  4 nil t]
+         ["sys/level_2.dic"      ("level_2.h")  1 nil t]
+         ["sys/basic.dic"        ("basic.h")    7 nil t]
+         ["sys/computer.dic"     ("computer.h") 4 nil t]
+         ["sys/cwnn.dic"         ("cwnn.h")     4 nil t]
+         [("ud")                 nil            5 t   t])
+     (Q   t "QR"
+         nil
+         "sys/full.conR"
+         ["sys/QianMa.dic"       nil            1 nil nil])
+     (W   t "WR"
+         nil
+         "sys/full.conR"
+         ["sys/WuBi.dic"         nil            1 nil nil])
+     (nil t "PZR"
+         [1 5 2 750 10 80 10 5 1000 50 0 -200 0 0 0 16 0]
+         "sys/full.conR"
+         ["sys/level_1.dic"      ("level_1.h")  4 nil t]
+         ["sys/level_2.dic"      ("level_2.h")  1 nil t]
+         ["sys/basic.dic"        ("basic.h")    7 nil t]
+         ["sys/computer.dic"     ("computer.h") 4 nil t]
+         ["sys/cwnn.dic"         ("cwnn.h")     4 nil t]
+         [("ud")                 nil            5 t   t]))
+    (tserver
+     (nil nil ""
+         [1 5 2 750 10 80 10 5 1000 50 0 -200 0 0 0 16 0]
+         "sys/full.con"
+         ["sys/cns_ch.dic"       ("cns_ch.h")   4 nil t]
+         ["sys/cns_wd.dic"       ("cns_wd.h")   1 nil t]
+         [("ud")                 nil            5 t   t])
+     (nil t "R"
+         [1 5 2 750 10 80 10 5 1000 50 0 -200 0 0 0 16 0]
+         "sys/full.conR"
+         ["sys/cns_ch.dic"       ("cns_ch.h")   4 nil t]
+         ["sys/cns_wd.dic"       ("cns_wd.h")   1 nil t]
+         [("ud")                 nil            5 t   t]))
+    (kserver
+     (nil nil ""
+         [2 5 2 45 200 80 5 1 40 0 400 -100 400 80 200 2 200]
+         "sys/full.fzk"
+         ["sys/hword.dic"        ("hword.h")    5 nil t]
+         ["sys/single.dic"       ("single.h")   1 nil t]
+         [("ud")                 nil            2 t   t])
+     (nil t "R"
+         [2 10 2 45 1 80 5 1 50 -20 400 -10 100 -100 200 0 200]
+         "sys/full.fzk"
+         ["sys/hword.dic"        ("hword.h")    5 nil t]
+         ["sys/single.dic"       ("single.h")   1 nil t]
+         [("ud")                 nil            2 t   t]))))
+
+(defsubst wnn-get-dic-spec (server)
+  (cdr (assoc server wnn-dictionary-specification-list)))
+
+(defsubst wnn-dic-spec-dic-set (spec)
+  (nth 0 spec))
+
+(defsubst wnn-dic-spec-reverse (spec)
+  (nth 1 spec))
+
+(defsubst wnn-dic-spec-name (spec)
+  (nth 2 spec))
+
+(defsubst wnn-dic-spec-param (spec)
+  (nth 3 spec))
+
+(defsubst wnn-dic-spec-fuzokugo (spec)
+  (nth 4 spec))
+
+(defsubst wnn-dic-spec-dic-list (spec)
+  (nthcdr 5 spec))
+
+
+(defcustom wnn-usr-dic-dir (concat "usr/" (user-login-name))
+  "*Directory of user dictionary for Wnn."
+  :group 'wnn
+  :type 'string)
 
 (defun wnn-filename (p)
   ""
@@ -512,48 +694,77 @@ On failure, return negate-encoded error code."
        (wnnrpc-open-file proc env-id freqname)) ; XXX: error?
     -1))
 
-(defun wnn-get-environment (dic-spec)
-  "Return WNN Environemt.  If none, create new environment.
-Take one argument DIC-SPEC for dictionary specification."
-  (if wnn-environment
-      wnn-environment
-    (let ((username (user-login-name))
-         (proc (wnn-open wnn-server "ja_JP")))
-      (setq wnn-environment
-           (wnn-create-environment proc username nil dic-spec)))))
-
-(defun wnn-create-environment (proc username reverse-flag spec)
+(defun wnn-get-environment (server-info &optional dic-set reverse)
+  "Return WNN Environemt for the conversion server specified
+by SERVER-INFO.  If none, create new environment.  Optional
+argument DIC-SET specifies dictionary set.  Optional argument
+REVERSE specifies reverse conversion, if non nil."
+  (let ((server-type (wnn-server-type server-info))
+       (env wnn-environments)
+       proc spec e s)
+    (setq reverse (null (null reverse)))
+    (if (catch 'found
+         (while env
+           (setq e (car env))
+           (if (and (eq (wnnenv-get-server-type e) server-type)
+                    (eq (wnnenv-get-dictionary-set e) dic-set)
+                    (eq (wnnenv-get-reverse-flag e) reverse))
+               (throw 'found t))
+           (setq env (cdr env))))
+       e
+      (setq proc (wnn-open server-info)
+           spec (wnn-get-dic-spec server-type))
+      (while spec
+       (setq s (car spec)
+             e (wnn-create-environment proc server-type s)
+             wnn-environments (cons e wnn-environments))
+       (if (and (eq (wnn-dic-spec-dic-set s) dic-set)
+                (eq (wnn-dic-spec-reverse s) reverse))
+           (setq env e))
+       (setq spec (cdr spec)))
+      env)))
+
+(defun wnn-create-environment (proc server-type spec)
   ""
   ;; Create new data structure: something like wnn_buf
   ;; Process, Environment-ID and Daibunsetsu-info.
-  (let (env env-id parameters)
-    (setq env-id (wnnrpc-connect proc username))
+  (let (env-id parameters filename fuzokugo-fid ret dic-set reverse)
+    (setq env-id (wnnrpc-connect proc (wnn-make-env-name spec)))
     (if (< env-id 0)
-       (let ((msg (wnnrpc-get-error-message (- env-id))))
-         (error "Can't connect new WNN environment: %s" msg)))
-    (setq parameters (car spec))
-    (setq spec (cdr spec))
-    (let ((filename (wnn-filename (car spec)))
-         fuzokugo-fid ret)
-      (setq fuzokugo-fid (wnn-open-file proc env-id filename))
-      (if (null fuzokugo-fid)
-         (setq fuzokugo-fid -1)
-       (if (< fuzokugo-fid 0)
-           (let ((msg (wnnrpc-get-error-message (- fuzokugo-fid))))
-             (message "WNN: Can't open fuzokugo file (%s): %s" filename msg)
-             (setq fuzokugo-fid -1))))
-      (setq ret (wnnrpc-set-fuzokugo-file proc env-id fuzokugo-fid))
-      (if (< ret 0)
-         (let ((msg (wnnrpc-get-error-message (- ret))))
-           (message "WNN: Error on setting fuzokugo (%s): %s" filename msg))))
-    (setq spec (cdr spec))
+       (error "Can't connect new WNN environment: %s"
+              (wnnrpc-get-error-message (- env-id))))
+    (setq dic-set (wnn-dic-spec-dic-set spec)
+         reverse (wnn-dic-spec-reverse spec)
+         parameters (wnn-dic-spec-param spec)
+         filename (wnn-filename (wnn-dic-spec-fuzokugo spec))
+         fuzokugo-fid (wnn-open-file proc env-id filename))
+    (if (null fuzokugo-fid)
+       (setq fuzokugo-fid -1)
+      (if (< fuzokugo-fid 0)
+         (progn
+           (message "WNN: Can't open fuzokugo file (%s): %s"
+                    filename
+                    (wnnrpc-get-error-message (- fuzokugo-fid)))
+           (setq fuzokugo-fid -1))))
+    (setq ret (wnnrpc-set-fuzokugo-file proc env-id fuzokugo-fid))
+    (if (< ret 0)
+       (let ((msg (wnnrpc-get-error-message (- ret))))
+         (message "WNN: Error on setting fuzokugo (%s): %s" filename msg)))
+    (setq spec (wnn-dic-spec-dic-list spec))
     (while spec
-      (let ((dic-spec (car spec)))
-       (wnn-set-dictionary proc env-id reverse-flag dic-spec)
-       (setq spec (cdr spec))))
-    (wnnrpc-set-conversion-parameters proc env-id parameters)
-    (setq env (wnnenv-create proc env-id))
-    env))
+      (wnn-set-dictionary proc env-id reverse (car spec))
+      (setq spec (cdr spec)))
+    (if parameters
+       (wnnrpc-set-conversion-parameters proc env-id parameters))
+    (wnnenv-create proc env-id server-type dic-set reverse)))
+
+(defvar wnn-user-name nil)
+
+(defun wnn-make-env-name (spec)
+  (or wnn-user-name
+      (setq wnn-user-name (getenv "WNNUSER"))
+      (setq wnn-user-name (user-login-name)))
+  (concat wnn-user-name (wnn-dic-spec-name spec)))
 
 (defun wnn-update-frequency (env bunsetsu-info-list)
   (let ((l bunsetsu-info-list))
@@ -663,4 +874,18 @@ Take one argument DIC-SPEC for dictionary specification."
     (wnnrpc-add-word env dic-number yomi kanji comment
                     hinshi-id initial-freq)))
 
+;;; setup
+
+(require 'egg)
+(load "egg/wnnrpc")
+
+;;;###autoload
+(defun egg-activate-wnn (&optional arg)
+  "Activate Wnn backend of Tamagotchy."
+  (egg-set-support-languages wnn-support-languages)
+  (egg-set-conversion-backend wnn-conversion-backend
+                             (list (nth 2 arg))
+                             wnn-support-languages)
+  (apply 'egg-mode arg))
+
 ;;; egg/wnn.el ends here.

diff --git a/egg/wnnrpc.el b/egg/wnnrpc.el
index 901d088..723453a 100644 (file)
--- a/egg/wnnrpc.el
+++ b/egg/wnnrpc.el
@@ -1,21 +1,23 @@
 ;;; egg/wnnrpc.el --- WNN Support (low level interface) in Egg
 ;;;                   Input Method Architecture
 
-;; Copyright (C) 1997 Mule Project, Powered by Electrotechnical
+;; Copyright (C) 1997, 1998 Mule Project, Powered by Electrotechnical
 ;; Laboratory, JAPAN.
 ;; Project Leader: Satoru Tomura <tomura@etl.go.jp>
 
 ;; Author: NIIBE Yutaka <gniibe@mri.co.jp>
+;;         KATAYAMA Yoshio <kate@pfu.co.jp> ; Korean, Chinese support.
+;;
 ;; Maintainer: NIIBE Yutaka <gniibe@mri.co.jp>
 
 ;; This file will be part of GNU Emacs (in future).
 
-;; GNU Emacs is free software; you can redistribute it and/or modify
+;; EGG is free software; you can redistribute it and/or modify
 ;; it under the terms of the GNU General Public License as published by
 ;; the Free Software Foundation; either version 2, or (at your option)
 ;; any later version.
 
-;; GNU Emacs is distributed in the hope that it will be useful,
+;; EGG is distributed in the hope that it will be useful,
 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 ;; GNU General Public License for more details.
@@ -31,7 +33,7 @@
 
 (eval-when-compile
   (require 'egg-com)
-  (load-library "egg/wnn")
+  ;; (load-library "egg/wnn")
   (defmacro wnn-const (c)
     "Macro for WNN constants."
     (cond ((eq c 'JS_VERSION)             0)
@@ -104,135 +106,500 @@
          ((eq c 'WNN_MAX_FILE_OF_AN_ENV)  60))))
 
 (defconst wnnrpc-error-message
-  [
-   nil
-   "\e$B%U%!%$%k$,B8:_$7$^$;$s\e(B"
-   nil
-   "\e$B%a%b%j\e(B allocation \e$B$G<:GT$7$^$7$?\e(B"
-   nil
-   "\e$B<-=q$G$O$"$j$^$;$s\e(B"
-   "\e$BIQEY%U%!%$%k$G$O$"$j$^$;$s\e(B"
-   "\e$BIUB08l%U%!%$%k$G$O$"$j$^$;$s\e(B"
-   nil
-   "\e$B<-=q%F!<%V%k$,0lGU$G$9\e(B"
-   "\e$BIQEY%U%!%$%k$,;XDj$5$l$?<-=q$NIQEY%U%!%$%k$G$O$"$j$^$;$s\e(B"
-   nil
-   nil
-   nil
-   nil
-   nil
-   "\e$B%U%!%$%k$,%*!<%W%s$G$-$^$;$s\e(B"
-   "\e$B@5$7$$IQEY%U%!%$%k$G$O$"$j$^$;$s\e(B"
-   "\e$B@5$7$$IUB08l%U%!%$%k$G$O$"$j$^$;$s\e(B"
-   "\e$BIUB08l$N8D?t\e(B, \e$B%Y%/%?D9$5$J$I$,B?2a$.$^$9\e(B"
-   "\e$B$=$NHV9f$N<-=q$O;H$o$l$F$$$^$;$s\e(B"
-   nil
-   nil
-   nil
-   "\e$BIUB08l%U%!%$%k$NFbMF$,@5$7$/$"$j$^$;$s\e(B"
-   "\e$B5?;wIJ;lHV9f$,0[>o$G$9\e(B(hinsi.data \e$B$,@5$7$/$"$j$^$;$s\e(B)"
-   "\e$BL$Dj5A$NIJ;l$,A0C<IJ;l$H$7$FDj5A$5$l$F$$$^$9\e(B"
-   "\e$BIUB08l%U%!%$%k$,FI$_9~$^$l$F$$$^$;$s\e(B"
-   nil
-   nil
-   "\e$B<-=q$N%(%$%s%H%j$,B?2a$.$^$9\e(B"
-   "\e$BJQ49$7$h$&$H$9$kJ8;zNs$,D92a$.$^$9\e(B"
-   "\e$BIUB08l2r@ONN0h$,ITB-$7$F$$$^$9\e(B"
-   nil
-   "\e$B<!8uJdNN0h$,ITB-$7$F$$$^$9\e(B"
-   "\e$B8uJd$,\e(B 1 \e$B$D$b:n$l$^$;$s$G$7$?\e(B"
-   nil
-   nil
-   nil
-   nil
-   "\e$BFI$_$,D92a$.$^$9\e(B"
-   "\e$B4A;z$,D92a$.$^$9\e(B"
-   "\e$B;XDj$5$l$?<-=q$OEPO?2DG=$G$O$"$j$^$;$s\e(B"
-   "\e$BFI$_$ND9$5$,\e(B 0 \e$B$G$9\e(B"
-   "\e$B;XDj$5$l$?<-=q$O5U0z$-2DG=$G$O$"$j$^$;$s\e(B"
-   "\e$B%j!<%I%*%s%j!<$N<-=q$KEPO?\e(B/\e$B:o=|$7$h$&$H$7$^$7$?\e(B"
-   "\e$B4D6-$KB8:_$7$J$$<-=q$KEPO?$7$h$&$H$7$^$7$?\e(B"
-   nil
-   nil
-   "\e$B%j!<%I%*%s%j!<$NIQEY$rJQ99$7$h$&$H$7$^$7$?\e(B"
-   "\e$B;XDj$5$l$?C18l$,B8:_$7$^$;$s\e(B"
-   nil
-   nil
-   nil
-   nil
-   nil
-   nil
-   nil
-   nil
-   nil
-   "\e$B%a%b%j\e(B allocation \e$B$G<:GT$7$^$7$?\e(B"
-   nil
-   nil
-   nil
-   nil
-   nil
-   nil
-   nil
-   "\e$B2?$+$N%(%i!<$,5/$3$j$^$7$?\e(B"
-   "\e$B%P%0$,H/@8$7$F$$$kLOMM$G$9\e(B"
-   "\e$B%5!<%P$,;`$s$G$$$^$9\e(B"
-   "allocation \e$B$K<:GT$7$^$7$?\e(B"
-   "\e$B%5!<%P$H@\B3$G$-$^$;$s$G$7$?\e(B"
-   "\e$BDL?.%W%m%H%3%k$N%P!<%8%g%s$,9g$C$F$$$^$;$s\e(B"
-   "\e$B%/%i%$%"%s%H$N@8@.$7$?4D6-$G$O$"$j$^$;$s\e(B"
-   nil
-   nil
-   nil
-   nil
-   nil
-   "\e$B%G%#%l%/%H%j$r:n$k$3$H$,$G$-$^$;$s\e(B"
-   nil
-   nil
-   nil
-   nil
-   nil
-   nil
-   nil
-   nil
-   nil
-   "\e$B%U%!%$%k$rFI$_9~$`$3$H$,$G$-$^$;$s\e(B"
-   "\e$B%U%!%$%k$r=q$-=P$9$3$H$,$G$-$^$;$s\e(B"
-   "\e$B%/%i%$%"%s%H$NFI$_9~$s$@%U%!%$%k$G$O$"$j$^$;$s\e(B"
-   "\e$B$3$l0J>e%U%!%$%k$rFI$_9~$`$3$H$,$G$-$^$;$s\e(B"
-   "\e$B%Q%9%o!<%I$,4V0c$C$F$$$^$9\e(B"
-   "\e$B%U%!%$%k$,FI$_9~$^$l$F$$$^$9\e(B"
-   "\e$B%U%!%$%k$,:o=|$G$-$^$;$s\e(B"
-   "\e$B%U%!%$%k$,:n@.=PMh$^$;$s\e(B"
-   "WNN \e$B$N%U%!%$%k$G$"$j$^$;$s\e(B"
-   "\e$B%U%!%$%k$N\e(B inode \e$B$H\e(B FILE_UNIQ \e$B$r0lCW$5$;$k;v$,$G$-$^$;$s\e(B"
-   "\e$BIJ;l%U%!%$%k$,Bg$-2a$.$^$9\e(B"
-   "\e$BIJ;l%U%!%$%k$,Bg$-2a$.$^$9\e(B"
-   "\e$BIJ;l%U%!%$%k$,B8:_$7$^$;$s\e(B"
-   "\e$BIJ;l%U%!%$%k$NFbMF$,4V0c$C$F$$$^$9\e(B"
-   nil
-   "\e$BIJ;l%U%!%$%k$,FI$_9~$^$l$F$$$^$;$s\e(B"
-   "\e$BIJ;lL>$,4V0c$C$F$$$^$9\e(B"
-   "\e$BIJ;lHV9f$,4V0c$C$F$$$^$9\e(B"
-   nil
-   "\e$B$=$NA`:n$O%5%]!<%H$5$l$F$$$^$;$s\e(B"
-   "\e$B%Q%9%o!<%I$NF~$C$F$$$k%U%!%$%k$,%*!<%W%s$G$-$^$;$s\e(B"
-   "uumrc \e$B%U%!%$%k$,B8:_$7$^$;$s\e(B"
-   "uumrc \e$B%U%!%$%k$N7A<0$,8m$C$F$$$^$9\e(B"
-   "\e$B$3$l0J>e4D6-$r:n$k$3$H$O$G$-$^$;$s\e(B"
-   "\e$B$3$N%/%i%$%"%s%H$,FI$_9~$s$@%U%!%$%k$G$"$j$^$;$s\e(B"
-   "\e$B<-=q$KIQEY%U%!%$%k$,$D$$$F$$$^$;$s\e(B"
-   "\e$B%Q%9%o!<%I$N%U%!%$%k$,:n@.=PMh$^$;$s\e(B"
-]
+  '(("Japanese" .
+     [
+      nil
+      "\e$B%U%!%$%k$,B8:_$7$^$;$s\e(B"
+      nil
+      "\e$B%a%b%j\e(B allocation \e$B$G<:GT$7$^$7$?\e(B"
+      nil
+      "\e$B<-=q$G$O$"$j$^$;$s\e(B"
+      "\e$BIQEY%U%!%$%k$G$O$"$j$^$;$s\e(B"
+      "\e$BIUB08l%U%!%$%k$G$O$"$j$^$;$s\e(B"
+      nil
+      "\e$B<-=q%F!<%V%k$,0lGU$G$9\e(B"
+      "\e$BIQEY%U%!%$%k$,;XDj$5$l$?<-=q$NIQEY%U%!%$%k$G$O$"$j$^$;$s\e(B"
+      nil
+      nil
+      nil
+      nil
+      nil
+      "\e$B%U%!%$%k$,%*!<%W%s$G$-$^$;$s\e(B"
+      "\e$B@5$7$$IQEY%U%!%$%k$G$O$"$j$^$;$s\e(B"
+      "\e$B@5$7$$IUB08l%U%!%$%k$G$O$"$j$^$;$s\e(B"
+      "\e$BIUB08l$N8D?t\e(B, \e$B%Y%/%?D9$5$J$I$,B?2a$.$^$9\e(B"
+      "\e$B$=$NHV9f$N<-=q$O;H$o$l$F$$$^$;$s\e(B"
+      nil
+      nil
+      nil
+      "\e$BIUB08l%U%!%$%k$NFbMF$,@5$7$/$"$j$^$;$s\e(B"
+      "\e$B5?;wIJ;lHV9f$,0[>o$G$9\e(B(hinsi.data \e$B$,@5$7$/$"$j$^$;$s\e(B)"
+      "\e$BL$Dj5A$NIJ;l$,A0C<IJ;l$H$7$FDj5A$5$l$F$$$^$9\e(B"
+      "\e$BIUB08l%U%!%$%k$,FI$_9~$^$l$F$$$^$;$s\e(B"
+      nil
+      nil
+      "\e$B<-=q$N%(%$%s%H%j$,B?2a$.$^$9\e(B"
+      "\e$BJQ49$7$h$&$H$9$kJ8;zNs$,D92a$.$^$9\e(B"
+      "\e$BIUB08l2r@ONN0h$,ITB-$7$F$$$^$9\e(B"
+      nil
+      "\e$B<!8uJdNN0h$,ITB-$7$F$$$^$9\e(B"
+      "\e$B8uJd$,\e(B 1 \e$B$D$b:n$l$^$;$s$G$7$?\e(B"
+      nil
+      nil
+      nil
+      nil
+      "\e$BFI$_$,D92a$.$^$9\e(B"
+      "\e$B4A;z$,D92a$.$^$9\e(B"
+      "\e$B;XDj$5$l$?<-=q$OEPO?2DG=$G$O$"$j$^$;$s\e(B"
+      "\e$BFI$_$ND9$5$,\e(B 0 \e$B$G$9\e(B"
+      "\e$B;XDj$5$l$?<-=q$O5U0z$-2DG=$G$O$"$j$^$;$s\e(B"
+      "\e$B%j!<%I%*%s%j!<$N<-=q$KEPO?\e(B/\e$B:o=|$7$h$&$H$7$^$7$?\e(B"
+      "\e$B4D6-$KB8:_$7$J$$<-=q$KEPO?$7$h$&$H$7$^$7$?\e(B"
+      nil
+      nil
+      "\e$B%j!<%I%*%s%j!<$NIQEY$rJQ99$7$h$&$H$7$^$7$?\e(B"
+      "\e$B;XDj$5$l$?C18l$,B8:_$7$^$;$s\e(B"
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      "\e$B%a%b%j\e(B allocation \e$B$G<:GT$7$^$7$?\e(B"
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      "\e$B2?$+$N%(%i!<$,5/$3$j$^$7$?\e(B"
+      "\e$B%P%0$,H/@8$7$F$$$kLOMM$G$9\e(B"
+      "\e$B%5!<%P$,;`$s$G$$$^$9\e(B"
+      "allocation \e$B$K<:GT$7$^$7$?\e(B"
+      "\e$B%5!<%P$H@\B3$G$-$^$;$s$G$7$?\e(B"
+      "\e$BDL?.%W%m%H%3%k$N%P!<%8%g%s$,9g$C$F$$$^$;$s\e(B"
+      "\e$B%/%i%$%"%s%H$N@8@.$7$?4D6-$G$O$"$j$^$;$s\e(B"
+      nil
+      nil
+      nil
+      nil
+      nil
+      "\e$B%G%#%l%/%H%j$r:n$k$3$H$,$G$-$^$;$s\e(B"
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      "\e$B%U%!%$%k$rFI$_9~$`$3$H$,$G$-$^$;$s\e(B"
+      "\e$B%U%!%$%k$r=q$-=P$9$3$H$,$G$-$^$;$s\e(B"
+      "\e$B%/%i%$%"%s%H$NFI$_9~$s$@%U%!%$%k$G$O$"$j$^$;$s\e(B"
+      "\e$B$3$l0J>e%U%!%$%k$rFI$_9~$`$3$H$,$G$-$^$;$s\e(B"
+      "\e$B%Q%9%o!<%I$,4V0c$C$F$$$^$9\e(B"
+      "\e$B%U%!%$%k$,FI$_9~$^$l$F$$$^$9\e(B"
+      "\e$B%U%!%$%k$,:o=|$G$-$^$;$s\e(B"
+      "\e$B%U%!%$%k$,:n@.=PMh$^$;$s\e(B"
+      "WNN \e$B$N%U%!%$%k$G$"$j$^$;$s\e(B"
+      "\e$B%U%!%$%k$N\e(B inode \e$B$H\e(B FILE_UNIQ \e$B$r0lCW$5$;$k;v$,$G$-$^$;$s\e(B"
+      "\e$BIJ;l%U%!%$%k$,Bg$-2a$.$^$9\e(B"
+      "\e$BIJ;l%U%!%$%k$,Bg$-2a$.$^$9\e(B"
+      "\e$BIJ;l%U%!%$%k$,B8:_$7$^$;$s\e(B"
+      "\e$BIJ;l%U%!%$%k$NFbMF$,4V0c$C$F$$$^$9\e(B"
+      nil
+      "\e$BIJ;l%U%!%$%k$,FI$_9~$^$l$F$$$^$;$s\e(B"
+      "\e$BIJ;lL>$,4V0c$C$F$$$^$9\e(B"
+      "\e$BIJ;lHV9f$,4V0c$C$F$$$^$9\e(B"
+      nil
+      "\e$B$=$NA`:n$O%5%]!<%H$5$l$F$$$^$;$s\e(B"
+      "\e$B%Q%9%o!<%I$NF~$C$F$$$k%U%!%$%k$,%*!<%W%s$G$-$^$;$s\e(B"
+      "uumrc \e$B%U%!%$%k$,B8:_$7$^$;$s\e(B"
+      "uumrc \e$B%U%!%$%k$N7A<0$,8m$C$F$$$^$9\e(B"
+      "\e$B$3$l0J>e4D6-$r:n$k$3$H$O$G$-$^$;$s\e(B"
+      "\e$B$3$N%/%i%$%"%s%H$,FI$_9~$s$@%U%!%$%k$G$"$j$^$;$s\e(B"
+      "\e$B<-=q$KIQEY%U%!%$%k$,$D$$$F$$$^$;$s\e(B"
+      "\e$B%Q%9%o!<%I$N%U%!%$%k$,:n@.=PMh$^$;$s\e(B"
+      ])
+    ("Chinese-GB" .
+     [
+      nil
+      "\e$AND<~2;4fTZ\e(B"
+      nil
+      "\e$ADZ4f\e(Balloc\e$AJ'0\\e(B"
+      nil
+      "\e$A2;JGWV5d\e(B"
+      "\e$A2;JGF56HND<~\e(B"
+      "\e$A2;JGND7(ND<~\e(B"
+      nil
+      "\e$AWV5d1m8qBz\e(B"
+      "\e$AF56HND<~#:2;JGV86(5DWV5d5DF56HND<~\e(B"
+      nil
+      nil
+      nil
+      nil
+      nil
+      "\e$AND<~2;D\4r?*\e(B"
+      "\e$A2;JGU}H75DF56HND<~\e(B"
+      "\e$A2;JGU}H75DND7(ND<~\e(B"
+      "\e$A8=JtSo5D8vJ}!"OrA?3$6H5H3,9}\e(B"
+      "\e$AUb8v:EBk5DWV5d!"C;SPJ9SC\e(B"
+      nil
+      nil
+      nil
+      "\e$AND7(ND<~5DDZH]2;U}H7\e(B"
+      "\e$APiDb4JPT:EBkRl3#\e(Bcixing.data\e$A2;U}H7\e(B"
+      "\e$AN46(Re5D4JPT!"6(ReAKG06K4JPT\e(B"
+      "\e$AND7(ND<~2;D\6AH!\e(B"
+      nil
+      nil
+      "\e$AWV5d5DOnJ}3,9}\e(B"
+      "\e$A1d;;:sWV7{4.5D3$6H3,9}\e(B"
+      "\e$A8=JtSo=bNvSr2;9;\e(B"
+      nil
+      "\e$A4N:n29Sr2;9;\e(B"
+      "\e$A:n29\e(B 1\e$A8vR2C;SP\e(B"
+      nil
+      nil
+      nil
+      nil
+      "\e$A6ARt3$6H3,9}\e(B"
+      "\e$A::WV3$6H3,9}\e(B"
+      "\e$AV86(5DWV5d!"2;D\5GB<\e(B"
+      "\e$A6ARt5D3$6HJG\e(B0"
+      "\e$AV86(5DWV5d!"2;D\Df2i\e(B"
+      "\e$AV;6A5DWV5d!"5GB<\e(B/\e$AO{3}AK\e(B"
+      "\e$A;7>3VP2;4fTZ5DWV5d!"5GB<AK\e(B"
+      nil
+      nil
+      "\e$AV;6A5DF56H!"1d8|AK\e(B"
+      "\e$AV86(5D5%WV2;4fTZ\e(B"
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      "\e$ADZ4f\e(Balloc\e$AJ'0\\e(B"
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      "\e$ASP3v4m7"Iz\e(B"
+      "\e$A:COsSP#b#u#g7"Iz\e(B"
+      "server\e$AK@AK\e(B"
+      "alloc\e$AJ'0\AK\e(B"
+      "\e$A2;D\:M\e(Bserver\e$AA,=S\e(B"
+      "\e$AM(PE9f3L5D0f1>2;7{\e(B"
+      "\e$A2;JG#c#W#n#nSC;'Iz3I5D;7>3\e(B"
+      nil
+      nil
+      nil
+      nil
+      nil
+      "\e$AWSD?B<2;D\44=(\e(B"
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      "\e$AND<~2;D\6AH!\e(B"
+      "\e$AND<~2;D\P43v\e(B"
+      "\e$A2;JG#c#W#n#nSC;'?I6AH!5DND<~\e(B"
+      "\e$ARTIO5DND<~2;D\6AH!\e(B"
+      "password\e$A2;6T\e(B"
+      "\e$AND<~U}TZ6AH!\e(B"
+      "\e$AND<~2;D\O{3}\e(B"
+      "\e$AND<~C;SP44=(3v@4\e(B"
+      "\e$A2;JG#c#W#n#n5DND<~\e(B"
+      "\e$AND<~5D\e(BI-node\e$A:M\e(BFILE_UNIQ\e$A2;D\R;VB\e(B"
+      "\e$A4JPTND<~L+4s\e(B"
+      "\e$A4JPTND<~L+4s\e(B"
+      "\e$A4JPTND<~2;4fTZ\e(B"
+      "\e$A4JPTND<~5DDZH]2;6T\e(B"
+      nil
+      "\e$A4JPTND<~2;D\6AH!\e(B"
+      "\e$A4JPTC{2;6T\e(B"
+      "\e$A4JPT:EBk2;6T\e(B"
+      nil
+      "\e$AUb8v2YWw2;V'3V\e(B"
+      "password\e$A5DJdHkND<~2;D\4r?*\e(B"
+      "uumrc\e$AND<~2;4fTZ\e(B"
+      "uumrc\e$AND<~5DPNJ=4mNs\e(B"
+      "\e$ARTIO;7>32;D\44=(\e(B"
+      "\e$AUb8v#c#W#n#nSC;'!"6AH!5DND<~C;SP\e(B"
+      "\e$AWV5d5DF56HND<~C;SP\e(B"
+      "password\e$A5DND<~C;SP44=(3v@4\e(B"
+      ])
+    ("Chinese-CNS" .
+     [
+      nil
+      "\e$(GEFG5DbGtGc\e(B"
+      nil
+      "\e$(GDyGt\e(Balloc\e$(GFBZu\e(B"
+      nil
+      "\e$(GDbQRGsL(\e(B"
+      "\e$(GDbQRs"PyEFG5\e(B"
+      "\e$(GDbQREFNNEFG5\e(B"
+      nil
+      "\e$(GGsL(OPV*iH\e(B"
+      "\e$(Gs"PyEFG5!3DbQRQ@LyN{GsL(N{s"PyEFG5\e(B"
+      nil
+      nil
+      nil
+      nil
+      nil
+      "\e$(GEFG5DbWdFTbd\e(B"
+      "\e$(GDbQRF_m}N{s"PyEFG5\e(B"
+      "\e$(GDbQRF_m}N{EFNNEFG5\e(B"
+      "\e$(GOazhk#N{T6m0!#GWbXO[Pya+b>g4\e(B"
+      "\e$(G]UT6f@n#N{GsL(!#JtH4KpFn\e(B"
+      nil
+      nil
+      nil
+      "\e$(GEFNNEFG5N{DyU)DbF_m}\e(B"
+      "\e$(Gapsib$MLf@n#\,Z&\e(Bcixing.data\e$(GDbF_m}\e(B"
+      "\e$(GF\LyexN{b$ML!#LyexD'P)j&b$ML\e(B"
+      "\e$(GEFNNEFG5DbWd{tL=\e(B"
+      nil
+      nil
+      "\e$(GGsL(N{bzm0b>g4\e(B"
+      "\e$(G|H_PG[Gs\JHkN{O[Pyb>g4\e(B"
+      "\e$(GOazhk#fXN5YQDbY\\e(B"
+      nil
+      "\e$(GH9OlfPYQDbY\\e(B"
+      "\e$(GOlfP\e(B 1\e$(GT6D>JtH4\e(B"
+      nil
+      nil
+      nil
+      nil
+      "\e$(G{tSvO[Pyb>g4\e(B"
+      "\e$(GiGGsO[Pyb>g4\e(B"
+      "\e$(GQ@LyN{GsL(!#DbWd`trg\e(B"
+      "\e$(G{tSvN{O[PyQR\e(B0"
+      "\e$(GQ@LyN{GsL(!#DbWdXKQg\e(B"
+      "\e$(GF7{tN{GsL(!#`trg\e(B/\e$(GV<XfD'\e(B"
+      "\e$(Gt?h:DcDbGtGcN{GsL(!#`trgD'\e(B"
+      nil
+      nil
+      "\e$(GF7{tN{s"Py!#|HJUD'\e(B"
+      "\e$(GQ@LyN{^LGsDbGtGc\e(B"
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      "\e$(GDyGt\e(Balloc\e$(GFBZu\e(B"
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      "\e$(GH4Exrc`uFm\e(B"
+      "\e$(GGob/H4$\$o$a`uFm\e(B"
+      "server\e$(GH;D'\e(B"
+      "alloc\e$(GFBZuD'\e(B"
+      "\e$(GDbWdLO\e(Bserver\e$(G]YZY\e(B"
+      "\e$(G]WOj]=a#N{NjF[Db\J\e(B"
+      "\e$(GDbQR$]$q$h$hFnEBFmH)N{t?h:\e(B"
+      nil
+      nil
+      nil
+      nil
+      nil
+      "\e$(GDMFxrgDbWd^6Pz\e(B"
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      "\e$(GEFG5DbWd{tL=\e(B"
+      "\e$(GEFG5DbWdlQEx\e(B"
+      "\e$(GDbQR$]$q$h$hFnEBF+{tL=N{EFG5\e(B"
+      "\e$(GEhD8N{EFG5DbWd{tL=\e(B"
+      "password\e$(GDbhW\e(B"
+      "\e$(GEFG5F_Gc{tL=\e(B"
+      "\e$(GEFG5DbWdV<Xf\e(B"
+      "\e$(GEFG5JtH4^6PzExKt\e(B"
+      "\e$(GDbQR$C$W$h$hN{EFG5\e(B"
+      "\e$(GEFG5N{\e(BI-node\e$(GLO\e(BFILE_UNIQ\e$(GDbWdD!S3\e(B"
+      "\e$(Gb$MLEFG5E4DK\e(B"
+      "\e$(Gb$MLEFG5E4DK\e(B"
+      "\e$(Gb$MLEFG5DbGtGc\e(B"
+      "\e$(Gb$MLEFG5N{DyU)DbhW\e(B"
+      nil
+      "\e$(Gb$MLEFG5DbWd{tL=\e(B"
+      "\e$(Gb$MLGXDbhW\e(B"
+      "\e$(Gb$MLf@n#DbhW\e(B"
+      nil
+      "\e$(G]UT6pgI"DbEEQ=\e(B"
+      "password\e$(GN{rSD+EFG5DbWdFTbd\e(B"
+      "cwnnrc\e$(GEFG5DbGtGc\e(B"
+      "cwnnrc\e$(GEFG5N{J0H"rck(\e(B"
+      "\e$(GEhD8t?h:DbWd^6Pz\e(B"
+      "\e$(G]UT6$C$W$h$hFnEB!#{tL=N{EFG5JtH4\e(B"
+      "\e$(GGsL(N{s"PyEFG5JtH4\e(B"
+      "password\e$(GN{EFG5JtH4^6PzExKt\e(B"
+      ])
+    ("Korean" .
+     [
+      nil
+      "\e$(CH-@O@L\e(B \e$(CA8@gGOAv\e(B \e$(C>J=@4O4Y\e(B"
+      nil
+      "\e$(C8^8p8.\e(B alloc \e$(C?!<-\e(B \e$(C=GFPG_@>4O4Y\e(B"
+      nil
+      "\e$(C;g@|@L\e(B \e$(C>F4U4O4Y\e(B"
+      "\e$(C:s55\e(B \e$(CH-@O@L\e(B \e$(C>F4U4O4Y\e(B"
+      "\e$(C:N<S>n\e(B \e$(CH-@O@L\e(B \e$(C>F4U4O4Y\e(B"
+      nil
+      "\e$(C;g@|\e(B \e$(CEW@L:m@L\e(B \e$(C2K\e(B \e$(CC!@>4O4Y\e(B"
+      "\e$(CAvA$5H\e(B \e$(C;g@|@G\e(B \e$(C:s55\e(B \e$(CH-@O@L\e(B \e$(C>F4U4O4Y\e(B"
+      nil
+      nil
+      nil
+      nil
+      nil
+      "\e$(CH-@O@;\e(B \e$(C?-\e(B \e$(C<v\e(B \e$(C>x@>4O4Y\e(B"
+      "\e$(C8B4B\e(B \e$(C:s55\e(B \e$(CH-@O@L\e(B \e$(C>F4U4O4Y\e(B"
+      "\e$(C8B4B\e(B \e$(C:N<S>n\e(B \e$(CH-@O@L\e(B \e$(C>F4U4O4Y\e(B"
+      "\e$(C:N<S>n@G\e(B \e$(C09<v0!\e(B \e$(C3J9+\e(B \e$(C890E3*\e(B \e$(C:$EM@G\e(B \e$(C1f@L0!\e(B \e$(C3J9+\e(B \e$(C1i4O4Y\e(B"
+      "\e$(C1W\e(B \e$(C9xH#@G\e(B \e$(C;g@|@:\e(B \e$(C;g?k5G0m\e(B \e$(C@VAv\e(B \e$(C>J=@4O4Y\e(B"
+      nil
+      nil
+      nil
+      "\e$(C:N<S>n\e(B \e$(CH-@O@G\e(B \e$(C3;?k@L\e(B \e$(C8BAv\e(B \e$(C>J=@4O4Y\e(B"
+      "\e$(C0!;s\e(B \e$(CG0;g@G\e(B \e$(C9xH#0!\e(B \e$(CF2834O4Y\e(B. hinsi.data \e$(C0!\e(B \e$(C8BAv\e(B \e$(C>J=@4O4Y\e(B"
+      "\e$(C9LA$@G@G\e(B \e$(CG0;g0!\e(B \e$(C@|4\\e(B \e$(CG0;g7N\e(B \e$(CA$@G5G>n\e(B \e$(C@V=@4O4Y\e(B"
+      "\e$(C:N<S>n\e(B \e$(CH-@O@L\e(B \e$(C@PGtA.\e(B \e$(C@VAv\e(B \e$(C>J=@4O4Y\e(B"
+      nil
+      nil
+      "\e$(C;g@|@G\e(B \e$(C?#F.8.0!\e(B \e$(C3J9+\e(B \e$(C89=@4O4Y\e(B"
+      "\e$(C:/H/GO7A4B\e(B \e$(C9.@Z?-@L\e(B \e$(C3J9+\e(B \e$(C1i4O4Y\e(B"
+      "\e$(C:N<S>n\e(B \e$(CGX<.\e(B \e$(C?5?*@L\e(B \e$(C:NA7GU4O4Y\e(B"
+      nil
+      "\e$(C4Y@=\e(B \e$(CHD:8\e(B \e$(C?5?*@L\e(B \e$(C:NA7GU4O4Y\e(B"
+      "\e$(CHD:80!\e(B \e$(C>x@>4O4Y\e(B"
+      nil
+      nil
+      nil
+      nil
+      "\e$(CGQ1[@L\e(B \e$(C3J9+\e(B \e$(C1i4O4Y\e(B"
+      "\e$(CGQ@Z0!\e(B \e$(C3J9+\e(B \e$(C1i4O4Y\e(B"
+      "\e$(CAvA$5H\e(B \e$(C;g@|@:\e(B \e$(C5n7O\e(B \e$(C:R0!4I@T4O4Y\e(B"
+      "\e$(CGQ1[@G\e(B \e$(C1f@L0!\e(B 0 \e$(C@T4O4Y\e(B"
+      "\e$(CAvA$5H\e(B \e$(C;g@|@:\e(B \e$(C?*B|A6\e(B \e$(C:R0!4I@T4O4Y\e(B"
+      "\e$(C@P1b@|?k\e(B \e$(C;g@|?!\e(B \e$(C5n7O\e(B/\e$(C<R0E\e(B \e$(CGO7A0m\e(B \e$(CG_@>4O4Y\e(B"
+      "\e$(CA8@gGOAv\e(B \e$(C>J4B\e(B \e$(C;g@|?!\e(B \e$(C5n7O\e(B \e$(CGO7A0m\e(B \e$(CG_@>4O4Y\e(B"
+      nil
+      nil
+      "\e$(C@P1b@|?k\e(B \e$(C:s558&\e(B \e$(C0f=E\e(B \e$(CGO7A0m\e(B \e$(CG_@>4O4Y\e(B"
+      "\e$(CAvA$5H\e(B \e$(C4\>n4B\e(B \e$(CA8@gGOAv\e(B \e$(C>J=@4O4Y\e(B"
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      "\e$(C8^8p8.\e(B alloc \e$(C?!\e(B \e$(C=GFPG_@>4O4Y\e(B"
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      "\e$(C?!7/0!\e(B \e$(C9_;}G_@>4O4Y\e(B"
+      "\e$(C9v1W\e(B(Bug)\e$(C0!\e(B \e$(C9_;}G_@>4O4Y\e(B"
+      "\e$(C<-9v\e(B(Server)\e$(C0!\e(B \e$(CAW>n\e(B \e$(C@V@>4O4Y\e(B"
+      "alloc\e$(C?!\e(B \e$(C=GFPG_@>4O4Y\e(B"
+      "\e$(C<-9v\e(B(Server) \e$(C?M\e(B \e$(CA"CKGR\e(B \e$(C<v\e(B \e$(C>x@>4O4Y\e(B"
+      "\e$(CEk=E\e(B \e$(CGA7NEdD]@G\e(B \e$(C9vA/@L\e(B \e$(C8BAv\e(B \e$(C>J=@4O4Y\e(B"
+      "\e$(CE,6s@L>HF.0!\e(B \e$(C;}<:GQ\e(B \e$(CH/0f@L\e(B \e$(C>F4U4O4Y\e(B"
+      nil
+      nil
+      nil
+      nil
+      nil
+      "\e$(C5p7:Ed8.8&\e(B \e$(C885i\e(B \e$(C<v\e(B \e$(C>x@>4O4Y\e(B"
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      "\e$(CH-@O\e(B \e$(C@P1b?!\e(B \e$(C=GFPG_@>4O4Y\e(B"
+      "\e$(CH-@O\e(B \e$(C>21b?!\e(B \e$(C=GFPG_@>4O4Y\e(B"
+      "\e$(CE,6s@L>HF.0!\e(B \e$(C@P>n\e(B \e$(C5e80\e(B \e$(CH-@O@L\e(B \e$(C>F4U4O4Y\e(B"
+      "\e$(C4u\e(B \e$(C@L;s@G\e(B \e$(CH-@O@;\e(B \e$(C@P>n\e(B \e$(C5e81\e(B \e$(C<v\e(B \e$(C>x@>4O4Y\e(B"
+      "\e$(CFP=:?v5e0!\e(B \e$(CF2834O4Y\e(B"
+      "\e$(CH-@O@L\e(B \e$(C@PGtA.\e(B \e$(C@V@>4O4Y\e(B"
+      "\e$(CH-@O@;\e(B \e$(C<R0EGR\e(B \e$(C<v\e(B \e$(C>x@>4O4Y\e(B"
+      "\e$(CH-@O@;\e(B \e$(C@[<:GR\e(B \e$(C<v\e(B \e$(C>x@>4O4Y\e(B"
+      "kWnn\e$(C@G\e(B \e$(CH-@O@L\e(B \e$(C>F4U4O4Y\e(B"
+      "\e$(CH-@O@G\e(B I-node \e$(C?M\e(B FILE_UNIQ \e$(C8&\e(B \e$(C@OD!=CE3\e(B \e$(C<v\e(B \e$(C>x@>4O4Y\e(B"
+      "\e$(CG0;g\e(B \e$(CH-@O@G\e(B \e$(CE)1b0!\e(B \e$(C3J9+\e(B \e$(CE.4O4Y\e(B"
+      "\e$(CG0;g\e(B \e$(CH-@O@G\e(B \e$(CE)1b0!\e(B \e$(C3J9+\e(B \e$(CE.4O4Y\e(B"
+      "\e$(CG0;g\e(B \e$(CH-@O@L\e(B \e$(CA8@gGOAv\e(B \e$(C>J=@4O4Y\e(B"
+      "\e$(CG0;g\e(B \e$(CH-@O@G\e(B \e$(C3;?k@L\e(B \e$(CF2834O4Y\e(B"
+      nil
+      "\e$(CG0;g\e(B \e$(CH-@O@L\e(B \e$(C@PGtA.\e(B \e$(C@VAv\e(B \e$(C>J=@4O4Y\e(B"
+      "\e$(CG0;g\e(B \e$(C@L8'@L\e(B \e$(CF2834O4Y\e(B"
+      "\e$(CG0;g\e(B \e$(C9xH#0!\e(B \e$(CF2834O4Y\e(B"
+      nil
+      "\e$(C1W\e(B \e$(CA6@[@:\e(B \e$(CAv?x5GAv\e(B \e$(C>J=@4O4Y\e(B"
+      "\e$(CFP=:?v5e0!\e(B \e$(C5i>n@V4B\e(B \e$(CH-@O@;\e(B \e$(C?-\e(B \e$(C<v\e(B \e$(C>x@>4O4Y\e(B"
+      "uumrc \e$(C@L\e(B \e$(CA8@gGOAv\e(B \e$(C>J=@4O4Y\e(B"
+      "uumrc \e$(C@G\e(B \e$(CG|=D@L\e(B \e$(CF2834O4Y\e(B"
+      "\e$(C@L\e(B \e$(C@L;s\e(B \e$(CH/0f@;\e(B \e$(C@[<:GR\e(B \e$(C<v\e(B \e$(C>x@>4O4Y\e(B"
+      "\e$(CE)6s@L>HF.0!\e(B \e$(C@P>n\e(B \e$(C5e80\e(B \e$(CH-@O@L\e(B \e$(C>F4U4O4Y\e(B"
+      "\e$(C;g@|?!\e(B \e$(C:s55\e(B \e$(CH-@O@L\e(B \e$(CA8@gGOAv\e(B \e$(C>J=@4O4Y\e(B"
+      "\e$(CFP=:?v5e\e(B \e$(CH-@O@;\e(B \e$(C@[<:GR\e(B \e$(C<v\e(B \e$(C>x@>4O4Y\e(B"
+      ]))
   "Array of WNN error messages.  Indexed by error code.")
 
 (defun wnnrpc-get-error-message (errno)
   "Return error message string specified by ERRNO."
-  (or (aref wnnrpc-error-message errno) (format "#%d" errno)))
+  (let ((msg (or (assoc egg-default-language wnnrpc-error-message)
+                (assoc its-current-language wnnrpc-error-message)
+                (assoc "Japanese" wnnrpc-error-message))))
+    (or (aref (cdr msg) errno) (format "#%d" errno))))
 
 (defmacro wnnrpc-call-with-environment (e vlist send-expr &rest receive-exprs)
   (let ((v (append
            `((proc (wnnenv-get-proc ,e))
-             (env-id (wnnenv-get-env-id ,e)))
+             (env-id (wnnenv-get-env-id ,e))
+             (egg-zhuyin its-zhuyin))
            vlist)))
     (list
      'let v

diff --git a/its-keydef.el b/its-keydef.el
new file mode 100644 (file)
index 0000000..90b77f1
--- /dev/null
+++ b/its-keydef.el
@@ -0,0 +1,60 @@
+(eval-when-compile
+  (require 'cl))
+
+(defvar its-current-language "Japanese")
+
+(defvar its-zhuyin nil)
+(make-variable-buffer-local 'its-zhuyin)
+
+(defmacro its-make-slect-func (key name file map &optional lang zhuyin)
+  (setq name (intern (concat "its-select-" (symbol-name name)))
+       file (intern (concat "its/" (symbol-name file)))
+       map (intern (concat "its-" (symbol-name map) "-map"))
+       lang (symbol-name lang))
+  `(progn
+     (defun ,name ()
+       (interactive)
+       (cond
+       ((its-in-fence-p)
+        (its-input-end)
+        (its-put-cursor t))
+       ((egg-get-bunsetsu-info (point))
+        (egg-exit-conversion)))
+       ,(if lang `(egg-check-language ,lang))
+       (require ',file)
+       (setq its-current-map ,map)
+       ,(if lang `(setq its-current-language ,lang))
+       ,(if zhuyin `(setq its-zhuyin ,(eq zhuyin 'T)))
+       (egg-set-mode-line-title (its-get-indicator its-current-map)))
+     (define-key mule-keymap ,key ',name)))
+
+(defmacro its-do-list-make-slect-func (list)
+  (eval-when (eval compile)
+    (let (e l)
+      (while list
+       (setq e (car list))
+       (setq l (cons `(its-make-slect-func ,@(car list)) l))
+       (setq list (cdr list)))
+      (cons 'progn l))))
+
+(its-do-list-make-slect-func
+ (("Q"    upcase               ascii    up)
+  ("q"    downcase             ascii    down)
+  ("h"    hiragana             hira     hira             Japanese)
+  ("K"    katakana             kata     kata             Japanese)
+  ("x"    hankaku-katakana     hankata  han-kata         Japanese)
+  ("Z"    zenkaku-upcase       zenkaku  zenkaku-up       Japanese)
+  ("z"    zenkaku-downcase     zenkaku  zenkaku-down     Japanese)
+  ("\C-e" erpin-cn             erpin    erpin-cn         Chinese-GB NIL)
+  ("\C-p" pinyin-cn            pinyin   pinyin-cn        Chinese-GB NIL)
+  ("\C-z" zhuyin-cn            zhuyin   zhuyin-cn        Chinese-GB T)
+  ("\C-u" quanjiao-upcase-cn   quanjiao quanjiao-up-cn   Chinese-GB)
+  ("\C-d" quanjiao-downcase-cn quanjiao quanjiao-down-cn Chinese-GB)
+  ("E"    erpin-tw             erpin    erpin-tw         Chinese-CNS NIL)
+  ("P"    pinyin-tw            pinyin   pinyin-tw        Chinese-CNS NIL)
+  ("Z"    zhuyin-tw            zhuyin   zhuyin-tw        Chinese-CNS T)
+  ("U"    quanjiao-upcase-tw   quanjiao quanjiao-up-tw   Chinese-CNS)
+  ("D"    quanjiao-downcase-tw quanjiao quanjiao-down-tw Chinese-CNS)
+  ("H"    hangul               hangul   hangul           Korean)
+  ("J"    jeonkak-upcase       jeonkak  jeonkak-up       Korean)
+  ("j"    jeonkak-downcase     jeonkak  jeonkak-down     Korean)))

diff --git a/its.el b/its.el
index 6a19430..26aeb04 100644 (file)
--- a/its.el
+++ b/its.el
@@ -1,21 +1,22 @@
 ;;; its.el --- Input Translation Systam AKA "ITS(uDekirunDa!)"
 
-;; Copyright (C) 1997 Mule Project, Powered by Electrotechnical
+;; Copyright (C) 1997, 1998 Mule Project, Powered by Electrotechnical
 ;; Laboratory, JAPAN.
 ;; Project Leader: Satoru Tomura <tomura@etl.go.jp>
 
 ;; Author: NIIBE Yutaka <gniibe@mri.co.jp>
+;;         KATAYAMA Yoshio <kate@pfu.co.jp>
 ;; Maintainer: NIIBE Yutaka <gniibe@mri.co.jp>
 ;; Keywords: mule, multilingual, input method
 
 ;; This file will be part of GNU Emacs (in future).
 
-;; GNU Emacs is free software; you can redistribute it and/or modify
+;; EGG is free software; you can redistribute it and/or modify
 ;; it under the terms of the GNU General Public License as published by
 ;; the Free Software Foundation; either version 2, or (at your option)
 ;; any later version.
 
-;; GNU Emacs is distributed in the hope that it will be useful,
+;; EGG is distributed in the hope that it will be useful,
 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 ;; GNU General Public License for more details.
@@ -29,6 +30,11 @@
 
 ;;; Code:
 
+(require 'cl)
+
+(defvar its-current-language)
+(make-variable-buffer-local 'its-current-language)
+\f
 ;; Data structure in ITS
 ;; (1) SYL and CURSOR
 ;;
@@ -82,30 +88,27 @@
 
 ;; Data structure in ITS (3) Map
 ;;
-;; <map>         ::= ( <name> . ( <indicator> . <start-state> ) )
-;; <start-state> ::= <state>
+;; <map>         ::= ( <name> <indicator> <language> . <start-state> )
 ;; <name>        ::= "string"
 ;; <indicator>   ::= "string"
+;; <language>    ::= "string"
+;; <start-state> ::= <state>
 ;;
 \f
 (defsubst its-new-state (output keyseq back)
   (cons output (cons keyseq back)))
 
-(defsubst its-new-map (name indicator)
-  (cons name (cons indicator (its-new-state "" "" nil))))
+(defsubst its-new-map (name indicator language)
+  (cons name (cons indicator (cons language (its-new-state "" "" nil)))))
 
 (defsubst its-get-indicator (map)
-  (car (cdr map)))
+  (nth 1 map))
 
-(defsubst its-set-indicator (map indicator)
-  (setcar (cdr map) indicator))
+(defsubst its-get-language (map)
+  (nth 2 map))
 
 (defsubst its-get-start-state (map)
-  (cdr (cdr map)))
-
-(defsubst its-reset-start-state (map)
-  (setcdr (cdr map) (its-new-state "" "" nil))
-  map)
+  (nthcdr 3 map))
 
 (defsubst its-get-kst/t (state)
   (cdr (cdr state)))
@@ -118,6 +121,7 @@
 
 (defsubst its-set-keyseq (state keyseq)
   (setcar (cdr state) keyseq))
+
 (defun its-get-keyseq-cooked (state)
   (let ((keyseq (its-get-keyseq state))
        (back (its-get-kst/t state)))
@@ -377,6 +381,8 @@
     (insert (its-get-output newsyl))
     (add-text-properties p (point)
                         (list 'its-syl newsyl
+                              'its-map its-current-map
+                              'its-lang its-current-language
                               'intangible 'its-part-1))
     (if its-fence-face
        (put-text-property p (point) 'face its-fence-face))))
@@ -425,29 +431,16 @@
       (setq its-map-alist (cons map its-map-alist)))
     map))
 
-(defun its-define-state-machine (name indicator &optional continue)
-  "NAME \e$B$G;XDj$5$l$?\e(B State Machine \e$B$NDj5A$r3+;O$9$k!#\e(B
-INDICATOR \e$B$O\e(B mode line \e$B$KI=<($9$k\e(B indicator \e$B$r;XDj$9$k!#\e(B
-CONTINUE \e$B$,\e(B nil \e$B$N;~$K$O\e(B State Machine \e$B$NDj5A$r6u$K$9$k!#\e(Bits-defrule 
-\e$B$r;2>H!#\e(B"
-  (setq its-current-map
-       (if (null (its-get-map name))
-           (its-register-map (its-new-map name indicator))
-         (let ((map (its-get-map name)))
-           (its-set-indicator map indicator)
-           (if continue
-               map
-             (its-reset-start-state map))))))
-
-(defmacro define-its-state-machine (map name indicator doc &rest exprs)
-  `(let ((its-current-map (its-new-map ,name ,indicator)))
-     ,(cons 'progn exprs)
-     (defconst ,map its-current-map ,doc)))
-
-;;(defmacro define-its-state-machine (map name indicator doc &rest exprs)
-;;  (let ((its-current-map (its-new-map name indicator)))
-;;    (eval (cons 'progn exprs))
-;;    `(defconst ,map ',its-current-map ,doc)))
+(defmacro define-its-state-machine (map name indicator lang doc &rest exprs)
+  `(progn
+     (eval-when (eval compile)
+       (let ((its-current-map (its-new-map ,name ,indicator ,lang)))
+        ,@exprs
+        (setq ,map its-current-map)))
+     (define-its-compiled-map ,map ,doc)))
+
+(defmacro define-its-compiled-map (map doc)
+  `(defconst ,map ',(symbol-value map) ,doc))
 
 (defmacro define-its-state-machine-append (map &rest exprs)
   (append
@@ -525,8 +518,8 @@ Return last state."
       (let ((begpos (previous-single-property-change (point) 'its-start)))
        ;; Make SYLs have property of "part 2"
        (put-text-property begpos (point) 'intangible 'its-part-2)
-       (goto-char begpos)
-       (its-put-cursor t))))
+       (goto-char begpos)))
+  (its-put-cursor t))
 
 (defun its-end-of-input-buffer ()
   (interactive)
@@ -535,8 +528,8 @@ Return last state."
       (let ((endpos (next-single-property-change (point) 'its-end)))
        ;; Make SYLs have property of "part 1"
        (put-text-property (point) endpos 'intangible 'its-part-1)
-       (goto-char endpos)
-       (its-put-cursor t))))
+       (goto-char endpos)))
+  (its-put-cursor t))
 
 ;; TODO: move in VSYL
 (defun its-backward-SYL (n)
@@ -568,7 +561,7 @@ Return last state."
       (setq syl (get-text-property p 'its-syl))
       (setq n (1- n)))
     ;; Make SYLs have property of "part 1"
-    (put-text-property p old-point'intangible 'its-part-1)
+    (put-text-property p old-point 'intangible 'its-part-1)
     (goto-char p)
     (its-put-cursor t)
     (if (> n 0)
@@ -631,7 +624,8 @@ Return last state."
 (defun its-delete-backward-within-SYL (syl n killflag)
   (let* ((keyseq (its-get-keyseq-syl syl))
         (len (length keyseq))
-        (p (point)))
+        (p (point))
+        (its-current-map (get-text-property (1- (point)) 'its-map)))
     (if (> n len)
        (signal 'args-out-of-range (list p n)))
     ;; Delete CURSOR
@@ -695,10 +689,12 @@ Return last state."
     (delete-region end (1+ end))
     ;; Remove all properties added by ITS
     (remove-text-properties start end '(its-syl nil
+                                       its-map nil
                                        face nil
                                        intangible nil))
     (if proceed-to-conversion
        (egg-convert-region start end)
+      (remove-text-properties start end '(its-lang nil))
       (egg-do-auto-fill)
       (run-hooks 'input-method-after-insert-chunk-hook))))
 
@@ -706,6 +702,10 @@ Return last state."
   (interactive)
   (its-input-end)
   (its-exit-mode-internal t))
+
+(defun its-in-fence-p ()
+  (let ((prop (get-text-property (point) 'intangible)))
+    (or (eq prop 'its-part-1) (eq prop 'its-part-2))))
 \f
 (defvar its-translation-result nil "")
 
@@ -739,51 +739,7 @@ Return last state."
     (delete-region start end)
     (apply 'insert (reverse its-translation-result))))
 \f
-(defvar its-select-map-menu '(menu "Map:" nil))
-
-(defun its-select-map-from-menu ()
-  (interactive)
-  (setcar (nthcdr 2 its-select-map-menu) its-map-alist)
-  (setq its-current-map (menudiag-select its-select-map-menu))
-  (force-mode-line-update))
-
-(defun its-select-hiragana ()
-  (interactive)
-  (its-select-map "roma-kana"))
-
-(defun its-select-katakana ()
-  (interactive)
-  (its-select-map "roma-kata"))
-
-(defun its-select-downcase ()
-  (interactive)
-  (its-select-map "downcase"))
-
-(defun its-select-upcase ()
-  (interactive)
-  (its-select-map "upcase"))
-
-(defun its-select-zenkaku-downcase ()
-  (interactive)
-  (its-select-map "zenkaku-downcase"))
-
-(defun its-select-zenkaku-upcase ()
-  (interactive)
-  (its-select-map "zenkaku-upcase"))
-
-(defun its-select-map (name)
-  (interactive (list (completing-read "ITS map: " its-map-alist)))
-  (if (its-get-map name)
-      (progn
-       (setq its-current-map (its-get-map name))
-       (force-mode-line-update))
-    (ding)))
-\f
-;; Escape character to Zenkaku inputs
-(defconst its-zenkaku-escape "Z")
-
-;; Escape character to Hankaku inputs
-(defconst its-hankaku-escape "~")
+(load "its-keydef.el")
 
 (provide 'its)
 ;;; its.el ends here.

diff --git a/its/hangul.el b/its/hangul.el
new file mode 100644 (file)
index 0000000..a37f32e
--- /dev/null
+++ b/its/hangul.el
@@ -0,0 +1,2864 @@
+(eval-when-compile
+  (require 'its)
+  (require 'cl))
+
+(defvar its-hangul-open-bracket  "\e$(C!8\e(B" "*[")  ; "\e$(C#[\e(B"
+(defvar its-hangul-close-bracket  "\e$(C!9\e(B" "*]") ; "\e$(C#]\e(B"
+
+(eval-when-compile
+
+ (defvar its-jeonkak-escape "J")
+ (defvar its-pankak-escape  "B")
+
+ (defconst its-hangul-kijuhynbmlopOP
+   (its-make-class+back "[kijuhynbmlopOP]" -2))
+ (defconst its-hangul-kijuhynbmlopP
+   (its-make-class+back "[kijuhynbmlopP]" -2))
+ (defconst its-hangul-kjhynmlop
+   (its-make-class+back "[kjhynmlop]"   -2))
+
+ (defmacro its-defrule-hangul-2 (seq out &rest exprs)
+   `(let ((next-state (its-goto-state ,seq nil t)))
+      (its-set-output next-state ,out)
+      (its-make-next-state next-state -1 ,seq ,out)
+      (its-defrule-otherwise next-state ,out)
+      (let ((kijuhynbmlopOP (its-make-otherwise ,out its-hangul-kijuhynbmlopOP))
+           (kijuhynbmlopP  (its-make-otherwise ,out its-hangul-kijuhynbmlopP))
+           (kjhynmlop      (its-make-otherwise ,out its-hangul-kjhynmlop))
+           (next-state next-state))
+       ,@exprs)))
+
+ (defmacro its-define-hangul (seq out otherwise &rest exprs)
+   `(let ((next-state (its-make-next-state ',next-state
+                                          (aref ,seq (1- (length ,seq)))
+                                          ,seq ,out)))
+      (its-set-output next-state ,out)
+      (its-make-next-state next-state -1 ,seq ,out)
+      (its-define-otherwise next-state
+                           (its-make-otherwise ,out its-otherwise-back-one))
+      (its-define-otherwise next-state ,otherwise)
+      (if ',exprs
+         (let ((kijuhynbmlopOP (its-make-otherwise ,out its-hangul-kijuhynbmlopOP))
+               (kijuhynbmlopP  (its-make-otherwise ,out its-hangul-kijuhynbmlopP))
+               (kjhynmlop      (its-make-otherwise ,out its-hangul-kjhynmlop)))
+           ,@exprs))))
+
+ (defun its-defrule-hangul (seq output)
+   (let ((state (its-goto-state seq nil t)))
+     (its-set-output state output)
+     (its-make-next-state state -1 seq output)
+
+     (its-defrule-otherwise state output))))
+
+(define-its-state-machine its-hangul-map
+  "hangul" "\e$(CGQ\e(B" "korean"
+  "Map for Hangul input. (Korean)"
+  (its-defrule-hangul  "r"     "\e$(C$!\e(B")
+  (its-defrule-hangul  "s"     "\e$(C$$\e(B")
+  (its-defrule-hangul  "e"     "\e$(C$'\e(B")
+  (its-defrule-hangul  "f"     "\e$(C$)\e(B")
+  (its-defrule-hangul  "a"     "\e$(C$1\e(B")
+  (its-defrule-hangul  "q"     "\e$(C$2\e(B")
+  (its-defrule-hangul  "t"     "\e$(C$5\e(B")
+  (its-defrule-hangul  "d"     "\e$(C$7\e(B")
+  (its-defrule-hangul  "w"     "\e$(C$8\e(B")
+  (its-defrule-hangul  "c"     "\e$(C$:\e(B")
+  (its-defrule-hangul  "z"     "\e$(C$;\e(B")
+  (its-defrule-hangul  "x"     "\e$(C$<\e(B")
+  (its-defrule-hangul  "v"     "\e$(C$=\e(B")
+  (its-defrule-hangul  "g"     "\e$(C$>\e(B")
+  (its-defrule-hangul  "R"     "\e$(C$"\e(B")
+  (its-defrule-hangul  "E"     "\e$(C$(\e(B")
+  (its-defrule-hangul  "Q"     "\e$(C$3\e(B")
+  (its-defrule-hangul  "T"     "\e$(C$6\e(B")
+  (its-defrule-hangul  "W"     "\e$(C$9\e(B")
+
+  (its-defrule-hangul  "k"     "\e$(C$?\e(B")
+  (its-defrule-hangul  "i"     "\e$(C$A\e(B")
+  (its-defrule-hangul  "j"     "\e$(C$C\e(B")
+  (its-defrule-hangul  "u"     "\e$(C$E\e(B")
+  (its-defrule-hangul  "h"     "\e$(C$G\e(B")
+  (its-defrule-hangul  "y"     "\e$(C$K\e(B")
+  (its-defrule-hangul  "n"     "\e$(C$L\e(B")
+  (its-defrule-hangul  "b"     "\e$(C$P\e(B")
+  (its-defrule-hangul  "m"     "\e$(C$Q\e(B")
+  (its-defrule-hangul  "l"     "\e$(C$S\e(B")
+  (its-defrule-hangul  "o"     "\e$(C$@\e(B")
+  (its-defrule-hangul  "p"     "\e$(C$D\e(B")
+  (its-defrule-hangul  "O"     "\e$(C$B\e(B")
+  (its-defrule-hangul  "P"     "\e$(C$F\e(B")
+
+  (its-defrule-hangul-2        "rk"    "\e$(C0!\e(B"
+    (its-define-hangul "rkr"   "\e$(C0"\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "rks"   "\e$(C0#\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rke"   "\e$(C0$\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rkf"   "\e$(C0%\e(B"     kijuhynbmlopP
+     (its-define-hangul        "rkfr"  "\e$(C0&\e(B"     kijuhynbmlopOP)
+     (its-define-hangul        "rkfa"  "\e$(C0'\e(B"     kijuhynbmlopP))
+    (its-define-hangul "rka"   "\e$(C0(\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rkq"   "\e$(C0)\e(B"     kijuhynbmlopP
+     (its-define-hangul        "rkqt"  "\e$(C0*\e(B"     kijuhynbmlopOP))
+    (its-define-hangul "rkt"   "\e$(C0+\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "rkT"   "\e$(C0,\e(B"     kjhynmlop)
+    (its-define-hangul "rkd"   "\e$(C0-\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "rkw"   "\e$(C0.\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "rkc"   "\e$(C0/\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rkx"   "\e$(C00\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rkv"   "\e$(C01\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rkg"   "\e$(C02\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "ro"    "\e$(C03\e(B"
+    (its-define-hangul "ror"   "\e$(C04\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ros"   "\e$(C05\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rof"   "\e$(C06\e(B"     kijuhynbmlopP)
+    (its-define-hangul "roa"   "\e$(C07\e(B"     kijuhynbmlopP)
+    (its-define-hangul "roq"   "\e$(C08\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rot"   "\e$(C09\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "roT"   "\e$(C0:\e(B"     kjhynmlop)
+    (its-define-hangul "rod"   "\e$(C0;\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "ri"    "\e$(C0<\e(B"
+    (its-define-hangul "rir"   "\e$(C0=\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ris"   "\e$(C0>\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rif"   "\e$(C0?\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rit"   "\e$(C0@\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "rid"   "\e$(C0A\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "rO"    "\e$(C0B\e(B"
+    (its-define-hangul "rOs"   "\e$(C0C\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rOf"   "\e$(C0D\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "rj"    "\e$(C0E\e(B"
+    (its-define-hangul "rjr"   "\e$(C0F\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "rjs"   "\e$(C0G\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rje"   "\e$(C0H\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rjf"   "\e$(C0I\e(B"     kijuhynbmlopP
+     (its-define-hangul        "rjfa"  "\e$(C0J\e(B"     kijuhynbmlopP))
+    (its-define-hangul "rja"   "\e$(C0K\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rjq"   "\e$(C0L\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rjt"   "\e$(C0M\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "rjT"   "\e$(C0N\e(B"     kjhynmlop)
+    (its-define-hangul "rjd"   "\e$(C0O\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "rjw"   "\e$(C0P\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "rjx"   "\e$(C0Q\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rjv"   "\e$(C0R\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rjg"   "\e$(C0S\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "rp"    "\e$(C0T\e(B"
+    (its-define-hangul "rps"   "\e$(C0U\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rpf"   "\e$(C0V\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rpa"   "\e$(C0W\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rpq"   "\e$(C0X\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rpt"   "\e$(C0Y\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "rpT"   "\e$(C0Z\e(B"     kjhynmlop)
+    (its-define-hangul "rpd"   "\e$(C0[\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "ru"    "\e$(C0\\e(B"
+    (its-define-hangul "rur"   "\e$(C0]\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ruR"   "\e$(C0^\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rus"   "\e$(C0_\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rue"   "\e$(C0`\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ruf"   "\e$(C0a\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rua"   "\e$(C0b\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ruq"   "\e$(C0c\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rut"   "\e$(C0d\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ruT"   "\e$(C0e\e(B"     kjhynmlop)
+    (its-define-hangul "rud"   "\e$(C0f\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "rux"   "\e$(C0g\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "rP"    "\e$(C0h\e(B"
+    (its-define-hangul "rPs"   "\e$(C0i\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rPf"   "\e$(C0j\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rPq"   "\e$(C0k\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rPt"   "\e$(C0l\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "rh"    "\e$(C0m\e(B"
+    (its-define-hangul "rhr"   "\e$(C0n\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "rhs"   "\e$(C0o\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rhe"   "\e$(C0p\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rhf"   "\e$(C0q\e(B"     kijuhynbmlopP
+     (its-define-hangul        "rhfa"  "\e$(C0r\e(B"     kijuhynbmlopP)
+     (its-define-hangul        "rhft"  "\e$(C0s\e(B"     kijuhynbmlopOP)
+     (its-define-hangul        "rhfg"  "\e$(C0t\e(B"     kijuhynbmlopP))
+    (its-define-hangul "rha"   "\e$(C0u\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rhq"   "\e$(C0v\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rht"   "\e$(C0w\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "rhd"   "\e$(C0x\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "rhw"   "\e$(C0y\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "rhk"   "\e$(C0z\e(B"
+    (its-define-hangul "rhkr"  "\e$(C0{\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "rhks"  "\e$(C0|\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rhkf"  "\e$(C0}\e(B"     kijuhynbmlopP
+     (its-define-hangul        "rhkfa" "\e$(C0~\e(B"     kijuhynbmlopP))
+    (its-define-hangul "rhka"  "\e$(C1!\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rhkq"  "\e$(C1"\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rhkt"  "\e$(C1#\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "rhkd"  "\e$(C1$\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "rho"   "\e$(C1%\e(B"
+    (its-define-hangul "rhos"  "\e$(C1&\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rhof"  "\e$(C1'\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rhoq"  "\e$(C1(\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rhoT"  "\e$(C1)\e(B"     kjhynmlop)
+    (its-define-hangul "rhod"  "\e$(C1*\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "rhl"   "\e$(C1+\e(B"
+    (its-define-hangul "rhlr"  "\e$(C1,\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "rhls"  "\e$(C1-\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rhlf"  "\e$(C1.\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rhla"  "\e$(C1/\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rhlq"  "\e$(C10\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rhlt"  "\e$(C11\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "rhld"  "\e$(C12\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "ry"    "\e$(C13\e(B"
+    (its-define-hangul "rys"   "\e$(C14\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ryf"   "\e$(C15\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ryq"   "\e$(C16\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ryt"   "\e$(C17\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "rn"    "\e$(C18\e(B"
+    (its-define-hangul "rnr"   "\e$(C19\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "rns"   "\e$(C1:\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rne"   "\e$(C1;\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rnf"   "\e$(C1<\e(B"     kijuhynbmlopP
+     (its-define-hangul        "rnfr"  "\e$(C1=\e(B"     kijuhynbmlopOP)
+     (its-define-hangul        "rnfa"  "\e$(C1>\e(B"     kijuhynbmlopP)
+     (its-define-hangul        "rnfg"  "\e$(C1?\e(B"     kijuhynbmlopP))
+    (its-define-hangul "rna"   "\e$(C1@\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rnq"   "\e$(C1A\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rnt"   "\e$(C1B\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "rnd"   "\e$(C1C\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "rnw"   "\e$(C1D\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "rnj"   "\e$(C1E\e(B"
+    (its-define-hangul "rnjr"  "\e$(C1F\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "rnjs"  "\e$(C1G\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rnjf"  "\e$(C1H\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rnjT"  "\e$(C1I\e(B"     kjhynmlop)
+    (its-define-hangul "rnjd"  "\e$(C1J\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "rnp"   "\e$(C1K\e(B"
+    (its-define-hangul "rnpt"  "\e$(C1L\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "rnl"   "\e$(C1M\e(B"
+    (its-define-hangul "rnlr"  "\e$(C1N\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "rnls"  "\e$(C1O\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rnlf"  "\e$(C1P\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rnla"  "\e$(C1Q\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rnlq"  "\e$(C1R\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rnlt"  "\e$(C1S\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "rb"    "\e$(C1T\e(B"
+    (its-define-hangul "rbs"   "\e$(C1U\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rbf"   "\e$(C1V\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "rm"    "\e$(C1W\e(B"
+    (its-define-hangul "rmr"   "\e$(C1X\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "rms"   "\e$(C1Y\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rme"   "\e$(C1Z\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rmf"   "\e$(C1[\e(B"     kijuhynbmlopP
+     (its-define-hangul        "rmfr"  "\e$(C1\\e(B"     kijuhynbmlopOP))
+    (its-define-hangul "rma"   "\e$(C1]\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rmq"   "\e$(C1^\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rmt"   "\e$(C1_\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "rmd"   "\e$(C1`\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul  "rml"   "\e$(C1a\e(B")
+
+  (its-defrule-hangul-2        "rl"    "\e$(C1b\e(B"
+    (its-define-hangul "rlr"   "\e$(C1c\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "rls"   "\e$(C1d\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rle"   "\e$(C1e\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rlf"   "\e$(C1f\e(B"     kijuhynbmlopP
+     (its-define-hangul        "rlfa"  "\e$(C1g\e(B"     kijuhynbmlopP))
+    (its-define-hangul "rla"   "\e$(C1h\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rlq"   "\e$(C1i\e(B"     kijuhynbmlopP)
+    (its-define-hangul "rlt"   "\e$(C1j\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "rld"   "\e$(C1k\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "rlw"   "\e$(C1l\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "rlv"   "\e$(C1m\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "Rk"    "\e$(C1n\e(B"
+    (its-define-hangul "Rkr"   "\e$(C1o\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "RkR"   "\e$(C1p\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rks"   "\e$(C1q\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rkf"   "\e$(C1r\e(B"     kijuhynbmlopP
+     (its-define-hangul        "Rkfa"  "\e$(C1s\e(B"     kijuhynbmlopP))
+    (its-define-hangul "Rka"   "\e$(C1t\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rkq"   "\e$(C1u\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rkt"   "\e$(C1v\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "RkT"   "\e$(C1w\e(B"     kjhynmlop)
+    (its-define-hangul "Rkd"   "\e$(C1x\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Rkx"   "\e$(C1y\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "Ro"    "\e$(C1z\e(B"
+    (its-define-hangul "Ror"   "\e$(C1{\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Ros"   "\e$(C1|\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rof"   "\e$(C1}\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Roa"   "\e$(C1~\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Roq"   "\e$(C2!\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rot"   "\e$(C2"\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "RoT"   "\e$(C2#\e(B"     kjhynmlop)
+    (its-define-hangul "Rod"   "\e$(C2$\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "Ri"    "\e$(C2%\e(B"
+    (its-define-hangul "Rir"   "\e$(C2&\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Rif"   "\e$(C2'\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "Rj"    "\e$(C2(\e(B"
+    (its-define-hangul "Rjr"   "\e$(C2)\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "RjR"   "\e$(C2*\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rjs"   "\e$(C2+\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rjf"   "\e$(C2,\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rja"   "\e$(C2-\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rjq"   "\e$(C2.\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rjt"   "\e$(C2/\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "RjT"   "\e$(C20\e(B"     kjhynmlop)
+    (its-define-hangul "Rjd"   "\e$(C21\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "Rp"    "\e$(C22\e(B"
+    (its-define-hangul "Rpr"   "\e$(C23\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Rps"   "\e$(C24\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rpa"   "\e$(C25\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rpt"   "\e$(C26\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Rpd"   "\e$(C27\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "Ru"    "\e$(C28\e(B"
+    (its-define-hangul "Rus"   "\e$(C29\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Ruf"   "\e$(C2:\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rut"   "\e$(C2;\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "RuT"   "\e$(C2<\e(B"     kjhynmlop)
+    (its-define-hangul "Rux"   "\e$(C2=\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul  "RP"    "\e$(C2>\e(B")
+
+  (its-defrule-hangul-2        "Rh"    "\e$(C2?\e(B"
+    (its-define-hangul "Rhr"   "\e$(C2@\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Rhs"   "\e$(C2A\e(B"     kijuhynbmlopP
+     (its-define-hangul        "Rhsg"  "\e$(C2B\e(B"     kijuhynbmlopP))
+    (its-define-hangul "Rhf"   "\e$(C2C\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rha"   "\e$(C2D\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rhq"   "\e$(C2E\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rht"   "\e$(C2F\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Rhd"   "\e$(C2G\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Rhw"   "\e$(C2H\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Rhc"   "\e$(C2I\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "Rhk"   "\e$(C2J\e(B"
+    (its-define-hangul "Rhkr"  "\e$(C2K\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Rhkf"  "\e$(C2L\e(B"     kijuhynbmlopP)
+    (its-define-hangul "RhkT"  "\e$(C2M\e(B"     kjhynmlop)
+    (its-define-hangul "Rhkd"  "\e$(C2N\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "Rho"   "\e$(C2O\e(B"
+    (its-define-hangul "Rhor"  "\e$(C2P\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Rhod"  "\e$(C2Q\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "Rhl"   "\e$(C2R\e(B"
+    (its-define-hangul "Rhls"  "\e$(C2S\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rhlf"  "\e$(C2T\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rhla"  "\e$(C2U\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rhlq"  "\e$(C2V\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rhld"  "\e$(C2W\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul  "Ry"    "\e$(C2X\e(B")
+
+  (its-defrule-hangul-2        "Rn"    "\e$(C2Y\e(B"
+    (its-define-hangul "Rnr"   "\e$(C2Z\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Rns"   "\e$(C2[\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rnf"   "\e$(C2\\e(B"     kijuhynbmlopP
+     (its-define-hangul        "Rnfg"  "\e$(C2]\e(B"     kijuhynbmlopP))
+    (its-define-hangul "Rna"   "\e$(C2^\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rnq"   "\e$(C2_\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rnt"   "\e$(C2`\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Rnd"   "\e$(C2a\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Rnw"   "\e$(C2b\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "Rnj"   "\e$(C2c\e(B"
+    (its-define-hangul "Rnjf"  "\e$(C2d\e(B"     kijuhynbmlopP)
+    (its-define-hangul "RnjT"  "\e$(C2e\e(B"     kjhynmlop)
+    (its-define-hangul "Rnjd"  "\e$(C2f\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "Rnp"   "\e$(C2g\e(B"
+    (its-define-hangul "Rnpr"  "\e$(C2h\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Rnps"  "\e$(C2i\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rnpf"  "\e$(C2j\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rnpa"  "\e$(C2k\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rnpq"  "\e$(C2l\e(B"     kijuhynbmlopP)
+    (its-define-hangul "RnpT"  "\e$(C2m\e(B"     kjhynmlop))
+
+  (its-defrule-hangul-2        "Rnl"   "\e$(C2n\e(B"
+    (its-define-hangul "Rnls"  "\e$(C2o\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rnlf"  "\e$(C2p\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rnla"  "\e$(C2q\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rnlq"  "\e$(C2r\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul  "Rb"    "\e$(C2s\e(B")
+
+  (its-defrule-hangul-2        "Rm"    "\e$(C2t\e(B"
+    (its-define-hangul "Rmr"   "\e$(C2u\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Rms"   "\e$(C2v\e(B"     kijuhynbmlopP
+     (its-define-hangul        "Rmsg"  "\e$(C2w\e(B"     kijuhynbmlopP))
+    (its-define-hangul "Rmf"   "\e$(C2x\e(B"     kijuhynbmlopP
+     (its-define-hangul        "Rmfa"  "\e$(C2y\e(B"     kijuhynbmlopP)
+     (its-define-hangul        "Rmfg"  "\e$(C2z\e(B"     kijuhynbmlopP))
+    (its-define-hangul "Rma"   "\e$(C2{\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rmq"   "\e$(C2|\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rmt"   "\e$(C2}\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Rmd"   "\e$(C2~\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Rmx"   "\e$(C3!\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "Rl"    "\e$(C3"\e(B"
+    (its-define-hangul "Rlr"   "\e$(C3#\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Rls"   "\e$(C3$\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rlf"   "\e$(C3%\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rla"   "\e$(C3&\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rlq"   "\e$(C3'\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Rlt"   "\e$(C3(\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Rld"   "\e$(C3)\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "sk"    "\e$(C3*\e(B"
+    (its-define-hangul "skr"   "\e$(C3+\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "skR"   "\e$(C3,\e(B"     kijuhynbmlopP)
+    (its-define-hangul "sks"   "\e$(C3-\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ske"   "\e$(C3.\e(B"     kijuhynbmlopP)
+    (its-define-hangul "skf"   "\e$(C3/\e(B"     kijuhynbmlopP
+     (its-define-hangul        "skfr"  "\e$(C30\e(B"     kijuhynbmlopOP)
+     (its-define-hangul        "skfa"  "\e$(C31\e(B"     kijuhynbmlopP))
+    (its-define-hangul "ska"   "\e$(C32\e(B"     kijuhynbmlopP)
+    (its-define-hangul "skq"   "\e$(C33\e(B"     kijuhynbmlopP)
+    (its-define-hangul "skt"   "\e$(C34\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "skT"   "\e$(C35\e(B"     kjhynmlop)
+    (its-define-hangul "skd"   "\e$(C36\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "skw"   "\e$(C37\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "skc"   "\e$(C38\e(B"     kijuhynbmlopP)
+    (its-define-hangul "skx"   "\e$(C39\e(B"     kijuhynbmlopP)
+    (its-define-hangul "skg"   "\e$(C3:\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "so"    "\e$(C3;\e(B"
+    (its-define-hangul "sor"   "\e$(C3<\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "sos"   "\e$(C3=\e(B"     kijuhynbmlopP)
+    (its-define-hangul "sof"   "\e$(C3>\e(B"     kijuhynbmlopP)
+    (its-define-hangul "soa"   "\e$(C3?\e(B"     kijuhynbmlopP)
+    (its-define-hangul "soq"   "\e$(C3@\e(B"     kijuhynbmlopP)
+    (its-define-hangul "sot"   "\e$(C3A\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "soT"   "\e$(C3B\e(B"     kjhynmlop)
+    (its-define-hangul "sod"   "\e$(C3C\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "si"    "\e$(C3D\e(B"
+    (its-define-hangul "sir"   "\e$(C3E\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "sis"   "\e$(C3F\e(B"     kijuhynbmlopP)
+    (its-define-hangul "sif"   "\e$(C3G\e(B"     kijuhynbmlopP)
+    (its-define-hangul "sia"   "\e$(C3H\e(B"     kijuhynbmlopP)
+    (its-define-hangul "sid"   "\e$(C3I\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "sj"    "\e$(C3J\e(B"
+    (its-define-hangul "sjr"   "\e$(C3K\e(B"     kijuhynbmlopOP
+     (its-define-hangul        "sjrt"  "\e$(C3L\e(B"     kijuhynbmlopOP))
+    (its-define-hangul "sjs"   "\e$(C3M\e(B"     kijuhynbmlopP)
+    (its-define-hangul "sjf"   "\e$(C3N\e(B"     kijuhynbmlopP
+     (its-define-hangul        "sjfa"  "\e$(C3O\e(B"     kijuhynbmlopP)
+     (its-define-hangul        "sjfq"  "\e$(C3P\e(B"     kijuhynbmlopP))
+    (its-define-hangul "sja"   "\e$(C3Q\e(B"     kijuhynbmlopP)
+    (its-define-hangul "sjq"   "\e$(C3R\e(B"     kijuhynbmlopP)
+    (its-define-hangul "sjt"   "\e$(C3S\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "sjT"   "\e$(C3T\e(B"     kjhynmlop)
+    (its-define-hangul "sjd"   "\e$(C3U\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "sjg"   "\e$(C3V\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "sp"    "\e$(C3W\e(B"
+    (its-define-hangul "spr"   "\e$(C3X\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "sps"   "\e$(C3Y\e(B"     kijuhynbmlopP)
+    (its-define-hangul "spf"   "\e$(C3Z\e(B"     kijuhynbmlopP)
+    (its-define-hangul "spa"   "\e$(C3[\e(B"     kijuhynbmlopP)
+    (its-define-hangul "spq"   "\e$(C3\\e(B"     kijuhynbmlopP)
+    (its-define-hangul "spt"   "\e$(C3]\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "spT"   "\e$(C3^\e(B"     kjhynmlop)
+    (its-define-hangul "spd"   "\e$(C3_\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "su"    "\e$(C3`\e(B"
+    (its-define-hangul "sur"   "\e$(C3a\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "sus"   "\e$(C3b\e(B"     kijuhynbmlopP)
+    (its-define-hangul "suf"   "\e$(C3c\e(B"     kijuhynbmlopP)
+    (its-define-hangul "sua"   "\e$(C3d\e(B"     kijuhynbmlopP)
+    (its-define-hangul "suq"   "\e$(C3e\e(B"     kijuhynbmlopP)
+    (its-define-hangul "suT"   "\e$(C3f\e(B"     kjhynmlop)
+    (its-define-hangul "sud"   "\e$(C3g\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "suz"   "\e$(C3h\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "sP"    "\e$(C3i\e(B"
+    (its-define-hangul "sPs"   "\e$(C3j\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "sh"    "\e$(C3k\e(B"
+    (its-define-hangul "shr"   "\e$(C3l\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "shs"   "\e$(C3m\e(B"     kijuhynbmlopP)
+    (its-define-hangul "shf"   "\e$(C3n\e(B"     kijuhynbmlopP
+     (its-define-hangul        "shfa"  "\e$(C3o\e(B"     kijuhynbmlopP))
+    (its-define-hangul "sha"   "\e$(C3p\e(B"     kijuhynbmlopP)
+    (its-define-hangul "shq"   "\e$(C3q\e(B"     kijuhynbmlopP)
+    (its-define-hangul "sht"   "\e$(C3r\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "shd"   "\e$(C3s\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "shv"   "\e$(C3t\e(B"     kijuhynbmlopP)
+    (its-define-hangul "shg"   "\e$(C3u\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "shk"   "\e$(C3v\e(B"
+    (its-define-hangul "shks"  "\e$(C3w\e(B"     kijuhynbmlopP)
+    (its-define-hangul "shkf"  "\e$(C3x\e(B"     kijuhynbmlopP)
+    (its-define-hangul "shkT"  "\e$(C3y\e(B"     kjhynmlop))
+
+  (its-defrule-hangul-2        "shl"   "\e$(C3z\e(B"
+    (its-define-hangul "shls"  "\e$(C3{\e(B"     kijuhynbmlopP)
+    (its-define-hangul "shlf"  "\e$(C3|\e(B"     kijuhynbmlopP)
+    (its-define-hangul "shla"  "\e$(C3}\e(B"     kijuhynbmlopP)
+    (its-define-hangul "shlq"  "\e$(C3~\e(B"     kijuhynbmlopP)
+    (its-define-hangul "shlt"  "\e$(C4!\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "sy"    "\e$(C4"\e(B"
+    (its-define-hangul "syr"   "\e$(C4#\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "sys"   "\e$(C4$\e(B"     kijuhynbmlopP)
+    (its-define-hangul "syf"   "\e$(C4%\e(B"     kijuhynbmlopP)
+    (its-define-hangul "syq"   "\e$(C4&\e(B"     kijuhynbmlopP)
+    (its-define-hangul "syt"   "\e$(C4'\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "syd"   "\e$(C4(\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "sn"    "\e$(C4)\e(B"
+    (its-define-hangul "snr"   "\e$(C4*\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "sns"   "\e$(C4+\e(B"     kijuhynbmlopP)
+    (its-define-hangul "sne"   "\e$(C4,\e(B"     kijuhynbmlopP)
+    (its-define-hangul "snf"   "\e$(C4-\e(B"     kijuhynbmlopP)
+    (its-define-hangul "sna"   "\e$(C4.\e(B"     kijuhynbmlopP)
+    (its-define-hangul "snq"   "\e$(C4/\e(B"     kijuhynbmlopP)
+    (its-define-hangul "snt"   "\e$(C40\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "snd"   "\e$(C41\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "snj"   "\e$(C42\e(B"
+    (its-define-hangul "snjT"  "\e$(C43\e(B"     kjhynmlop))
+
+  (its-defrule-hangul  "snp"   "\e$(C44\e(B")
+
+  (its-defrule-hangul-2        "snl"   "\e$(C45\e(B"
+    (its-define-hangul "snls"  "\e$(C46\e(B"     kijuhynbmlopP)
+    (its-define-hangul "snlf"  "\e$(C47\e(B"     kijuhynbmlopP)
+    (its-define-hangul "snla"  "\e$(C48\e(B"     kijuhynbmlopP)
+    (its-define-hangul "snlq"  "\e$(C49\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "sb"    "\e$(C4:\e(B"
+    (its-define-hangul "sbr"   "\e$(C4;\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "sbf"   "\e$(C4<\e(B"     kijuhynbmlopP)
+    (its-define-hangul "sba"   "\e$(C4=\e(B"     kijuhynbmlopP)
+    (its-define-hangul "sbq"   "\e$(C4>\e(B"     kijuhynbmlopP)
+    (its-define-hangul "sbd"   "\e$(C4?\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "sm"    "\e$(C4@\e(B"
+    (its-define-hangul "smr"   "\e$(C4A\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "sms"   "\e$(C4B\e(B"     kijuhynbmlopP)
+    (its-define-hangul "smf"   "\e$(C4C\e(B"     kijuhynbmlopP
+     (its-define-hangul        "smfr"  "\e$(C4D\e(B"     kijuhynbmlopOP)
+     (its-define-hangul        "smfa"  "\e$(C4E\e(B"     kijuhynbmlopP))
+    (its-define-hangul "sma"   "\e$(C4F\e(B"     kijuhynbmlopP)
+    (its-define-hangul "smq"   "\e$(C4G\e(B"     kijuhynbmlopP)
+    (its-define-hangul "smt"   "\e$(C4H\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "smd"   "\e$(C4I\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "smw"   "\e$(C4J\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "smv"   "\e$(C4K\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "sml"   "\e$(C4L\e(B"
+    (its-define-hangul "smls"  "\e$(C4M\e(B"     kijuhynbmlopP)
+    (its-define-hangul "smlf"  "\e$(C4N\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "sl"    "\e$(C4O\e(B"
+    (its-define-hangul "slr"   "\e$(C4P\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "sls"   "\e$(C4Q\e(B"     kijuhynbmlopP)
+    (its-define-hangul "slf"   "\e$(C4R\e(B"     kijuhynbmlopP
+     (its-define-hangul        "slfa"  "\e$(C4S\e(B"     kijuhynbmlopP))
+    (its-define-hangul "sla"   "\e$(C4T\e(B"     kijuhynbmlopP)
+    (its-define-hangul "slq"   "\e$(C4U\e(B"     kijuhynbmlopP)
+    (its-define-hangul "slt"   "\e$(C4V\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "sld"   "\e$(C4W\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "slv"   "\e$(C4X\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "ek"    "\e$(C4Y\e(B"
+    (its-define-hangul "ekr"   "\e$(C4Z\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ekR"   "\e$(C4[\e(B"     kijuhynbmlopP)
+    (its-define-hangul "eks"   "\e$(C4\\e(B"     kijuhynbmlopP)
+    (its-define-hangul "eke"   "\e$(C4]\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ekf"   "\e$(C4^\e(B"     kijuhynbmlopP
+     (its-define-hangul        "ekfr"  "\e$(C4_\e(B"     kijuhynbmlopOP)
+     (its-define-hangul        "ekfa"  "\e$(C4`\e(B"     kijuhynbmlopP)
+     (its-define-hangul        "ekfq"  "\e$(C4a\e(B"     kijuhynbmlopP)
+     (its-define-hangul        "ekfg"  "\e$(C4b\e(B"     kijuhynbmlopP))
+    (its-define-hangul "eka"   "\e$(C4c\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ekq"   "\e$(C4d\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ekt"   "\e$(C4e\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ekT"   "\e$(C4f\e(B"     kjhynmlop)
+    (its-define-hangul "ekd"   "\e$(C4g\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ekw"   "\e$(C4h\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ekc"   "\e$(C4i\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ekg"   "\e$(C4j\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "eo"    "\e$(C4k\e(B"
+    (its-define-hangul "eor"   "\e$(C4l\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "eos"   "\e$(C4m\e(B"     kijuhynbmlopP)
+    (its-define-hangul "eof"   "\e$(C4n\e(B"     kijuhynbmlopP)
+    (its-define-hangul "eoa"   "\e$(C4o\e(B"     kijuhynbmlopP)
+    (its-define-hangul "eoq"   "\e$(C4p\e(B"     kijuhynbmlopP)
+    (its-define-hangul "eot"   "\e$(C4q\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "eoT"   "\e$(C4r\e(B"     kjhynmlop)
+    (its-define-hangul "eod"   "\e$(C4s\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul  "ei"    "\e$(C4t\e(B")
+
+  (its-defrule-hangul-2        "ej"    "\e$(C4u\e(B"
+    (its-define-hangul "ejr"   "\e$(C4v\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ejR"   "\e$(C4w\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ejs"   "\e$(C4x\e(B"     kijuhynbmlopP)
+    (its-define-hangul "eje"   "\e$(C4y\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ejf"   "\e$(C4z\e(B"     kijuhynbmlopP
+     (its-define-hangul        "ejfa"  "\e$(C4{\e(B"     kijuhynbmlopP)
+     (its-define-hangul        "ejfq"  "\e$(C4|\e(B"     kijuhynbmlopP))
+    (its-define-hangul "eja"   "\e$(C4}\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ejq"   "\e$(C4~\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ejt"   "\e$(C5!\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ejd"   "\e$(C5"\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ejc"   "\e$(C5#\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ejv"   "\e$(C5$\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "ep"    "\e$(C5%\e(B"
+    (its-define-hangul "epr"   "\e$(C5&\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "eps"   "\e$(C5'\e(B"     kijuhynbmlopP)
+    (its-define-hangul "epf"   "\e$(C5(\e(B"     kijuhynbmlopP)
+    (its-define-hangul "epa"   "\e$(C5)\e(B"     kijuhynbmlopP)
+    (its-define-hangul "epq"   "\e$(C5*\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ept"   "\e$(C5+\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "epT"   "\e$(C5,\e(B"     kjhynmlop)
+    (its-define-hangul "epd"   "\e$(C5-\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "eu"    "\e$(C5.\e(B"
+    (its-define-hangul "eus"   "\e$(C5/\e(B"     kijuhynbmlopP)
+    (its-define-hangul "euf"   "\e$(C50\e(B"     kijuhynbmlopP)
+    (its-define-hangul "euT"   "\e$(C51\e(B"     kjhynmlop)
+    (its-define-hangul "eud"   "\e$(C52\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "eP"    "\e$(C53\e(B"
+    (its-define-hangul "ePs"   "\e$(C54\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "eh"    "\e$(C55\e(B"
+    (its-define-hangul "ehr"   "\e$(C56\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ehs"   "\e$(C57\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ehe"   "\e$(C58\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ehf"   "\e$(C59\e(B"     kijuhynbmlopP
+     (its-define-hangul        "ehfa"  "\e$(C5:\e(B"     kijuhynbmlopP)
+     (its-define-hangul        "ehft"  "\e$(C5;\e(B"     kijuhynbmlopOP))
+    (its-define-hangul "eha"   "\e$(C5<\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ehq"   "\e$(C5=\e(B"     kijuhynbmlopP)
+    (its-define-hangul "eht"   "\e$(C5>\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ehd"   "\e$(C5?\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ehc"   "\e$(C5@\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ehx"   "\e$(C5A\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "ehk"   "\e$(C5B\e(B"
+    (its-define-hangul "ehks"  "\e$(C5C\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ehkf"  "\e$(C5D\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "eho"   "\e$(C5E\e(B"
+    (its-define-hangul "ehoT"  "\e$(C5F\e(B"     kjhynmlop))
+
+  (its-defrule-hangul-2        "ehl"   "\e$(C5G\e(B"
+    (its-define-hangul "ehls"  "\e$(C5H\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ehlf"  "\e$(C5I\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ehla"  "\e$(C5J\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ehlq"  "\e$(C5K\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ehlt"  "\e$(C5L\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul  "ey"    "\e$(C5M\e(B")
+
+  (its-defrule-hangul-2        "en"    "\e$(C5N\e(B"
+    (its-define-hangul "enr"   "\e$(C5O\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ens"   "\e$(C5P\e(B"     kijuhynbmlopP)
+    (its-define-hangul "enf"   "\e$(C5Q\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ena"   "\e$(C5R\e(B"     kijuhynbmlopP)
+    (its-define-hangul "enq"   "\e$(C5S\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ent"   "\e$(C5T\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "end"   "\e$(C5U\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "enj"   "\e$(C5V\e(B"
+    (its-define-hangul "enjT"  "\e$(C5W\e(B"     kjhynmlop))
+
+  (its-defrule-hangul-2        "enp"   "\e$(C5X\e(B"
+    (its-define-hangul "enpd"  "\e$(C5Y\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "enl"   "\e$(C5Z\e(B"
+    (its-define-hangul "enls"  "\e$(C5[\e(B"     kijuhynbmlopP)
+    (its-define-hangul "enlf"  "\e$(C5\\e(B"     kijuhynbmlopP)
+    (its-define-hangul "enlq"  "\e$(C5]\e(B"     kijuhynbmlopP)
+    (its-define-hangul "enlt"  "\e$(C5^\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "enld"  "\e$(C5_\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "eb"    "\e$(C5`\e(B"
+    (its-define-hangul "ebs"   "\e$(C5a\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ebf"   "\e$(C5b\e(B"     kijuhynbmlopP)
+    (its-define-hangul "eba"   "\e$(C5c\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ebd"   "\e$(C5d\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "em"    "\e$(C5e\e(B"
+    (its-define-hangul "emr"   "\e$(C5f\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ems"   "\e$(C5g\e(B"     kijuhynbmlopP)
+    (its-define-hangul "eme"   "\e$(C5h\e(B"     kijuhynbmlopP)
+    (its-define-hangul "emf"   "\e$(C5i\e(B"     kijuhynbmlopP
+     (its-define-hangul        "emfa"  "\e$(C5j\e(B"     kijuhynbmlopP))
+    (its-define-hangul "ema"   "\e$(C5k\e(B"     kijuhynbmlopP)
+    (its-define-hangul "emq"   "\e$(C5l\e(B"     kijuhynbmlopP)
+    (its-define-hangul "emt"   "\e$(C5m\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "emd"   "\e$(C5n\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul  "eml"   "\e$(C5o\e(B")
+
+  (its-defrule-hangul-2        "el"    "\e$(C5p\e(B"
+    (its-define-hangul "elr"   "\e$(C5q\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "els"   "\e$(C5r\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ele"   "\e$(C5s\e(B"     kijuhynbmlopP)
+    (its-define-hangul "elf"   "\e$(C5t\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ela"   "\e$(C5u\e(B"     kijuhynbmlopP)
+    (its-define-hangul "elq"   "\e$(C5v\e(B"     kijuhynbmlopP)
+    (its-define-hangul "elt"   "\e$(C5w\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "elT"   "\e$(C5x\e(B"     kjhynmlop)
+    (its-define-hangul "eld"   "\e$(C5y\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "elw"   "\e$(C5z\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "Ek"    "\e$(C5{\e(B"
+    (its-define-hangul "Ekr"   "\e$(C5|\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Eks"   "\e$(C5}\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Ekf"   "\e$(C5~\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Eka"   "\e$(C6!\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Ekq"   "\e$(C6"\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Ekt"   "\e$(C6#\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "EkT"   "\e$(C6$\e(B"     kjhynmlop)
+    (its-define-hangul "Ekd"   "\e$(C6%\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Ekg"   "\e$(C6&\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "Eo"    "\e$(C6'\e(B"
+    (its-define-hangul "Eor"   "\e$(C6(\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Eos"   "\e$(C6)\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Eof"   "\e$(C6*\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Eoa"   "\e$(C6+\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Eoq"   "\e$(C6,\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Eot"   "\e$(C6-\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "EoT"   "\e$(C6.\e(B"     kjhynmlop)
+    (its-define-hangul "Eod"   "\e$(C6/\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "Ej"    "\e$(C60\e(B"
+    (its-define-hangul "Ejr"   "\e$(C61\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Ejs"   "\e$(C62\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Ejf"   "\e$(C63\e(B"     kijuhynbmlopP
+     (its-define-hangul        "Ejfa"  "\e$(C64\e(B"     kijuhynbmlopP)
+     (its-define-hangul        "Ejfq"  "\e$(C65\e(B"     kijuhynbmlopP))
+    (its-define-hangul "Eja"   "\e$(C66\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Ejq"   "\e$(C67\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Ejt"   "\e$(C68\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "EjT"   "\e$(C69\e(B"     kjhynmlop)
+    (its-define-hangul "Ejd"   "\e$(C6:\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Ejg"   "\e$(C6;\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "Ep"    "\e$(C6<\e(B"
+    (its-define-hangul "Epr"   "\e$(C6=\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Eps"   "\e$(C6>\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Epf"   "\e$(C6?\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Epa"   "\e$(C6@\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Epq"   "\e$(C6A\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Ept"   "\e$(C6B\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "EpT"   "\e$(C6C\e(B"     kjhynmlop)
+    (its-define-hangul "Epd"   "\e$(C6D\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "Eu"    "\e$(C6E\e(B"
+    (its-define-hangul "EuT"   "\e$(C6F\e(B"     kjhynmlop))
+
+  (its-defrule-hangul-2        "Eh"    "\e$(C6G\e(B"
+    (its-define-hangul "Ehr"   "\e$(C6H\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Ehs"   "\e$(C6I\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Ehf"   "\e$(C6J\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Ehd"   "\e$(C6K\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "Ehk"   "\e$(C6L\e(B"
+    (its-define-hangul "Ehkf"  "\e$(C6M\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul  "Eho"   "\e$(C6N\e(B")
+
+  (its-defrule-hangul-2        "Ehl"   "\e$(C6O\e(B"
+    (its-define-hangul "Ehls"  "\e$(C6P\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "En"    "\e$(C6Q\e(B"
+    (its-define-hangul "Enr"   "\e$(C6R\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Ens"   "\e$(C6S\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Enf"   "\e$(C6T\e(B"     kijuhynbmlopP
+     (its-define-hangul        "Enfg"  "\e$(C6U\e(B"     kijuhynbmlopP))
+    (its-define-hangul "Ena"   "\e$(C6V\e(B"     kijuhynbmlopP)
+    (its-define-hangul "End"   "\e$(C6W\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul  "Enp"   "\e$(C6X\e(B")
+
+  (its-defrule-hangul-2        "Enl"   "\e$(C6Y\e(B"
+    (its-define-hangul "Enls"  "\e$(C6Z\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Enlf"  "\e$(C6[\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Enla"  "\e$(C6\\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Enlq"  "\e$(C6]\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Enld"  "\e$(C6^\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "Em"    "\e$(C6_\e(B"
+    (its-define-hangul "Emr"   "\e$(C6`\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Ems"   "\e$(C6a\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Eme"   "\e$(C6b\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Emf"   "\e$(C6c\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Ema"   "\e$(C6d\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Emq"   "\e$(C6e\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Emt"   "\e$(C6f\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "Eml"   "\e$(C6g\e(B"
+    (its-define-hangul "Emls"  "\e$(C6h\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Emlf"  "\e$(C6i\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Emla"  "\e$(C6j\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Emlq"  "\e$(C6k\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "El"    "\e$(C6l\e(B"
+    (its-define-hangul "Els"   "\e$(C6m\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Elf"   "\e$(C6n\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Ela"   "\e$(C6o\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Elq"   "\e$(C6p\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Elt"   "\e$(C6q\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Eld"   "\e$(C6r\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "fk"    "\e$(C6s\e(B"
+    (its-define-hangul "fkr"   "\e$(C6t\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "fks"   "\e$(C6u\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fkf"   "\e$(C6v\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fka"   "\e$(C6w\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fkq"   "\e$(C6x\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fkt"   "\e$(C6y\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "fkT"   "\e$(C6z\e(B"     kjhynmlop)
+    (its-define-hangul "fkd"   "\e$(C6{\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "fkw"   "\e$(C6|\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "fkv"   "\e$(C6}\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fkg"   "\e$(C6~\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "fo"    "\e$(C7!\e(B"
+    (its-define-hangul "for"   "\e$(C7"\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "fos"   "\e$(C7#\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fof"   "\e$(C7$\e(B"     kijuhynbmlopP)
+    (its-define-hangul "foa"   "\e$(C7%\e(B"     kijuhynbmlopP)
+    (its-define-hangul "foq"   "\e$(C7&\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fot"   "\e$(C7'\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "foT"   "\e$(C7(\e(B"     kjhynmlop)
+    (its-define-hangul "fod"   "\e$(C7)\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "fi"    "\e$(C7*\e(B"
+    (its-define-hangul "fir"   "\e$(C7+\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "fis"   "\e$(C7,\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fit"   "\e$(C7-\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "fid"   "\e$(C7.\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "fj"    "\e$(C7/\e(B"
+    (its-define-hangul "fjr"   "\e$(C70\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "fjs"   "\e$(C71\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fjf"   "\e$(C72\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fja"   "\e$(C73\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fjq"   "\e$(C74\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fjt"   "\e$(C75\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "fjT"   "\e$(C76\e(B"     kjhynmlop)
+    (its-define-hangul "fjd"   "\e$(C77\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "fjg"   "\e$(C78\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "fp"    "\e$(C79\e(B"
+    (its-define-hangul "fpr"   "\e$(C7:\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "fps"   "\e$(C7;\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fpf"   "\e$(C7<\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fpa"   "\e$(C7=\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fpq"   "\e$(C7>\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fpt"   "\e$(C7?\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "fpd"   "\e$(C7@\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "fu"    "\e$(C7A\e(B"
+    (its-define-hangul "fur"   "\e$(C7B\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "fus"   "\e$(C7C\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fuf"   "\e$(C7D\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fua"   "\e$(C7E\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fuq"   "\e$(C7F\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fut"   "\e$(C7G\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "fuT"   "\e$(C7H\e(B"     kjhynmlop)
+    (its-define-hangul "fud"   "\e$(C7I\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "fP"    "\e$(C7J\e(B"
+    (its-define-hangul "fPs"   "\e$(C7K\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fPq"   "\e$(C7L\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fPt"   "\e$(C7M\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "fh"    "\e$(C7N\e(B"
+    (its-define-hangul "fhr"   "\e$(C7O\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "fhs"   "\e$(C7P\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fhf"   "\e$(C7Q\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fha"   "\e$(C7R\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fhq"   "\e$(C7S\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fht"   "\e$(C7T\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "fhd"   "\e$(C7U\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "fhk"   "\e$(C7V\e(B"
+    (its-define-hangul "fhks"  "\e$(C7W\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fhkd"  "\e$(C7X\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul  "fho"   "\e$(C7N\e(Bo")
+  (its-defrule-hangul  "fhoT"  "\e$(C7Y\e(B")
+
+  (its-defrule-hangul-2        "fhl"   "\e$(C7Z\e(B"
+    (its-define-hangul "fhls"  "\e$(C7[\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fhlf"  "\e$(C7\\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fhla"  "\e$(C7]\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fhlq"  "\e$(C7^\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fhlt"  "\e$(C7_\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "fhld"  "\e$(C7`\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "fy"    "\e$(C7a\e(B"
+    (its-define-hangul "fys"   "\e$(C7b\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fyf"   "\e$(C7c\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fyq"   "\e$(C7d\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fyt"   "\e$(C7e\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "fyd"   "\e$(C7f\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "fn"    "\e$(C7g\e(B"
+    (its-define-hangul "fnr"   "\e$(C7h\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "fns"   "\e$(C7i\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fnf"   "\e$(C7j\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fna"   "\e$(C7k\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fnq"   "\e$(C7l\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fnt"   "\e$(C7m\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "fnd"   "\e$(C7n\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "fnj"   "\e$(C7o\e(B"
+    (its-define-hangul "fnjT"  "\e$(C7p\e(B"     kjhynmlop))
+
+  (its-defrule-hangul  "fnp"   "\e$(C7q\e(B")
+
+  (its-defrule-hangul-2        "fnl"   "\e$(C7r\e(B"
+    (its-define-hangul "fnlr"  "\e$(C7s\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "fnls"  "\e$(C7t\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fnlf"  "\e$(C7u\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fnla"  "\e$(C7v\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fnlt"  "\e$(C7w\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "fnld"  "\e$(C7x\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "fb"    "\e$(C7y\e(B"
+    (its-define-hangul "fbr"   "\e$(C7z\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "fbs"   "\e$(C7{\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fbf"   "\e$(C7|\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fba"   "\e$(C7}\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fbq"   "\e$(C7~\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fbt"   "\e$(C8!\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "fbd"   "\e$(C8"\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "fm"    "\e$(C8#\e(B"
+    (its-define-hangul "fmr"   "\e$(C8$\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "fms"   "\e$(C8%\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fmf"   "\e$(C8&\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fma"   "\e$(C8'\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fmq"   "\e$(C8(\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fmt"   "\e$(C8)\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "fmd"   "\e$(C8*\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "fmw"   "\e$(C8+\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "fmx"   "\e$(C8,\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fmv"   "\e$(C8-\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "fl"    "\e$(C8.\e(B"
+    (its-define-hangul "flr"   "\e$(C8/\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "fls"   "\e$(C80\e(B"     kijuhynbmlopP)
+    (its-define-hangul "flf"   "\e$(C81\e(B"     kijuhynbmlopP)
+    (its-define-hangul "fla"   "\e$(C82\e(B"     kijuhynbmlopP)
+    (its-define-hangul "flq"   "\e$(C83\e(B"     kijuhynbmlopP)
+    (its-define-hangul "flt"   "\e$(C84\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "fld"   "\e$(C85\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "ak"    "\e$(C86\e(B"
+    (its-define-hangul "akr"   "\e$(C87\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "aks"   "\e$(C88\e(B"     kijuhynbmlopP
+     (its-define-hangul        "aksg"  "\e$(C89\e(B"     kijuhynbmlopP))
+    (its-define-hangul "ake"   "\e$(C8:\e(B"     kijuhynbmlopP)
+    (its-define-hangul "akf"   "\e$(C8;\e(B"     kijuhynbmlopP
+     (its-define-hangul        "akfr"  "\e$(C8<\e(B"     kijuhynbmlopOP)
+     (its-define-hangul        "akfa"  "\e$(C8=\e(B"     kijuhynbmlopP))
+    (its-define-hangul "aka"   "\e$(C8>\e(B"     kijuhynbmlopP)
+    (its-define-hangul "akq"   "\e$(C8?\e(B"     kijuhynbmlopP)
+    (its-define-hangul "akt"   "\e$(C8@\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "akd"   "\e$(C8A\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "akw"   "\e$(C8B\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "akx"   "\e$(C8C\e(B"     kijuhynbmlopP)
+    (its-define-hangul "akg"   "\e$(C8D\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "ao"    "\e$(C8E\e(B"
+    (its-define-hangul "aor"   "\e$(C8F\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "aos"   "\e$(C8G\e(B"     kijuhynbmlopP)
+    (its-define-hangul "aof"   "\e$(C8H\e(B"     kijuhynbmlopP)
+    (its-define-hangul "aoa"   "\e$(C8I\e(B"     kijuhynbmlopP)
+    (its-define-hangul "aoq"   "\e$(C8J\e(B"     kijuhynbmlopP)
+    (its-define-hangul "aot"   "\e$(C8K\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "aoT"   "\e$(C8L\e(B"     kjhynmlop)
+    (its-define-hangul "aod"   "\e$(C8M\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "aow"   "\e$(C8N\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "ai"    "\e$(C8O\e(B"
+    (its-define-hangul "air"   "\e$(C8P\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "aif"   "\e$(C8Q\e(B"     kijuhynbmlopP)
+    (its-define-hangul "aid"   "\e$(C8R\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "aj"    "\e$(C8S\e(B"
+    (its-define-hangul "ajr"   "\e$(C8T\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ajs"   "\e$(C8U\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ajf"   "\e$(C8V\e(B"     kijuhynbmlopP
+     (its-define-hangul        "ajfa"  "\e$(C8W\e(B"     kijuhynbmlopP))
+    (its-define-hangul "aja"   "\e$(C8X\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ajq"   "\e$(C8Y\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ajt"   "\e$(C8Z\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ajd"   "\e$(C8[\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ajw"   "\e$(C8\\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ajg"   "\e$(C8]\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "ap"    "\e$(C8^\e(B"
+    (its-define-hangul "apr"   "\e$(C8_\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "aps"   "\e$(C8`\e(B"     kijuhynbmlopP)
+    (its-define-hangul "apf"   "\e$(C8a\e(B"     kijuhynbmlopP)
+    (its-define-hangul "apa"   "\e$(C8b\e(B"     kijuhynbmlopP)
+    (its-define-hangul "apq"   "\e$(C8c\e(B"     kijuhynbmlopP)
+    (its-define-hangul "apt"   "\e$(C8d\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "apT"   "\e$(C8e\e(B"     kjhynmlop)
+    (its-define-hangul "apd"   "\e$(C8f\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "au"    "\e$(C8g\e(B"
+    (its-define-hangul "aur"   "\e$(C8h\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "aus"   "\e$(C8i\e(B"     kijuhynbmlopP)
+    (its-define-hangul "auf"   "\e$(C8j\e(B"     kijuhynbmlopP)
+    (its-define-hangul "aut"   "\e$(C8k\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "auT"   "\e$(C8l\e(B"     kjhynmlop)
+    (its-define-hangul "aud"   "\e$(C8m\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "auc"   "\e$(C8n\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul  "aP"    "\e$(C8o\e(B")
+
+  (its-defrule-hangul-2        "ah"    "\e$(C8p\e(B"
+    (its-define-hangul "ahr"   "\e$(C8q\e(B"     kijuhynbmlopOP
+     (its-define-hangul        "ahrt"  "\e$(C8r\e(B"     kijuhynbmlopOP))
+    (its-define-hangul "ahs"   "\e$(C8s\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ahf"   "\e$(C8t\e(B"     kijuhynbmlopP
+     (its-define-hangul        "ahfa"  "\e$(C8u\e(B"     kijuhynbmlopP))
+    (its-define-hangul "aha"   "\e$(C8v\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ahq"   "\e$(C8w\e(B"     kijuhynbmlopP)
+    (its-define-hangul "aht"   "\e$(C8x\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ahd"   "\e$(C8y\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "ahk"   "\e$(C8z\e(B"
+    (its-define-hangul "ahks"  "\e$(C8{\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ahkT"  "\e$(C8|\e(B"     kjhynmlop)
+    (its-define-hangul "ahkd"  "\e$(C8}\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "ahl"   "\e$(C8~\e(B"
+    (its-define-hangul "ahls"  "\e$(C9!\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ahlf"  "\e$(C9"\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ahlq"  "\e$(C9#\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ahlt"  "\e$(C9$\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ahld"  "\e$(C9%\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "ay"    "\e$(C9&\e(B"
+    (its-define-hangul "ays"   "\e$(C9'\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ayf"   "\e$(C9(\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ayq"   "\e$(C9)\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ayt"   "\e$(C9*\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "an"    "\e$(C9+\e(B"
+    (its-define-hangul "anr"   "\e$(C9,\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "anR"   "\e$(C9-\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ans"   "\e$(C9.\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ane"   "\e$(C9/\e(B"     kijuhynbmlopP)
+    (its-define-hangul "anf"   "\e$(C90\e(B"     kijuhynbmlopP
+     (its-define-hangul        "anfr"  "\e$(C91\e(B"     kijuhynbmlopOP)
+     (its-define-hangul        "anfa"  "\e$(C92\e(B"     kijuhynbmlopP))
+    (its-define-hangul "ana"   "\e$(C93\e(B"     kijuhynbmlopP)
+    (its-define-hangul "anq"   "\e$(C94\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ant"   "\e$(C95\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "and"   "\e$(C96\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "anx"   "\e$(C97\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ang"   "\e$(C98\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "anj"   "\e$(C99\e(B"
+    (its-define-hangul "anjs"  "\e$(C9:\e(B"     kijuhynbmlopP)
+    (its-define-hangul "anjf"  "\e$(C9;\e(B"     kijuhynbmlopP)
+    (its-define-hangul "anjq"  "\e$(C9<\e(B"     kijuhynbmlopP)
+    (its-define-hangul "anjt"  "\e$(C9=\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul  "anp"   "\e$(C9>\e(B")
+
+  (its-defrule-hangul-2        "anl"   "\e$(C9?\e(B"
+    (its-define-hangul "anls"  "\e$(C9@\e(B"     kijuhynbmlopP)
+    (its-define-hangul "anlf"  "\e$(C9A\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "ab"    "\e$(C9B\e(B"
+    (its-define-hangul "abs"   "\e$(C9C\e(B"     kijuhynbmlopP)
+    (its-define-hangul "abf"   "\e$(C9D\e(B"     kijuhynbmlopP)
+    (its-define-hangul "aba"   "\e$(C9E\e(B"     kijuhynbmlopP)
+    (its-define-hangul "abt"   "\e$(C9F\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "am"    "\e$(C9G\e(B"
+    (its-define-hangul "ams"   "\e$(C9H\e(B"     kijuhynbmlopP)
+    (its-define-hangul "amf"   "\e$(C9I\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ama"   "\e$(C9J\e(B"     kijuhynbmlopP)
+    (its-define-hangul "amt"   "\e$(C9K\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "al"    "\e$(C9L\e(B"
+    (its-define-hangul "alr"   "\e$(C9M\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "als"   "\e$(C9N\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ale"   "\e$(C9O\e(B"     kijuhynbmlopP)
+    (its-define-hangul "alf"   "\e$(C9P\e(B"     kijuhynbmlopP
+     (its-define-hangul        "alfa"  "\e$(C9Q\e(B"     kijuhynbmlopP))
+    (its-define-hangul "ala"   "\e$(C9R\e(B"     kijuhynbmlopP)
+    (its-define-hangul "alq"   "\e$(C9S\e(B"     kijuhynbmlopP)
+    (its-define-hangul "alt"   "\e$(C9T\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "alT"   "\e$(C9U\e(B"     kjhynmlop)
+    (its-define-hangul "ald"   "\e$(C9V\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "alc"   "\e$(C9W\e(B"     kijuhynbmlopP)
+    (its-define-hangul "alx"   "\e$(C9X\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "qk"    "\e$(C9Y\e(B"
+    (its-define-hangul "qkr"   "\e$(C9Z\e(B"     kijuhynbmlopOP
+     (its-define-hangul        "qkrt"  "\e$(C9\\e(B"     kijuhynbmlopOP))
+    (its-define-hangul "qkR"   "\e$(C9[\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qks"   "\e$(C9]\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qke"   "\e$(C9^\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qkf"   "\e$(C9_\e(B"     kijuhynbmlopP
+     (its-define-hangul        "qkfr"  "\e$(C9`\e(B"     kijuhynbmlopOP)
+     (its-define-hangul        "qkfa"  "\e$(C9a\e(B"     kijuhynbmlopP)
+     (its-define-hangul        "qkfq"  "\e$(C9b\e(B"     kijuhynbmlopP))
+    (its-define-hangul "qka"   "\e$(C9c\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qkq"   "\e$(C9d\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qkt"   "\e$(C9e\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "qkd"   "\e$(C9f\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "qkx"   "\e$(C9g\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "qo"    "\e$(C9h\e(B"
+    (its-define-hangul "qor"   "\e$(C9i\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "qos"   "\e$(C9j\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qof"   "\e$(C9k\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qoa"   "\e$(C9l\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qoq"   "\e$(C9m\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qot"   "\e$(C9n\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "qoT"   "\e$(C9o\e(B"     kjhynmlop)
+    (its-define-hangul "qod"   "\e$(C9p\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "qox"   "\e$(C9q\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "qi"    "\e$(C9r\e(B"
+    (its-define-hangul "qir"   "\e$(C9s\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "qis"   "\e$(C9t\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qiq"   "\e$(C9u\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "qj"    "\e$(C9v\e(B"
+    (its-define-hangul "qjr"   "\e$(C9w\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "qjs"   "\e$(C9x\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qje"   "\e$(C9y\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qjf"   "\e$(C9z\e(B"     kijuhynbmlopP
+     (its-define-hangul        "qjfa"  "\e$(C9{\e(B"     kijuhynbmlopP))
+    (its-define-hangul "qja"   "\e$(C9|\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qjq"   "\e$(C9}\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qjt"   "\e$(C9~\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "qjd"   "\e$(C:!\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "qjw"   "\e$(C:"\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "qp"    "\e$(C:#\e(B"
+    (its-define-hangul "qpr"   "\e$(C:$\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "qps"   "\e$(C:%\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qpe"   "\e$(C:&\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qpf"   "\e$(C:'\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qpa"   "\e$(C:(\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qpq"   "\e$(C:)\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qpt"   "\e$(C:*\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "qpT"   "\e$(C:+\e(B"     kjhynmlop)
+    (its-define-hangul "qpd"   "\e$(C:,\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "qu"    "\e$(C:-\e(B"
+    (its-define-hangul "qur"   "\e$(C:.\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "qus"   "\e$(C:/\e(B"     kijuhynbmlopP)
+    (its-define-hangul "quf"   "\e$(C:0\e(B"     kijuhynbmlopP)
+    (its-define-hangul "quq"   "\e$(C:1\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qut"   "\e$(C:2\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "quT"   "\e$(C:3\e(B"     kjhynmlop)
+    (its-define-hangul "qud"   "\e$(C:4\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "qux"   "\e$(C:5\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "qP"    "\e$(C:6\e(B"
+    (its-define-hangul "qPs"   "\e$(C:7\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "qh"    "\e$(C:8\e(B"
+    (its-define-hangul "qhr"   "\e$(C:9\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "qhR"   "\e$(C::\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qhs"   "\e$(C:;\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qhf"   "\e$(C:<\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qha"   "\e$(C:=\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qhq"   "\e$(C:>\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qht"   "\e$(C:?\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "qhd"   "\e$(C:@\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "qhk"   "\e$(C:A\e(B"
+    (its-define-hangul "qhks"  "\e$(C:B\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qhkT"  "\e$(C:C\e(B"     kjhynmlop))
+
+  (its-defrule-hangul-2        "qho"   "\e$(C:D\e(B"
+    (its-define-hangul "qhoT"  "\e$(C:E\e(B"     kjhynmlop))
+
+  (its-defrule-hangul-2        "qhl"   "\e$(C:F\e(B"
+    (its-define-hangul "qhlr"  "\e$(C:G\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "qhls"  "\e$(C:H\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qhlf"  "\e$(C:I\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qhla"  "\e$(C:J\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qhlq"  "\e$(C:K\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "qy"    "\e$(C:L\e(B"
+    (its-define-hangul "qys"   "\e$(C:M\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "qn"    "\e$(C:N\e(B"
+    (its-define-hangul "qnr"   "\e$(C:O\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "qns"   "\e$(C:P\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qne"   "\e$(C:Q\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qnf"   "\e$(C:R\e(B"     kijuhynbmlopP
+     (its-define-hangul        "qnfr"  "\e$(C:S\e(B"     kijuhynbmlopOP)
+     (its-define-hangul        "qnfa"  "\e$(C:T\e(B"     kijuhynbmlopP))
+    (its-define-hangul "qna"   "\e$(C:U\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qnq"   "\e$(C:V\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qnt"   "\e$(C:W\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "qnd"   "\e$(C:X\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "qnx"   "\e$(C:Y\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qnv"   "\e$(C:Z\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "qnj"   "\e$(C:[\e(B"
+    (its-define-hangul "qnjf"  "\e$(C:\\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qnjT"  "\e$(C:]\e(B"     kjhynmlop))
+
+  (its-defrule-hangul  "qnp"   "\e$(C:^\e(B")
+
+  (its-defrule-hangul-2        "qnl"   "\e$(C:_\e(B"
+    (its-define-hangul "qnlr"  "\e$(C:`\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "qnls"  "\e$(C:a\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qnlf"  "\e$(C:b\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qnld"  "\e$(C:c\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "qb"    "\e$(C:d\e(B"
+    (its-define-hangul "qbs"   "\e$(C:e\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qbf"   "\e$(C:f\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qba"   "\e$(C:g\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qbt"   "\e$(C:h\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "qbd"   "\e$(C:i\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "qm"    "\e$(C:j\e(B"
+    (its-define-hangul "qmr"   "\e$(C:k\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "qms"   "\e$(C:l\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qmf"   "\e$(C:m\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qma"   "\e$(C:n\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qmq"   "\e$(C:o\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qmt"   "\e$(C:p\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "ql"    "\e$(C:q\e(B"
+    (its-define-hangul "qlr"   "\e$(C:r\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "qls"   "\e$(C:s\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qlf"   "\e$(C:t\e(B"     kijuhynbmlopP
+     (its-define-hangul        "qlfa"  "\e$(C:u\e(B"     kijuhynbmlopP))
+    (its-define-hangul "qla"   "\e$(C:v\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qlq"   "\e$(C:w\e(B"     kijuhynbmlopP)
+    (its-define-hangul "qlt"   "\e$(C:x\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "qld"   "\e$(C:y\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "qlw"   "\e$(C:z\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "qlc"   "\e$(C:{\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "Qk"    "\e$(C:|\e(B"
+    (its-define-hangul "Qkr"   "\e$(C:}\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Qks"   "\e$(C:~\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Qkf"   "\e$(C;!\e(B"     kijuhynbmlopP
+     (its-define-hangul        "Qkfa"  "\e$(C;"\e(B"     kijuhynbmlopP))
+    (its-define-hangul "Qka"   "\e$(C;#\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Qkq"   "\e$(C;$\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Qkt"   "\e$(C;%\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "QkT"   "\e$(C;&\e(B"     kjhynmlop)
+    (its-define-hangul "Qkd"   "\e$(C;'\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Qkg"   "\e$(C;(\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "Qo"    "\e$(C;)\e(B"
+    (its-define-hangul "Qor"   "\e$(C;*\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Qos"   "\e$(C;+\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Qof"   "\e$(C;,\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Qoa"   "\e$(C;-\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Qoq"   "\e$(C;.\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Qot"   "\e$(C;/\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "QoT"   "\e$(C;0\e(B"     kjhynmlop)
+    (its-define-hangul "Qod"   "\e$(C;1\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "Qi"    "\e$(C;2\e(B"
+    (its-define-hangul "Qir"   "\e$(C;3\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Qia"   "\e$(C;4\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "Qj"    "\e$(C;5\e(B"
+    (its-define-hangul "Qjr"   "\e$(C;6\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Qjs"   "\e$(C;7\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Qje"   "\e$(C;8\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Qjf"   "\e$(C;9\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Qja"   "\e$(C;:\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Qjt"   "\e$(C;;\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "QjT"   "\e$(C;<\e(B"     kjhynmlop)
+    (its-define-hangul "Qjd"   "\e$(C;=\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "Qp"    "\e$(C;>\e(B"
+    (its-define-hangul "Qpd"   "\e$(C;?\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "Qu"    "\e$(C;@\e(B"
+    (its-define-hangul "Qur"   "\e$(C;A\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Qua"   "\e$(C;B\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Quq"   "\e$(C;C\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Qut"   "\e$(C;D\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "QuT"   "\e$(C;E\e(B"     kjhynmlop)
+    (its-define-hangul "Qud"   "\e$(C;F\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "Qh"    "\e$(C;G\e(B"
+    (its-define-hangul "Qhr"   "\e$(C;H\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Qhs"   "\e$(C;I\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Qhf"   "\e$(C;J\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Qha"   "\e$(C;K\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Qhq"   "\e$(C;L\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Qhd"   "\e$(C;M\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul  "Qhl"   "\e$(C;N\e(B")
+
+  (its-defrule-hangul-2        "Qy"    "\e$(C;O\e(B"
+    (its-define-hangul "Qyd"   "\e$(C;P\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "Qn"    "\e$(C;Q\e(B"
+    (its-define-hangul "Qnr"   "\e$(C;R\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Qns"   "\e$(C;S\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Qnf"   "\e$(C;T\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Qna"   "\e$(C;U\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Qnt"   "\e$(C;V\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Qnd"   "\e$(C;W\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "Qb"    "\e$(C;X\e(B"
+    (its-define-hangul "Qbd"   "\e$(C;Y\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "Qm"    "\e$(C;Z\e(B"
+    (its-define-hangul "Qms"   "\e$(C;[\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Qmf"   "\e$(C;\\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Qma"   "\e$(C;]\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Qmq"   "\e$(C;^\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "Ql"    "\e$(C;_\e(B"
+    (its-define-hangul "Qlr"   "\e$(C;`\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Qls"   "\e$(C;a\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Qlf"   "\e$(C;b\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Qla"   "\e$(C;c\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Qlq"   "\e$(C;d\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Qlt"   "\e$(C;e\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Qld"   "\e$(C;f\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "tk"    "\e$(C;g\e(B"
+    (its-define-hangul "tkr"   "\e$(C;h\e(B"     kijuhynbmlopOP
+     (its-define-hangul        "tkrt"  "\e$(C;i\e(B"     kijuhynbmlopOP))
+    (its-define-hangul "tks"   "\e$(C;j\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tke"   "\e$(C;k\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tkf"   "\e$(C;l\e(B"     kijuhynbmlopP
+     (its-define-hangul        "tkfr"  "\e$(C;m\e(B"     kijuhynbmlopOP)
+     (its-define-hangul        "tkfa"  "\e$(C;n\e(B"     kijuhynbmlopP))
+    (its-define-hangul "tka"   "\e$(C;o\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tkq"   "\e$(C;p\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tkt"   "\e$(C;q\e(B"     kijuhynbmlopOP
+     (its-define-hangul        "tktT"  "\e$(C;r\e(B"     kjhynmlop))
+    (its-define-hangul "tkd"   "\e$(C;s\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "tkx"   "\e$(C;t\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "to"    "\e$(C;u\e(B"
+    (its-define-hangul "tor"   "\e$(C;v\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "tos"   "\e$(C;w\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tof"   "\e$(C;x\e(B"     kijuhynbmlopP)
+    (its-define-hangul "toa"   "\e$(C;y\e(B"     kijuhynbmlopP)
+    (its-define-hangul "toq"   "\e$(C;z\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tot"   "\e$(C;{\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "toT"   "\e$(C;|\e(B"     kjhynmlop)
+    (its-define-hangul "tod"   "\e$(C;}\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "ti"    "\e$(C;~\e(B"
+    (its-define-hangul "tir"   "\e$(C<!\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "tis"   "\e$(C<"\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tif"   "\e$(C<#\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tia"   "\e$(C<$\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tiq"   "\e$(C<%\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tit"   "\e$(C<&\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "tid"   "\e$(C<'\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "tO"    "\e$(C<(\e(B"
+    (its-define-hangul "tOs"   "\e$(C<)\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tOf"   "\e$(C<*\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tOa"   "\e$(C<+\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tOd"   "\e$(C<,\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "tj"    "\e$(C<-\e(B"
+    (its-define-hangul "tjr"   "\e$(C<.\e(B"     kijuhynbmlopOP
+     (its-define-hangul        "tjrt"  "\e$(C<0\e(B"     kijuhynbmlopOP))
+    (its-define-hangul "tjR"   "\e$(C</\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tjs"   "\e$(C<1\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tje"   "\e$(C<2\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tjf"   "\e$(C<3\e(B"     kijuhynbmlopP
+     (its-define-hangul        "tjfa"  "\e$(C<4\e(B"     kijuhynbmlopP)
+     (its-define-hangul        "tjfq"  "\e$(C<5\e(B"     kijuhynbmlopP))
+    (its-define-hangul "tja"   "\e$(C<6\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tjq"   "\e$(C<7\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tjt"   "\e$(C<8\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "tjT"   "\e$(C<9\e(B"     kjhynmlop)
+    (its-define-hangul "tjd"   "\e$(C<:\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "tjv"   "\e$(C<;\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "tp"    "\e$(C<<\e(B"
+    (its-define-hangul "tpr"   "\e$(C<=\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "tps"   "\e$(C<>\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tpf"   "\e$(C<?\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tpa"   "\e$(C<@\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tpq"   "\e$(C<A\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tpt"   "\e$(C<B\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "tpT"   "\e$(C<C\e(B"     kjhynmlop)
+    (its-define-hangul "tpd"   "\e$(C<D\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "tu"    "\e$(C<E\e(B"
+    (its-define-hangul "tur"   "\e$(C<F\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "tus"   "\e$(C<G\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tuf"   "\e$(C<H\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tua"   "\e$(C<I\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tuq"   "\e$(C<J\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tut"   "\e$(C<K\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "tuT"   "\e$(C<L\e(B"     kjhynmlop)
+    (its-define-hangul "tud"   "\e$(C<M\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "tP"    "\e$(C<N\e(B"
+    (its-define-hangul "tPs"   "\e$(C<O\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tPf"   "\e$(C<P\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tPd"   "\e$(C<Q\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "th"    "\e$(C<R\e(B"
+    (its-define-hangul "thr"   "\e$(C<S\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "thR"   "\e$(C<T\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ths"   "\e$(C<U\e(B"     kijuhynbmlopP)
+    (its-define-hangul "thf"   "\e$(C<V\e(B"     kijuhynbmlopP
+     (its-define-hangul        "thfa"  "\e$(C<W\e(B"     kijuhynbmlopP))
+    (its-define-hangul "tha"   "\e$(C<X\e(B"     kijuhynbmlopP)
+    (its-define-hangul "thq"   "\e$(C<Y\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tht"   "\e$(C<Z\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "thd"   "\e$(C<[\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "thx"   "\e$(C<\\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "thk"   "\e$(C<]\e(B"
+    (its-define-hangul "thkr"  "\e$(C<^\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "thks"  "\e$(C<_\e(B"     kijuhynbmlopP)
+    (its-define-hangul "thkf"  "\e$(C<`\e(B"     kijuhynbmlopP)
+    (its-define-hangul "thkd"  "\e$(C<a\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "tho"   "\e$(C<b\e(B"
+    (its-define-hangul "thos"  "\e$(C<c\e(B"     kijuhynbmlopP)
+    (its-define-hangul "thof"  "\e$(C<d\e(B"     kijuhynbmlopP)
+    (its-define-hangul "thoa"  "\e$(C<e\e(B"     kijuhynbmlopP)
+    (its-define-hangul "thot"  "\e$(C<f\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "thoT"  "\e$(C<g\e(B"     kjhynmlop))
+
+  (its-defrule-hangul-2        "thl"   "\e$(C<h\e(B"
+    (its-define-hangul "thls"  "\e$(C<i\e(B"     kijuhynbmlopP)
+    (its-define-hangul "thlf"  "\e$(C<j\e(B"     kijuhynbmlopP)
+    (its-define-hangul "thla"  "\e$(C<k\e(B"     kijuhynbmlopP)
+    (its-define-hangul "thlq"  "\e$(C<l\e(B"     kijuhynbmlopP)
+    (its-define-hangul "thlt"  "\e$(C<m\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "ty"    "\e$(C<n\e(B"
+    (its-define-hangul "tyr"   "\e$(C<o\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "tys"   "\e$(C<p\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tyf"   "\e$(C<q\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tya"   "\e$(C<r\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tyq"   "\e$(C<s\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tyt"   "\e$(C<t\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "tyd"   "\e$(C<u\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "tn"    "\e$(C<v\e(B"
+    (its-define-hangul "tnr"   "\e$(C<w\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "tns"   "\e$(C<x\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tne"   "\e$(C<y\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tnf"   "\e$(C<z\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tna"   "\e$(C<{\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tnq"   "\e$(C<|\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tnt"   "\e$(C<}\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "tnd"   "\e$(C<~\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "tnc"   "\e$(C=!\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tnx"   "\e$(C="\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tnv"   "\e$(C=#\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "tnj"   "\e$(C=$\e(B"
+    (its-define-hangul "tnjT"  "\e$(C=%\e(B"     kjhynmlop))
+
+  (its-defrule-hangul-2        "tnp"   "\e$(C=&\e(B"
+    (its-define-hangul "tnpr"  "\e$(C='\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "tnps"  "\e$(C=(\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tnpf"  "\e$(C=)\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tnpa"  "\e$(C=*\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tnpd"  "\e$(C=+\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "tnl"   "\e$(C=,\e(B"
+    (its-define-hangul "tnlr"  "\e$(C=-\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "tnls"  "\e$(C=.\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tnlf"  "\e$(C=/\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tnla"  "\e$(C=0\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tnlq"  "\e$(C=1\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tnlt"  "\e$(C=2\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "tnld"  "\e$(C=3\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "tb"    "\e$(C=4\e(B"
+    (its-define-hangul "tbr"   "\e$(C=5\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "tbf"   "\e$(C=6\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tba"   "\e$(C=7\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tbt"   "\e$(C=8\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "tbd"   "\e$(C=9\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "tm"    "\e$(C=:\e(B"
+    (its-define-hangul "tmr"   "\e$(C=;\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "tms"   "\e$(C=<\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tmf"   "\e$(C==\e(B"     kijuhynbmlopP
+     (its-define-hangul        "tmfr"  "\e$(C=>\e(B"     kijuhynbmlopOP))
+    (its-define-hangul "tma"   "\e$(C=?\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tmq"   "\e$(C=@\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tmt"   "\e$(C=A\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "tmd"   "\e$(C=B\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "tl"    "\e$(C=C\e(B"
+    (its-define-hangul "tlr"   "\e$(C=D\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "tls"   "\e$(C=E\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tle"   "\e$(C=F\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tlf"   "\e$(C=G\e(B"     kijuhynbmlopP
+     (its-define-hangul        "tlfg"  "\e$(C=H\e(B"     kijuhynbmlopP))
+    (its-define-hangul "tla"   "\e$(C=I\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tlq"   "\e$(C=J\e(B"     kijuhynbmlopP)
+    (its-define-hangul "tlt"   "\e$(C=K\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "tld"   "\e$(C=L\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "tlv"   "\e$(C=M\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "Tk"    "\e$(C=N\e(B"
+    (its-define-hangul "Tkr"   "\e$(C=O\e(B"     kijuhynbmlopOP
+     (its-define-hangul        "Tkrt"  "\e$(C=P\e(B"     kijuhynbmlopOP))
+    (its-define-hangul "Tks"   "\e$(C=Q\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Tkf"   "\e$(C=R\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Tka"   "\e$(C=S\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Tkq"   "\e$(C=T\e(B"     kijuhynbmlopP)
+    (its-define-hangul "TkT"   "\e$(C=U\e(B"     kjhynmlop)
+    (its-define-hangul "Tkd"   "\e$(C=V\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Tkg"   "\e$(C=W\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "To"    "\e$(C=X\e(B"
+    (its-define-hangul "Tor"   "\e$(C=Y\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Tos"   "\e$(C=Z\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Tof"   "\e$(C=[\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Toa"   "\e$(C=\\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Toq"   "\e$(C=]\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ToT"   "\e$(C=^\e(B"     kjhynmlop)
+    (its-define-hangul "Tod"   "\e$(C=_\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul  "Ti"    "\e$(C$6\e(Bi")
+  (its-defrule-hangul  "Tid"   "\e$(C=`\e(B")
+
+  (its-defrule-hangul-2        "Tj"    "\e$(C=a\e(B"
+    (its-define-hangul "Tjr"   "\e$(C=b\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Tjs"   "\e$(C=c\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Tjf"   "\e$(C=d\e(B"     kijuhynbmlopP
+     (its-define-hangul        "Tjfq"  "\e$(C=e\e(B"     kijuhynbmlopP))
+    (its-define-hangul "Tja"   "\e$(C=f\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Tjq"   "\e$(C=g\e(B"     kijuhynbmlopP)
+    (its-define-hangul "TjT"   "\e$(C=h\e(B"     kjhynmlop)
+    (its-define-hangul "Tjd"   "\e$(C=i\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "Tp"    "\e$(C=j\e(B"
+    (its-define-hangul "Tps"   "\e$(C=k\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Tpf"   "\e$(C=l\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul  "TP"    "\e$(C$6\e(BP")
+  (its-defrule-hangul  "TPs"   "\e$(C=m\e(B")
+
+  (its-defrule-hangul-2        "Th"    "\e$(C=n\e(B"
+    (its-define-hangul "Thr"   "\e$(C=o\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Ths"   "\e$(C=p\e(B"     kijuhynbmlopP)
+    (its-define-hangul "The"   "\e$(C=q\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Thf"   "\e$(C=r\e(B"     kijuhynbmlopP
+     (its-define-hangul        "Thfa"  "\e$(C=s\e(B"     kijuhynbmlopP))
+    (its-define-hangul "Tha"   "\e$(C=t\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Thq"   "\e$(C=u\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Thd"   "\e$(C=v\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "Thk"   "\e$(C=w\e(B"
+    (its-define-hangul "Thkr"  "\e$(C=x\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Thks"  "\e$(C=y\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ThkT"  "\e$(C=z\e(B"     kjhynmlop))
+
+  (its-defrule-hangul-2        "Tho"   "\e$(C={\e(B"
+    (its-define-hangul "ThoT"  "\e$(C=|\e(B"     kjhynmlop))
+
+  (its-defrule-hangul-2        "Thl"   "\e$(C=}\e(B"
+    (its-define-hangul "Thls"  "\e$(C=~\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Thlf"  "\e$(C>!\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Thla"  "\e$(C>"\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Thlq"  "\e$(C>#\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul  "Ty"    "\e$(C>$\e(B")
+
+  (its-defrule-hangul-2        "Tn"    "\e$(C>%\e(B"
+    (its-define-hangul "Tnr"   "\e$(C>&\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Tns"   "\e$(C>'\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Tnf"   "\e$(C>(\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Tna"   "\e$(C>)\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Tnq"   "\e$(C>*\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Tnd"   "\e$(C>+\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "Tnj"   "\e$(C>,\e(B"
+    (its-define-hangul "TnjT"  "\e$(C>-\e(B"     kjhynmlop))
+
+  (its-defrule-hangul  "Tnjp"  "\e$(C>.\e(B")
+
+  (its-defrule-hangul-2        "Tnl"   "\e$(C>/\e(B"
+    (its-define-hangul "Tnls"  "\e$(C>0\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul  "Tb"    "\e$(C$6\e(Bd")
+  (its-defrule-hangul  "Tbd"   "\e$(C>1\e(B")
+
+  (its-defrule-hangul-2        "Tm"    "\e$(C>2\e(B"
+    (its-define-hangul "Tmr"   "\e$(C>3\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Tms"   "\e$(C>4\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Tmf"   "\e$(C>5\e(B"     kijuhynbmlopP
+     (its-define-hangul        "Tmfa"  "\e$(C>6\e(B"     kijuhynbmlopP)
+     (its-define-hangul        "Tmfg"  "\e$(C>7\e(B"     kijuhynbmlopP))
+    (its-define-hangul "Tma"   "\e$(C>8\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Tmq"   "\e$(C>9\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "Tml"   "\e$(C>:\e(B"
+    (its-define-hangul "Tmls"  "\e$(C>;\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Tmlf"  "\e$(C><\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Tmla"  "\e$(C>=\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "Tl"    "\e$(C>>\e(B"
+    (its-define-hangul "Tlr"   "\e$(C>?\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Tls"   "\e$(C>@\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Tlf"   "\e$(C>A\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Tla"   "\e$(C>B\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Tlq"   "\e$(C>C\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Tlt"   "\e$(C>D\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Tld"   "\e$(C>E\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "dk"    "\e$(C>F\e(B"
+    (its-define-hangul "dkr"   "\e$(C>G\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dks"   "\e$(C>H\e(B"     kijuhynbmlopP
+     (its-define-hangul        "dksw"  "\e$(C>I\e(B"     kijuhynbmlopOP)
+     (its-define-hangul        "dksg"  "\e$(C>J\e(B"     kijuhynbmlopP))
+    (its-define-hangul "dkf"   "\e$(C>K\e(B"     kijuhynbmlopP
+     (its-define-hangul        "dkfr"  "\e$(C>L\e(B"     kijuhynbmlopOP)
+     (its-define-hangul        "dkfa"  "\e$(C>M\e(B"     kijuhynbmlopP)
+     (its-define-hangul        "dkfg"  "\e$(C>N\e(B"     kijuhynbmlopP))
+    (its-define-hangul "dka"   "\e$(C>O\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dkq"   "\e$(C>P\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dkt"   "\e$(C>Q\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dkT"   "\e$(C>R\e(B"     kjhynmlop)
+    (its-define-hangul "dkd"   "\e$(C>S\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dkx"   "\e$(C>T\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dkv"   "\e$(C>U\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "do"    "\e$(C>V\e(B"
+    (its-define-hangul "dor"   "\e$(C>W\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dos"   "\e$(C>X\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dof"   "\e$(C>Y\e(B"     kijuhynbmlopP)
+    (its-define-hangul "doa"   "\e$(C>Z\e(B"     kijuhynbmlopP)
+    (its-define-hangul "doq"   "\e$(C>[\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dot"   "\e$(C>\\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "doT"   "\e$(C>]\e(B"     kjhynmlop)
+    (its-define-hangul "dod"   "\e$(C>^\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "di"    "\e$(C>_\e(B"
+    (its-define-hangul "dir"   "\e$(C>`\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dis"   "\e$(C>a\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dif"   "\e$(C>b\e(B"     kijuhynbmlopP
+     (its-define-hangul        "difq"  "\e$(C>c\e(B"     kijuhynbmlopP))
+    (its-define-hangul "dia"   "\e$(C>d\e(B"     kijuhynbmlopP)
+    (its-define-hangul "diq"   "\e$(C>e\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dit"   "\e$(C>f\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "did"   "\e$(C>g\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dix"   "\e$(C>h\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dig"   "\e$(C>i\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "dO"    "\e$(C>j\e(B"
+    (its-define-hangul "dOs"   "\e$(C>k\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dOf"   "\e$(C>l\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dOq"   "\e$(C>m\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "dj"    "\e$(C>n\e(B"
+    (its-define-hangul "djr"   "\e$(C>o\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "djs"   "\e$(C>p\e(B"     kijuhynbmlopP
+     (its-define-hangul        "djsw"  "\e$(C>q\e(B"     kijuhynbmlopOP))
+    (its-define-hangul "dje"   "\e$(C>r\e(B"     kijuhynbmlopP)
+    (its-define-hangul "djf"   "\e$(C>s\e(B"     kijuhynbmlopP
+     (its-define-hangul        "djfr"  "\e$(C>t\e(B"     kijuhynbmlopOP)
+     (its-define-hangul        "djfa"  "\e$(C>u\e(B"     kijuhynbmlopP))
+    (its-define-hangul "dja"   "\e$(C>v\e(B"     kijuhynbmlopP)
+    (its-define-hangul "djq"   "\e$(C>w\e(B"     kijuhynbmlopP
+     (its-define-hangul        "djqt"  "\e$(C>x\e(B"     kijuhynbmlopOP))
+    (its-define-hangul "djt"   "\e$(C>y\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "djT"   "\e$(C>z\e(B"     kjhynmlop)
+    (its-define-hangul "djd"   "\e$(C>{\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "djw"   "\e$(C>|\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "djz"   "\e$(C>}\e(B"     kijuhynbmlopP)
+    (its-define-hangul "djv"   "\e$(C>~\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "dp"    "\e$(C?!\e(B"
+    (its-define-hangul "dpr"   "\e$(C?"\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dps"   "\e$(C?#\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dpf"   "\e$(C?$\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dpa"   "\e$(C?%\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dpq"   "\e$(C?&\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dpt"   "\e$(C?'\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dpd"   "\e$(C?(\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "du"    "\e$(C?)\e(B"
+    (its-define-hangul "dur"   "\e$(C?*\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "duR"   "\e$(C?+\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dus"   "\e$(C?,\e(B"     kijuhynbmlopP)
+    (its-define-hangul "duf"   "\e$(C?-\e(B"     kijuhynbmlopP
+     (its-define-hangul        "dufa"  "\e$(C?.\e(B"     kijuhynbmlopP)
+     (its-define-hangul        "dufq"  "\e$(C?/\e(B"     kijuhynbmlopP))
+    (its-define-hangul "dua"   "\e$(C?0\e(B"     kijuhynbmlopP)
+    (its-define-hangul "duq"   "\e$(C?1\e(B"     kijuhynbmlopP
+     (its-define-hangul        "duqt"  "\e$(C?2\e(B"     kijuhynbmlopOP))
+    (its-define-hangul "dut"   "\e$(C?3\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "duT"   "\e$(C?4\e(B"     kjhynmlop)
+    (its-define-hangul "dud"   "\e$(C?5\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dux"   "\e$(C?6\e(B"     kijuhynbmlopP)
+    (its-define-hangul "duv"   "\e$(C?7\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dug"   "\e$(C?8\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "dP"    "\e$(C?9\e(B"
+    (its-define-hangul "dPs"   "\e$(C?:\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dPf"   "\e$(C?;\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dPa"   "\e$(C?<\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dPq"   "\e$(C?=\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dPt"   "\e$(C?>\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dPT"   "\e$(C??\e(B"     kjhynmlop))
+
+  (its-defrule-hangul-2        "dh"    "\e$(C?@\e(B"
+    (its-define-hangul "dhr"   "\e$(C?A\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dhs"   "\e$(C?B\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dhf"   "\e$(C?C\e(B"     kijuhynbmlopP
+     (its-define-hangul        "dhfr"  "\e$(C?D\e(B"     kijuhynbmlopOP)
+     (its-define-hangul        "dhfa"  "\e$(C?E\e(B"     kijuhynbmlopP)
+     (its-define-hangul        "dhft"  "\e$(C?F\e(B"     kijuhynbmlopOP)
+     (its-define-hangul        "dhfg"  "\e$(C?G\e(B"     kijuhynbmlopP))
+    (its-define-hangul "dha"   "\e$(C?H\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dhq"   "\e$(C?I\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dht"   "\e$(C?J\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dhd"   "\e$(C?K\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dhc"   "\e$(C?L\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "dhk"   "\e$(C?M\e(B"
+    (its-define-hangul "dhkr"  "\e$(C?N\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dhks"  "\e$(C?O\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dhkf"  "\e$(C?P\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dhka"  "\e$(C?Q\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dhkq"  "\e$(C?R\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dhkt"  "\e$(C?S\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dhkT"  "\e$(C?T\e(B"     kjhynmlop)
+    (its-define-hangul "dhkd"  "\e$(C?U\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "dho"   "\e$(C?V\e(B"
+    (its-define-hangul "dhor"  "\e$(C?W\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dhos"  "\e$(C?X\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dhoa"  "\e$(C?Y\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dhot"  "\e$(C?Z\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dhod"  "\e$(C?[\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "dhl"   "\e$(C?\\e(B"
+    (its-define-hangul "dhlr"  "\e$(C?]\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dhls"  "\e$(C?^\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dhlf"  "\e$(C?_\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dhla"  "\e$(C?`\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dhlq"  "\e$(C?a\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dhlt"  "\e$(C?b\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dhld"  "\e$(C?c\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "dy"    "\e$(C?d\e(B"
+    (its-define-hangul "dyr"   "\e$(C?e\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dys"   "\e$(C?f\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dyf"   "\e$(C?g\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dya"   "\e$(C?h\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dyq"   "\e$(C?i\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dyt"   "\e$(C?j\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dyd"   "\e$(C?k\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "dn"    "\e$(C?l\e(B"
+    (its-define-hangul "dnr"   "\e$(C?m\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dns"   "\e$(C?n\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dnf"   "\e$(C?o\e(B"     kijuhynbmlopP
+     (its-define-hangul        "dnfr"  "\e$(C?p\e(B"     kijuhynbmlopOP)
+     (its-define-hangul        "dnfa"  "\e$(C?q\e(B"     kijuhynbmlopP))
+    (its-define-hangul "dna"   "\e$(C?r\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dnq"   "\e$(C?s\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dnt"   "\e$(C?t\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dnd"   "\e$(C?u\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "dnj"   "\e$(C?v\e(B"
+    (its-define-hangul "dnjr"  "\e$(C?w\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dnjs"  "\e$(C?x\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dnjf"  "\e$(C?y\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dnja"  "\e$(C?z\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dnjq"  "\e$(C?{\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dnjT"  "\e$(C?|\e(B"     kjhynmlop)
+    (its-define-hangul "dnjd"  "\e$(C?}\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "dnp"   "\e$(C?~\e(B"
+    (its-define-hangul "dnpr"  "\e$(C@!\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dnps"  "\e$(C@"\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dnpf"  "\e$(C@#\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dnpa"  "\e$(C@$\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dnpq"  "\e$(C@%\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dnpd"  "\e$(C@&\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "dnl"   "\e$(C@'\e(B"
+    (its-define-hangul "dnlr"  "\e$(C@(\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dnls"  "\e$(C@)\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dnlf"  "\e$(C@*\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dnla"  "\e$(C@+\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dnlq"  "\e$(C@,\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dnlt"  "\e$(C@-\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dnld"  "\e$(C@.\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "db"    "\e$(C@/\e(B"
+    (its-define-hangul "dbr"   "\e$(C@0\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dbs"   "\e$(C@1\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dbf"   "\e$(C@2\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dba"   "\e$(C@3\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dbq"   "\e$(C@4\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dbt"   "\e$(C@5\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dbd"   "\e$(C@6\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dbc"   "\e$(C@7\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "dm"    "\e$(C@8\e(B"
+    (its-define-hangul "dmr"   "\e$(C@9\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dms"   "\e$(C@:\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dmf"   "\e$(C@;\e(B"     kijuhynbmlopP
+     (its-define-hangul        "dmfv"  "\e$(C@<\e(B"     kijuhynbmlopP))
+    (its-define-hangul "dma"   "\e$(C@=\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dmq"   "\e$(C@>\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dmt"   "\e$(C@?\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dmd"   "\e$(C@@\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dmw"   "\e$(C@A\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dmc"   "\e$(C@B\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dmz"   "\e$(C@C\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dmx"   "\e$(C@D\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dmv"   "\e$(C@E\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dmg"   "\e$(C@F\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "dml"   "\e$(C@G\e(B"
+    (its-define-hangul "dmls"  "\e$(C@H\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dmlf"  "\e$(C@I\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dmla"  "\e$(C@J\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dmlt"  "\e$(C@K\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "dl"    "\e$(C@L\e(B"
+    (its-define-hangul "dlr"   "\e$(C@M\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dls"   "\e$(C@N\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dlf"   "\e$(C@O\e(B"     kijuhynbmlopP
+     (its-define-hangul        "dlfr"  "\e$(C@P\e(B"     kijuhynbmlopOP)
+     (its-define-hangul        "dlfa"  "\e$(C@Q\e(B"     kijuhynbmlopP)
+     (its-define-hangul        "dlfg"  "\e$(C@R\e(B"     kijuhynbmlopP))
+    (its-define-hangul "dla"   "\e$(C@S\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dlq"   "\e$(C@T\e(B"     kijuhynbmlopP)
+    (its-define-hangul "dlt"   "\e$(C@U\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dlT"   "\e$(C@V\e(B"     kjhynmlop)
+    (its-define-hangul "dld"   "\e$(C@W\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dlw"   "\e$(C@X\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "dlv"   "\e$(C@Y\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "wk"    "\e$(C@Z\e(B"
+    (its-define-hangul "wkr"   "\e$(C@[\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "wks"   "\e$(C@\\e(B"     kijuhynbmlopP
+     (its-define-hangul        "wksg"  "\e$(C@]\e(B"     kijuhynbmlopP))
+    (its-define-hangul "wke"   "\e$(C@^\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wkf"   "\e$(C@_\e(B"     kijuhynbmlopP
+     (its-define-hangul        "wkfa"  "\e$(C@`\e(B"     kijuhynbmlopP))
+    (its-define-hangul "wka"   "\e$(C@a\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wkq"   "\e$(C@b\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wkt"   "\e$(C@c\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "wkT"   "\e$(C@d\e(B"     kjhynmlop)
+    (its-define-hangul "wkd"   "\e$(C@e\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "wkw"   "\e$(C@f\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "wo"    "\e$(C@g\e(B"
+    (its-define-hangul "wor"   "\e$(C@h\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "wos"   "\e$(C@i\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wof"   "\e$(C@j\e(B"     kijuhynbmlopP)
+    (its-define-hangul "woa"   "\e$(C@k\e(B"     kijuhynbmlopP)
+    (its-define-hangul "woq"   "\e$(C@l\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wot"   "\e$(C@m\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "woT"   "\e$(C@n\e(B"     kjhynmlop)
+    (its-define-hangul "wod"   "\e$(C@o\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "wi"    "\e$(C@p\e(B"
+    (its-define-hangul "wir"   "\e$(C@q\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "wis"   "\e$(C@r\e(B"     kijuhynbmlopP
+     (its-define-hangul        "wisg"  "\e$(C@s\e(B"     kijuhynbmlopP))
+    (its-define-hangul "wif"   "\e$(C@t\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wia"   "\e$(C@u\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wid"   "\e$(C@v\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "wO"    "\e$(C@w\e(B"
+    (its-define-hangul "wOs"   "\e$(C@x\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wOf"   "\e$(C@y\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "wj"    "\e$(C@z\e(B"
+    (its-define-hangul "wjr"   "\e$(C@{\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "wjs"   "\e$(C@|\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wjf"   "\e$(C@}\e(B"     kijuhynbmlopP
+     (its-define-hangul        "wjfa"  "\e$(C@~\e(B"     kijuhynbmlopP))
+    (its-define-hangul "wja"   "\e$(CA!\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wjq"   "\e$(CA"\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wjt"   "\e$(CA#\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "wjd"   "\e$(CA$\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "wjw"   "\e$(CA%\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "wp"    "\e$(CA&\e(B"
+    (its-define-hangul "wpr"   "\e$(CA'\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "wps"   "\e$(CA(\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wpf"   "\e$(CA)\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wpa"   "\e$(CA*\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wpq"   "\e$(CA+\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wpt"   "\e$(CA,\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "wpd"   "\e$(CA-\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "wu"    "\e$(CA.\e(B"
+    (its-define-hangul "wus"   "\e$(CA/\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wuf"   "\e$(CA0\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wua"   "\e$(CA1\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wuq"   "\e$(CA2\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wuT"   "\e$(CA3\e(B"     kjhynmlop)
+    (its-define-hangul "wud"   "\e$(CA4\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul  "wP"    "\e$(CA5\e(B")
+
+  (its-defrule-hangul-2        "wh"    "\e$(CA6\e(B"
+    (its-define-hangul "whr"   "\e$(CA7\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "whs"   "\e$(CA8\e(B"     kijuhynbmlopP)
+    (its-define-hangul "whf"   "\e$(CA9\e(B"     kijuhynbmlopP
+     (its-define-hangul        "whfa"  "\e$(CA:\e(B"     kijuhynbmlopP))
+    (its-define-hangul "wha"   "\e$(CA;\e(B"     kijuhynbmlopP)
+    (its-define-hangul "whq"   "\e$(CA<\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wht"   "\e$(CA=\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "whd"   "\e$(CA>\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "whw"   "\e$(CA?\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "whc"   "\e$(CA@\e(B"     kijuhynbmlopP)
+    (its-define-hangul "whg"   "\e$(CAA\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "whk"   "\e$(CAB\e(B"
+    (its-define-hangul "whkr"  "\e$(CAC\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "whkf"  "\e$(CAD\e(B"     kijuhynbmlopP)
+    (its-define-hangul "whkq"  "\e$(CAE\e(B"     kijuhynbmlopP)
+    (its-define-hangul "whkt"  "\e$(CAF\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "whkd"  "\e$(CAG\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "who"   "\e$(CAH\e(B"
+    (its-define-hangul "whoT"  "\e$(CAI\e(B"     kjhynmlop)
+    (its-define-hangul "whod"  "\e$(CAJ\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "whl"   "\e$(CAK\e(B"
+    (its-define-hangul "whls"  "\e$(CAL\e(B"     kijuhynbmlopP)
+    (its-define-hangul "whlf"  "\e$(CAM\e(B"     kijuhynbmlopP)
+    (its-define-hangul "whla"  "\e$(CAN\e(B"     kijuhynbmlopP)
+    (its-define-hangul "whlq"  "\e$(CAO\e(B"     kijuhynbmlopP)
+    (its-define-hangul "whlt"  "\e$(CAP\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "whld"  "\e$(CAQ\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "wy"    "\e$(CAR\e(B"
+    (its-define-hangul "wyr"   "\e$(CAS\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "wys"   "\e$(CAT\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wyd"   "\e$(CAU\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "wn"    "\e$(CAV\e(B"
+    (its-define-hangul "wnr"   "\e$(CAW\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "wns"   "\e$(CAX\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wnf"   "\e$(CAY\e(B"     kijuhynbmlopP
+     (its-define-hangul        "wnfr"  "\e$(CAZ\e(B"     kijuhynbmlopOP)
+     (its-define-hangul        "wnfa"  "\e$(CA[\e(B"     kijuhynbmlopP))
+    (its-define-hangul "wna"   "\e$(CA\\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wnq"   "\e$(CA]\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wnt"   "\e$(CA^\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "wnd"   "\e$(CA_\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "wnj"   "\e$(CA`\e(B"
+    (its-define-hangul "wnjT"  "\e$(CAa\e(B"     kjhynmlop))
+
+  (its-defrule-hangul  "wnp"   "\e$(CAb\e(B")
+
+  (its-defrule-hangul-2        "wnl"   "\e$(CAc\e(B"
+    (its-define-hangul "wnlr"  "\e$(CAd\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "wnls"  "\e$(CAe\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wnlf"  "\e$(CAf\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wnla"  "\e$(CAg\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wnlq"  "\e$(CAh\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wnlt"  "\e$(CAi\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "wb"    "\e$(CAj\e(B"
+    (its-define-hangul "wbs"   "\e$(CAk\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wbf"   "\e$(CAl\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wba"   "\e$(CAm\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "wm"    "\e$(CAn\e(B"
+    (its-define-hangul "wmr"   "\e$(CAo\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "wms"   "\e$(CAp\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wmf"   "\e$(CAq\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wma"   "\e$(CAr\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wmq"   "\e$(CAs\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wmt"   "\e$(CAt\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "wmd"   "\e$(CAu\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "wl"    "\e$(CAv\e(B"
+    (its-define-hangul "wlr"   "\e$(CAw\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "wls"   "\e$(CAx\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wle"   "\e$(CAy\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wlf"   "\e$(CAz\e(B"     kijuhynbmlopP
+     (its-define-hangul        "wlfa"  "\e$(CA{\e(B"     kijuhynbmlopP))
+    (its-define-hangul "wla"   "\e$(CA|\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wlq"   "\e$(CA}\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wlt"   "\e$(CA~\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "wld"   "\e$(CB!\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "wlw"   "\e$(CB"\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "wlx"   "\e$(CB#\e(B"     kijuhynbmlopP)
+    (its-define-hangul "wlv"   "\e$(CB$\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "Wk"    "\e$(CB%\e(B"
+    (its-define-hangul "Wkr"   "\e$(CB&\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Wks"   "\e$(CB'\e(B"     kijuhynbmlopP
+     (its-define-hangul        "Wksg"  "\e$(CB(\e(B"     kijuhynbmlopP))
+    (its-define-hangul "Wkf"   "\e$(CB)\e(B"     kijuhynbmlopP
+     (its-define-hangul        "Wkfq"  "\e$(CB*\e(B"     kijuhynbmlopP))
+    (its-define-hangul "Wka"   "\e$(CB+\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Wkq"   "\e$(CB,\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Wkt"   "\e$(CB-\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "WkT"   "\e$(CB.\e(B"     kjhynmlop)
+    (its-define-hangul "Wkd"   "\e$(CB/\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "Wo"    "\e$(CB0\e(B"
+    (its-define-hangul "Wor"   "\e$(CB1\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Wos"   "\e$(CB2\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Wof"   "\e$(CB3\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Woa"   "\e$(CB4\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Woq"   "\e$(CB5\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Wot"   "\e$(CB6\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "WoT"   "\e$(CB7\e(B"     kjhynmlop)
+    (its-define-hangul "Wod"   "\e$(CB8\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "Wi"    "\e$(CB9\e(B"
+    (its-define-hangul "Wis"   "\e$(CB:\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Wid"   "\e$(CB;\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "Wj"    "\e$(CB<\e(B"
+    (its-define-hangul "Wjr"   "\e$(CB=\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Wjs"   "\e$(CB>\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Wjf"   "\e$(CB?\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Wja"   "\e$(CB@\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Wjq"   "\e$(CBA\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Wjt"   "\e$(CBB\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "WjT"   "\e$(CBC\e(B"     kjhynmlop)
+    (its-define-hangul "Wjd"   "\e$(CBD\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "Wp"    "\e$(CBE\e(B"
+    (its-define-hangul "Wpd"   "\e$(CBF\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "Wu"    "\e$(CBG\e(B"
+    (its-define-hangul "WuT"   "\e$(CBH\e(B"     kjhynmlop))
+
+  (its-defrule-hangul-2        "Wh"    "\e$(CBI\e(B"
+    (its-define-hangul "Whr"   "\e$(CBJ\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Whs"   "\e$(CBK\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Whf"   "\e$(CBL\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Wha"   "\e$(CBM\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Whq"   "\e$(CBN\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Wht"   "\e$(CBO\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Whd"   "\e$(CBP\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Whc"   "\e$(CBQ\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "Whk"   "\e$(CBR\e(B"
+    (its-define-hangul "Whkr"  "\e$(CBS\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Whkf"  "\e$(CBT\e(B"     kijuhynbmlopP)
+    (its-define-hangul "WhkT"  "\e$(CBU\e(B"     kjhynmlop))
+
+  (its-defrule-hangul-2        "Who"   "\e$(CBV\e(B"
+    (its-define-hangul "WhoT"  "\e$(CBW\e(B"     kjhynmlop))
+
+  (its-defrule-hangul-2        "Whl"   "\e$(CBX\e(B"
+    (its-define-hangul "Whls"  "\e$(CBY\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Whlf"  "\e$(CBZ\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Whla"  "\e$(CB[\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Whlq"  "\e$(CB\\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul  "Wy"    "\e$(C$9\e(By")
+  (its-defrule-hangul  "Wyd"   "\e$(CB]\e(B")
+
+  (its-defrule-hangul-2        "Wn"    "\e$(CB^\e(B"
+    (its-define-hangul "Wnr"   "\e$(CB_\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Wns"   "\e$(CB`\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Wnf"   "\e$(CBa\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Wna"   "\e$(CBb\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Wnq"   "\e$(CBc\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Wnd"   "\e$(CBd\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "Wnj"   "\e$(CBe\e(B"
+    (its-define-hangul "WnjT"  "\e$(CBf\e(B"     kjhynmlop)
+    (its-define-hangul "Wnjd"  "\e$(CBg\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul  "Wnl"   "\e$(CBh\e(B")
+
+  (its-defrule-hangul  "Wb"    "\e$(CBi\e(B")
+
+  (its-defrule-hangul-2        "Wm"    "\e$(CBj\e(B"
+    (its-define-hangul "Wma"   "\e$(CBk\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Wmt"   "\e$(CBl\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Wmd"   "\e$(CBm\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "Wl"    "\e$(CBn\e(B"
+    (its-define-hangul "Wlr"   "\e$(CBo\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Wls"   "\e$(CBp\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Wlf"   "\e$(CBq\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Wla"   "\e$(CBr\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Wlq"   "\e$(CBs\e(B"     kijuhynbmlopP)
+    (its-define-hangul "Wld"   "\e$(CBt\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Wlw"   "\e$(CBu\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "Wlg"   "\e$(CBv\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "ck"    "\e$(CBw\e(B"
+    (its-define-hangul "ckr"   "\e$(CBx\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "cks"   "\e$(CBy\e(B"     kijuhynbmlopP
+     (its-define-hangul        "cksg"  "\e$(CBz\e(B"     kijuhynbmlopP))
+    (its-define-hangul "ckf"   "\e$(CB{\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cka"   "\e$(CB|\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ckq"   "\e$(CB}\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ckt"   "\e$(CB~\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ckT"   "\e$(CC!\e(B"     kjhynmlop)
+    (its-define-hangul "ckd"   "\e$(CC"\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ckw"   "\e$(CC#\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "co"    "\e$(CC$\e(B"
+    (its-define-hangul "cor"   "\e$(CC%\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "cos"   "\e$(CC&\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cof"   "\e$(CC'\e(B"     kijuhynbmlopP)
+    (its-define-hangul "coa"   "\e$(CC(\e(B"     kijuhynbmlopP)
+    (its-define-hangul "coq"   "\e$(CC)\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cot"   "\e$(CC*\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "coT"   "\e$(CC+\e(B"     kjhynmlop)
+    (its-define-hangul "cod"   "\e$(CC,\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "ci"    "\e$(CC-\e(B"
+    (its-define-hangul "cis"   "\e$(CC.\e(B"     kijuhynbmlopP
+     (its-define-hangul        "cisg"  "\e$(CC/\e(B"     kijuhynbmlopP))
+    (its-define-hangul "cif"   "\e$(CC0\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cia"   "\e$(CC1\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cid"   "\e$(CC2\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "cj"    "\e$(CC3\e(B"
+    (its-define-hangul "cjr"   "\e$(CC4\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "cjs"   "\e$(CC5\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cjf"   "\e$(CC6\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cja"   "\e$(CC7\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cjq"   "\e$(CC8\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cjt"   "\e$(CC9\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "cjT"   "\e$(CC:\e(B"     kjhynmlop)
+    (its-define-hangul "cjd"   "\e$(CC;\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "cp"    "\e$(CC<\e(B"
+    (its-define-hangul "cpr"   "\e$(CC=\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "cps"   "\e$(CC>\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cpf"   "\e$(CC?\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cpa"   "\e$(CC@\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cpq"   "\e$(CCA\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cpt"   "\e$(CCB\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "cpd"   "\e$(CCC\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "cu"    "\e$(CCD\e(B"
+    (its-define-hangul "cus"   "\e$(CCE\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cuT"   "\e$(CCF\e(B"     kjhynmlop))
+
+  (its-defrule-hangul-2        "cP"    "\e$(CCG\e(B"
+    (its-define-hangul "cPs"   "\e$(CCH\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cPd"   "\e$(CCI\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "ch"    "\e$(CCJ\e(B"
+    (its-define-hangul "chr"   "\e$(CCK\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "chs"   "\e$(CCL\e(B"     kijuhynbmlopP)
+    (its-define-hangul "chf"   "\e$(CCM\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cha"   "\e$(CCN\e(B"     kijuhynbmlopP)
+    (its-define-hangul "chq"   "\e$(CCO\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cht"   "\e$(CCP\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "chd"   "\e$(CCQ\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "chk"   "\e$(CCR\e(B"
+    (its-define-hangul "chks"  "\e$(CCS\e(B"     kijuhynbmlopP)
+    (its-define-hangul "chkf"  "\e$(CCT\e(B"     kijuhynbmlopP)
+    (its-define-hangul "chkd"  "\e$(CCU\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "chl"   "\e$(CCV\e(B"
+    (its-define-hangul "chls"  "\e$(CCW\e(B"     kijuhynbmlopP)
+    (its-define-hangul "chlf"  "\e$(CCX\e(B"     kijuhynbmlopP)
+    (its-define-hangul "chla"  "\e$(CCY\e(B"     kijuhynbmlopP)
+    (its-define-hangul "chlq"  "\e$(CCZ\e(B"     kijuhynbmlopP)
+    (its-define-hangul "chlt"  "\e$(CC[\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "chld"  "\e$(CC\\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "cy"    "\e$(CC]\e(B"
+    (its-define-hangul "cya"   "\e$(CC^\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "cn"    "\e$(CC_\e(B"
+    (its-define-hangul "cnr"   "\e$(CC`\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "cns"   "\e$(CCa\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cnf"   "\e$(CCb\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cna"   "\e$(CCc\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cnq"   "\e$(CCd\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cnt"   "\e$(CCe\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "cnd"   "\e$(CCf\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "cnj"   "\e$(CCg\e(B"
+    (its-define-hangul "cnjT"  "\e$(CCh\e(B"     kjhynmlop))
+
+  (its-defrule-hangul-2        "cnp"   "\e$(CCi\e(B"
+    (its-define-hangul "cnps"  "\e$(CCj\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "cnl"   "\e$(CCk\e(B"
+    (its-define-hangul "cnls"  "\e$(CCl\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cnlf"  "\e$(CCm\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cnla"  "\e$(CCn\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cnlq"  "\e$(CCo\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cnlt"  "\e$(CCp\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "cnld"  "\e$(CCq\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "cb"    "\e$(CCr\e(B"
+    (its-define-hangul "cbs"   "\e$(CCs\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cbf"   "\e$(CCt\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cba"   "\e$(CCu\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cbd"   "\e$(CCv\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "cm"    "\e$(CCw\e(B"
+    (its-define-hangul "cmr"   "\e$(CCx\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "cms"   "\e$(CCy\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cmf"   "\e$(CCz\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cma"   "\e$(CC{\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cmq"   "\e$(CC|\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cmt"   "\e$(CC}\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "cmd"   "\e$(CC~\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "cl"    "\e$(CD!\e(B"
+    (its-define-hangul "clr"   "\e$(CD"\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "cls"   "\e$(CD#\e(B"     kijuhynbmlopP)
+    (its-define-hangul "cle"   "\e$(CD$\e(B"     kijuhynbmlopP)
+    (its-define-hangul "clf"   "\e$(CD%\e(B"     kijuhynbmlopP
+     (its-define-hangul        "clfr"  "\e$(CD&\e(B"     kijuhynbmlopOP))
+    (its-define-hangul "cla"   "\e$(CD'\e(B"     kijuhynbmlopP)
+    (its-define-hangul "clq"   "\e$(CD(\e(B"     kijuhynbmlopP)
+    (its-define-hangul "clt"   "\e$(CD)\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "cld"   "\e$(CD*\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "zk"    "\e$(CD+\e(B"
+    (its-define-hangul "zkr"   "\e$(CD,\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "zks"   "\e$(CD-\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zkf"   "\e$(CD.\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zka"   "\e$(CD/\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zkq"   "\e$(CD0\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zkt"   "\e$(CD1\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "zkd"   "\e$(CD2\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "zo"    "\e$(CD3\e(B"
+    (its-define-hangul "zor"   "\e$(CD4\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "zos"   "\e$(CD5\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zof"   "\e$(CD6\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zoa"   "\e$(CD7\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zoq"   "\e$(CD8\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zot"   "\e$(CD9\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "zoT"   "\e$(CD:\e(B"     kjhynmlop)
+    (its-define-hangul "zod"   "\e$(CD;\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "zi"    "\e$(CD<\e(B"
+    (its-define-hangul "zir"   "\e$(CD=\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "zid"   "\e$(CD>\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "zj"    "\e$(CD?\e(B"
+    (its-define-hangul "zjr"   "\e$(CD@\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "zjs"   "\e$(CDA\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zje"   "\e$(CDB\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zjf"   "\e$(CDC\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zja"   "\e$(CDD\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zjq"   "\e$(CDE\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zjt"   "\e$(CDF\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "zjT"   "\e$(CDG\e(B"     kjhynmlop)
+    (its-define-hangul "zjd"   "\e$(CDH\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "zp"    "\e$(CDI\e(B"
+    (its-define-hangul "zpr"   "\e$(CDJ\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "zps"   "\e$(CDK\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zpf"   "\e$(CDL\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zpa"   "\e$(CDM\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zpq"   "\e$(CDN\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zpt"   "\e$(CDO\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "zpd"   "\e$(CDP\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "zu"    "\e$(CDQ\e(B"
+    (its-define-hangul "zus"   "\e$(CDR\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zuf"   "\e$(CDS\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zua"   "\e$(CDT\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zuq"   "\e$(CDU\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zut"   "\e$(CDV\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "zuT"   "\e$(CDW\e(B"     kjhynmlop)
+    (its-define-hangul "zud"   "\e$(CDX\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul  "zP"    "\e$(CDY\e(B")
+
+  (its-defrule-hangul-2        "zh"    "\e$(CDZ\e(B"
+    (its-define-hangul "zhr"   "\e$(CD[\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "zhs"   "\e$(CD\\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zhf"   "\e$(CD]\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zha"   "\e$(CD^\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zhq"   "\e$(CD_\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zht"   "\e$(CD`\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "zhd"   "\e$(CDa\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "zhk"   "\e$(CDb\e(B"
+    (its-define-hangul "zhkr"  "\e$(CDc\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "zhks"  "\e$(CDd\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zhkf"  "\e$(CDe\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zhka"  "\e$(CDf\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zhkd"  "\e$(CDg\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "zho"   "\e$(CDh\e(B"
+    (its-define-hangul "zhod"  "\e$(CDi\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "zhl"   "\e$(CDj\e(B"
+    (its-define-hangul "zhlf"  "\e$(CDk\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul  "zy"    "\e$(CDl\e(B")
+
+  (its-defrule-hangul-2        "zn"    "\e$(CDm\e(B"
+    (its-define-hangul "znr"   "\e$(CDn\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "znf"   "\e$(CDp\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zna"   "\e$(CDq\e(B"     kijuhynbmlopP)
+    (its-define-hangul "znq"   "\e$(CDr\e(B"     kijuhynbmlopP)
+    (its-define-hangul "znt"   "\e$(CDs\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "znd"   "\e$(CDt\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "znj"   "\e$(CDu\e(B"
+    (its-define-hangul "znjs"  "\e$(CDv\e(B"     kijuhynbmlopP)
+    (its-define-hangul "znjf"  "\e$(CDw\e(B"     kijuhynbmlopP)
+    (its-define-hangul "znjd"  "\e$(CDx\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "znp"   "\e$(CDy\e(B"
+    (its-define-hangul "znpd"  "\e$(CDz\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "znl"   "\e$(CD{\e(B"
+    (its-define-hangul "znlr"  "\e$(CD|\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "znls"  "\e$(CD}\e(B"     kijuhynbmlopP)
+    (its-define-hangul "znlf"  "\e$(CD~\e(B"     kijuhynbmlopP)
+    (its-define-hangul "znla"  "\e$(CE!\e(B"     kijuhynbmlopP)
+    (its-define-hangul "znlq"  "\e$(CE"\e(B"     kijuhynbmlopP)
+    (its-define-hangul "znlt"  "\e$(CE#\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "znld"  "\e$(CE$\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "zb"    "\e$(CE%\e(B"
+    (its-define-hangul "zbs"   "\e$(CE&\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zbf"   "\e$(CE'\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zba"   "\e$(CE(\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "zm"    "\e$(CE)\e(B"
+    (its-define-hangul "zmr"   "\e$(CE*\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "zms"   "\e$(CE+\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zmf"   "\e$(CE,\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zma"   "\e$(CE-\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zmq"   "\e$(CE.\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zmd"   "\e$(CE/\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "zl"    "\e$(CE0\e(B"
+    (its-define-hangul "zlr"   "\e$(CE1\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "zls"   "\e$(CE2\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zlf"   "\e$(CE3\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zla"   "\e$(CE4\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zlq"   "\e$(CE5\e(B"     kijuhynbmlopP)
+    (its-define-hangul "zlt"   "\e$(CE6\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "zld"   "\e$(CE7\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "xk"    "\e$(CE8\e(B"
+    (its-define-hangul "xkr"   "\e$(CE9\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "xks"   "\e$(CE:\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xkf"   "\e$(CE;\e(B"     kijuhynbmlopP
+     (its-define-hangul        "xkfr"  "\e$(CE<\e(B"     kijuhynbmlopOP))
+    (its-define-hangul "xka"   "\e$(CE=\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xkq"   "\e$(CE>\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xkt"   "\e$(CE?\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "xkT"   "\e$(CE@\e(B"     kjhynmlop)
+    (its-define-hangul "xkd"   "\e$(CEA\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "xo"    "\e$(CEB\e(B"
+    (its-define-hangul "xor"   "\e$(CEC\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "xos"   "\e$(CED\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xof"   "\e$(CEE\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xoa"   "\e$(CEF\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xoq"   "\e$(CEG\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xot"   "\e$(CEH\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "xoT"   "\e$(CEI\e(B"     kjhynmlop)
+    (its-define-hangul "xod"   "\e$(CEJ\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "xi"    "\e$(CEK\e(B"
+    (its-define-hangul "xid"   "\e$(CEL\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "xj"    "\e$(CEM\e(B"
+    (its-define-hangul "xjr"   "\e$(CEN\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "xjs"   "\e$(CEO\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xjf"   "\e$(CEP\e(B"     kijuhynbmlopP
+     (its-define-hangul        "xjfa"  "\e$(CEQ\e(B"     kijuhynbmlopP))
+    (its-define-hangul "xja"   "\e$(CER\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xjq"   "\e$(CES\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xjt"   "\e$(CET\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "xjT"   "\e$(CEU\e(B"     kjhynmlop)
+    (its-define-hangul "xjd"   "\e$(CEV\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "xp"    "\e$(CEW\e(B"
+    (its-define-hangul "xpr"   "\e$(CEX\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "xps"   "\e$(CEY\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xpf"   "\e$(CEZ\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xpa"   "\e$(CE[\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xpq"   "\e$(CE\\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xpt"   "\e$(CE]\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "xpd"   "\e$(CE^\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "xu"    "\e$(CE_\e(B"
+    (its-define-hangul "xus"   "\e$(CE`\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xuT"   "\e$(CEa\e(B"     kjhynmlop))
+
+  (its-defrule-hangul-2        "xP"    "\e$(CEb\e(B"
+    (its-define-hangul "xPs"   "\e$(CEc\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "xh"    "\e$(CEd\e(B"
+    (its-define-hangul "xhr"   "\e$(CEe\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "xhs"   "\e$(CEf\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xhf"   "\e$(CEg\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xha"   "\e$(CEh\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xhq"   "\e$(CEi\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xht"   "\e$(CEj\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "xhd"   "\e$(CEk\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "xhv"   "\e$(CEl\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "xhk"   "\e$(CEm\e(B"
+    (its-define-hangul "xhks"  "\e$(CEn\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul  "xho"   "\e$(CEo\e(B")
+
+  (its-defrule-hangul-2        "xhl"   "\e$(CEp\e(B"
+    (its-define-hangul "xhls"  "\e$(CEq\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xhlt"  "\e$(CEr\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "xhld"  "\e$(CEs\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul  "xy"    "\e$(CEt\e(B")
+
+  (its-defrule-hangul-2        "xn"    "\e$(CEu\e(B"
+    (its-define-hangul "xnr"   "\e$(CEv\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "xns"   "\e$(CEw\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xnf"   "\e$(CEx\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xna"   "\e$(CEy\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xnq"   "\e$(CEz\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xnt"   "\e$(CE{\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "xnd"   "\e$(CE|\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "xnj"   "\e$(CE}\e(B"
+    (its-define-hangul "xnjT"  "\e$(CE~\e(B"     kjhynmlop))
+
+  (its-defrule-hangul  "xnp"   "\e$(CF!\e(B")
+
+  (its-defrule-hangul-2        "xnl"   "\e$(CF"\e(B"
+    (its-define-hangul "xnlr"  "\e$(CF#\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "xnls"  "\e$(CF$\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xnlf"  "\e$(CF%\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xnla"  "\e$(CF&\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xnlq"  "\e$(CF'\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xnld"  "\e$(CF(\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "xb"    "\e$(CF)\e(B"
+    (its-define-hangul "xbs"   "\e$(CF*\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xbf"   "\e$(CF+\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xba"   "\e$(CF,\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xbd"   "\e$(CF-\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "xm"    "\e$(CF.\e(B"
+    (its-define-hangul "xmr"   "\e$(CF/\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "xms"   "\e$(CF0\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xme"   "\e$(CF1\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xmf"   "\e$(CF2\e(B"     kijuhynbmlopP
+     (its-define-hangul        "xmfa"  "\e$(CF3\e(B"     kijuhynbmlopP))
+    (its-define-hangul "xma"   "\e$(CF4\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xmq"   "\e$(CF5\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xmt"   "\e$(CF6\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "xml"   "\e$(CF7\e(B"
+    (its-define-hangul "xmls"  "\e$(CF8\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xmlf"  "\e$(CF9\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xmla"  "\e$(CF:\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xmlq"  "\e$(CF;\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "xl"    "\e$(CF<\e(B"
+    (its-define-hangul "xlr"   "\e$(CF=\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "xls"   "\e$(CF>\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xlf"   "\e$(CF?\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xla"   "\e$(CF@\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xlq"   "\e$(CFA\e(B"     kijuhynbmlopP)
+    (its-define-hangul "xlt"   "\e$(CFB\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "xld"   "\e$(CFC\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "vk"    "\e$(CFD\e(B"
+    (its-define-hangul "vkr"   "\e$(CFE\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "vkR"   "\e$(CFF\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vks"   "\e$(CFG\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vkf"   "\e$(CFH\e(B"     kijuhynbmlopP
+     (its-define-hangul        "vkfa"  "\e$(CFI\e(B"     kijuhynbmlopP))
+    (its-define-hangul "vka"   "\e$(CFJ\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vkq"   "\e$(CFK\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vkt"   "\e$(CFL\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "vkT"   "\e$(CFM\e(B"     kjhynmlop)
+    (its-define-hangul "vkd"   "\e$(CFN\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "vkx"   "\e$(CFO\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "vo"    "\e$(CFP\e(B"
+    (its-define-hangul "vor"   "\e$(CFQ\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "vos"   "\e$(CFR\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vof"   "\e$(CFS\e(B"     kijuhynbmlopP)
+    (its-define-hangul "voa"   "\e$(CFT\e(B"     kijuhynbmlopP)
+    (its-define-hangul "voq"   "\e$(CFU\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vot"   "\e$(CFV\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "voT"   "\e$(CFW\e(B"     kjhynmlop)
+    (its-define-hangul "vod"   "\e$(CFX\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "vi"    "\e$(CFY\e(B"
+    (its-define-hangul "vir"   "\e$(CFZ\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "vj"    "\e$(CF[\e(B"
+    (its-define-hangul "vjr"   "\e$(CF\\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "vjs"   "\e$(CF]\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vja"   "\e$(CF_\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vjq"   "\e$(CF`\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vjt"   "\e$(CFa\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "vjT"   "\e$(CFb\e(B"     kjhynmlop)
+    (its-define-hangul "vjd"   "\e$(CFc\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "vp"    "\e$(CFd\e(B"
+    (its-define-hangul "vpr"   "\e$(CFe\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "vps"   "\e$(CFf\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vpf"   "\e$(CFg\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vpa"   "\e$(CFh\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vpq"   "\e$(CFi\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vpt"   "\e$(CFj\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "vpd"   "\e$(CFk\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "vu"    "\e$(CFl\e(B"
+    (its-define-hangul "vus"   "\e$(CFm\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vuf"   "\e$(CFn\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vua"   "\e$(CFo\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vuq"   "\e$(CFp\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vuT"   "\e$(CFq\e(B"     kjhynmlop)
+    (its-define-hangul "vud"   "\e$(CFr\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "vP"    "\e$(CFs\e(B"
+    (its-define-hangul "vPf"   "\e$(CFt\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vPq"   "\e$(CFu\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vPt"   "\e$(CFv\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "vh"    "\e$(CFw\e(B"
+    (its-define-hangul "vhr"   "\e$(CFx\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "vhs"   "\e$(CFy\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vhf"   "\e$(CFz\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vha"   "\e$(CF{\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vhq"   "\e$(CF|\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vht"   "\e$(CF}\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "vhd"   "\e$(CF~\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "vhk"   "\e$(CG!\e(B"
+    (its-define-hangul "vhkd"  "\e$(CG"\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "vhl"   "\e$(CG#\e(B"
+    (its-define-hangul "vhls"  "\e$(CG$\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "vy"    "\e$(CG%\e(B"
+    (its-define-hangul "vys"   "\e$(CG&\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vyf"   "\e$(CG'\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vyq"   "\e$(CG(\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vyt"   "\e$(CG)\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "vn"    "\e$(CG*\e(B"
+    (its-define-hangul "vnr"   "\e$(CG+\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "vns"   "\e$(CG,\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vne"   "\e$(CG-\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vnf"   "\e$(CG.\e(B"     kijuhynbmlopP
+     (its-define-hangul        "vnfa"  "\e$(CG/\e(B"     kijuhynbmlopP))
+    (its-define-hangul "vna"   "\e$(CG0\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vnq"   "\e$(CG1\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vnt"   "\e$(CG2\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "vnd"   "\e$(CG3\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "vnj"   "\e$(CG4\e(B"
+    (its-define-hangul "vnjd"  "\e$(CG5\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "vnl"   "\e$(CG6\e(B"
+    (its-define-hangul "vnls"  "\e$(CG7\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vnlf"  "\e$(CG8\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vnla"  "\e$(CG9\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vnlt"  "\e$(CG:\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "vb"    "\e$(CG;\e(B"
+    (its-define-hangul "vbs"   "\e$(CG<\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vbf"   "\e$(CG=\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vba"   "\e$(CG>\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vbt"   "\e$(CG?\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "vbd"   "\e$(CG@\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "vm"    "\e$(CGA\e(B"
+    (its-define-hangul "vms"   "\e$(CGB\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vmf"   "\e$(CGC\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vma"   "\e$(CGD\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vmq"   "\e$(CGE\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vmt"   "\e$(CGF\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "vl"    "\e$(CGG\e(B"
+    (its-define-hangul "vlr"   "\e$(CGH\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "vls"   "\e$(CGI\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vlf"   "\e$(CGJ\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vla"   "\e$(CGK\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vlq"   "\e$(CGL\e(B"     kijuhynbmlopP)
+    (its-define-hangul "vlt"   "\e$(CGM\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "vld"   "\e$(CGN\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "gk"    "\e$(CGO\e(B"
+    (its-define-hangul "gkr"   "\e$(CGP\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "gks"   "\e$(CGQ\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gkf"   "\e$(CGR\e(B"     kijuhynbmlopP
+     (its-define-hangul        "gkfx"  "\e$(CGS\e(B"     kijuhynbmlopP))
+    (its-define-hangul "gka"   "\e$(CGT\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gkq"   "\e$(CGU\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gkt"   "\e$(CGV\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "gkd"   "\e$(CGW\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "go"    "\e$(CGX\e(B"
+    (its-define-hangul "gor"   "\e$(CGY\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "gos"   "\e$(CGZ\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gof"   "\e$(CG[\e(B"     kijuhynbmlopP)
+    (its-define-hangul "goa"   "\e$(CG\\e(B"     kijuhynbmlopP)
+    (its-define-hangul "goq"   "\e$(CG]\e(B"     kijuhynbmlopP)
+    (its-define-hangul "got"   "\e$(CG^\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "goT"   "\e$(CG_\e(B"     kjhynmlop)
+    (its-define-hangul "god"   "\e$(CG`\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "gi"    "\e$(CGa\e(B"
+    (its-define-hangul "gid"   "\e$(CGb\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "gj"    "\e$(CGc\e(B"
+    (its-define-hangul "gjr"   "\e$(CGd\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "gjs"   "\e$(CGe\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gjf"   "\e$(CGf\e(B"     kijuhynbmlopP
+     (its-define-hangul        "gjfa"  "\e$(CGg\e(B"     kijuhynbmlopP))
+    (its-define-hangul "gja"   "\e$(CGh\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gjq"   "\e$(CGi\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gjt"   "\e$(CGj\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "gjd"   "\e$(CGk\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "gp"    "\e$(CGl\e(B"
+    (its-define-hangul "gpr"   "\e$(CGm\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "gps"   "\e$(CGn\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gpf"   "\e$(CGo\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gpa"   "\e$(CGp\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gpq"   "\e$(CGq\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gpt"   "\e$(CGr\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "gpd"   "\e$(CGs\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "gu"    "\e$(CGt\e(B"
+    (its-define-hangul "gur"   "\e$(CGu\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "gus"   "\e$(CGv\e(B"     kijuhynbmlopP)
+    (its-define-hangul "guf"   "\e$(CGw\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gua"   "\e$(CGx\e(B"     kijuhynbmlopP)
+    (its-define-hangul "guq"   "\e$(CGy\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gut"   "\e$(CGz\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "guT"   "\e$(CG{\e(B"     kjhynmlop)
+    (its-define-hangul "gud"   "\e$(CG|\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "gP"    "\e$(CG}\e(B"
+    (its-define-hangul "gPs"   "\e$(CG~\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gPf"   "\e$(CH!\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gPq"   "\e$(CH"\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "gh"    "\e$(CH#\e(B"
+    (its-define-hangul "ghr"   "\e$(CH$\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ghs"   "\e$(CH%\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ghf"   "\e$(CH&\e(B"     kijuhynbmlopP
+     (its-define-hangul        "ghfx"  "\e$(CH'\e(B"     kijuhynbmlopP))
+    (its-define-hangul "gha"   "\e$(CH(\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ghq"   "\e$(CH)\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ght"   "\e$(CH*\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ghd"   "\e$(CH+\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ghx"   "\e$(CH,\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "ghk"   "\e$(CH-\e(B"
+    (its-define-hangul "ghkr"  "\e$(CH.\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ghks"  "\e$(CH/\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ghkf"  "\e$(CH0\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ghkt"  "\e$(CH1\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ghkd"  "\e$(CH2\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "gho"   "\e$(CH3\e(B"
+    (its-define-hangul "ghor"  "\e$(CH4\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ghos"  "\e$(CH5\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ghot"  "\e$(CH6\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ghod"  "\e$(CH7\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "ghl"   "\e$(CH8\e(B"
+    (its-define-hangul "ghlr"  "\e$(CH9\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ghls"  "\e$(CH:\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ghlf"  "\e$(CH;\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ghlq"  "\e$(CH<\e(B"     kijuhynbmlopP)
+    (its-define-hangul "ghlt"  "\e$(CH=\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "ghld"  "\e$(CH>\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "gy"    "\e$(CH?\e(B"
+    (its-define-hangul "gys"   "\e$(CH@\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gyf"   "\e$(CHA\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gyq"   "\e$(CHB\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gyt"   "\e$(CHC\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "gn"    "\e$(CHD\e(B"
+    (its-define-hangul "gnr"   "\e$(CHE\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "gns"   "\e$(CHF\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gnf"   "\e$(CHG\e(B"     kijuhynbmlopP
+     (its-define-hangul        "gnfx"  "\e$(CHH\e(B"     kijuhynbmlopP))
+    (its-define-hangul "gna"   "\e$(CHI\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gnt"   "\e$(CHJ\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "gnd"   "\e$(CHK\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "gnj"   "\e$(CHL\e(B"
+    (its-define-hangul "gnjs"  "\e$(CHM\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gnjf"  "\e$(CHN\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gnja"  "\e$(CHO\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gnjd"  "\e$(CHP\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "gnp"   "\e$(CHQ\e(B"
+    (its-define-hangul "gnpr"  "\e$(CHR\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "gnps"  "\e$(CHS\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gnpf"  "\e$(CHT\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gnpd"  "\e$(CHU\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "gnl"   "\e$(CHV\e(B"
+    (its-define-hangul "gnlr"  "\e$(CHW\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "gnls"  "\e$(CHX\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gnlf"  "\e$(CHY\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gnla"  "\e$(CHZ\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gnlq"  "\e$(CH[\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gnlt"  "\e$(CH\\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "gnld"  "\e$(CH]\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "gb"    "\e$(CH^\e(B"
+    (its-define-hangul "gbr"   "\e$(CH_\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "gbs"   "\e$(CH`\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gbf"   "\e$(CHa\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gba"   "\e$(CHb\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gbt"   "\e$(CHc\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "gbd"   "\e$(CHd\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "gm"    "\e$(CHe\e(B"
+    (its-define-hangul "gmr"   "\e$(CHf\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "gms"   "\e$(CHg\e(B"     kijuhynbmlopP
+     (its-define-hangul        "gmsg"  "\e$(CHh\e(B"     kijuhynbmlopP))
+    (its-define-hangul "gme"   "\e$(CHi\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gmf"   "\e$(CHj\e(B"     kijuhynbmlopP
+     (its-define-hangul        "gmfr"  "\e$(CHk\e(B"     kijuhynbmlopOP))
+    (its-define-hangul "gma"   "\e$(CHl\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gmq"   "\e$(CHm\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gmt"   "\e$(CHn\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "gmd"   "\e$(CHo\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "gmx"   "\e$(CHp\e(B"     kijuhynbmlopP))
+
+  (its-defrule-hangul-2        "gml"   "\e$(CHq\e(B"
+    (its-define-hangul "gmls"  "\e$(CHr\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gmlf"  "\e$(CHs\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gmla"  "\e$(CHt\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gmlq"  "\e$(CHu\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gmld"  "\e$(CHv\e(B"     kijuhynbmlopOP))
+
+  (its-defrule-hangul-2        "gl"    "\e$(CHw\e(B"
+    (its-define-hangul "glr"   "\e$(CHx\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "gls"   "\e$(CHy\e(B"     kijuhynbmlopP)
+    (its-define-hangul "glf"   "\e$(CHz\e(B"     kijuhynbmlopP)
+    (its-define-hangul "gla"   "\e$(CH{\e(B"     kijuhynbmlopP)
+    (its-define-hangul "glq"   "\e$(CH|\e(B"     kijuhynbmlopP)
+    (its-define-hangul "glt"   "\e$(CH}\e(B"     kijuhynbmlopOP)
+    (its-define-hangul "gld"   "\e$(CH~\e(B"     kijuhynbmlopOP))
+
+  ;;; Jeonkak Symbols
+
+  (its-defrule   "1"   "\e$(C#1\e(B")
+  (its-defrule   "2"   "\e$(C#2\e(B")
+  (its-defrule   "3"   "\e$(C#3\e(B")
+  (its-defrule   "4"   "\e$(C#4\e(B")
+  (its-defrule   "5"   "\e$(C#5\e(B")
+  (its-defrule   "6"   "\e$(C#6\e(B")
+  (its-defrule   "7"   "\e$(C#7\e(B")
+  (its-defrule   "8"   "\e$(C#8\e(B")
+  (its-defrule   "9"   "\e$(C#9\e(B")
+  (its-defrule   "0"   "\e$(C#0\e(B")
+
+  ;;(its-defrule   " "   "\e$(C!!\e(B")
+  (its-defrule   "!"   "\e$(C#!\e(B")
+  (its-defrule   "@"   "\e$(C#@\e(B")
+  (its-defrule   "#"   "\e$(C##\e(B")
+  (its-defrule   "$"   "\e$(C#$\e(B")
+  (its-defrule   "%"   "\e$(C#%\e(B")
+  (its-defrule   "^"   "\e$(C#^\e(B")
+  (its-defrule   "&"   "\e$(C#&\e(B")
+  (its-defrule   "*"   "\e$(C#*\e(B")
+  (its-defrule   "("   "\e$(C#(\e(B")
+  (its-defrule   ")"   "\e$(C#)\e(B")
+  (its-defrule   "-"   "\e$(C#-\e(B")
+  (its-defrule   "="   "\e$(C#=\e(B")
+  (its-defrule   "`"   "\e$(C#`\e(B")
+  (its-defrule   "\\"  "\e$(C#\\e(B")
+  (its-defrule   "|"   "\e$(C#|\e(B")
+  (its-defrule   "_"   "\e$(C#_\e(B")
+  (its-defrule   "+"   "\e$(C#+\e(B")
+  (its-defrule   "~"   "\e$(C#~\e(B")
+  (its-defrule   "["   "\e$(C!8\e(B");;(its-defrule   "["   "\e$(C#[\e(B")
+  (its-defrule   "]"   "\e$(C!9\e(B");;(its-defrule   "]"   "\e$(C#]\e(B")
+  (its-defrule   "{"   "\e$(C#{\e(B")
+  (its-defrule   "}"   "\e$(C#}\e(B")
+  (its-defrule   ":"   "\e$(C#:\e(B")
+  (its-defrule   ";"   "\e$(C#;\e(B")
+  (its-defrule   "\""  "\e$(C#"\e(B")
+  (its-defrule   "'"   "\e$(C#'\e(B")
+  (its-defrule   "<"   "\e$(C#<\e(B")
+  (its-defrule   ">"   "\e$(C#>\e(B")
+  (its-defrule   "?"   "\e$(C#?\e(B")
+  (its-defrule   "/"   "\e$(C#/\e(B")
+  (its-defrule   ","   "\e$(C#,\e(B")
+  (its-defrule   "."   "\e$(C#.\e(B")
+
+  (its-defrule (concat its-jeonkak-escape " ") "\e$(C!!\e(B")
+  (let ((i ?!))
+    (while (<= i ?~)
+      (its-defrule (concat its-jeonkak-escape (char-to-string i))
+                  (char-to-string (+ (- ?\e$(C#!\e(B ?!) i)))
+      (setq i (1+ i))))
+
+  ;;; pankak 
+  (let ((i ?!))
+    (while (<= i ?~)
+      (its-defrule (concat its-pankak-escape (char-to-string i))
+                  (char-to-string i))
+       (setq i (1+ i)))))
+
+(define-its-state-machine-append its-hangul-map
+  (its-defrule "[" its-hangul-open-bracket  nil t)
+  (its-defrule "]" its-hangul-close-bracket nil t)
+  )
+
+(provide 'its/hangul)

diff --git a/its/hira.el b/its/hira.el
index 617ee50..a08cec9 100644 (file)
--- a/its/hira.el
+++ b/its/hira.el
@@ -1,6 +1,6 @@
 ;;; its/hira.el --- Hiragana Input in Egg Input Method Architecture
 
-;; Copyright (C) 1997 Mule Project,
+;; Copyright (C) 1997, 1998 Mule Project,
 ;; Powered by Electrotechnical Laboratory, JAPAN.
 ;; Project Leader: Satoru Tomura <tomura@etl.go.jp>
 
@@ -45,8 +45,11 @@
 (defvar its-hira-horizontal  "\e$B!<\e(B" "*-")    ; "\e$B!]\e(B"
 
 (define-its-state-machine its-hira-map
-  "roma-kana" "\e$B$"\e(B"
+  "roma-kana" "\e$B$"\e(B" "Japanese" nil
   "Map for Romaji-Hiragana translation. (Japanese)"
+  (defconst its-zenkaku-escape "Z")  ;; Escape character to Zenkaku inputs
+  (defconst its-hankaku-escape "~")  ;; Escape character to Hankaku inputs
+
 ;;; k      k
 ;;; kk     \e$B$C\e(Bk
 ;;; kka    \e$B$C$+\e(B
@@ -482,4 +485,5 @@
       (its-defrule   "/"   "/")))
   )
 
+(provide 'its/hira)
 ;;; its/hira.el ends here.

diff --git a/its/pinyin.el b/its/pinyin.el
new file mode 100644 (file)
index 0000000..9d3505d
--- /dev/null
+++ b/its/pinyin.el
@@ -0,0 +1,347 @@
+(eval-when-compile
+  (require 'its)
+  (require 'cl))
+
+(defvar its-pinyin-cn-open-braket  "\e$A!8\e(B" "*[") ; "\e$A#[\e(B"
+(defvar its-pinyin-cn-close-braket "\e$A!9\e(B" "*]") ; "\e$A#]\e(B"
+
+(defvar its-pinyin-tw-open-braket  "\e$(G!V\e(B" "*[") ; "\e$(G!b\e(B "
+(defvar its-pinyin-tw-close-braket "\e$(G!W\e(B" "*]") ; "\e$(G!c\e(B"
+
+(eval-when-compile
+  (defvar its-quanjiao-escape "Z")
+  (defvar its-banjiao-escape  "X")
+
+  (defconst its-pinyin-term
+    (char-to-string (make-char 'chinese-sisheng ?@)))
+
+  (defsubst its-defoutput* (input display)
+    (its-set-output (its-goto-state input nil t) display))
+
+  (defun its-prev-terminal-state (input)
+    (let ((len (length input))
+         (state (its-get-start-state its-current-map))
+         (i 0) (ret nil) kst ks)
+      (while (and (< i len)
+                 (setq state (its-get-next-state state (aref input i))))
+       (if (or (null (its-kst-p (setq kst (its-get-kst/t state))))
+               (mapcan (lambda (eob) (if (eq (its-eob-back eob) -1) (list t)))
+                       (cdr kst))
+               (and (setq ks (assq -1 (car kst)))
+                    (null (its-get-kst/t (cdr ks)))))
+           (setq ret state))
+       (setq i (1+ i)))
+      ret))
+
+  (defun its-define-qingsheng (shengmu yunmu &optional s y)
+    (let ((input (concat shengmu yunmu))
+         (output (concat (if s s (capitalize shengmu))
+                         (if y y yunmu)
+                         its-pinyin-term))
+         state term kst i len c+b)
+      (setq state (its-goto-state input nil t))
+      (its-make-next-state state -1 input output)
+      (its-make-next-state state ?  (concat input " ") output)
+      (its-make-next-state state ?0 (concat input "0") output)
+      (its-define-otherwise
+       state (its-make-otherwise output its-otherwise-back-one))
+      (setq term (its-prev-terminal-state (substring input 0 -1)))
+      (if term
+         (progn
+           (setq len (length (its-get-keyseq term))
+                 i len
+                 output (car (rassoc '(nil . -1) (cdr (its-get-kst/t term)))))
+           (while (null
+                   (eq (setq term (its-get-next-state term (aref input i)))
+                       state))
+             (setq i (1+ i) kst (its-get-kst/t term))
+             (if (null (assq -1 (car kst)))
+                 (its-make-next-state term -1
+                                      (its-get-keyseq term) output (- len i)))
+             (setq c+b (its-make-class+back nil (1- (- len i))))
+             (if (null (rassoc c+b (cdr kst)))
+                 (its-define-otherwise term
+                                       (its-make-otherwise output c+b))))))
+      state))
+
+  (defmacro its-do-sisheng-table (list)
+    `(progn ,@(mapcar (lambda (syl)
+                       `(its-define-sisheng ,(car syl) ,(cdr syl)))
+                     list)))
+
+  (defmacro its-define-sisheng (shengmu yunmu)
+    `(let ((qing (nth 5 ,yunmu)) (y (car ,yunmu))
+          (ss (list ,@shengmu)) s cs state i)
+       (while ss
+        (setq s (car ss)
+              cs (capitalize s)
+              state (its-define-qingsheng s y cs qing))
+        (setq i 1)
+        (while (<= i 4)
+          (its-make-next-state state (+ ?0 i)
+                               (concat s y i)
+                               (concat cs (nth i ,yunmu) its-pinyin-term))
+          (setq i (1+ i)))
+        (setq ss (cdr ss)))))
+
+  (defmacro its-define-pinyin-table ()
+    '(let ((- "")  (B "b") (C "c") (D "d") (F "f") (G "g") (H "h")
+          (J "j") (K "k") (L "l") (M "m") (N "n") (P "p") (Q "q")
+          (R "r") (S "s") (T "t") (W "w") (X "x") (Y "y") (Z "z")
+          (CH "ch") (SH "sh") (ZH "zh")
+
+          (A    '("a"    "\e(0!\e(B"    "\e(0"\e(B"    "\e(0#\e(B"    "\e(0$\e(B"    "a"   ))
+          (AI   '("ai"   "\e(0!\e(Bi"   "\e(0"\e(Bi"   "\e(0#\e(Bi"   "\e(0$\e(Bi"   "ai"  ))
+          (AN   '("an"   "\e(0!\e(Bn"   "\e(0"\e(Bn"   "\e(0#\e(Bn"   "\e(0$\e(Bn"   "an"  ))
+          (ANG  '("ang"  "\e(0!\e(Bng"  "\e(0"\e(Bng"  "\e(0#\e(Bng"  "\e(0$\e(Bng"  "ang" ))
+          (AO   '("ao"   "\e(0!\e(Bo"   "\e(0"\e(Bo"   "\e(0#\e(Bo"   "\e(0$\e(Bo"   "ao"  ))
+          (E    '("e"    "\e(0%\e(B"    "\e(0&\e(B"    "\e(0'\e(B"    "\e(0(\e(B"    "e"   ))
+          (EI   '("ei"   "\e(0%\e(Bi"   "\e(0&\e(Bi"   "\e(0'\e(Bi"   "\e(0(\e(Bi"   "ei"  ))
+          (EN   '("en"   "\e(0%\e(Bn"   "\e(0&\e(Bn"   "\e(0'\e(Bn"   "\e(0(\e(Bn"   "en"  ))
+          (ENG  '("eng"  "\e(0%\e(Bng"  "\e(0&\e(Bng"  "\e(0'\e(Bng"  "\e(0(\e(Bng"  "eng" ))
+          (ER   '("er"   "\e(0%\e(Br"   "\e(0&\e(Br"   "\e(0'\e(Br"   "\e(0(\e(Br"   "er"  ))
+          (I    '("i"    "\e(0)\e(B"    "\e(0*\e(B"    "\e(0+\e(B"    "\e(0,\e(B"    "i"   ))
+          (IA   '("ia"   "i\e(0!\e(B"   "i\e(0"\e(B"   "i\e(0#\e(B"   "i\e(0$\e(B"   "ia"  ))
+          (IAN  '("ian"  "i\e(0!\e(Bn"  "i\e(0"\e(Bn"  "i\e(0#\e(Bn"  "i\e(0$\e(Bn"  "ian" ))
+          (IANG '("iang" "i\e(0!\e(Bng" "i\e(0"\e(Bng" "i\e(0#\e(Bng" "i\e(0$\e(Bng" "iang"))
+          (IAO  '("iao"  "i\e(0!\e(Bo"  "i\e(0"\e(Bo"  "i\e(0#\e(Bo"  "i\e(0$\e(Bo"  "iao" ))
+          (IE   '("ie"   "i\e(0%\e(B"   "i\e(0&\e(B"   "i\e(0'\e(B"   "i\e(0(\e(B"   "ie"  ))
+          (IN   '("in"   "\e(0)\e(Bn"   "\e(0*\e(Bn"   "\e(0+\e(Bn"   "\e(0,\e(Bn"   "in"  ))
+          (ING  '("ing"  "\e(0)\e(Bng"  "\e(0*\e(Bng"  "\e(0+\e(Bng"  "\e(0,\e(Bng"  "ing" ))
+          (IONG '("iong" "i\e(0-\e(Bng" "i\e(0.\e(Bng" "i\e(0/\e(Bng" "i\e(00\e(Bng" "iong"))
+          (IU   '("iu"   "i\e(01\e(B"   "i\e(02\e(B"   "i\e(03\e(B"   "i\e(04\e(B"   "iu"  ))
+          (O    '("o"    "\e(0-\e(B"    "\e(0.\e(B"    "\e(0/\e(B"    "\e(00\e(B"    "o"   ))
+          (ONG  '("ong"  "\e(0-\e(Bng"  "\e(0.\e(Bng"  "\e(0/\e(Bng"  "\e(00\e(Bng"  "ong" ))
+          (OU   '("ou"   "\e(0-\e(Bu"   "\e(0.\e(Bu"   "\e(0/\e(Bu"   "\e(00\e(Bu"   "ou"  ))
+          (U    '("u"    "\e(01\e(B"    "\e(02\e(B"    "\e(03\e(B"    "\e(04\e(B"    "u"   ))
+          (V    '("v"    "\e(05\e(B"    "\e(06\e(B"    "\e(07\e(B"    "\e(08\e(B"    "\e(09\e(B"   ))
+          (UA   '("ua"   "u\e(0!\e(B"   "u\e(0"\e(B"   "u\e(0#\e(B"   "u\e(0$\e(B"   "ua"  ))
+          (UAI  '("uai"  "u\e(0!\e(Bi"  "u\e(0"\e(Bi"  "u\e(0#\e(Bi"  "u\e(0$\e(Bi"  "uai" ))
+          (UAN  '("uan"  "u\e(0!\e(Bn"  "u\e(0"\e(Bn"  "u\e(0#\e(Bn"  "u\e(0$\e(Bn"  "uan" ))
+          (UANG '("uang" "u\e(0!\e(Bng" "u\e(0"\e(Bng" "u\e(0#\e(Bng" "u\e(0$\e(Bng" "uang"))
+          (UE   '("ue"   "u\e(0%\e(B"   "u\e(0&\e(B"   "u\e(0'\e(B"   "u\e(0(\e(B"   "ue"  ))
+          (VE   '("ve"   "\e(09%\e(B"   "\e(09&\e(B"   "\e(09'\e(B"   "\e(09(\e(B"   "\e(09\e(Be"  ))
+          (UI   '("ui"   "u\e(0)\e(B"   "u\e(0*\e(B"   "u\e(0+\e(B"   "u\e(0,\e(B"   "ui"  ))
+          (UN   '("un"   "\e(01\e(Bn"   "\e(02\e(Bn"   "\e(03\e(Bn"   "\e(04\e(Bn"   "un"  ))
+          (UO   '("uo"   "u\e(0-\e(B"   "u\e(0.\e(B"   "u\e(0/\e(B"   "u\e(00\e(B"   "uo"  )))
+
+       (its-do-sisheng-table
+       (((- B C D F G H   K L M N P     S T W   Y Z CH SH ZH ) . A)
+        ((- B C D   G H   K L M N P     S T W     Z CH SH ZH ) . AI)
+        ((- B C D F G H   K L M N P   R S T W   Y Z CH SH ZH ) . AN)
+        ((- B C D F G H   K L M N P   R S T W   Y Z CH SH ZH ) . ANG)
+        ((- B C D   G H   K L M N P   R S T     Y Z CH SH ZH ) . AO)
+        ((-   C D   G H   K L M N     R S T     Y Z CH SH ZH ) . E)
+        ((- B C D F G H   K L M N P       T W     Z    SH ZH ) . EI)
+        ((- B C D F G H   K   M N P   R S   W     Z CH SH ZH ) . EN)
+        ((- B C D F G H   K L M N P   R S T W     Z CH SH ZH ) . ENG)
+        ((-                                                  ) . ER)
+        ((  B C D       J   L M N P Q R S T   X Y Z CH SH ZH ) . I)
+        ((      D       J   L       Q         X              ) . IA)
+        ((  B   D       J   L M N P Q     T   X              ) . IAN)
+        ((              J   L   N   Q         X              ) . IANG)
+        ((  B   D       J   L M N P Q     T   X              ) . IAO)
+        ((  B   D       J   L M N P Q     T   X              ) . IE)
+        ((  B           J   L M N P Q         X Y            ) . IN)
+        ((  B   D       J   L M N P Q     T   X Y            ) . ING)
+        ((              J           Q         X              ) . IONG)
+        ((      D       J   L M N   Q         X              ) . IU)
+        ((- B     F         L M   P         W   Y            ) . O)
+        ((    C D   G H   K L   N     R S T     Y Z CH    ZH ) . ONG)
+        ((-   C D F G H   K L M N P   R S T     Y Z CH SH ZH ) . OU)
+        ((  B C D F G H J K L M N P Q R S T W X Y Z CH SH ZH ) . U)
+        ((                  L   N                            ) . V)
+        ((          G H   K           R             CH SH ZH ) . UA)
+        ((          G H   K                         CH SH ZH ) . UAI)
+        ((    C D   G H J K L   N   Q R S T   X Y Z CH SH ZH ) . UAN)
+        ((          G H   K                         CH SH ZH ) . UANG)
+        ((              J           Q         X Y            ) . UE)
+        ((                  L   N                            ) . VE)
+        ((    C D   G H   K           R S T       Z CH SH ZH ) . UI)
+        ((    C D   G H J K L       Q R S T   X Y Z CH SH ZH ) . UN)
+        ((    C D   G H   K L   N     R S T       Z CH SH ZH ) . UO)
+
+        ((J Q X) . (cons "a"   (cdr IA  )))
+        ((J Q X) . (cons "ai"  (cdr IA  )))
+        ((J Q X) . (cons "an"  (cdr IAN )))
+        ((J Q X) . (cons "ang" (cdr IANG)))
+        ((J Q X) . (cons "ao"  (cdr IAO )))
+        ((J Q X) . (cons "e"   (cdr IE  )))
+        ((J Q X) . (cons "ei"  (cdr IE  )))
+        ((J Q X) . (cons "en"  (cdr IN  )))
+        ((J Q X) . (cons "eng" (cdr ING )))
+        ((J Q X) . (cons "ou"  (cdr IU  )))))
+
+       (its-define-qingsheng   "hm"    "")
+       (its-define-qingsheng   "hng"   "")
+       (its-define-qingsheng   ""      "ng")
+
+       (its-define-qingsheng   ""      "m")
+       (its-define-qingsheng   ""      "n")
+       (its-defrule    "n2"    "\e(0=@\e(B")
+       (its-defrule    "n3"    "\e(0>@\e(B")
+       (its-defrule    "n4"    "\e(0?@\e(B"))))
+
+(define-its-state-machine its-pinyin-cn-map
+  "pinyin-cn" "\e$AF4\e(BG" "Chinese-GB"
+  "Map for Pinyin input. (Chinese-GB)"
+  (its-define-pinyin-table)
+  (its-defoutput*      "b "    "\e$A2;\e(B")
+  (its-defoutput*      "c "    "\e$A2E\e(B")
+  (its-defoutput*      "ch "   "\e$A3v\e(B")
+  (its-defoutput*      "d "    "\e$A5D\e(B")
+  (its-defoutput*      "f "    "\e$A74\e(B")
+  (its-defoutput*      "g "    "\e$A8v\e(B")
+  (its-defoutput*      "h "    "\e$A:M\e(B")
+  (its-defoutput*      "i "    "\e$AR;\e(B")
+  (its-defoutput*      "j "    "\e$A>M\e(B")
+  (its-defoutput*      "k "    "\e$A?I\e(B")
+  (its-defoutput*      "l "    "\e$AAK\e(B")
+  (its-defoutput*      "m "    "\e$AC?\e(B")
+  (its-defoutput*      "n "    "\e$ADj\e(B")
+  (its-defoutput*      "p "    "\e$AEz\e(B")
+  (its-defoutput*      "q "    "\e$AH%\e(B")
+  (its-defoutput*      "r "    "\e$AHU\e(B")
+  (its-defoutput*      "s "    "\e$AJG\e(B")
+  (its-defoutput*      "sh "   "\e$AIO\e(B")
+  (its-defoutput*      "t "    "\e$AK{\e(B")
+  (its-defoutput*      "w "    "\e$ANR\e(B")
+  (its-defoutput*      "x "    "\e$AOr\e(B")
+  (its-defoutput*      "y "    "\e$ASV\e(B")
+  (its-defoutput*      "z "    "\e$ATZ\e(B")
+  (its-defoutput*      "zh "   "\e$AWE\e(B")
+
+  (dolist (ascii '(("0" . "\e$A#0\e(B")  ("1" . "\e$A#1\e(B")  ("2" . "\e$A#2\e(B")  ("3" . "\e$A#3\e(B")
+                  ("4" . "\e$A#4\e(B")  ("5" . "\e$A#5\e(B")  ("6" . "\e$A#6\e(B")  ("7" . "\e$A#7\e(B")
+                  ("8" . "\e$A#8\e(B")  ("9" . "\e$A#9\e(B") 
+                  (" " . "\e$A!!\e(B")  ("!" . "\e$A#!\e(B")  ("@" . "\e$A#@\e(B")  ("#" . "\e$A##\e(B")
+                  ("$" . "\e$A!g\e(B")  ("%" . "\e$A#%\e(B")  ("^" . "\e$A#^\e(B")  ("&" . "\e$A#&\e(B")
+                  ("*" . "\e$A#*\e(B")  ("(" . "\e$A#(\e(B")  (")" . "\e$A#)\e(B")
+                  ("-" . "\e$A#-\e(B")  ("=" . "\e$A#=\e(B")  ("`" . "\e$A#`\e(B")  ("\\" . "\e$A#\\e(B")
+                  ("|" . "\e$A#|\e(B")  ("_" . "\e$A#_\e(B")  ("+" . "\e$A#+\e(B")  ("~" . "\e$A!+\e(B")
+                  ("[" . "\e$A#[\e(B")  ("]" . "\e$A#]\e(B")  ("{" . "\e$A#{\e(B")  ("}" . "\e$A#}\e(B")
+                  (":" . "\e$A#:\e(B")  (";" . "\e$A#;\e(B")  ("\"" . "\e$A#"\e(B") ("'" . "\e$A#'\e(B")
+                  ("<" . "\e$A#<\e(B")  (">" . "\e$A#>\e(B")  ("?" . "\e$A#?\e(B")  ("/" . "\e$A#/\e(B")
+                  ("," . "\e$A#,\e(B")  ("." . "\e$A#.\e(B")
+                  ("a" . "\e$A#a\e(B")  ("b" . "\e$A#b\e(B")  ("c" . "\e$A#c\e(B")  ("d" . "\e$A#d\e(B")
+                  ("e" . "\e$A#e\e(B")  ("f" . "\e$A#f\e(B")  ("g" . "\e$A#g\e(B")  ("h" . "\e$A#h\e(B")
+                  ("i" . "\e$A#i\e(B")  ("j" . "\e$A#j\e(B")  ("k" . "\e$A#k\e(B")  ("l" . "\e$A#l\e(B")
+                  ("m" . "\e$A#m\e(B")  ("n" . "\e$A#n\e(B")  ("o" . "\e$A#o\e(B")  ("p" . "\e$A#p\e(B")
+                  ("q" . "\e$A#q\e(B")  ("r" . "\e$A#r\e(B")  ("s" . "\e$A#s\e(B")  ("t" . "\e$A#t\e(B")
+                  ("u" . "\e$A#u\e(B")  ("v" . "\e$A#v\e(B")  ("w" . "\e$A#w\e(B")  ("x" . "\e$A#x\e(B")
+                  ("y" . "\e$A#y\e(B")  ("z" . "\e$A#z\e(B")
+                  ("A" . "\e$A#A\e(B")  ("B" . "\e$A#B\e(B")  ("C" . "\e$A#C\e(B")  ("D" . "\e$A#D\e(B")
+                  ("E" . "\e$A#E\e(B")  ("F" . "\e$A#F\e(B")  ("G" . "\e$A#G\e(B")  ("H" . "\e$A#H\e(B")
+                  ("I" . "\e$A#I\e(B")  ("J" . "\e$A#J\e(B")  ("K" . "\e$A#K\e(B")  ("L" . "\e$A#L\e(B")
+                  ("M" . "\e$A#M\e(B")  ("N" . "\e$A#N\e(B")  ("O" . "\e$A#O\e(B")  ("P" . "\e$A#P\e(B")
+                  ("Q" . "\e$A#Q\e(B")  ("R" . "\e$A#R\e(B")  ("S" . "\e$A#S\e(B")  ("T" . "\e$A#T\e(B")
+                  ("U" . "\e$A#U\e(B")  ("V" . "\e$A#V\e(B")  ("W" . "\e$A#W\e(B")  ("X" . "\e$A#X\e(B")
+                  ("Y" . "\e$A#Y\e(B")  ("Z" . "\e$A#Z\e(B")))
+    (let ((in (car ascii)) (out (cdr ascii)))
+      (if (and (or (string< in "a") (string< "z" in))
+              (null (equal in " "))
+              (null (equal in its-banjiao-escape))
+              (null (equal in its-quanjiao-escape)))
+         (progn
+           (its-defrule in in)
+           (its-defrule (concat (downcase its-banjiao-escape) in) in)
+           (its-defrule (concat (downcase its-quanjiao-escape) in) out)))
+      (its-defrule (concat its-banjiao-escape in) in)
+      (its-defrule (concat its-quanjiao-escape in) out)))
+
+  (its-defrule ","     "\e$A#,\e(B"      nil t)
+  (its-defrule "."     "\e$A!#\e(B"      nil t)
+  (its-defrule "/"     "\e$A!"\e(B"      nil t)
+  (its-defrule ":"     "\e$A#:\e(B"      nil t)
+  (its-defrule ";"     "\e$A#;\e(B"      nil t)
+  (its-defrule "?"     "\e$A#?\e(B"      nil t)
+  (its-defrule "!"     "\e$A#!\e(B"      nil t)
+  (its-defrule "-"     "\e$A!*\e(B"      nil t))
+
+(define-its-state-machine its-pinyin-tw-map
+  "pinyin-tw" "\e$(GQ;\e(BC" "Chinese-CNS"
+  "Map for Pinyin input."
+  (its-define-pinyin-table)
+  (its-defoutput*      "b "    "\e$(GDb\e(B")
+  (its-defoutput*      "c "    "\e$(GD_\e(B")
+  (its-defoutput*      "ch "   "\e$(GEx\e(B")
+  (its-defoutput*      "d "    "\e$(GN{\e(B")
+  (its-defoutput*      "f "    "\e$(GE0\e(B")
+  (its-defoutput*      "g "    "\e$(GT6\e(B")
+  (its-defoutput*      "h "    "\e$(GLO\e(B")
+  (its-defoutput*      "i "    "\e$(GD!\e(B")
+  (its-defoutput*      "j "    "\e$(G^s\e(B")
+  (its-defoutput*      "k "    "\e$(GF+\e(B")
+  (its-defoutput*      "l "    "\e$(GD'\e(B")
+  (its-defoutput*      "m "    "\e$(GJd\e(B")
+  (its-defoutput*      "n "    "\e$(GH!\e(B")
+  (its-defoutput*      "p "    "\e$(GJG\e(B")
+  (its-defoutput*      "q "    "\e$(GF*\e(B")
+  (its-defoutput*      "r "    "\e$(GEJ\e(B")
+  (its-defoutput*      "s "    "\e$(GQR\e(B")
+  (its-defoutput*      "sh "   "\e$(GD8\e(B")
+  (its-defoutput*      "t "    "\e$(GEl\e(B")
+  (its-defoutput*      "w "    "\e$(GJ<\e(B")
+  (its-defoutput*      "x "    "\e$(GGW\e(B")
+  (its-defoutput*      "y "    "\e$(GD4\e(B")
+  (its-defoutput*      "z "    "\e$(GGc\e(B")
+  (its-defoutput*      "zh "   "\e$(Gaa\e(B")
+
+  (dolist (ascii '(("0" . "\e$(G$!\e(B")  ("1" . "\e$(G$"\e(B")  ("2" . "\e$(G$#\e(B")  ("3" . "\e$(G$$\e(B")
+                  ("4" . "\e$(G$%\e(B")  ("5" . "\e$(G$&\e(B")  ("6" . "\e$(G$'\e(B")  ("7" . "\e$(G$(\e(B")
+                  ("8" . "\e$(G$)\e(B")  ("9" . "\e$(G$*\e(B") 
+                  (" " . "\e$(G!!\e(B")  ("!" . "\e$(G!*\e(B")  ("@" . "\e$(G"i\e(B")  ("#" . "\e$(G!l\e(B")
+                  ("$" . "\e$(G"c\e(B")  ("%" . "\e$(G"h\e(B")  ("^" . "\e$(G!T\e(B")  ("&" . "\e$(G!m\e(B")
+                  ("*" . "\e$(G!n\e(B")  ("(" . "\e$(G!>\e(B")  (")" . "\e$(G!?\e(B")
+                  ("-" . "\e$(G"1\e(B")  ("=" . "\e$(G"8\e(B")  ("`" . "\e$(G!j\e(B")  ("\\" . "\e$(G"b\e(B")
+                  ("|" . "\e$(G"^\e(B")  ("_" . "\e$(G"%\e(B")  ("+" . "\e$(G"0\e(B")  ("~" . "\e$(G"D\e(B")
+                  ("[" . "\e$(G!b\e(B")  ("]" . "\e$(G!c\e(B")  ("{" . "\e$A#{\e(B")  ("}" . "\e$(G!a\e(B")
+                  (":" . "\e$(G!(\e(B")  (";" . "\e$(G!'\e(B")  ("\"" . "\e$(G!i\e(B") ("'" . "\e$(G!k\e(B")
+                  ("<" . "\e$(G"6\e(B")  (">" . "\e$(G"7\e(B")  ("?" . "\e$(G!)\e(B")  ("/" . "\e$(G"a\e(B")
+                  ("," . "\e$(G!"\e(B")  ("." . "\e$(G!%\e(B")
+                  ("a" . "\e$(G$[\e(B")  ("b" . "\e$(G$\\e(B")  ("c" . "\e$(G$]\e(B")  ("d" . "\e$(G$^\e(B")
+                  ("e" . "\e$(G$_\e(B")  ("f" . "\e$(G$`\e(B")  ("g" . "\e$(G$a\e(B")  ("h" . "\e$(G$b\e(B")
+                  ("i" . "\e$(G$c\e(B")  ("j" . "\e$(G$d\e(B")  ("k" . "\e$(G$e\e(B")  ("l" . "\e$(G$f\e(B")
+                  ("m" . "\e$(G$g\e(B")  ("n" . "\e$(G$h\e(B")  ("o" . "\e$(G$i\e(B")  ("p" . "\e$(G$j\e(B")
+                  ("q" . "\e$(G$k\e(B")  ("r" . "\e$(G$l\e(B")  ("s" . "\e$(G$m\e(B")  ("t" . "\e$(G$n\e(B")
+                  ("u" . "\e$(G$o\e(B")  ("v" . "\e$(G$p\e(B")  ("w" . "\e$(G$q\e(B")  ("x" . "\e$(G$r\e(B")
+                  ("y" . "\e$(G$s\e(B")  ("z" . "\e$(G$t\e(B")
+                  ("A" . "\e$(G$A\e(B")  ("B" . "\e$(G$B\e(B")  ("C" . "\e$(G$C\e(B")  ("D" . "\e$(G$D\e(B")
+                  ("E" . "\e$(G$E\e(B")  ("F" . "\e$(G$F\e(B")  ("G" . "\e$(G$G\e(B")  ("H" . "\e$(G$H\e(B")
+                  ("I" . "\e$(G$I\e(B")  ("J" . "\e$(G$J\e(B")  ("K" . "\e$(G$K\e(B")  ("L" . "\e$(G$L\e(B")
+                  ("M" . "\e$(G$M\e(B")  ("N" . "\e$(G$N\e(B")  ("O" . "\e$(G$O\e(B")  ("P" . "\e$(G$P\e(B")
+                  ("Q" . "\e$(G$Q\e(B")  ("R" . "\e$(G$R\e(B")  ("S" . "\e$(G$S\e(B")  ("T" . "\e$(G$T\e(B")
+                  ("U" . "\e$(G$U\e(B")  ("V" . "\e$(G$V\e(B")  ("W" . "\e$(G$W\e(B")  ("X" . "\e$(G$X\e(B")
+                  ("Y" . "\e$(G$Y\e(B")  ("Z" . "\e$(G$Z\e(B")))
+    (let ((in (car ascii)) (out (cdr ascii)))
+      (if (and (or (string< in "a") (string< "z" in))
+              (null (equal in " "))
+              (null (equal in its-banjiao-escape))
+              (null (equal in its-quanjiao-escape)))
+         (progn
+           (its-defrule in in)
+           (its-defrule (concat (downcase its-banjiao-escape) in) in)
+           (its-defrule (concat (downcase its-quanjiao-escape) in) out)))
+      (its-defrule (concat its-banjiao-escape in) in)
+      (its-defrule (concat its-quanjiao-escape in) out)))
+
+  (its-defrule ","     "\e$(G!"\e(B"     nil t)
+  (its-defrule "."     "\e$(G!$\e(B"     nil t)
+  (its-defrule "/"     "\e$(G!#\e(B"     nil t)
+  (its-defrule ":"     "\e$(G!(\e(B"     nil t)
+  (its-defrule ";"     "\e$(G!'\e(B"     nil t)
+  (its-defrule "?"     "\e$(G!)\e(B"     nil t)
+  (its-defrule "!"     "\e$(G!*\e(B"     nil t)
+  (its-defrule "-"     "\e$(G"1\e(B"     nil t)
+  (its-defrule "["     "\e$(G!V\e(B"     nil t)
+  (its-defrule "]"     "\e$(G!W\e(B"     nil t))
+
+(define-its-state-machine-append its-pinyin-cn-map
+  (its-defrule "[" its-pinyin-cn-open-braket  nil t)
+  (its-defrule "]" its-pinyin-cn-close-braket nil t))
+
+(define-its-state-machine-append its-pinyin-tw-map
+  (its-defrule "[" its-pinyin-tw-open-braket  nil t)
+  (its-defrule "]" its-pinyin-tw-close-braket nil t))
+
+(provide 'its/pinyin)

diff --git a/leim-list-egg.el b/leim-list-egg.el
index d360439..ed5a5d7 100644 (file)
--- a/leim-list-egg.el
+++ b/leim-list-egg.el
@@ -1,4 +1,39 @@
 ;;; Tamago
+
+(autoload 'egg-activate-wnn "egg/wnn" "Activate Wnn backend of Tamagotchy." t)
+(autoload 'egg-activate-sj3 "egg/sj3" "Activate SJ3 backend of Tamagotchy." t)
+
 (register-input-method
- "egg-ja" "Japanese" 'egg-mode
- "A\e$(B$"\e(B"  "Romaji -> Hiragana -> Kanji&Kana")
+ "japanese-egg-wnn" "Japanese" 'egg-activate-wnn
+ "A\e$B$"\e(B"  "Romaji -> Hiragana -> Kanji&Kana")
+
+(register-input-method
+ "japanese-egg-sj3" "Japanese" 'egg-activate-sj3
+ "A\e$B$"\e(B"  "Romaji -> Hiragana -> Kanji&Kana")
+
+(register-input-method
+ "chinese-gb-egg-wnn-py" "Chinese-GB" 'egg-activate-wnn
+ 'egg-mode-line-title  "Pinyin -> Simplified Hanzi"
+ 'its-select-pinyin-cn "Chinese-GB")
+
+(register-input-method
+ "chinese-gb-egg-wnn-zy" "Chinese-GB" 'egg-activate-wnn
+ 'egg-mode-line-title  "Zhunyin -> Simplified Hanzi"
+ 'its-select-zhuyin-cn "Chinese-GB")
+
+(register-input-method
+ "chinese-cns-egg-wnn-py" "Chinese-CNS" 'egg-activate-wnn
+ 'egg-mode-line-title  "Pinyin -> Traditional Hanzi"
+ 'its-select-pinyin-tw "Chinese-CNS")
+
+(register-input-method
+ "chinese-cns-egg-wnn-zy" "Chinese-CNS" 'egg-activate-wnn
+ 'egg-mode-line-title  "Zhunyin -> Traditional Hanzi"
+ 'its-select-zhuyin-tw "Chinese-CNS")
+
+(register-input-method
+ "korean-egg-wnn" "Korean" 'egg-activate-wnn
+ 'egg-mode-line-title  "Hangul -> Hanja"
+ 'its-select-hangul "Korean")
+
+(autoload 'egg-mode "egg" "Toggle EGG  mode." t)

diff --git a/menudiag.el b/menudiag.el
index f9caf06..a8a57de 100644 (file)
--- a/menudiag.el
+++ b/menudiag.el
@@ -51,7 +51,11 @@
 (defvar menudiag-mode-map
   (let ((map (make-keymap))
        (ch 0))
-    (while (< ch 127)
+    (while (< ch 27)
+      (define-key map (char-to-string ch) 'undefined)
+      (setq ch (1+ ch)))
+    (setq ch 28)
+    (while (< ch 255)
       (define-key map (char-to-string ch) 'undefined)
       (setq ch (1+ ch)))
     (setq ch ?0)
@@ -68,6 +72,8 @@
       (setq ch (1+ ch)))
     (define-key map "\C-a" 'menudiag-beginning-of-line)
     (define-key map "\C-e" 'menudiag-end-of-line)
+    (define-key map "\M-<" 'menudiag-beginning-of-items)
+    (define-key map "\M->" 'menudiag-end-of-items)
     (define-key map "\C-f" 'menudiag-forward-item)
     (define-key map "\C-b" 'menudiag-backward-item)
     (define-key map "\C-n" 'menudiag-next-line)
@@ -77,8 +83,8 @@
     (define-key map "\C-l" 'menudiag-redraw)
     (define-key map "\C-m" 'menudiag-select-this-item)
     (define-key map [return] 'menudiag-select-this-item)
-    (define-key map [left] 'menudiag-forward-item)
-    (define-key map [right] 'menudiag-backward-item)
+    (define-key map [left] 'menudiag-backward-item)
+    (define-key map [right] 'menudiag-forward-item)
     (define-key map [up] 'menudiag-previous-line)
     (define-key map [down] 'menudiag-next-line)
     (define-key map [menudiag-continuation] 'menudiag-follow-continuation)
@@ -177,19 +183,39 @@
     (mapconcat
      (function (lambda (item)
                 (setq i (1+ i))
-                (format "  %x.%s" i (menudiag-item-string item))))
+                (format "  %c.%s" (menudiag-item-num-to-char i) 
+                           (menudiag-item-string item))))
      item-list "")))
 
+
+;; ITEM No --> Character
+(defun menudiag-item-num-to-char (num)
+  (let ((char))
+    (cond ((<= num 9)
+           (setq char (+ ?0 num)))
+          (t
+           (setq char (+ ?a (- num 10))))
+          )
+    char))
+
+;; Character --> ITEM No
+(defun menudiag-char-to-item-num (char)
+  (let ((num))
+    (cond ((and (<= ?0 ch) (<= ch ?9))
+           (setq num (- ch ?0)))
+          ((and (<= ?a ch) (<= ch ?z))
+           (setq num (+ 10 (- ch ?a))))
+          ((and (<= ?A ch) (<= ch ?Z))
+           (setq num (+ 10 (- ch ?A))))
+          (t (setq num 1000)))
+    num))
+
+
 (defun menudiag-goto-item ()
   (interactive)
   (let ((ch last-command-char)
        (n 0))
-    (cond ((and (<= ?0 ch) (<= ch ?9))
-          (setq n (- ch ?0)))
-         ((and (<= ?a ch) (<= ch ?z))
-          (setq n (+ 10 (- ch ?a))))
-         ((and (<= ?A ch) (<= ch ?Z))
-          (setq n (+ 10 (- ch ?A)))))
+    (setq n (menudiag-char-to-item-num ch))
     (if (>= n (length line))
        (error "No such item")
       (menudiag-goto-item-internal n))))
@@ -204,6 +230,16 @@
       (setq i (1+ i)))
     (goto-char p)))
 
+(defun menudiag-beginning-of-items ()
+  (interactive)
+  (menudiag-goto-line 0)
+  (menudiag-beginning-of-line))
+
+(defun menudiag-end-of-items ()
+  (interactive)
+  (menudiag-goto-line (1- (length selection-list)))
+  (menudiag-end-of-line))
+
 (defun menudiag-beginning-of-line ()
   (interactive)
   (menudiag-goto-item-internal 0))