Sync up with egg-980627.

diff --git a/ChangeLog b/ChangeLog
index 0b00d91..3829a2c 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,151 @@
+1998-06-27  KATAYAMA Yoshio <kate@pfu.co.jp>
+
+       * egg-cnv.el (egg-abort-conversion): Bug fix.
+
+1998-06-27  NIIBE Yutaka  <gniibe@akebono>
+
+       * egg/wnn.el (wnn-dictionary-specification-list): Don' specify
+       for gerodic/g-jinmei.
+       Suggested by SAKAI Kiyotaka <ksakai@netwk.ntt-at.co.jp>.
+
+1998-06-26  KATAYAMA Yoshio <kate@pfu.co.jp>
+
+       * its.el (its-cancel-input): Bug fix.
+
+1998-06-26  SAKAI Kiyotaka <ksakai@netwk.ntt-at.co.jp>
+
+       * egg-cnv.el (egg-conversion-mode, egg-help-command): New
+       functions for help string.
+       * its.el (its-mode, its-mode-help-command): Likewise.
+
+1998-06-26  KATAYAMA Yoshio <kate@pfu.co.jp>
+
+       * egg-cnv.el (egg-convert-region): Bug fix.
+       * egg.el (egg-default-language): Don't use string.
+
+       * its/hankata.el (its-han-kata-enable-double-n, and others):
+       Variable name change (-han-) to distingush kata.el.
+
+       * its/erpin.el (its-erpin-tw-enable-quanjioao-alphabet,
+       its-erpin-cn-enable-quanjioao-alphabet): 
+       See its-enable-fullwidth-alphabet.
+       * its/kata.el (its-kata-enable-zenkaku-alphabet): Likewise.
+       * its/pinyin.el (its-pinyin-cn-enable-quanjioao-alphabet): Likewise.
+       * its/zenkaku.el (its-zenkaku-down-map): Likewise.
+
+       * its/erpin.el (its-erpin-tw-map): Bug fix for "\\", "{", "}", and
+       "/".
+       * its/pinyin.el (its-pinyin-cn-map): Ditto.
+       * its/quanjiao.el (its-quanjiao-down-tw-map): Ditto.
+       * its/zhuyin.el (its-zhuyin-cn-enable-quanjioao-alphabet): Ditto.
+
+       * its/hira.el (its-hira-enable-zenkaku-alphabet): Follow changes
+       of its.el.
+       * its/ascii.el (its-up-map, its-down-map): Ditto.
+       * its/jeonkak.el (its-jeonkak-up-map): Ditto.
+
+       * its/hira.el (its-hira-enable-zenkaku-alphabet): 
+       See its-enable-fullwidth-alphabet.
+
+       * egg/wnn.el (wnn-save-dictionaries): Rewritten.
+
+       * egg/canna.el (egg-edep): Required.
+       (canna-support-languages): Use symbol.
+       * egg/sj3.el (egg-edep): Likewise.
+
+       * egg/wnn.el (egg-edep): Likewise.      
+       * egg/wnnrpc.el: Use symbol.
+
+       * menudiag.el (menudiag-mode-map): Bug fix for boundary conditions.
+       (menudiag-make-selection-list): Bug fix in case of many items.
+
+       (menudiag-forward-item, menudiag-backward-item,
+       menudiag-goto-line): Change so that it wraps.
+
+       * its.el (egg-edep): Required.
+       (its-keydef): Require unconditioanlly.
+       (its-mode-map): Don't call its-define-select-keys here.
+       (its-mode-map): Use of symbol as keymap.
+       (its-fence-invisible): New variable.
+       (its-put-cursor): Don't call its-define-select-keys.
+       (its-setup-fence-mode): invisible handling and its-define-select-keys.
+       (its-keyseq-acceptable-p): if (CDR SYL) is number, return NIL.
+       (define-its-state-machine): Introduce its-temporaly-map.
+       (define-its-state-machine-append): Likewise.
+
+       (its-goto-state): Use symbol as keymap, not directly.
+
+       (its-set-part-1,its-set-part-2): New function.
+       (its-delete-backward-within-SYL): Conditionalize.
+
+       * egg.el (egg-edep): Required.
+       (egg-mode): Add remove-hook call.
+       Supply NIL as first argument to egg-set-conversion-backend.
+       make-local-hook for input-method-activate-hook.
+       (egg-set-face): Add optional argument OBJECT.
+       (egg-redraw-face): Bind inhibit-point-motion-hooks.
+
+       * egg.el (set-buffer-multibyte): Move to egg-edep.el.
+
+       * egg-mlh.el (mlh-space-bar-backward-henkan): Use assq.
+
+       * egg-com.el (egg-zhuyin-syllable): compatibility change.
+       (encode-fixed-euc-china-region): Removed maxlen.
+
+       Really Needed? -- gN.
+       * egg-com.el (egg-pinyin-syllable): Check exact match.
+       (egg-zhuyin-syllable): Likewise.
+
+       * egg-cnv.el (egg-edep): Required.
+       (its-keydef): Not required.
+       (egg-conversion-map): Don't call its-define-select-keys here.
+       Fset it to use symbol instead of the map directly.
+
+       (egg-get-bunsetsu-info): Add new optional argument for getting
+       property.
+       (egg-start-conversion-other-languages): set egg-conversion-backend.
+       (egg-set-current-backend): Use assq instead of assoc.
+       (egg-get-conversion-face): Likewise.
+       (egg-conversion-invisible): New variable.
+       (egg-convert-region): Change for open/close delimiter.
+       (egg-chinese-sisheng-regexp): New function.
+       (egg-separate-languages): Use egg-chinese-sisheng-regexp,
+       use symbol for language specifier (instead of string).
+
+       (egg-charset-to-language): Use symbol for language specifier
+       (instead of string).
+       (egg-next-chinese-lang): Likewise.
+
+       (egg-next-part-lang): Change the arguments.
+
+       (egg-make-bunsetsu): New function changing egg-insert-bunsetsu.
+
+       (egg-separate-characters): compatibility changes.
+
+       (egg-conversion-wrap-select): New Variable.
+
+       (egg-next-candidate): Can wrap around.
+
+       (egg-decide-before-point): Rewritten.
+       (egg-abort-conversion): Back to previous one.
+       (egg-select-candidate): Use egg-make-bunsetsu.
+
+       * egg-edep.el: New File for handling differences between Emacs version.
+       * its/thai.el: New File.
+       * its/hangul.el: Updated.
+
+1998-06-26  NIIBE Yutaka  <gniibe@mri.co.jp>
+
+       * Makefile (install): Don't touch .emacs and leim-list.el
+       directly.  User should do it by her hand.
+       Reported by SAKAI Kiyotaka <ksakai@netwk.ntt-at.co.jp>
+
+1998-06-25  NIIBE Yutaka  <gniibe@mri.co.jp>
+
+       * egg/canna.el (canna-dictionary-specification): "user" instead of
+       ("user").  Should chnage canna-filename later.
+       Reported by Akio Morita <amorita@bird.scphys.kyoto-u.ac.jp>.
+
 1998-04-02  NIIBE Yutaka  <gniibe@mri.co.jp>
 
        * egg-com.el (comm-unpack-u16-string): Call string-as-multibyte.

diff --git a/egg-cnv.el b/egg-cnv.el
index bd947dc..a996838 100644 (file)
--- a/egg-cnv.el
+++ b/egg-cnv.el
@@ -1,4 +1,4 @@
-;;; egg-cnv.el --- Conversion Backend in Egg Input Method Architecture
+pn;;; egg-cnv.el --- Conversion Backend in Egg Input Method Architecture
 
 ;; Copyright (C) 1997, 1998 Mule Project,
 ;; Powered by Electrotechnical Laboratory, JAPAN.
@@ -31,31 +31,33 @@
 
 ;;; Code:
 
+(require 'egg-edep)
+
 (defvar egg-current-language)
 (make-variable-buffer-local 'egg-current-language)
 (put 'egg-current-language 'permanent-local t)
 
 (defsubst egg-bunsetsu-info () 'intangible)
 
-(defun egg-get-bunsetsu-info (p)
-  (let ((bunsetsu-info (get-text-property p (egg-bunsetsu-info))))
+(defun egg-get-bunsetsu-info (p &optional object)
+  (let ((bunsetsu-info (get-text-property p (egg-bunsetsu-info) object)))
     (if bunsetsu-info
-       (setq egg-conversion-backend (get-text-property p 'egg-backend)
-             egg-current-language (get-text-property p 'egg-lang)))
+       (setq egg-conversion-backend (get-text-property p 'egg-backend object)
+             egg-current-language (get-text-property p 'egg-lang object)))
     bunsetsu-info))
 ;;
 
 (defconst egg-conversion-backend-other-languages
   [ egg-init-other-languages
 
-        egg-start-conversion-other-languages
+       egg-start-conversion-other-languages
       egg-get-bunsetsu-converted-other-languages
       egg-get-bunsetsu-source-other-languages
       egg-list-candidates-other-languages
-          egg-get-number-of-candidates-other-languages
-          egg-get-current-candidate-number-other-languages
-          egg-get-all-candidates-other-languages
-          egg-decide-candidate-other-languages
+         egg-get-number-of-candidates-other-languages
+         egg-get-current-candidate-number-other-languages
+         egg-get-all-candidates-other-languages
+         egg-decide-candidate-other-languages
       egg-change-bunsetsu-length-other-languages
     egg-end-conversion-other-languages
     nil
@@ -67,6 +69,7 @@
   )
 
 (defun egg-start-conversion-other-languages (yomi-string language)
+  (setq egg-conversion-backend egg-conversion-backend-other-languages)
   (list yomi-string))
 (defun egg-get-bunsetsu-converted-other-languages (bunsetsu-info)
   bunsetsu-info)
@@ -102,7 +105,7 @@
 
 (defun egg-set-current-backend (language)
   (setq egg-conversion-backend
-       (cdr (assoc language egg-conversion-backend-alist)))
+       (cdr (assq language egg-conversion-backend-alist)))
   (if (null egg-conversion-backend)
       (setq egg-conversion-backend egg-conversion-backend-other-languages)))
 
@@ -165,165 +168,179 @@
 (defvar egg-conversion-open  "|"  "*\e$B%U%'%s%9$N;OE@$r<($9J8;zNs\e(B (1 \e$BJ8;z0J>e\e(B)")
 (defvar egg-conversion-close "|"  "*\e$B%U%'%s%9$N=*E@$r<($9J8;zNs\e(B (1 \e$BJ8;z0J>e\e(B)")
 (defvar egg-conversion-face  nil  "*\e$B%U%'%s%9I=<($KMQ$$$k\e(B face \e$B$^$?$O\e(B nil")
+(defvar egg-conversion-invisible nil)
 (defvar egg-conversion-separator " ")
 
 (defun egg-get-conversion-face ()
   (let ((face (and (listp egg-conversion-face)
-                  (or (assoc egg-current-language egg-conversion-face)
-                      (assoc t egg-conversion-face)))))
+                  (or (assq egg-current-language egg-conversion-face)
+                      (assq t egg-conversion-face)))))
     (if face (cdr face) egg-conversion-face)))
 
 ;;
 (defun egg-convert-region (start end)
   (interactive "r")
-  (if (>= start end)
-      ;; nothing to do
-      nil
-    (remove-text-properties start end '(read-only nil intangible nil))
-    (goto-char start)
-    (insert egg-conversion-open)
-    (let ((inhibit-read-only t)
-         (max (make-marker))
-         bunsetsu-info-list contin p s e result)
-      (setq p (+ (point) (- end start)))
-      (set-text-properties start (point)
-                          (list
-                           'read-only t
-                           'egg-start t
-                           'egg-source (buffer-substring (point) p)))
-      (if egg-conversion-face
-         (put-text-property start (point) 'invisible t))
-      (setq start (point))
-      (goto-char p)
-      (insert egg-conversion-close)
-      (set-text-properties p (point) '(read-only t rear-nonsticky t egg-end t))
-      (if egg-conversion-face
-         (put-text-property p (point) 'invisible t))
-      (set-marker max p)
-      (egg-separate-languages start max)
-      (goto-char start)
-      (while (< (point) max)
-       (setq egg-current-language (get-text-property (point) 'egg-lang)
-             s (point)
-             e (point))
-       (while (and (< e max)
-                   (equal egg-current-language
-                          (get-text-property e 'egg-lang)))
-         (setq e (next-single-property-change e 'egg-lang nil max)))
-       (condition-case result
-           (setq bunsetsu-info-list
-                 (egg-start-conversion
-                  (buffer-substring-no-properties s e)
-                  egg-current-language))
-         (error                        ; XXX: catching all error is BADBADBAD
-          (setq egg-conversion-backend egg-conversion-backend-other-languages
-                bunsetsu-info-list (egg-start-conversion-other-languages
-                                    (buffer-substring-no-properties s e)
-                                    egg-current-language))
-          (message "egg %s backend: %s" egg-current-language (cadr result))))
-       (setq contin (< e max))
-       (delete-region s e)
-       (egg-insert-bunsetsu-list bunsetsu-info-list
-                                 (if (< (point) max) 'contine t)))
-      (set-marker max nil)
-      (goto-char start))))
-
-(defun egg-separate-languages (start end &optional use-context)
-  (let (lang last-lang last-chinese p pe l c cset)
+  (let ((source (buffer-substring start end))
+       (no-prop-source (buffer-substring-no-properties start end))
+       bunsetsu-info-list len result i j s)
+    (if (>= start end)
+       ;; nothing to do
+       nil
+      (delete-region start end)
+      (let ((inhibit-read-only t))
+       (its-define-select-keys egg-conversion-map)
+       (goto-char start)
+       ;; XXX: Why make OPEN&CLOSE string every time when 
+       ;; this function is invoked?  Any Reason?
+       ;; For me it's matter of user costomization
+       ;; of setting egg-conversion-open/egg-conversion-close
+       ;; it can be string of properties at the beginning, isn't it?
+       (setq s (copy-sequence egg-conversion-open)
+             len (length s))
+       (set-text-properties 0 len
+                            (list
+                             'read-only t
+                             'egg-start t
+                             'egg-source source)
+                            s)
+       (if egg-conversion-invisible
+           (put-text-property 0 len 'invisible t s))
+       (insert s)
+       (setq start (point)
+             s (copy-sequence egg-conversion-close)
+             len (length s))
+       (set-text-properties 0 len
+                            '(read-only t rear-nonsticky t egg-end t)
+                            s)
+       (if egg-conversion-invisible
+           (put-text-property 0 len 'invisible t s))
+       (insert s)
+       (goto-char start)
+       (egg-separate-languages (copy-sequence source))
+       (setq i 0
+             len (length source))
+       (while (< i len)
+         (setq egg-current-language (get-text-property i 'egg-lang source)
+               j (egg-next-single-property-change i 'egg-lang source len))
+         (condition-case result
+             (setq bunsetsu-info-list (egg-start-conversion
+                                       (substring no-prop-source i j)
+                                       egg-current-language))
+           (error                      ; XXX: catching all error is BADBADBAD
+            (setq bunsetsu-info-list (egg-start-conversion-other-languages
+                                      (substring no-prop-source i j)
+                                      egg-current-language))
+            (message "egg %s backend: %s"
+                     egg-current-language (nth 1 result))))
+         (egg-insert-bunsetsu-list bunsetsu-info-list
+                                   (if (< j len) 'contine t))
+         (setq i j))
+       (goto-char start)))))
+
+(defconst egg-chinese-sisheng-regexp
+  (concat "[" (list (make-char 'chinese-sisheng 32))
+         "-" (list (make-char 'chinese-sisheng 127))
+         "]+"))
+
+(defun egg-separate-languages (str &optional last-lang)
+  (let (lang last-chinese
+       (len (length str)) i j l)
     ;; 1st pass -- mark undefined Chinese part
-    (goto-char start)
-    (and use-context
-        (setq last-lang (get-text-property (1- (point)) 'egg-lang))
-        (or (equal last-lang "Chinese-GB") (equal last-lang "Chinese-CNS"))
-        (setq last-chinese last-lang))
-    (while (< (point) end)
-      (setq p (point)
-           pe (next-single-property-change (point) 'egg-lang nil end))
-      (cond
-       ((get-text-property (point) 'egg-lang)
-       (goto-char pe)
-       (setq lang nil))
-       ((setq l (egg-chinese-syllable (buffer-substring p pe)))
-       (goto-char (+ p l))
-       (setq lang "Chinese"))
-       ((progn
-         (setq c (following-char)
-               cset (char-charset c))
-         (eq cset 'chinese-sisheng))
-       (forward-char)
-       (setq lang "Chinese"))
-       ((eq cset 'ascii)
-       (skip-chars-forward "\0-\177" pe)
-       (if (eq (char-charset (following-char)) 'chinese-sisheng)
-           (goto-char (max (1+ pp) (- (point) 6))))
-       (setq lang nil))
-       ((eq cset 'composition)
-       (forward-char)
-       (setq lang (egg-charset-to-language
-                   (char-charset (car (decompose-composite-char c 'list))))))
-       (t
-       (skip-chars-forward (concat (vector (make-char cset 33 33))
-                                   "-"
-                                   (vector (make-char cset 127 127)))
-                           pe)
-       (setq lang (egg-charset-to-language cset))))
-      (if lang
-         (put-text-property p (point) 'egg-lang lang)))
+    (if (or (eq last-lang 'Chinese-GB) (eq last-lang 'Chinese-CNS))
+       (setq last-chinese last-lang))
+    (setq i 0)
+    (while (< i len)
+      (setq j (egg-next-single-property-change i 'egg-lang str len))
+      (if (get-text-property i 'egg-lang str)
+         nil
+       (setq c (egg-string-to-char-at str i)
+             cset (char-charset c))
+       (cond
+        ((eq cset 'chinese-sisheng)
+         (string-match egg-chinese-sisheng-regexp str i)
+         (setq l (match-end 0)
+               j (min j l)
+               lang 'Chinese))
+        ((setq l (egg-chinese-syllable str i))
+         (setq j (+ i l)
+               lang 'Chinese))
+        ((eq cset 'ascii)
+         (if (eq (string-match "[\0-\177\240-\377]+" str (1+ i)) (1+ i))
+             (setq j (match-end 0))
+           (setq j (1+ i)))
+         (if (and (< j len)
+                  (eq (char-charset (egg-string-to-char-at str j))
+                      'chinese-sisheng))
+             (setq j (max (1+ i) (- j 6))))
+         (setq lang nil))
+        ((eq cset 'composition)
+         (setq j (+ i (egg-char-bytes c))
+               lang (egg-charset-to-language
+                     (char-charset
+                      (car (decompose-composite-char c 'list))))))
+        (t
+         (string-match (concat "[" (list (make-char cset 32 32))
+                               "-" (list (make-char cset 127 127))
+                               "]+")
+                       str i)
+         (setq j (match-end 0)
+               lang (egg-charset-to-language cset))))
+       (if lang
+           (put-text-property i j 'egg-lang lang str)))
+      (setq i j))
     ;; 2nd pass -- set language property
-    (goto-char start)
-    (while (< (point) end)
-      (setq lang (get-text-property (point) 'egg-lang))
+    (setq i 0)
+    (while (< i len)
+      (setq lang (get-text-property i 'egg-lang str))
       (cond
        ((null lang)
        (setq lang (or last-lang
-                      (egg-next-part-lang end))))
-       ((equal lang "Chinese")
+                      (egg-next-part-lang str i))))
+       ((equal lang 'Chinese)
        (setq lang (or last-chinese
-                      (egg-next-chinese-lang end)))))
+                      (egg-next-chinese-lang str i)))))
       (setq last-lang lang)
-      (if (or (equal lang "Chinese-GB") (equal lang "Chinese-CNS"))
+      (if (or (eq lang 'Chinese-GB) (eq lang 'Chinese-CNS))
          (setq last-chinese lang))
-      (setq p (point))
-      (goto-char (next-single-property-change (point) 'egg-lang nil end))
-      (set-text-properties p (point) (list 'egg-lang lang)))))
+      (setq j i
+           i (egg-next-single-property-change i 'egg-lang str len))
+      (set-text-properties j i (list 'egg-lang lang) str))))
 
+;;; Should think again the interface to language-info-alist
 (defun egg-charset-to-language (charset)
   (let ((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) 'egg-lang nil end))
-        (lang (get-text-property p 'egg-lang)))
-    (if (equal lang "Chinese")
-       (egg-next-chinese-lang end)
+    (if list
+       (intern (car (car list))))))
+
+(defun egg-next-part-lang (str pos)
+  (let ((lang (get-text-property
+              (egg-next-single-property-change pos 'egg-lang str (length str))
+              'egg-lang str)))
+    (if (eq lang 'Chinese)
+       (egg-next-chinese-lang str pos)
       (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 'egg-lang nil end))
-      (setq lang (get-text-property p 'egg-lang))
-      (if (null (or (equal lang "Chinese-GB")
-                   (equal lang "Chinese-CNS")))
+(defun egg-next-chinese-lang (str pos)
+  (let ((len (length str)) lang)
+    (while (and (< pos len) (null lang))
+      (setq pos (egg-next-single-property-change pos 'egg-lang str len)
+           lang (get-text-property pos 'egg-lang str))
+      (if (null (or (eq lang 'Chinese-GB)
+                   (eq 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"))))
+     ((eq its-current-language 'Chinese-GB)  'Chinese-GB)
+     ((eq its-current-language 'Chinese-CNS) 'Chinese-CNS)
+     ((eq egg-default-language 'Chinese-GB)  'Chinese-GB)
+     ((eq egg-default-language 'Chinese-CNS) 'Chinese-CNS)
+     (t 'Chinese-GB))))
 \f
-(require 'its-keydef)
-
 (defvar egg-conversion-map
   (let ((map (make-sparse-keymap))
        (i 33))
@@ -352,39 +369,45 @@
     (define-key map [right]  'egg-forward-bunsetsu)
     (define-key map [left]   'egg-backward-bunsetsu)
     (define-key map " "      'egg-next-candidate)
-    (its-define-select-keys map)
     map)
   "Keymap for EGG Conversion mode.")
 
+(fset 'egg-conversion-map egg-conversion-map)
+
 (defun egg-exit-conversion-unread-char ()
   (interactive)
   (setq unread-command-events (list last-command-event))
   (egg-exit-conversion))
 
-(defun egg-insert-bunsetsu (bunsetsu-info last)
-  (let ((bunsetsu (egg-get-bunsetsu-converted bunsetsu-info))
-       (p (point)) p1)
-    (insert bunsetsu)
-    (setq p1 (point))
+(defun egg-make-bunsetsu (bunsetsu-info last)
+  (let ((bunsetsu (copy-sequence (egg-get-bunsetsu-converted bunsetsu-info)))
+       len len1)
+    (setq len1 (length bunsetsu))
     (if (null (eq last t))
-       (insert egg-conversion-separator))
-    (set-text-properties p (point)
+       (setq bunsetsu (concat bunsetsu egg-conversion-separator)))
+    (setq len (length bunsetsu))
+    (set-text-properties 0 len
                         (list 'read-only          t
                               (egg-bunsetsu-info) bunsetsu-info
                               'egg-backend        egg-conversion-backend
                               'egg-lang           egg-current-language
                               'egg-bunsetsu-last  last
-                              'local-map          egg-conversion-map))
+                              'local-map          'egg-conversion-map)
+                        bunsetsu)
     (if egg-conversion-face
-       (egg-set-face p p1 (egg-get-conversion-face)))))
+       (egg-set-face 0 len1 (egg-get-conversion-face) bunsetsu))
+    bunsetsu))
 
 (defun egg-insert-bunsetsu-list (bunsetsu-info-list &optional last)
   (let ((l bunsetsu-info-list)
-       bunsetsu-info)
+       bunsetsu-info bunsetsu)
     (while l
       (setq bunsetsu-info (car l)
-           l (cdr l))
-      (egg-insert-bunsetsu bunsetsu-info (and (null l) last)))))
+           l (cdr l)
+           bunsetsu (cons (egg-make-bunsetsu bunsetsu-info
+                                             (and (null l) last))
+                          bunsetsu)))
+    (apply 'insert (nreverse bunsetsu)))) ; XXX: Should avoid apply and reverse
 
 (defun egg-beginning-of-conversion-buffer (n)
   (interactive "p")
@@ -431,13 +454,13 @@
        (egg-get-bunsetsu-info (- p 2))))
 
 (defun egg-separate-characters (str)
-  (let* ((v (string-to-vector str))
+  (let* ((v (egg-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))))
+         (setq m (egg-chars-in-period str j n))
+       (setq m 1 n (egg-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))
@@ -486,6 +509,10 @@
     (if beep
        (ding))))
 
+(defvar egg-conversion-wrap-select nil
+  "*Candidate selection wraps around to first candidate, if non-nil.
+Otherwise stop at the last candidate.")
+
 (defun egg-next-candidate (n)
   (interactive "p")
   (let ((inhibit-read-only t)
@@ -503,17 +530,21 @@
       (setq i (egg-get-current-candidate-number b))
       (setq i (+ n i)))
     (if (null max+)
-       (setq beep t)
-      (if (< i 0)                      ; go backward as if it is ring
-         (while (< i 0)
-           (setq i (+ i max+))))
-      (if (>= i max+)                  ; don't go forward 
-         (setq i (1- max+)
-               beep t))
+      (setq beep t)
+     (cond
+      ((< i 0)                         ; go backward as if it is ring
+       (while (< i 0)
+        (setq i (+ i max+))))
+      ((< i max+))                     ; OK
+      (egg-conversion-wrap-select      ; go backward as if it is ring
+       (while (>= i max+)
+        (setq i (- i max+))))
+      ((setq i (1- max+)               ; don't go forward 
+            beep t)))
       (setq new (egg-decide-candidate b i))
       (setq p (point))
       (delete-region p (progn (forward-char) (point)))
-      (egg-insert-bunsetsu new last)
+      (insert (egg-make-bunsetsu new last))
       (goto-char p))
     (if beep
        (ding))))
@@ -559,46 +590,44 @@
 (defun egg-decide-before-point ()
   (interactive)
   (let ((inhibit-read-only t)
-       (len (length egg-conversion-open))
-       bunsetsu-list bl (p (point)) source lang s)
-    (save-restriction
-      (if (null (get-text-property (1- (point)) 'egg-start))
-         (goto-char (previous-single-property-change (point) 'egg-start)))
-      (narrow-to-region (- (point) len) p)
-      (setq bunsetsu-list (setq bl (list nil)))
-      (while (< (point) (point-max))
-       ;; delete sparator/open marker
-       (delete-region (- (point) len) (point))
-       (setq len 1
-             bl (setcdr bl (list (egg-get-bunsetsu-info (point)))))
-       (if (get-text-property (point) 'egg-bunsetsu-last)
-           (progn
-             (egg-end-conversion (cdr bunsetsu-list) nil)
-             (setq bunsetsu-list (setq bl (list nil)))))
-       (setq p (point))
-       (forward-char)
-       (set-text-properties p (point) nil)))
-    (if (cdr bunsetsu-list)
-       (egg-end-conversion (cdr bunsetsu-list) nil))
-    (if (get-text-property (point) 'egg-end)
+       start end len decided undecided bunsetsu source)
+    (setq start (if (get-text-property (1- (point)) 'egg-start)
+                   (point)
+                 (previous-single-property-change (point) 'egg-start))
+         end (if (get-text-property (point) 'egg-end)
+                 (point)
+               (next-single-property-change (point) 'egg-end))
+         decided (buffer-substring start (point))
+         undecided (buffer-substring (point) end))
+    (delete-region (- start (length egg-conversion-open))
+                  (+ end (length egg-conversion-close)))
+    (setq i 0
+         len (length decided))
+    (while (< i len)
+      (setq bunsetsu (cons (egg-get-bunsetsu-info i decided) bunsetsu)
+           i (egg-next-single-property-change
+              i (egg-bunsetsu-info) decided len))
+      (if (or (= i len)
+             (get-text-property (1- i) 'egg-bunsetsu-last decided))
+         (progn
+           (setq bunsetsu (nreverse bunsetsu))
+           (apply 'insert (mapcar (lambda (b) (egg-get-bunsetsu-converted b))
+                                  bunsetsu))
+           (egg-end-conversion bunsetsu nil)
+           (setq bunsetsu nil))))
+    (setq len (length undecided))
+    (if (= len 0)
        (progn
-         ;; delete close marker
-         (delete-region (point) (+ (point) (length egg-conversion-close)))
          (egg-do-auto-fill)
          (run-hooks 'input-method-after-insert-chunk-hook))
-      ;; delete from last speparater
-      (delete-region (1- (point)) (point))
-      (setq source "")
-      (while (null (get-text-property (point) 'egg-end))
-       (setq s (egg-get-bunsetsu-source (egg-get-bunsetsu-info (point))))
-       (put-text-property 0 (length s) 'egg-lang egg-current-language s)
-       (setq source (concat source s))
-       (setq p (point))
-       (forward-char)
-       (delete-region p (point)))
-      ;; delete close marker
-      (delete-region (point) (+ (point) (length egg-conversion-close)))
-      (its-restart source t))))
+      (setq i 0)
+      (while (< i len)
+       (setq source (cons (egg-get-bunsetsu-source
+                           (egg-get-bunsetsu-info i undecided))
+                          source)
+             i (egg-next-single-property-change
+                i (egg-bunsetsu-info) undecided len)))
+      (its-restart (apply 'concat (nreverse source)) t))))
 
 (defun egg-exit-conversion ()
   (interactive)
@@ -607,21 +636,16 @@
 
 (defun egg-abort-conversion ()
   (interactive)
-  (let ((inhibit-read-only t)
-       start bunsetsu-list source)
-    (if (get-text-property (1- (point)) 'egg-start)
-       (setq start (1- (point)))
-      (setq start (1- (previous-single-property-change (point) 'egg-start))))
-    (goto-char start)
+  (let ((inhibit-read-only t) source)
+    (goto-char (- (if (get-text-property (1- (point)) 'egg-start)
+                     (point)
+                   (previous-single-property-change (point) 'egg-start))
+                 (length egg-conversion-open)))
     (setq source (get-text-property (point) 'egg-source))
-    ;; Delete open marker
-    (delete-region start (+ start (length egg-conversion-open)))
-    (setq bunsetsu-list (egg-decide-bunsetsu))
-    ;; Delete close marker
-    (delete-region (point) (+ (point) (length egg-conversion-close)))
-    (egg-end-conversion bunsetsu-list t)
-    (delete-region start (point))
-    (its-restart source)))
+    (delete-region (point) (+ (next-single-property-change (point) 'egg-end)
+                             (length egg-conversion-close)))
+    (its-restart source)
+    (its-end-of-input-buffer)))
 
 (defun egg-select-candidate ()
   (interactive)
@@ -655,8 +679,21 @@
        (setq new (egg-decide-candidate b i))
        (setq p (point))
        (delete-region p (progn (forward-char) (point)))
-       (egg-insert-bunsetsu new last)
+       (insert (egg-make-bunsetsu new last))
        (goto-char p)))))
 
+(defun egg-conversion-mode ()
+  "\\{egg-conversion-map}"
+  ;; dummy function to get docstring
+  )
+
+(defun egg-help-command ()
+  "Display documentation for EGG Conversion mode."
+  (interactive)
+  (with-output-to-temp-buffer "*Help*"
+    (princ "EGG Conversion mode:\n")
+    (princ (documentation 'egg-conversion-mode))
+    (help-setup-xref (cons #'help-xref-mode (current-buffer)) (interactive-p))))
+
 (provide 'egg-cnv)
 ;;; egg-cnv.el ends here.

diff --git a/egg-com.el b/egg-com.el
index 72d8045..7117563 100644 (file)
--- a/egg-com.el
+++ b/egg-com.el
@@ -1,8 +1,7 @@
-;;; egg-com.el --- Communication Routines in Egg Input
-;;;                   Method Architecture
+;;; egg-com.el --- Communication Routines in Egg Input Method Architecture
 
-;; Copyright (C) 1997, 1998 Mule Project, Powered by Electrotechnical
-;; Laboratory, JAPAN.
+;; 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>
@@ -31,6 +30,8 @@
 
 ;;; Code:
 
+(require 'egg-edep)
+
 (defvar egg-fixed-euc 'fixed-euc-jp)
 (make-variable-buffer-local 'egg-fixed-euc)
 
@@ -60,30 +61,24 @@
            (r0 = (r1 | ?\x80))
            (write-read-repeat r0)))))))))
 
-(define-ccl-program ccl-encode-fixed-euc
+(define-ccl-program ccl-encode-fixed-euc-jp
   `(2
     ((read r0)
      (loop
-;      (if (r0 < ?\x20)
-;        (write-read-repeat r0))
-      (if (r0 == ,(charset-id 'latin-jisx0201))                 ; Unify
+      (if (r0 == ,(charset-id 'latin-jisx0201))                   ; Unify
          ((read r0)
           (r0 &= ?\x7f)))
-      (if (r0 < ?\x80)
+      (if (r0 < ?\x80)                                            ;G0
          ((write 0)
           (write-read-repeat r0)))
       (r6 = (r0 == ,(charset-id 'japanese-jisx0208)))
       (r6 |= (r0 == ,(charset-id 'japanese-jisx0208-1978)))
-      (r6 |= (r0 == ,(charset-id 'chinese-gb2312)))
-      (r6 |= (r0 == ,(charset-id 'korean-ksc5601)))
       (if r6                                                      ;G1
          ((read r0)
           (write r0)
           (read r0)
           (write-read-repeat r0)))
-      (r6 = (r0 == ,(charset-id 'katakana-jisx0201)))
-      (r6 |= (r0 == ,(charset-id 'chinese-sisheng)))
-      (if r6                                                      ;G2
+      (if (r0 == ,(charset-id 'katakana-jisx0201))                ;G2
          ((read r0)
           (write 0)
           (write-read-repeat r0)))
@@ -98,7 +93,7 @@
 )
 
 (make-coding-system 'fixed-euc-jp 4 ?W "Coding System for fixed EUC Japanese"
-                   (cons ccl-decode-fixed-euc-jp ccl-encode-fixed-euc))
+                   (cons ccl-decode-fixed-euc-jp ccl-encode-fixed-euc-jp))
 
 ;; Korean
 
@@ -119,17 +114,13 @@
   `(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)))))
@@ -416,20 +407,23 @@
    ?\x0000
    ])
 
-(defun egg-chinese-syllable (str &optional start)
-  (if start
-      (setq str (substring str start)))
+(defconst egg-chinese-syllable-max-len
+  (max (length "Zhu\e(0!\e(Bng\e(0@\e(B") (length "\e(0ShdA\e(B")))
+
+(defun egg-chinese-syllable (str pos)
+  (setq str (substring str pos (min (length str)
+                                   (+ pos egg-chinese-syllable-max-len))))
   (or (car (egg-pinyin-syllable str))
       (car (egg-zhuyin-syllable str))))
 
 (defsubst egg-make-fixed-euc-china-code (s y)
-  (concat (list
-          (+ (* 2 (nth 1 y)) (logand (nth 2 y) 1) 32)
-          (+ (* 4 (if (= s 0) 20 s)) (lsh (nth 2 y) -1) 156))))
+  (cons
+   (+ (* 2 (nth 1 y)) (logand (nth 2 y) 1) 32)
+   (+ (* 4 (if (= s 0) 20 s)) (lsh (nth 2 y) -1) 156)))
 
 (defun egg-pinyin-syllable (str)
   (let (s y end)
-    (if (string-match "^[A-Za-z\e(0!\e(B-\e(0?\e(B]+\e(0@\e(B" str)
+    (if (eq (string-match "^[A-Za-z\e(0!\e(B-\e(0?\e(B]+\e(0@\e(B" str) 0)
        (progn
          (setq end (match-end 0))
          (cond
@@ -444,8 +438,8 @@
              (cons end (egg-make-fixed-euc-china-code s y)))))))
 
 (defun egg-zhuyin-syllable (str)
-  (let (end s y c z (zhuyin-len (charset-bytes 'chinese-sisheng)))
-    (if (string-match "^[\e(0E\e(B-\e(0i\e(B@0-4]+[\e(0@ABCD\e(B]" str)
+  (let (end s y c z (zhuyin-len (egg-charset-bytes 'chinese-sisheng)))
+    (if (eq (string-match "^[\e(0E\e(B-\e(0i\e(B@0-4]+[\e(0@ABCD\e(B]" str) 0)
        (progn
          (setq end (match-end 0)
                c (substring str 0 zhuyin-len)
@@ -465,21 +459,22 @@
 
 (defun encode-fixed-euc-china-region (beg end type)
   "Encode the text in the region to EUC-CN/TW."
-  (let (s syl c cset (maxlen (max (length "Zhu\e(0!\e(Bng\e(0@\e(B") (length "\e(0ShdA\e(B"))))
+  (let (s syl c cset)
     (save-excursion
       (save-restriction
        (narrow-to-region beg end)
        (goto-char (point-min))
        (while (< (point) (point-max))
-         (setq s (buffer-substring (point) 
-                                   (min (+ (point) maxlen) (point-max))))
+         (setq s (buffer-substring
+                  (point)
+                  (min (point-max) (+ (point) egg-chinese-syllable-max-len))))
          (cond
           ((setq syl (egg-pinyin-syllable s))
            (delete-region (point) (+ (point) (car syl)))
-           (insert (cdr syl)))
+           (insert (car (cdr syl)) (cdr (cdr syl))))
           ((setq syl (egg-zhuyin-syllable s))
            (delete-region (point) (+ (point) (car syl)))
-           (insert (cdr syl)))
+           (insert (car (cdr syl)) (cdr (cdr syl))))
           (t
            (setq c (split-char (following-char))
                  cset (car c))
@@ -494,9 +489,11 @@
             ((eq cset 'chinese-sisheng)
              (delete-char 1)
              (insert 0 (+ (nth 1 c) 128)))
+            ((eq cset 'ascii)
+             (delete-char 1)
+             (insert 0 (nth 1 c)))
             (t
-             (delete-region (point) (1+ (point)))
-             (insert 0 (nth 1 c)))))))
+             (delete-char 1))))))
        (- (point-max) (point-min))))))
 
 (defun pre-write-encode-fixed-euc-china (from to type)
@@ -504,9 +501,11 @@
        (work (get-buffer-create " *pre-write-encoding-work*")))
     (set-buffer work)
     (erase-buffer)
-    (if (stringp from)
-       (insert from)
-      (insert-buffer-substring buf from to))
+    (if (null (stringp from))
+       (save-excursion
+         (set-buffer buf)
+         (setq from (buffer-substring from to))))
+    (insert (string-as-multibyte from))
     (encode-fixed-euc-china-region 1 (point-max) type)
     nil))
 
@@ -519,54 +518,56 @@
 (defun decode-fixed-euc-china-region (beg end type)
   "Decode EUC-CN/TW encoded text in the region.
 Return the length of resulting text."
-  (interactive "r")
   (prog1
-      (let (c0 c1 s y ss)
-       (save-restriction
-         (narrow-to-region beg end)
-         (goto-char (point-min))
-         (while (< (point) (point-max))
-           (setq c1 (buffer-substring (point) (+ (point) 2))
-                 c0 (aref c1 0)
-                 c1 (aref c1 1))
-           (delete-region (point) (+ (point) 2))
+      (let ((str (string-as-unibyte (buffer-substring beg end)))
+           (i 0)
+           l c0 c1 s y ss)
+       (delete-region beg end)
+       (setq l (1- (length str)))
+       (while (< i l)
+         (setq c0 (aref str i)
+               c1 (aref str (1+ i))
+               i  (+ i 2))
+         (cond
+          ((eq c0 0)
+           (if (> c1 ?\xa0)
+               (insert leading-code-private-11
+                       (charset-id 'chinese-sisheng)
+                       c1)
+             (insert c1)))
+          ((>= c0 ?\x80)
            (cond
-            ((eq c0 0)
-             (if (> c1 ?\xa0)
-                 (insert leading-code-private-11
-                         (charset-id 'chinese-sisheng)
-                         c1)
-               (insert c1)))
+            ((eq type 'cn)
+             (insert (charset-id 'chinese-gb2312) c0 (logior c1 ?\x80)))
             ((>= c0 ?\x80)
-             (cond
-              ((eq type 'cn)
-               (insert (charset-id 'chinese-gb2312) c0 (logior c1 ?\x80)))
-              ((>= c0 ?\x80)
-               (insert (charset-id 'chinese-cns11643-1) c0 c1))
-              (t
-               (insert (charset-id 'chinese-cns11643-2) c0 (+ c1 ?\x80)))))
+             (insert (charset-id 'chinese-cns11643-1) c0 c1))
             (t
-             (setq c1 (logand c1 ?\x7f))
-             (setq s (- (lsh c1 -2) 7)  ;;(+ (lsh (- c1 32) -2) 1)
-                   y (- (lsh c0 -1) 16) ;;(lsh (- c0 32) -1)
-                   ss (+ (logand c0 1) (logand c1 3)))
-             (if egg-zhuyin
-                  (progn
-                   (setq c0 (aref yincode-zhuyin-table (+ (* 41 s) y)))
-                    (if (eq (logand c0 ?\x8080) ?\x80)
-                        (setq s (lsh c0 -8)
-                              y (logand c0 ?\x7f)))
-                    (if (and (eq s 20)
-                             (eq (aref yincode-pinyin-table (+ (* 39 s) y)) 0))
-                        (setq s 0))
-                    (insert (car (nth s yincode-zhuyin-shengmu))
-                            (car (nth (+ (* 5 y) ss) yincode-zhuyin-yunmu))))
-                (if (and (eq s 20)
-                         (eq (aref yincode-pinyin-table (+ (* 39 s) y)) 0))
-                    (setq s 0))
-               (insert (car (nth s yincode-pinyin-shengmu))
-                       (car (nth (+ (* 5 y) ss) yincode-pinyin-yunmu)))))))
-         (- (point-max) (point-min))))
+             (insert (charset-id 'chinese-cns11643-2) c0 (+ c1 ?\x80)))))
+          (t
+           (setq c1 (logand c1 ?\x7f))
+           (setq s (- (lsh c1 -2) 7);;(+ (lsh (- c1 32) -2) 1)
+                 y (- (lsh c0 -1) 16);;(lsh (- c0 32) -1)
+                 ss (+ (logand c0 1) (logand c1 3)))
+           (if egg-zhuyin
+               (progn
+                 (setq c0 (aref yincode-zhuyin-table (+ (* 41 s) y)))
+                 (if (eq (logand c0 ?\x8080) ?\x80)
+                     (setq s (lsh c0 -8)
+                           y (logand c0 ?\x7f)))
+                 (if (and (eq s 20)
+                          (eq (aref yincode-pinyin-table (+ (* 39 s) y)) 0))
+                     (setq s 0))
+                 (setq s (car (nth s yincode-zhuyin-shengmu))
+                       y (car (nth (+ (* 5 y) ss) yincode-zhuyin-yunmu))))
+             (if (and (eq s 20)
+                      (eq (aref yincode-pinyin-table (+ (* 39 s) y)) 0))
+                 (setq s 0))
+             (setq s (car (nth s yincode-pinyin-shengmu))
+                   y (car (nth (+ (* 5 y) ss) yincode-pinyin-yunmu))))
+           (if enable-multibyte-characters
+               (insert s y)
+             (insert (string-as-unibyte s) (string-as-unibyte y))))))
+       (- (point) beg))
     (if (looking-at "\0\0") (forward-char 2))))
 
 (defun post-read-decode-fixed-euc-china (len type)
@@ -582,13 +583,13 @@ Return the length of resulting text."
 (defun post-read-decode-euc-tw (len)
   (post-read-decode-fixed-euc-china len 'tw))
 
-(make-coding-system 'fixed-euc-cn 5 ?W "Coding System for fixed EUC Chinese-gb2312")
-(put 'fixed-euc-cn 'pre-write-conversion 'pre-write-encode-euc-cn)
-(put 'fixed-euc-cn 'post-read-conversion 'post-read-decode-euc-cn)
+(make-coding-system 'fixed-euc-cn 0 ?W "Coding System for fixed EUC Chinese-gb2312")
+(coding-system-put 'fixed-euc-cn 'pre-write-conversion 'pre-write-encode-euc-cn)
+(coding-system-put 'fixed-euc-cn 'post-read-conversion 'post-read-decode-euc-cn)
 
-(make-coding-system 'fixed-euc-tw 5 ?W "Coding System for fixed EUC Chinese-cns11643")
-(put 'fixed-euc-tw 'pre-write-conversion 'pre-write-encode-euc-tw)
-(put 'fixed-euc-tw 'post-read-conversion 'post-read-decode-euc-tw)
+(make-coding-system 'fixed-euc-tw 0 ?W "Coding System for fixed EUC Chinese-cns11643")
+(coding-system-put 'fixed-euc-tw 'pre-write-conversion 'pre-write-encode-euc-tw)
+(coding-system-put 'fixed-euc-tw 'post-read-conversion 'post-read-decode-euc-tw)
 \f
 (defsubst comm-format-u32c (uint32c)
   (let ((h0 (car uint32c))
@@ -689,10 +690,6 @@ v means 8-bit vector."
      'progn
      result)))
 \f
-(if (not (fboundp 'string-as-multibyte))
-    (defsubst string-as-multibyte (str)
-      str))
-
 ;; Do not move the point, leave it where it was.
 (defun comm-accept-process-output (proc)
   (let ((p (point)))

diff --git a/egg-edep.el b/egg-edep.el
new file mode 100644 (file)
index 0000000..2d1e3d9
--- /dev/null
+++ b/egg-edep.el
@@ -0,0 +1,44 @@
+;; This file serves Emacs version dependent definitions
+
+(if (and (fboundp 'set-buffer-multibyte)
+        (subrp (symbol-function 'set-buffer-multibyte)))
+    ;; Emacs 20.3
+    (progn
+      (defun egg-char-bytes (x) 1)
+      (defun egg-charset-bytes (x) 1)
+      (defun egg-char-bytes-at (str pos) 1)
+      (defun egg-chars-in-period (str pos len) len)
+      (defalias 'egg-string-to-vector 'identity)
+      (defalias 'egg-string-to-char-at 'aref)
+      )
+  ;; Emacs 20.2
+  (defun set-buffer-multibyte (flag)
+    (setq enable-multibyte-characters flag))
+  (defalias 'string-as-unibyte 'identity)
+  (defalias 'string-as-multibyte 'identity)
+  (defalias 'coding-system-put 'put)
+
+  (defalias 'egg-char-bytes 'char-bytes)
+  (defalias 'egg-charset-bytes 'charset-bytes)
+  (defun egg-char-bytes-at (str pos)
+    (char-bytes (egg-string-to-char-at str pos)))
+  (defun egg-chars-in-period (str pos len)
+    (chars-in-string (substring str pos (+ pos len))))
+  (defalias 'egg-string-to-vector 'string-to-vector)
+  (defun egg-string-to-char-at (str pos)
+    (let ((c (aref str pos)))
+      (if (or (< c ?\200)
+             (>= c ?\240)
+             (>= (1+ pos) (length str))
+             (< (aref str (1+ pos)) ?\240))
+         c
+       (string-match "[\240-\377]+" str (1+ pos))
+       (string-to-char (substring str pos (match-end 0))))))
+  )
+
+;; Elisp bug fix
+
+(defun egg-next-single-property-change (pos prop &optional object limit)
+  (min limit (next-single-property-change pos prop object (1+ limit))))
+
+(provide 'egg-edep)

diff --git a/egg-mlh.el b/egg-mlh.el
index 36ad108..1c9aefe 100644 (file)
--- a/egg-mlh.el
+++ b/egg-mlh.el
@@ -43,7 +43,7 @@ Or else, execute command that space-bar invokes usually."
   (let ((henkan-begin nil)
         (inhibit-henkan t)
         (its-disable-special-action t))
-    (if (null (assoc "Japanese" egg-conversion-backend-alist))
+    (if (null (assq 'Japanese egg-conversion-backend-alist))
        (progn
           (setq egg-mode-preference nil)
           (activate-input-method (concat "japanese-egg-" mlh-default-backend)))

diff --git a/egg.el b/egg.el
index caec255..601c981 100644 (file)
--- a/egg.el
+++ b/egg.el
@@ -29,10 +29,12 @@
 ;;; Commentary:
 
 ;;; Code:
+(require 'egg-edep)
+
 (defvar egg-mode-preference t
   "Non-nil if modefull.")
 
-(defvar egg-default-language "Japanese")
+(defvar egg-default-language)
 (defvar egg-last-method-name)
 (make-variable-buffer-local 'egg-last-method-name)
 
@@ -53,12 +55,13 @@
        (setq describe-current-input-method-function nil)
        (setq current-input-method nil)
        (use-local-map (keymap-parent (current-local-map)))
+       (remove-hook 'input-method-activate-hook 'its-set-mode-line-title t)
        (force-mode-line-update))
     ;; Turn on
     (if (null (string= (car arg) egg-last-method-name))
-       (let ((backend egg-conversion-backend))
+       (progn
          (funcall (nth 1 arg))
-         (egg-set-conversion-backend backend (list its-current-language) t)
+         (egg-set-conversion-backend nil (list its-current-language) t)
          (setq egg-default-language its-current-language)))
     (setq egg-last-method-name (car arg))
     (use-local-map (if egg-mode-preference
@@ -66,7 +69,8 @@
                     (egg-modeless-map)))
     (setq inactivate-current-input-method-function 'egg-mode)
     (setq describe-current-input-method-function 'egg-help)
-    (add-hook 'input-method-activate-hook 'its-set-mode-line-title)))
+    (make-local-hook 'input-method-activate-hook)
+    (add-hook 'input-method-activate-hook 'its-set-mode-line-title nil t)))
 
 (defun egg-modefull-map ()
   "Generate modefull keymap for EGG mode."  
@@ -95,81 +99,92 @@
 (defvar egg-mark-list nil)
 (defvar egg-suppress-marking nil)
 
-(defun egg-set-face (beg eng face)
+(defun egg-set-face (beg eng face &optional object)
+  (put face 'face face)
   (add-text-properties beg eng
-                      (list 'face face
-                            'egg-face face
-                            'modification-hooks '(egg-mark-modification))))
+                      (list 'category face
+                            'egg-face t
+                            'modification-hooks '(egg-mark-modification))
+                      object))
 
 (defun egg-mark-modification (beg end)
   (if (and (null egg-suppress-marking)
           (or (get-text-property beg 'egg-face)
-               (setq beg (next-single-property-change beg 'egg-face)))
-           (or (get-text-property (1- end) 'egg-face)
-               (setq end (previous-single-property-change end 'egg-face)))
-           (< beg end))
+              (setq beg (next-single-property-change beg 'egg-face)))
+          (or (get-text-property (1- end) 'egg-face)
+              (setq end (previous-single-property-change end 'egg-face)))
+          (< beg end))
       (let ((list egg-mark-list)
-            (found 0)
-            pair mb me b e)
+           (found 0)
+           pair mb me b e)
        (add-hook 'post-command-hook 'egg-redraw-face t)
-        (setq list egg-mark-list)
+       (setq list egg-mark-list)
        (while (and list (< found 2))
-          (setq pair (car list)
-                list (cdr list)
-                mb (car pair)
-                me (cdr pair)
+         (setq pair (car list)
+               list (cdr list)
+               mb (car pair)
+               me (cdr pair)
                b (marker-position mb)
                e (marker-position me))
-          (cond
-           ;; no overwrapping -- SKIP
-           ((or (null (eq (marker-buffer mb) (current-buffer)))
-                (or (> beg e) (< end b))))
-           ;; completely included
-           ((and (>= beg b) (<= end e))
-            (setq found 3))
-           ;; partially overwrapping
-           (t
+         (cond
+          ;; no overwrapping -- SKIP
+          ((or (null (eq (marker-buffer mb) (current-buffer)))
+               (or (> beg e) (< end b))))
+          ;; completely included
+          ((and (>= beg b) (<= end e))
+           (setq found 3))
+          ;; partially overwrapping
+          (t
            (set-marker mb nil)
            (set-marker me nil)
-            (setq egg-mark-list (delete pair egg-mark-list)
-                  beg (min beg b)
-                  end (max end e)
-                  found (1+ found)))))
-        (if (< found 3)
-            (progn
-              (setq b (make-marker)
-                    e (make-marker)
-                    egg-mark-list (cons (cons b e) egg-mark-list))
-              (set-marker b beg)
-              (set-marker e end))))))
+           (setq egg-mark-list (delete pair egg-mark-list)
+                 beg (min beg b)
+                 end (max end e)
+                 found (1+ found)))))
+       (if (< found 3)
+           (progn
+             (setq b (make-marker)
+                   e (make-marker)
+                   egg-mark-list (cons (cons b e) egg-mark-list))
+             (set-marker b beg)
+             (set-marker e end))))))
 
 (defun egg-redraw-face ()
   (let ((inhibit-read-only t)
+       (inhibit-point-motion-hooks t)
        (egg-suppress-marking t)
        (list egg-mark-list)
+       (org-buffer (current-buffer))
+       (org-point (point))
        mb me b e p)
     (setq egg-mark-list nil)
     (remove-hook 'post-command-hook 'egg-redraw-face)
-    (save-excursion
-      (while list
-       (setq mb (car (car list))
-             me (cdr (car list))
-             list (cdr list))
-       (when (marker-buffer mb)
-         (set-buffer (marker-buffer mb))
-         (let ((before-change-functions nil) (after-change-functions nil))
-           (save-restriction
-             (widen)
-             (setq b (max mb (point-min))
-                   e (min me (point-max)))
-             (set-marker mb nil)
-             (set-marker me nil)
-             (while (< b e)
-               (if (null (get-text-property b 'egg-face))
-                   (setq b (next-single-property-change b 'egg-face nil e)))
-               (setq p (next-single-property-change b 'egg-face nil e))
-               (put-text-property b p 'face (get-text-property b 'egg-face))
-               (setq b p)))))))))
+    (while list
+      (setq mb (car (car list))
+           me (cdr (car list))
+           list (cdr list))
+      (when (marker-buffer mb)
+       (set-buffer (marker-buffer mb))
+       (let ((before-change-functions nil) (after-change-functions nil))
+         (save-restriction
+           (widen)
+           (setq b (max mb (point-min))
+                 e (min me (point-max)))
+           (set-marker mb nil)
+           (set-marker me nil)
+           (while (< b e)
+             (if (null (get-text-property b 'egg-face))
+                 (setq b (next-single-property-change b 'egg-face nil e)))
+             (setq p (next-single-property-change b 'egg-face nil e))
+             (when (< b p)
+               (goto-char b)
+               (setq str (buffer-substring b p))
+               (delete-region b p)
+               (remove-text-properties 0 (- p b) '(face) str)
+               (insert str)
+               (setq b p)))))))
+    (set-buffer org-buffer)
+    (goto-char org-point)))
 \f
 (defun egg-hinshi-select ()
  (menudiag-select ; Should generate at initialization time
@@ -254,10 +269,6 @@
 (defun egg-kill-emacs-function ()
   (egg-finalize-backend))
 
-(if (not (fboundp 'set-buffer-multibyte))
-(defun set-buffer-multibyte (flag)
-  (setq enable-multibyte-characters flag)))
-
 (provide 'egg)
 
 ;;; egg.el ends here

diff --git a/egg/canna.el b/egg/canna.el
index 736302d..80f04b6 100644 (file)
--- a/egg/canna.el
+++ b/egg/canna.el
@@ -29,7 +29,9 @@
 
 ;;; Code:
 
-(defconst canna-support-languages '("Japanese"))
+(require 'egg-edep)
+
+(defconst canna-support-languages '(Japanese))
 
 (eval-when-compile
   (defmacro CANNA-const (c)
@@ -131,7 +133,7 @@
     "hojomwd"
     "hojoswd"
     "bushu"
-    ("user")
+    "user"
     )
   "Dictionary specification of CANNA.")
 

diff --git a/egg/sj3.el b/egg/sj3.el
index 33abd34..865f42b 100644 (file)
--- a/egg/sj3.el
+++ b/egg/sj3.el
@@ -29,7 +29,9 @@
 
 ;;; Code:
 
-(defconst sj3-support-languages '("Japanese"))
+(require 'egg-edep)
+
+(defconst sj3-support-languages '(Japanese))
 
 (eval-when-compile
   (defmacro SJ3-const (c)

diff --git a/egg/wnn.el b/egg/wnn.el
index 4ada308..1e8330d 100644 (file)
--- a/egg/wnn.el
+++ b/egg/wnn.el
@@ -30,12 +30,14 @@
 ;;; Commentary:
 
 ;;; Code:
+
+(require 'egg-edep)
+
 (defgroup wnn nil
   "Wnn interface for Tamagotchy"
   :group 'egg)
 
-(defconst wnn-support-languages
-  '("Japanese" "Chinese-GB" "Chinese-CNS" "Korean"))
+(defconst wnn-support-languages '(Japanese Chinese-GB Chinese-CNS Korean))
 
 (eval-when-compile
   (defmacro WNN-const (c)
@@ -166,18 +168,17 @@
 
 ;; 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 wnn-jport "Wnn"  fixed-euc-jp wnn-jserver)
-    ("Chinese-GB"  "zh_CN" cserver wnn-cport "cWnn" fixed-euc-cn wnn-cserver)
-    ("Chinese-CNS" "zh_TW" tserver wnn-tport "tWnn" fixed-euc-tw wnn-tserver)
-    ("Korean"      "ko_KR" kserver wnn-kport "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))))
+  ;; language    locale  server  port     stream coding-system hostname
+  '((Japanese    "ja_JP" jserver wnn-jport "Wnn"  fixed-euc-jp wnn-jserver)
+    (Chinese-GB  "zh_CN" cserver wnn-cport "cWnn" fixed-euc-cn wnn-cserver)
+    (Chinese-CNS "zh_TW" tserver wnn-tport "tWnn" fixed-euc-tw wnn-tserver)
+    (Korean      "ko_KR" kserver wnn-kport "kWnn" fixed-euc-kr wnn-kserver)))
+
+(defsubst wnn-server-get-info (lang)
+  (assq (or lang its-current-language) wnn-server-info-list))
+
+(defsubst wnn-server-language (info)
+  (car info))
 
 (defsubst wnn-server-locale (info)
   (nth 1 info))
@@ -206,7 +207,7 @@
 (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* ((server-info (wnn-get-server-info language))
+  (let* ((server-info (wnn-server-get-info language))
         (env (wnn-get-environment server-info dic-set reverse))
         (result (wnnrpc-renbunsetsu-conversion env yomi
                                                (WNN-const BUN_SENTOU) "")))
@@ -358,29 +359,88 @@ Return the list of bunsetsu."
 (defvar wnn-sticky-environment-flag nil
   "*Flag which specifies sticky environment.")
 
-(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))))
+(defmacro wnn-for-each-environment (lang env &rest body)
+  `(let* ((server-info (wnn-server-get-info ,lang))
+        (server-type (wnn-server-type server-info))
+        (env-list wnn-environments))
+    (if server-type
+       (while env-list
+         (let ((,env (car env-list)))
+           ,@body)
+         (setq env-list (cdr env-list))))))
+
+(defun wnn-fini (lang &optional save-only)
+  (let* ((server-info (wnn-server-get-info lang))
+        (server-type (wnn-server-type server-info))
+        (l wnn-environments)
+        new-env-list del-list env proc)
+    (if server-type
+       (progn
+         (message "%s \e$B$NIQEY>pJs!&<-=q>pJs$rB`Hr$7$F$$$^$9\e(B"
+                  (wnn-server-stream-name server-info))
+         (while l
+           (setq env (car l))
+           (if (eq (wnnenv-get-server-type env) server-type)
+               (condition-case nil
+                   (progn
+                     (wnn-save-dictionaries env)
+                     (if (null save-only)
+                         (progn
+                           (setq del-list (nconc del-list (list env)))
+                           (if wnn-sticky-environment-flag
+                               (wnnrpc-make-env-sticky env)
+                             (wnnrpc-make-env-unsticky env))
+                           (wnnrpc-disconnect env))))
+                 (error nil))
+             (setq new-env-list (nconc new-env-list (list env))))
+           (setq l (cdr l)))
+         (message "%s \e$B$NIQEY>pJs!&<-=q>pJs$rB`Hr$7$^$7$?\e(B"
+                  (wnn-server-stream-name server-info))
+         (if (null save-only)
+             (progn
+               (setq proc (and del-list (wnnenv-get-proc (car del-list))))
+               (if (and proc (eq (process-status proc) 'open))
+                   (progn
+                     (wnnrpc-close proc)
+                     (kill-buffer (process-buffer proc))))
+               (setq wnn-environments new-env-list)))))))
+
+(defun wnn-close (lang)
+  (interactive (list (wnn-read-active-lang)))
+  (or (listp lang)
+      (setq lang (list lang)))
+  (while lang
+    (wnn-fini (car lang))
+    (setq lang (cdr lang))))
+
+(defun wnn-dictionary-save (lang)
+  (interactive (list (wnn-read-active-lang)))
+  (or (listp lang)
+      (setq lang (list lang)))
+  (while lang
+    (wnn-fini (car lang) t)
+    (setq lang (cdr lang))))
+
+(defun wnn-read-active-lang ()
+  (let ((completion-ignore-case t)
+       (env wnn-environments)
+       langs server server-list)
+    (while env
+      (setq server (wnnenv-get-server-type (car env))
+           env (cdr env))
+      (if (null (member server server-list))
+         (setq server-list (cons server server-list))))
+    (setq langs (delete nil
+                       (mapcar (lambda (info)
+                                 (if (memq (wnn-server-type info) server-list)
+                                     (wnn-server-language info)))
+                               wnn-server-info-list)))
+    (if (<= (length langs) 1)
+       langs
+      (setq langs (cons (cons "All" langs)
+                       (mapcar (lambda (lang) (cons (symbol-name lang) lang))
+                               langs)))
+      (cdr (assoc (completing-read "language? " langs nil t) langs)))))
 \f
 ;;
 (defun wnn-comm-sentinel (proc reason) ; assume it is close
@@ -426,7 +486,6 @@ Return the list of bunsetsu."
       (setq hostname (car hostname-list)
            hostname-list (cdr hostname-list))
       (message msg-form server-type hostname)
-      (sit-for 0)
       (condition-case result
          (setq proc (open-network-stream (wnn-server-stream-name server-info)
                                          buf
@@ -476,7 +535,7 @@ Return the list of bunsetsu."
          ["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]
+;        ["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])
@@ -493,7 +552,7 @@ Return the list of bunsetsu."
          ["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]
+;        ["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]))
@@ -839,14 +898,41 @@ REVERSE specifies reverse conversion, if non nil."
 ;(defun wnn-set-conversion-mode ()
 ;  (jl-set-environment))
 
-(defun wnn-save-dictionaries ()
-  (for-each-environment
-   js-dic-list
-   (while (< i count)
-     dic => id
-     js-file-write
-     hindo => id
-     js-file-write)))
+(defsubst wnn-dicinfo-entry (info) (aref info 0))
+(defsubst wnn-dicinfo-id (info freq) (aref info (+ 1 freq)))
+(defsubst wnn-dicinfo-mode (info freq) (aref info (+ 3 freq)))
+(defsubst wnn-dicinfo-enable (info) (aref info 5))
+(defsubst wnn-dicinfo-nice (info) (aref info 6))
+(defsubst wnn-dicinfo-reverse (info) (aref info 7))
+(defsubst wnn-dicinfo-comment (info) (aref info 8))
+(defsubst wnn-dicinfo-name (info freq) (aref info (+ 9 freq)))
+(defsubst wnn-dicinfo-passwd (info freq) (aref info (+ 11 freq)))
+(defsubst wnn-dicinfo-type (info) (aref info 13))
+(defsubst wnn-dicinfo-words (info) (aref info 14))
+(defsubst wnn-dicinfo-local (info freq) (aref info (+ 15 freq)))
+
+(defun wnn-save-dictionaries (env)
+  (let ((dic-list (wnnrpc-get-dictionary-list-with-environment env))
+       (result 0) info freq)
+    (while (and dic-list
+               (>= result 0))
+      (setq info (car dic-list)
+           dic-list (cdr dic-list)
+           freq 0)
+      (while (<= freq 1)
+       (if (and (> (wnn-dicinfo-id info freq) 0)
+                (= (wnn-dicinfo-mode info freq) 0))
+           (if (= (wnn-dicinfo-local info freq) 1)
+               (setq result (wnnrpc-write-file env
+                                               (wnn-dicinfo-id info freq)
+                                               (wnn-dicinfo-name info freq)))
+             (message "WNN: remote dictionary (%s) not supported yet"
+                      (wnn-dicinfo-name info freq))
+             (ding)
+             (sit-for 1)))
+       (if (< result 0)
+           (wnnrpc-disconnect env))
+       (setq freq (1+ freq))))))
 
 (defun wnn-version (proc)
   "Return version number string of WNN server."

diff --git a/egg/wnnrpc.el b/egg/wnnrpc.el
index 723453a..ee35e72 100644 (file)
--- a/egg/wnnrpc.el
+++ b/egg/wnnrpc.el
@@ -38,60 +38,60 @@
     "Macro for WNN constants."
     (cond ((eq c 'JS_VERSION)             0)
          ((eq c 'JS_OPEN)                1)
-          ((eq c 'JS_CLOSE)               3)
-          ((eq c 'JS_CONNECT)             5)
-          ((eq c 'JS_DISCONNECT)          6)
-          ((eq c 'JS_ENV_EXIST)           7)
-          ((eq c 'JS_ENV_STICKY)          8)
-          ((eq c 'JS_ENV_UNSTICKY)        9)
-          ((eq c 'JS_KANREN)             17)
-          ((eq c 'JS_KANTAN_SHO)         18)
-          ((eq c 'JS_KANZEN_SHO)         19)
-          ((eq c 'JS_KANTAN_DAI)         20)
-          ((eq c 'JS_KANZEN_DAI)         21)
-          ((eq c 'JS_HINDO_SET)          24)
-          ((eq c 'JS_DIC_ADD)            33)
-          ((eq c 'JS_DIC_DELETE)         34)
-          ((eq c 'JS_DIC_USE)            35)
-          ((eq c 'JS_DIC_LIST)           36)
-          ((eq c 'JS_DIC_INFO)           37)
-          ((eq c 'JS_FUZOKUGO_SET)       41)
-          ((eq c 'JS_FUZOKUGO_GET)       48)
-          ((eq c 'JS_WORD_ADD)           49)
-          ((eq c 'JS_WORD_DELETE)        50)
-          ((eq c 'JS_WORD_SEARCH)        51)
-          ((eq c 'JS_WORD_SEARCH_BY_ENV) 52)
-          ((eq c 'JS_WORD_INFO)          53)
-          ((eq c 'JS_WORD_COMMENT_SET)   54)
-          ((eq c 'JS_PARAM_SET)          65)
-          ((eq c 'JS_PARAM_GET)          66)
-          ((eq c 'JS_MKDIR)              81)
-          ((eq c 'JS_ACCESS)             82)
-          ((eq c 'JS_WHO)                83)
-          ((eq c 'JS_ENV_LIST)           85)
-          ((eq c 'JS_FILE_LIST_ALL)      86)
-          ((eq c 'JS_DIC_LIST_ALL)       87)
-          ((eq c 'JS_FILE_READ)          97)
-          ((eq c 'JS_FILE_WRITE)         98)
-          ((eq c 'JS_FILE_SEND)          99)
-          ((eq c 'JS_FILE_RECEIVE)      100)
-          ((eq c 'JS_HINDO_FILE_CREATE) 101)
-          ((eq c 'JS_DIC_FILE_CREATE)   102)
-          ((eq c 'JS_FILE_REMOVE)       103)
-          ((eq c 'JS_FILE_LIST)         104)
-          ((eq c 'JS_FILE_INFO)         105)
-          ((eq c 'JS_FILE_LOADED)       106)
-          ((eq c 'JS_FILE_LOADED_LOCAL) 107)
-          ((eq c 'JS_FILE_DISCARD)      108)
-          ((eq c 'JS_FILE_COMMENT_SET)  109)
-          ((eq c 'JS_FILE_PASSWORD)     110)
-          ((eq c 'JS_FILE_STAT)         111)
-          ((eq c 'JS_KILL)              112)
-          ((eq c 'JS_HINSI_LIST)        114)
-          ((eq c 'JS_HINSI_NAME)        115)
-          ((eq c 'JS_HINSI_NUMBER)      116)
-          ((eq c 'JS_HINSI_DICTS)       117)
-          ((eq c 'JS_HINSI_TABLE_SET)   118)
+         ((eq c 'JS_CLOSE)               3)
+         ((eq c 'JS_CONNECT)             5)
+         ((eq c 'JS_DISCONNECT)          6)
+         ((eq c 'JS_ENV_EXIST)           7)
+         ((eq c 'JS_ENV_STICKY)          8)
+         ((eq c 'JS_ENV_UNSTICKY)        9)
+         ((eq c 'JS_KANREN)             17)
+         ((eq c 'JS_KANTAN_SHO)         18)
+         ((eq c 'JS_KANZEN_SHO)         19)
+         ((eq c 'JS_KANTAN_DAI)         20)
+         ((eq c 'JS_KANZEN_DAI)         21)
+         ((eq c 'JS_HINDO_SET)          24)
+         ((eq c 'JS_DIC_ADD)            33)
+         ((eq c 'JS_DIC_DELETE)         34)
+         ((eq c 'JS_DIC_USE)            35)
+         ((eq c 'JS_DIC_LIST)           36)
+         ((eq c 'JS_DIC_INFO)           37)
+         ((eq c 'JS_FUZOKUGO_SET)       41)
+         ((eq c 'JS_FUZOKUGO_GET)       48)
+         ((eq c 'JS_WORD_ADD)           49)
+         ((eq c 'JS_WORD_DELETE)        50)
+         ((eq c 'JS_WORD_SEARCH)        51)
+         ((eq c 'JS_WORD_SEARCH_BY_ENV) 52)
+         ((eq c 'JS_WORD_INFO)          53)
+         ((eq c 'JS_WORD_COMMENT_SET)   54)
+         ((eq c 'JS_PARAM_SET)          65)
+         ((eq c 'JS_PARAM_GET)          66)
+         ((eq c 'JS_MKDIR)              81)
+         ((eq c 'JS_ACCESS)             82)
+         ((eq c 'JS_WHO)                83)
+         ((eq c 'JS_ENV_LIST)           85)
+         ((eq c 'JS_FILE_LIST_ALL)      86)
+         ((eq c 'JS_DIC_LIST_ALL)       87)
+         ((eq c 'JS_FILE_READ)          97)
+         ((eq c 'JS_FILE_WRITE)         98)
+         ((eq c 'JS_FILE_SEND)          99)
+         ((eq c 'JS_FILE_RECEIVE)      100)
+         ((eq c 'JS_HINDO_FILE_CREATE) 101)
+         ((eq c 'JS_DIC_FILE_CREATE)   102)
+         ((eq c 'JS_FILE_REMOVE)       103)
+         ((eq c 'JS_FILE_LIST)         104)
+         ((eq c 'JS_FILE_INFO)         105)
+         ((eq c 'JS_FILE_LOADED)       106)
+         ((eq c 'JS_FILE_LOADED_LOCAL) 107)
+         ((eq c 'JS_FILE_DISCARD)      108)
+         ((eq c 'JS_FILE_COMMENT_SET)  109)
+         ((eq c 'JS_FILE_PASSWORD)     110)
+         ((eq c 'JS_FILE_STAT)         111)
+         ((eq c 'JS_KILL)              112)
+         ((eq c 'JS_HINSI_LIST)        114)
+         ((eq c 'JS_HINSI_NAME)        115)
+         ((eq c 'JS_HINSI_NUMBER)      116)
+         ((eq c 'JS_HINSI_DICTS)       117)
+         ((eq c 'JS_HINSI_TABLE_SET)   118)
 
          ((eq c 'JLIB_VERSION) 16387)  ; 0x4003
 
@@ -106,7 +106,7 @@
          ((eq c 'WNN_MAX_FILE_OF_AN_ENV)  60))))
 
 (defconst wnnrpc-error-message
-  '(("Japanese" .
+  '((Japanese .
      [
       nil
       "\e$B%U%!%$%k$,B8:_$7$^$;$s\e(B"
@@ -226,7 +226,7 @@
       "\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" .
+    (Chinese-GB .
      [
       nil
       "\e$AND<~2;4fTZ\e(B"
@@ -346,7 +346,7 @@
       "\e$AWV5d5DF56HND<~C;SP\e(B"
       "password\e$A5DND<~C;SP44=(3v@4\e(B"
       ])
-    ("Chinese-CNS" .
+    (Chinese-CNS .
      [
       nil
       "\e$(GEFG5DbGtGc\e(B"
@@ -466,7 +466,7 @@
       "\e$(GGsL(N{s"PyEFG5JtH4\e(B"
       "password\e$(GN{EFG5JtH4^6PzExKt\e(B"
       ])
-    ("Korean" .
+    (Korean .
      [
       nil
       "\e$(CH-@O@L\e(B \e$(CA8@gGOAv\e(B \e$(C>J=@4O4Y\e(B"
@@ -590,10 +590,11 @@
 
 (defun wnnrpc-get-error-message (errno)
   "Return error message string specified by 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))))
+  (let ((msg (cdr (or (assoc egg-default-language wnnrpc-error-message)
+                     (assoc its-current-language wnnrpc-error-message)
+                     (assoc 'Japanese wnnrpc-error-message)))))
+    (or (and (< errno (length msg)) (aref msg errno))
+       (format "#%d" errno))))
 
 (defmacro wnnrpc-call-with-environment (e vlist send-expr &rest receive-exprs)
   (let ((v (append
@@ -1353,7 +1354,7 @@ HINSHI and FUZOKU are information of preceding bunsetsu."
            (concat (system-name)
                    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0") 0 16)))
       (comm-call-with-proc proc (result)
-        (comm-format (u U U U s) (wnn-const JS_FILE_LOADED_LOCAL)
+       (comm-format (u U U U s) (wnn-const JS_FILE_LOADED_LOCAL)
                     time dev inode padded-hostname)
        (comm-unpack (u) result)
        result))))

diff --git a/its-keydef.el b/its-keydef.el
index 9372491..5e3a835 100644 (file)
--- a/its-keydef.el
+++ b/its-keydef.el
@@ -5,7 +5,7 @@
 (make-variable-buffer-local 'its-zhuyin)
 (put 'its-zhuyin 'permanent-local t)
 
-(eval-when (eval compile)
+(eval-and-compile
   (defun its-make-select-func (key1 key2 func file map &optional zhuyin)
     (setq func (intern (concat "its-select-" (symbol-name func)))
          file (intern (concat "its/" (symbol-name file)))
@@ -23,31 +23,45 @@
              (its-put-cursor t))
             ((egg-get-bunsetsu-info (point))
              (egg-exit-conversion)))
-           (setq its-current-select-func ',func)
-           (setq its-current-map ,map)
-           (if (its-get-language its-current-map)
-               (setq its-current-language (its-get-language its-current-map)))
+           (setq its-current-select-func ',func
+                 its-current-map ',map)
+           (if (its-get-language ,map)
+               (setq its-current-language (its-get-language ,map)))
            ,(if zhuyin `(setq its-zhuyin ,(eq zhuyin 'T)))
            (if (null mode-line-unchange)
                (its-set-mode-line-title)))))
-     `(define-key map
-       (if fence
-           ,(concat "\e" key2)
-         ,(concat "\C-x\C-m" key1))
-       ',func))))
+     `(,func ,(concat "\C-x\C-m" key1) ,(concat "\e" key2)))))
 
 (defmacro its-do-list-make-select-func (list)
-  (eval-when (eval compile)
-    (let (funcs keydefs pair)
-      (while list
-       (setq pair (apply 'its-make-select-func (car list)))
-       (setq funcs (cons (car pair) funcs)
-             keydefs (cons (cdr pair) keydefs))
-       (setq list (cdr list)))
-      `(progn
-        ,@funcs
-        (defun its-define-select-keys (map &optional fence)
-          ,@keydefs)))))
+  (let (funcs keydefs pair)
+    (while list
+      (setq pair (apply 'its-make-select-func (car list))
+           funcs (cons (car pair) funcs)
+           keydefs (cons (cdr pair) keydefs)
+           list (cdr list)))
+    `(progn
+       ,@funcs
+       (defvar its-define-select-key-list ',keydefs))))
+
+(defmacro its-add-select-funcs (list)
+  (let (funcs keydefs pair)
+    (while list
+      (setq pair (apply 'its-make-select-func (car list))
+           funcs (cons (car pair) funcs)
+           keydefs (cons (cdr pair) keydefs)
+           list (cdr list)))
+    `(progn
+       ,@funcs
+       (setq its-define-select-key-list
+            (append ',keydefs its-define-select-key-list)))))
+
+(defun its-define-select-keys (map &optional fence)
+  (let ((key-list its-define-select-key-list))
+    (while key-list
+      (define-key map (nth 1 (car key-list)) (car (car key-list)))
+      (if fence
+         (define-key map (nth 2 (car key-list)) (car (car key-list))))
+      (setq key-list (cdr key-list)))))
 
 (its-do-list-make-select-func
  (("Q"    "Q"    upcase               ascii    up)

diff --git a/its.el b/its.el
index 4aff32b..b01b06b 100644 (file)
--- a/its.el
+++ b/its.el
@@ -31,6 +31,7 @@
 ;;; Code:
 
 (require 'cl)
+(require 'egg-edep)
 
 (defvar its-current-map nil)
 (make-variable-buffer-local 'its-current-map)
@@ -187,8 +188,7 @@
 ;;
 ;;
 
-(eval-when (eval load compile)
-  (require 'its-keydef))
+(require 'its-keydef)
 
 (defvar its-mode-map
   (let ((map (make-sparse-keymap))
@@ -228,13 +228,15 @@
     (define-key map "\M-k" 'its-katakana)
     (define-key map "\M-<" 'its-hankaku)
     (define-key map "\M->" 'its-zenkaku)
-    (its-define-select-keys map t)
     map)
   "Keymap for ITS mode.")
 
+(fset 'its-mode-map its-mode-map)
+
 (defvar its-fence-open  "|" "*\e$B%U%'%s%9$N;OE@$r<($9J8;zNs\e(B (1 \e$BJ8;z0J>e\e(B)")
 (defvar its-fence-close "|" "*\e$B%U%'%s%9$N=*E@$r<($9J8;zNs\e(B (1 \e$BJ8;z0J>e\e(B)")
 (defvar its-fence-face  nil "*\e$B%U%'%s%9I=<($KMQ$$$k\e(B face \e$B$^$?$O\e(B nil")
+(defvar its-fence-invisible  nil)
 
 (defconst its-setup-fence-before-insert-SYL nil)
 
@@ -245,11 +247,9 @@
     (if face (cdr face) its-fence-face)))
 
 (defun its-put-cursor (cursor)
-  (let ((p (point))
-       (map (copy-keymap its-mode-map)))
-    (its-define-select-keys map)
+  (let ((p (point)))
     (insert "!")
-    (add-text-properties p (point) (list 'local-map map
+    (add-text-properties p (point) (list 'local-map 'its-mode-map
                                         'read-only t
                                         'invisible t
                                         'intangible 'its-part-2
@@ -275,17 +275,18 @@
   (let ((open-props '(its-start t intangible its-part-1))
        (close-props '(rear-nonsticky t its-end t intangible its-part-2))
        (p (point)) p1)
-    ;; Put open-fence before inhibit-read-only to detect read-nly
+    ;; Put open-fence before inhibit-read-only to detect read-only
     (insert its-fence-open)
     (let ((inhibit-read-only t))
       (setq p1 (point))
       (add-text-properties p p1 open-props)
       (insert its-fence-close)
       (add-text-properties p1 (point) close-props)
-      (if its-fence-face
+      (if its-fence-invisible
          (put-text-property p (point) 'invisible t))
       (put-text-property p (point) 'read-only t)
       (goto-char p1)
+      (its-define-select-keys its-mode-map t)
       (its-put-cursor t))))
 
 (defun its-start (key)
@@ -318,7 +319,7 @@
     (its-input syl key)))
 
 (defun its-initial-ISYL ()
-  (its-get-start-state its-current-map))
+  (its-get-start-state (symbol-value its-current-map)))
 
 (defun its-make-VSYL (keyseq)
   (cons keyseq (length keyseq)))
@@ -516,19 +517,21 @@
        cursor)
     (if (null syl)
        (setq syl (its-initial-ISYL)))
-    (while (and syl (< i len))
-      (setq cursor (its-state-machine syl (aref keyseq i) emit))
-      (cond
-       ((eq cursor 'its-keyseq-test-failed)
-       (setq syl nil))
-       (cursor
-       (setq syl (its-initial-ISYL)))
-       (t
-       its-latest-SYL))
-      (setq i (1+ i)))
-    (if (and syl eol)
-       (setq cursor (its-state-machine syl -1 emit)))
-    (not (eq cursor 'its-keyseq-test-failed))))
+    (if (numberp (cdr syl))
+       nil
+      (while (and syl (< i len))
+       (setq cursor (its-state-machine syl (aref keyseq i) emit))
+       (cond
+        ((eq cursor 'its-keyseq-test-failed)
+         (setq syl nil))
+        (cursor
+         (setq syl (its-initial-ISYL)))
+        (t
+         its-latest-SYL))
+       (setq i (1+ i)))
+      (if (and syl eol)
+         (setq cursor (its-state-machine syl -1 emit)))
+      (not (eq cursor 'its-keyseq-test-failed)))))
 \f
 ;;;
 ;;; Name --> map
@@ -551,9 +554,10 @@
 (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)))
+       (let ((its-current-map 'its-temporaly-map)
+            (its-temporaly-map (its-new-map ,name ,indicator ,lang)))
         ,@exprs
-        (setq ,map its-current-map)))
+        (setq ,map its-temporaly-map)))
      (define-its-compiled-map ,map ,doc)))
 
 (defmacro define-its-compiled-map (map doc)
@@ -561,9 +565,10 @@
 
 (defmacro define-its-state-machine-append (map &rest exprs)
   (append
-   `(let ((its-current-map ,map)))
+   `(let ((its-current-map 'its-temporaly-map)
+         (its-temporaly-map ,map)))
    exprs
-   (list `(setq ,map its-current-map))))
+   (list `(setq ,map its-temporaly-map))))
 
 ;;
 ;; Construct State Machine
@@ -583,7 +588,8 @@ Return last state."
 (defun its-goto-state (input &optional initial-state build-if-none)
   (let ((len (length input))
        (i 0)
-       (state (or initial-state (its-get-start-state its-current-map))))
+       (state (or initial-state
+                  (its-get-start-state (symbol-value its-current-map)))))
     (while (< i len)
       (setq state
            (or (its-get-next-state state (aref input i))
@@ -638,6 +644,22 @@ Return last state."
                t))
 \f
 ;;;
+(defun its-set-part-1 (beg end)
+  (let ((inhibit-point-motion-hooks t)
+       (str (buffer-substring beg end)))
+    (goto-char beg)
+    (delete-region beg end)
+    (put-text-property 0 (- end beg) 'intangible 'its-part-1 str)
+    (insert str)))
+
+(defun its-set-part-2 (beg end)
+  (let ((inhibit-point-motion-hooks t)
+       (str (buffer-substring beg end)))
+    (goto-char beg)
+    (delete-region beg end)
+    (put-text-property 0 (- end beg) 'intangible 'its-part-2 str)
+    (insert str)))
+
 (defun its-beginning-of-input-buffer ()
   (interactive)
   (let ((inhibit-read-only t))
@@ -645,7 +667,7 @@ Return last state."
     (if (not (get-text-property (1- (point)) 'its-start))
        (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)
+         (its-set-part-2 begpos (point))
          (goto-char begpos)))
     (its-put-cursor t)))
 
@@ -656,7 +678,7 @@ Return last state."
     (if (not (get-text-property (point) 'its-end))
        (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)
+         (its-set-part-1 (point) endpos)
          (goto-char endpos)))
     (its-put-cursor t)))
 
@@ -690,7 +712,7 @@ Return last state."
   (let ((inhibit-read-only t))
     (delete-region (if (get-text-property (1- (point)) 'its-start)
                       (point)
-                    (previous-single-property-change (1- (point)) 'its-start))
+                    (previous-single-property-change (point) 'its-start))
                   (if (get-text-property (point) 'its-end)
                       (point)
                     (next-single-property-change (point) 'its-end)))
@@ -711,7 +733,7 @@ Return last state."
       (setq syl (get-text-property (1- p) 'its-syl))
       (setq n (1- n)))
     ;; Make SYLs have property of "part 2"
-    (put-text-property p old-point 'intangible 'its-part-2)
+    (its-set-part-2 p old-point)
     (goto-char p)
     (its-put-cursor t)
     (if (> n 0)
@@ -731,7 +753,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 old-point p 'intangible 'its-part-1)
+    (its-set-part-1 old-point p)
     (goto-char p)
     (its-put-cursor t)
     (if (> n 0)
@@ -799,55 +821,53 @@ Return last state."
 
 ;; TODO: killflag
 (defun its-delete-backward-within-SYL (syl n killflag)
-  (let* ((keyseq (its-get-keyseq-syl syl))
-        (len (length keyseq))
-        (p (- (point) (length (its-get-output syl))))
-        (its-current-map (get-text-property (1- (point)) 'its-map))
-        (its-current-language (get-text-property (1- (point)) 'egg-lang))
-        back pp)
-    (if (< n 0)
-       (signal 'args-out-of-range (list (- (point) n) (point))))
-    (if its-delete-by-keystroke
-      (while (null (or (eq p pp) (its-concrete-DSYL-p syl)))
-         (setq pp p)
-         (while (and (setq syl (get-text-property (1- p) 'its-syl))
-                     (its-DSYL-with-back-p syl)
-                     (<= (setq back (- (its-get-kst/t syl))) len)
-                     (> back (- len n))
-                     (equal (substring (its-get-keyseq syl) (- back))
-                            (substring keyseq 0 back)))
-           (setq keyseq (concat (its-get-keyseq-syl syl) keyseq)
-                 len (length keyseq)
-                 p (- p (length (its-get-output syl)))))
-         (if (and (eq p pp) syl (> n len))
-             (setq n (- n len)
-                   keyseq (its-get-keyseq-syl syl)
-                   len (length keyseq)
-                   p (- p (length (its-get-output syl))))))
-      (if (and (> n len) (its-concrete-DSYL-p syl))
-         (setq len 1)))
-    (if (> n len)
-       (setq n (- n len)
-             len 0))
-    (while (and (> n len) (setq syl (get-text-property (1- p) 'its-syl)))
-      (setq n (1- n)
-           p (- p (length (its-get-output syl)))))
-    (if (> n len)
-       (signal 'beginning-of-buffer nil))
-    (delete-region p (point))
-    (cond
-     ((> len n)
-      (its-state-machine-keyseq (substring keyseq 0 (- len n)) 
-                               'its-buffer-ins/del-SYL))
-     ;; Check if empty
-     ((and (get-text-property (1- (point)) 'its-start)
-          (get-text-property (1+ (point)) 'its-end))
-      (its-exit-mode-internal))
-     ((and its-delete-by-keystroke
-          (null (its-concrete-DSYL-p (get-text-property (1- p) 'its-syl))))
-      (its-set-cursor-status 'its-cursor))
-     (t
-      (its-set-cursor-status t)))))
+  (if (let* ((keyseq (its-get-keyseq-syl syl))
+            (len (length keyseq))
+            (p (- (point) (length (its-get-output syl))))
+            (its-current-map (get-text-property (1- (point)) 'its-map))
+            (its-current-language (get-text-property (1- (point)) 'egg-lang))
+            back pp)
+       (if (< n 0)
+           (signal 'args-out-of-range (list (- (point) n) (point))))
+       (if its-delete-by-keystroke
+           (while (null (or (eq p pp) (its-concrete-DSYL-p syl)))
+             (setq pp p)
+             (while (and (setq syl (get-text-property (1- p) 'its-syl))
+                         (its-DSYL-with-back-p syl)
+                         (<= (setq back (- (its-get-kst/t syl))) len)
+                         (> back (- len n))
+                         (equal (substring (its-get-keyseq syl) (- back))
+                                (substring keyseq 0 back)))
+               (setq keyseq (concat (its-get-keyseq-syl syl) keyseq)
+                     len (length keyseq)
+                     p (- p (length (its-get-output syl)))))
+             (if (and (eq p pp) syl (> n len))
+                 (setq n (- n len)
+                       keyseq (its-get-keyseq-syl syl)
+                       len (length keyseq)
+                       p (- p (length (its-get-output syl))))))
+         (if (and (> n len) (its-concrete-DSYL-p syl))
+             (setq len 1)))
+       (if (> n len)
+           (setq n (- n len)
+                 len 0))
+       (while (and (> n len) (setq syl (get-text-property (1- p) 'its-syl)))
+         (setq n (1- n)
+               p (- p (length (its-get-output syl)))))
+       (if (> n len)
+           (signal 'beginning-of-buffer nil))
+       (delete-region p (point))
+       (if (> len n)
+           (its-state-machine-keyseq (substring keyseq 0 (- len n)) 
+                                     'its-buffer-ins/del-SYL)
+         (its-set-cursor-status
+          (if (or (null its-delete-by-keystroke)
+                  (its-concrete-DSYL-p (get-text-property (1- p) 'its-syl)))
+              t
+            'its-cursor)))
+       (and (get-text-property (1- (point)) 'its-start)
+            (get-text-property (1+ (point)) 'its-end)))
+      (its-exit-mode-internal)))
 
 (defun its-transpose-chars (n)
   (interactive "p")
@@ -918,29 +938,39 @@ Return last state."
 
 (defun its-setup-yanked-portion (start end)
   (let ((yank-before (eq (point) end))
-       (max-sisheng (make-char 'chinese-sisheng 127))
-       p syl lang)
-    (remove-text-properties start end '(intangible nil))
-    (egg-separate-languages start end t)
-    (goto-char start)
-    (while (< (point) end)
-      (setq p (point)
-           lang (get-text-property p 'egg-lang))
+       syl lang source no-prop-source len i j l)
+    (setq source (buffer-substring start end)
+         no-prop-source (buffer-substring-no-properties start end)
+         len (length source))
+    (remove-text-properties 0 len '(intangible nil) source)
+    (egg-separate-languages source (get-text-property (1- start) 'egg-lang))
+    (setq i 0)
+    (while (< i len)
+      (setq lang (get-text-property i 'egg-lang source))
       (if (and
-          (or (equal lang "Chinese-GB") (equal lang "Chinese-CNS"))
-          (<= (following-char) max-sisheng)
-          (setq len (egg-chinese-syllable (buffer-substring (point) end))))
-         (goto-char (+ (point) len))
-       (forward-char))
-      (setq syl (buffer-substring-no-properties p (point)))
-      (put-text-property p (point) 'its-syl (cons syl syl))
-      (if its-fence-face
-         (let ((its-current-language (get-text-property p 'egg-lang)))
-           (egg-set-face p (point) (its-get-fence-face)))))
+          (or (eq lang 'Chinese-GB) (eq lang 'Chinese-CNS))
+          (setq l (egg-chinese-syllable source i)))
+         (setq j (+ i l))
+       (setq j (+ i (egg-char-bytes (egg-string-to-char-at source i)))))
+      (setq syl (substring no-prop-source i j))
+      (put-text-property i j 'its-syl (cons syl syl) source)
+      (setq i j))
+    (if its-fence-face
+       (let (its-current-language)
+         (setq i 0)
+         (while (< i len)
+           (setq j (egg-next-single-property-change i 'egg-lang source len)
+                 its-current-language (get-text-property i 'egg-lang source))
+         (egg-set-face i j (its-get-fence-face) source)
+         (setq i j))))
+    (delete-region start end)
     (if yank-before
-       (add-text-properties start end '(read-only t intangible its-part-1))
-      (add-text-properties start end '(read-only t intangible its-part-2))
+       (progn
+         (add-text-properties 0 len '(read-only t intangible its-part-1) source)
+         (insert source))
       (delete-region (point) (1+ (point)))
+      (add-text-properties 0 len '(read-only t intangible its-part-2) source)
+      (insert source)
       (goto-char start)
       (its-put-cursor t))))
 
@@ -949,7 +979,8 @@ Return last state."
   (let ((cursor (get-text-property (point) 'its-cursor)))
     ;; key "END"
     (if (null cursor)
-       (its-input (get-text-property (1- (point)) 'its-syl) -1))
+       (let ((its-current-language (get-text-property (1- (point)) 'egg-lang)))
+         (its-input (get-text-property (1- (point)) 'its-syl) -1)))
     (delete-region (point) (1+ (point)))))
 
 (defun its-exit-mode ()
@@ -981,7 +1012,10 @@ Return last state."
     (if proceed-to-conversion
        (egg-convert-region start end)
       ;; Remove all properties
-      (set-text-properties start end nil)
+      (goto-char start)
+      (setq s (buffer-substring-no-properties start end))
+      (delete-region start end)
+      (insert s)
       (egg-do-auto-fill)
       (run-hooks 'input-method-after-insert-chunk-hook))))
 
@@ -1045,7 +1079,7 @@ Return last state."
     (insert its-translation-result)))
 \f
 (defun its-set-mode-line-title ()
-  (let ((title (its-get-indicator its-current-map)))
+  (let ((title (its-get-indicator (symbol-value its-current-map))))
     (setq current-input-method-title (if its-previous-select-func
                                         (concat "<" title ">")
                                       title))
@@ -1067,5 +1101,18 @@ Return last state."
     (setq its-previous-select-func nil)
     (its-set-mode-line-title)))
 
+(defun its-mode ()
+  "\\{its-mode-map}"
+  ;; dummy function to get docstring
+  )
+
+(defun its-mode-help-command ()
+  "Display documentation for ITS mode."
+  (interactive)
+  (with-output-to-temp-buffer "*Help*"
+    (princ "ITS mode:\n")
+    (princ (documentation 'its-mode))
+    (help-setup-xref (cons #'help-xref-mode (current-buffer)) (interactive-p))))
+
 (provide 'its)
 ;;; its.el ends here.

diff --git a/its/ascii.el b/its/ascii.el
index 272a340..3595d17 100644 (file)
--- a/its/ascii.el
+++ b/its/ascii.el
@@ -35,7 +35,7 @@
   (require 'its))
 
 (define-its-state-machine its-up-map
-  "upcase" "aA" nil nil
+  "upcase" "aA" nil
   "Map for upcase input."
 
   (let ((i ? ))
@@ -44,7 +44,7 @@
       (setq i (1+ i)))))
 
 (define-its-state-machine its-down-map
-  "downcase" "aa" nil nil
+  "downcase" "aa" nil
   "Map for downcase input."
 
   (let ((i ? ))

diff --git a/its/erpin.el b/its/erpin.el
index db0665b..83b1d6f 100644 (file)
--- a/its/erpin.el
+++ b/its/erpin.el
@@ -2,11 +2,21 @@
   (require 'its)
   (require 'cl))
 
-(defvar its-erpin-cn-enable-quanjioao-alphabet t "*Enable Quanjiao alphabet")
+(defvar its-erpin-cn-enable-quanjioao-alphabet
+  (if (boundp 'its-enable-fullwidth-alphabet)
+      its-enable-fullwidth-alphabet
+    t)
+  "*Enable Quanjiao alphabet")
+
 (defvar its-erpin-cn-open-braket  "\e$A!8\e(B" "*[") ; "\e$A#[\e(B"
 (defvar its-erpin-cn-close-braket "\e$A!9\e(B" "*]") ; "\e$A#]\e(B"
 
-(defvar its-erpin-tw-enable-quanjioao-alphabet t "*Enable Quanjiao alphabet")
+(defvar its-erpin-tw-enable-quanjioao-alphabet
+  (if (boundp 'its-enable-fullwidth-alphabet)
+      its-enable-fullwidth-alphabet
+    t)
+  "*Enable Quanjiao alphabet")
+
 (defvar its-erpin-tw-open-braket  "\e$(G!V\e(B" "*[") ; "\e$(G!b\e(B "
 (defvar its-erpin-tw-close-braket "\e$(G!W\e(B" "*]") ; "\e$(G!c\e(B"
 
@@ -153,7 +163,7 @@
        (its-defrule    "on4"   "\e(0?@\e(B"))))
 
 (define-its-state-machine its-erpin-cn-map
-  "erpin-cn" "\e$A6~\e(BG" "Chinese-GB"
+  "erpin-cn" "\e$A6~\e(BG" 'Chinese-GB
   "Map for Erpin input. (Chinese-GB)"
 
   (defconst its-quanjiao-escape "Z")
@@ -227,7 +237,7 @@
   (its-defrule "!"     "\e$A#!\e(B"))
 
 (define-its-state-machine its-erpin-tw-map
-  "erpin-tw" "\e$(GD(\e(BC" "Chinese-CNS"
+  "erpin-tw" "\e$(GD(\e(BC" 'Chinese-CNS
   "Map for Erpin input."
 
   (defconst its-quanjiao-escape "Z")
@@ -268,11 +278,11 @@
                   (" " . "\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"1\e(B")  ("=" . "\e$(G"8\e(B")  ("`" . "\e$(G!j\e(B")  ("\\" . "\e$(G"`\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!b\e(B")  ("]" . "\e$(G!c\e(B")  ("{" . "\e$(G!B\e(B")  ("}" . "\e$(G!C\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"6\e(B")  (">" . "\e$(G"7\e(B")  ("?" . "\e$(G!)\e(B")  ("/" . "\e$(G"_\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")
@@ -320,7 +330,7 @@
        (its-defrule "="  "\e$A#=\e(B")  (its-defrule "`"  "\e$A#`\e(B")
        (its-defrule "\\" "\e$A#\\e(B")  (its-defrule "|"  "\e$A#|\e(B")
        (its-defrule "_"  "\e$A#_\e(B")  (its-defrule "+"  "\e$A#+\e(B")
-       (its-defrule "{"  "\e$A#{\e(B")  (its-defrule "}"  "\e$A#}\e(B")
+       (its-defrule "{"  "\e$(G!B\e(B")  (its-defrule "}"  "\e$(G!C\e(B")
        (its-defrule "\"" "\e$A#"\e(B")  (its-defrule "'"  "\e$A#'\e(B")
        (its-defrule "<"  "\e$A#<\e(B")  (its-defrule ">"  "\e$A#>\e(B"))
     (progn

diff --git a/its/hangul.el b/its/hangul.el
index 888c434..83a7556 100644 (file)
--- a/its/hangul.el
+++ b/its/hangul.el
@@ -31,57 +31,90 @@
 
 (eval-when-compile
   (require 'its)
+  (require 'egg-edep)
   (require 'cl))
 
-(defvar its-hangul-enable-jeonkak-alphabet t "*Enable Jeonkak alphabet")
+(defvar its-hangul-enable-jeonkak-alphabet
+  (if (boundp 'its-enable-fullwidth-alphabet)
+      its-enable-fullwidth-alphabet
+    t)
+  "*Enable Jeonkak alphabet")
+
 (defvar        its-hangul-period ". " "*\e$(C#.\e(B")    ; ". " "\e$(C#.\e(B"
 (defvar        its-hangul-comma  ", " "*\e$(C#,\e(B")    ; ", " "\e$(C#,\e(B"
 (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
- (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))))
+  (defconst its-hangul-key-alist nil)
+  (defconst its-hangul-successor-list nil)
+
+  (defsubst its-hangul-sequence-to-key (seq)
+    (concat (mapcar (lambda (c)
+                     (cdr (assq c its-hangul-key-alist)))
+                   (string-to-list seq))))
+
+  (defsubst its-hangul-make-successor (init keyseq)
+    (concat (if init (substring init 0 (1- (length init))) "[")
+           (list (aref keyseq 1))
+           "]")))
+
+(eval-when-compile
+  (defun its-define-hangul-key (key output)
+    (let ((out (string-to-char output))
+         (state (its-goto-state key nil t)))
+      (setq its-hangul-key-alist (cons (cons out (string-to-char key))
+                                      its-hangul-key-alist))
+      (its-set-output state output)
+      (its-make-next-state state -1 (its-get-keyseq state) output)
+      (its-defrule-otherwise state output)))
+
+  (defun its-define-hangul-successor-list (keyseq)
+    (let ((pair (assq (aref keyseq 0) its-hangul-successor-list)))
+      (if (null pair)
+         (setq its-hangul-successor-list
+               (cons (cons (aref keyseq 0)
+                           (its-hangul-make-successor nil keyseq))
+                     its-hangul-successor-list))
+       (if (null (string-match (cdr pair) keyseq 1))
+           (setcdr pair (its-hangul-make-successor (cdr pair) keyseq))))))
+
+  (defun its-defrule-hangul (input output)
+    (let ((state (its-get-start-state (symbol-value its-current-map)))
+         (len (length input)) (i 0)
+         keyseq key prev-out out pair)
+      (while (< i len)
+       (setq key (aref input i)
+             next-state (its-get-next-state state key)
+             i (1+ i))
+       (if next-state
+           (setq prev-out out
+                 out (its-get-output next-state)
+                 state next-state)
+         (setq keyseq (substring input 0 i)
+               prev-out out
+               out (if (= i len) output (concat out (list key)))
+               state (its-make-next-state state key keyseq out))
+         (its-make-next-state state -1 keyseq out)
+         (its-defrule-otherwise state out)))
+     (if (and (= (egg-chars-in-period prev-out 0 (length prev-out)) 1)
+             (> (string-to-char prev-out) ?\377)
+             (setq pair (assq (aref keyseq (1- len))
+                              its-hangul-successor-list)))
+        (its-defrule-otherwise state prev-out (cdr pair) -2))))
+
+  (defmacro its-define-hangul (&rest list)
+    (cons 'progn
+         (mapcar (lambda (l)
+                   (let ((case-fold-search nil)
+                         (keyseq (its-hangul-sequence-to-key (car l))))
+                     (if (eq (length keyseq) 2)
+                         (its-define-hangul-successor-list keyseq))
+                     (list 'its-defrule-hangul keyseq (nth 1 l))))
+                 list))))
 
 (define-its-state-machine its-hangul-map
-  "hangul" "\e$(CGQ\e(B" "Korean"
+  "hangul" "\e$(CGQ\e(B" 'Korean
   "Map for Hangul input. (Korean)"
 
   (defconst its-jeonkak-escape "Z")
@@ -90,2777 +123,2773 @@
   (its-defrule-select-mode-temporally "B" downcase)
   (its-defrule-select-mode-temporally "J" jeonkak-downcase)
 
-  (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))
+  (its-define-hangul-key       "r"     "\e$(C$!\e(B")
+  (its-define-hangul-key       "s"     "\e$(C$$\e(B")
+  (its-define-hangul-key       "e"     "\e$(C$'\e(B")
+  (its-define-hangul-key       "f"     "\e$(C$)\e(B")
+  (its-define-hangul-key       "a"     "\e$(C$1\e(B")
+  (its-define-hangul-key       "q"     "\e$(C$2\e(B")
+  (its-define-hangul-key       "t"     "\e$(C$5\e(B")
+  (its-define-hangul-key       "d"     "\e$(C$7\e(B")
+  (its-define-hangul-key       "w"     "\e$(C$8\e(B")
+  (its-define-hangul-key       "c"     "\e$(C$:\e(B")
+  (its-define-hangul-key       "z"     "\e$(C$;\e(B")
+  (its-define-hangul-key       "x"     "\e$(C$<\e(B")
+  (its-define-hangul-key       "v"     "\e$(C$=\e(B")
+  (its-define-hangul-key       "g"     "\e$(C$>\e(B")
+  (its-define-hangul-key       "R"     "\e$(C$"\e(B")
+  (its-define-hangul-key       "E"     "\e$(C$(\e(B")
+  (its-define-hangul-key       "Q"     "\e$(C$3\e(B")
+  (its-define-hangul-key       "T"     "\e$(C$6\e(B")
+  (its-define-hangul-key       "W"     "\e$(C$9\e(B")
+
+  (its-define-hangul-key       "k"     "\e$(C$?\e(B")
+  (its-define-hangul-key       "i"     "\e$(C$A\e(B")
+  (its-define-hangul-key       "j"     "\e$(C$C\e(B")
+  (its-define-hangul-key       "u"     "\e$(C$E\e(B")
+  (its-define-hangul-key       "h"     "\e$(C$G\e(B")
+  (its-define-hangul-key       "y"     "\e$(C$K\e(B")
+  (its-define-hangul-key       "n"     "\e$(C$L\e(B")
+  (its-define-hangul-key       "b"     "\e$(C$P\e(B")
+  (its-define-hangul-key       "m"     "\e$(C$Q\e(B")
+  (its-define-hangul-key       "l"     "\e$(C$S\e(B")
+  (its-define-hangul-key       "o"     "\e$(C$@\e(B")
+  (its-define-hangul-key       "p"     "\e$(C$D\e(B")
+  (its-define-hangul-key       "O"     "\e$(C$B\e(B")
+  (its-define-hangul-key       "P"     "\e$(C$F\e(B")
+
+  (its-define-hangul
+   ("\e$(C$!$?\e(B"      "\e$(C0!\e(B")
+   ("\e$(C$!$?$!\e(B"    "\e$(C0"\e(B")
+   ("\e$(C$!$?$$\e(B"    "\e$(C0#\e(B")
+   ("\e$(C$!$?$'\e(B"    "\e$(C0$\e(B")
+   ("\e$(C$!$?$)\e(B"    "\e$(C0%\e(B")
+   ("\e$(C$!$?$)$!\e(B"  "\e$(C0&\e(B")
+   ("\e$(C$!$?$)$1\e(B"  "\e$(C0'\e(B")
+   ("\e$(C$!$?$1\e(B"    "\e$(C0(\e(B")
+   ("\e$(C$!$?$2\e(B"    "\e$(C0)\e(B")
+   ("\e$(C$!$?$2$5\e(B"  "\e$(C0*\e(B")
+   ("\e$(C$!$?$5\e(B"    "\e$(C0+\e(B")
+   ("\e$(C$!$?$6\e(B"    "\e$(C0,\e(B")
+   ("\e$(C$!$?$7\e(B"    "\e$(C0-\e(B")
+   ("\e$(C$!$?$8\e(B"    "\e$(C0.\e(B")
+   ("\e$(C$!$?$:\e(B"    "\e$(C0/\e(B")
+   ("\e$(C$!$?$<\e(B"    "\e$(C00\e(B")
+   ("\e$(C$!$?$=\e(B"    "\e$(C01\e(B")
+   ("\e$(C$!$?$>\e(B"    "\e$(C02\e(B")
+
+   ("\e$(C$!$@\e(B"      "\e$(C03\e(B")
+   ("\e$(C$!$@$!\e(B"    "\e$(C04\e(B")
+   ("\e$(C$!$@$$\e(B"    "\e$(C05\e(B")
+   ("\e$(C$!$@$)\e(B"    "\e$(C06\e(B")
+   ("\e$(C$!$@$1\e(B"    "\e$(C07\e(B")
+   ("\e$(C$!$@$2\e(B"    "\e$(C08\e(B")
+   ("\e$(C$!$@$5\e(B"    "\e$(C09\e(B")
+   ("\e$(C$!$@$6\e(B"    "\e$(C0:\e(B")
+   ("\e$(C$!$@$7\e(B"    "\e$(C0;\e(B")
+
+   ("\e$(C$!$A\e(B"      "\e$(C0<\e(B")
+   ("\e$(C$!$A$!\e(B"    "\e$(C0=\e(B")
+   ("\e$(C$!$A$$\e(B"    "\e$(C0>\e(B")
+   ("\e$(C$!$A$)\e(B"    "\e$(C0?\e(B")
+   ("\e$(C$!$A$5\e(B"    "\e$(C0@\e(B")
+   ("\e$(C$!$A$7\e(B"    "\e$(C0A\e(B")
+
+   ("\e$(C$!$B\e(B"      "\e$(C0B\e(B")
+   ("\e$(C$!$B$$\e(B"    "\e$(C0C\e(B")
+   ("\e$(C$!$B$)\e(B"    "\e$(C0D\e(B")
+
+   ("\e$(C$!$C\e(B"      "\e$(C0E\e(B")
+   ("\e$(C$!$C$!\e(B"    "\e$(C0F\e(B")
+   ("\e$(C$!$C$$\e(B"    "\e$(C0G\e(B")
+   ("\e$(C$!$C$'\e(B"    "\e$(C0H\e(B")
+   ("\e$(C$!$C$)\e(B"    "\e$(C0I\e(B")
+   ("\e$(C$!$C$)$1\e(B"  "\e$(C0J\e(B")
+   ("\e$(C$!$C$1\e(B"    "\e$(C0K\e(B")
+   ("\e$(C$!$C$2\e(B"    "\e$(C0L\e(B")
+   ("\e$(C$!$C$5\e(B"    "\e$(C0M\e(B")
+   ("\e$(C$!$C$6\e(B"    "\e$(C0N\e(B")
+   ("\e$(C$!$C$7\e(B"    "\e$(C0O\e(B")
+   ("\e$(C$!$C$8\e(B"    "\e$(C0P\e(B")
+   ("\e$(C$!$C$<\e(B"    "\e$(C0Q\e(B")
+   ("\e$(C$!$C$=\e(B"    "\e$(C0R\e(B")
+   ("\e$(C$!$C$>\e(B"    "\e$(C0S\e(B")
+
+   ("\e$(C$!$D\e(B"      "\e$(C0T\e(B")
+   ("\e$(C$!$D$$\e(B"    "\e$(C0U\e(B")
+   ("\e$(C$!$D$)\e(B"    "\e$(C0V\e(B")
+   ("\e$(C$!$D$1\e(B"    "\e$(C0W\e(B")
+   ("\e$(C$!$D$2\e(B"    "\e$(C0X\e(B")
+   ("\e$(C$!$D$5\e(B"    "\e$(C0Y\e(B")
+   ("\e$(C$!$D$6\e(B"    "\e$(C0Z\e(B")
+   ("\e$(C$!$D$7\e(B"    "\e$(C0[\e(B")
+
+   ("\e$(C$!$E\e(B"      "\e$(C0\\e(B")
+   ("\e$(C$!$E$!\e(B"    "\e$(C0]\e(B")
+   ("\e$(C$!$E$"\e(B"    "\e$(C0^\e(B")
+   ("\e$(C$!$E$$\e(B"    "\e$(C0_\e(B")
+   ("\e$(C$!$E$'\e(B"    "\e$(C0`\e(B")
+   ("\e$(C$!$E$)\e(B"    "\e$(C0a\e(B")
+   ("\e$(C$!$E$1\e(B"    "\e$(C0b\e(B")
+   ("\e$(C$!$E$2\e(B"    "\e$(C0c\e(B")
+   ("\e$(C$!$E$5\e(B"    "\e$(C0d\e(B")
+   ("\e$(C$!$E$6\e(B"    "\e$(C0e\e(B")
+   ("\e$(C$!$E$7\e(B"    "\e$(C0f\e(B")
+   ("\e$(C$!$E$<\e(B"    "\e$(C0g\e(B")
+
+   ("\e$(C$!$F\e(B"      "\e$(C0h\e(B")
+   ("\e$(C$!$F$$\e(B"    "\e$(C0i\e(B")
+   ("\e$(C$!$F$)\e(B"    "\e$(C0j\e(B")
+   ("\e$(C$!$F$2\e(B"    "\e$(C0k\e(B")
+   ("\e$(C$!$F$5\e(B"    "\e$(C0l\e(B")
+
+   ("\e$(C$!$G\e(B"      "\e$(C0m\e(B")
+   ("\e$(C$!$G$!\e(B"    "\e$(C0n\e(B")
+   ("\e$(C$!$G$$\e(B"    "\e$(C0o\e(B")
+   ("\e$(C$!$G$'\e(B"    "\e$(C0p\e(B")
+   ("\e$(C$!$G$)\e(B"    "\e$(C0q\e(B")
+   ("\e$(C$!$G$)$1\e(B"  "\e$(C0r\e(B")
+   ("\e$(C$!$G$)$5\e(B"  "\e$(C0s\e(B")
+   ("\e$(C$!$G$)$>\e(B"  "\e$(C0t\e(B")
+   ("\e$(C$!$G$1\e(B"    "\e$(C0u\e(B")
+   ("\e$(C$!$G$2\e(B"    "\e$(C0v\e(B")
+   ("\e$(C$!$G$5\e(B"    "\e$(C0w\e(B")
+   ("\e$(C$!$G$7\e(B"    "\e$(C0x\e(B")
+   ("\e$(C$!$G$8\e(B"    "\e$(C0y\e(B")
+
+   ("\e$(C$!$G$?\e(B"    "\e$(C0z\e(B")
+   ("\e$(C$!$G$?$!\e(B"  "\e$(C0{\e(B")
+   ("\e$(C$!$G$?$$\e(B"  "\e$(C0|\e(B")
+   ("\e$(C$!$G$?$)\e(B"  "\e$(C0}\e(B")
+   ("\e$(C$!$G$?$)$1\e(B"        "\e$(C0~\e(B")
+   ("\e$(C$!$G$?$1\e(B"  "\e$(C1!\e(B")
+   ("\e$(C$!$G$?$2\e(B"  "\e$(C1"\e(B")
+   ("\e$(C$!$G$?$5\e(B"  "\e$(C1#\e(B")
+   ("\e$(C$!$G$?$7\e(B"  "\e$(C1$\e(B")
+
+   ("\e$(C$!$G$@\e(B"    "\e$(C1%\e(B")
+   ("\e$(C$!$G$@$$\e(B"  "\e$(C1&\e(B")
+   ("\e$(C$!$G$@$)\e(B"  "\e$(C1'\e(B")
+   ("\e$(C$!$G$@$2\e(B"  "\e$(C1(\e(B")
+   ("\e$(C$!$G$@$6\e(B"  "\e$(C1)\e(B")
+   ("\e$(C$!$G$@$7\e(B"  "\e$(C1*\e(B")
+
+   ("\e$(C$!$G$S\e(B"    "\e$(C1+\e(B")
+   ("\e$(C$!$G$S$!\e(B"  "\e$(C1,\e(B")
+   ("\e$(C$!$G$S$$\e(B"  "\e$(C1-\e(B")
+   ("\e$(C$!$G$S$)\e(B"  "\e$(C1.\e(B")
+   ("\e$(C$!$G$S$1\e(B"  "\e$(C1/\e(B")
+   ("\e$(C$!$G$S$2\e(B"  "\e$(C10\e(B")
+   ("\e$(C$!$G$S$5\e(B"  "\e$(C11\e(B")
+   ("\e$(C$!$G$S$7\e(B"  "\e$(C12\e(B")
+
+   ("\e$(C$!$K\e(B"      "\e$(C13\e(B")
+   ("\e$(C$!$K$$\e(B"    "\e$(C14\e(B")
+   ("\e$(C$!$K$)\e(B"    "\e$(C15\e(B")
+   ("\e$(C$!$K$2\e(B"    "\e$(C16\e(B")
+   ("\e$(C$!$K$5\e(B"    "\e$(C17\e(B")
+
+   ("\e$(C$!$L\e(B"      "\e$(C18\e(B")
+   ("\e$(C$!$L$!\e(B"    "\e$(C19\e(B")
+   ("\e$(C$!$L$$\e(B"    "\e$(C1:\e(B")
+   ("\e$(C$!$L$'\e(B"    "\e$(C1;\e(B")
+   ("\e$(C$!$L$)\e(B"    "\e$(C1<\e(B")
+   ("\e$(C$!$L$)$!\e(B"  "\e$(C1=\e(B")
+   ("\e$(C$!$L$)$1\e(B"  "\e$(C1>\e(B")
+   ("\e$(C$!$L$)$>\e(B"  "\e$(C1?\e(B")
+   ("\e$(C$!$L$1\e(B"    "\e$(C1@\e(B")
+   ("\e$(C$!$L$2\e(B"    "\e$(C1A\e(B")
+   ("\e$(C$!$L$5\e(B"    "\e$(C1B\e(B")
+   ("\e$(C$!$L$7\e(B"    "\e$(C1C\e(B")
+   ("\e$(C$!$L$8\e(B"    "\e$(C1D\e(B")
+
+   ("\e$(C$!$L$C\e(B"    "\e$(C1E\e(B")
+   ("\e$(C$!$L$C$!\e(B"  "\e$(C1F\e(B")
+   ("\e$(C$!$L$C$$\e(B"  "\e$(C1G\e(B")
+   ("\e$(C$!$L$C$)\e(B"  "\e$(C1H\e(B")
+   ("\e$(C$!$L$C$6\e(B"  "\e$(C1I\e(B")
+   ("\e$(C$!$L$C$7\e(B"  "\e$(C1J\e(B")
+
+   ("\e$(C$!$L$D\e(B"    "\e$(C1K\e(B")
+   ("\e$(C$!$L$D$5\e(B"  "\e$(C1L\e(B")
+
+   ("\e$(C$!$L$S\e(B"    "\e$(C1M\e(B")
+   ("\e$(C$!$L$S$!\e(B"  "\e$(C1N\e(B")
+   ("\e$(C$!$L$S$$\e(B"  "\e$(C1O\e(B")
+   ("\e$(C$!$L$S$)\e(B"  "\e$(C1P\e(B")
+   ("\e$(C$!$L$S$1\e(B"  "\e$(C1Q\e(B")
+   ("\e$(C$!$L$S$2\e(B"  "\e$(C1R\e(B")
+   ("\e$(C$!$L$S$5\e(B"  "\e$(C1S\e(B")
+
+   ("\e$(C$!$P\e(B"      "\e$(C1T\e(B")
+   ("\e$(C$!$P$$\e(B"    "\e$(C1U\e(B")
+   ("\e$(C$!$P$)\e(B"    "\e$(C1V\e(B")
+
+   ("\e$(C$!$Q\e(B"      "\e$(C1W\e(B")
+   ("\e$(C$!$Q$!\e(B"    "\e$(C1X\e(B")
+   ("\e$(C$!$Q$$\e(B"    "\e$(C1Y\e(B")
+   ("\e$(C$!$Q$'\e(B"    "\e$(C1Z\e(B")
+   ("\e$(C$!$Q$)\e(B"    "\e$(C1[\e(B")
+   ("\e$(C$!$Q$)$!\e(B"  "\e$(C1\\e(B")
+   ("\e$(C$!$Q$1\e(B"    "\e$(C1]\e(B")
+   ("\e$(C$!$Q$2\e(B"    "\e$(C1^\e(B")
+   ("\e$(C$!$Q$5\e(B"    "\e$(C1_\e(B")
+   ("\e$(C$!$Q$7\e(B"    "\e$(C1`\e(B")
+
+   ("\e$(C$!$Q$S\e(B"    "\e$(C1a\e(B")
+
+   ("\e$(C$!$S\e(B"      "\e$(C1b\e(B")
+   ("\e$(C$!$S$!\e(B"    "\e$(C1c\e(B")
+   ("\e$(C$!$S$$\e(B"    "\e$(C1d\e(B")
+   ("\e$(C$!$S$'\e(B"    "\e$(C1e\e(B")
+   ("\e$(C$!$S$)\e(B"    "\e$(C1f\e(B")
+   ("\e$(C$!$S$)$1\e(B"  "\e$(C1g\e(B")
+   ("\e$(C$!$S$1\e(B"    "\e$(C1h\e(B")
+   ("\e$(C$!$S$2\e(B"    "\e$(C1i\e(B")
+   ("\e$(C$!$S$5\e(B"    "\e$(C1j\e(B")
+   ("\e$(C$!$S$7\e(B"    "\e$(C1k\e(B")
+   ("\e$(C$!$S$8\e(B"    "\e$(C1l\e(B")
+   ("\e$(C$!$S$=\e(B"    "\e$(C1m\e(B")
+
+   ("\e$(C$"$?\e(B"      "\e$(C1n\e(B")
+   ("\e$(C$"$?$!\e(B"    "\e$(C1o\e(B")
+   ("\e$(C$"$?$"\e(B"    "\e$(C1p\e(B")
+   ("\e$(C$"$?$$\e(B"    "\e$(C1q\e(B")
+   ("\e$(C$"$?$)\e(B"    "\e$(C1r\e(B")
+   ("\e$(C$"$?$)$1\e(B"  "\e$(C1s\e(B")
+   ("\e$(C$"$?$1\e(B"    "\e$(C1t\e(B")
+   ("\e$(C$"$?$2\e(B"    "\e$(C1u\e(B")
+   ("\e$(C$"$?$5\e(B"    "\e$(C1v\e(B")
+   ("\e$(C$"$?$6\e(B"    "\e$(C1w\e(B")
+   ("\e$(C$"$?$7\e(B"    "\e$(C1x\e(B")
+   ("\e$(C$"$?$<\e(B"    "\e$(C1y\e(B")
+
+   ("\e$(C$"$@\e(B"      "\e$(C1z\e(B")
+   ("\e$(C$"$@$!\e(B"    "\e$(C1{\e(B")
+   ("\e$(C$"$@$$\e(B"    "\e$(C1|\e(B")
+   ("\e$(C$"$@$)\e(B"    "\e$(C1}\e(B")
+   ("\e$(C$"$@$1\e(B"    "\e$(C1~\e(B")
+   ("\e$(C$"$@$2\e(B"    "\e$(C2!\e(B")
+   ("\e$(C$"$@$5\e(B"    "\e$(C2"\e(B")
+   ("\e$(C$"$@$6\e(B"    "\e$(C2#\e(B")
+   ("\e$(C$"$@$7\e(B"    "\e$(C2$\e(B")
+
+   ("\e$(C$"$A\e(B"      "\e$(C2%\e(B")
+   ("\e$(C$"$A$!\e(B"    "\e$(C2&\e(B")
+   ("\e$(C$"$A$)\e(B"    "\e$(C2'\e(B")
+
+   ("\e$(C$"$C\e(B"      "\e$(C2(\e(B")
+   ("\e$(C$"$C$!\e(B"    "\e$(C2)\e(B")
+   ("\e$(C$"$C$"\e(B"    "\e$(C2*\e(B")
+   ("\e$(C$"$C$$\e(B"    "\e$(C2+\e(B")
+   ("\e$(C$"$C$)\e(B"    "\e$(C2,\e(B")
+   ("\e$(C$"$C$1\e(B"    "\e$(C2-\e(B")
+   ("\e$(C$"$C$2\e(B"    "\e$(C2.\e(B")
+   ("\e$(C$"$C$5\e(B"    "\e$(C2/\e(B")
+   ("\e$(C$"$C$6\e(B"    "\e$(C20\e(B")
+   ("\e$(C$"$C$7\e(B"    "\e$(C21\e(B")
+
+   ("\e$(C$"$D\e(B"      "\e$(C22\e(B")
+   ("\e$(C$"$D$!\e(B"    "\e$(C23\e(B")
+   ("\e$(C$"$D$$\e(B"    "\e$(C24\e(B")
+   ("\e$(C$"$D$1\e(B"    "\e$(C25\e(B")
+   ("\e$(C$"$D$5\e(B"    "\e$(C26\e(B")
+   ("\e$(C$"$D$7\e(B"    "\e$(C27\e(B")
+
+   ("\e$(C$"$E\e(B"      "\e$(C28\e(B")
+   ("\e$(C$"$E$$\e(B"    "\e$(C29\e(B")
+   ("\e$(C$"$E$)\e(B"    "\e$(C2:\e(B")
+   ("\e$(C$"$E$5\e(B"    "\e$(C2;\e(B")
+   ("\e$(C$"$E$6\e(B"    "\e$(C2<\e(B")
+   ("\e$(C$"$E$<\e(B"    "\e$(C2=\e(B")
+
+   ("\e$(C$"$F\e(B"      "\e$(C2>\e(B")
+
+   ("\e$(C$"$G\e(B"      "\e$(C2?\e(B")
+   ("\e$(C$"$G$!\e(B"    "\e$(C2@\e(B")
+   ("\e$(C$"$G$$\e(B"    "\e$(C2A\e(B")
+   ("\e$(C$"$G$$$>\e(B"  "\e$(C2B\e(B")
+   ("\e$(C$"$G$)\e(B"    "\e$(C2C\e(B")
+   ("\e$(C$"$G$1\e(B"    "\e$(C2D\e(B")
+   ("\e$(C$"$G$2\e(B"    "\e$(C2E\e(B")
+   ("\e$(C$"$G$5\e(B"    "\e$(C2F\e(B")
+   ("\e$(C$"$G$7\e(B"    "\e$(C2G\e(B")
+   ("\e$(C$"$G$8\e(B"    "\e$(C2H\e(B")
+   ("\e$(C$"$G$:\e(B"    "\e$(C2I\e(B")
+
+   ("\e$(C$"$G$?\e(B"    "\e$(C2J\e(B")
+   ("\e$(C$"$G$?$!\e(B"  "\e$(C2K\e(B")
+   ("\e$(C$"$G$?$)\e(B"  "\e$(C2L\e(B")
+   ("\e$(C$"$G$?$6\e(B"  "\e$(C2M\e(B")
+   ("\e$(C$"$G$?$7\e(B"  "\e$(C2N\e(B")
+
+   ("\e$(C$"$G$@\e(B"    "\e$(C2O\e(B")
+   ("\e$(C$"$G$@$!\e(B"  "\e$(C2P\e(B")
+   ("\e$(C$"$G$@$7\e(B"  "\e$(C2Q\e(B")
+
+   ("\e$(C$"$G$S\e(B"    "\e$(C2R\e(B")
+   ("\e$(C$"$G$S$$\e(B"  "\e$(C2S\e(B")
+   ("\e$(C$"$G$S$)\e(B"  "\e$(C2T\e(B")
+   ("\e$(C$"$G$S$1\e(B"  "\e$(C2U\e(B")
+   ("\e$(C$"$G$S$2\e(B"  "\e$(C2V\e(B")
+   ("\e$(C$"$G$S$7\e(B"  "\e$(C2W\e(B")
+
+   ("\e$(C$"$K\e(B"      "\e$(C2X\e(B")
+
+   ("\e$(C$"$L\e(B"      "\e$(C2Y\e(B")
+   ("\e$(C$"$L$!\e(B"    "\e$(C2Z\e(B")
+   ("\e$(C$"$L$$\e(B"    "\e$(C2[\e(B")
+   ("\e$(C$"$L$)\e(B"    "\e$(C2\\e(B")
+   ("\e$(C$"$L$)$>\e(B"  "\e$(C2]\e(B")
+   ("\e$(C$"$L$1\e(B"    "\e$(C2^\e(B")
+   ("\e$(C$"$L$2\e(B"    "\e$(C2_\e(B")
+   ("\e$(C$"$L$5\e(B"    "\e$(C2`\e(B")
+   ("\e$(C$"$L$7\e(B"    "\e$(C2a\e(B")
+   ("\e$(C$"$L$8\e(B"    "\e$(C2b\e(B")
+
+   ("\e$(C$"$L$C\e(B"    "\e$(C2c\e(B")
+   ("\e$(C$"$L$C$)\e(B"  "\e$(C2d\e(B")
+   ("\e$(C$"$L$C$6\e(B"  "\e$(C2e\e(B")
+   ("\e$(C$"$L$C$7\e(B"  "\e$(C2f\e(B")
+
+   ("\e$(C$"$L$D\e(B"    "\e$(C2g\e(B")
+   ("\e$(C$"$L$D$!\e(B"  "\e$(C2h\e(B")
+   ("\e$(C$"$L$D$$\e(B"  "\e$(C2i\e(B")
+   ("\e$(C$"$L$D$)\e(B"  "\e$(C2j\e(B")
+   ("\e$(C$"$L$D$1\e(B"  "\e$(C2k\e(B")
+   ("\e$(C$"$L$D$2\e(B"  "\e$(C2l\e(B")
+   ("\e$(C$"$L$D$6\e(B"  "\e$(C2m\e(B")
+
+   ("\e$(C$"$L$S\e(B"    "\e$(C2n\e(B")
+   ("\e$(C$"$L$S$$\e(B"  "\e$(C2o\e(B")
+   ("\e$(C$"$L$S$)\e(B"  "\e$(C2p\e(B")
+   ("\e$(C$"$L$S$1\e(B"  "\e$(C2q\e(B")
+   ("\e$(C$"$L$S$2\e(B"  "\e$(C2r\e(B")
+
+   ("\e$(C$"$P\e(B"      "\e$(C2s\e(B")
+
+   ("\e$(C$"$Q\e(B"      "\e$(C2t\e(B")
+   ("\e$(C$"$Q$!\e(B"    "\e$(C2u\e(B")
+   ("\e$(C$"$Q$$\e(B"    "\e$(C2v\e(B")
+   ("\e$(C$"$Q$$$>\e(B"  "\e$(C2w\e(B")
+   ("\e$(C$"$Q$)\e(B"    "\e$(C2x\e(B")
+   ("\e$(C$"$Q$)$1\e(B"  "\e$(C2y\e(B")
+   ("\e$(C$"$Q$)$>\e(B"  "\e$(C2z\e(B")
+   ("\e$(C$"$Q$1\e(B"    "\e$(C2{\e(B")
+   ("\e$(C$"$Q$2\e(B"    "\e$(C2|\e(B")
+   ("\e$(C$"$Q$5\e(B"    "\e$(C2}\e(B")
+   ("\e$(C$"$Q$7\e(B"    "\e$(C2~\e(B")
+   ("\e$(C$"$Q$<\e(B"    "\e$(C3!\e(B")
+
+   ("\e$(C$"$S\e(B"      "\e$(C3"\e(B")
+   ("\e$(C$"$S$!\e(B"    "\e$(C3#\e(B")
+   ("\e$(C$"$S$$\e(B"    "\e$(C3$\e(B")
+   ("\e$(C$"$S$)\e(B"    "\e$(C3%\e(B")
+   ("\e$(C$"$S$1\e(B"    "\e$(C3&\e(B")
+   ("\e$(C$"$S$2\e(B"    "\e$(C3'\e(B")
+   ("\e$(C$"$S$5\e(B"    "\e$(C3(\e(B")
+   ("\e$(C$"$S$7\e(B"    "\e$(C3)\e(B")
+
+   ("\e$(C$$$?\e(B"      "\e$(C3*\e(B")
+   ("\e$(C$$$?$!\e(B"    "\e$(C3+\e(B")
+   ("\e$(C$$$?$"\e(B"    "\e$(C3,\e(B")
+   ("\e$(C$$$?$$\e(B"    "\e$(C3-\e(B")
+   ("\e$(C$$$?$'\e(B"    "\e$(C3.\e(B")
+   ("\e$(C$$$?$)\e(B"    "\e$(C3/\e(B")
+   ("\e$(C$$$?$)$!\e(B"  "\e$(C30\e(B")
+   ("\e$(C$$$?$)$1\e(B"  "\e$(C31\e(B")
+   ("\e$(C$$$?$1\e(B"    "\e$(C32\e(B")
+   ("\e$(C$$$?$2\e(B"    "\e$(C33\e(B")
+   ("\e$(C$$$?$5\e(B"    "\e$(C34\e(B")
+   ("\e$(C$$$?$6\e(B"    "\e$(C35\e(B")
+   ("\e$(C$$$?$7\e(B"    "\e$(C36\e(B")
+   ("\e$(C$$$?$8\e(B"    "\e$(C37\e(B")
+   ("\e$(C$$$?$:\e(B"    "\e$(C38\e(B")
+   ("\e$(C$$$?$<\e(B"    "\e$(C39\e(B")
+   ("\e$(C$$$?$>\e(B"    "\e$(C3:\e(B")
+
+   ("\e$(C$$$@\e(B"      "\e$(C3;\e(B")
+   ("\e$(C$$$@$!\e(B"    "\e$(C3<\e(B")
+   ("\e$(C$$$@$$\e(B"    "\e$(C3=\e(B")
+   ("\e$(C$$$@$)\e(B"    "\e$(C3>\e(B")
+   ("\e$(C$$$@$1\e(B"    "\e$(C3?\e(B")
+   ("\e$(C$$$@$2\e(B"    "\e$(C3@\e(B")
+   ("\e$(C$$$@$5\e(B"    "\e$(C3A\e(B")
+   ("\e$(C$$$@$6\e(B"    "\e$(C3B\e(B")
+   ("\e$(C$$$@$7\e(B"    "\e$(C3C\e(B")
+
+   ("\e$(C$$$A\e(B"      "\e$(C3D\e(B")
+   ("\e$(C$$$A$!\e(B"    "\e$(C3E\e(B")
+   ("\e$(C$$$A$$\e(B"    "\e$(C3F\e(B")
+   ("\e$(C$$$A$)\e(B"    "\e$(C3G\e(B")
+   ("\e$(C$$$A$1\e(B"    "\e$(C3H\e(B")
+   ("\e$(C$$$A$7\e(B"    "\e$(C3I\e(B")
+
+   ("\e$(C$$$C\e(B"      "\e$(C3J\e(B")
+   ("\e$(C$$$C$!\e(B"    "\e$(C3K\e(B")
+   ("\e$(C$$$C$!$5\e(B"  "\e$(C3L\e(B")
+   ("\e$(C$$$C$$\e(B"    "\e$(C3M\e(B")
+   ("\e$(C$$$C$)\e(B"    "\e$(C3N\e(B")
+   ("\e$(C$$$C$)$1\e(B"  "\e$(C3O\e(B")
+   ("\e$(C$$$C$)$2\e(B"  "\e$(C3P\e(B")
+   ("\e$(C$$$C$1\e(B"    "\e$(C3Q\e(B")
+   ("\e$(C$$$C$2\e(B"    "\e$(C3R\e(B")
+   ("\e$(C$$$C$5\e(B"    "\e$(C3S\e(B")
+   ("\e$(C$$$C$6\e(B"    "\e$(C3T\e(B")
+   ("\e$(C$$$C$7\e(B"    "\e$(C3U\e(B")
+   ("\e$(C$$$C$>\e(B"    "\e$(C3V\e(B")
+
+   ("\e$(C$$$D\e(B"      "\e$(C3W\e(B")
+   ("\e$(C$$$D$!\e(B"    "\e$(C3X\e(B")
+   ("\e$(C$$$D$$\e(B"    "\e$(C3Y\e(B")
+   ("\e$(C$$$D$)\e(B"    "\e$(C3Z\e(B")
+   ("\e$(C$$$D$1\e(B"    "\e$(C3[\e(B")
+   ("\e$(C$$$D$2\e(B"    "\e$(C3\\e(B")
+   ("\e$(C$$$D$5\e(B"    "\e$(C3]\e(B")
+   ("\e$(C$$$D$6\e(B"    "\e$(C3^\e(B")
+   ("\e$(C$$$D$7\e(B"    "\e$(C3_\e(B")
+
+   ("\e$(C$$$E\e(B"      "\e$(C3`\e(B")
+   ("\e$(C$$$E$!\e(B"    "\e$(C3a\e(B")
+   ("\e$(C$$$E$$\e(B"    "\e$(C3b\e(B")
+   ("\e$(C$$$E$)\e(B"    "\e$(C3c\e(B")
+   ("\e$(C$$$E$1\e(B"    "\e$(C3d\e(B")
+   ("\e$(C$$$E$2\e(B"    "\e$(C3e\e(B")
+   ("\e$(C$$$E$6\e(B"    "\e$(C3f\e(B")
+   ("\e$(C$$$E$7\e(B"    "\e$(C3g\e(B")
+   ("\e$(C$$$E$;\e(B"    "\e$(C3h\e(B")
+
+   ("\e$(C$$$F\e(B"      "\e$(C3i\e(B")
+   ("\e$(C$$$F$$\e(B"    "\e$(C3j\e(B")
+
+   ("\e$(C$$$G\e(B"      "\e$(C3k\e(B")
+   ("\e$(C$$$G$!\e(B"    "\e$(C3l\e(B")
+   ("\e$(C$$$G$$\e(B"    "\e$(C3m\e(B")
+   ("\e$(C$$$G$)\e(B"    "\e$(C3n\e(B")
+   ("\e$(C$$$G$)$1\e(B"  "\e$(C3o\e(B")
+   ("\e$(C$$$G$1\e(B"    "\e$(C3p\e(B")
+   ("\e$(C$$$G$2\e(B"    "\e$(C3q\e(B")
+   ("\e$(C$$$G$5\e(B"    "\e$(C3r\e(B")
+   ("\e$(C$$$G$7\e(B"    "\e$(C3s\e(B")
+   ("\e$(C$$$G$=\e(B"    "\e$(C3t\e(B")
+   ("\e$(C$$$G$>\e(B"    "\e$(C3u\e(B")
+
+   ("\e$(C$$$G$?\e(B"    "\e$(C3v\e(B")
+   ("\e$(C$$$G$?$$\e(B"  "\e$(C3w\e(B")
+   ("\e$(C$$$G$?$)\e(B"  "\e$(C3x\e(B")
+   ("\e$(C$$$G$?$6\e(B"  "\e$(C3y\e(B")
+
+   ("\e$(C$$$G$S\e(B"    "\e$(C3z\e(B")
+   ("\e$(C$$$G$S$$\e(B"  "\e$(C3{\e(B")
+   ("\e$(C$$$G$S$)\e(B"  "\e$(C3|\e(B")
+   ("\e$(C$$$G$S$1\e(B"  "\e$(C3}\e(B")
+   ("\e$(C$$$G$S$2\e(B"  "\e$(C3~\e(B")
+   ("\e$(C$$$G$S$5\e(B"  "\e$(C4!\e(B")
+
+   ("\e$(C$$$K\e(B"      "\e$(C4"\e(B")
+   ("\e$(C$$$K$!\e(B"    "\e$(C4#\e(B")
+   ("\e$(C$$$K$$\e(B"    "\e$(C4$\e(B")
+   ("\e$(C$$$K$)\e(B"    "\e$(C4%\e(B")
+   ("\e$(C$$$K$2\e(B"    "\e$(C4&\e(B")
+   ("\e$(C$$$K$5\e(B"    "\e$(C4'\e(B")
+   ("\e$(C$$$K$7\e(B"    "\e$(C4(\e(B")
+
+   ("\e$(C$$$L\e(B"      "\e$(C4)\e(B")
+   ("\e$(C$$$L$!\e(B"    "\e$(C4*\e(B")
+   ("\e$(C$$$L$$\e(B"    "\e$(C4+\e(B")
+   ("\e$(C$$$L$'\e(B"    "\e$(C4,\e(B")
+   ("\e$(C$$$L$)\e(B"    "\e$(C4-\e(B")
+   ("\e$(C$$$L$1\e(B"    "\e$(C4.\e(B")
+   ("\e$(C$$$L$2\e(B"    "\e$(C4/\e(B")
+   ("\e$(C$$$L$5\e(B"    "\e$(C40\e(B")
+   ("\e$(C$$$L$7\e(B"    "\e$(C41\e(B")
+
+   ("\e$(C$$$L$C\e(B"    "\e$(C42\e(B")
+   ("\e$(C$$$L$C$6\e(B"  "\e$(C43\e(B")
+
+   ("\e$(C$$$L$D\e(B"    "\e$(C44\e(B")
+
+   ("\e$(C$$$L$S\e(B"    "\e$(C45\e(B")
+   ("\e$(C$$$L$S$$\e(B"  "\e$(C46\e(B")
+   ("\e$(C$$$L$S$)\e(B"  "\e$(C47\e(B")
+   ("\e$(C$$$L$S$1\e(B"  "\e$(C48\e(B")
+   ("\e$(C$$$L$S$2\e(B"  "\e$(C49\e(B")
+
+   ("\e$(C$$$P\e(B"      "\e$(C4:\e(B")
+   ("\e$(C$$$P$!\e(B"    "\e$(C4;\e(B")
+   ("\e$(C$$$P$)\e(B"    "\e$(C4<\e(B")
+   ("\e$(C$$$P$1\e(B"    "\e$(C4=\e(B")
+   ("\e$(C$$$P$2\e(B"    "\e$(C4>\e(B")
+   ("\e$(C$$$P$7\e(B"    "\e$(C4?\e(B")
+
+   ("\e$(C$$$Q\e(B"      "\e$(C4@\e(B")
+   ("\e$(C$$$Q$!\e(B"    "\e$(C4A\e(B")
+   ("\e$(C$$$Q$$\e(B"    "\e$(C4B\e(B")
+   ("\e$(C$$$Q$)\e(B"    "\e$(C4C\e(B")
+   ("\e$(C$$$Q$)$!\e(B"  "\e$(C4D\e(B")
+   ("\e$(C$$$Q$)$1\e(B"  "\e$(C4E\e(B")
+   ("\e$(C$$$Q$1\e(B"    "\e$(C4F\e(B")
+   ("\e$(C$$$Q$2\e(B"    "\e$(C4G\e(B")
+   ("\e$(C$$$Q$5\e(B"    "\e$(C4H\e(B")
+   ("\e$(C$$$Q$7\e(B"    "\e$(C4I\e(B")
+   ("\e$(C$$$Q$8\e(B"    "\e$(C4J\e(B")
+   ("\e$(C$$$Q$=\e(B"    "\e$(C4K\e(B")
+
+   ("\e$(C$$$Q$S\e(B"    "\e$(C4L\e(B")
+   ("\e$(C$$$Q$S$$\e(B"  "\e$(C4M\e(B")
+   ("\e$(C$$$Q$S$)\e(B"  "\e$(C4N\e(B")
+
+   ("\e$(C$$$S\e(B"      "\e$(C4O\e(B")
+   ("\e$(C$$$S$!\e(B"    "\e$(C4P\e(B")
+   ("\e$(C$$$S$$\e(B"    "\e$(C4Q\e(B")
+   ("\e$(C$$$S$)\e(B"    "\e$(C4R\e(B")
+   ("\e$(C$$$S$)$1\e(B"  "\e$(C4S\e(B")
+   ("\e$(C$$$S$1\e(B"    "\e$(C4T\e(B")
+   ("\e$(C$$$S$2\e(B"    "\e$(C4U\e(B")
+   ("\e$(C$$$S$5\e(B"    "\e$(C4V\e(B")
+   ("\e$(C$$$S$7\e(B"    "\e$(C4W\e(B")
+   ("\e$(C$$$S$=\e(B"    "\e$(C4X\e(B")
+
+   ("\e$(C$'$?\e(B"      "\e$(C4Y\e(B")
+   ("\e$(C$'$?$!\e(B"    "\e$(C4Z\e(B")
+   ("\e$(C$'$?$"\e(B"    "\e$(C4[\e(B")
+   ("\e$(C$'$?$$\e(B"    "\e$(C4\\e(B")
+   ("\e$(C$'$?$'\e(B"    "\e$(C4]\e(B")
+   ("\e$(C$'$?$)\e(B"    "\e$(C4^\e(B")
+   ("\e$(C$'$?$)$!\e(B"  "\e$(C4_\e(B")
+   ("\e$(C$'$?$)$1\e(B"  "\e$(C4`\e(B")
+   ("\e$(C$'$?$)$2\e(B"  "\e$(C4a\e(B")
+   ("\e$(C$'$?$)$>\e(B"  "\e$(C4b\e(B")
+   ("\e$(C$'$?$1\e(B"    "\e$(C4c\e(B")
+   ("\e$(C$'$?$2\e(B"    "\e$(C4d\e(B")
+   ("\e$(C$'$?$5\e(B"    "\e$(C4e\e(B")
+   ("\e$(C$'$?$6\e(B"    "\e$(C4f\e(B")
+   ("\e$(C$'$?$7\e(B"    "\e$(C4g\e(B")
+   ("\e$(C$'$?$8\e(B"    "\e$(C4h\e(B")
+   ("\e$(C$'$?$:\e(B"    "\e$(C4i\e(B")
+   ("\e$(C$'$?$>\e(B"    "\e$(C4j\e(B")
+
+   ("\e$(C$'$@\e(B"      "\e$(C4k\e(B")
+   ("\e$(C$'$@$!\e(B"    "\e$(C4l\e(B")
+   ("\e$(C$'$@$$\e(B"    "\e$(C4m\e(B")
+   ("\e$(C$'$@$)\e(B"    "\e$(C4n\e(B")
+   ("\e$(C$'$@$1\e(B"    "\e$(C4o\e(B")
+   ("\e$(C$'$@$2\e(B"    "\e$(C4p\e(B")
+   ("\e$(C$'$@$5\e(B"    "\e$(C4q\e(B")
+   ("\e$(C$'$@$6\e(B"    "\e$(C4r\e(B")
+   ("\e$(C$'$@$7\e(B"    "\e$(C4s\e(B")
+
+   ("\e$(C$'$A\e(B"      "\e$(C4t\e(B")
+
+   ("\e$(C$'$C\e(B"      "\e$(C4u\e(B")
+   ("\e$(C$'$C$!\e(B"    "\e$(C4v\e(B")
+   ("\e$(C$'$C$"\e(B"    "\e$(C4w\e(B")
+   ("\e$(C$'$C$$\e(B"    "\e$(C4x\e(B")
+   ("\e$(C$'$C$'\e(B"    "\e$(C4y\e(B")
+   ("\e$(C$'$C$)\e(B"    "\e$(C4z\e(B")
+   ("\e$(C$'$C$)$1\e(B"  "\e$(C4{\e(B")
+   ("\e$(C$'$C$)$2\e(B"  "\e$(C4|\e(B")
+   ("\e$(C$'$C$1\e(B"    "\e$(C4}\e(B")
+   ("\e$(C$'$C$2\e(B"    "\e$(C4~\e(B")
+   ("\e$(C$'$C$5\e(B"    "\e$(C5!\e(B")
+   ("\e$(C$'$C$7\e(B"    "\e$(C5"\e(B")
+   ("\e$(C$'$C$:\e(B"    "\e$(C5#\e(B")
+   ("\e$(C$'$C$=\e(B"    "\e$(C5$\e(B")
+
+   ("\e$(C$'$D\e(B"      "\e$(C5%\e(B")
+   ("\e$(C$'$D$!\e(B"    "\e$(C5&\e(B")
+   ("\e$(C$'$D$$\e(B"    "\e$(C5'\e(B")
+   ("\e$(C$'$D$)\e(B"    "\e$(C5(\e(B")
+   ("\e$(C$'$D$1\e(B"    "\e$(C5)\e(B")
+   ("\e$(C$'$D$2\e(B"    "\e$(C5*\e(B")
+   ("\e$(C$'$D$5\e(B"    "\e$(C5+\e(B")
+   ("\e$(C$'$D$6\e(B"    "\e$(C5,\e(B")
+   ("\e$(C$'$D$7\e(B"    "\e$(C5-\e(B")
+
+   ("\e$(C$'$E\e(B"      "\e$(C5.\e(B")
+   ("\e$(C$'$E$$\e(B"    "\e$(C5/\e(B")
+   ("\e$(C$'$E$)\e(B"    "\e$(C50\e(B")
+   ("\e$(C$'$E$6\e(B"    "\e$(C51\e(B")
+   ("\e$(C$'$E$7\e(B"    "\e$(C52\e(B")
+
+   ("\e$(C$'$F\e(B"      "\e$(C53\e(B")
+   ("\e$(C$'$F$$\e(B"    "\e$(C54\e(B")
+
+   ("\e$(C$'$G\e(B"      "\e$(C55\e(B")
+   ("\e$(C$'$G$!\e(B"    "\e$(C56\e(B")
+   ("\e$(C$'$G$$\e(B"    "\e$(C57\e(B")
+   ("\e$(C$'$G$'\e(B"    "\e$(C58\e(B")
+   ("\e$(C$'$G$)\e(B"    "\e$(C59\e(B")
+   ("\e$(C$'$G$)$1\e(B"  "\e$(C5:\e(B")
+   ("\e$(C$'$G$)$5\e(B"  "\e$(C5;\e(B")
+   ("\e$(C$'$G$1\e(B"    "\e$(C5<\e(B")
+   ("\e$(C$'$G$2\e(B"    "\e$(C5=\e(B")
+   ("\e$(C$'$G$5\e(B"    "\e$(C5>\e(B")
+   ("\e$(C$'$G$7\e(B"    "\e$(C5?\e(B")
+   ("\e$(C$'$G$:\e(B"    "\e$(C5@\e(B")
+   ("\e$(C$'$G$<\e(B"    "\e$(C5A\e(B")
+
+   ("\e$(C$'$G$?\e(B"    "\e$(C5B\e(B")
+   ("\e$(C$'$G$?$$\e(B"  "\e$(C5C\e(B")
+   ("\e$(C$'$G$?$)\e(B"  "\e$(C5D\e(B")
+
+   ("\e$(C$'$G$@\e(B"    "\e$(C5E\e(B")
+   ("\e$(C$'$G$@$6\e(B"  "\e$(C5F\e(B")
+
+   ("\e$(C$'$G$S\e(B"    "\e$(C5G\e(B")
+   ("\e$(C$'$G$S$$\e(B"  "\e$(C5H\e(B")
+   ("\e$(C$'$G$S$)\e(B"  "\e$(C5I\e(B")
+   ("\e$(C$'$G$S$1\e(B"  "\e$(C5J\e(B")
+   ("\e$(C$'$G$S$2\e(B"  "\e$(C5K\e(B")
+   ("\e$(C$'$G$S$5\e(B"  "\e$(C5L\e(B")
+
+   ("\e$(C$'$K\e(B"      "\e$(C5M\e(B")
+
+   ("\e$(C$'$L\e(B"      "\e$(C5N\e(B")
+   ("\e$(C$'$L$!\e(B"    "\e$(C5O\e(B")
+   ("\e$(C$'$L$$\e(B"    "\e$(C5P\e(B")
+   ("\e$(C$'$L$)\e(B"    "\e$(C5Q\e(B")
+   ("\e$(C$'$L$1\e(B"    "\e$(C5R\e(B")
+   ("\e$(C$'$L$2\e(B"    "\e$(C5S\e(B")
+   ("\e$(C$'$L$5\e(B"    "\e$(C5T\e(B")
+   ("\e$(C$'$L$7\e(B"    "\e$(C5U\e(B")
+
+   ("\e$(C$'$L$C\e(B"    "\e$(C5V\e(B")
+   ("\e$(C$'$L$C$6\e(B"  "\e$(C5W\e(B")
+
+   ("\e$(C$'$L$D\e(B"    "\e$(C5X\e(B")
+   ("\e$(C$'$L$D$7\e(B"  "\e$(C5Y\e(B")
+
+   ("\e$(C$'$L$S\e(B"    "\e$(C5Z\e(B")
+   ("\e$(C$'$L$S$$\e(B"  "\e$(C5[\e(B")
+   ("\e$(C$'$L$S$)\e(B"  "\e$(C5\\e(B")
+   ("\e$(C$'$L$S$2\e(B"  "\e$(C5]\e(B")
+   ("\e$(C$'$L$S$5\e(B"  "\e$(C5^\e(B")
+   ("\e$(C$'$L$S$7\e(B"  "\e$(C5_\e(B")
+
+   ("\e$(C$'$P\e(B"      "\e$(C5`\e(B")
+   ("\e$(C$'$P$$\e(B"    "\e$(C5a\e(B")
+   ("\e$(C$'$P$)\e(B"    "\e$(C5b\e(B")
+   ("\e$(C$'$P$1\e(B"    "\e$(C5c\e(B")
+   ("\e$(C$'$P$7\e(B"    "\e$(C5d\e(B")
+
+   ("\e$(C$'$Q\e(B"      "\e$(C5e\e(B")
+   ("\e$(C$'$Q$!\e(B"    "\e$(C5f\e(B")
+   ("\e$(C$'$Q$$\e(B"    "\e$(C5g\e(B")
+   ("\e$(C$'$Q$'\e(B"    "\e$(C5h\e(B")
+   ("\e$(C$'$Q$)\e(B"    "\e$(C5i\e(B")
+   ("\e$(C$'$Q$)$1\e(B"  "\e$(C5j\e(B")
+   ("\e$(C$'$Q$1\e(B"    "\e$(C5k\e(B")
+   ("\e$(C$'$Q$2\e(B"    "\e$(C5l\e(B")
+   ("\e$(C$'$Q$5\e(B"    "\e$(C5m\e(B")
+   ("\e$(C$'$Q$7\e(B"    "\e$(C5n\e(B")
+
+   ("\e$(C$'$Q$S\e(B"    "\e$(C5o\e(B")
+
+   ("\e$(C$'$S\e(B"      "\e$(C5p\e(B")
+   ("\e$(C$'$S$!\e(B"    "\e$(C5q\e(B")
+   ("\e$(C$'$S$$\e(B"    "\e$(C5r\e(B")
+   ("\e$(C$'$S$'\e(B"    "\e$(C5s\e(B")
+   ("\e$(C$'$S$)\e(B"    "\e$(C5t\e(B")
+   ("\e$(C$'$S$1\e(B"    "\e$(C5u\e(B")
+   ("\e$(C$'$S$2\e(B"    "\e$(C5v\e(B")
+   ("\e$(C$'$S$5\e(B"    "\e$(C5w\e(B")
+   ("\e$(C$'$S$6\e(B"    "\e$(C5x\e(B")
+   ("\e$(C$'$S$7\e(B"    "\e$(C5y\e(B")
+   ("\e$(C$'$S$8\e(B"    "\e$(C5z\e(B")
+
+   ("\e$(C$($?\e(B"      "\e$(C5{\e(B")
+   ("\e$(C$($?$!\e(B"    "\e$(C5|\e(B")
+   ("\e$(C$($?$$\e(B"    "\e$(C5}\e(B")
+   ("\e$(C$($?$)\e(B"    "\e$(C5~\e(B")
+   ("\e$(C$($?$1\e(B"    "\e$(C6!\e(B")
+   ("\e$(C$($?$2\e(B"    "\e$(C6"\e(B")
+   ("\e$(C$($?$5\e(B"    "\e$(C6#\e(B")
+   ("\e$(C$($?$6\e(B"    "\e$(C6$\e(B")
+   ("\e$(C$($?$7\e(B"    "\e$(C6%\e(B")
+   ("\e$(C$($?$>\e(B"    "\e$(C6&\e(B")
+
+   ("\e$(C$($@\e(B"      "\e$(C6'\e(B")
+   ("\e$(C$($@$!\e(B"    "\e$(C6(\e(B")
+   ("\e$(C$($@$$\e(B"    "\e$(C6)\e(B")
+   ("\e$(C$($@$)\e(B"    "\e$(C6*\e(B")
+   ("\e$(C$($@$1\e(B"    "\e$(C6+\e(B")
+   ("\e$(C$($@$2\e(B"    "\e$(C6,\e(B")
+   ("\e$(C$($@$5\e(B"    "\e$(C6-\e(B")
+   ("\e$(C$($@$6\e(B"    "\e$(C6.\e(B")
+   ("\e$(C$($@$7\e(B"    "\e$(C6/\e(B")
+
+   ("\e$(C$($C\e(B"      "\e$(C60\e(B")
+   ("\e$(C$($C$!\e(B"    "\e$(C61\e(B")
+   ("\e$(C$($C$$\e(B"    "\e$(C62\e(B")
+   ("\e$(C$($C$)\e(B"    "\e$(C63\e(B")
+   ("\e$(C$($C$)$1\e(B"  "\e$(C64\e(B")
+   ("\e$(C$($C$)$2\e(B"  "\e$(C65\e(B")
+   ("\e$(C$($C$1\e(B"    "\e$(C66\e(B")
+   ("\e$(C$($C$2\e(B"    "\e$(C67\e(B")
+   ("\e$(C$($C$5\e(B"    "\e$(C68\e(B")
+   ("\e$(C$($C$6\e(B"    "\e$(C69\e(B")
+   ("\e$(C$($C$7\e(B"    "\e$(C6:\e(B")
+   ("\e$(C$($C$>\e(B"    "\e$(C6;\e(B")
+
+   ("\e$(C$($D\e(B"      "\e$(C6<\e(B")
+   ("\e$(C$($D$!\e(B"    "\e$(C6=\e(B")
+   ("\e$(C$($D$$\e(B"    "\e$(C6>\e(B")
+   ("\e$(C$($D$)\e(B"    "\e$(C6?\e(B")
+   ("\e$(C$($D$1\e(B"    "\e$(C6@\e(B")
+   ("\e$(C$($D$2\e(B"    "\e$(C6A\e(B")
+   ("\e$(C$($D$5\e(B"    "\e$(C6B\e(B")
+   ("\e$(C$($D$6\e(B"    "\e$(C6C\e(B")
+   ("\e$(C$($D$7\e(B"    "\e$(C6D\e(B")
+
+   ("\e$(C$($E\e(B"      "\e$(C6E\e(B")
+   ("\e$(C$($E$6\e(B"    "\e$(C6F\e(B")
+
+   ("\e$(C$($G\e(B"      "\e$(C6G\e(B")
+   ("\e$(C$($G$!\e(B"    "\e$(C6H\e(B")
+   ("\e$(C$($G$$\e(B"    "\e$(C6I\e(B")
+   ("\e$(C$($G$)\e(B"    "\e$(C6J\e(B")
+   ("\e$(C$($G$7\e(B"    "\e$(C6K\e(B")
+
+   ("\e$(C$($G$?\e(B"    "\e$(C6L\e(B")
+   ("\e$(C$($G$?$)\e(B"  "\e$(C6M\e(B")
+
+   ("\e$(C$($G$@\e(B"    "\e$(C6N\e(B")
+
+   ("\e$(C$($G$S\e(B"    "\e$(C6O\e(B")
+   ("\e$(C$($G$S$$\e(B"  "\e$(C6P\e(B")
+
+   ("\e$(C$($L\e(B"      "\e$(C6Q\e(B")
+   ("\e$(C$($L$!\e(B"    "\e$(C6R\e(B")
+   ("\e$(C$($L$$\e(B"    "\e$(C6S\e(B")
+   ("\e$(C$($L$)\e(B"    "\e$(C6T\e(B")
+   ("\e$(C$($L$)$>\e(B"  "\e$(C6U\e(B")
+   ("\e$(C$($L$1\e(B"    "\e$(C6V\e(B")
+   ("\e$(C$($L$7\e(B"    "\e$(C6W\e(B")
+
+   ("\e$(C$($L$D\e(B"    "\e$(C6X\e(B")
+
+   ("\e$(C$($L$S\e(B"    "\e$(C6Y\e(B")
+   ("\e$(C$($L$S$$\e(B"  "\e$(C6Z\e(B")
+   ("\e$(C$($L$S$)\e(B"  "\e$(C6[\e(B")
+   ("\e$(C$($L$S$1\e(B"  "\e$(C6\\e(B")
+   ("\e$(C$($L$S$2\e(B"  "\e$(C6]\e(B")
+   ("\e$(C$($L$S$7\e(B"  "\e$(C6^\e(B")
+
+   ("\e$(C$($Q\e(B"      "\e$(C6_\e(B")
+   ("\e$(C$($Q$!\e(B"    "\e$(C6`\e(B")
+   ("\e$(C$($Q$$\e(B"    "\e$(C6a\e(B")
+   ("\e$(C$($Q$'\e(B"    "\e$(C6b\e(B")
+   ("\e$(C$($Q$)\e(B"    "\e$(C6c\e(B")
+   ("\e$(C$($Q$1\e(B"    "\e$(C6d\e(B")
+   ("\e$(C$($Q$2\e(B"    "\e$(C6e\e(B")
+   ("\e$(C$($Q$5\e(B"    "\e$(C6f\e(B")
+
+   ("\e$(C$($Q$S\e(B"    "\e$(C6g\e(B")
+   ("\e$(C$($Q$S$$\e(B"  "\e$(C6h\e(B")
+   ("\e$(C$($Q$S$)\e(B"  "\e$(C6i\e(B")
+   ("\e$(C$($Q$S$1\e(B"  "\e$(C6j\e(B")
+   ("\e$(C$($Q$S$2\e(B"  "\e$(C6k\e(B")
+
+   ("\e$(C$($S\e(B"      "\e$(C6l\e(B")
+   ("\e$(C$($S$$\e(B"    "\e$(C6m\e(B")
+   ("\e$(C$($S$)\e(B"    "\e$(C6n\e(B")
+   ("\e$(C$($S$1\e(B"    "\e$(C6o\e(B")
+   ("\e$(C$($S$2\e(B"    "\e$(C6p\e(B")
+   ("\e$(C$($S$5\e(B"    "\e$(C6q\e(B")
+   ("\e$(C$($S$7\e(B"    "\e$(C6r\e(B")
+
+   ("\e$(C$)$?\e(B"      "\e$(C6s\e(B")
+   ("\e$(C$)$?$!\e(B"    "\e$(C6t\e(B")
+   ("\e$(C$)$?$$\e(B"    "\e$(C6u\e(B")
+   ("\e$(C$)$?$)\e(B"    "\e$(C6v\e(B")
+   ("\e$(C$)$?$1\e(B"    "\e$(C6w\e(B")
+   ("\e$(C$)$?$2\e(B"    "\e$(C6x\e(B")
+   ("\e$(C$)$?$5\e(B"    "\e$(C6y\e(B")
+   ("\e$(C$)$?$6\e(B"    "\e$(C6z\e(B")
+   ("\e$(C$)$?$7\e(B"    "\e$(C6{\e(B")
+   ("\e$(C$)$?$8\e(B"    "\e$(C6|\e(B")
+   ("\e$(C$)$?$=\e(B"    "\e$(C6}\e(B")
+   ("\e$(C$)$?$>\e(B"    "\e$(C6~\e(B")
+
+   ("\e$(C$)$@\e(B"      "\e$(C7!\e(B")
+   ("\e$(C$)$@$!\e(B"    "\e$(C7"\e(B")
+   ("\e$(C$)$@$$\e(B"    "\e$(C7#\e(B")
+   ("\e$(C$)$@$)\e(B"    "\e$(C7$\e(B")
+   ("\e$(C$)$@$1\e(B"    "\e$(C7%\e(B")
+   ("\e$(C$)$@$2\e(B"    "\e$(C7&\e(B")
+   ("\e$(C$)$@$5\e(B"    "\e$(C7'\e(B")
+   ("\e$(C$)$@$6\e(B"    "\e$(C7(\e(B")
+   ("\e$(C$)$@$7\e(B"    "\e$(C7)\e(B")
+
+   ("\e$(C$)$A\e(B"      "\e$(C7*\e(B")
+   ("\e$(C$)$A$!\e(B"    "\e$(C7+\e(B")
+   ("\e$(C$)$A$$\e(B"    "\e$(C7,\e(B")
+   ("\e$(C$)$A$5\e(B"    "\e$(C7-\e(B")
+   ("\e$(C$)$A$7\e(B"    "\e$(C7.\e(B")
+
+   ("\e$(C$)$C\e(B"      "\e$(C7/\e(B")
+   ("\e$(C$)$C$!\e(B"    "\e$(C70\e(B")
+   ("\e$(C$)$C$$\e(B"    "\e$(C71\e(B")
+   ("\e$(C$)$C$)\e(B"    "\e$(C72\e(B")
+   ("\e$(C$)$C$1\e(B"    "\e$(C73\e(B")
+   ("\e$(C$)$C$2\e(B"    "\e$(C74\e(B")
+   ("\e$(C$)$C$5\e(B"    "\e$(C75\e(B")
+   ("\e$(C$)$C$6\e(B"    "\e$(C76\e(B")
+   ("\e$(C$)$C$7\e(B"    "\e$(C77\e(B")
+   ("\e$(C$)$C$>\e(B"    "\e$(C78\e(B")
+
+   ("\e$(C$)$D\e(B"      "\e$(C79\e(B")
+   ("\e$(C$)$D$!\e(B"    "\e$(C7:\e(B")
+   ("\e$(C$)$D$$\e(B"    "\e$(C7;\e(B")
+   ("\e$(C$)$D$)\e(B"    "\e$(C7<\e(B")
+   ("\e$(C$)$D$1\e(B"    "\e$(C7=\e(B")
+   ("\e$(C$)$D$2\e(B"    "\e$(C7>\e(B")
+   ("\e$(C$)$D$5\e(B"    "\e$(C7?\e(B")
+   ("\e$(C$)$D$7\e(B"    "\e$(C7@\e(B")
+
+   ("\e$(C$)$E\e(B"      "\e$(C7A\e(B")
+   ("\e$(C$)$E$!\e(B"    "\e$(C7B\e(B")
+   ("\e$(C$)$E$$\e(B"    "\e$(C7C\e(B")
+   ("\e$(C$)$E$)\e(B"    "\e$(C7D\e(B")
+   ("\e$(C$)$E$1\e(B"    "\e$(C7E\e(B")
+   ("\e$(C$)$E$2\e(B"    "\e$(C7F\e(B")
+   ("\e$(C$)$E$5\e(B"    "\e$(C7G\e(B")
+   ("\e$(C$)$E$6\e(B"    "\e$(C7H\e(B")
+   ("\e$(C$)$E$7\e(B"    "\e$(C7I\e(B")
+
+   ("\e$(C$)$F\e(B"      "\e$(C7J\e(B")
+   ("\e$(C$)$F$$\e(B"    "\e$(C7K\e(B")
+   ("\e$(C$)$F$2\e(B"    "\e$(C7L\e(B")
+   ("\e$(C$)$F$5\e(B"    "\e$(C7M\e(B")
+
+   ("\e$(C$)$G\e(B"      "\e$(C7N\e(B")
+   ("\e$(C$)$G$!\e(B"    "\e$(C7O\e(B")
+   ("\e$(C$)$G$$\e(B"    "\e$(C7P\e(B")
+   ("\e$(C$)$G$)\e(B"    "\e$(C7Q\e(B")
+   ("\e$(C$)$G$1\e(B"    "\e$(C7R\e(B")
+   ("\e$(C$)$G$2\e(B"    "\e$(C7S\e(B")
+   ("\e$(C$)$G$5\e(B"    "\e$(C7T\e(B")
+   ("\e$(C$)$G$7\e(B"    "\e$(C7U\e(B")
+
+   ("\e$(C$)$G$?\e(B"    "\e$(C7V\e(B")
+   ("\e$(C$)$G$?$$\e(B"  "\e$(C7W\e(B")
+   ("\e$(C$)$G$?$7\e(B"  "\e$(C7X\e(B")
+
+   ("\e$(C$)$G$@$6\e(B"  "\e$(C7Y\e(B")
+
+   ("\e$(C$)$G$S\e(B"    "\e$(C7Z\e(B")
+   ("\e$(C$)$G$S$$\e(B"  "\e$(C7[\e(B")
+   ("\e$(C$)$G$S$)\e(B"  "\e$(C7\\e(B")
+   ("\e$(C$)$G$S$1\e(B"  "\e$(C7]\e(B")
+   ("\e$(C$)$G$S$2\e(B"  "\e$(C7^\e(B")
+   ("\e$(C$)$G$S$5\e(B"  "\e$(C7_\e(B")
+   ("\e$(C$)$G$S$7\e(B"  "\e$(C7`\e(B")
+
+   ("\e$(C$)$K\e(B"      "\e$(C7a\e(B")
+   ("\e$(C$)$K$$\e(B"    "\e$(C7b\e(B")
+   ("\e$(C$)$K$)\e(B"    "\e$(C7c\e(B")
+   ("\e$(C$)$K$2\e(B"    "\e$(C7d\e(B")
+   ("\e$(C$)$K$5\e(B"    "\e$(C7e\e(B")
+   ("\e$(C$)$K$7\e(B"    "\e$(C7f\e(B")
+
+   ("\e$(C$)$L\e(B"      "\e$(C7g\e(B")
+   ("\e$(C$)$L$!\e(B"    "\e$(C7h\e(B")
+   ("\e$(C$)$L$$\e(B"    "\e$(C7i\e(B")
+   ("\e$(C$)$L$)\e(B"    "\e$(C7j\e(B")
+   ("\e$(C$)$L$1\e(B"    "\e$(C7k\e(B")
+   ("\e$(C$)$L$2\e(B"    "\e$(C7l\e(B")
+   ("\e$(C$)$L$5\e(B"    "\e$(C7m\e(B")
+   ("\e$(C$)$L$7\e(B"    "\e$(C7n\e(B")
+
+   ("\e$(C$)$L$C\e(B"    "\e$(C7o\e(B")
+   ("\e$(C$)$L$C$6\e(B"  "\e$(C7p\e(B")
+
+   ("\e$(C$)$L$D\e(B"    "\e$(C7q\e(B")
+
+   ("\e$(C$)$L$S\e(B"    "\e$(C7r\e(B")
+   ("\e$(C$)$L$S$!\e(B"  "\e$(C7s\e(B")
+   ("\e$(C$)$L$S$$\e(B"  "\e$(C7t\e(B")
+   ("\e$(C$)$L$S$)\e(B"  "\e$(C7u\e(B")
+   ("\e$(C$)$L$S$1\e(B"  "\e$(C7v\e(B")
+   ("\e$(C$)$L$S$5\e(B"  "\e$(C7w\e(B")
+   ("\e$(C$)$L$S$7\e(B"  "\e$(C7x\e(B")
+
+   ("\e$(C$)$P\e(B"      "\e$(C7y\e(B")
+   ("\e$(C$)$P$!\e(B"    "\e$(C7z\e(B")
+   ("\e$(C$)$P$$\e(B"    "\e$(C7{\e(B")
+   ("\e$(C$)$P$)\e(B"    "\e$(C7|\e(B")
+   ("\e$(C$)$P$1\e(B"    "\e$(C7}\e(B")
+   ("\e$(C$)$P$2\e(B"    "\e$(C7~\e(B")
+   ("\e$(C$)$P$5\e(B"    "\e$(C8!\e(B")
+   ("\e$(C$)$P$7\e(B"    "\e$(C8"\e(B")
+
+   ("\e$(C$)$Q\e(B"      "\e$(C8#\e(B")
+   ("\e$(C$)$Q$!\e(B"    "\e$(C8$\e(B")
+   ("\e$(C$)$Q$$\e(B"    "\e$(C8%\e(B")
+   ("\e$(C$)$Q$)\e(B"    "\e$(C8&\e(B")
+   ("\e$(C$)$Q$1\e(B"    "\e$(C8'\e(B")
+   ("\e$(C$)$Q$2\e(B"    "\e$(C8(\e(B")
+   ("\e$(C$)$Q$5\e(B"    "\e$(C8)\e(B")
+   ("\e$(C$)$Q$7\e(B"    "\e$(C8*\e(B")
+   ("\e$(C$)$Q$8\e(B"    "\e$(C8+\e(B")
+   ("\e$(C$)$Q$<\e(B"    "\e$(C8,\e(B")
+   ("\e$(C$)$Q$=\e(B"    "\e$(C8-\e(B")
+
+   ("\e$(C$)$S\e(B"      "\e$(C8.\e(B")
+   ("\e$(C$)$S$!\e(B"    "\e$(C8/\e(B")
+   ("\e$(C$)$S$$\e(B"    "\e$(C80\e(B")
+   ("\e$(C$)$S$)\e(B"    "\e$(C81\e(B")
+   ("\e$(C$)$S$1\e(B"    "\e$(C82\e(B")
+   ("\e$(C$)$S$2\e(B"    "\e$(C83\e(B")
+   ("\e$(C$)$S$5\e(B"    "\e$(C84\e(B")
+   ("\e$(C$)$S$7\e(B"    "\e$(C85\e(B")
+
+   ("\e$(C$1$?\e(B"      "\e$(C86\e(B")
+   ("\e$(C$1$?$!\e(B"    "\e$(C87\e(B")
+   ("\e$(C$1$?$$\e(B"    "\e$(C88\e(B")
+   ("\e$(C$1$?$$$>\e(B"  "\e$(C89\e(B")
+   ("\e$(C$1$?$'\e(B"    "\e$(C8:\e(B")
+   ("\e$(C$1$?$)\e(B"    "\e$(C8;\e(B")
+   ("\e$(C$1$?$)$!\e(B"  "\e$(C8<\e(B")
+   ("\e$(C$1$?$)$1\e(B"  "\e$(C8=\e(B")
+   ("\e$(C$1$?$1\e(B"    "\e$(C8>\e(B")
+   ("\e$(C$1$?$2\e(B"    "\e$(C8?\e(B")
+   ("\e$(C$1$?$5\e(B"    "\e$(C8@\e(B")
+   ("\e$(C$1$?$7\e(B"    "\e$(C8A\e(B")
+   ("\e$(C$1$?$8\e(B"    "\e$(C8B\e(B")
+   ("\e$(C$1$?$<\e(B"    "\e$(C8C\e(B")
+   ("\e$(C$1$?$>\e(B"    "\e$(C8D\e(B")
+
+   ("\e$(C$1$@\e(B"      "\e$(C8E\e(B")
+   ("\e$(C$1$@$!\e(B"    "\e$(C8F\e(B")
+   ("\e$(C$1$@$$\e(B"    "\e$(C8G\e(B")
+   ("\e$(C$1$@$)\e(B"    "\e$(C8H\e(B")
+   ("\e$(C$1$@$1\e(B"    "\e$(C8I\e(B")
+   ("\e$(C$1$@$2\e(B"    "\e$(C8J\e(B")
+   ("\e$(C$1$@$5\e(B"    "\e$(C8K\e(B")
+   ("\e$(C$1$@$6\e(B"    "\e$(C8L\e(B")
+   ("\e$(C$1$@$7\e(B"    "\e$(C8M\e(B")
+   ("\e$(C$1$@$8\e(B"    "\e$(C8N\e(B")
+
+   ("\e$(C$1$A\e(B"      "\e$(C8O\e(B")
+   ("\e$(C$1$A$!\e(B"    "\e$(C8P\e(B")
+   ("\e$(C$1$A$)\e(B"    "\e$(C8Q\e(B")
+   ("\e$(C$1$A$7\e(B"    "\e$(C8R\e(B")
+
+   ("\e$(C$1$C\e(B"      "\e$(C8S\e(B")
+   ("\e$(C$1$C$!\e(B"    "\e$(C8T\e(B")
+   ("\e$(C$1$C$$\e(B"    "\e$(C8U\e(B")
+   ("\e$(C$1$C$)\e(B"    "\e$(C8V\e(B")
+   ("\e$(C$1$C$)$1\e(B"  "\e$(C8W\e(B")
+   ("\e$(C$1$C$1\e(B"    "\e$(C8X\e(B")
+   ("\e$(C$1$C$2\e(B"    "\e$(C8Y\e(B")
+   ("\e$(C$1$C$5\e(B"    "\e$(C8Z\e(B")
+   ("\e$(C$1$C$7\e(B"    "\e$(C8[\e(B")
+   ("\e$(C$1$C$8\e(B"    "\e$(C8\\e(B")
+   ("\e$(C$1$C$>\e(B"    "\e$(C8]\e(B")
+
+   ("\e$(C$1$D\e(B"      "\e$(C8^\e(B")
+   ("\e$(C$1$D$!\e(B"    "\e$(C8_\e(B")
+   ("\e$(C$1$D$$\e(B"    "\e$(C8`\e(B")
+   ("\e$(C$1$D$)\e(B"    "\e$(C8a\e(B")
+   ("\e$(C$1$D$1\e(B"    "\e$(C8b\e(B")
+   ("\e$(C$1$D$2\e(B"    "\e$(C8c\e(B")
+   ("\e$(C$1$D$5\e(B"    "\e$(C8d\e(B")
+   ("\e$(C$1$D$6\e(B"    "\e$(C8e\e(B")
+   ("\e$(C$1$D$7\e(B"    "\e$(C8f\e(B")
+
+   ("\e$(C$1$E\e(B"      "\e$(C8g\e(B")
+   ("\e$(C$1$E$!\e(B"    "\e$(C8h\e(B")
+   ("\e$(C$1$E$$\e(B"    "\e$(C8i\e(B")
+   ("\e$(C$1$E$)\e(B"    "\e$(C8j\e(B")
+   ("\e$(C$1$E$5\e(B"    "\e$(C8k\e(B")
+   ("\e$(C$1$E$6\e(B"    "\e$(C8l\e(B")
+   ("\e$(C$1$E$7\e(B"    "\e$(C8m\e(B")
+   ("\e$(C$1$E$:\e(B"    "\e$(C8n\e(B")
+
+   ("\e$(C$1$F\e(B"      "\e$(C8o\e(B")
+
+   ("\e$(C$1$G\e(B"      "\e$(C8p\e(B")
+   ("\e$(C$1$G$!\e(B"    "\e$(C8q\e(B")
+   ("\e$(C$1$G$!$5\e(B"  "\e$(C8r\e(B")
+   ("\e$(C$1$G$$\e(B"    "\e$(C8s\e(B")
+   ("\e$(C$1$G$)\e(B"    "\e$(C8t\e(B")
+   ("\e$(C$1$G$)$1\e(B"  "\e$(C8u\e(B")
+   ("\e$(C$1$G$1\e(B"    "\e$(C8v\e(B")
+   ("\e$(C$1$G$2\e(B"    "\e$(C8w\e(B")
+   ("\e$(C$1$G$5\e(B"    "\e$(C8x\e(B")
+   ("\e$(C$1$G$7\e(B"    "\e$(C8y\e(B")
+
+   ("\e$(C$1$G$?\e(B"    "\e$(C8z\e(B")
+   ("\e$(C$1$G$?$$\e(B"  "\e$(C8{\e(B")
+   ("\e$(C$1$G$?$6\e(B"  "\e$(C8|\e(B")
+   ("\e$(C$1$G$?$7\e(B"  "\e$(C8}\e(B")
+
+   ("\e$(C$1$G$S\e(B"    "\e$(C8~\e(B")
+   ("\e$(C$1$G$S$$\e(B"  "\e$(C9!\e(B")
+   ("\e$(C$1$G$S$)\e(B"  "\e$(C9"\e(B")
+   ("\e$(C$1$G$S$2\e(B"  "\e$(C9#\e(B")
+   ("\e$(C$1$G$S$5\e(B"  "\e$(C9$\e(B")
+   ("\e$(C$1$G$S$7\e(B"  "\e$(C9%\e(B")
+
+   ("\e$(C$1$K\e(B"      "\e$(C9&\e(B")
+   ("\e$(C$1$K$$\e(B"    "\e$(C9'\e(B")
+   ("\e$(C$1$K$)\e(B"    "\e$(C9(\e(B")
+   ("\e$(C$1$K$2\e(B"    "\e$(C9)\e(B")
+   ("\e$(C$1$K$5\e(B"    "\e$(C9*\e(B")
+
+   ("\e$(C$1$L\e(B"      "\e$(C9+\e(B")
+   ("\e$(C$1$L$!\e(B"    "\e$(C9,\e(B")
+   ("\e$(C$1$L$"\e(B"    "\e$(C9-\e(B")
+   ("\e$(C$1$L$$\e(B"    "\e$(C9.\e(B")
+   ("\e$(C$1$L$'\e(B"    "\e$(C9/\e(B")
+   ("\e$(C$1$L$)\e(B"    "\e$(C90\e(B")
+   ("\e$(C$1$L$)$!\e(B"  "\e$(C91\e(B")
+   ("\e$(C$1$L$)$1\e(B"  "\e$(C92\e(B")
+   ("\e$(C$1$L$1\e(B"    "\e$(C93\e(B")
+   ("\e$(C$1$L$2\e(B"    "\e$(C94\e(B")
+   ("\e$(C$1$L$5\e(B"    "\e$(C95\e(B")
+   ("\e$(C$1$L$7\e(B"    "\e$(C96\e(B")
+   ("\e$(C$1$L$<\e(B"    "\e$(C97\e(B")
+   ("\e$(C$1$L$>\e(B"    "\e$(C98\e(B")
+
+   ("\e$(C$1$L$C\e(B"    "\e$(C99\e(B")
+   ("\e$(C$1$L$C$$\e(B"  "\e$(C9:\e(B")
+   ("\e$(C$1$L$C$)\e(B"  "\e$(C9;\e(B")
+   ("\e$(C$1$L$C$2\e(B"  "\e$(C9<\e(B")
+   ("\e$(C$1$L$C$5\e(B"  "\e$(C9=\e(B")
+
+   ("\e$(C$1$L$D\e(B"    "\e$(C9>\e(B")
+
+   ("\e$(C$1$L$S\e(B"    "\e$(C9?\e(B")
+   ("\e$(C$1$L$S$$\e(B"  "\e$(C9@\e(B")
+   ("\e$(C$1$L$S$)\e(B"  "\e$(C9A\e(B")
+
+   ("\e$(C$1$P\e(B"      "\e$(C9B\e(B")
+   ("\e$(C$1$P$$\e(B"    "\e$(C9C\e(B")
+   ("\e$(C$1$P$)\e(B"    "\e$(C9D\e(B")
+   ("\e$(C$1$P$1\e(B"    "\e$(C9E\e(B")
+   ("\e$(C$1$P$5\e(B"    "\e$(C9F\e(B")
+
+   ("\e$(C$1$Q\e(B"      "\e$(C9G\e(B")
+   ("\e$(C$1$Q$$\e(B"    "\e$(C9H\e(B")
+   ("\e$(C$1$Q$)\e(B"    "\e$(C9I\e(B")
+   ("\e$(C$1$Q$1\e(B"    "\e$(C9J\e(B")
+   ("\e$(C$1$Q$5\e(B"    "\e$(C9K\e(B")
+
+   ("\e$(C$1$S\e(B"      "\e$(C9L\e(B")
+   ("\e$(C$1$S$!\e(B"    "\e$(C9M\e(B")
+   ("\e$(C$1$S$$\e(B"    "\e$(C9N\e(B")
+   ("\e$(C$1$S$'\e(B"    "\e$(C9O\e(B")
+   ("\e$(C$1$S$)\e(B"    "\e$(C9P\e(B")
+   ("\e$(C$1$S$)$1\e(B"  "\e$(C9Q\e(B")
+   ("\e$(C$1$S$1\e(B"    "\e$(C9R\e(B")
+   ("\e$(C$1$S$2\e(B"    "\e$(C9S\e(B")
+   ("\e$(C$1$S$5\e(B"    "\e$(C9T\e(B")
+   ("\e$(C$1$S$6\e(B"    "\e$(C9U\e(B")
+   ("\e$(C$1$S$7\e(B"    "\e$(C9V\e(B")
+   ("\e$(C$1$S$:\e(B"    "\e$(C9W\e(B")
+   ("\e$(C$1$S$<\e(B"    "\e$(C9X\e(B")
+
+   ("\e$(C$2$?\e(B"      "\e$(C9Y\e(B")
+   ("\e$(C$2$?$!\e(B"    "\e$(C9Z\e(B")
+   ("\e$(C$2$?$!$5\e(B"  "\e$(C9\\e(B")
+   ("\e$(C$2$?$"\e(B"    "\e$(C9[\e(B")
+   ("\e$(C$2$?$$\e(B"    "\e$(C9]\e(B")
+   ("\e$(C$2$?$'\e(B"    "\e$(C9^\e(B")
+   ("\e$(C$2$?$)\e(B"    "\e$(C9_\e(B")
+   ("\e$(C$2$?$)$!\e(B"  "\e$(C9`\e(B")
+   ("\e$(C$2$?$)$1\e(B"  "\e$(C9a\e(B")
+   ("\e$(C$2$?$)$2\e(B"  "\e$(C9b\e(B")
+   ("\e$(C$2$?$1\e(B"    "\e$(C9c\e(B")
+   ("\e$(C$2$?$2\e(B"    "\e$(C9d\e(B")
+   ("\e$(C$2$?$5\e(B"    "\e$(C9e\e(B")
+   ("\e$(C$2$?$7\e(B"    "\e$(C9f\e(B")
+   ("\e$(C$2$?$<\e(B"    "\e$(C9g\e(B")
+
+   ("\e$(C$2$@\e(B"      "\e$(C9h\e(B")
+   ("\e$(C$2$@$!\e(B"    "\e$(C9i\e(B")
+   ("\e$(C$2$@$$\e(B"    "\e$(C9j\e(B")
+   ("\e$(C$2$@$)\e(B"    "\e$(C9k\e(B")
+   ("\e$(C$2$@$1\e(B"    "\e$(C9l\e(B")
+   ("\e$(C$2$@$2\e(B"    "\e$(C9m\e(B")
+   ("\e$(C$2$@$5\e(B"    "\e$(C9n\e(B")
+   ("\e$(C$2$@$6\e(B"    "\e$(C9o\e(B")
+   ("\e$(C$2$@$7\e(B"    "\e$(C9p\e(B")
+   ("\e$(C$2$@$<\e(B"    "\e$(C9q\e(B")
+
+   ("\e$(C$2$A\e(B"      "\e$(C9r\e(B")
+   ("\e$(C$2$A$!\e(B"    "\e$(C9s\e(B")
+   ("\e$(C$2$A$$\e(B"    "\e$(C9t\e(B")
+   ("\e$(C$2$A$2\e(B"    "\e$(C9u\e(B")
+
+   ("\e$(C$2$C\e(B"      "\e$(C9v\e(B")
+   ("\e$(C$2$C$!\e(B"    "\e$(C9w\e(B")
+   ("\e$(C$2$C$$\e(B"    "\e$(C9x\e(B")
+   ("\e$(C$2$C$'\e(B"    "\e$(C9y\e(B")
+   ("\e$(C$2$C$)\e(B"    "\e$(C9z\e(B")
+   ("\e$(C$2$C$)$1\e(B"  "\e$(C9{\e(B")
+   ("\e$(C$2$C$1\e(B"    "\e$(C9|\e(B")
+   ("\e$(C$2$C$2\e(B"    "\e$(C9}\e(B")
+   ("\e$(C$2$C$5\e(B"    "\e$(C9~\e(B")
+   ("\e$(C$2$C$7\e(B"    "\e$(C:!\e(B")
+   ("\e$(C$2$C$8\e(B"    "\e$(C:"\e(B")
+
+   ("\e$(C$2$D\e(B"      "\e$(C:#\e(B")
+   ("\e$(C$2$D$!\e(B"    "\e$(C:$\e(B")
+   ("\e$(C$2$D$$\e(B"    "\e$(C:%\e(B")
+   ("\e$(C$2$D$'\e(B"    "\e$(C:&\e(B")
+   ("\e$(C$2$D$)\e(B"    "\e$(C:'\e(B")
+   ("\e$(C$2$D$1\e(B"    "\e$(C:(\e(B")
+   ("\e$(C$2$D$2\e(B"    "\e$(C:)\e(B")
+   ("\e$(C$2$D$5\e(B"    "\e$(C:*\e(B")
+   ("\e$(C$2$D$6\e(B"    "\e$(C:+\e(B")
+   ("\e$(C$2$D$7\e(B"    "\e$(C:,\e(B")
+
+   ("\e$(C$2$E\e(B"      "\e$(C:-\e(B")
+   ("\e$(C$2$E$!\e(B"    "\e$(C:.\e(B")
+   ("\e$(C$2$E$$\e(B"    "\e$(C:/\e(B")
+   ("\e$(C$2$E$)\e(B"    "\e$(C:0\e(B")
+   ("\e$(C$2$E$2\e(B"    "\e$(C:1\e(B")
+   ("\e$(C$2$E$5\e(B"    "\e$(C:2\e(B")
+   ("\e$(C$2$E$6\e(B"    "\e$(C:3\e(B")
+   ("\e$(C$2$E$7\e(B"    "\e$(C:4\e(B")
+   ("\e$(C$2$E$<\e(B"    "\e$(C:5\e(B")
+
+   ("\e$(C$2$F\e(B"      "\e$(C:6\e(B")
+   ("\e$(C$2$F$$\e(B"    "\e$(C:7\e(B")
+
+   ("\e$(C$2$G\e(B"      "\e$(C:8\e(B")
+   ("\e$(C$2$G$!\e(B"    "\e$(C:9\e(B")
+   ("\e$(C$2$G$"\e(B"    "\e$(C::\e(B")
+   ("\e$(C$2$G$$\e(B"    "\e$(C:;\e(B")
+   ("\e$(C$2$G$)\e(B"    "\e$(C:<\e(B")
+   ("\e$(C$2$G$1\e(B"    "\e$(C:=\e(B")
+   ("\e$(C$2$G$2\e(B"    "\e$(C:>\e(B")
+   ("\e$(C$2$G$5\e(B"    "\e$(C:?\e(B")
+   ("\e$(C$2$G$7\e(B"    "\e$(C:@\e(B")
+
+   ("\e$(C$2$G$?\e(B"    "\e$(C:A\e(B")
+   ("\e$(C$2$G$?$$\e(B"  "\e$(C:B\e(B")
+   ("\e$(C$2$G$?$6\e(B"  "\e$(C:C\e(B")
+
+   ("\e$(C$2$G$@\e(B"    "\e$(C:D\e(B")
+   ("\e$(C$2$G$@$6\e(B"  "\e$(C:E\e(B")
+
+   ("\e$(C$2$G$S\e(B"    "\e$(C:F\e(B")
+   ("\e$(C$2$G$S$!\e(B"  "\e$(C:G\e(B")
+   ("\e$(C$2$G$S$$\e(B"  "\e$(C:H\e(B")
+   ("\e$(C$2$G$S$)\e(B"  "\e$(C:I\e(B")
+   ("\e$(C$2$G$S$1\e(B"  "\e$(C:J\e(B")
+   ("\e$(C$2$G$S$2\e(B"  "\e$(C:K\e(B")
+
+   ("\e$(C$2$K\e(B"      "\e$(C:L\e(B")
+   ("\e$(C$2$K$$\e(B"    "\e$(C:M\e(B")
+
+   ("\e$(C$2$L\e(B"      "\e$(C:N\e(B")
+   ("\e$(C$2$L$!\e(B"    "\e$(C:O\e(B")
+   ("\e$(C$2$L$$\e(B"    "\e$(C:P\e(B")
+   ("\e$(C$2$L$'\e(B"    "\e$(C:Q\e(B")
+   ("\e$(C$2$L$)\e(B"    "\e$(C:R\e(B")
+   ("\e$(C$2$L$)$!\e(B"  "\e$(C:S\e(B")
+   ("\e$(C$2$L$)$1\e(B"  "\e$(C:T\e(B")
+   ("\e$(C$2$L$1\e(B"    "\e$(C:U\e(B")
+   ("\e$(C$2$L$2\e(B"    "\e$(C:V\e(B")
+   ("\e$(C$2$L$5\e(B"    "\e$(C:W\e(B")
+   ("\e$(C$2$L$7\e(B"    "\e$(C:X\e(B")
+   ("\e$(C$2$L$<\e(B"    "\e$(C:Y\e(B")
+   ("\e$(C$2$L$=\e(B"    "\e$(C:Z\e(B")
+
+   ("\e$(C$2$L$C\e(B"    "\e$(C:[\e(B")
+   ("\e$(C$2$L$C$)\e(B"  "\e$(C:\\e(B")
+   ("\e$(C$2$L$C$6\e(B"  "\e$(C:]\e(B")
+
+   ("\e$(C$2$L$D\e(B"    "\e$(C:^\e(B")
+
+   ("\e$(C$2$L$S\e(B"    "\e$(C:_\e(B")
+   ("\e$(C$2$L$S$!\e(B"  "\e$(C:`\e(B")
+   ("\e$(C$2$L$S$$\e(B"  "\e$(C:a\e(B")
+   ("\e$(C$2$L$S$)\e(B"  "\e$(C:b\e(B")
+   ("\e$(C$2$L$S$7\e(B"  "\e$(C:c\e(B")
+
+   ("\e$(C$2$P\e(B"      "\e$(C:d\e(B")
+   ("\e$(C$2$P$$\e(B"    "\e$(C:e\e(B")
+   ("\e$(C$2$P$)\e(B"    "\e$(C:f\e(B")
+   ("\e$(C$2$P$1\e(B"    "\e$(C:g\e(B")
+   ("\e$(C$2$P$5\e(B"    "\e$(C:h\e(B")
+   ("\e$(C$2$P$7\e(B"    "\e$(C:i\e(B")
+
+   ("\e$(C$2$Q\e(B"      "\e$(C:j\e(B")
+   ("\e$(C$2$Q$!\e(B"    "\e$(C:k\e(B")
+   ("\e$(C$2$Q$$\e(B"    "\e$(C:l\e(B")
+   ("\e$(C$2$Q$)\e(B"    "\e$(C:m\e(B")
+   ("\e$(C$2$Q$1\e(B"    "\e$(C:n\e(B")
+   ("\e$(C$2$Q$2\e(B"    "\e$(C:o\e(B")
+   ("\e$(C$2$Q$5\e(B"    "\e$(C:p\e(B")
+
+   ("\e$(C$2$S\e(B"      "\e$(C:q\e(B")
+   ("\e$(C$2$S$!\e(B"    "\e$(C:r\e(B")
+   ("\e$(C$2$S$$\e(B"    "\e$(C:s\e(B")
+   ("\e$(C$2$S$)\e(B"    "\e$(C:t\e(B")
+   ("\e$(C$2$S$)$1\e(B"  "\e$(C:u\e(B")
+   ("\e$(C$2$S$1\e(B"    "\e$(C:v\e(B")
+   ("\e$(C$2$S$2\e(B"    "\e$(C:w\e(B")
+   ("\e$(C$2$S$5\e(B"    "\e$(C:x\e(B")
+   ("\e$(C$2$S$7\e(B"    "\e$(C:y\e(B")
+   ("\e$(C$2$S$8\e(B"    "\e$(C:z\e(B")
+   ("\e$(C$2$S$:\e(B"    "\e$(C:{\e(B")
+
+   ("\e$(C$3$?\e(B"      "\e$(C:|\e(B")
+   ("\e$(C$3$?$!\e(B"    "\e$(C:}\e(B")
+   ("\e$(C$3$?$$\e(B"    "\e$(C:~\e(B")
+   ("\e$(C$3$?$)\e(B"    "\e$(C;!\e(B")
+   ("\e$(C$3$?$)$1\e(B"  "\e$(C;"\e(B")
+   ("\e$(C$3$?$1\e(B"    "\e$(C;#\e(B")
+   ("\e$(C$3$?$2\e(B"    "\e$(C;$\e(B")
+   ("\e$(C$3$?$5\e(B"    "\e$(C;%\e(B")
+   ("\e$(C$3$?$6\e(B"    "\e$(C;&\e(B")
+   ("\e$(C$3$?$7\e(B"    "\e$(C;'\e(B")
+   ("\e$(C$3$?$>\e(B"    "\e$(C;(\e(B")
+
+   ("\e$(C$3$@\e(B"      "\e$(C;)\e(B")
+   ("\e$(C$3$@$!\e(B"    "\e$(C;*\e(B")
+   ("\e$(C$3$@$$\e(B"    "\e$(C;+\e(B")
+   ("\e$(C$3$@$)\e(B"    "\e$(C;,\e(B")
+   ("\e$(C$3$@$1\e(B"    "\e$(C;-\e(B")
+   ("\e$(C$3$@$2\e(B"    "\e$(C;.\e(B")
+   ("\e$(C$3$@$5\e(B"    "\e$(C;/\e(B")
+   ("\e$(C$3$@$6\e(B"    "\e$(C;0\e(B")
+   ("\e$(C$3$@$7\e(B"    "\e$(C;1\e(B")
+
+   ("\e$(C$3$A\e(B"      "\e$(C;2\e(B")
+   ("\e$(C$3$A$!\e(B"    "\e$(C;3\e(B")
+   ("\e$(C$3$A$1\e(B"    "\e$(C;4\e(B")
+
+   ("\e$(C$3$C\e(B"      "\e$(C;5\e(B")
+   ("\e$(C$3$C$!\e(B"    "\e$(C;6\e(B")
+   ("\e$(C$3$C$$\e(B"    "\e$(C;7\e(B")
+   ("\e$(C$3$C$'\e(B"    "\e$(C;8\e(B")
+   ("\e$(C$3$C$)\e(B"    "\e$(C;9\e(B")
+   ("\e$(C$3$C$1\e(B"    "\e$(C;:\e(B")
+   ("\e$(C$3$C$5\e(B"    "\e$(C;;\e(B")
+   ("\e$(C$3$C$6\e(B"    "\e$(C;<\e(B")
+   ("\e$(C$3$C$7\e(B"    "\e$(C;=\e(B")
+
+   ("\e$(C$3$D\e(B"      "\e$(C;>\e(B")
+   ("\e$(C$3$D$7\e(B"    "\e$(C;?\e(B")
+
+   ("\e$(C$3$E\e(B"      "\e$(C;@\e(B")
+   ("\e$(C$3$E$!\e(B"    "\e$(C;A\e(B")
+   ("\e$(C$3$E$1\e(B"    "\e$(C;B\e(B")
+   ("\e$(C$3$E$2\e(B"    "\e$(C;C\e(B")
+   ("\e$(C$3$E$5\e(B"    "\e$(C;D\e(B")
+   ("\e$(C$3$E$6\e(B"    "\e$(C;E\e(B")
+   ("\e$(C$3$E$7\e(B"    "\e$(C;F\e(B")
+
+   ("\e$(C$3$G\e(B"      "\e$(C;G\e(B")
+   ("\e$(C$3$G$!\e(B"    "\e$(C;H\e(B")
+   ("\e$(C$3$G$$\e(B"    "\e$(C;I\e(B")
+   ("\e$(C$3$G$)\e(B"    "\e$(C;J\e(B")
+   ("\e$(C$3$G$1\e(B"    "\e$(C;K\e(B")
+   ("\e$(C$3$G$2\e(B"    "\e$(C;L\e(B")
+   ("\e$(C$3$G$7\e(B"    "\e$(C;M\e(B")
+
+   ("\e$(C$3$G$S\e(B"    "\e$(C;N\e(B")
+
+   ("\e$(C$3$K\e(B"      "\e$(C;O\e(B")
+   ("\e$(C$3$K$7\e(B"    "\e$(C;P\e(B")
+
+   ("\e$(C$3$L\e(B"      "\e$(C;Q\e(B")
+   ("\e$(C$3$L$!\e(B"    "\e$(C;R\e(B")
+   ("\e$(C$3$L$$\e(B"    "\e$(C;S\e(B")
+   ("\e$(C$3$L$)\e(B"    "\e$(C;T\e(B")
+   ("\e$(C$3$L$1\e(B"    "\e$(C;U\e(B")
+   ("\e$(C$3$L$5\e(B"    "\e$(C;V\e(B")
+   ("\e$(C$3$L$7\e(B"    "\e$(C;W\e(B")
+
+   ("\e$(C$3$P\e(B"      "\e$(C;X\e(B")
+   ("\e$(C$3$P$7\e(B"    "\e$(C;Y\e(B")
+
+   ("\e$(C$3$Q\e(B"      "\e$(C;Z\e(B")
+   ("\e$(C$3$Q$$\e(B"    "\e$(C;[\e(B")
+   ("\e$(C$3$Q$)\e(B"    "\e$(C;\\e(B")
+   ("\e$(C$3$Q$1\e(B"    "\e$(C;]\e(B")
+   ("\e$(C$3$Q$2\e(B"    "\e$(C;^\e(B")
+
+   ("\e$(C$3$S\e(B"      "\e$(C;_\e(B")
+   ("\e$(C$3$S$!\e(B"    "\e$(C;`\e(B")
+   ("\e$(C$3$S$$\e(B"    "\e$(C;a\e(B")
+   ("\e$(C$3$S$)\e(B"    "\e$(C;b\e(B")
+   ("\e$(C$3$S$1\e(B"    "\e$(C;c\e(B")
+   ("\e$(C$3$S$2\e(B"    "\e$(C;d\e(B")
+   ("\e$(C$3$S$5\e(B"    "\e$(C;e\e(B")
+   ("\e$(C$3$S$7\e(B"    "\e$(C;f\e(B")
+
+   ("\e$(C$5$?\e(B"      "\e$(C;g\e(B")
+   ("\e$(C$5$?$!\e(B"    "\e$(C;h\e(B")
+   ("\e$(C$5$?$!$5\e(B"  "\e$(C;i\e(B")
+   ("\e$(C$5$?$$\e(B"    "\e$(C;j\e(B")
+   ("\e$(C$5$?$'\e(B"    "\e$(C;k\e(B")
+   ("\e$(C$5$?$)\e(B"    "\e$(C;l\e(B")
+   ("\e$(C$5$?$)$!\e(B"  "\e$(C;m\e(B")
+   ("\e$(C$5$?$)$1\e(B"  "\e$(C;n\e(B")
+   ("\e$(C$5$?$1\e(B"    "\e$(C;o\e(B")
+   ("\e$(C$5$?$2\e(B"    "\e$(C;p\e(B")
+   ("\e$(C$5$?$5\e(B"    "\e$(C;q\e(B")
+   ("\e$(C$5$?$5$6\e(B"  "\e$(C;r\e(B")
+   ("\e$(C$5$?$7\e(B"    "\e$(C;s\e(B")
+   ("\e$(C$5$?$<\e(B"    "\e$(C;t\e(B")
+
+   ("\e$(C$5$@\e(B"      "\e$(C;u\e(B")
+   ("\e$(C$5$@$!\e(B"    "\e$(C;v\e(B")
+   ("\e$(C$5$@$$\e(B"    "\e$(C;w\e(B")
+   ("\e$(C$5$@$)\e(B"    "\e$(C;x\e(B")
+   ("\e$(C$5$@$1\e(B"    "\e$(C;y\e(B")
+   ("\e$(C$5$@$2\e(B"    "\e$(C;z\e(B")
+   ("\e$(C$5$@$5\e(B"    "\e$(C;{\e(B")
+   ("\e$(C$5$@$6\e(B"    "\e$(C;|\e(B")
+   ("\e$(C$5$@$7\e(B"    "\e$(C;}\e(B")
+
+   ("\e$(C$5$A\e(B"      "\e$(C;~\e(B")
+   ("\e$(C$5$A$!\e(B"    "\e$(C<!\e(B")
+   ("\e$(C$5$A$$\e(B"    "\e$(C<"\e(B")
+   ("\e$(C$5$A$)\e(B"    "\e$(C<#\e(B")
+   ("\e$(C$5$A$1\e(B"    "\e$(C<$\e(B")
+   ("\e$(C$5$A$2\e(B"    "\e$(C<%\e(B")
+   ("\e$(C$5$A$5\e(B"    "\e$(C<&\e(B")
+   ("\e$(C$5$A$7\e(B"    "\e$(C<'\e(B")
+
+   ("\e$(C$5$B\e(B"      "\e$(C<(\e(B")
+   ("\e$(C$5$B$$\e(B"    "\e$(C<)\e(B")
+   ("\e$(C$5$B$)\e(B"    "\e$(C<*\e(B")
+   ("\e$(C$5$B$1\e(B"    "\e$(C<+\e(B")
+   ("\e$(C$5$B$7\e(B"    "\e$(C<,\e(B")
+
+   ("\e$(C$5$C\e(B"      "\e$(C<-\e(B")
+   ("\e$(C$5$C$!\e(B"    "\e$(C<.\e(B")
+   ("\e$(C$5$C$!$5\e(B"  "\e$(C<0\e(B")
+   ("\e$(C$5$C$"\e(B"    "\e$(C</\e(B")
+   ("\e$(C$5$C$$\e(B"    "\e$(C<1\e(B")
+   ("\e$(C$5$C$'\e(B"    "\e$(C<2\e(B")
+   ("\e$(C$5$C$)\e(B"    "\e$(C<3\e(B")
+   ("\e$(C$5$C$)$1\e(B"  "\e$(C<4\e(B")
+   ("\e$(C$5$C$)$2\e(B"  "\e$(C<5\e(B")
+   ("\e$(C$5$C$1\e(B"    "\e$(C<6\e(B")
+   ("\e$(C$5$C$2\e(B"    "\e$(C<7\e(B")
+   ("\e$(C$5$C$5\e(B"    "\e$(C<8\e(B")
+   ("\e$(C$5$C$6\e(B"    "\e$(C<9\e(B")
+   ("\e$(C$5$C$7\e(B"    "\e$(C<:\e(B")
+   ("\e$(C$5$C$=\e(B"    "\e$(C<;\e(B")
+
+   ("\e$(C$5$D\e(B"      "\e$(C<<\e(B")
+   ("\e$(C$5$D$!\e(B"    "\e$(C<=\e(B")
+   ("\e$(C$5$D$$\e(B"    "\e$(C<>\e(B")
+   ("\e$(C$5$D$)\e(B"    "\e$(C<?\e(B")
+   ("\e$(C$5$D$1\e(B"    "\e$(C<@\e(B")
+   ("\e$(C$5$D$2\e(B"    "\e$(C<A\e(B")
+   ("\e$(C$5$D$5\e(B"    "\e$(C<B\e(B")
+   ("\e$(C$5$D$6\e(B"    "\e$(C<C\e(B")
+   ("\e$(C$5$D$7\e(B"    "\e$(C<D\e(B")
+
+   ("\e$(C$5$E\e(B"      "\e$(C<E\e(B")
+   ("\e$(C$5$E$!\e(B"    "\e$(C<F\e(B")
+   ("\e$(C$5$E$$\e(B"    "\e$(C<G\e(B")
+   ("\e$(C$5$E$)\e(B"    "\e$(C<H\e(B")
+   ("\e$(C$5$E$1\e(B"    "\e$(C<I\e(B")
+   ("\e$(C$5$E$2\e(B"    "\e$(C<J\e(B")
+   ("\e$(C$5$E$5\e(B"    "\e$(C<K\e(B")
+   ("\e$(C$5$E$6\e(B"    "\e$(C<L\e(B")
+   ("\e$(C$5$E$7\e(B"    "\e$(C<M\e(B")
+
+   ("\e$(C$5$F\e(B"      "\e$(C<N\e(B")
+   ("\e$(C$5$F$$\e(B"    "\e$(C<O\e(B")
+   ("\e$(C$5$F$)\e(B"    "\e$(C<P\e(B")
+   ("\e$(C$5$F$7\e(B"    "\e$(C<Q\e(B")
+
+   ("\e$(C$5$G\e(B"      "\e$(C<R\e(B")
+   ("\e$(C$5$G$!\e(B"    "\e$(C<S\e(B")
+   ("\e$(C$5$G$"\e(B"    "\e$(C<T\e(B")
+   ("\e$(C$5$G$$\e(B"    "\e$(C<U\e(B")
+   ("\e$(C$5$G$)\e(B"    "\e$(C<V\e(B")
+   ("\e$(C$5$G$)$1\e(B"  "\e$(C<W\e(B")
+   ("\e$(C$5$G$1\e(B"    "\e$(C<X\e(B")
+   ("\e$(C$5$G$2\e(B"    "\e$(C<Y\e(B")
+   ("\e$(C$5$G$5\e(B"    "\e$(C<Z\e(B")
+   ("\e$(C$5$G$7\e(B"    "\e$(C<[\e(B")
+   ("\e$(C$5$G$<\e(B"    "\e$(C<\\e(B")
+
+   ("\e$(C$5$G$?\e(B"    "\e$(C<]\e(B")
+   ("\e$(C$5$G$?$!\e(B"  "\e$(C<^\e(B")
+   ("\e$(C$5$G$?$$\e(B"  "\e$(C<_\e(B")
+   ("\e$(C$5$G$?$)\e(B"  "\e$(C<`\e(B")
+   ("\e$(C$5$G$?$7\e(B"  "\e$(C<a\e(B")
+
+   ("\e$(C$5$G$@\e(B"    "\e$(C<b\e(B")
+   ("\e$(C$5$G$@$$\e(B"  "\e$(C<c\e(B")
+   ("\e$(C$5$G$@$)\e(B"  "\e$(C<d\e(B")
+   ("\e$(C$5$G$@$1\e(B"  "\e$(C<e\e(B")
+   ("\e$(C$5$G$@$5\e(B"  "\e$(C<f\e(B")
+   ("\e$(C$5$G$@$6\e(B"  "\e$(C<g\e(B")
+
+   ("\e$(C$5$G$S\e(B"    "\e$(C<h\e(B")
+   ("\e$(C$5$G$S$$\e(B"  "\e$(C<i\e(B")
+   ("\e$(C$5$G$S$)\e(B"  "\e$(C<j\e(B")
+   ("\e$(C$5$G$S$1\e(B"  "\e$(C<k\e(B")
+   ("\e$(C$5$G$S$2\e(B"  "\e$(C<l\e(B")
+   ("\e$(C$5$G$S$5\e(B"  "\e$(C<m\e(B")
+
+   ("\e$(C$5$K\e(B"      "\e$(C<n\e(B")
+   ("\e$(C$5$K$!\e(B"    "\e$(C<o\e(B")
+   ("\e$(C$5$K$$\e(B"    "\e$(C<p\e(B")
+   ("\e$(C$5$K$)\e(B"    "\e$(C<q\e(B")
+   ("\e$(C$5$K$1\e(B"    "\e$(C<r\e(B")
+   ("\e$(C$5$K$2\e(B"    "\e$(C<s\e(B")
+   ("\e$(C$5$K$5\e(B"    "\e$(C<t\e(B")
+   ("\e$(C$5$K$7\e(B"    "\e$(C<u\e(B")
+
+   ("\e$(C$5$L\e(B"      "\e$(C<v\e(B")
+   ("\e$(C$5$L$!\e(B"    "\e$(C<w\e(B")
+   ("\e$(C$5$L$$\e(B"    "\e$(C<x\e(B")
+   ("\e$(C$5$L$'\e(B"    "\e$(C<y\e(B")
+   ("\e$(C$5$L$)\e(B"    "\e$(C<z\e(B")
+   ("\e$(C$5$L$1\e(B"    "\e$(C<{\e(B")
+   ("\e$(C$5$L$2\e(B"    "\e$(C<|\e(B")
+   ("\e$(C$5$L$5\e(B"    "\e$(C<}\e(B")
+   ("\e$(C$5$L$7\e(B"    "\e$(C<~\e(B")
+   ("\e$(C$5$L$:\e(B"    "\e$(C=!\e(B")
+   ("\e$(C$5$L$<\e(B"    "\e$(C="\e(B")
+   ("\e$(C$5$L$=\e(B"    "\e$(C=#\e(B")
+
+   ("\e$(C$5$L$C\e(B"    "\e$(C=$\e(B")
+   ("\e$(C$5$L$C$6\e(B"  "\e$(C=%\e(B")
+
+   ("\e$(C$5$L$D\e(B"    "\e$(C=&\e(B")
+   ("\e$(C$5$L$D$!\e(B"  "\e$(C='\e(B")
+   ("\e$(C$5$L$D$$\e(B"  "\e$(C=(\e(B")
+   ("\e$(C$5$L$D$)\e(B"  "\e$(C=)\e(B")
+   ("\e$(C$5$L$D$1\e(B"  "\e$(C=*\e(B")
+   ("\e$(C$5$L$D$7\e(B"  "\e$(C=+\e(B")
+
+   ("\e$(C$5$L$S\e(B"    "\e$(C=,\e(B")
+   ("\e$(C$5$L$S$!\e(B"  "\e$(C=-\e(B")
+   ("\e$(C$5$L$S$$\e(B"  "\e$(C=.\e(B")
+   ("\e$(C$5$L$S$)\e(B"  "\e$(C=/\e(B")
+   ("\e$(C$5$L$S$1\e(B"  "\e$(C=0\e(B")
+   ("\e$(C$5$L$S$2\e(B"  "\e$(C=1\e(B")
+   ("\e$(C$5$L$S$5\e(B"  "\e$(C=2\e(B")
+   ("\e$(C$5$L$S$7\e(B"  "\e$(C=3\e(B")
+
+   ("\e$(C$5$P\e(B"      "\e$(C=4\e(B")
+   ("\e$(C$5$P$!\e(B"    "\e$(C=5\e(B")
+   ("\e$(C$5$P$)\e(B"    "\e$(C=6\e(B")
+   ("\e$(C$5$P$1\e(B"    "\e$(C=7\e(B")
+   ("\e$(C$5$P$5\e(B"    "\e$(C=8\e(B")
+   ("\e$(C$5$P$7\e(B"    "\e$(C=9\e(B")
+
+   ("\e$(C$5$Q\e(B"      "\e$(C=:\e(B")
+   ("\e$(C$5$Q$!\e(B"    "\e$(C=;\e(B")
+   ("\e$(C$5$Q$$\e(B"    "\e$(C=<\e(B")
+   ("\e$(C$5$Q$)\e(B"    "\e$(C==\e(B")
+   ("\e$(C$5$Q$)$!\e(B"  "\e$(C=>\e(B")
+   ("\e$(C$5$Q$1\e(B"    "\e$(C=?\e(B")
+   ("\e$(C$5$Q$2\e(B"    "\e$(C=@\e(B")
+   ("\e$(C$5$Q$5\e(B"    "\e$(C=A\e(B")
+   ("\e$(C$5$Q$7\e(B"    "\e$(C=B\e(B")
+
+   ("\e$(C$5$S\e(B"      "\e$(C=C\e(B")
+   ("\e$(C$5$S$!\e(B"    "\e$(C=D\e(B")
+   ("\e$(C$5$S$$\e(B"    "\e$(C=E\e(B")
+   ("\e$(C$5$S$'\e(B"    "\e$(C=F\e(B")
+   ("\e$(C$5$S$)\e(B"    "\e$(C=G\e(B")
+   ("\e$(C$5$S$)$>\e(B"  "\e$(C=H\e(B")
+   ("\e$(C$5$S$1\e(B"    "\e$(C=I\e(B")
+   ("\e$(C$5$S$2\e(B"    "\e$(C=J\e(B")
+   ("\e$(C$5$S$5\e(B"    "\e$(C=K\e(B")
+   ("\e$(C$5$S$7\e(B"    "\e$(C=L\e(B")
+   ("\e$(C$5$S$=\e(B"    "\e$(C=M\e(B")
+
+   ("\e$(C$6$?\e(B"      "\e$(C=N\e(B")
+   ("\e$(C$6$?$!\e(B"    "\e$(C=O\e(B")
+   ("\e$(C$6$?$!$5\e(B"  "\e$(C=P\e(B")
+   ("\e$(C$6$?$$\e(B"    "\e$(C=Q\e(B")
+   ("\e$(C$6$?$)\e(B"    "\e$(C=R\e(B")
+   ("\e$(C$6$?$1\e(B"    "\e$(C=S\e(B")
+   ("\e$(C$6$?$2\e(B"    "\e$(C=T\e(B")
+   ("\e$(C$6$?$6\e(B"    "\e$(C=U\e(B")
+   ("\e$(C$6$?$7\e(B"    "\e$(C=V\e(B")
+   ("\e$(C$6$?$>\e(B"    "\e$(C=W\e(B")
+
+   ("\e$(C$6$@\e(B"      "\e$(C=X\e(B")
+   ("\e$(C$6$@$!\e(B"    "\e$(C=Y\e(B")
+   ("\e$(C$6$@$$\e(B"    "\e$(C=Z\e(B")
+   ("\e$(C$6$@$)\e(B"    "\e$(C=[\e(B")
+   ("\e$(C$6$@$1\e(B"    "\e$(C=\\e(B")
+   ("\e$(C$6$@$2\e(B"    "\e$(C=]\e(B")
+   ("\e$(C$6$@$6\e(B"    "\e$(C=^\e(B")
+   ("\e$(C$6$@$7\e(B"    "\e$(C=_\e(B")
+
+   ("\e$(C$6$A$7\e(B"    "\e$(C=`\e(B")
+
+   ("\e$(C$6$C\e(B"      "\e$(C=a\e(B")
+   ("\e$(C$6$C$!\e(B"    "\e$(C=b\e(B")
+   ("\e$(C$6$C$$\e(B"    "\e$(C=c\e(B")
+   ("\e$(C$6$C$)\e(B"    "\e$(C=d\e(B")
+   ("\e$(C$6$C$)$2\e(B"  "\e$(C=e\e(B")
+   ("\e$(C$6$C$1\e(B"    "\e$(C=f\e(B")
+   ("\e$(C$6$C$2\e(B"    "\e$(C=g\e(B")
+   ("\e$(C$6$C$6\e(B"    "\e$(C=h\e(B")
+   ("\e$(C$6$C$7\e(B"    "\e$(C=i\e(B")
+
+   ("\e$(C$6$D\e(B"      "\e$(C=j\e(B")
+   ("\e$(C$6$D$$\e(B"    "\e$(C=k\e(B")
+   ("\e$(C$6$D$)\e(B"    "\e$(C=l\e(B")
+
+   ("\e$(C$6$F$$\e(B"    "\e$(C=m\e(B")
+
+   ("\e$(C$6$G\e(B"      "\e$(C=n\e(B")
+   ("\e$(C$6$G$!\e(B"    "\e$(C=o\e(B")
+   ("\e$(C$6$G$$\e(B"    "\e$(C=p\e(B")
+   ("\e$(C$6$G$'\e(B"    "\e$(C=q\e(B")
+   ("\e$(C$6$G$)\e(B"    "\e$(C=r\e(B")
+   ("\e$(C$6$G$)$1\e(B"  "\e$(C=s\e(B")
+   ("\e$(C$6$G$1\e(B"    "\e$(C=t\e(B")
+   ("\e$(C$6$G$2\e(B"    "\e$(C=u\e(B")
+   ("\e$(C$6$G$7\e(B"    "\e$(C=v\e(B")
+
+   ("\e$(C$6$G$?\e(B"    "\e$(C=w\e(B")
+   ("\e$(C$6$G$?$!\e(B"  "\e$(C=x\e(B")
+   ("\e$(C$6$G$?$$\e(B"  "\e$(C=y\e(B")
+   ("\e$(C$6$G$?$6\e(B"  "\e$(C=z\e(B")
+
+   ("\e$(C$6$G$@\e(B"    "\e$(C={\e(B")
+   ("\e$(C$6$G$@$6\e(B"  "\e$(C=|\e(B")
+
+   ("\e$(C$6$G$S\e(B"    "\e$(C=}\e(B")
+   ("\e$(C$6$G$S$$\e(B"  "\e$(C=~\e(B")
+   ("\e$(C$6$G$S$)\e(B"  "\e$(C>!\e(B")
+   ("\e$(C$6$G$S$1\e(B"  "\e$(C>"\e(B")
+   ("\e$(C$6$G$S$2\e(B"  "\e$(C>#\e(B")
+
+   ("\e$(C$6$K\e(B"      "\e$(C>$\e(B")
+
+   ("\e$(C$6$L\e(B"      "\e$(C>%\e(B")
+   ("\e$(C$6$L$!\e(B"    "\e$(C>&\e(B")
+   ("\e$(C$6$L$$\e(B"    "\e$(C>'\e(B")
+   ("\e$(C$6$L$)\e(B"    "\e$(C>(\e(B")
+   ("\e$(C$6$L$1\e(B"    "\e$(C>)\e(B")
+   ("\e$(C$6$L$2\e(B"    "\e$(C>*\e(B")
+   ("\e$(C$6$L$7\e(B"    "\e$(C>+\e(B")
+
+   ("\e$(C$6$L$C\e(B"    "\e$(C>,\e(B")
+   ("\e$(C$6$L$C$6\e(B"  "\e$(C>-\e(B")
+
+   ("\e$(C$6$L$D\e(B"    "\e$(C>.\e(B")
+
+   ("\e$(C$6$L$S\e(B"    "\e$(C>/\e(B")
+   ("\e$(C$6$L$S$$\e(B"  "\e$(C>0\e(B")
+
+   ("\e$(C$6$P$7\e(B"    "\e$(C>1\e(B")
+
+   ("\e$(C$6$Q\e(B"      "\e$(C>2\e(B")
+   ("\e$(C$6$Q$!\e(B"    "\e$(C>3\e(B")
+   ("\e$(C$6$Q$$\e(B"    "\e$(C>4\e(B")
+   ("\e$(C$6$Q$)\e(B"    "\e$(C>5\e(B")
+   ("\e$(C$6$Q$)$1\e(B"  "\e$(C>6\e(B")
+   ("\e$(C$6$Q$)$>\e(B"  "\e$(C>7\e(B")
+   ("\e$(C$6$Q$1\e(B"    "\e$(C>8\e(B")
+   ("\e$(C$6$Q$2\e(B"    "\e$(C>9\e(B")
+
+   ("\e$(C$6$Q$S\e(B"    "\e$(C>:\e(B")
+   ("\e$(C$6$Q$S$$\e(B"  "\e$(C>;\e(B")
+   ("\e$(C$6$Q$S$)\e(B"  "\e$(C><\e(B")
+   ("\e$(C$6$Q$S$1\e(B"  "\e$(C>=\e(B")
+
+   ("\e$(C$6$S\e(B"      "\e$(C>>\e(B")
+   ("\e$(C$6$S$!\e(B"    "\e$(C>?\e(B")
+   ("\e$(C$6$S$$\e(B"    "\e$(C>@\e(B")
+   ("\e$(C$6$S$)\e(B"    "\e$(C>A\e(B")
+   ("\e$(C$6$S$1\e(B"    "\e$(C>B\e(B")
+   ("\e$(C$6$S$2\e(B"    "\e$(C>C\e(B")
+   ("\e$(C$6$S$5\e(B"    "\e$(C>D\e(B")
+   ("\e$(C$6$S$7\e(B"    "\e$(C>E\e(B")
+
+   ("\e$(C$7$?\e(B"      "\e$(C>F\e(B")
+   ("\e$(C$7$?$!\e(B"    "\e$(C>G\e(B")
+   ("\e$(C$7$?$$\e(B"    "\e$(C>H\e(B")
+   ("\e$(C$7$?$$$8\e(B"  "\e$(C>I\e(B")
+   ("\e$(C$7$?$$$>\e(B"  "\e$(C>J\e(B")
+   ("\e$(C$7$?$)\e(B"    "\e$(C>K\e(B")
+   ("\e$(C$7$?$)$!\e(B"  "\e$(C>L\e(B")
+   ("\e$(C$7$?$)$1\e(B"  "\e$(C>M\e(B")
+   ("\e$(C$7$?$)$>\e(B"  "\e$(C>N\e(B")
+   ("\e$(C$7$?$1\e(B"    "\e$(C>O\e(B")
+   ("\e$(C$7$?$2\e(B"    "\e$(C>P\e(B")
+   ("\e$(C$7$?$5\e(B"    "\e$(C>Q\e(B")
+   ("\e$(C$7$?$6\e(B"    "\e$(C>R\e(B")
+   ("\e$(C$7$?$7\e(B"    "\e$(C>S\e(B")
+   ("\e$(C$7$?$<\e(B"    "\e$(C>T\e(B")
+   ("\e$(C$7$?$=\e(B"    "\e$(C>U\e(B")
+
+   ("\e$(C$7$@\e(B"      "\e$(C>V\e(B")
+   ("\e$(C$7$@$!\e(B"    "\e$(C>W\e(B")
+   ("\e$(C$7$@$$\e(B"    "\e$(C>X\e(B")
+   ("\e$(C$7$@$)\e(B"    "\e$(C>Y\e(B")
+   ("\e$(C$7$@$1\e(B"    "\e$(C>Z\e(B")
+   ("\e$(C$7$@$2\e(B"    "\e$(C>[\e(B")
+   ("\e$(C$7$@$5\e(B"    "\e$(C>\\e(B")
+   ("\e$(C$7$@$6\e(B"    "\e$(C>]\e(B")
+   ("\e$(C$7$@$7\e(B"    "\e$(C>^\e(B")
+
+   ("\e$(C$7$A\e(B"      "\e$(C>_\e(B")
+   ("\e$(C$7$A$!\e(B"    "\e$(C>`\e(B")
+   ("\e$(C$7$A$$\e(B"    "\e$(C>a\e(B")
+   ("\e$(C$7$A$)\e(B"    "\e$(C>b\e(B")
+   ("\e$(C$7$A$)$2\e(B"  "\e$(C>c\e(B")
+   ("\e$(C$7$A$1\e(B"    "\e$(C>d\e(B")
+   ("\e$(C$7$A$2\e(B"    "\e$(C>e\e(B")
+   ("\e$(C$7$A$5\e(B"    "\e$(C>f\e(B")
+   ("\e$(C$7$A$7\e(B"    "\e$(C>g\e(B")
+   ("\e$(C$7$A$<\e(B"    "\e$(C>h\e(B")
+   ("\e$(C$7$A$>\e(B"    "\e$(C>i\e(B")
+
+   ("\e$(C$7$B\e(B"      "\e$(C>j\e(B")
+   ("\e$(C$7$B$$\e(B"    "\e$(C>k\e(B")
+   ("\e$(C$7$B$)\e(B"    "\e$(C>l\e(B")
+   ("\e$(C$7$B$2\e(B"    "\e$(C>m\e(B")
+
+   ("\e$(C$7$C\e(B"      "\e$(C>n\e(B")
+   ("\e$(C$7$C$!\e(B"    "\e$(C>o\e(B")
+   ("\e$(C$7$C$$\e(B"    "\e$(C>p\e(B")
+   ("\e$(C$7$C$$$8\e(B"  "\e$(C>q\e(B")
+   ("\e$(C$7$C$'\e(B"    "\e$(C>r\e(B")
+   ("\e$(C$7$C$)\e(B"    "\e$(C>s\e(B")
+   ("\e$(C$7$C$)$!\e(B"  "\e$(C>t\e(B")
+   ("\e$(C$7$C$)$1\e(B"  "\e$(C>u\e(B")
+   ("\e$(C$7$C$1\e(B"    "\e$(C>v\e(B")
+   ("\e$(C$7$C$2\e(B"    "\e$(C>w\e(B")
+   ("\e$(C$7$C$2$5\e(B"  "\e$(C>x\e(B")
+   ("\e$(C$7$C$5\e(B"    "\e$(C>y\e(B")
+   ("\e$(C$7$C$6\e(B"    "\e$(C>z\e(B")
+   ("\e$(C$7$C$7\e(B"    "\e$(C>{\e(B")
+   ("\e$(C$7$C$8\e(B"    "\e$(C>|\e(B")
+   ("\e$(C$7$C$;\e(B"    "\e$(C>}\e(B")
+   ("\e$(C$7$C$=\e(B"    "\e$(C>~\e(B")
+
+   ("\e$(C$7$D\e(B"      "\e$(C?!\e(B")
+   ("\e$(C$7$D$!\e(B"    "\e$(C?"\e(B")
+   ("\e$(C$7$D$$\e(B"    "\e$(C?#\e(B")
+   ("\e$(C$7$D$)\e(B"    "\e$(C?$\e(B")
+   ("\e$(C$7$D$1\e(B"    "\e$(C?%\e(B")
+   ("\e$(C$7$D$2\e(B"    "\e$(C?&\e(B")
+   ("\e$(C$7$D$5\e(B"    "\e$(C?'\e(B")
+   ("\e$(C$7$D$7\e(B"    "\e$(C?(\e(B")
+
+   ("\e$(C$7$E\e(B"      "\e$(C?)\e(B")
+   ("\e$(C$7$E$!\e(B"    "\e$(C?*\e(B")
+   ("\e$(C$7$E$"\e(B"    "\e$(C?+\e(B")
+   ("\e$(C$7$E$$\e(B"    "\e$(C?,\e(B")
+   ("\e$(C$7$E$)\e(B"    "\e$(C?-\e(B")
+   ("\e$(C$7$E$)$1\e(B"  "\e$(C?.\e(B")
+   ("\e$(C$7$E$)$2\e(B"  "\e$(C?/\e(B")
+   ("\e$(C$7$E$1\e(B"    "\e$(C?0\e(B")
+   ("\e$(C$7$E$2\e(B"    "\e$(C?1\e(B")
+   ("\e$(C$7$E$2$5\e(B"  "\e$(C?2\e(B")
+   ("\e$(C$7$E$5\e(B"    "\e$(C?3\e(B")
+   ("\e$(C$7$E$6\e(B"    "\e$(C?4\e(B")
+   ("\e$(C$7$E$7\e(B"    "\e$(C?5\e(B")
+   ("\e$(C$7$E$<\e(B"    "\e$(C?6\e(B")
+   ("\e$(C$7$E$=\e(B"    "\e$(C?7\e(B")
+   ("\e$(C$7$E$>\e(B"    "\e$(C?8\e(B")
+
+   ("\e$(C$7$F\e(B"      "\e$(C?9\e(B")
+   ("\e$(C$7$F$$\e(B"    "\e$(C?:\e(B")
+   ("\e$(C$7$F$)\e(B"    "\e$(C?;\e(B")
+   ("\e$(C$7$F$1\e(B"    "\e$(C?<\e(B")
+   ("\e$(C$7$F$2\e(B"    "\e$(C?=\e(B")
+   ("\e$(C$7$F$5\e(B"    "\e$(C?>\e(B")
+   ("\e$(C$7$F$6\e(B"    "\e$(C??\e(B")
+
+   ("\e$(C$7$G\e(B"      "\e$(C?@\e(B")
+   ("\e$(C$7$G$!\e(B"    "\e$(C?A\e(B")
+   ("\e$(C$7$G$$\e(B"    "\e$(C?B\e(B")
+   ("\e$(C$7$G$)\e(B"    "\e$(C?C\e(B")
+   ("\e$(C$7$G$)$!\e(B"  "\e$(C?D\e(B")
+   ("\e$(C$7$G$)$1\e(B"  "\e$(C?E\e(B")
+   ("\e$(C$7$G$)$5\e(B"  "\e$(C?F\e(B")
+   ("\e$(C$7$G$)$>\e(B"  "\e$(C?G\e(B")
+   ("\e$(C$7$G$1\e(B"    "\e$(C?H\e(B")
+   ("\e$(C$7$G$2\e(B"    "\e$(C?I\e(B")
+   ("\e$(C$7$G$5\e(B"    "\e$(C?J\e(B")
+   ("\e$(C$7$G$7\e(B"    "\e$(C?K\e(B")
+   ("\e$(C$7$G$:\e(B"    "\e$(C?L\e(B")
+
+   ("\e$(C$7$G$?\e(B"    "\e$(C?M\e(B")
+   ("\e$(C$7$G$?$!\e(B"  "\e$(C?N\e(B")
+   ("\e$(C$7$G$?$$\e(B"  "\e$(C?O\e(B")
+   ("\e$(C$7$G$?$)\e(B"  "\e$(C?P\e(B")
+   ("\e$(C$7$G$?$1\e(B"  "\e$(C?Q\e(B")
+   ("\e$(C$7$G$?$2\e(B"  "\e$(C?R\e(B")
+   ("\e$(C$7$G$?$5\e(B"  "\e$(C?S\e(B")
+   ("\e$(C$7$G$?$6\e(B"  "\e$(C?T\e(B")
+   ("\e$(C$7$G$?$7\e(B"  "\e$(C?U\e(B")
+
+   ("\e$(C$7$G$@\e(B"    "\e$(C?V\e(B")
+   ("\e$(C$7$G$@$!\e(B"  "\e$(C?W\e(B")
+   ("\e$(C$7$G$@$$\e(B"  "\e$(C?X\e(B")
+   ("\e$(C$7$G$@$1\e(B"  "\e$(C?Y\e(B")
+   ("\e$(C$7$G$@$5\e(B"  "\e$(C?Z\e(B")
+   ("\e$(C$7$G$@$7\e(B"  "\e$(C?[\e(B")
+
+   ("\e$(C$7$G$S\e(B"    "\e$(C?\\e(B")
+   ("\e$(C$7$G$S$!\e(B"  "\e$(C?]\e(B")
+   ("\e$(C$7$G$S$$\e(B"  "\e$(C?^\e(B")
+   ("\e$(C$7$G$S$)\e(B"  "\e$(C?_\e(B")
+   ("\e$(C$7$G$S$1\e(B"  "\e$(C?`\e(B")
+   ("\e$(C$7$G$S$2\e(B"  "\e$(C?a\e(B")
+   ("\e$(C$7$G$S$5\e(B"  "\e$(C?b\e(B")
+   ("\e$(C$7$G$S$7\e(B"  "\e$(C?c\e(B")
+
+   ("\e$(C$7$K\e(B"      "\e$(C?d\e(B")
+   ("\e$(C$7$K$!\e(B"    "\e$(C?e\e(B")
+   ("\e$(C$7$K$$\e(B"    "\e$(C?f\e(B")
+   ("\e$(C$7$K$)\e(B"    "\e$(C?g\e(B")
+   ("\e$(C$7$K$1\e(B"    "\e$(C?h\e(B")
+   ("\e$(C$7$K$2\e(B"    "\e$(C?i\e(B")
+   ("\e$(C$7$K$5\e(B"    "\e$(C?j\e(B")
+   ("\e$(C$7$K$7\e(B"    "\e$(C?k\e(B")
+
+   ("\e$(C$7$L\e(B"      "\e$(C?l\e(B")
+   ("\e$(C$7$L$!\e(B"    "\e$(C?m\e(B")
+   ("\e$(C$7$L$$\e(B"    "\e$(C?n\e(B")
+   ("\e$(C$7$L$)\e(B"    "\e$(C?o\e(B")
+   ("\e$(C$7$L$)$!\e(B"  "\e$(C?p\e(B")
+   ("\e$(C$7$L$)$1\e(B"  "\e$(C?q\e(B")
+   ("\e$(C$7$L$1\e(B"    "\e$(C?r\e(B")
+   ("\e$(C$7$L$2\e(B"    "\e$(C?s\e(B")
+   ("\e$(C$7$L$5\e(B"    "\e$(C?t\e(B")
+   ("\e$(C$7$L$7\e(B"    "\e$(C?u\e(B")
+
+   ("\e$(C$7$L$C\e(B"    "\e$(C?v\e(B")
+   ("\e$(C$7$L$C$!\e(B"  "\e$(C?w\e(B")
+   ("\e$(C$7$L$C$$\e(B"  "\e$(C?x\e(B")
+   ("\e$(C$7$L$C$)\e(B"  "\e$(C?y\e(B")
+   ("\e$(C$7$L$C$1\e(B"  "\e$(C?z\e(B")
+   ("\e$(C$7$L$C$2\e(B"  "\e$(C?{\e(B")
+   ("\e$(C$7$L$C$6\e(B"  "\e$(C?|\e(B")
+   ("\e$(C$7$L$C$7\e(B"  "\e$(C?}\e(B")
+
+   ("\e$(C$7$L$D\e(B"    "\e$(C?~\e(B")
+   ("\e$(C$7$L$D$!\e(B"  "\e$(C@!\e(B")
+   ("\e$(C$7$L$D$$\e(B"  "\e$(C@"\e(B")
+   ("\e$(C$7$L$D$)\e(B"  "\e$(C@#\e(B")
+   ("\e$(C$7$L$D$1\e(B"  "\e$(C@$\e(B")
+   ("\e$(C$7$L$D$2\e(B"  "\e$(C@%\e(B")
+   ("\e$(C$7$L$D$7\e(B"  "\e$(C@&\e(B")
+
+   ("\e$(C$7$L$S\e(B"    "\e$(C@'\e(B")
+   ("\e$(C$7$L$S$!\e(B"  "\e$(C@(\e(B")
+   ("\e$(C$7$L$S$$\e(B"  "\e$(C@)\e(B")
+   ("\e$(C$7$L$S$)\e(B"  "\e$(C@*\e(B")
+   ("\e$(C$7$L$S$1\e(B"  "\e$(C@+\e(B")
+   ("\e$(C$7$L$S$2\e(B"  "\e$(C@,\e(B")
+   ("\e$(C$7$L$S$5\e(B"  "\e$(C@-\e(B")
+   ("\e$(C$7$L$S$7\e(B"  "\e$(C@.\e(B")
+
+   ("\e$(C$7$P\e(B"      "\e$(C@/\e(B")
+   ("\e$(C$7$P$!\e(B"    "\e$(C@0\e(B")
+   ("\e$(C$7$P$$\e(B"    "\e$(C@1\e(B")
+   ("\e$(C$7$P$)\e(B"    "\e$(C@2\e(B")
+   ("\e$(C$7$P$1\e(B"    "\e$(C@3\e(B")
+   ("\e$(C$7$P$2\e(B"    "\e$(C@4\e(B")
+   ("\e$(C$7$P$5\e(B"    "\e$(C@5\e(B")
+   ("\e$(C$7$P$7\e(B"    "\e$(C@6\e(B")
+   ("\e$(C$7$P$:\e(B"    "\e$(C@7\e(B")
+
+   ("\e$(C$7$Q\e(B"      "\e$(C@8\e(B")
+   ("\e$(C$7$Q$!\e(B"    "\e$(C@9\e(B")
+   ("\e$(C$7$Q$$\e(B"    "\e$(C@:\e(B")
+   ("\e$(C$7$Q$)\e(B"    "\e$(C@;\e(B")
+   ("\e$(C$7$Q$)$=\e(B"  "\e$(C@<\e(B")
+   ("\e$(C$7$Q$1\e(B"    "\e$(C@=\e(B")
+   ("\e$(C$7$Q$2\e(B"    "\e$(C@>\e(B")
+   ("\e$(C$7$Q$5\e(B"    "\e$(C@?\e(B")
+   ("\e$(C$7$Q$7\e(B"    "\e$(C@@\e(B")
+   ("\e$(C$7$Q$8\e(B"    "\e$(C@A\e(B")
+   ("\e$(C$7$Q$:\e(B"    "\e$(C@B\e(B")
+   ("\e$(C$7$Q$;\e(B"    "\e$(C@C\e(B")
+   ("\e$(C$7$Q$<\e(B"    "\e$(C@D\e(B")
+   ("\e$(C$7$Q$=\e(B"    "\e$(C@E\e(B")
+   ("\e$(C$7$Q$>\e(B"    "\e$(C@F\e(B")
+
+   ("\e$(C$7$Q$S\e(B"    "\e$(C@G\e(B")
+   ("\e$(C$7$Q$S$$\e(B"  "\e$(C@H\e(B")
+   ("\e$(C$7$Q$S$)\e(B"  "\e$(C@I\e(B")
+   ("\e$(C$7$Q$S$1\e(B"  "\e$(C@J\e(B")
+   ("\e$(C$7$Q$S$5\e(B"  "\e$(C@K\e(B")
+
+   ("\e$(C$7$S\e(B"      "\e$(C@L\e(B")
+   ("\e$(C$7$S$!\e(B"    "\e$(C@M\e(B")
+   ("\e$(C$7$S$$\e(B"    "\e$(C@N\e(B")
+   ("\e$(C$7$S$)\e(B"    "\e$(C@O\e(B")
+   ("\e$(C$7$S$)$!\e(B"  "\e$(C@P\e(B")
+   ("\e$(C$7$S$)$1\e(B"  "\e$(C@Q\e(B")
+   ("\e$(C$7$S$)$>\e(B"  "\e$(C@R\e(B")
+   ("\e$(C$7$S$1\e(B"    "\e$(C@S\e(B")
+   ("\e$(C$7$S$2\e(B"    "\e$(C@T\e(B")
+   ("\e$(C$7$S$5\e(B"    "\e$(C@U\e(B")
+   ("\e$(C$7$S$6\e(B"    "\e$(C@V\e(B")
+   ("\e$(C$7$S$7\e(B"    "\e$(C@W\e(B")
+   ("\e$(C$7$S$8\e(B"    "\e$(C@X\e(B")
+   ("\e$(C$7$S$=\e(B"    "\e$(C@Y\e(B")
+
+   ("\e$(C$8$?\e(B"      "\e$(C@Z\e(B")
+   ("\e$(C$8$?$!\e(B"    "\e$(C@[\e(B")
+   ("\e$(C$8$?$$\e(B"    "\e$(C@\\e(B")
+   ("\e$(C$8$?$$$>\e(B"  "\e$(C@]\e(B")
+   ("\e$(C$8$?$'\e(B"    "\e$(C@^\e(B")
+   ("\e$(C$8$?$)\e(B"    "\e$(C@_\e(B")
+   ("\e$(C$8$?$)$1\e(B"  "\e$(C@`\e(B")
+   ("\e$(C$8$?$1\e(B"    "\e$(C@a\e(B")
+   ("\e$(C$8$?$2\e(B"    "\e$(C@b\e(B")
+   ("\e$(C$8$?$5\e(B"    "\e$(C@c\e(B")
+   ("\e$(C$8$?$6\e(B"    "\e$(C@d\e(B")
+   ("\e$(C$8$?$7\e(B"    "\e$(C@e\e(B")
+   ("\e$(C$8$?$8\e(B"    "\e$(C@f\e(B")
+
+   ("\e$(C$8$@\e(B"      "\e$(C@g\e(B")
+   ("\e$(C$8$@$!\e(B"    "\e$(C@h\e(B")
+   ("\e$(C$8$@$$\e(B"    "\e$(C@i\e(B")
+   ("\e$(C$8$@$)\e(B"    "\e$(C@j\e(B")
+   ("\e$(C$8$@$1\e(B"    "\e$(C@k\e(B")
+   ("\e$(C$8$@$2\e(B"    "\e$(C@l\e(B")
+   ("\e$(C$8$@$5\e(B"    "\e$(C@m\e(B")
+   ("\e$(C$8$@$6\e(B"    "\e$(C@n\e(B")
+   ("\e$(C$8$@$7\e(B"    "\e$(C@o\e(B")
+
+   ("\e$(C$8$A\e(B"      "\e$(C@p\e(B")
+   ("\e$(C$8$A$!\e(B"    "\e$(C@q\e(B")
+   ("\e$(C$8$A$$\e(B"    "\e$(C@r\e(B")
+   ("\e$(C$8$A$$$>\e(B"  "\e$(C@s\e(B")
+   ("\e$(C$8$A$)\e(B"    "\e$(C@t\e(B")
+   ("\e$(C$8$A$1\e(B"    "\e$(C@u\e(B")
+   ("\e$(C$8$A$7\e(B"    "\e$(C@v\e(B")
+
+   ("\e$(C$8$B\e(B"      "\e$(C@w\e(B")
+   ("\e$(C$8$B$$\e(B"    "\e$(C@x\e(B")
+   ("\e$(C$8$B$)\e(B"    "\e$(C@y\e(B")
+
+   ("\e$(C$8$C\e(B"      "\e$(C@z\e(B")
+   ("\e$(C$8$C$!\e(B"    "\e$(C@{\e(B")
+   ("\e$(C$8$C$$\e(B"    "\e$(C@|\e(B")
+   ("\e$(C$8$C$)\e(B"    "\e$(C@}\e(B")
+   ("\e$(C$8$C$)$1\e(B"  "\e$(C@~\e(B")
+   ("\e$(C$8$C$1\e(B"    "\e$(CA!\e(B")
+   ("\e$(C$8$C$2\e(B"    "\e$(CA"\e(B")
+   ("\e$(C$8$C$5\e(B"    "\e$(CA#\e(B")
+   ("\e$(C$8$C$7\e(B"    "\e$(CA$\e(B")
+   ("\e$(C$8$C$8\e(B"    "\e$(CA%\e(B")
+
+   ("\e$(C$8$D\e(B"      "\e$(CA&\e(B")
+   ("\e$(C$8$D$!\e(B"    "\e$(CA'\e(B")
+   ("\e$(C$8$D$$\e(B"    "\e$(CA(\e(B")
+   ("\e$(C$8$D$)\e(B"    "\e$(CA)\e(B")
+   ("\e$(C$8$D$1\e(B"    "\e$(CA*\e(B")
+   ("\e$(C$8$D$2\e(B"    "\e$(CA+\e(B")
+   ("\e$(C$8$D$5\e(B"    "\e$(CA,\e(B")
+   ("\e$(C$8$D$7\e(B"    "\e$(CA-\e(B")
+
+   ("\e$(C$8$E\e(B"      "\e$(CA.\e(B")
+   ("\e$(C$8$E$$\e(B"    "\e$(CA/\e(B")
+   ("\e$(C$8$E$)\e(B"    "\e$(CA0\e(B")
+   ("\e$(C$8$E$1\e(B"    "\e$(CA1\e(B")
+   ("\e$(C$8$E$2\e(B"    "\e$(CA2\e(B")
+   ("\e$(C$8$E$6\e(B"    "\e$(CA3\e(B")
+   ("\e$(C$8$E$7\e(B"    "\e$(CA4\e(B")
+
+   ("\e$(C$8$F\e(B"      "\e$(CA5\e(B")
+
+   ("\e$(C$8$G\e(B"      "\e$(CA6\e(B")
+   ("\e$(C$8$G$!\e(B"    "\e$(CA7\e(B")
+   ("\e$(C$8$G$$\e(B"    "\e$(CA8\e(B")
+   ("\e$(C$8$G$)\e(B"    "\e$(CA9\e(B")
+   ("\e$(C$8$G$)$1\e(B"  "\e$(CA:\e(B")
+   ("\e$(C$8$G$1\e(B"    "\e$(CA;\e(B")
+   ("\e$(C$8$G$2\e(B"    "\e$(CA<\e(B")
+   ("\e$(C$8$G$5\e(B"    "\e$(CA=\e(B")
+   ("\e$(C$8$G$7\e(B"    "\e$(CA>\e(B")
+   ("\e$(C$8$G$8\e(B"    "\e$(CA?\e(B")
+   ("\e$(C$8$G$:\e(B"    "\e$(CA@\e(B")
+   ("\e$(C$8$G$>\e(B"    "\e$(CAA\e(B")
+
+   ("\e$(C$8$G$?\e(B"    "\e$(CAB\e(B")
+   ("\e$(C$8$G$?$!\e(B"  "\e$(CAC\e(B")
+   ("\e$(C$8$G$?$)\e(B"  "\e$(CAD\e(B")
+   ("\e$(C$8$G$?$2\e(B"  "\e$(CAE\e(B")
+   ("\e$(C$8$G$?$5\e(B"  "\e$(CAF\e(B")
+   ("\e$(C$8$G$?$7\e(B"  "\e$(CAG\e(B")
+
+   ("\e$(C$8$G$@\e(B"    "\e$(CAH\e(B")
+   ("\e$(C$8$G$@$6\e(B"  "\e$(CAI\e(B")
+   ("\e$(C$8$G$@$7\e(B"  "\e$(CAJ\e(B")
+
+   ("\e$(C$8$G$S\e(B"    "\e$(CAK\e(B")
+   ("\e$(C$8$G$S$$\e(B"  "\e$(CAL\e(B")
+   ("\e$(C$8$G$S$)\e(B"  "\e$(CAM\e(B")
+   ("\e$(C$8$G$S$1\e(B"  "\e$(CAN\e(B")
+   ("\e$(C$8$G$S$2\e(B"  "\e$(CAO\e(B")
+   ("\e$(C$8$G$S$5\e(B"  "\e$(CAP\e(B")
+   ("\e$(C$8$G$S$7\e(B"  "\e$(CAQ\e(B")
+
+   ("\e$(C$8$K\e(B"      "\e$(CAR\e(B")
+   ("\e$(C$8$K$!\e(B"    "\e$(CAS\e(B")
+   ("\e$(C$8$K$$\e(B"    "\e$(CAT\e(B")
+   ("\e$(C$8$K$7\e(B"    "\e$(CAU\e(B")
+
+   ("\e$(C$8$L\e(B"      "\e$(CAV\e(B")
+   ("\e$(C$8$L$!\e(B"    "\e$(CAW\e(B")
+   ("\e$(C$8$L$$\e(B"    "\e$(CAX\e(B")
+   ("\e$(C$8$L$)\e(B"    "\e$(CAY\e(B")
+   ("\e$(C$8$L$)$!\e(B"  "\e$(CAZ\e(B")
+   ("\e$(C$8$L$)$1\e(B"  "\e$(CA[\e(B")
+   ("\e$(C$8$L$1\e(B"    "\e$(CA\\e(B")
+   ("\e$(C$8$L$2\e(B"    "\e$(CA]\e(B")
+   ("\e$(C$8$L$5\e(B"    "\e$(CA^\e(B")
+   ("\e$(C$8$L$7\e(B"    "\e$(CA_\e(B")
+
+   ("\e$(C$8$L$C\e(B"    "\e$(CA`\e(B")
+   ("\e$(C$8$L$C$6\e(B"  "\e$(CAa\e(B")
+
+   ("\e$(C$8$L$D\e(B"    "\e$(CAb\e(B")
+
+   ("\e$(C$8$L$S\e(B"    "\e$(CAc\e(B")
+   ("\e$(C$8$L$S$!\e(B"  "\e$(CAd\e(B")
+   ("\e$(C$8$L$S$$\e(B"  "\e$(CAe\e(B")
+   ("\e$(C$8$L$S$)\e(B"  "\e$(CAf\e(B")
+   ("\e$(C$8$L$S$1\e(B"  "\e$(CAg\e(B")
+   ("\e$(C$8$L$S$2\e(B"  "\e$(CAh\e(B")
+   ("\e$(C$8$L$S$5\e(B"  "\e$(CAi\e(B")
+
+   ("\e$(C$8$P\e(B"      "\e$(CAj\e(B")
+   ("\e$(C$8$P$$\e(B"    "\e$(CAk\e(B")
+   ("\e$(C$8$P$)\e(B"    "\e$(CAl\e(B")
+   ("\e$(C$8$P$1\e(B"    "\e$(CAm\e(B")
+
+   ("\e$(C$8$Q\e(B"      "\e$(CAn\e(B")
+   ("\e$(C$8$Q$!\e(B"    "\e$(CAo\e(B")
+   ("\e$(C$8$Q$$\e(B"    "\e$(CAp\e(B")
+   ("\e$(C$8$Q$)\e(B"    "\e$(CAq\e(B")
+   ("\e$(C$8$Q$1\e(B"    "\e$(CAr\e(B")
+   ("\e$(C$8$Q$2\e(B"    "\e$(CAs\e(B")
+   ("\e$(C$8$Q$5\e(B"    "\e$(CAt\e(B")
+   ("\e$(C$8$Q$7\e(B"    "\e$(CAu\e(B")
+
+   ("\e$(C$8$S\e(B"      "\e$(CAv\e(B")
+   ("\e$(C$8$S$!\e(B"    "\e$(CAw\e(B")
+   ("\e$(C$8$S$$\e(B"    "\e$(CAx\e(B")
+   ("\e$(C$8$S$'\e(B"    "\e$(CAy\e(B")
+   ("\e$(C$8$S$)\e(B"    "\e$(CAz\e(B")
+   ("\e$(C$8$S$)$1\e(B"  "\e$(CA{\e(B")
+   ("\e$(C$8$S$1\e(B"    "\e$(CA|\e(B")
+   ("\e$(C$8$S$2\e(B"    "\e$(CA}\e(B")
+   ("\e$(C$8$S$5\e(B"    "\e$(CA~\e(B")
+   ("\e$(C$8$S$7\e(B"    "\e$(CB!\e(B")
+   ("\e$(C$8$S$8\e(B"    "\e$(CB"\e(B")
+   ("\e$(C$8$S$<\e(B"    "\e$(CB#\e(B")
+   ("\e$(C$8$S$=\e(B"    "\e$(CB$\e(B")
+
+   ("\e$(C$9$?\e(B"      "\e$(CB%\e(B")
+   ("\e$(C$9$?$!\e(B"    "\e$(CB&\e(B")
+   ("\e$(C$9$?$$\e(B"    "\e$(CB'\e(B")
+   ("\e$(C$9$?$$$>\e(B"  "\e$(CB(\e(B")
+   ("\e$(C$9$?$)\e(B"    "\e$(CB)\e(B")
+   ("\e$(C$9$?$)$2\e(B"  "\e$(CB*\e(B")
+   ("\e$(C$9$?$1\e(B"    "\e$(CB+\e(B")
+   ("\e$(C$9$?$2\e(B"    "\e$(CB,\e(B")
+   ("\e$(C$9$?$5\e(B"    "\e$(CB-\e(B")
+   ("\e$(C$9$?$6\e(B"    "\e$(CB.\e(B")
+   ("\e$(C$9$?$7\e(B"    "\e$(CB/\e(B")
+
+   ("\e$(C$9$@\e(B"      "\e$(CB0\e(B")
+   ("\e$(C$9$@$!\e(B"    "\e$(CB1\e(B")
+   ("\e$(C$9$@$$\e(B"    "\e$(CB2\e(B")
+   ("\e$(C$9$@$)\e(B"    "\e$(CB3\e(B")
+   ("\e$(C$9$@$1\e(B"    "\e$(CB4\e(B")
+   ("\e$(C$9$@$2\e(B"    "\e$(CB5\e(B")
+   ("\e$(C$9$@$5\e(B"    "\e$(CB6\e(B")
+   ("\e$(C$9$@$6\e(B"    "\e$(CB7\e(B")
+   ("\e$(C$9$@$7\e(B"    "\e$(CB8\e(B")
+
+   ("\e$(C$9$A\e(B"      "\e$(CB9\e(B")
+   ("\e$(C$9$A$$\e(B"    "\e$(CB:\e(B")
+   ("\e$(C$9$A$7\e(B"    "\e$(CB;\e(B")
+
+   ("\e$(C$9$C\e(B"      "\e$(CB<\e(B")
+   ("\e$(C$9$C$!\e(B"    "\e$(CB=\e(B")
+   ("\e$(C$9$C$$\e(B"    "\e$(CB>\e(B")
+   ("\e$(C$9$C$)\e(B"    "\e$(CB?\e(B")
+   ("\e$(C$9$C$1\e(B"    "\e$(CB@\e(B")
+   ("\e$(C$9$C$2\e(B"    "\e$(CBA\e(B")
+   ("\e$(C$9$C$5\e(B"    "\e$(CBB\e(B")
+   ("\e$(C$9$C$6\e(B"    "\e$(CBC\e(B")
+   ("\e$(C$9$C$7\e(B"    "\e$(CBD\e(B")
+
+   ("\e$(C$9$D\e(B"      "\e$(CBE\e(B")
+   ("\e$(C$9$D$7\e(B"    "\e$(CBF\e(B")
+
+   ("\e$(C$9$E\e(B"      "\e$(CBG\e(B")
+   ("\e$(C$9$E$6\e(B"    "\e$(CBH\e(B")
+
+   ("\e$(C$9$G\e(B"      "\e$(CBI\e(B")
+   ("\e$(C$9$G$!\e(B"    "\e$(CBJ\e(B")
+   ("\e$(C$9$G$$\e(B"    "\e$(CBK\e(B")
+   ("\e$(C$9$G$)\e(B"    "\e$(CBL\e(B")
+   ("\e$(C$9$G$1\e(B"    "\e$(CBM\e(B")
+   ("\e$(C$9$G$2\e(B"    "\e$(CBN\e(B")
+   ("\e$(C$9$G$5\e(B"    "\e$(CBO\e(B")
+   ("\e$(C$9$G$7\e(B"    "\e$(CBP\e(B")
+   ("\e$(C$9$G$:\e(B"    "\e$(CBQ\e(B")
+
+   ("\e$(C$9$G$?\e(B"    "\e$(CBR\e(B")
+   ("\e$(C$9$G$?$!\e(B"  "\e$(CBS\e(B")
+   ("\e$(C$9$G$?$)\e(B"  "\e$(CBT\e(B")
+   ("\e$(C$9$G$?$6\e(B"  "\e$(CBU\e(B")
+
+   ("\e$(C$9$G$@\e(B"    "\e$(CBV\e(B")
+   ("\e$(C$9$G$@$6\e(B"  "\e$(CBW\e(B")
+
+   ("\e$(C$9$G$S\e(B"    "\e$(CBX\e(B")
+   ("\e$(C$9$G$S$$\e(B"  "\e$(CBY\e(B")
+   ("\e$(C$9$G$S$)\e(B"  "\e$(CBZ\e(B")
+   ("\e$(C$9$G$S$1\e(B"  "\e$(CB[\e(B")
+   ("\e$(C$9$G$S$2\e(B"  "\e$(CB\\e(B")
+
+   ("\e$(C$9$K$7\e(B"    "\e$(CB]\e(B")
+
+   ("\e$(C$9$L\e(B"      "\e$(CB^\e(B")
+   ("\e$(C$9$L$!\e(B"    "\e$(CB_\e(B")
+   ("\e$(C$9$L$$\e(B"    "\e$(CB`\e(B")
+   ("\e$(C$9$L$)\e(B"    "\e$(CBa\e(B")
+   ("\e$(C$9$L$1\e(B"    "\e$(CBb\e(B")
+   ("\e$(C$9$L$2\e(B"    "\e$(CBc\e(B")
+   ("\e$(C$9$L$7\e(B"    "\e$(CBd\e(B")
+
+   ("\e$(C$9$L$C\e(B"    "\e$(CBe\e(B")
+   ("\e$(C$9$L$C$6\e(B"  "\e$(CBf\e(B")
+   ("\e$(C$9$L$C$7\e(B"  "\e$(CBg\e(B")
+
+   ("\e$(C$9$L$S\e(B"    "\e$(CBh\e(B")
+
+   ("\e$(C$9$P\e(B"      "\e$(CBi\e(B")
+
+   ("\e$(C$9$Q\e(B"      "\e$(CBj\e(B")
+   ("\e$(C$9$Q$1\e(B"    "\e$(CBk\e(B")
+   ("\e$(C$9$Q$5\e(B"    "\e$(CBl\e(B")
+   ("\e$(C$9$Q$7\e(B"    "\e$(CBm\e(B")
+
+   ("\e$(C$9$S\e(B"      "\e$(CBn\e(B")
+   ("\e$(C$9$S$!\e(B"    "\e$(CBo\e(B")
+   ("\e$(C$9$S$$\e(B"    "\e$(CBp\e(B")
+   ("\e$(C$9$S$)\e(B"    "\e$(CBq\e(B")
+   ("\e$(C$9$S$1\e(B"    "\e$(CBr\e(B")
+   ("\e$(C$9$S$2\e(B"    "\e$(CBs\e(B")
+   ("\e$(C$9$S$7\e(B"    "\e$(CBt\e(B")
+   ("\e$(C$9$S$8\e(B"    "\e$(CBu\e(B")
+   ("\e$(C$9$S$>\e(B"    "\e$(CBv\e(B")
+
+   ("\e$(C$:$?\e(B"      "\e$(CBw\e(B")
+   ("\e$(C$:$?$!\e(B"    "\e$(CBx\e(B")
+   ("\e$(C$:$?$$\e(B"    "\e$(CBy\e(B")
+   ("\e$(C$:$?$$$>\e(B"  "\e$(CBz\e(B")
+   ("\e$(C$:$?$)\e(B"    "\e$(CB{\e(B")
+   ("\e$(C$:$?$1\e(B"    "\e$(CB|\e(B")
+   ("\e$(C$:$?$2\e(B"    "\e$(CB}\e(B")
+   ("\e$(C$:$?$5\e(B"    "\e$(CB~\e(B")
+   ("\e$(C$:$?$6\e(B"    "\e$(CC!\e(B")
+   ("\e$(C$:$?$7\e(B"    "\e$(CC"\e(B")
+   ("\e$(C$:$?$8\e(B"    "\e$(CC#\e(B")
+
+   ("\e$(C$:$@\e(B"      "\e$(CC$\e(B")
+   ("\e$(C$:$@$!\e(B"    "\e$(CC%\e(B")
+   ("\e$(C$:$@$$\e(B"    "\e$(CC&\e(B")
+   ("\e$(C$:$@$)\e(B"    "\e$(CC'\e(B")
+   ("\e$(C$:$@$1\e(B"    "\e$(CC(\e(B")
+   ("\e$(C$:$@$2\e(B"    "\e$(CC)\e(B")
+   ("\e$(C$:$@$5\e(B"    "\e$(CC*\e(B")
+   ("\e$(C$:$@$6\e(B"    "\e$(CC+\e(B")
+   ("\e$(C$:$@$7\e(B"    "\e$(CC,\e(B")
+
+   ("\e$(C$:$A\e(B"      "\e$(CC-\e(B")
+   ("\e$(C$:$A$$\e(B"    "\e$(CC.\e(B")
+   ("\e$(C$:$A$$$>\e(B"  "\e$(CC/\e(B")
+   ("\e$(C$:$A$)\e(B"    "\e$(CC0\e(B")
+   ("\e$(C$:$A$1\e(B"    "\e$(CC1\e(B")
+   ("\e$(C$:$A$7\e(B"    "\e$(CC2\e(B")
+
+   ("\e$(C$:$C\e(B"      "\e$(CC3\e(B")
+   ("\e$(C$:$C$!\e(B"    "\e$(CC4\e(B")
+   ("\e$(C$:$C$$\e(B"    "\e$(CC5\e(B")
+   ("\e$(C$:$C$)\e(B"    "\e$(CC6\e(B")
+   ("\e$(C$:$C$1\e(B"    "\e$(CC7\e(B")
+   ("\e$(C$:$C$2\e(B"    "\e$(CC8\e(B")
+   ("\e$(C$:$C$5\e(B"    "\e$(CC9\e(B")
+   ("\e$(C$:$C$6\e(B"    "\e$(CC:\e(B")
+   ("\e$(C$:$C$7\e(B"    "\e$(CC;\e(B")
+
+   ("\e$(C$:$D\e(B"      "\e$(CC<\e(B")
+   ("\e$(C$:$D$!\e(B"    "\e$(CC=\e(B")
+   ("\e$(C$:$D$$\e(B"    "\e$(CC>\e(B")
+   ("\e$(C$:$D$)\e(B"    "\e$(CC?\e(B")
+   ("\e$(C$:$D$1\e(B"    "\e$(CC@\e(B")
+   ("\e$(C$:$D$2\e(B"    "\e$(CCA\e(B")
+   ("\e$(C$:$D$5\e(B"    "\e$(CCB\e(B")
+   ("\e$(C$:$D$7\e(B"    "\e$(CCC\e(B")
+
+   ("\e$(C$:$E\e(B"      "\e$(CCD\e(B")
+   ("\e$(C$:$E$$\e(B"    "\e$(CCE\e(B")
+   ("\e$(C$:$E$6\e(B"    "\e$(CCF\e(B")
+
+   ("\e$(C$:$F\e(B"      "\e$(CCG\e(B")
+   ("\e$(C$:$F$$\e(B"    "\e$(CCH\e(B")
+   ("\e$(C$:$F$7\e(B"    "\e$(CCI\e(B")
+
+   ("\e$(C$:$G\e(B"      "\e$(CCJ\e(B")
+   ("\e$(C$:$G$!\e(B"    "\e$(CCK\e(B")
+   ("\e$(C$:$G$$\e(B"    "\e$(CCL\e(B")
+   ("\e$(C$:$G$)\e(B"    "\e$(CCM\e(B")
+   ("\e$(C$:$G$1\e(B"    "\e$(CCN\e(B")
+   ("\e$(C$:$G$2\e(B"    "\e$(CCO\e(B")
+   ("\e$(C$:$G$5\e(B"    "\e$(CCP\e(B")
+   ("\e$(C$:$G$7\e(B"    "\e$(CCQ\e(B")
+
+   ("\e$(C$:$G$?\e(B"    "\e$(CCR\e(B")
+   ("\e$(C$:$G$?$$\e(B"  "\e$(CCS\e(B")
+   ("\e$(C$:$G$?$)\e(B"  "\e$(CCT\e(B")
+   ("\e$(C$:$G$?$7\e(B"  "\e$(CCU\e(B")
+
+   ("\e$(C$:$G$S\e(B"    "\e$(CCV\e(B")
+   ("\e$(C$:$G$S$$\e(B"  "\e$(CCW\e(B")
+   ("\e$(C$:$G$S$)\e(B"  "\e$(CCX\e(B")
+   ("\e$(C$:$G$S$1\e(B"  "\e$(CCY\e(B")
+   ("\e$(C$:$G$S$2\e(B"  "\e$(CCZ\e(B")
+   ("\e$(C$:$G$S$5\e(B"  "\e$(CC[\e(B")
+   ("\e$(C$:$G$S$7\e(B"  "\e$(CC\\e(B")
+
+   ("\e$(C$:$K\e(B"      "\e$(CC]\e(B")
+   ("\e$(C$:$K$1\e(B"    "\e$(CC^\e(B")
+
+   ("\e$(C$:$L\e(B"      "\e$(CC_\e(B")
+   ("\e$(C$:$L$!\e(B"    "\e$(CC`\e(B")
+   ("\e$(C$:$L$$\e(B"    "\e$(CCa\e(B")
+   ("\e$(C$:$L$)\e(B"    "\e$(CCb\e(B")
+   ("\e$(C$:$L$1\e(B"    "\e$(CCc\e(B")
+   ("\e$(C$:$L$2\e(B"    "\e$(CCd\e(B")
+   ("\e$(C$:$L$5\e(B"    "\e$(CCe\e(B")
+   ("\e$(C$:$L$7\e(B"    "\e$(CCf\e(B")
+
+   ("\e$(C$:$L$C\e(B"    "\e$(CCg\e(B")
+   ("\e$(C$:$L$C$6\e(B"  "\e$(CCh\e(B")
+
+   ("\e$(C$:$L$D\e(B"    "\e$(CCi\e(B")
+   ("\e$(C$:$L$D$$\e(B"  "\e$(CCj\e(B")
+
+   ("\e$(C$:$L$S\e(B"    "\e$(CCk\e(B")
+   ("\e$(C$:$L$S$$\e(B"  "\e$(CCl\e(B")
+   ("\e$(C$:$L$S$)\e(B"  "\e$(CCm\e(B")
+   ("\e$(C$:$L$S$1\e(B"  "\e$(CCn\e(B")
+   ("\e$(C$:$L$S$2\e(B"  "\e$(CCo\e(B")
+   ("\e$(C$:$L$S$5\e(B"  "\e$(CCp\e(B")
+   ("\e$(C$:$L$S$7\e(B"  "\e$(CCq\e(B")
+
+   ("\e$(C$:$P\e(B"      "\e$(CCr\e(B")
+   ("\e$(C$:$P$$\e(B"    "\e$(CCs\e(B")
+   ("\e$(C$:$P$)\e(B"    "\e$(CCt\e(B")
+   ("\e$(C$:$P$1\e(B"    "\e$(CCu\e(B")
+   ("\e$(C$:$P$7\e(B"    "\e$(CCv\e(B")
+
+   ("\e$(C$:$Q\e(B"      "\e$(CCw\e(B")
+   ("\e$(C$:$Q$!\e(B"    "\e$(CCx\e(B")
+   ("\e$(C$:$Q$$\e(B"    "\e$(CCy\e(B")
+   ("\e$(C$:$Q$)\e(B"    "\e$(CCz\e(B")
+   ("\e$(C$:$Q$1\e(B"    "\e$(CC{\e(B")
+   ("\e$(C$:$Q$2\e(B"    "\e$(CC|\e(B")
+   ("\e$(C$:$Q$5\e(B"    "\e$(CC}\e(B")
+   ("\e$(C$:$Q$7\e(B"    "\e$(CC~\e(B")
+
+   ("\e$(C$:$S\e(B"      "\e$(CD!\e(B")
+   ("\e$(C$:$S$!\e(B"    "\e$(CD"\e(B")
+   ("\e$(C$:$S$$\e(B"    "\e$(CD#\e(B")
+   ("\e$(C$:$S$'\e(B"    "\e$(CD$\e(B")
+   ("\e$(C$:$S$)\e(B"    "\e$(CD%\e(B")
+   ("\e$(C$:$S$)$!\e(B"  "\e$(CD&\e(B")
+   ("\e$(C$:$S$1\e(B"    "\e$(CD'\e(B")
+   ("\e$(C$:$S$2\e(B"    "\e$(CD(\e(B")
+   ("\e$(C$:$S$5\e(B"    "\e$(CD)\e(B")
+   ("\e$(C$:$S$7\e(B"    "\e$(CD*\e(B")
+
+   ("\e$(C$;$?\e(B"      "\e$(CD+\e(B")
+   ("\e$(C$;$?$!\e(B"    "\e$(CD,\e(B")
+   ("\e$(C$;$?$$\e(B"    "\e$(CD-\e(B")
+   ("\e$(C$;$?$)\e(B"    "\e$(CD.\e(B")
+   ("\e$(C$;$?$1\e(B"    "\e$(CD/\e(B")
+   ("\e$(C$;$?$2\e(B"    "\e$(CD0\e(B")
+   ("\e$(C$;$?$5\e(B"    "\e$(CD1\e(B")
+   ("\e$(C$;$?$7\e(B"    "\e$(CD2\e(B")
+
+   ("\e$(C$;$@\e(B"      "\e$(CD3\e(B")
+   ("\e$(C$;$@$!\e(B"    "\e$(CD4\e(B")
+   ("\e$(C$;$@$$\e(B"    "\e$(CD5\e(B")
+   ("\e$(C$;$@$)\e(B"    "\e$(CD6\e(B")
+   ("\e$(C$;$@$1\e(B"    "\e$(CD7\e(B")
+   ("\e$(C$;$@$2\e(B"    "\e$(CD8\e(B")
+   ("\e$(C$;$@$5\e(B"    "\e$(CD9\e(B")
+   ("\e$(C$;$@$6\e(B"    "\e$(CD:\e(B")
+   ("\e$(C$;$@$7\e(B"    "\e$(CD;\e(B")
+
+   ("\e$(C$;$A\e(B"      "\e$(CD<\e(B")
+   ("\e$(C$;$A$!\e(B"    "\e$(CD=\e(B")
+   ("\e$(C$;$A$7\e(B"    "\e$(CD>\e(B")
+
+   ("\e$(C$;$C\e(B"      "\e$(CD?\e(B")
+   ("\e$(C$;$C$!\e(B"    "\e$(CD@\e(B")
+   ("\e$(C$;$C$$\e(B"    "\e$(CDA\e(B")
+   ("\e$(C$;$C$'\e(B"    "\e$(CDB\e(B")
+   ("\e$(C$;$C$)\e(B"    "\e$(CDC\e(B")
+   ("\e$(C$;$C$1\e(B"    "\e$(CDD\e(B")
+   ("\e$(C$;$C$2\e(B"    "\e$(CDE\e(B")
+   ("\e$(C$;$C$5\e(B"    "\e$(CDF\e(B")
+   ("\e$(C$;$C$6\e(B"    "\e$(CDG\e(B")
+   ("\e$(C$;$C$7\e(B"    "\e$(CDH\e(B")
+
+   ("\e$(C$;$D\e(B"      "\e$(CDI\e(B")
+   ("\e$(C$;$D$!\e(B"    "\e$(CDJ\e(B")
+   ("\e$(C$;$D$$\e(B"    "\e$(CDK\e(B")
+   ("\e$(C$;$D$)\e(B"    "\e$(CDL\e(B")
+   ("\e$(C$;$D$1\e(B"    "\e$(CDM\e(B")
+   ("\e$(C$;$D$2\e(B"    "\e$(CDN\e(B")
+   ("\e$(C$;$D$5\e(B"    "\e$(CDO\e(B")
+   ("\e$(C$;$D$7\e(B"    "\e$(CDP\e(B")
+
+   ("\e$(C$;$E\e(B"      "\e$(CDQ\e(B")
+   ("\e$(C$;$E$$\e(B"    "\e$(CDR\e(B")
+   ("\e$(C$;$E$)\e(B"    "\e$(CDS\e(B")
+   ("\e$(C$;$E$1\e(B"    "\e$(CDT\e(B")
+   ("\e$(C$;$E$2\e(B"    "\e$(CDU\e(B")
+   ("\e$(C$;$E$5\e(B"    "\e$(CDV\e(B")
+   ("\e$(C$;$E$6\e(B"    "\e$(CDW\e(B")
+   ("\e$(C$;$E$7\e(B"    "\e$(CDX\e(B")
+
+   ("\e$(C$;$F\e(B"      "\e$(CDY\e(B")
+
+   ("\e$(C$;$G\e(B"      "\e$(CDZ\e(B")
+   ("\e$(C$;$G$!\e(B"    "\e$(CD[\e(B")
+   ("\e$(C$;$G$$\e(B"    "\e$(CD\\e(B")
+   ("\e$(C$;$G$)\e(B"    "\e$(CD]\e(B")
+   ("\e$(C$;$G$1\e(B"    "\e$(CD^\e(B")
+   ("\e$(C$;$G$2\e(B"    "\e$(CD_\e(B")
+   ("\e$(C$;$G$5\e(B"    "\e$(CD`\e(B")
+   ("\e$(C$;$G$7\e(B"    "\e$(CDa\e(B")
+
+   ("\e$(C$;$G$?\e(B"    "\e$(CDb\e(B")
+   ("\e$(C$;$G$?$!\e(B"  "\e$(CDc\e(B")
+   ("\e$(C$;$G$?$$\e(B"  "\e$(CDd\e(B")
+   ("\e$(C$;$G$?$)\e(B"  "\e$(CDe\e(B")
+   ("\e$(C$;$G$?$1\e(B"  "\e$(CDf\e(B")
+   ("\e$(C$;$G$?$7\e(B"  "\e$(CDg\e(B")
+
+   ("\e$(C$;$G$@\e(B"    "\e$(CDh\e(B")
+   ("\e$(C$;$G$@$7\e(B"  "\e$(CDi\e(B")
+
+   ("\e$(C$;$G$S\e(B"    "\e$(CDj\e(B")
+   ("\e$(C$;$G$S$)\e(B"  "\e$(CDk\e(B")
+
+   ("\e$(C$;$K\e(B"      "\e$(CDl\e(B")
+
+   ("\e$(C$;$L\e(B"      "\e$(CDm\e(B")
+   ("\e$(C$;$L$!\e(B"    "\e$(CDn\e(B")
+   ("\e$(C$;$L$)\e(B"    "\e$(CDp\e(B")
+   ("\e$(C$;$L$1\e(B"    "\e$(CDq\e(B")
+   ("\e$(C$;$L$2\e(B"    "\e$(CDr\e(B")
+   ("\e$(C$;$L$5\e(B"    "\e$(CDs\e(B")
+   ("\e$(C$;$L$7\e(B"    "\e$(CDt\e(B")
+
+   ("\e$(C$;$L$C\e(B"    "\e$(CDu\e(B")
+   ("\e$(C$;$L$C$$\e(B"  "\e$(CDv\e(B")
+   ("\e$(C$;$L$C$)\e(B"  "\e$(CDw\e(B")
+   ("\e$(C$;$L$C$7\e(B"  "\e$(CDx\e(B")
+
+   ("\e$(C$;$L$D\e(B"    "\e$(CDy\e(B")
+   ("\e$(C$;$L$D$7\e(B"  "\e$(CDz\e(B")
+
+   ("\e$(C$;$L$S\e(B"    "\e$(CD{\e(B")
+   ("\e$(C$;$L$S$!\e(B"  "\e$(CD|\e(B")
+   ("\e$(C$;$L$S$$\e(B"  "\e$(CD}\e(B")
+   ("\e$(C$;$L$S$)\e(B"  "\e$(CD~\e(B")
+   ("\e$(C$;$L$S$1\e(B"  "\e$(CE!\e(B")
+   ("\e$(C$;$L$S$2\e(B"  "\e$(CE"\e(B")
+   ("\e$(C$;$L$S$5\e(B"  "\e$(CE#\e(B")
+   ("\e$(C$;$L$S$7\e(B"  "\e$(CE$\e(B")
+
+   ("\e$(C$;$P\e(B"      "\e$(CE%\e(B")
+   ("\e$(C$;$P$$\e(B"    "\e$(CE&\e(B")
+   ("\e$(C$;$P$)\e(B"    "\e$(CE'\e(B")
+   ("\e$(C$;$P$1\e(B"    "\e$(CE(\e(B")
+
+   ("\e$(C$;$Q\e(B"      "\e$(CE)\e(B")
+   ("\e$(C$;$Q$!\e(B"    "\e$(CE*\e(B")
+   ("\e$(C$;$Q$$\e(B"    "\e$(CE+\e(B")
+   ("\e$(C$;$Q$)\e(B"    "\e$(CE,\e(B")
+   ("\e$(C$;$Q$1\e(B"    "\e$(CE-\e(B")
+   ("\e$(C$;$Q$2\e(B"    "\e$(CE.\e(B")
+   ("\e$(C$;$Q$7\e(B"    "\e$(CE/\e(B")
+
+   ("\e$(C$;$S\e(B"      "\e$(CE0\e(B")
+   ("\e$(C$;$S$!\e(B"    "\e$(CE1\e(B")
+   ("\e$(C$;$S$$\e(B"    "\e$(CE2\e(B")
+   ("\e$(C$;$S$)\e(B"    "\e$(CE3\e(B")
+   ("\e$(C$;$S$1\e(B"    "\e$(CE4\e(B")
+   ("\e$(C$;$S$2\e(B"    "\e$(CE5\e(B")
+   ("\e$(C$;$S$5\e(B"    "\e$(CE6\e(B")
+   ("\e$(C$;$S$7\e(B"    "\e$(CE7\e(B")
+
+   ("\e$(C$<$?\e(B"      "\e$(CE8\e(B")
+   ("\e$(C$<$?$!\e(B"    "\e$(CE9\e(B")
+   ("\e$(C$<$?$$\e(B"    "\e$(CE:\e(B")
+   ("\e$(C$<$?$)\e(B"    "\e$(CE;\e(B")
+   ("\e$(C$<$?$)$!\e(B"  "\e$(CE<\e(B")
+   ("\e$(C$<$?$1\e(B"    "\e$(CE=\e(B")
+   ("\e$(C$<$?$2\e(B"    "\e$(CE>\e(B")
+   ("\e$(C$<$?$5\e(B"    "\e$(CE?\e(B")
+   ("\e$(C$<$?$6\e(B"    "\e$(CE@\e(B")
+   ("\e$(C$<$?$7\e(B"    "\e$(CEA\e(B")
+
+   ("\e$(C$<$@\e(B"      "\e$(CEB\e(B")
+   ("\e$(C$<$@$!\e(B"    "\e$(CEC\e(B")
+   ("\e$(C$<$@$$\e(B"    "\e$(CED\e(B")
+   ("\e$(C$<$@$)\e(B"    "\e$(CEE\e(B")
+   ("\e$(C$<$@$1\e(B"    "\e$(CEF\e(B")
+   ("\e$(C$<$@$2\e(B"    "\e$(CEG\e(B")
+   ("\e$(C$<$@$5\e(B"    "\e$(CEH\e(B")
+   ("\e$(C$<$@$6\e(B"    "\e$(CEI\e(B")
+   ("\e$(C$<$@$7\e(B"    "\e$(CEJ\e(B")
+
+   ("\e$(C$<$A\e(B"      "\e$(CEK\e(B")
+   ("\e$(C$<$A$7\e(B"    "\e$(CEL\e(B")
+
+   ("\e$(C$<$C\e(B"      "\e$(CEM\e(B")
+   ("\e$(C$<$C$!\e(B"    "\e$(CEN\e(B")
+   ("\e$(C$<$C$$\e(B"    "\e$(CEO\e(B")
+   ("\e$(C$<$C$)\e(B"    "\e$(CEP\e(B")
+   ("\e$(C$<$C$)$1\e(B"  "\e$(CEQ\e(B")
+   ("\e$(C$<$C$1\e(B"    "\e$(CER\e(B")
+   ("\e$(C$<$C$2\e(B"    "\e$(CES\e(B")
+   ("\e$(C$<$C$5\e(B"    "\e$(CET\e(B")
+   ("\e$(C$<$C$6\e(B"    "\e$(CEU\e(B")
+   ("\e$(C$<$C$7\e(B"    "\e$(CEV\e(B")
+
+   ("\e$(C$<$D\e(B"      "\e$(CEW\e(B")
+   ("\e$(C$<$D$!\e(B"    "\e$(CEX\e(B")
+   ("\e$(C$<$D$$\e(B"    "\e$(CEY\e(B")
+   ("\e$(C$<$D$)\e(B"    "\e$(CEZ\e(B")
+   ("\e$(C$<$D$1\e(B"    "\e$(CE[\e(B")
+   ("\e$(C$<$D$2\e(B"    "\e$(CE\\e(B")
+   ("\e$(C$<$D$5\e(B"    "\e$(CE]\e(B")
+   ("\e$(C$<$D$7\e(B"    "\e$(CE^\e(B")
+
+   ("\e$(C$<$E\e(B"      "\e$(CE_\e(B")
+   ("\e$(C$<$E$$\e(B"    "\e$(CE`\e(B")
+   ("\e$(C$<$E$6\e(B"    "\e$(CEa\e(B")
+
+   ("\e$(C$<$F\e(B"      "\e$(CEb\e(B")
+   ("\e$(C$<$F$$\e(B"    "\e$(CEc\e(B")
+
+   ("\e$(C$<$G\e(B"      "\e$(CEd\e(B")
+   ("\e$(C$<$G$!\e(B"    "\e$(CEe\e(B")
+   ("\e$(C$<$G$$\e(B"    "\e$(CEf\e(B")
+   ("\e$(C$<$G$)\e(B"    "\e$(CEg\e(B")
+   ("\e$(C$<$G$1\e(B"    "\e$(CEh\e(B")
+   ("\e$(C$<$G$2\e(B"    "\e$(CEi\e(B")
+   ("\e$(C$<$G$5\e(B"    "\e$(CEj\e(B")
+   ("\e$(C$<$G$7\e(B"    "\e$(CEk\e(B")
+   ("\e$(C$<$G$=\e(B"    "\e$(CEl\e(B")
+
+   ("\e$(C$<$G$?\e(B"    "\e$(CEm\e(B")
+   ("\e$(C$<$G$?$$\e(B"  "\e$(CEn\e(B")
+
+   ("\e$(C$<$G$@\e(B"    "\e$(CEo\e(B")
+
+   ("\e$(C$<$G$S\e(B"    "\e$(CEp\e(B")
+   ("\e$(C$<$G$S$$\e(B"  "\e$(CEq\e(B")
+   ("\e$(C$<$G$S$5\e(B"  "\e$(CEr\e(B")
+   ("\e$(C$<$G$S$7\e(B"  "\e$(CEs\e(B")
+
+   ("\e$(C$<$K\e(B"      "\e$(CEt\e(B")
+
+   ("\e$(C$<$L\e(B"      "\e$(CEu\e(B")
+   ("\e$(C$<$L$!\e(B"    "\e$(CEv\e(B")
+   ("\e$(C$<$L$$\e(B"    "\e$(CEw\e(B")
+   ("\e$(C$<$L$)\e(B"    "\e$(CEx\e(B")
+   ("\e$(C$<$L$1\e(B"    "\e$(CEy\e(B")
+   ("\e$(C$<$L$2\e(B"    "\e$(CEz\e(B")
+   ("\e$(C$<$L$5\e(B"    "\e$(CE{\e(B")
+   ("\e$(C$<$L$7\e(B"    "\e$(CE|\e(B")
+
+   ("\e$(C$<$L$C\e(B"    "\e$(CE}\e(B")
+   ("\e$(C$<$L$C$6\e(B"  "\e$(CE~\e(B")
+
+   ("\e$(C$<$L$D\e(B"    "\e$(CF!\e(B")
+
+   ("\e$(C$<$L$S\e(B"    "\e$(CF"\e(B")
+   ("\e$(C$<$L$S$!\e(B"  "\e$(CF#\e(B")
+   ("\e$(C$<$L$S$$\e(B"  "\e$(CF$\e(B")
+   ("\e$(C$<$L$S$)\e(B"  "\e$(CF%\e(B")
+   ("\e$(C$<$L$S$1\e(B"  "\e$(CF&\e(B")
+   ("\e$(C$<$L$S$2\e(B"  "\e$(CF'\e(B")
+   ("\e$(C$<$L$S$7\e(B"  "\e$(CF(\e(B")
+
+   ("\e$(C$<$P\e(B"      "\e$(CF)\e(B")
+   ("\e$(C$<$P$$\e(B"    "\e$(CF*\e(B")
+   ("\e$(C$<$P$)\e(B"    "\e$(CF+\e(B")
+   ("\e$(C$<$P$1\e(B"    "\e$(CF,\e(B")
+   ("\e$(C$<$P$7\e(B"    "\e$(CF-\e(B")
+
+   ("\e$(C$<$Q\e(B"      "\e$(CF.\e(B")
+   ("\e$(C$<$Q$!\e(B"    "\e$(CF/\e(B")
+   ("\e$(C$<$Q$$\e(B"    "\e$(CF0\e(B")
+   ("\e$(C$<$Q$'\e(B"    "\e$(CF1\e(B")
+   ("\e$(C$<$Q$)\e(B"    "\e$(CF2\e(B")
+   ("\e$(C$<$Q$)$1\e(B"  "\e$(CF3\e(B")
+   ("\e$(C$<$Q$1\e(B"    "\e$(CF4\e(B")
+   ("\e$(C$<$Q$2\e(B"    "\e$(CF5\e(B")
+   ("\e$(C$<$Q$5\e(B"    "\e$(CF6\e(B")
+
+   ("\e$(C$<$Q$S\e(B"    "\e$(CF7\e(B")
+   ("\e$(C$<$Q$S$$\e(B"  "\e$(CF8\e(B")
+   ("\e$(C$<$Q$S$)\e(B"  "\e$(CF9\e(B")
+   ("\e$(C$<$Q$S$1\e(B"  "\e$(CF:\e(B")
+   ("\e$(C$<$Q$S$2\e(B"  "\e$(CF;\e(B")
+
+   ("\e$(C$<$S\e(B"      "\e$(CF<\e(B")
+   ("\e$(C$<$S$!\e(B"    "\e$(CF=\e(B")
+   ("\e$(C$<$S$$\e(B"    "\e$(CF>\e(B")
+   ("\e$(C$<$S$)\e(B"    "\e$(CF?\e(B")
+   ("\e$(C$<$S$1\e(B"    "\e$(CF@\e(B")
+   ("\e$(C$<$S$2\e(B"    "\e$(CFA\e(B")
+   ("\e$(C$<$S$5\e(B"    "\e$(CFB\e(B")
+   ("\e$(C$<$S$7\e(B"    "\e$(CFC\e(B")
+
+   ("\e$(C$=$?\e(B"      "\e$(CFD\e(B")
+   ("\e$(C$=$?$!\e(B"    "\e$(CFE\e(B")
+   ("\e$(C$=$?$"\e(B"    "\e$(CFF\e(B")
+   ("\e$(C$=$?$$\e(B"    "\e$(CFG\e(B")
+   ("\e$(C$=$?$)\e(B"    "\e$(CFH\e(B")
+   ("\e$(C$=$?$)$1\e(B"  "\e$(CFI\e(B")
+   ("\e$(C$=$?$1\e(B"    "\e$(CFJ\e(B")
+   ("\e$(C$=$?$2\e(B"    "\e$(CFK\e(B")
+   ("\e$(C$=$?$5\e(B"    "\e$(CFL\e(B")
+   ("\e$(C$=$?$6\e(B"    "\e$(CFM\e(B")
+   ("\e$(C$=$?$7\e(B"    "\e$(CFN\e(B")
+   ("\e$(C$=$?$<\e(B"    "\e$(CFO\e(B")
+
+   ("\e$(C$=$@\e(B"      "\e$(CFP\e(B")
+   ("\e$(C$=$@$!\e(B"    "\e$(CFQ\e(B")
+   ("\e$(C$=$@$$\e(B"    "\e$(CFR\e(B")
+   ("\e$(C$=$@$)\e(B"    "\e$(CFS\e(B")
+   ("\e$(C$=$@$1\e(B"    "\e$(CFT\e(B")
+   ("\e$(C$=$@$2\e(B"    "\e$(CFU\e(B")
+   ("\e$(C$=$@$5\e(B"    "\e$(CFV\e(B")
+   ("\e$(C$=$@$6\e(B"    "\e$(CFW\e(B")
+   ("\e$(C$=$@$7\e(B"    "\e$(CFX\e(B")
+
+   ("\e$(C$=$A\e(B"      "\e$(CFY\e(B")
+   ("\e$(C$=$A$!\e(B"    "\e$(CFZ\e(B")
+
+   ("\e$(C$=$C\e(B"      "\e$(CF[\e(B")
+   ("\e$(C$=$C$!\e(B"    "\e$(CF\\e(B")
+   ("\e$(C$=$C$$\e(B"    "\e$(CF]\e(B")
+   ("\e$(C$=$C$1\e(B"    "\e$(CF_\e(B")
+   ("\e$(C$=$C$2\e(B"    "\e$(CF`\e(B")
+   ("\e$(C$=$C$5\e(B"    "\e$(CFa\e(B")
+   ("\e$(C$=$C$6\e(B"    "\e$(CFb\e(B")
+   ("\e$(C$=$C$7\e(B"    "\e$(CFc\e(B")
+
+   ("\e$(C$=$D\e(B"      "\e$(CFd\e(B")
+   ("\e$(C$=$D$!\e(B"    "\e$(CFe\e(B")
+   ("\e$(C$=$D$$\e(B"    "\e$(CFf\e(B")
+   ("\e$(C$=$D$)\e(B"    "\e$(CFg\e(B")
+   ("\e$(C$=$D$1\e(B"    "\e$(CFh\e(B")
+   ("\e$(C$=$D$2\e(B"    "\e$(CFi\e(B")
+   ("\e$(C$=$D$5\e(B"    "\e$(CFj\e(B")
+   ("\e$(C$=$D$7\e(B"    "\e$(CFk\e(B")
+
+   ("\e$(C$=$E\e(B"      "\e$(CFl\e(B")
+   ("\e$(C$=$E$$\e(B"    "\e$(CFm\e(B")
+   ("\e$(C$=$E$)\e(B"    "\e$(CFn\e(B")
+   ("\e$(C$=$E$1\e(B"    "\e$(CFo\e(B")
+   ("\e$(C$=$E$2\e(B"    "\e$(CFp\e(B")
+   ("\e$(C$=$E$6\e(B"    "\e$(CFq\e(B")
+   ("\e$(C$=$E$7\e(B"    "\e$(CFr\e(B")
+
+   ("\e$(C$=$F\e(B"      "\e$(CFs\e(B")
+   ("\e$(C$=$F$)\e(B"    "\e$(CFt\e(B")
+   ("\e$(C$=$F$2\e(B"    "\e$(CFu\e(B")
+   ("\e$(C$=$F$5\e(B"    "\e$(CFv\e(B")
+
+   ("\e$(C$=$G\e(B"      "\e$(CFw\e(B")
+   ("\e$(C$=$G$!\e(B"    "\e$(CFx\e(B")
+   ("\e$(C$=$G$$\e(B"    "\e$(CFy\e(B")
+   ("\e$(C$=$G$)\e(B"    "\e$(CFz\e(B")
+   ("\e$(C$=$G$1\e(B"    "\e$(CF{\e(B")
+   ("\e$(C$=$G$2\e(B"    "\e$(CF|\e(B")
+   ("\e$(C$=$G$5\e(B"    "\e$(CF}\e(B")
+   ("\e$(C$=$G$7\e(B"    "\e$(CF~\e(B")
+
+   ("\e$(C$=$G$?\e(B"    "\e$(CG!\e(B")
+   ("\e$(C$=$G$?$7\e(B"  "\e$(CG"\e(B")
+
+   ("\e$(C$=$G$S\e(B"    "\e$(CG#\e(B")
+   ("\e$(C$=$G$S$$\e(B"  "\e$(CG$\e(B")
+
+   ("\e$(C$=$K\e(B"      "\e$(CG%\e(B")
+   ("\e$(C$=$K$$\e(B"    "\e$(CG&\e(B")
+   ("\e$(C$=$K$)\e(B"    "\e$(CG'\e(B")
+   ("\e$(C$=$K$2\e(B"    "\e$(CG(\e(B")
+   ("\e$(C$=$K$5\e(B"    "\e$(CG)\e(B")
+
+   ("\e$(C$=$L\e(B"      "\e$(CG*\e(B")
+   ("\e$(C$=$L$!\e(B"    "\e$(CG+\e(B")
+   ("\e$(C$=$L$$\e(B"    "\e$(CG,\e(B")
+   ("\e$(C$=$L$'\e(B"    "\e$(CG-\e(B")
+   ("\e$(C$=$L$)\e(B"    "\e$(CG.\e(B")
+   ("\e$(C$=$L$)$1\e(B"  "\e$(CG/\e(B")
+   ("\e$(C$=$L$1\e(B"    "\e$(CG0\e(B")
+   ("\e$(C$=$L$2\e(B"    "\e$(CG1\e(B")
+   ("\e$(C$=$L$5\e(B"    "\e$(CG2\e(B")
+   ("\e$(C$=$L$7\e(B"    "\e$(CG3\e(B")
+
+   ("\e$(C$=$L$C\e(B"    "\e$(CG4\e(B")
+   ("\e$(C$=$L$C$7\e(B"  "\e$(CG5\e(B")
+
+   ("\e$(C$=$L$S\e(B"    "\e$(CG6\e(B")
+   ("\e$(C$=$L$S$$\e(B"  "\e$(CG7\e(B")
+   ("\e$(C$=$L$S$)\e(B"  "\e$(CG8\e(B")
+   ("\e$(C$=$L$S$1\e(B"  "\e$(CG9\e(B")
+   ("\e$(C$=$L$S$5\e(B"  "\e$(CG:\e(B")
+
+   ("\e$(C$=$P\e(B"      "\e$(CG;\e(B")
+   ("\e$(C$=$P$$\e(B"    "\e$(CG<\e(B")
+   ("\e$(C$=$P$)\e(B"    "\e$(CG=\e(B")
+   ("\e$(C$=$P$1\e(B"    "\e$(CG>\e(B")
+   ("\e$(C$=$P$5\e(B"    "\e$(CG?\e(B")
+   ("\e$(C$=$P$7\e(B"    "\e$(CG@\e(B")
+
+   ("\e$(C$=$Q\e(B"      "\e$(CGA\e(B")
+   ("\e$(C$=$Q$$\e(B"    "\e$(CGB\e(B")
+   ("\e$(C$=$Q$)\e(B"    "\e$(CGC\e(B")
+   ("\e$(C$=$Q$1\e(B"    "\e$(CGD\e(B")
+   ("\e$(C$=$Q$2\e(B"    "\e$(CGE\e(B")
+   ("\e$(C$=$Q$5\e(B"    "\e$(CGF\e(B")
+
+   ("\e$(C$=$S\e(B"      "\e$(CGG\e(B")
+   ("\e$(C$=$S$!\e(B"    "\e$(CGH\e(B")
+   ("\e$(C$=$S$$\e(B"    "\e$(CGI\e(B")
+   ("\e$(C$=$S$)\e(B"    "\e$(CGJ\e(B")
+   ("\e$(C$=$S$1\e(B"    "\e$(CGK\e(B")
+   ("\e$(C$=$S$2\e(B"    "\e$(CGL\e(B")
+   ("\e$(C$=$S$5\e(B"    "\e$(CGM\e(B")
+   ("\e$(C$=$S$7\e(B"    "\e$(CGN\e(B")
+
+   ("\e$(C$>$?\e(B"      "\e$(CGO\e(B")
+   ("\e$(C$>$?$!\e(B"    "\e$(CGP\e(B")
+   ("\e$(C$>$?$$\e(B"    "\e$(CGQ\e(B")
+   ("\e$(C$>$?$)\e(B"    "\e$(CGR\e(B")
+   ("\e$(C$>$?$)$<\e(B"  "\e$(CGS\e(B")
+   ("\e$(C$>$?$1\e(B"    "\e$(CGT\e(B")
+   ("\e$(C$>$?$2\e(B"    "\e$(CGU\e(B")
+   ("\e$(C$>$?$5\e(B"    "\e$(CGV\e(B")
+   ("\e$(C$>$?$7\e(B"    "\e$(CGW\e(B")
+
+   ("\e$(C$>$@\e(B"      "\e$(CGX\e(B")
+   ("\e$(C$>$@$!\e(B"    "\e$(CGY\e(B")
+   ("\e$(C$>$@$$\e(B"    "\e$(CGZ\e(B")
+   ("\e$(C$>$@$)\e(B"    "\e$(CG[\e(B")
+   ("\e$(C$>$@$1\e(B"    "\e$(CG\\e(B")
+   ("\e$(C$>$@$2\e(B"    "\e$(CG]\e(B")
+   ("\e$(C$>$@$5\e(B"    "\e$(CG^\e(B")
+   ("\e$(C$>$@$6\e(B"    "\e$(CG_\e(B")
+   ("\e$(C$>$@$7\e(B"    "\e$(CG`\e(B")
+
+   ("\e$(C$>$A\e(B"      "\e$(CGa\e(B")
+   ("\e$(C$>$A$7\e(B"    "\e$(CGb\e(B")
+
+   ("\e$(C$>$C\e(B"      "\e$(CGc\e(B")
+   ("\e$(C$>$C$!\e(B"    "\e$(CGd\e(B")
+   ("\e$(C$>$C$$\e(B"    "\e$(CGe\e(B")
+   ("\e$(C$>$C$)\e(B"    "\e$(CGf\e(B")
+   ("\e$(C$>$C$)$1\e(B"  "\e$(CGg\e(B")
+   ("\e$(C$>$C$1\e(B"    "\e$(CGh\e(B")
+   ("\e$(C$>$C$2\e(B"    "\e$(CGi\e(B")
+   ("\e$(C$>$C$5\e(B"    "\e$(CGj\e(B")
+   ("\e$(C$>$C$7\e(B"    "\e$(CGk\e(B")
+
+   ("\e$(C$>$D\e(B"      "\e$(CGl\e(B")
+   ("\e$(C$>$D$!\e(B"    "\e$(CGm\e(B")
+   ("\e$(C$>$D$$\e(B"    "\e$(CGn\e(B")
+   ("\e$(C$>$D$)\e(B"    "\e$(CGo\e(B")
+   ("\e$(C$>$D$1\e(B"    "\e$(CGp\e(B")
+   ("\e$(C$>$D$2\e(B"    "\e$(CGq\e(B")
+   ("\e$(C$>$D$5\e(B"    "\e$(CGr\e(B")
+   ("\e$(C$>$D$7\e(B"    "\e$(CGs\e(B")
+
+   ("\e$(C$>$E\e(B"      "\e$(CGt\e(B")
+   ("\e$(C$>$E$!\e(B"    "\e$(CGu\e(B")
+   ("\e$(C$>$E$$\e(B"    "\e$(CGv\e(B")
+   ("\e$(C$>$E$)\e(B"    "\e$(CGw\e(B")
+   ("\e$(C$>$E$1\e(B"    "\e$(CGx\e(B")
+   ("\e$(C$>$E$2\e(B"    "\e$(CGy\e(B")
+   ("\e$(C$>$E$5\e(B"    "\e$(CGz\e(B")
+   ("\e$(C$>$E$6\e(B"    "\e$(CG{\e(B")
+   ("\e$(C$>$E$7\e(B"    "\e$(CG|\e(B")
+
+   ("\e$(C$>$F\e(B"      "\e$(CG}\e(B")
+   ("\e$(C$>$F$$\e(B"    "\e$(CG~\e(B")
+   ("\e$(C$>$F$)\e(B"    "\e$(CH!\e(B")
+   ("\e$(C$>$F$2\e(B"    "\e$(CH"\e(B")
+
+   ("\e$(C$>$G\e(B"      "\e$(CH#\e(B")
+   ("\e$(C$>$G$!\e(B"    "\e$(CH$\e(B")
+   ("\e$(C$>$G$$\e(B"    "\e$(CH%\e(B")
+   ("\e$(C$>$G$)\e(B"    "\e$(CH&\e(B")
+   ("\e$(C$>$G$)$<\e(B"  "\e$(CH'\e(B")
+   ("\e$(C$>$G$1\e(B"    "\e$(CH(\e(B")
+   ("\e$(C$>$G$2\e(B"    "\e$(CH)\e(B")
+   ("\e$(C$>$G$5\e(B"    "\e$(CH*\e(B")
+   ("\e$(C$>$G$7\e(B"    "\e$(CH+\e(B")
+   ("\e$(C$>$G$<\e(B"    "\e$(CH,\e(B")
+
+   ("\e$(C$>$G$?\e(B"    "\e$(CH-\e(B")
+   ("\e$(C$>$G$?$!\e(B"  "\e$(CH.\e(B")
+   ("\e$(C$>$G$?$$\e(B"  "\e$(CH/\e(B")
+   ("\e$(C$>$G$?$)\e(B"  "\e$(CH0\e(B")
+   ("\e$(C$>$G$?$5\e(B"  "\e$(CH1\e(B")
+   ("\e$(C$>$G$?$7\e(B"  "\e$(CH2\e(B")
+
+   ("\e$(C$>$G$@\e(B"    "\e$(CH3\e(B")
+   ("\e$(C$>$G$@$!\e(B"  "\e$(CH4\e(B")
+   ("\e$(C$>$G$@$$\e(B"  "\e$(CH5\e(B")
+   ("\e$(C$>$G$@$5\e(B"  "\e$(CH6\e(B")
+   ("\e$(C$>$G$@$7\e(B"  "\e$(CH7\e(B")
+
+   ("\e$(C$>$G$S\e(B"    "\e$(CH8\e(B")
+   ("\e$(C$>$G$S$!\e(B"  "\e$(CH9\e(B")
+   ("\e$(C$>$G$S$$\e(B"  "\e$(CH:\e(B")
+   ("\e$(C$>$G$S$)\e(B"  "\e$(CH;\e(B")
+   ("\e$(C$>$G$S$2\e(B"  "\e$(CH<\e(B")
+   ("\e$(C$>$G$S$5\e(B"  "\e$(CH=\e(B")
+   ("\e$(C$>$G$S$7\e(B"  "\e$(CH>\e(B")
+
+   ("\e$(C$>$K\e(B"      "\e$(CH?\e(B")
+   ("\e$(C$>$K$$\e(B"    "\e$(CH@\e(B")
+   ("\e$(C$>$K$)\e(B"    "\e$(CHA\e(B")
+   ("\e$(C$>$K$2\e(B"    "\e$(CHB\e(B")
+   ("\e$(C$>$K$5\e(B"    "\e$(CHC\e(B")
+
+   ("\e$(C$>$L\e(B"      "\e$(CHD\e(B")
+   ("\e$(C$>$L$!\e(B"    "\e$(CHE\e(B")
+   ("\e$(C$>$L$$\e(B"    "\e$(CHF\e(B")
+   ("\e$(C$>$L$)\e(B"    "\e$(CHG\e(B")
+   ("\e$(C$>$L$)$<\e(B"  "\e$(CHH\e(B")
+   ("\e$(C$>$L$1\e(B"    "\e$(CHI\e(B")
+   ("\e$(C$>$L$5\e(B"    "\e$(CHJ\e(B")
+   ("\e$(C$>$L$7\e(B"    "\e$(CHK\e(B")
+
+   ("\e$(C$>$L$C\e(B"    "\e$(CHL\e(B")
+   ("\e$(C$>$L$C$$\e(B"  "\e$(CHM\e(B")
+   ("\e$(C$>$L$C$)\e(B"  "\e$(CHN\e(B")
+   ("\e$(C$>$L$C$1\e(B"  "\e$(CHO\e(B")
+   ("\e$(C$>$L$C$7\e(B"  "\e$(CHP\e(B")
+
+   ("\e$(C$>$L$D\e(B"    "\e$(CHQ\e(B")
+   ("\e$(C$>$L$D$!\e(B"  "\e$(CHR\e(B")
+   ("\e$(C$>$L$D$$\e(B"  "\e$(CHS\e(B")
+   ("\e$(C$>$L$D$)\e(B"  "\e$(CHT\e(B")
+   ("\e$(C$>$L$D$7\e(B"  "\e$(CHU\e(B")
+
+   ("\e$(C$>$L$S\e(B"    "\e$(CHV\e(B")
+   ("\e$(C$>$L$S$!\e(B"  "\e$(CHW\e(B")
+   ("\e$(C$>$L$S$$\e(B"  "\e$(CHX\e(B")
+   ("\e$(C$>$L$S$)\e(B"  "\e$(CHY\e(B")
+   ("\e$(C$>$L$S$1\e(B"  "\e$(CHZ\e(B")
+   ("\e$(C$>$L$S$2\e(B"  "\e$(CH[\e(B")
+   ("\e$(C$>$L$S$5\e(B"  "\e$(CH\\e(B")
+   ("\e$(C$>$L$S$7\e(B"  "\e$(CH]\e(B")
+
+   ("\e$(C$>$P\e(B"      "\e$(CH^\e(B")
+   ("\e$(C$>$P$!\e(B"    "\e$(CH_\e(B")
+   ("\e$(C$>$P$$\e(B"    "\e$(CH`\e(B")
+   ("\e$(C$>$P$)\e(B"    "\e$(CHa\e(B")
+   ("\e$(C$>$P$1\e(B"    "\e$(CHb\e(B")
+   ("\e$(C$>$P$5\e(B"    "\e$(CHc\e(B")
+   ("\e$(C$>$P$7\e(B"    "\e$(CHd\e(B")
+
+   ("\e$(C$>$Q\e(B"      "\e$(CHe\e(B")
+   ("\e$(C$>$Q$!\e(B"    "\e$(CHf\e(B")
+   ("\e$(C$>$Q$$\e(B"    "\e$(CHg\e(B")
+   ("\e$(C$>$Q$$$>\e(B"  "\e$(CHh\e(B")
+   ("\e$(C$>$Q$'\e(B"    "\e$(CHi\e(B")
+   ("\e$(C$>$Q$)\e(B"    "\e$(CHj\e(B")
+   ("\e$(C$>$Q$)$!\e(B"  "\e$(CHk\e(B")
+   ("\e$(C$>$Q$1\e(B"    "\e$(CHl\e(B")
+   ("\e$(C$>$Q$2\e(B"    "\e$(CHm\e(B")
+   ("\e$(C$>$Q$5\e(B"    "\e$(CHn\e(B")
+   ("\e$(C$>$Q$7\e(B"    "\e$(CHo\e(B")
+   ("\e$(C$>$Q$<\e(B"    "\e$(CHp\e(B")
+
+   ("\e$(C$>$Q$S\e(B"    "\e$(CHq\e(B")
+   ("\e$(C$>$Q$S$$\e(B"  "\e$(CHr\e(B")
+   ("\e$(C$>$Q$S$)\e(B"  "\e$(CHs\e(B")
+   ("\e$(C$>$Q$S$1\e(B"  "\e$(CHt\e(B")
+   ("\e$(C$>$Q$S$2\e(B"  "\e$(CHu\e(B")
+   ("\e$(C$>$Q$S$7\e(B"  "\e$(CHv\e(B")
+
+   ("\e$(C$>$S\e(B"      "\e$(CHw\e(B")
+   ("\e$(C$>$S$!\e(B"    "\e$(CHx\e(B")
+   ("\e$(C$>$S$$\e(B"    "\e$(CHy\e(B")
+   ("\e$(C$>$S$)\e(B"    "\e$(CHz\e(B")
+   ("\e$(C$>$S$1\e(B"    "\e$(CH{\e(B")
+   ("\e$(C$>$S$2\e(B"    "\e$(CH|\e(B")
+   ("\e$(C$>$S$5\e(B"    "\e$(CH}\e(B")
+   ("\e$(C$>$S$7\e(B"    "\e$(CH~\e(B"))
 
   (dolist (ascii '(("1" . "\e$(C#1\e(B")  ("2" . "\e$(C#2\e(B")  ("3" . "\e$(C#3\e(B")  ("4" . "\e$(C#4\e(B")
-                  ("5" . "\e$(C#5\e(B")  ("6" . "\e$(C#6\e(B")  ("7" . "\e$(C#7\e(B")  ("8" . "\e$(C#8\e(B")
-                  ("9" . "\e$(C#9\e(B")  ("0" . "\e$(C#0\e(B")
-                  (" " . "\e$(C!!\e(B")  ("!" . "\e$(C#!\e(B")  ("@" . "\e$(C#@\e(B")  ("#" . "\e$(C##\e(B")
-                  ("$" . "\e$(C#$\e(B")  ("%" . "\e$(C#%\e(B")  ("^" . "\e$(C#^\e(B")  ("&" . "\e$(C#&\e(B")
-                  ("*" . "\e$(C#*\e(B")  ("(" . "\e$(C#(\e(B")  (")" . "\e$(C#)\e(B")
-                  ("-" . "\e$(C#-\e(B")  ("=" . "\e$(C#=\e(B")  ("`" . "\e$(C#`\e(B")  ("\\" . "\e$(C#\\e(B")
-                  ("|" . "\e$(C#|\e(B")  ("_" . "\e$(C#_\e(B")  ("+" . "\e$(C#+\e(B")  ("~" . "\e$(C#~\e(B")
-                  ("[" . "\e$(C!8\e(B")  ("]" . "\e$(C!9\e(B")  ("{" . "\e$(C#{\e(B")  ("}" . "\e$(C#}\e(B")
-                  (":" . "\e$(C#:\e(B")  (";" . "\e$(C#;\e(B")  ("\"" . "\e$(C#"\e(B") ("'" . "\e$(C#'\e(B")
-                  ("<" . "\e$(C#<\e(B")  (">" . "\e$(C#>\e(B")  ("?" . "\e$(C#?\e(B")  ("/" . "\e$(C#/\e(B")
-                  ("," . "\e$(C#,\e(B")  ("." . "\e$(C#.\e(B")
-                  ("a" . "\e$(C#a\e(B")  ("b" . "\e$(C#b\e(B")  ("c" . "\e$(C#c\e(B")  ("d" . "\e$(C#d\e(B")
-                  ("e" . "\e$(C#e\e(B")  ("f" . "\e$(C#f\e(B")  ("g" . "\e$(C#g\e(B")  ("h" . "\e$(C#h\e(B")
-                  ("i" . "\e$(C#i\e(B")  ("j" . "\e$(C#j\e(B")  ("k" . "\e$(C#k\e(B")  ("l" . "\e$(C#l\e(B")
-                  ("m" . "\e$(C#m\e(B")  ("n" . "\e$(C#n\e(B")  ("o" . "\e$(C#o\e(B")  ("p" . "\e$(C#p\e(B")
-                  ("q" . "\e$(C#q\e(B")  ("r" . "\e$(C#r\e(B")  ("s" . "\e$(C#s\e(B")  ("t" . "\e$(C#t\e(B")
-                  ("u" . "\e$(C#u\e(B")  ("v" . "\e$(C#v\e(B")  ("w" . "\e$(C#w\e(B")  ("x" . "\e$(C#x\e(B")
-                  ("y" . "\e$(C#y\e(B")  ("z" . "\e$(C#z\e(B")
-                  ("A" . "\e$(C#A\e(B")  ("B" . "\e$(C#B\e(B")  ("C" . "\e$(C#C\e(B")  ("D" . "\e$(C#D\e(B")
-                  ("E" . "\e$(C#E\e(B")  ("F" . "\e$(C#F\e(B")  ("G" . "\e$(C#G\e(B")  ("H" . "\e$(C#H\e(B")
-                  ("I" . "\e$(C#I\e(B")  ("J" . "\e$(C#J\e(B")  ("K" . "\e$(C#K\e(B")  ("L" . "\e$(C#L\e(B")
-                  ("M" . "\e$(C#M\e(B")  ("N" . "\e$(C#N\e(B")  ("O" . "\e$(C#O\e(B")  ("P" . "\e$(C#P\e(B")
-                  ("Q" . "\e$(C#Q\e(B")  ("R" . "\e$(C#R\e(B")  ("S" . "\e$(C#S\e(B")  ("T" . "\e$(C#T\e(B")
-                  ("U" . "\e$(C#U\e(B")  ("V" . "\e$(C#V\e(B")  ("W" . "\e$(C#W\e(B")  ("X" . "\e$(C#X\e(B")
-                  ("Y" . "\e$(C#Y\e(B")  ("Z" . "\e$(C#Z\e(B")))
+                    ("5" . "\e$(C#5\e(B")  ("6" . "\e$(C#6\e(B")  ("7" . "\e$(C#7\e(B")  ("8" . "\e$(C#8\e(B")
+                    ("9" . "\e$(C#9\e(B")  ("0" . "\e$(C#0\e(B")
+                    (" " . "\e$(C!!\e(B")  ("!" . "\e$(C#!\e(B")  ("@" . "\e$(C#@\e(B")  ("#" . "\e$(C##\e(B")
+                    ("$" . "\e$(C#$\e(B")  ("%" . "\e$(C#%\e(B")  ("^" . "\e$(C#^\e(B")  ("&" . "\e$(C#&\e(B")
+                    ("*" . "\e$(C#*\e(B")  ("(" . "\e$(C#(\e(B")  (")" . "\e$(C#)\e(B")
+                    ("-" . "\e$(C#-\e(B")  ("=" . "\e$(C#=\e(B")  ("`" . "\e$(C#`\e(B")  ("\\" . "\e$(C#\\e(B")
+                    ("|" . "\e$(C#|\e(B")  ("_" . "\e$(C#_\e(B")  ("+" . "\e$(C#+\e(B")  ("~" . "\e$(C#~\e(B")
+                    ("[" . "\e$(C!8\e(B")  ("]" . "\e$(C!9\e(B")  ("{" . "\e$(C#{\e(B")  ("}" . "\e$(C#}\e(B")
+                    (":" . "\e$(C#:\e(B")  (";" . "\e$(C#;\e(B")  ("\"" . "\e$(C#"\e(B") ("'" . "\e$(C#'\e(B")
+                    ("<" . "\e$(C#<\e(B")  (">" . "\e$(C#>\e(B")  ("?" . "\e$(C#?\e(B")  ("/" . "\e$(C#/\e(B")
+                    ("," . "\e$(C#,\e(B")  ("." . "\e$(C#.\e(B")
+                    ("a" . "\e$(C#a\e(B")  ("b" . "\e$(C#b\e(B")  ("c" . "\e$(C#c\e(B")  ("d" . "\e$(C#d\e(B")
+                    ("e" . "\e$(C#e\e(B")  ("f" . "\e$(C#f\e(B")  ("g" . "\e$(C#g\e(B")  ("h" . "\e$(C#h\e(B")
+                    ("i" . "\e$(C#i\e(B")  ("j" . "\e$(C#j\e(B")  ("k" . "\e$(C#k\e(B")  ("l" . "\e$(C#l\e(B")
+                    ("m" . "\e$(C#m\e(B")  ("n" . "\e$(C#n\e(B")  ("o" . "\e$(C#o\e(B")  ("p" . "\e$(C#p\e(B")
+                    ("q" . "\e$(C#q\e(B")  ("r" . "\e$(C#r\e(B")  ("s" . "\e$(C#s\e(B")  ("t" . "\e$(C#t\e(B")
+                    ("u" . "\e$(C#u\e(B")  ("v" . "\e$(C#v\e(B")  ("w" . "\e$(C#w\e(B")  ("x" . "\e$(C#x\e(B")
+                    ("y" . "\e$(C#y\e(B")  ("z" . "\e$(C#z\e(B")
+                    ("A" . "\e$(C#A\e(B")  ("B" . "\e$(C#B\e(B")  ("C" . "\e$(C#C\e(B")  ("D" . "\e$(C#D\e(B")
+                    ("E" . "\e$(C#E\e(B")  ("F" . "\e$(C#F\e(B")  ("G" . "\e$(C#G\e(B")  ("H" . "\e$(C#H\e(B")
+                    ("I" . "\e$(C#I\e(B")  ("J" . "\e$(C#J\e(B")  ("K" . "\e$(C#K\e(B")  ("L" . "\e$(C#L\e(B")
+                    ("M" . "\e$(C#M\e(B")  ("N" . "\e$(C#N\e(B")  ("O" . "\e$(C#O\e(B")  ("P" . "\e$(C#P\e(B")
+                    ("Q" . "\e$(C#Q\e(B")  ("R" . "\e$(C#R\e(B")  ("S" . "\e$(C#S\e(B")  ("T" . "\e$(C#T\e(B")
+                    ("U" . "\e$(C#U\e(B")  ("V" . "\e$(C#V\e(B")  ("W" . "\e$(C#W\e(B")  ("X" . "\e$(C#X\e(B")
+                    ("Y" . "\e$(C#Y\e(B")  ("Z" . "\e$(C#Z\e(B")))
     (let ((in (car ascii)) (out (cdr ascii)))
-      (its-defrule (concat its-pankak-escape in) in)
-      (its-defrule (concat its-jeonkak-escape in) out))))
+       (its-defrule (concat its-pankak-escape in) in)
+       (its-defrule (concat its-jeonkak-escape in) out))))
 
 (define-its-state-machine-append its-hangul-map
   (its-defrule "[" its-hangul-open-bracket)
@@ -2869,45 +2898,45 @@
   (its-defrule "," its-hangul-comma)
 
   (if its-hangul-enable-jeonkak-alphabet
-      (progn
-       (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#}\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"))
+       (progn
+         (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#}\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"))
     (progn
-      (its-defrule   "1"   "1")  (its-defrule   "2"   "2")
-      (its-defrule   "3"   "3")  (its-defrule   "4"   "4")
-      (its-defrule   "5"   "5")  (its-defrule   "6"   "6")
-      (its-defrule   "7"   "7")  (its-defrule   "8"   "8")
-      (its-defrule   "9"   "9")  (its-defrule   "0"   "0")
-      (its-defrule   "!"   "!")  (its-defrule   "@"   "@")
-      (its-defrule   "#"   "#")  (its-defrule   "$"   "$")
-      (its-defrule   "%"   "%")  (its-defrule   "^"   "^")
-      (its-defrule   "&"   "&")  (its-defrule   "*"   "*")
-      (its-defrule   "("   "(")  (its-defrule   ")"   ")")
-      (its-defrule   "-"   "-")  (its-defrule   "~"   "~")
-      (its-defrule   "="   "=")  (its-defrule   "`"   "`")
-      (its-defrule   "\\"  "\\") (its-defrule   "|"   "|")
-      (its-defrule   "_"   "_")  (its-defrule   "+"   "+")
-      (its-defrule   "{"   "{")  (its-defrule   "}"   "}")
-      (its-defrule   ":"   ":")  (its-defrule   ";"   ";")
-      (its-defrule   "\""  "\"") (its-defrule   "'"   "'")
-      (its-defrule   "<"   "<")  (its-defrule   ">"   ">")
-      (its-defrule   "?"   "?")  (its-defrule   "/"   "/"))))
+       (its-defrule   "1"   "1")  (its-defrule   "2"   "2")
+       (its-defrule   "3"   "3")  (its-defrule   "4"   "4")
+       (its-defrule   "5"   "5")  (its-defrule   "6"   "6")
+       (its-defrule   "7"   "7")  (its-defrule   "8"   "8")
+       (its-defrule   "9"   "9")  (its-defrule   "0"   "0")
+       (its-defrule   "!"   "!")  (its-defrule   "@"   "@")
+       (its-defrule   "#"   "#")  (its-defrule   "$"   "$")
+       (its-defrule   "%"   "%")  (its-defrule   "^"   "^")
+       (its-defrule   "&"   "&")  (its-defrule   "*"   "*")
+       (its-defrule   "("   "(")  (its-defrule   ")"   ")")
+       (its-defrule   "-"   "-")  (its-defrule   "~"   "~")
+       (its-defrule   "="   "=")  (its-defrule   "`"   "`")
+       (its-defrule   "\\"  "\\") (its-defrule   "|"   "|")
+       (its-defrule   "_"   "_")  (its-defrule   "+"   "+")
+       (its-defrule   "{"   "{")  (its-defrule   "}"   "}")
+       (its-defrule   ":"   ":")  (its-defrule   ";"   ";")
+       (its-defrule   "\""  "\"") (its-defrule   "'"   "'")
+       (its-defrule   "<"   "<")  (its-defrule   ">"   ">")
+       (its-defrule   "?"   "?")  (its-defrule   "/"   "/"))))
 
 (provide 'its/hangul)

diff --git a/its/hankata.el b/its/hankata.el
index fc51124..e701c1a 100644 (file)
--- a/its/hankata.el
+++ b/its/hankata.el
@@ -35,16 +35,16 @@
   (require 'its)
   (require 'cl))
 
-(defvar its-kata-enable-double-n nil "*Enable \"nn\" input for \"\e$B%s\e(B\" ")
-(defvar its-kata-enable-zenkaku-alphabet t "*Enable Zenkaku alphabet")
-(defvar its-kata-period "\e(I!\e(B" "*\e$B%T%j%*%I\e(B")  ; ". " "\e$B!%\e(B"
-(defvar its-kata-comma  "\e(I$\e(B" "*\e$B%3%s%^\e(B")    ; ", " "\e$B!$\e(B"
-(defvar its-kata-open-bracket  "\e(I"\e(B" "*[")  ; "\e$B!N\e(B"
-(defvar its-kata-close-bracket  "\e(I#\e(B" "*]") ; "\e$B!O\e(B"
-(defvar its-kata-horizontal  "\e(I0\e(B" "*-")    ; "\e$B!]\e(B"
+(defvar its-han-kata-enable-double-n nil "*Enable \"nn\" input for \"\e$B%s\e(B\" ")
+(defvar its-han-kata-enable-zenkaku-alphabet t "*Enable Zenkaku alphabet")
+(defvar its-han-kata-period "\e(I!\e(B" "*\e$B%T%j%*%I\e(B")  ; ". " "\e$B!%\e(B"
+(defvar its-han-kata-comma  "\e(I$\e(B" "*\e$B%3%s%^\e(B")    ; ", " "\e$B!$\e(B"
+(defvar its-han-kata-open-bracket  "\e(I"\e(B" "*[")  ; "\e$B!N\e(B"
+(defvar its-han-kata-close-bracket  "\e(I#\e(B" "*]") ; "\e$B!O\e(B"
+(defvar its-han-kata-horizontal  "\e(I0\e(B" "*-")    ; "\e$B!]\e(B"
 
 (define-its-state-machine its-han-kata-map
-  "roma-han-kata" "\e(I11\e(B" "Japanese" nil
+  "roma-han-kata" "\e(I11\e(B" "Japanese"
   "Map for Romaji-Hankaku-Katakana translation. (Japanese)"
 
   (defconst its-hankaku-escape "~")  ;; Escape character to Hankaku inputs
@@ -276,15 +276,15 @@
     (its-defrule (concat its-hankaku-escape upcase) upcase)))
 
 (define-its-state-machine-append its-han-kata-map
-  (if its-kata-enable-double-n
+  (if its-han-kata-enable-double-n
       (its-defrule "nn" "\e(I]\e(B")
     (its-defrule "nn" "\e(I]\e(B" -1))
 
-  (its-defrule "-" its-kata-horizontal)
-  (its-defrule "[" its-kata-open-bracket)
-  (its-defrule "]" its-kata-close-bracket)
-  (its-defrule "." its-kata-period)
-  (its-defrule "," its-kata-comma)
+  (its-defrule "-" its-han-kata-horizontal)
+  (its-defrule "[" its-han-kata-open-bracket)
+  (its-defrule "]" its-han-kata-close-bracket)
+  (its-defrule "." its-han-kata-period)
+  (its-defrule "," its-han-kata-comma)
   )
 
 (provide 'its/hankata)

diff --git a/its/hira.el b/its/hira.el
index 051dcc6..f899001 100644 (file)
--- a/its/hira.el
+++ b/its/hira.el
@@ -36,8 +36,13 @@
   (require 'its)
   (require 'cl))
 
+(defvar its-hira-enable-zenkaku-alphabet
+  (if (boundp 'its-enable-fullwidth-alphabet)
+      its-enable-fullwidth-alphabet
+    t)
+  "*Enable Zenkaku alphabet")
+
 (defvar its-hira-enable-double-n nil "*Enable \"nn\" input for \"\e$B$s\e(B\" ")
-(defvar its-hira-enable-zenkaku-alphabet t "*Enable Zenkaku alphabet")
 (defvar its-hira-period "\e$B!#\e(B" "*\e$B%T%j%*%I\e(B")  ; ". " "\e$B!%\e(B"
 (defvar its-hira-comma  "\e$B!"\e(B" "*\e$B%3%s%^\e(B")    ; ", " "\e$B!$\e(B"
 (defvar its-hira-open-bracket  "\e$B!V\e(B" "*[")  ; "\e$B!N\e(B"
@@ -45,7 +50,7 @@
 (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" "Japanese" nil
+  "roma-kana" "\e$B$"\e(B" 'Japanese
   "Map for Romaji-Hiragana translation. (Japanese)"
 
   (defconst its-zenkaku-escape "Z")  ;; Escape character to Zenkaku inputs

diff --git a/its/jeonkak.el b/its/jeonkak.el
index 2baedfe..e81fb7c 100644 (file)
--- a/its/jeonkak.el
+++ b/its/jeonkak.el
@@ -35,7 +35,7 @@
   (require 'its))
 
 (define-its-state-machine its-jeonkak-up-map
-  "jeonkak-upcase" "\e$(C#A\e(B" "Korean" nil
+  "jeonkak-upcase" "\e$(C#A\e(B" 'Korean
   "Map for jeonkak-upcase input."
 
   (dolist (ascii '(("1" . "\e$(C#1\e(B")  ("2" . "\e$(C#2\e(B")  ("3" . "\e$(C#3\e(B")  ("4" . "\e$(C#4\e(B")
@@ -68,7 +68,7 @@
       (its-defrule in out))))
 
 (define-its-state-machine its-jeonkak-down-map
-  "jeonkak-downcase" "\e$(C#a\e(B" "Korean" nil
+  "jeonkak-downcase" "\e$(C#a\e(B" 'Korean
   "Map for jeonkak-downcase input."
 
   (dolist (ascii '(("1" . "\e$(C#1\e(B")  ("2" . "\e$(C#2\e(B")  ("3" . "\e$(C#3\e(B")  ("4" . "\e$(C#4\e(B")

diff --git a/its/kata.el b/its/kata.el
index b138b66..9c11905 100644 (file)
--- a/its/kata.el
+++ b/its/kata.el
@@ -36,8 +36,13 @@
   (require 'its)
   (require 'cl))
 
+(defvar its-kata-enable-zenkaku-alphabet
+  (if (boundp 'its-enable-fullwidth-alphabet)
+      its-enable-fullwidth-alphabet
+    t)
+  "*Enable Zenkaku alphabet")
+
 (defvar its-kata-enable-double-n nil "*Enable \"nn\" input for \"\e$B%s\e(B\" ")
-(defvar its-kata-enable-zenkaku-alphabet t "*Enable Zenkaku alphabet")
 (defvar its-kata-period "\e$B!#\e(B" "*\e$B%T%j%*%I\e(B")  ; ". " "\e$B!%\e(B"
 (defvar its-kata-comma  "\e$B!"\e(B" "*\e$B%3%s%^\e(B")    ; ", " "\e$B!$\e(B"
 (defvar its-kata-open-bracket  "\e$B!V\e(B" "*[")  ; "\e$B!N\e(B"
@@ -45,7 +50,7 @@
 (defvar its-kata-horizontal  "\e$B!<\e(B" "*-")    ; "\e$B!]\e(B"
 
 (define-its-state-machine its-kata-map
-  "roma-kata" "\e$B%"\e(B" "Japanese" nil
+  "roma-kata" "\e$B%"\e(B" 'Japanese
   "Map for Romaji-Katakana translation. (Japanese)"
 
   (defconst its-zenkaku-escape "Z")  ;; Escape character to Zenkaku inputs

diff --git a/its/pinyin.el b/its/pinyin.el
index 6a32775..887f7ca 100644 (file)
--- a/its/pinyin.el
+++ b/its/pinyin.el
@@ -32,7 +32,12 @@
   (require 'its)
   (require 'cl))
 
-(defvar its-pinyin-cn-enable-quanjioao-alphabet t "*Enable Quanjiao alphabet")
+(defvar its-pinyin-cn-enable-quanjioao-alphabet
+  (if (boundp 'its-enable-fullwidth-alphabet)
+      its-enable-fullwidth-alphabet
+    t)
+  "*Enable Quanjiao alphabet")
+
 (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"
 
@@ -49,7 +54,7 @@
 
   (defun its-prev-terminal-state (input)
     (let ((len (length input))
-         (state (its-get-start-state its-current-map))
+         (state (its-get-start-state (symbol-value its-current-map)))
          (i 0) (ret nil) kst ks)
       (while (and (< i len)
                  (setq state (its-get-next-state state (aref input i))))
@@ -213,7 +218,7 @@
        (its-defrule    "n4"    "\e(0?@\e(B"))))
 
 (define-its-state-machine its-pinyin-cn-map
-  "pinyin-cn" "\e$AF4\e(BG" "Chinese-GB"
+  "pinyin-cn" "\e$AF4\e(BG" 'Chinese-GB
   "Map for Pinyin input. (Chinese-GB)"
 
   (defconst its-quanjiao-escape "Z")
@@ -287,7 +292,7 @@
   (its-defrule "!"     "\e$A#!\e(B"))
 
 (define-its-state-machine its-pinyin-tw-map
-  "pinyin-tw" "\e$(GQ;\e(BC" "Chinese-CNS"
+  "pinyin-tw" "\e$(GQ;\e(BC" 'Chinese-CNS
   "Map for Pinyin input."
 
   (defconst its-quanjiao-escape "Z")
@@ -328,11 +333,11 @@
                   (" " . "\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"1\e(B")  ("=" . "\e$(G"8\e(B")  ("`" . "\e$(G!j\e(B")  ("\\" . "\e$(G"`\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!b\e(B")  ("]" . "\e$(G!c\e(B")  ("{" . "\e$(G!B\e(B")  ("}" . "\e$(G!C\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"6\e(B")  (">" . "\e$(G"7\e(B")  ("?" . "\e$(G!)\e(B")  ("/" . "\e$(G"_\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")
@@ -380,7 +385,7 @@
        (its-defrule "="  "\e$A#=\e(B")  (its-defrule "`"  "\e$A#`\e(B")
        (its-defrule "\\" "\e$A#\\e(B")  (its-defrule "|"  "\e$A#|\e(B")
        (its-defrule "_"  "\e$A#_\e(B")  (its-defrule "+"  "\e$A#+\e(B")
-       (its-defrule "{"  "\e$A#{\e(B")  (its-defrule "}"  "\e$A#}\e(B")
+       (its-defrule "{"  "\e$(G!B\e(B")  (its-defrule "}"  "\e$(G!C\e(B")
        (its-defrule "\"" "\e$A#"\e(B")  (its-defrule "'"  "\e$A#'\e(B")
        (its-defrule "<"  "\e$A#<\e(B")  (its-defrule ">"  "\e$A#>\e(B"))
     (progn

diff --git a/its/quanjiao.el b/its/quanjiao.el
index d33205d..d23b881 100644 (file)
--- a/its/quanjiao.el
+++ b/its/quanjiao.el
@@ -35,7 +35,7 @@
   (require 'its))
 
 (define-its-state-machine its-quanjiao-up-cn-map
-  "quanjiao-upcase-cn" "\e$A#A\e(B" "Chinese-GB" nil
+  "quanjiao-upcase-cn" "\e$A#A\e(B" 'Chinese-GB
   "Map for quanjiao-upcase input. (Chinese-GB)"
 
   (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")
@@ -68,7 +68,7 @@
       (its-defrule in out))))
 
 (define-its-state-machine its-quanjiao-down-cn-map
-  "quanjiao-downcase-cn" "\e$A#a\e(B" "Chinese-GB" nil
+  "quanjiao-downcase-cn" "\e$A#a\e(B" 'Chinese-GB
   "Map for quanjiao-downcase input. (Chinese-GB)"
 
   (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")
@@ -101,7 +101,7 @@
       (its-defrule in out))))
 
 (define-its-state-machine its-quanjiao-up-tw-map
-  "quanjiao-upcase-tw" "\e$(G$A\e(B" "Chinese-CNS" nil
+  "quanjiao-upcase-tw" "\e$(G$A\e(B" 'Chinese-CNS
   "Map for quanjiao-upcase input. (Chinese-CNS)"
 
   (dolist (ascii '(("0" . "\e$(G$!\e(B")  ("1" . "\e$(G$"\e(B")  ("2" . "\e$(G$#\e(B")  ("3" . "\e$(G$$\e(B")
@@ -134,7 +134,7 @@
       (its-defrule in out))))
 
 (define-its-state-machine its-quanjiao-down-tw-map
-  "quanjiao-downcase-tw" "\e$(G$[\e(B" "Chinese-CNS" nil
+  "quanjiao-downcase-tw" "\e$(G$[\e(B" 'Chinese-CNS
   "Map for quanjiao-downcase input. (Chinese-CNS)"
 
   (dolist (ascii '(("0" . "\e$(G$!\e(B")  ("1" . "\e$(G$"\e(B")  ("2" . "\e$(G$#\e(B")  ("3" . "\e$(G$$\e(B")
@@ -143,11 +143,11 @@
                   (" " . "\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"1\e(B")  ("=" . "\e$(G"8\e(B")  ("`" . "\e$(G!j\e(B")  ("\\" . "\e$(G"`\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!b\e(B")  ("]" . "\e$(G!c\e(B")  ("{" . "\e$(G!B\e(B")  ("}" . "\e$(G!C\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"6\e(B")  (">" . "\e$(G"7\e(B")  ("?" . "\e$(G!)\e(B")  ("/" . "\e$(G"_\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")

diff --git a/its/zenkaku.el b/its/zenkaku.el
index d56c1bb..bfde649 100644 (file)
--- a/its/zenkaku.el
+++ b/its/zenkaku.el
@@ -35,7 +35,7 @@
   (require 'its))
 
 (define-its-state-machine its-zenkaku-up-map
-  "zenkaku-upcase" "\e$B#A\e(B" "Japanese" nil
+  "zenkaku-upcase" "\e$B#A\e(B" 'Japanese
   "Map for zenkaku-upcase input."
 
   (dolist (ascii '(("0" . "\e$B#0\e(B")  ("1" . "\e$B#1\e(B")  ("2" . "\e$B#2\e(B")  ("3" . "\e$B#3\e(B")
@@ -68,7 +68,7 @@
       (its-defrule in out))))
 
 (define-its-state-machine its-zenkaku-down-map
-  "zenkaku-downcase" "\e$B#a\e(B" "Japanese" nil
+  "zenkaku-downcase" "\e$B#a\e(B" 'Japanese
   "Map for zenkaku-downcase input."
 
   (dolist (ascii '(("0" . "\e$B#0\e(B")  ("1" . "\e$B#1\e(B")  ("2" . "\e$B#2\e(B")  ("3" . "\e$B#3\e(B")

diff --git a/its/zhuyin.el b/its/zhuyin.el
index 442834b..ff7213f 100644 (file)
--- a/its/zhuyin.el
+++ b/its/zhuyin.el
@@ -32,11 +32,21 @@
   (require 'its)
   (require 'cl))
 
-(defvar its-zhuyin-cn-enable-quanjioao-alphabet t "*Enable Quanjiao alphabet")
+(defvar its-zhuyin-cn-enable-quanjioao-alphabet
+  (if (boundp 'its-enable-fullwidth-alphabet)
+      its-enable-fullwidth-alphabet
+    t)
+  "*Enable Quanjiao alphabet")
+
 (defvar its-zhuyin-cn-open-braket  "\e$A!8\e(B" "*[") ; "\e$A#[\e(B"
 (defvar its-zhuyin-cn-close-braket "\e$A!9\e(B" "*]") ; "\e$A#]\e(B"
 
-(defvar its-zhuyin-tw-enable-quanjioao-alphabet t "*Enable Quanjiao alphabet")
+(defvar its-zhuyin-tw-enable-quanjioao-alphabet
+  (if (boundp 'its-enable-fullwidth-alphabet)
+      its-enable-fullwidth-alphabet
+    t)
+  "*Enable Quanjiao alphabet")
+
 (defvar its-zhuyin-tw-open-braket  "\e$(G!V\e(B" "*[") ; "\e$(G!b\e(B "
 (defvar its-zhuyin-tw-close-braket "\e$(G!W\e(B" "*]") ; "\e$(G!c\e(B"
 
@@ -140,7 +150,7 @@
        (its-defrule (concat (car N) 4) (concat (nth 1 N) "\e(0D\e(B")))))
 
 (define-its-state-machine its-zhuyin-cn-map
-  "zhuyin-cn" "\e$AW"\e(BG" "Chinese-GB"
+  "zhuyin-cn" "\e$AW"\e(BG" 'Chinese-GB
   "Map for Zhuyin input. (Chinese-GB)"
 
   (defconst its-quanjiao-escape "Z")
@@ -185,7 +195,7 @@
     (its-defrule "?" "\e$A!"\e(B"))
 
 (define-its-state-machine its-zhuyin-tw-map
-  "zhuyin-tw" "\e$(GNC\e(BC" "Chinese-CNS"
+  "zhuyin-tw" "\e$(GNC\e(BC" 'Chinese-CNS
   "Map for Zhuyin input."
 
   (defconst its-quanjiao-escape "Z")
@@ -201,11 +211,11 @@
                   (" " . "\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"1\e(B")  ("=" . "\e$(G"8\e(B")  ("`" . "\e$(G!j\e(B")  ("\\" . "\e$(G"`\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!b\e(B")  ("]" . "\e$(G!c\e(B")  ("{" . "\e$(G!B\e(B")  ("}" . "\e$(G!C\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"6\e(B")  (">" . "\e$(G"7\e(B")  ("?" . "\e$(G!)\e(B")  ("/" . "\e$(G"_\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")
@@ -241,9 +251,9 @@
        (its-defrule "("  "\e$A#(\e(B")  (its-defrule ")"  "\e$A#)\e(B")
        (its-defrule "~"  "\e$A!+\e(B")
        (its-defrule "="  "\e$A#=\e(B")  (its-defrule "`"  "\e$A#`\e(B")
-       (its-defrule "\\" "\e$A#\\e(B")  (its-defrule "|"  "\e$A#|\e(B")
+       (its-defrule "\\" "\e$(G"`\e(B")  (its-defrule "|"  "\e$A#|\e(B")
        (its-defrule "_"  "\e$A#_\e(B")  (its-defrule "+"  "\e$A#+\e(B")
-       (its-defrule "{"  "\e$A#{\e(B")  (its-defrule "}"  "\e$A#}\e(B")
+       (its-defrule "{"  "\e$(G!B\e(B")  (its-defrule "}"  "\e$(G!C\e(B")
        (its-defrule "\"" "\e$A#"\e(B")  (its-defrule "'"  "\e$A#'\e(B"))
     (progn
       (its-defrule "#"  "#")  (its-defrule "$"  "$")

diff --git a/menudiag.el b/menudiag.el
index a8a57de..b758b45 100644 (file)
--- a/menudiag.el
+++ b/menudiag.el
@@ -59,15 +59,15 @@
       (define-key map (char-to-string ch) 'undefined)
       (setq ch (1+ ch)))
     (setq ch ?0)
-    (while (< ch ?9)
+    (while (<= ch ?9)
       (define-key map (char-to-string ch) 'menudiag-goto-item)
       (setq ch (1+ ch)))
     (setq ch ?a)
-    (while (< ch ?z)
+    (while (<= ch ?z)
       (define-key map (char-to-string ch) 'menudiag-goto-item)
       (setq ch (1+ ch)))
     (setq ch ?A)
-    (while (< ch ?Z)
+    (while (<= ch ?Z)
       (define-key map (char-to-string ch) 'menudiag-goto-item)
       (setq ch (1+ ch)))
     (define-key map "\C-a" 'menudiag-beginning-of-line)
@@ -110,16 +110,20 @@
 (defun menudiag-make-selection-list (item-list line-width)
   (let ((l nil)
        (line nil)
-       (width 0))
+       (width 0)
+       (i 0))
     (while item-list
       (let* ((item (car item-list))
             (item-width (menudiag-item-width item)))
-       (if (and line (>= (+ width item-width) line-width))
+       (if (and line (or (>= (+ width item-width) line-width)
+                          (>= i 36)))
            (setq l (cons (reverse line) l)
                  line nil
-                 width 0))
+                 width 0
+                 i 0))
        (setq line (cons item line)
              width (+ width (menudiag-item-width item))
+             i (1+ i)
              item-list (cdr item-list))))
     (if line
        (reverse (cons (reverse line) l))
@@ -248,31 +252,63 @@
   (interactive)
   (menudiag-goto-item-internal (1- (length line))))
 
+;; Should retain compatibility.  Must.
+;;
+;;(defun menudiag-forward-item ()
+;;  (interactive)
+;;  (if (< pos-in-line (1- (length line)))
+;;      (menudiag-goto-item-internal (1+ pos-in-line))
+;;    (if (>= linepos (1- (length selection-list)))
+;;     (signal 'end-of-buffer "")
+;;      (menudiag-goto-line (1+ linepos))
+;;      (menudiag-beginning-of-line))))
+;;
+;;(defun menudiag-backward-item ()
+;;  (interactive)
+;;  (if (< 0 pos-in-line)
+;;      (menudiag-goto-item-internal (1- pos-in-line))
+;;    (if (< linepos 1)
+;;     (signal 'beginning-of-buffer "")
+;;      (menudiag-goto-line (1- linepos))
+;;      (menudiag-end-of-line))))
+;;
+;;(defun menudiag-goto-line (n)
+;;  (if (or (>= n (length selection-list)) (< n 0))
+;;      (ding)
+;;    (setq line (nth n selection-list)
+;;       linepos n)
+;;    (delete-region (point-min) (point-max))
+;;    (insert (menudiag-make-menu-formatted-string line))))
+;;
+
 (defun menudiag-forward-item ()
   (interactive)
   (if (< pos-in-line (1- (length line)))
       (menudiag-goto-item-internal (1+ pos-in-line))
     (if (>= linepos (1- (length selection-list)))
-       (signal 'end-of-buffer "")
-      (menudiag-goto-line (1+ linepos))
-      (menudiag-beginning-of-line))))
+       (menudiag-goto-line 0)
+      (menudiag-goto-line (1+ linepos)))
+    (menudiag-beginning-of-line)))
 
 (defun menudiag-backward-item ()
   (interactive)
   (if (< 0 pos-in-line)
       (menudiag-goto-item-internal (1- pos-in-line))
     (if (< linepos 1)
-       (signal 'beginning-of-buffer "")
-      (menudiag-goto-line (1- linepos))
-      (menudiag-end-of-line))))
+        (menudiag-goto-line (1- (length selection-list)))
+      (menudiag-goto-line (1- linepos)))
+    (menudiag-end-of-line)))
 
 (defun menudiag-goto-line (n)
-  (if (or (>= n (length selection-list)) (< n 0))
-      (ding)
-    (setq line (nth n selection-list)
-         linepos n)
-    (delete-region (point-min) (point-max))
-    (insert (menudiag-make-menu-formatted-string line))))
+  (cond
+   ((>= n (length selection-list))
+    (setq n 0))
+   ((< n 0)
+    (setq n (1- (length selection-list)))))
+  (setq line (nth n selection-list)
+        linepos n)
+  (delete-region (point-min) (point-max))
+  (insert (menudiag-make-menu-formatted-string line)))
 
 (defun menudiag-next-line ()
   (interactive)