
(provide (quote wnn-egg))

(if (not (or (boundp (quote WNN3)) (boundp (quote WNN4V3)))) (require (quote wnn-client)))

(defvar egg-version "2.24" "\
Version number of this version of Egg. ")

(and (equal (user-full-name) "Satoru Tomura") (defun egg-version-update (arg) (interactive "P") (if (equal (buffer-name (current-buffer)) "wnn-egg.el") (save-excursion (goto-char (point-min)) (re-search-forward "(defvar egg-version \"[0-9]+\\.") (let ((point (point)) (minor)) (search-forward "\"") (backward-char 1) (setq minor (string-to-int (buffer-substring point (point)))) (delete-region point (point)) (if (<= minor 8) (insert "0")) (insert (int-to-string (1+ minor))) (search-forward "Egg last modified date: ") (kill-line) (insert (current-time-string))) (save-buffer) (if arg (byte-compile-file (buffer-file-name)))))))

(defconst *protected-local-variables* (append (quote (egg:*input-mode* egg:*mode-on* egg:*current-mode* egg:*current-map* mode-line-egg-mode)) *protected-local-variables*) "\
*List of buffer local variables protected from \"kill-all-local-variables\" .")

(defun jis-code-input nil (interactive) (byte-code "!" [nil insert-jis-code-from-minibuffer "JIS (16ʿɽ): "] 2))

(defun insert-jis-code-from-minibuffer (prompt) (byte-code "	!!?  	\" 
@\"
A\"\"*" [str prompt val read-from-minibuffer nil read-jis-code-from-string beep insert logior 128] 10))

(defun hexadigit-value (ch) (byte-code "X	 X Z7 X X& Z\\7 X/ X7 Z\\" [ch 48 57 97 102 10 65 70] 2))

(defun read-jis-code-from-string (str) (byte-code "GU( H!X( H!( H!X( H!H H!\"H!\\H!\"H!\\B" [str 4 2 hexadigit-value 0 1 3 * 16] 14))

(defconst *notification-window* " *Notification* ")

(defun notify (str &rest args) (byte-code "	B\"!" [str args notify-internal apply format] 5))

(defun notify-internal (message &optional noerase) (byte-code "	!qdbÉ O$ŉ!!/ Â6 !!))" [notify-buff *notification-window* buffer-read-only nil message t noerase get-buffer-create insert current-time-string 4 19 ":: " 10 bury-buffer sleep-for 1 ""] 8))

(defun notify-yes-or-no-p (str &rest args) (byte-code "	B\"!" [str args notify-yes-or-no-p-internal apply format] 5))

(defun notify-yes-or-no-p-internal (message) (byte-code "ŋ" [*notification-window* buffer-read-only nil message t ((byte-code "!db O$ĉ!" [*notification-window* buffer-read-only nil message t pop-to-buffer insert current-time-string 4 19 ":: " 10 yes-or-no-p "Ǥ"] 7))] 1))

(defun notify-y-or-n-p (str &rest args) (byte-code "	B\"!" [str args notify-y-or-n-p-internal apply format] 5))

(defun notify-y-or-n-p-internal (message) (byte-code "ŋ" [*notification-window* buffer-read-only nil message t ((byte-code "!db O$ĉ!" [*notification-window* buffer-read-only nil message t pop-to-buffer insert current-time-string 4 19 ":: " 10 y-or-n-p "Ǥ"] 7))] 1))

(defun select-notification nil (interactive) (byte-code "È!" [*notification-window* buffer-read-only t nil pop-to-buffer] 3))

(defvar menu:*select-items* nil)

(defvar menu:*select-menus* nil)

(defvar menu:*select-item-no* nil)

(defvar menu:*select-menu-no* nil)

(defvar menu:*select-menu-stack* nil)

(defvar menu:*select-start* nil)

(defvar menu:*select-positions* nil)

(defun menu:select-from-menu (menu &optional initial position) (byte-code "  !ed\"8c !	
`88GZ\"!O XO 8GWY !a ׉!?rȉU} !U GS!U  U  U T!U		@	A	88888
A
ed\"8c`!!)ȉU&S!U4!XKXKGS\\XWZ!XnXnGS\\X|Z\\!XXGS\\XZ\\!U8A 
B
<@=
%	B	ed\"8c`88GZ\"׉!ȉÉ )b *ed\"!
!
?7ÉDC
BD," [previous-window echo-keystrokes inhibit-quit t value menu window-width finished nil menu:*select-menu-stack* menu:*select-positions* menu:*select-start* menu:*select-menus* initial menu:*select-item-no* ch quit-flag menu:*select-items* menu:*select-menu-no* save menu:select-menu-items position selected-window 0 select-window minibuffer-window delete-region 1 menu:make-selection-list 2 numberp menu:select-goto-item-position menu:select-goto-menu menu:select-goto-item 5 6 menu:select-next-item menu:select-previous-item 14 7 3 4 16 12 48 57 97 122 10 65 90 13 menu:select-item-position list beep reverse] 34))

(defun menu:select-item-position nil (byte-code "	
W 	8G\\	T \\*" [p m menu:*select-menu-no* menu:*select-menus* menu:*select-item-no* 0] 4))

(defun menu:select-goto-item-position (pos) (byte-code "
8G\\X\" 
8G\\T 
Z!+" [m i p menu:*select-menus* pos menu:*select-item-no* 0 menu:select-goto-menu] 4))

(defun menu:select-goto-menu (no) (byte-code "	
GS#
8d\"GX! GSb^ X@ \"I Z\\\"@@\"AT+ *!" [menu:*select-menu-no* no menu:*select-menus* menu:*select-items* menu:*select-start* menu:*select-item-no* l i check-number-range 0 delete-region insert 9 format "  %d." "  %c." 10 97 menu:select-goto-item] 9))

(defun menu:select-goto-item (no) (byte-code "	
GS#\\W* 
8@G#T b*" [menu:*select-item-no* no menu:*select-items* p menu:*select-start* i check-number-range 0 2 + 4] 6))

(defun menu:select-next-item nil (byte-code "	GSW T! ĉ
T!" [menu:*select-item-no* menu:*select-items* menu:*select-menu-no* menu:select-goto-item 0 menu:select-goto-menu] 3))

(defun menu:select-previous-item nil (byte-code "W S! ĉ	S!" [menu:*select-item-no* menu:*select-menu-no* 0 menu:select-goto-item 1000 menu:select-goto-menu] 3))

(defun menu:make-selection-list (list width) (byte-code "N @@G#X8 
) 
!BƉ5 @CBAJ @
B@@G#A 
] 
!B!` !+" [whole nil line size list width 0 + 4 reverse] 7))

(defvar ascii-char "[ -~]")

(defvar ascii-space "[ 	]")

(defvar ascii-symbols "[ -/:-@[-`{-~]")

(defvar ascii-numeric "[0-9]")

(defvar ascii-English-Upper "[A-Z]")

(defvar ascii-English-Lower "[a-z]")

(defvar ascii-alphanumeric "[0-9A-Za-z]")

(defvar kanji-char "\\z")

(defvar kanji-space "")

(defvar kanji-symbols "\\cs")

(defvar kanji-numeric "[-]")

(defvar kanji-English-Upper "[-]")

(defvar kanji-English-Lower "[-]")

(defvar kanji-hiragana "[-]")

(defvar kanji-katakana "[-]")

(defvar kanji-Greek-Upper "[-]")

(defvar kanji-Greek-Lower "[-]")

(defvar kanji-Russian-Upper "[-]")

(defvar kanji-Russian-Lower "[-]")

(defvar kanji-Kanji-1st-Level "[-]")

(defvar kanji-Kanji-2nd-Level "[С-]")

(defvar kanji-kanji-char "\\(\\ch\\|\\ck\\|\\cc\\)")

(defvar aletter (concat "\\(" ascii-char "\\|" kanji-char "\\)"))

(defun hiragana-region (start end) (interactive "r") (byte-code "ň`	b
# h!\") )" [point start kanji-katakana end ch2 nil re-search-forward delete-char -1 insert 164] 6))

(defun hiragana-paragraph nil "\
hiragana  paragraph at or after point." (interactive) (byte-code " ` `\"))" [end nil forward-paragraph backward-paragraph hiragana-region] 5))

(defun hiragana-sentence nil "\
hiragana  sentence at or after point." (interactive) (byte-code " ` `\"))" [end nil forward-sentence backward-sentence hiragana-region] 5))

(defun katakana-region (start end) (interactive "r") (byte-code "ň`	b
# h!\") )" [point start kanji-hiragana end ch2 nil re-search-forward delete-char -1 insert 165] 6))

(defun katakana-paragraph nil "\
katakana  paragraph at or after point." (interactive) (byte-code " ` `\"))" [end nil forward-paragraph backward-paragraph katakana-region] 5))

(defun katakana-sentence nil "\
katakana  sentence at or after point." (interactive) (byte-code " ` `\"))" [end nil forward-sentence backward-sentence katakana-region] 5))

(defun hankaku-region (start end) (interactive "r") (byte-code "ƈ	\"ebdd#G `Zfh
U4 \"A0 !c)B 
UB !Zc* )" [start end ch1 ch2 val *hankaku-alist* nil narrow-to-region re-search-forward "\\cs\\|\\ca" 2 161 assq delete-char -1 163 128] 8))

(defun hankaku-paragraph nil "\
hankaku  paragraph at or after point." (interactive) (byte-code " ` `\"))" [end nil forward-paragraph backward-paragraph hankaku-region] 5))

(defun hankaku-sentence nil "\
hankaku  sentence at or after point." (interactive) (byte-code " ` `\"))" [end nil forward-sentence backward-sentence hankaku-region] 5))

(defun hankaku-word (arg) (interactive "p") (byte-code "`	!`\")" [start arg nil forward-word hankaku-region] 4))

(defvar *hankaku-alist* (quote ((161 . 32) (170 . 33) (201 . 34) (244 . 35) (240 . 36) (243 . 37) (245 . 38) (199 . 39) (202 . 40) (203 . 41) (246 . 42) (220 . 43) (164 . 44) (221 . 45) (165 . 46) (191 . 47) (167 . 58) (168 . 59) (227 . 60) (225 . 61) (228 . 62) (169 . 63) (247 . 64) (206 . 91) (239 . 92) (207 . 93) (176 . 0) (178 . 95) (208 . 123) (195 . 124) (209 . 125) (177 . 126))))

(defun zenkaku-region (start end) (interactive "r") (byte-code "ň	\"ebdd#@ h
X 
X; !
\"A4 c: 
\\\")) )" [start end ch zen *zenkaku-alist* nil narrow-to-region re-search-forward "[ -~]" 32 126 delete-char -1 assq insert 163 128] 9))

(defun zenkaku-paragraph nil "\
zenkaku  paragraph at or after point." (interactive) (byte-code " ` `\"))" [end nil forward-paragraph backward-paragraph zenkaku-region] 5))

(defun zenkaku-sentence nil "\
zenkaku  sentence at or after point." (interactive) (byte-code " ` `\"))" [end nil forward-sentence backward-sentence zenkaku-region] 5))

(defun zenkaku-word (arg) (interactive "p") (byte-code "`	!`\")" [start arg nil forward-word zenkaku-region] 4))

(defvar *zenkaku-alist* (quote ((32 . "") (33 . "") (34 . "") (35 . "") (36 . "") (37 . "") (38 . "") (39 . "") (40 . "") (41 . "") (42 . "") (43 . "") (44 . "") (45 . "") (46 . "") (47 . "") (58 . "") (59 . "") (60 . "") (61 . "") (62 . "") (63 . "") (64 . "") (91 . "") (92 . "") (93 . "") (94 . "") (95 . "") (123 . "") (124 . "") (125 . "") (126 . ""))))

(defun roma-kana-region (start end) (interactive "r") (byte-code "ň!	
\"ebm?g\"?\" !`S`	?		T		f?Q łU \"? x 	b	`\"cʉ 	bʉ!? !!@9 	Tb	`\"!c!@= ʉ @= `8c`S	8? \"8G8$\"8!!5 . ))" [egg:*current-map* start end current-map ch nil action output kana-quit-flag point t egg:get-mode-map "roma-kana" narrow-to-region get-key-action forward-char 1 delete-region action-get-output action-get-map top next 2 setcar nthcdr egg:simulate-input 0] 22))

(defun roma-kana-paragraph nil "\
roma-kana  paragraph at or after point." (interactive) (byte-code " ` `\"))" [end nil forward-paragraph backward-paragraph roma-kana-region] 5))

(defun roma-kana-sentence nil "\
roma-kana  sentence at or after point." (interactive) (byte-code " ` `\"))" [end nil forward-sentence backward-sentence roma-kana-region] 5))

(defun roma-kanji-region (start end) (interactive "r") (byte-code "	\"`\"eb\"db)`\"" [start end nil roma-kana-region narrow-to-region replace-regexp "\\(\\| \\)" "" henkan-region-internal] 6))

(defun roma-kanji-paragraph nil "\
roma-kanji  paragraph at or after point." (interactive) (byte-code " ` `\"))" [end nil forward-paragraph backward-paragraph roma-kanji-region] 5))

(defun roma-kanji-sentence nil "\
roma-kanji  sentence at or after point." (interactive) (byte-code " ` `\"))" [end nil forward-sentence backward-sentence roma-kanji-region] 5))

(defun egg:member (elt list) (byte-code "?
 	@\"? A  " [list elt equal] 4))

(defvar egg:*mode-alist* nil)

(defun egg:get-mode-map (name) (byte-code "	\"A" [name egg:*mode-alist* assoc] 3))

(defun egg:set-mode-map (name map) (byte-code "	
\" A@\"A\")& 	B
B)" [place name egg:*mode-alist* mapplace map assoc setcar setcdr] 5))

(defvar egg:*mode-indicator* nil)

(defun egg:get-mode-indicator (name) (byte-code "	\" 	\"A " [name egg:*mode-indicator* assoc] 4))

(defun egg:set-mode-indicator (name indicator) (byte-code "	\" 	\"
\" 
B	B" [name egg:*mode-indicator* indicator assoc setcdr] 5))

(defvar egg:*processing-map* nil)

(defun define-egg-mode (name &optional reset) (byte-code "!? B	\"' !' 	\"	\"" [name egg:*processing-map* nil reset egg:get-mode-map egg:set-mode-map setcar setcdr] 7))

(defun egg:collect-symbols (form) (byte-code "\"" [form nil egg:collect-symbol*] 3))

(defun egg:collect-symbol* (form alist) (byte-code "?	 	1 9 	\" 	 	B1 :0 @A	\"\"1 	" [form alist t egg:member egg:collect-symbol*] 6))

(defun egg:fetch-value (form alist) (byte-code "?	 * 9 
\"A* :) @
\"A
\"B* " [form nil alist t assq egg:fetch-value] 6))

(defun egg:flatten-to-string (form) (byte-code "?	 1 ; 1 9 !1 !* \"1 \"\"" [form t "" symbol-name numberp make-string 1 apply concat mapcar egg:flatten-to-string] 8))

(defun egg:generate-all-subst (vars) (byte-code "?	 + A!@!) @!$ @!\"\"* )" [vars nil t r egg:generate-all-subst boundp apply append mapcar (lambda (val) (byte-code " \" 	@
BCC" [r vars val mapcar (lambda (assign) (byte-code "@	B
B" [vars val assign] 2))] 3)) eval] 9))

(defun defrule (input output &optional next) (byte-code "	
E!!F C 	@\"
@\"@\"!!6 !%+A X 	!
!U !%*" [vars input output next substs in out egg:*processing-map* egg:collect-symbols egg:generate-all-subst egg:fetch-value defrule* 0 egg:flatten-to-string] 18))

(defun defrule* (i input output next map) (byte-code "	
H\"? 	
H #	
H\"
GTU !H !\"7 !\"?E 
$)L \"v !?_ \"s !\"?s 
$) !? 
	# ! 
$) !? ! 	B\"T
	
H\"!%)Ǉ" [action map input i output next debug-on-error nil t get-key-action set-key-action make-action action-get-output equal action-get-next error "(defrule \"%s\" \"%s\" \"%s\") is ambiguous" action-set-output action-get-map action-set-next action-set-top action-get-top action-set-map defrule*] 33))

(defun make-map (&optional map alist) (byte-code "	B" [map alist] 2))

(defun get-key-action (map ch) (byte-code "	A\"A" [ch map assq] 3))

(defun set-key-action (map ch val) (byte-code "	
A\" \" 
	B
AB\")" [place ch map val assq setcdr] 6))

(defun map-toplevelp (map) (byte-code "@?" [map] 1))

(defun make-action (&optional map output) (byte-code "	D" [map output] 2))

(defun action-get-map (action) (byte-code "8" [action 0] 2))

(defun action-set-map (action val) (byte-code "\"	\"" [action val setcar nthcdr 0] 4))

(defun action-get-output (action) (byte-code "8" [action 1] 2))

(defun action-set-output (action output) (byte-code "\"	\"" [action output setcar nthcdr 1] 4))

(defun action-get-top (action) (byte-code "8@=" [action 0 top] 2))

(defun action-set-top (action input map) (byte-code "		GSO
E\"" [action input map action-set-map top 0] 6))

(defun action-get-next (action) (byte-code "8@= 88" [action 0 next 1] 3))

(defun action-set-next (action next) (byte-code "	E\"" [action next nil action-set-map] 5))

(defun egg:simulate-input (i j input map) (byte-code "	W 
H\"!T  
" [i j map input action-get-map get-key-action] 6))

(defun fence-self-insert-command nil (interactive) (byte-code "ƈ? 	
\"? 
cw	
`	?p\"?> !H ʉlXT H=r @!e ʉo !@rl?  `\"cʉ X H= H=  r ʉl!? c!rl!@9]`\"!c!@=)rX H=\"8!ʉ`\"8c8r&ʉZ@=Z`8c8?R\"8G8	$\"8rlc!!r) ." [egg:*input-mode* egg:*current-map* last-command-char current-map ch action nil output start inhibit-quit t kana-quit-flag echo-keystrokes fence-mode-map unread-command-char get-key-action 0 map-toplevelp 127 fence-backward-delete-char delete-char -1 delete-region fence-self-insert-command undefined beep action-get-output action-get-map top 2 1 next setcar nthcdr egg:simulate-input] 24))

(defun setf-key-action (map key action) (byte-code "	
BAB\"" [map key action setcdr] 4))

(defun dump-egg-mode-map (name filename) (interactive (byte-code "\"!D" [egg:*mode-alist* completing-read "EGG mode: " read-file-name "Output file name:"] 4)) (byte-code "Ĉ!	q	ĉ  !!!!!!  !!!!!)ed!#!!))" [egg:*mode-alist* buff standard-output buffer-read-only nil name filename get-buffer-create "*EggModeDumpBuffer*" erase-buffer terpri princ "(egg:set-mode-indicator " prin1 " " egg:get-mode-indicator " )" "(egg:set-mode-map " egg:dump-map egg:get-mode-map write-region expand-file-name byte-compile-file] 21))

(defun egg:dump-map (map) (byte-code "@?  !A! ! !" [map terpri princ "(let ((map (cons nil nil)))" egg:dump-map-alist " map)" error "ARG map is not toplevel."] 7))

(defun egg:dump-map-alist (alist) (byte-code "	??0 @@@A !
!!!!A* )" [l alist ch action terpri princ "(setf-key-action map " " " egg:dump-map-action ")"] 9))

(defun egg:dump-map-action (action) (byte-code "	!	!!? !Q @=. !8!!Q @=E !8!!Q !A!!
!!*" [map action output t action-get-map action-get-output princ "(list " "nil " next "(list 'next " prin1 1 " nil)" top "(list 'top " " map)" "(let ((map (cons map nil)))" egg:dump-map-alist " )"] 16))

(defvar egg:*mode-on* nil "\
T if egg mode is on.")

(make-variable-buffer-local (quote egg:*mode-on*))

(set-default (quote egg:*mode-on*) nil)

(defvar egg:*input-mode* t "\
T if egg map is active.")

(make-variable-buffer-local (quote egg:*input-mode*))

(set-default (quote egg:*input-mode*) t)

(defvar egg:*in-fence-mode* nil "\
T if in fence mode.")

(define-egg-mode "roma-kana")

(egg:set-mode-indicator "roma-kana" " a")

(defvar egg:*current-map* nil)

(make-variable-buffer-local (quote egg:*current-map*))

(setq-default egg:*current-map* (egg:get-mode-map "roma-kana"))

(defvar egg:*current-mode* nil)

(make-variable-buffer-local (quote egg:*current-mode*))

(setq-default egg:*current-mode* (egg:get-mode-indicator "roma-kana"))

(defconst mode-line-egg-mode "----")

(make-variable-buffer-local (quote mode-line-egg-mode))

(defvar mode-line-egg-mode-in-minibuffer "----" "\
global variable")

(defvar egg-in-minibuffer nil "\
global variable")

(defun egg:find-symbol-in-tree (item tree) (byte-code ": 	@\" 	A\" 	\"" [tree item egg:find-symbol-in-tree equal] 5))

(or (fboundp (quote si:select-window)) (fset (quote si:select-window) (symbol-function (quote select-window))))

(defun new:select-window (window) (byte-code "  =
 =	=  !	
!*" [was-in-minibuf enter-minibuf window minibuffer-window-selected selected-window minibuffer-window set-buffer-modified-p buffer-modified-p si:select-window] 7))

(or (fboundp (quote si:other-window)) (fset (quote si:other-window) (symbol-function (quote other-window))))

(defun new:other-window (arg) (interactive "p") (byte-code " 	W\" 	W !	T = 	V= 	V= \"	S( !)" [window arg nil selected-window 0 previous-window next-window select-window] 6))

(if (not (boundp (quote minibuffer-window-selected))) (progn (fset (quote select-window) (symbol-function (quote new:select-window))) (fset (quote other-window) (symbol-function (quote new:other-window)))))

(setq minibuffer-window-selected nil)

(defvar display-minibuffer-mode nil)

(defvar *minibuffer-window* (minibuffer-window))

(if (not (egg:find-symbol-in-tree (quote mode-line-egg-mode) mode-line-format)) (setq-default mode-line-format (cons (list (quote kanji-flag) (list (list (quote minibuffer-window-selected) (list (quote display-minibuffer-mode) "m" " ") " ") "[" (list (quote minibuffer-window-selected) (list (quote display-minibuffer-mode) (quote mode-line-egg-mode-in-minibuffer) (quote mode-line-egg-mode)) (quote mode-line-egg-mode)) "]")) mode-line-format)))

(defun mode-line-egg-mode-update (str) (byte-code "  	=   !" [minibuffer-window-selected *minibuffer-window* t display-minibuffer-mode mode-line-egg-mode-in-minibuffer str nil mode-line-egg-mode selected-window set-buffer-modified-p buffer-modified-p] 4))

(mode-line-egg-mode-update mode-line-egg-mode)

(defvar alphabet-mode-indicator " a a")

(defvar transparent-mode-indicator "----")

(defun egg:mode-line-display nil (byte-code " 	? 
  	  !" [egg:*in-fence-mode* egg:*input-mode* alphabet-mode-indicator egg:*mode-on* egg:*current-mode* t transparent-mode-indicator mode-line-egg-mode-update] 2))

(defun egg:toggle-egg-mode-on-off nil (interactive) (byte-code "? " [egg:*mode-on* nil egg:mode-line-display] 2))

(defun egg:goto-input-mode (name) (interactive (byte-code "\"C" [egg:*mode-alist* completing-read "EGG mode: "] 3)) (byte-code "Ĉ	! 	!	!   " [egg:*mode-alist* name egg:*current-mode* egg:*current-map* nil egg:get-mode-map egg:get-mode-indicator egg:mode-line-display beep] 6))

(defun toggle-egg-mode nil (interactive) (byte-code "È 	    " [kanji-flag egg:*mode-on* t nil fence-toggle-egg-mode egg:mode-line-display] 3))

(defun fence-toggle-egg-mode nil (interactive) (byte-code " 	?   " [egg:*current-map* egg:*input-mode* nil egg:mode-line-display beep] 3))

(defvar si:*global-map* (copy-keymap global-map))

(let ((ch 32)) (while (< ch 127) (aset global-map ch (quote egg-self-insert-command)) (setq ch (1+ ch))))

(define-key global-map "" (quote toggle-egg-mode))

(define-key ctl-x-map " " (quote henkan-region))

(if (not (fboundp (quote si:keyboard-quit))) (fset (quote si:keyboard-quit) (symbol-function (quote keyboard-quit))))

(defun keyboard-quit nil "\
See documents for si:keyboard-quit" (interactive) (byte-code "   " [minibuffer-window-selected nil display-minibuffer-mode egg:*mode-on* egg:*in-fence-mode* egg:mode-line-display si:keyboard-quit] 3))

(if (not (fboundp (quote si:abort-recursive-edit))) (fset (quote si:abort-recursive-edit) (symbol-function (quote abort-recursive-edit))))

(defun abort-recursive-edit nil "\
See documents for si:abort-recursive-edit" (interactive) (byte-code "    " [minibuffer-window-selected nil display-minibuffer-mode egg:*mode-on* egg:*in-fence-mode* egg:mode-line-display si:abort-recursive-edit] 3))

(if (not (fboundp (quote si:exit-minibuffer))) (fset (quote si:exit-minibuffer) (symbol-function (quote exit-minibuffer))))

(defun exit-minibuffer nil "\
See documents for si:exit-minibuffer" (interactive) (byte-code "  " [egg:*mode-on* nil minibuffer-window-selected display-minibuffer-mode egg:mode-line-display si:exit-minibuffer] 3))

(defun egg:do-auto-fill nil (byte-code " 	? i
V- i!
iW iW, i! )" [auto-fill-hook buffer-read-only fill-column ocolumn run-hooks] 4))

(defconst egg:*fence-open* "|" "\
*ե󥹤λ򼨤ʸ")

(defconst egg:*fence-close* "|" "\
*ե󥹤ν򼨤ʸ")

(defconst egg:*fence-attribute* nil "\
*եɽѤattribute ޤ nil")

(defvar egg:*attribute-alist* (quote (("nil") ("inverse" . inverse) ("underline" . underline))))

(defun set-egg-fence-mode-format (open close &optional attr) "\
fence mode ɽˡꤹ롣OPEN ϥե󥹤λ򼨤ʸޤ nil
CLOSEϥե󥹤ν򼨤ʸޤ nil
optional ATTR ϥե󥹶֤ɽ° ޤ nilx11term Τߤͭ" (interactive (byte-code "!!\"\"AE" [egg:*attribute-alist* read-string "ե󥹳ʸ: " "ե󥹽λʸ: " assoc completing-read "եɽ°: "] 8)) (byte-code "Ȉ	;	 	? 
; 
? \": 	\" 
( 5 !ǂ@ 	
$" [egg:*attribute-alist* open close attr egg:*fence-open* egg:*fence-close* egg:*fence-attribute* t nil egg:member (underline inverse nil) "" require attribute error "Wrong type of argument: %s %s %s"] 7))

(defconst egg:*region-start* (make-marker))

(defconst egg:*region-end* (set-marker-type (make-marker) t))

(defvar egg:*global-map-backup* nil)

(defvar egg:*local-map-backup* nil)

(defun egg-self-insert-command (arg) (interactive "p") (byte-code "Ɉ? 	 
  ? U?$  R !1 !J XG `Z`#R UR  " [buffer-read-only kanji-flag egg:*mode-on* egg:*input-mode* egg:*in-fence-mode* last-command-char arg egg-insert-after-hook self-insert-after-hook nil 32 egg:enter-fence-mode-and-self-insert self-insert-command run-hooks 1 funcall egg:do-auto-fill] 7))

(defun egg:enter-fence-mode-and-self-insert nil (byte-code " 	" [unread-command-char last-command-char enter-fence-mode] 3))

(defun egg:fence-attribute-on nil (byte-code "\"" [egg:*fence-attribute* t egg:set-region-attribute] 3))

(defun egg:fence-attribute-off nil (byte-code "\"" [egg:*fence-attribute* nil egg:set-region-attribute] 3))

(defun enter-fence-mode nil (byte-code "!	   !c`\"c\" b" [disable-undo t egg:*in-fence-mode* egg:*local-map-backup* fence-mode-map egg:*fence-open* egg:*region-start* egg:*fence-close* egg:*region-end* boundp egg:mode-line-display current-local-map use-local-map set-marker egg:fence-attribute-on] 8))

(defun henkan-fence-region-or-single-space nil (interactive) (byte-code "   c" [egg:*input-mode* nil henkan-fence-region 32] 2))

(defun henkan-fence-region nil (interactive) (byte-code "	\"" [egg:*region-start* egg:*region-end* nil henkan-region-internal] 3))

(defun fence-katakana nil (interactive) (byte-code "	\"" [egg:*region-start* egg:*region-end* nil katakana-region] 3))

(defun fence-hiragana nil (interactive) (byte-code "	\"" [egg:*region-start* egg:*region-end* nil hiragana-region] 3))

(defun fence-hankaku nil (interactive) (byte-code "	\"" [egg:*region-start* egg:*region-end* nil hankaku-region] 3))

(defun fence-zenkaku nil (interactive) (byte-code "	\"" [egg:*region-start* egg:*region-end* nil zenkaku-region] 3))

(defun fence-backward-char nil (interactive) (byte-code "`W    " [egg:*region-start* nil backward-char beep] 3))

(defun fence-forward-char nil (interactive) (byte-code "`W    " [egg:*region-end* nil forward-char beep] 3))

(defun fence-beginning-of-line nil (interactive) (byte-code "b" [egg:*region-start* nil] 1))

(defun fence-end-of-line nil (interactive) (byte-code "b" [egg:*region-end* nil] 1))

(defun fence-transpose-chars (arg) (interactive "P") (byte-code "È`W `	W 
!  " [egg:*region-start* egg:*region-end* arg nil transpose-chars beep] 3))

(defun egg:exit-if-empty-region nil (byte-code "	U  " [egg:*region-start* egg:*region-end* fence-exit-mode] 2))

(defun fence-delete-char nil (interactive) (byte-code "`W !   " [egg:*region-end* nil delete-char 1 egg:exit-if-empty-region beep] 4))

(defun fence-backward-delete-char nil (interactive) (byte-code "`W !   " [egg:*region-start* nil delete-char -1 egg:exit-if-empty-region beep] 4))

(defun fence-kill-line nil (interactive) (byte-code "`\" " [egg:*region-end* nil delete-region egg:exit-if-empty-region] 3))

(defun fence-exit-mode nil (interactive) (byte-code "Ĉ	GZ\"

G\\\"  " [egg:*region-start* egg:*fence-open* egg:*region-end* egg:*fence-close* nil delete-region egg:fence-attribute-off egg:quit-egg-mode] 5))

(defvar egg-insert-after-hook nil)

(make-variable-buffer-local (quote egg-insert-after-hook))

(defvar egg-exit-hook nil "\
Hook to run when egg exits. Should take two arguments START and END
correspoding to character position.")

(defun egg:quit-egg-mode nil (byte-code "! ( Z `)Z^\\\"*8 #Q 	G 	#Q U?Q  \"\"!g 
p !" [egg:*local-map-backup* egg:*in-fence-mode* nil overwrite-mode length egg:*region-end* egg:*region-start* rest self-insert-after-hook egg-exit-hook disable-undo egg-insert-after-hook use-local-map egg:mode-line-display end-of-line kanji-delete-region funcall egg:do-auto-fill set-marker boundp run-hooks] 12))

(defun fence-cancel-input nil (interactive) (byte-code "	\" " [egg:*region-start* egg:*region-end* nil delete-region fence-exit-mode] 3))

(defvar fence-mode-map (make-keymap))

(defvar fence-mode-esc-map (make-keymap))

(let ((ch 0)) (while (<= ch 127) (aset fence-mode-map ch (quote undefined)) (aset fence-mode-esc-map ch (quote undefined)) (setq ch (1+ ch))))

(let ((ch 32)) (while (< ch 127) (aset fence-mode-map ch (quote fence-self-insert-command)) (setq ch (1+ ch))))

(define-key fence-mode-map "" fence-mode-esc-map)

(define-key fence-mode-map "h" (quote fence-hiragana))

(define-key fence-mode-map "k" (quote fence-katakana))

(define-key fence-mode-map "<" (quote fence-hankaku))

(define-key fence-mode-map ">" (quote fence-zenkaku))

(define-key fence-mode-map " " (quote henkan-fence-region-or-single-space))

(define-key fence-mode-map " " (quote henkan-fence-region))

(define-key fence-mode-map "" (quote fence-beginning-of-line))

(define-key fence-mode-map "" (quote fence-backward-char))

(define-key fence-mode-map "" (quote fence-cancel-input))

(define-key fence-mode-map "" (quote fence-delete-char))

(define-key fence-mode-map "" (quote fence-end-of-line))

(define-key fence-mode-map "" (quote fence-forward-char))

(define-key fence-mode-map "" (quote fence-cancel-input))

(define-key fence-mode-map "" (quote help-command))

(define-key fence-mode-map "	" (quote undefined))

(define-key fence-mode-map "
" (quote undefined))

(define-key fence-mode-map "" (quote fence-kill-line))

(define-key fence-mode-map "" (quote fence-exit-mode))

(define-key fence-mode-map "" (quote fence-exit-mode))

(define-key fence-mode-map "" (quote undefined))

(define-key fence-mode-map "" (quote undefined))

(define-key fence-mode-map "" (quote undefined))

(define-key fence-mode-map "" (quote undefined))

(define-key fence-mode-map "" (quote undefined))

(define-key fence-mode-map "" (quote undefined))

(define-key fence-mode-map "" (quote fence-transpose-chars))

(define-key fence-mode-map "" (quote undefined))

(define-key fence-mode-map "" (quote undefined))

(define-key fence-mode-map "" (quote henkan-fence-region))

(define-key fence-mode-map "" (quote undefined))

(define-key fence-mode-map "" (quote undefined))

(define-key fence-mode-map "" (quote eval-expression))

(define-key fence-mode-map "" (quote fence-toggle-egg-mode))

(define-key fence-mode-map "" (quote jis-code-input))

(define-key fence-mode-map "" (quote fence-backward-delete-char))

(defvar egg:*minibuffer-local-hiragana-map* (copy-keymap minibuffer-local-map))

(let ((ch 32)) (while (< ch 127) (define-key egg:*minibuffer-local-hiragana-map* (make-string 1 ch) (quote fence-self-insert-command)) (setq ch (1+ ch))))

(defun read-hiragana-string (prompt &optional initial-input) (byte-code " !q!#*))" [minibuff egg:*input-mode* t egg:*current-map* prompt initial-input egg:*minibuffer-local-hiragana-map* window-buffer minibuffer-window egg:get-mode-map "roma-kana" read-from-minibuffer] 7))

(defvar *KKCP:error-flag* t)

(defun KKCP:error (errorCode &rest form) (byte-code "=,   \"	    \")  ( \" =X  : \"	L  H \"U  T \" :a @= A@\"	x A@\"~ A@\" : @= A@\"	 A@\" A\" #	 # #" [errorCode debug-on-error t form :WNN_SOCK_OPEN_FAIL notify "EGG: %s  WNN ޤ" get-wnn-host-name "local" error "EGG: No WNN on %s is running." :WNN_JSERVER_DEAD "EGG: %s WNN Ǥޤ" "EGG: WNN on %s is dead." "EGG: %s  WNN Ǥޤ" :WNN_UNKNOWN_HOST "EGG: ۥ %s ߤĤޤ" "EGG: Host %s is unknown." :WNN_UNKNOWN_SERVICE "EGG: Network service %s ߤĤޤ" "EGG: Service %s is unknown." "KKCP:  %s  %s ˼Ԥޤ" "KKCP: %s failed because of %s."] 24))

(defun KKCP:server-open (hostname loginname) (byte-code "	
\"?  	
$)" [result hostname loginname wnn-error-code t wnn-server-open KKCP:error KKCP:server-open] 6))

(defun KKCP:use-dict (dict hindo priority file-mode) (byte-code "	
$? 5 =\"  	
$5 ?, 5 	
&)" [result dict hindo priority file-mode wnn-error-code *KKCP:error-flag* t wnn-server-use-dict :wnn-no-connection EGG:open-wnn KKCP:use-dict KKCP:error kkcp:use-dict] 10))

(defun KKCP:henkan-begin (henkan-string) (byte-code "	!
? * 
=  	!* ?% * 
	#)" [result henkan-string wnn-error-code *KKCP:error-flag* t wnn-server-henkan-begin :wnn-no-connection EGG:open-wnn KKCP:henkan-begin KKCP:error] 7))

(defun KKCP:henkan-next (bunsetu-no) (byte-code "	!
? * 
=  	!* ?% * 
	#)" [result bunsetu-no wnn-error-code *KKCP:error-flag* t wnn-server-henkan-next :wnn-no-connection EGG:open-wnn KKCP:henkan-next KKCP:error] 7))

(defun KKCP:henkan-inspect (bunsetu-no jikouho-no) (byte-code "	
\"? - =  	
\"- ?' - 	
$)" [result bunsetu-no jikouho-no wnn-error-code *KKCP:error-flag* t wnn-bunsetu-kouho-inspect :wnn-no-connection EGG:open-wnn KKCP:henkan-inspect KKCP:error] 8))

(defun KKCP:henkan-kakutei (bunsetu-no jikouho-no) (byte-code "	
\"? - =  	
\"- ?' - 	
$)" [result bunsetu-no jikouho-no wnn-error-code *KKCP:error-flag* t wnn-server-henkan-kakutei :wnn-no-connection EGG:open-wnn KKCP:henkan-kakutei KKCP:error] 8))

(defun KKCP:bunsetu-henkou (bunsetu-no bunsetu-length) (byte-code "	
\"? - =  	
\"- ?' - 	
$)" [result bunsetu-no bunsetu-length wnn-error-code *KKCP:error-flag* t wnn-server-bunsetu-henkou :wnn-no-connection EGG:open-wnn KKCP:bunsetu-henkou KKCP:error kkcp:bunsetu-henkou] 8))

(defun KKCP:henkan-quit nil (byte-code " 	? ' 	=   ' 
?# ' 	\")" [result wnn-error-code *KKCP:error-flag* t wnn-server-henkan-quit :wnn-no-connection EGG:open-wnn KKCP:henkan-quit KKCP:error] 6))

(defun KKCP:henkan-end (&optional bunsetuno) (byte-code "	!
? ) 
=  	!) ?% ) 
\")" [result bunsetuno wnn-error-code *KKCP:error-flag* t wnn-server-henkan-end :wnn-no-connection EGG:open-wnn KKCP:henkan-end KKCP:error] 6))

(defun KKCP:set-current-dict (dict-no) (byte-code "	!
? * 
=  	!* ?% * 
	#)" [result dict-no wnn-error-code *KKCP:error-flag* t wnn-server-set-current-dict :wnn-no-connection EGG:open-wnn KKCP:set-current-dict KKCP:error kkcp:set-current-dict] 7))

(defun KKCP:dict-add (kanji yomi bunpo) (byte-code "	
#? 0 =   	
#0 ?) 0 	
%)" [result kanji yomi bunpo wnn-error-code *KKCP:error-flag* t wnn-server-dict-add :wnn-no-connection EGG:open-wnn KKCP:dict-add KKCP:error] 9))

(defun KKCP:dict-delete (serial-no yomi) (byte-code "	
\"? - =  	
\"- ?' - 	
$)" [result serial-no yomi wnn-error-code *KKCP:error-flag* t wnn-server-dict-delete :wnn-no-connection EGG:open-wnn KKCP:dict-delete KKCP:error] 8))

(defun KKCP:dict-info (yomi) (byte-code "	!
? * 
=  	!* ?% * 
	#)" [result yomi wnn-error-code *KKCP:error-flag* t wnn-server-dict-info :wnn-no-connection EGG:open-wnn KKCP:dict-info KKCP:error] 7))

(defun KKCP:make-directory (pathname) (byte-code "	!
? * 
=  	!* ?% * 
	#)" [result pathname wnn-error-code *KKCP:error-flag* t wnn-server-make-directory :wnn-no-connection EGG:open-wnn KKCP:make-directory KKCP:error kkcp:make-directory] 7))

(defun KKCP:file-access (pathname mode) (byte-code "	
\"? U Ă ł8 =(  	
\"8 ?2 8 	
$)" [result pathname mode wnn-error-code t nil *KKCP:error-flag* wnn-server-file-access 0 :wnn-no-connection EGG:open-wnn KKCP:file-access KKCP:error kkcp:file-access] 8))

(defun KKCP:server-close nil (byte-code " 	?  
?  	\")" [result wnn-error-code *KKCP:error-flag* t wnn-server-close KKCP:error KKCP:server-close] 4))

(defvar *default-sys-dic-directory* "~/")

(defun set-default-sys-dic-directory (pathname) "\
ƥ༭ɸdirectory PATHNAMEꤹ롣
PATHNAMEϴĶѿޤǤ褤" (byte-code "!!? !) \"?$ \"!) !" [pathname *default-sys-dic-directory* substitute-in-file-name file-name-absolute-p error "Default directory must be absolute pathname" KKCP:file-access 0 format "System Default directory(%s) ޤ" file-name-as-directory] 9))

(defvar *default-usr-dic-directory* "~/")

(defun set-default-usr-dic-directory (pathname) "\
ѼԼɸdirectory PATHNAMEꤹ롣
PATHNAMEϴĶѿޤǤ褤" (byte-code "!!!? !O \"?K O!	\"?5 \"!J \"!I !\"J )" [pathname updir nil *default-usr-dic-directory* file-name-as-directory substitute-in-file-name file-name-absolute-p error "Default directory must be absolute pathname" KKCP:file-access 0 file-name-directory -1 format "User Default directory(%s) ޤ" yes-or-no-p "User Default directory(%s) ޤ" KKCP:make-directory notify "User Default directory(%s) ޤ"] 15))

(defun setsysdic (dict hindo priority &optional noextend) (byte-code "	!? 
 	 ɂ Q	!?\" # - ɂ. Q!!#*" [dictfile dict *default-sys-dic-directory* noextend hindofile *default-usr-dic-directory* hindo priority file-name-absolute-p "" ".sys" ".hindo" egg:setsysdict expand-file-name] 8))

(defun setusrdic (dict priority &optional noextend) (byte-code "	!? 
 	 Ƃ Q!\")" [dictfile dict *default-usr-dic-directory* noextend priority file-name-absolute-p "" ".usr" egg:setusrdict expand-file-name] 5))

(defvar egg:*dict-list* nil)

(defvar egg:*sys-dict* nil)

(defun egg:setsysdict (dict hindo priority) (byte-code "!	\"  !\" \"?'  \" 
\"?d 
\"
\"!a 
$\\ 
\"BB` 
\"* 
$?z \" BB!B	B*" [dict egg:*dict-list* hindo *KKCP:error-flag* nil rc priority egg:*sys-dict* t assoc file-name-nondirectory beep notify "Ʊ̾Υƥ༭ %s ϿƤޤ" KKCP:file-access 0 "ƥ༭ %s ޤ" "٥ե %s ޤ" yes-or-no-p format "٥ե %s ޤ" KKCP:use-dict "٥ե %s ޤ" error "EGG: setsysdict failed.: %s" "EGG: setsysdict failed. :%s"] 20))

(defvar egg:*usr-dict* nil)

(defvar egg:*dict-menu* nil)

(defmacro push-end (val loc) (byte-code "	DE" [val loc push-end-internal quote] 4))

(defun push-end-internal (val loc) (byte-code "! !	B\" 	BL" [loc val nil eval nconc] 7))

(defun egg:setusrdict (dict priority) (byte-code "!	\"  !\" \"?\\ \"\"!Y $!T \"BB!B\"X \"* $! BB!B\"!B	B \"*" [dict egg:*dict-list* *KKCP:error-flag* nil dict-no priority egg:*usr-dict* t assoc file-name-nondirectory beep notify "Ʊ̾ѼԼ %s ϿƤޤ" KKCP:file-access 0 "ѼԼ %s ޤ" yes-or-no-p format "ѼԼ %s ޤ" KKCP:use-dict "" numberp "ѼԼ %s ޤ" push-end-internal egg:*dict-menu* error "EGG: setusrdict failed. : %s"] 23))

(defun get-wnn-host-name nil (byte-code "! ; ! ! 	; 	! !" [wnn-host-name jserver-host-name t boundp getenv "JSERVER"] 4))

(fset (quote get-jserver-host-name) (symbol-function (quote get-wnn-host-name)))

(defun set-wnn-host-name (name) (interactive "sHost name: ") (byte-code " )" [*KKCP:error-flag* nil wnn-host-name name disconnect-wnn] 3))

(defvar egg-default-startup-file "eggrc" "\
*Egg startup file name (system default)")

(defvar egg-startup-file ".eggrc" "\
*Egg startup file name.")

(defvar egg-startup-file-search-path (append (quote ("~" ".")) load-path) "\
*List of directories to search for start up file to load.")

(defun egg:search-file (filename searchpath) (byte-code "
!??  ?; 
@;\" @# \"!!2 6 A) )O 
!!!N ))" [result nil filename path searchpath file file-name-directory substitute-in-file-name expand-file-name file-exists-p] 9))

(defun EGG:open-wnn nil (byte-code "    \"  \"\"/ 	\": !@  !)" [egg:*sys-dict* nil egg:*usr-dict* egg:*dict-list* egg:*dict-menu* eggrc egg-startup-file egg-startup-file-search-path egg-default-startup-file load-path KKCP:server-open get-wnn-host-name system-name user-login-name notify "ۥ %s  WNN ưޤ" "local" egg:search-file load-file KKCP:server-close error "eggrc-search-path  egg-startup-file ޤ"] 12))

(defun disconnect-wnn nil (interactive) (byte-code " " [nil KKCP:server-close] 2))

(defun close-wnn nil (interactive) (byte-code "   !! " [nil wnn-server-active-p wnn-server-dict-save message "Wnnپ󡦼򤷤ޤ" sit-for 0 KKCP:server-close] 6))

(defvar egg:*kanji-kanabuff* nil)

(defvar *bunsetu-number* nil)

(defun bunsetu-su nil (byte-code " " [wnn-bunsetu-suu] 2))

(defun bunsetu-length (number) (byte-code "!" [number wnn-bunsetu-yomi-moji-suu] 2))

(defun kanji-moji-suu (str) (byte-code "	GW* 
T	HW! T& \\ 
+" [max str count i 0 128 2] 3))

(defun bunsetu-position (number) (byte-code "	
W 
!G#
T *" [pos egg:*region-start* i number egg:*bunsetu-kugiri* 0 + bunsetu-kanji-length] 6))

(defun bunsetu-kanji-length (bunsetu-no) (byte-code "!" [bunsetu-no wnn-bunsetu-kanji-length] 2))

(defun bunsetu-kanji (number) (byte-code "!" [number wnn-bunsetu-kanji] 2))

(defun bunsetu-kanji-insert (bunsetu-no) (byte-code "p\"" [bunsetu-no wnn-bunsetu-kanji] 3))

(defun bunsetu-set-kanji (bunsetu-no kouho-no) (byte-code "	\"" [bunsetu-no kouho-no wnn-server-henkan-kakutei] 3))

(defun bunsetu-yomi (number) (byte-code "!" [number wnn-bunsetu-yomi] 2))

(defun bunsetu-yomi-insert (bunsetu-no) (byte-code "p\"" [bunsetu-no wnn-bunsetu-yomi] 3))

(defun bunsetu-yomi-equal (number yomi) (byte-code "	\"" [number yomi wnn-bunsetu-yomi-equal] 3))

(defun bunsetu-kouho-suu (bunsetu-no) (byte-code "	!W  	!	!)" [no bunsetu-no wnn-bunsetu-kouho-suu 1 KKCP:henkan-next] 4))

(defun bunsetu-kouho-list (number) (byte-code "	!U 	!	!)" [no number bunsetu-kouho-suu 1 KKCP:henkan-next wnn-bunsetu-kouho-list] 4))

(defun bunsetu-kouho-number (bunsetu-no) (byte-code "!" [bunsetu-no wnn-bunsetu-kouho-number] 2))

(defun egg:henkan-attribute-on nil (byte-code "\"" [egg:*henkan-attribute* t egg:set-region-attribute] 3))

(defun egg:henkan-attribute-off nil (byte-code "\"" [egg:*henkan-attribute* nil egg:set-region-attribute] 3))

(defun henkan-region (start end) (interactive "r") (byte-code "t	 `!	\"" [start end nil set-mark henkan-region-internal] 4))

(defvar henkan-mode-indicator "")

(defun henkan-region-internal (start end) "\
region򤫤ʴѴ롣" (byte-code "	
\"ĉ! !	b!?Z  !3 ʉ		b	
\"c`\"c\" b  GZ\"G\\\"bc`\"b`c\")	b	
\" !!!)" [egg:*kanji-kanabuff* start end *bunsetu-number* nil result henkan-mode-indicator egg:*region-start* egg:*local-map-backup* disable-undo t egg:*henkan-open* egg:*henkan-close* egg:*region-end* egg:*fence-open* egg:*fence-close* point henkan-mode-map buffer-substring KKCP:henkan-begin mode-line-egg-mode-update marker-position current-local-map boundp delete-region set-marker egg:henkan-attribute-on egg:fence-attribute-off henkan-insert-kouho 0 henkan-goto-bunsetu use-local-map] 21))

(defun henkan-paragraph nil "\
Kana-kanji henkan  paragraph at or after point." (interactive) (byte-code " ` `\"))" [end nil forward-paragraph backward-paragraph henkan-region-internal] 5))

(defun henkan-sentence nil "\
Kana-kanji henkan sentence at or after point." (interactive) (byte-code " ` `\"))" [end nil forward-sentence backward-sentence henkan-region-internal] 5))

(defconst egg:*bunsetu-kugiri* " " "\
*ʸζڤ򼨤ʸ")

(defconst egg:*bunsetu-attribute* nil "\
*ʸɽѤattribute ޤ nil")

(defconst egg:*henkan-attribute* nil "\
*Ѵΰɽattribute ޤ nil")

(defconst egg:*henkan-open* "|" "\
*Ѵλ򼨤ʸ")

(defconst egg:*henkan-close* "|" "\
*Ѵν򼨤ʸ")

(defun set-egg-henkan-mode-format (open close kugiri &optional attr1 attr2) "\
Ѵ mode ɽˡꤹ롣OPEN Ѵλ򼨤ʸޤ nil
CLOSEѴν򼨤ʸޤ nil
KUGIRIʸζڤɽʸޤ nil
optional ATTR1 Ѵ֤ɽ° ޤ nilx11term Τߤͭ
optional ATTR2 ʸ֤ɽ° ޤ nilx11term Τߤͭ" (interactive (byte-code "!!!\"\"A\"\"A%" [egg:*attribute-alist* list read-string "Ѵʸ: " "Ѵλʸ: " "ʸڤʸ: " assoc completing-read "Ѵɽ°: " "ʸɽ°: "] 14)) (byte-code "ˈ	;	 	?+ 
; 
?+ ; ?+ \"+ \"S 	
9 	
H N !˂\\ 	
&" [egg:*attribute-alist* open close kugiri attr1 attr2 egg:*henkan-open* egg:*henkan-close* egg:*bunsetu-kugiri* egg:*henkan-attribute* egg:*bunsetu-attribute* nil egg:member (underline inverse nil) (underline inverse nil) "" require attribute error "Wrong type of arguments: %1 %2 %3 %4 %5"] 10))

(defun henkan-insert-kouho (bunsetu-no) (byte-code " 
	W 	!c	T 
W& G[!*" [max i bunsetu-no egg:*bunsetu-kugiri* bunsetu-su bunsetu-kanji-insert delete-char] 5))

(defun henkan-kakutei nil (interactive) (byte-code "Ȉ! 	
GZ	\"	\"G\\\"	b WC !?:  T' *  " [*bunsetu-number* egg:*region-start* egg:*henkan-open* egg:*region-end* egg:*henkan-close* i max overwrite-mode nil egg:bunsetu-attribute-off egg:henkan-attribute-off delete-region 0 bunsetu-su bunsetu-kanji-insert undo-boundary KKCP:henkan-end egg:quit-egg-mode] 11))

(defun henkan-kakutei-before-point nil (interactive) (byte-code "Έ! 	
\"	bW/ !?&  T *!	GZ	\"c	`\"

G\\\"
b`	
c
	\")	b ` 	W !To 	b+̉! " [*bunsetu-number* egg:*region-start* egg:*region-end* i max overwrite-mode egg:*henkan-open* egg:*fence-open* egg:*henkan-close* point egg:*fence-close* egg:*mode-on* t fence-mode-map nil egg:bunsetu-attribute-off egg:henkan-attribute-off delete-region 0 bunsetu-kanji-insert undo-boundary KKCP:henkan-end set-marker egg:fence-attribute-on bunsetu-su bunsetu-yomi-insert use-local-map egg:mode-line-display] 16))

(defun egg:set-region-attribute (attr on) (byte-code "
 	
$" [attr egg:*region-start* egg:*region-end* on attribute-on-off-region] 5))

(defun egg:set-bunsetu-attribute (no attr switch) (byte-code " 	J 		=2 !

!\" 
!# 
fX, ̂- \\)5 ! SUA H T!GZ$" [no attr point egg:*region-end* egg:*bunsetu-kugiri* switch attribute-on-off-region inverse bunsetu-position 128 markerp marker-position 2 1 bunsetu-su] 11))

(defun egg:bunsetu-attribute-on (no) (byte-code "	#" [no egg:*bunsetu-attribute* t egg:set-bunsetu-attribute] 4))

(defun egg:bunsetu-attribute-off (no) (byte-code "	#" [no egg:*bunsetu-attribute* nil egg:set-bunsetu-attribute] 4))

(defun henkan-goto-bunsetu (number) (byte-code "! 	 S#!b
#!" [*bunsetu-number* number egg:*henkan-attribute* nil egg:bunsetu-attribute-off egg:henkan-attribute-on check-number-range 0 bunsetu-su bunsetu-position egg:set-bunsetu-attribute egg:bunsetu-attribute-on] 9))

(defun henkan-forward-bunsetu nil (interactive) (byte-code "T!" [*bunsetu-number* nil henkan-goto-bunsetu] 2))

(defun henkan-backward-bunsetu nil (interactive) (byte-code "S!" [*bunsetu-number* nil henkan-goto-bunsetu] 2))

(defun henkan-first-bunsetu nil (interactive) (byte-code "!" [nil henkan-goto-bunsetu 0] 2))

(defun henkan-last-bunsetu nil (interactive) (byte-code " S!" [nil henkan-goto-bunsetu bunsetu-su] 3))

(defun check-number-range (i min max) (byte-code "	W
 
 
W 	 " [i min max t] 2))

(defun henkan-hiragana nil (interactive) (byte-code "!Z!" [*bunsetu-number* nil henkan-goto-kouho bunsetu-kouho-suu 1] 4))

(defun henkan-katakana nil (interactive) (byte-code "!Z!" [*bunsetu-number* nil henkan-goto-kouho bunsetu-kouho-suu 2] 4))

(defun henkan-next-kouho nil (interactive) (byte-code "!T!" [*bunsetu-number* nil henkan-goto-kouho bunsetu-kouho-number] 3))

(defun henkan-previous-kouho nil (interactive) (byte-code "!S!" [*bunsetu-number* nil henkan-goto-kouho bunsetu-kouho-number] 3))

(defun henkan-goto-kouho (kouho-number) (byte-code "! `! !S#WP 
\"G !!\\\"b\"!)T 	b,#!" [*bunsetu-number* point yomi i max kouho-number p1 egg:*henkan-attribute* nil egg:bunsetu-attribute-off egg:henkan-attribute-on bunsetu-yomi bunsetu-su check-number-range 0 bunsetu-kouho-suu bunsetu-yomi-equal bunsetu-position delete-region bunsetu-kanji-length bunsetu-set-kanji bunsetu-kanji-insert egg:set-bunsetu-attribute egg:bunsetu-attribute-on] 16))

(defun henkan-bunsetu-chijime nil (interactive) (byte-code "!U !S!" [*bunsetu-number* nil bunsetu-length 1 bunsetu-length-henko] 4))

(defun henkan-bunsetu-nobasi nil (interactive) (byte-code "T U? !T!" [*bunsetu-number* nil bunsetu-su bunsetu-length-henko bunsetu-length] 4))

(defun henkan-saishou-bunsetu nil (interactive) (byte-code "!" [nil bunsetu-length-henko 1] 2))

(defun henkan-saichou-bunsetu nil (interactive) (byte-code "Ĉ 
	W 	!\\	T	 !+" [max i *bunsetu-number* l nil bunsetu-su 0 bunsetu-length bunsetu-length-henko] 5))

(defun bunsetu-length-henko (length) (byte-code " !
\"	& !\"!b!!2  #!)" [*bunsetu-number* r length egg:*region-end* t egg:*henkan-attribute* nil egg:henkan-attribute-off egg:bunsetu-attribute-off KKCP:bunsetu-henkou delete-region bunsetu-position henkan-insert-kouho henkan-goto-bunsetu egg:henkan-attribute-on egg:set-bunsetu-attribute egg:bunsetu-attribute-on] 13))

(defun henkan-quit nil (interactive) (byte-code "̈! 	
GZ	\"	\"G\\\"	bc	`\"c`c\")b  ʉ	! " [*bunsetu-number* egg:*region-start* egg:*henkan-open* egg:*region-end* egg:*henkan-close* egg:*fence-open* egg:*kanji-kanabuff* point egg:*fence-close* egg:*mode-on* t fence-mode-map nil egg:bunsetu-attribute-off egg:henkan-attribute-off delete-region set-marker egg:fence-attribute-on KKCP:henkan-quit use-local-map egg:mode-line-display] 12))

(defun henkan-select-kouho nil (interactive) (byte-code "ň  =?L 	!7 @BBTA !+E
	!\"!*N  " [kouho-list *bunsetu-number* menu l r nil i selected-window minibuffer-window bunsetu-kouho-list ":" 0 reverse henkan-goto-kouho menu:select-from-menu bunsetu-kouho-number beep] 9))

(defun henkan-kakutei-and-self-insert nil (interactive) (byte-code "	 " [unread-command-char last-command-char nil henkan-kakutei] 2))

(defvar henkan-mode-map (make-keymap))

(defvar henkan-mode-esc-map (make-keymap))

(let ((ch 0)) (while (<= ch 127) (aset henkan-mode-map ch (quote undefined)) (aset henkan-mode-esc-map ch (quote undefined)) (setq ch (1+ ch))))

(let ((ch 32)) (while (< ch 127) (aset henkan-mode-map ch (quote henkan-kakutei-and-self-insert)) (setq ch (1+ ch))))

(define-key henkan-mode-map "" henkan-mode-esc-map)

(define-key henkan-mode-map "i" (quote henkan-inspect-bunsetu))

(define-key henkan-mode-map "s" (quote henkan-select-kouho))

(define-key henkan-mode-map "h" (quote henkan-hiragana))

(define-key henkan-mode-map "k" (quote henkan-katakana))

(define-key henkan-mode-map "<" (quote henkan-saishou-bunsetu))

(define-key henkan-mode-map ">" (quote henkan-saichou-bunsetu))

(define-key henkan-mode-map " " (quote henkan-next-kouho))

(define-key henkan-mode-map " " (quote henkan-next-kouho))

(define-key henkan-mode-map "" (quote henkan-first-bunsetu))

(define-key henkan-mode-map "" (quote henkan-backward-bunsetu))

(define-key henkan-mode-map "" (quote henkan-quit))

(define-key henkan-mode-map "" (quote undefined))

(define-key henkan-mode-map "" (quote henkan-last-bunsetu))

(define-key henkan-mode-map "" (quote henkan-forward-bunsetu))

(define-key henkan-mode-map "" (quote henkan-quit))

(define-key henkan-mode-map "" (quote help-command))

(define-key henkan-mode-map "	" (quote henkan-bunsetu-chijime))

(define-key henkan-mode-map "
" (quote undefined))

(define-key henkan-mode-map "" (quote henkan-kakutei-before-point))

(define-key henkan-mode-map "" (quote henkan-kakutei))

(define-key henkan-mode-map "" (quote henkan-kakutei))

(define-key henkan-mode-map "" (quote henkan-next-kouho))

(define-key henkan-mode-map "" (quote henkan-bunsetu-nobasi))

(define-key henkan-mode-map "" (quote henkan-previous-kouho))

(define-key henkan-mode-map "" (quote undefined))

(define-key henkan-mode-map "" (quote undefined))

(define-key henkan-mode-map "" (quote undefined))

(define-key henkan-mode-map "" (quote undefined))

(define-key henkan-mode-map "" (quote undefined))

(define-key henkan-mode-map "" (quote undefined))

(define-key henkan-mode-map "" (quote undefined))

(define-key henkan-mode-map "" (quote undefined))

(define-key henkan-mode-map "" (quote undefined))

(define-key henkan-mode-map "" (quote undefined))

(define-key henkan-mode-map "" (quote henkan-quit))

(defun henkan-help-command nil "\
Display documentation fo henkan-mode." (interactive) (byte-code "!! " [henkan-mode-document-string nil "*Help*" princ substitute-command-keys print-help-return-message] 5))

(defvar henkan-mode-document-string "Ѵ⡼:
ʸư
  \\[henkan-first-bunsetu]	Ƭʸ	\\[henkan-last-bunsetu]	ʸ  
  \\[henkan-backward-bunsetu]	ľʸ	\\[henkan-forward-bunsetu]	ľʸ
Ѵѹ
      \\[henkan-previous-kouho]  	    \\[henkan-next-kouho]
  ʸ῭  \\[henkan-bunsetu-nobasi]  	ʸ̤  \\[henkan-bunsetu-chijime]
  Ѵ  \\[henkan-select-kouho]
Ѵ
  ʸ  \\[henkan-kakutei]  	ľʸޤǳ  \\[henkan-kakutei-before-point]
Ѵ    \\[henkan-quit]
")

(defun remove-regexp-in-string (regexp string) (byte-code "	\"? 	P !!	OP	#M !!	OP$ ," [regexp string t str nil ostart oend nstart string-match 0 match-beginning match-end] 11))

(defun toroku-region (start end) (interactive "r") (byte-code "͈	
\"\"\"!!E!!#	\"8	\"8\"A

S 
QT 
a 
Qb %+," [kanji start end yomi type *bunpo-menu* dict-no egg:*dict-menu* hinshi *bunpo-code* gobi dict-name egg:*usr-dict* nil remove-regexp-in-string "[ -]" buffer-substring read-hiragana-string format "Ͽ%s  ɤ :" menu:select-from-menu menu "Ͽ̾:" KKCP:set-current-dict KKCP:dict-add 1 assq 2 notify "ܡ%s(%s: %s)%sϿޤ" " "] 17))

(defvar *bunpo-menu* (quote (menu "ʻ:" (("̾" . 18) ("ͭ̾" . 29) ("ư" menu "ʻ:ư:" (("Ըʸ촴" . 0) ("Ըʸ촴(ü)" . 1) ("Ըʸ촴" . 2) ("Ըʸ촴" . 3) ("Ըʸ촴" . 4) ("ʹԸʸ촴" . 5) ("йԸʸ촴" . 6) ("޹Ըʸ촴" . 7) ("Ըʸ촴" . 8) ("異Ըʸ촴" . 9) ("Ѳ(θ)" . 10) ("Ѳ(θ)" . 11) ("(̾췿)촴" . 12) ("(뷿)촴" . 13) ("(뷿)촴" . 14) ("Ѵ" . 15) ("ư()" . 22) ("ư()" . 23) ("ư" . 28))) ("ƻ촴" . 16) ("ư촴" . 17) ("Ϣλ" . 19) ("" . 20) ("³졦ư" . 21) ("Ƭ" . 24) ("" . 25) ("" . 26) ("" . 27) ("ñ" . 31)))))

(defvar *bunpo-code* (quote ((0 "Ըʸ촴" "" ("ʤ" "ޤ" "" "Ȥ" "")) (1 "Ըʸ촴(ü)" "" ("" "" "" "" "")) (2 "Ըʸ촴" "" ("ʤ" "ޤ" "" "" "")) (3 "Ըʸ촴" "" ("" "" "" "" "")) (4 "Ըʸ촴" "" ("" "" "" "" "")) (5 "ʹԸʸ촴" "" ("" "" "" "" "")) (6 "йԸʸ촴" "" ("" "" "" "" "")) (7 "޹Ըʸ촴" "" ("" "" "" "" "")) (8 "Ըʸ촴" "" ("" "" "" "" "")) (9 "異Ըʸ촴" "" ("" "" "" "" "")) (10 "Ѳ(θ)" "" ("" "" "" "" "")) (11 "Ѳ(θ)" "" ("" "" "" "" "")) (12 "(̾췿)촴" "" ("" "" "" "" "")) (13 "(뷿)촴" "" ("" "" "" "" "")) (14 "(뷿)촴" "" ("" "" "" "" "")) (15 "Ѵ" "" ("" "" "" "" "")) (16 "ƻ촴" "" ("" "" "" "" "")) (17 "ư촴" "" ("" "" "" "" "")) (18 "̾") (19 "Ϣλ") (20 "") (21 "³졦ư") (22 "ư()" "" ("" "" "" "" "")) (23 "ư()" "" ("" "" "" "" "")) (24 "Ƭ") (25 "") (26 "") (27 "") (28 "ư" "" ("" "" "" "" "")) (29 "ͭ̾") (31 "ñ") (1000 "¾"))))

(defvar *diced-window-configuration* nil)

(defvar *diced-dict-info* nil)

(defvar *diced-yomi* nil)

(defun edit-dict-item (yomi) (interactive (byte-code "!C" [read-hiragana-string "ߡ"] 2)) (byte-code "Ȉ	!? 	\"C 	 !ωЉ		GZ]\"Q!!!)" [dict-info yomi *diced-yomi* *diced-window-configuration* major-mode mode-name mode-line-buffer-identification diced-mode-map nil KKCP:dict-info message "%s٤μܤϤޤ" current-window-configuration pop-to-buffer "*Nihongo Dictionary Information*" diced-mode "Diced" "DictEd: " make-string 0 17 32 sit-for use-local-map diced-display] 10))

(defun diced-redisplay nil (byte-code "	!? 	\"  !)" [dict-info *diced-yomi* KKCP:dict-info message "%s٤μܤϤޤ" diced-quit diced-display] 5))

(defun diced-display (dict-info) (byte-code "\"É \"\"\"\" @8@8	\"8	\"8
@8@8\"Aj \"Aj !\"@8 ₄ cc \"\\G G\\ #\"
c\\
GZ\"!!!&A.	\" eb*҉" [dict-info *diced-dict-info* buffer-read-only nil l-kanji l-bunpo kanji bunpo gobi *bunpo-code* hinshi hindo dict-no dict-name egg:*sys-dict* egg:*usr-dict* sys-dict-p serial-no t sort (lambda (x y) (byte-code "8	8W/ 8	8U/ 8	8V/ 8	8U/ 8	8W" [x y 1 2 3] 3)) erase-buffer apply max mapcar (lambda (l) (byte-code "8G" [l 0] 2)) (lambda (l) (byte-code "8	\"8G" [l *bunpo-code* 1 assq] 4)) 0 1 2 assq 3 int-to-string 4 " *" "  " insert " " insert-char 32 - 10 "" file-name-nondirectory "/" " ١"] 28))

(defun diced-add nil (interactive) (byte-code "Έ!!!E!\"A
	\"8
	\"8
< 	Q= 	M QO 
%x !	
#
% ." [t kanji bunpo *bunpo-menu* dict-no egg:*dict-menu* dict-name egg:*usr-dict* gobi *bunpo-code* hinshi item item-yomi *diced-yomi* nil diced-execute read-from-minibuffer "" menu:select-from-menu menu "Ͽ̾:" assq 2 1 " " notify-yes-or-no-p "ܡ%s(%s: %s)%sϿޤ" KKCP:set-current-dict KKCP:dict-add notify "ܡ%s(%s: %s)%sϿޤ" diced-redisplay] 16))

(defun diced-delete nil (interactive) (byte-code " `TfU ! ) gU) !c!)" [buffer-read-only nil beginning-of-line 42 message "ƥ༭ܤϺǤޤ" beep 32 delete-char 1 "D" backward-char] 6))

(defun diced-undelete nil (interactive) (byte-code " gU !c!)  " [buffer-read-only nil beginning-of-line 68 delete-char 1 " " backward-char beep] 5))

(defun diced-quit nil (interactive) (byte-code " !!!" [buffer-read-only nil t *diced-window-configuration* erase-buffer bury-buffer get-buffer "*Nihongo Dictionary Information*" set-window-configuration] 5))

(defun diced-execute (&optional display) (interactive) (byte-code "҈ebm? gU 
8	8	8\"8\"8	8	8		\"AQ 	\"AQ 	!
	\"	8k Ql 
$ 	!\"
$.T! )!?  " [no dict-item *diced-dict-info* kanji bunpo gobi *bunpo-code* hinshi hindo dict-no dict-name egg:*sys-dict* egg:*usr-dict* sys-dict-p serial-no item *diced-yomi* display nil 0 68 1 2 assq 3 int-to-string 4 " " notify-yes-or-no-p "%s(%s)%sޤ" KKCP:set-current-dict KKCP:dict-delete notify "%s(%s)%sޤ" forward-line -1 diced-redisplay] 15))

(defun diced-next-line nil (interactive) (byte-code " !m  !" [nil beginning-of-line forward-line 1 beep -1] 5))

(defun diced-end-of-buffer nil (interactive) (byte-code " !" [nil end-of-buffer forward-line -1] 3))

(defun diced-scroll-down nil (interactive) (byte-code " m !" [nil scroll-down forward-line -1] 3))

(defun diced-mode nil "\
Mode for \"editing\" dictionaries.
In diced, you are \"editing\" a list of the entries in dictionaries.
You can move using the usual cursor motion commands.
Letters no longer insert themselves. Instead, 

Type  a to Add new entry.
Type  d to flag an entry for Deletion.
Type  n to move cursor to Next entry.
Type  p to move cursor to Previous entry.
Type  q to Quit from DicEd.
Type  u to Unflag an entry (remove its D flag).
Type  x to eXecute the deletions requested.
" (byte-code "" [nil] 1))

(defvar diced-mode-map (let ((map (make-keymap))) (suppress-keymap map) map))

(define-key diced-mode-map "a" (quote diced-add))

(define-key diced-mode-map "d" (quote diced-delete))

(define-key diced-mode-map "n" (quote diced-next-line))

(define-key diced-mode-map "p" (quote previous-line))

(define-key diced-mode-map "q" (quote diced-quit))

(define-key diced-mode-map "u" (quote diced-undelete))

(define-key diced-mode-map "x" (quote diced-execute))

(define-key diced-mode-map "" (quote help-command))

(define-key diced-mode-map "" (quote diced-next-line))

(define-key diced-mode-map "" (quote previous-line))

(define-key diced-mode-map "" (quote scroll-up))

(define-key diced-mode-map "<" (quote beginning-of-buffer))

(define-key diced-mode-map ">" (quote diced-end-of-buffer))

(define-key diced-mode-map "v" (quote diced-scroll-down))

(defun henkan-inspect-bunsetu nil (interactive) (byte-code "ˈ		!\"8888\"A/ \"A/ !!8	
	UK \"Y 
#\" !f 
? 
@8\" @8U 	@8U @8
@8A^ )
\"8
	&\".
" [info *bunsetu-number* jiritugo fuzokugo yomi jishono jishoname egg:*sys-dict* egg:*usr-dict* serial bunpo nil hinshi hindo t list *bunpo-code* KKCP:henkan-inspect bunsetu-kouho-number 0 1 2 3 file-name-nondirectory assq int-to-string 4 -1 equal "" notify-internal format "%sסʤҤ餬ʡѴˡܡ%s" KKCP:dict-info "%sסʻ졧%s %s ֹ桧%s ١%s ˡܡ%s"] 21))

(defvar *ku1-alist* (quote (("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . ""))))

(defvar *ku2-alist* (quote (("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . ""))))

(defvar egg:*symbol-alist* (append *ku1-alist* *ku2-alist*))

(defvar *ku3-alist* (quote (("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . ""))))

(defvar egg:*alphanumeric-alist* *ku3-alist*)

(defvar *ku4-alist* (quote (("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . ""))))

(defvar egg:*hiragana-alist* *ku4-alist*)

(defvar *ku5-alist* (quote (("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . ""))))

(defvar egg:*katakana-alist* *ku5-alist*)

(defvar *ku6-alist* (quote (("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . ""))))

(defvar egg:*greek-alist* *ku6-alist*)

(defvar *ku7-alist* (quote (("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . ""))))

(defvar egg:*russian-alist* *ku7-alist*)

(defvar *ku8-alist* (quote (("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . "") ("" . ""))))

(defvar egg:*keisen-alist* *ku8-alist*)

(defun make-all-jis-code-alist nil (byte-code "
W@ W6 \"
\\I\\IB)BS )
S *" [result nil ku ten str 116 32 126 make-string 2 0 128 1] 7))

(defun make-jis-first-level-code-alist nil (byte-code "
X@ X6 \"
\\I\\IB)BS )
S *" [result nil ku ten str 79 48 126 33 make-string 2 0 128 1] 7))

(defun make-jis-second-level-code-alist nil (byte-code "
X@ X6 \"
\\I\\IB)BS )
S *" [result nil ku ten str 116 80 126 33 make-string 2 0 128 1] 7))

(defvar egg:*first-level-alist* (make-jis-first-level-code-alist))

(defvar egg:*second-level-alist* (make-jis-second-level-code-alist))

(defvar *symbol-input-menu* (list (quote menu) ":" (list (cons "JIS" (quote (jis-code-input))) (cons "" (list (quote menu) ":" egg:*symbol-alist*)) (cons "ѿ" (list (quote menu) "ѿ:" egg:*alphanumeric-alist*)) (cons "Ҥ餬" (list (quote menu) "Ҥ餬:" egg:*hiragana-alist*)) (cons "" (list (quote menu) ":" egg:*katakana-alist*)) (cons "ꥷʸ" (list (quote menu) "ꥷʸ:" egg:*greek-alist*)) (cons "ʸ" (list (quote menu) "ʸ:" egg:*russian-alist*)) (cons "" (list (quote menu) ":" egg:*keisen-alist*)) (cons "" (list (quote menu) ":" egg:*first-level-alist*)) (cons "" (list (quote menu) ":" egg:*second-level-alist*)))))

(defun special-symbol-input nil (interactive) (byte-code "	!; c : !)" [code *symbol-input-menu* nil menu:select-from-menu eval] 3))

(define-key global-map "" (quote special-symbol-input))
