From e49d87454290194b304f768f0ff734460b492e96 Mon Sep 17 00:00:00 2001
From: naruse <naruse@b2dd03c8-39d4-4d8f-98ff-823fe69b080e>
Date: Mon, 27 Mar 2006 13:48:21 +0000
Subject: * ext/nkf/nkf-utf8/{nkf.c, utf8tbl.c}: imported nkf 2.0.6.   * Add
 --ic / --oc option and mapping tables.   * Add fallback option.   * Add
 --no-best-fit-chars option.   * Fix some bugs.

* ext/nkf/nkf.c (nkf_split_options): added for parse option string.

* ext/nkf/lib/kconv.rb (Kconv.to*): add -m0.
  Note that Kconv.to* still imply -X.

* ext/nkf/test.rb: Removed.  Obsolete by test/nkf.

* ext/.document: enabled documents in nkf and kconv

* ext/nkf/nkf.c, ext/nkf/lib/kconv.rb: Add rdoc.


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@10057 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
---
 ext/nkf/lib/kconv.rb       |  402 ++++++++------
 ext/nkf/nkf-utf8/nkf.c     | 1286 +++++++++++++++++++++++++++++++++++---------
 ext/nkf/nkf-utf8/utf8tbl.c |  984 +++++++++++++++++++--------------
 ext/nkf/nkf.c              |  430 +++++++++++++--
 ext/nkf/test.rb            |  864 -----------------------------
 5 files changed, 2236 insertions(+), 1730 deletions(-)
 delete mode 100644 ext/nkf/test.rb

(limited to 'ext/nkf')

diff --git a/ext/nkf/lib/kconv.rb b/ext/nkf/lib/kconv.rb
index 44a28c86e6..deaa4a02f6 100644
--- a/ext/nkf/lib/kconv.rb
+++ b/ext/nkf/lib/kconv.rb
@@ -12,35 +12,54 @@ module Kconv
   #
   
   #Constant of Encoding
-  AUTO = ::NKF::AUTO
-  JIS = ::NKF::JIS
-  EUC = ::NKF::EUC
-  SJIS = ::NKF::SJIS
-  BINARY = ::NKF::BINARY
-  NOCONV = ::NKF::NOCONV
-  ASCII = ::NKF::ASCII
-  UTF8 = ::NKF::UTF8
-  UTF16 = ::NKF::UTF16
-  UTF32 = ::NKF::UTF32
-  UNKNOWN = ::NKF::UNKNOWN
+  
+  # Auto-Detect
+  AUTO = NKF::AUTO
+  # ISO-2022-JP
+  JIS = NKF::JIS
+  # EUC-JP
+  EUC = NKF::EUC
+  # Shift_JIS
+  SJIS = NKF::SJIS
+  # BINARY
+  BINARY = NKF::BINARY
+  # NOCONV
+  NOCONV = NKF::NOCONV
+  # ASCII
+  ASCII = NKF::ASCII
+  # UTF-8
+  UTF8 = NKF::UTF8
+  # UTF-16
+  UTF16 = NKF::UTF16
+  # UTF-32
+  UTF32 = NKF::UTF32
+  # UNKNOWN
+  UNKNOWN = NKF::UNKNOWN
   
   #
   # Private Constants
   #
   
+  # Revision of kconv.rb
   REVISION = %q$Revision$
   
   #Regexp of Encoding
+  
+  # Regexp of Shift_JIS string (private constant)
   RegexpShiftjis = /\A(?:
 		       [\x00-\x7f\xa1-\xdf] |
 		       [\x81-\x9f\xe0-\xfc][\x40-\x7e\x80-\xfc] 
 		      )*\z/nx
+
+  # Regexp of EUC-JP string (private constant)
   RegexpEucjp = /\A(?:
 		    [\x00-\x7f]                         |
 		    \x8e        [\xa1-\xdf]             |
 		    \x8f        [\xa1-\xdf] [\xa1-\xfe] |
 		    [\xa1-\xdf] [\xa1-\xfe]
 		   )*\z/nx
+
+  # Regexp of UTF-8 string (private constant)
   RegexpUtf8  = /\A(?:
 		    [\x00-\x7f]                                     |
 		    [\xc2-\xdf] [\x80-\xbf]                         |
@@ -50,227 +69,280 @@ module Kconv
 		    [\xf1-\xf3] [\x80-\xbf] [\x80-\xbf] [\x80-\xbf] |
 		    \xf4        [\x80-\x8f] [\x80-\xbf] [\x80-\xbf]
 		   )*\z/nx
-  
-  # SYMBOL_TO_OPTION is the table for Kconv#conv
-  # Kconv#conv is intended to generic convertion method,
-  # so this table specifies symbols which can be supported not only nkf...
-  SYMBOL_TO_OPTION = {
-    :iso2022jp	=> '-j',
-    :jis	=> '-j',
-    :eucjp	=> '-e',
-    :euc	=> '-e',
-    :eucjpms	=> '-e --cp932',
-    :shiftjis	=> '-s',
-    :sjis	=> '-s',
-    :cp932	=> '-s --cp932',
-    :windows31j	=> '-s --cp932',
-    :utf8	=> '-w',
-    :utf8bom	=> '-w8',
-    :utf8n	=> '-w80',
-    :utf8mac	=> '-w --utf8mac-input',
-    :utf16	=> '-w16',
-    :utf16be	=> '-w16B',
-    :utf16ben	=> '-w16B0',
-    :utf16le	=> '-w16L',
-    :utf16len	=> '-w16L0',
-    :lf		=> '-Lu',	# LF
-    :cr		=> '-Lm',	# CR
-    :crlf	=> '-Lw',	# CRLF
-  }
-  
-  CONSTANT_TO_SYMBOL = {
-    JIS		=> :iso2022jp,
-    EUC		=> :eucjp,
-    SJIS	=> :shiftjis,
-    BINARY	=> :binary,
-    NOCONV	=> :noconv,
-    ASCII	=> :ascii,
-    UTF8	=> :utf8,
-    UTF16	=> :utf16,
-    UTF32	=> :utf32,
-    UNKNOWN	=> :unknown
-  }
-  
+
   #
   # Public Methods
   #
   
+  # call-seq:
+  #    Kconv.kconv(str, out_code, in_code = Kconv::AUTO)
+  #
+  # Convert <code>str</code> to out_code.
+  # <code>out_code</code> and <code>in_code</code> are given as constants of Kconv.
   #
-  # Kconv.conv( str, :to => :"euc-jp", :from => :shift_jis, :opt => [:hiragana, :katakana] )
-  #
-  def conv(str, *args)
-    option = nil
-    if args[0].is_a? Hash
-      option = [
-	args[0][:to]||args[0]['to'],
-	args[0][:from]||args[0]['from'],
-	args[0][:opt]||args[0]['opt'] ]
-    elsif args[0].is_a? String or args[0].is_a? Symbol or args[0].is_a? Integer
-      option = args
-    else
+  # *Note*
+  # This method decode MIME encoded string and
+  # convert halfwidth katakana to fullwidth katakana.
+  # If you don't want to decode them, use NKF.nkf.
+  def kconv(str, out_code, in_code = AUTO)
+    opt = '-'
+    case in_code
+    when ::NKF::JIS
+      opt << 'J'
+    when ::NKF::EUC
+      opt << 'E'
+    when ::NKF::SJIS
+      opt << 'S'
+    when ::NKF::UTF8
+      opt << 'W'
+    when ::NKF::UTF16
+      opt << 'W16'
+    end
+
+    case out_code
+    when ::NKF::JIS
+      opt << 'j'
+    when ::NKF::EUC
+      opt << 'e'
+    when ::NKF::SJIS
+      opt << 's'
+    when ::NKF::UTF8
+      opt << 'w'
+    when ::NKF::UTF16
+      opt << 'w16'
+    when ::NKF::NOCONV
       return str
     end
-    
-    to = symbol_to_option(option[0])
-    from = symbol_to_option(option[1]).to_s.sub(/(-[jesw])/o){$1.upcase}
-    opt = option[2..-1] and opt = opt.flatten.map{|x|symbol_to_option(x)}.compact.join(' ')
-    
-    nkf_opt = '-x -m0 %s %s %s' % [to, from, opt]
-    result = ::NKF::nkf( nkf_opt, str)
+
+    opt = '' if opt == '-'
+
+    ::NKF::nkf(opt, str)
   end
-  alias :kconv :conv
+  module_function :kconv
 
   #
   # Encode to
   #
 
+  # call-seq:
+  #    Kconv.tojis(str)   -> string
+  #
+  # Convert <code>str</code> to ISO-2022-JP
+  #
+  # *Note*
+  # This method convert halfwidth katakana to fullwidth katakana.
+  # If you don't want it, use NKF.nkf('-jxm0', str).
   def tojis(str)
-    ::NKF::nkf('-j', str)
+    ::NKF::nkf('-jm0', str)
   end
+  module_function :tojis
 
+  # call-seq:
+  #    Kconv.toeuc(str)   -> string
+  #
+  # Convert <code>str</code> to EUC-JP
+  #
+  # *Note*
+  # This method convert halfwidth katakana to fullwidth katakana.
+  # If you don't want it, use NKF.nkf('-exm0', str).
   def toeuc(str)
-    ::NKF::nkf('-e', str)
+    ::NKF::nkf('-em0', str)
   end
+  module_function :toeuc
 
+  # call-seq:
+  #    Kconv.tosjis(str)   -> string
+  #
+  # Convert <code>str</code> to Shift_JIS
+  #
+  # *Note*
+  # This method convert halfwidth katakana to fullwidth katakana.
+  # If you don't want it, use NKF.nkf('-sxm0', str).
   def tosjis(str)
-    ::NKF::nkf('-s', str)
+    ::NKF::nkf('-sm0', str)
   end
+  module_function :tosjis
 
+  # call-seq:
+  #    Kconv.toutf8(str)   -> string
+  #
+  # Convert <code>str</code> to UTF-8
+  #
+  # *Note*
+  # This method convert halfwidth katakana to fullwidth katakana.
+  # If you don't want it, use NKF.nkf('-wxm0', str).
   def toutf8(str)
-    ::NKF::nkf('-w', str)
+    ::NKF::nkf('-wm0', str)
   end
+  module_function :toutf8
 
+  # call-seq:
+  #    Kconv.toutf16(str)   -> string
+  #
+  # Convert <code>str</code> to UTF-16
+  #
+  # *Note*
+  # This method convert halfwidth katakana to fullwidth katakana.
+  # If you don't want it, use NKF.nkf('-w16xm0', str).
   def toutf16(str)
-    ::NKF::nkf('-w16', str)
+    ::NKF::nkf('-w16m0', str)
   end
-
-  alias :to_jis :tojis
-  alias :to_euc :toeuc
-  alias :to_eucjp :toeuc
-  alias :to_sjis :tosjis
-  alias :to_shiftjis :tosjis
-  alias :to_iso2022jp :tojis
-  alias :to_utf8 :toutf8
-  alias :to_utf16 :toutf16
+  module_function :toutf16
 
   #
   # guess
   #
 
+  # call-seq:
+  #    Kconv.guess(str)   -> integer
+  #
+  # Guess input encoding by NKF.guess2
   def guess(str)
     ::NKF::guess(str)
   end
+  module_function :guess
 
+  # call-seq:
+  #    Kconv.guess_old(str)   -> integer
+  #
+  # Guess input encoding by NKF.guess1
   def guess_old(str)
     ::NKF::guess1(str)
   end
-
-  def guess_as_symbol(str)
-    CONSTANT_TO_SYMBOL[guess(str)]
-  end
+  module_function :guess_old
 
   #
   # isEncoding
   #
 
+  # call-seq:
+  #    Kconv.iseuc(str)   -> obj or nil
+  #
+  # Returns whether input encoding is EUC-JP or not.
+  #
+  # *Note* don't expect this return value is MatchData.
   def iseuc(str)
     RegexpEucjp.match( str )
   end
-  
+  module_function :iseuc
+
+  # call-seq:
+  #    Kconv.issjis(str)   -> obj or nil
+  #
+  # Returns whether input encoding is Shift_JIS or not.
+  #
+  # *Note* don't expect this return value is MatchData.
   def issjis(str)
     RegexpShiftjis.match( str )
   end
+  module_function :issjis
 
+  # call-seq:
+  #    Kconv.isutf8(str)   -> obj or nil
+  #
+  # Returns whether input encoding is UTF-8 or not.
+  #
+  # *Note* don't expect this return value is MatchData.
   def isutf8(str)
     RegexpUtf8.match( str )
   end
+  module_function :isutf8
 
+end
+
+class String
+  # call-seq:
+  #    String#kconv(out_code, in_code = Kconv::AUTO)
   #
-  # encoding?
+  # Convert <code>self</code> to out_code.
+  # <code>out_code</code> and <code>in_code</code> are given as constants of Kconv.
   #
-
-  def eucjp?(str)
-    RegexpEucjp.match( str ) ? true : false
+  # *Note*
+  # This method convert halfwidth katakana to fullwidth katakana.
+  # If you don't want to decode them, use NKF.nkf.
+  def kconv(out_code, in_code=Kconv::AUTO)
+    Kconv::kconv(self, out_code, in_code)
   end
+  
+  #
+  # to Encoding
+  #
+  
+  # call-seq:
+  #    String#tojis   -> string
+  #
+  # Convert <code>self</code> to ISO-2022-JP
+  #
+  # *Note*
+  # This method convert halfwidth katakana to fullwidth katakana.
+  # If you don't want it, use NKF.nkf('-jxm0', str).
+  def tojis; Kconv.tojis(self) end
 
-  def shiftjis?(str)
-    RegexpShiftjis.match( str ) ? true : false
-  end
+  # call-seq:
+  #    String#toeuc   -> string
+  #
+  # Convert <code>self</code> to EUC-JP
+  #
+  # *Note*
+  # This method convert halfwidth katakana to fullwidth katakana.
+  # If you don't want it, use NKF.nkf('-exm0', str).
+  def toeuc; Kconv.toeuc(self) end
 
-  def utf8?(str)
-    RegexpUtf8.match( str ) ? true : false
-  end
+  # call-seq:
+  #    String#tosjis   -> string
+  #
+  # Convert <code>self</code> to Shift_JIS
+  #
+  # *Note*
+  # This method convert halfwidth katakana to fullwidth katakana.
+  # If you don't want it, use NKF.nkf('-sxm0', str).
+  def tosjis; Kconv.tosjis(self) end
 
-  alias :euc? :eucjp?
-  alias :sjis? :shiftjis?
+  # call-seq:
+  #    String#toutf8   -> string
+  #
+  # Convert <code>self</code> to UTF-8
+  #
+  # *Note*
+  # This method convert halfwidth katakana to fullwidth katakana.
+  # If you don't want it, use NKF.nkf('-wxm0', str).
+  def toutf8; Kconv.toutf8(self) end
 
+  # call-seq:
+  #    String#toutf16   -> string
   #
-  # Private Methods
+  # Convert <code>self</code> to UTF-16
   #
-  def symbol_to_option(symbol)
-    if symbol.is_a? Integer
-      symbol = CONSTANT_TO_SYMBOL[symbol]
-    elsif symbol.to_s[0] == ?-
-      return symbol.to_s
-    end
-    begin
-      SYMBOL_TO_OPTION[ symbol.to_s.downcase.delete('-_').to_sym ]
-    rescue
-      return nil
-    end
-  end
+  # *Note*
+  # This method convert halfwidth katakana to fullwidth katakana.
+  # If you don't want it, use NKF.nkf('-w16xm0', str).
+  def toutf16; Kconv.toutf16(self) end
 
   #
-  # Make them module functions
+  # is Encoding
   #
-  module_function(*instance_methods(false))
-  private_class_method :symbol_to_option
 
-end
+  # call-seq:
+  #    String#iseuc   -> obj or nil
+  #
+  # Returns whether <code>self</code>'s encoding is EUC-JP or not.
+  #
+  # *Note* don't expect this return value is MatchData.
+  def iseuc;	Kconv.iseuc(self) end
 
-class String
-  def kconv(*args)
-    Kconv::kconv(self, *args)
-  end
-  
-  def conv(*args)
-    Kconv::conv(self, *args)
-  end
-  
-  # to Encoding
-  def tojis
-    ::NKF::nkf('-j', self)
-  end
-  def toeuc
-    ::NKF::nkf('-e', self)
-  end
-  def tosjis
-    ::NKF::nkf('-s', self)
-  end
-  def toutf8
-    ::NKF::nkf('-w', self)
-  end
-  def toutf16
-    ::NKF::nkf('-w16', self)
-  end
-  alias :to_jis :tojis
-  alias :to_euc :toeuc
-  alias :to_eucjp :toeuc
-  alias :to_sjis :tosjis
-  alias :to_shiftjis :tosjis
-  alias :to_iso2022jp :tojis
-  alias :to_utf8 :toutf8
-  alias :to_utf16 :toutf16
-  
-  # is Encoding
-  def iseuc;	Kconv.iseuc( self ) end
-  def issjis;	Kconv.issjis( self ) end
-  def isutf8;	Kconv.isutf8( self ) end
-  def eucjp?;	Kconv.eucjp?( self ) end
-  def shiftjis?;Kconv.shiftjis?( self ) end
-  def utf8?;	Kconv.utf8?( self ) end
-  alias :euc? :eucjp?
-  alias :sjis? :shiftjis?
-  
-  def guess_as_symbol;	Kconv.guess_as_symbol( self ) end
+  # call-seq:
+  #    String#issjis   -> obj or nil
+  #
+  # Returns whether <code>self</code>'s encoding is Shift_JIS or not.
+  #
+  # *Note* don't expect this return value is MatchData.
+  def issjis;	Kconv.issjis(self) end
+
+  # call-seq:
+  #    String#isutf8   -> obj or nil
+  #
+  # Returns whether <code>self</code>'s encoding is UTF-8 or not.
+  #
+  # *Note* don't expect this return value is MatchData.
+  def isutf8;	Kconv.isutf8(self) end
 end
diff --git a/ext/nkf/nkf-utf8/nkf.c b/ext/nkf/nkf-utf8/nkf.c
index 34fceba1e4..a9498dc151 100644
--- a/ext/nkf/nkf-utf8/nkf.c
+++ b/ext/nkf/nkf-utf8/nkf.c
@@ -40,12 +40,13 @@
 **    $B$^$G8fO"Mm$r$*4j$$$7$^$9!#(B
 ***********************************************************************/
 /* $Id$ */
-#define NKF_VERSION "2.0.5"
-#define NKF_RELEASE_DATE "2005-07-22"
+#define NKF_VERSION "2.0.6"
+#define NKF_RELEASE_DATE "2006-03-26"
 #include "config.h"
 
 #define COPY_RIGHT \
-    "Copyright (C) 1987, FUJITSU LTD. (I.Ichikawa),2000 S. Kono, COW, 2002-2005 Kono, Furukawa, Naruse"
+    "Copyright (C) 1987, FUJITSU LTD. (I.Ichikawa),2000 S. Kono, COW\n" \
+    "                     2002-2006 Kono, Furukawa, Naruse, mastodon"
 
 
 /*
@@ -190,7 +191,9 @@
 #define         X0201           2
 #define         ISO8859_1       8
 #define         NO_X0201        3
-#define         X0212           16
+#define         X0212      0x2844
+#define         X0213_1    0x284F
+#define         X0213_2    0x2850
 
 /* Input Assumption */
 
@@ -232,6 +235,17 @@
 #define		is_alnum(c)  \
             (('a'<=c && c<='z')||('A'<= c && c<='Z')||('0'<=c && c<='9'))
 
+/* I don't trust portablity of toupper */
+#define nkf_toupper(c)  (('a'<=c && c<='z')?(c-('a'-'A')):c)
+#define nkf_isoctal(c)  ('0'<=c && c<='7')
+#define nkf_isdigit(c)  ('0'<=c && c<='9')
+#define nkf_isxdigit(c)  (nkf_isdigit(c) || ('a'<=c && c<='f') || ('A'<=c && c <= 'F'))
+#define nkf_isblank(c) (c == SPACE || c == TAB)
+#define nkf_isspace(c) (nkf_isblank(c) || c == CR || c == NL)
+#define nkf_isalpha(c) (('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z'))
+#define nkf_isalnum(c) (nkf_isdigit(c) || nkf_isalpha(c))
+#define hex2bin(x)     ( nkf_isdigit(x) ? x - '0' : nkf_toupper(x) - 'A' + 10)
+
 #define         HOLD_SIZE       1024
 #define         IOBUF_SIZE      16384
 
@@ -247,13 +261,12 @@
 
 
 #if defined(UTF8_OUTPUT_ENABLE) || defined(UTF8_INPUT_ENABLE)
-#define sizeof_euc_utf8 94
 #define sizeof_euc_to_utf8_1byte 94
 #define sizeof_euc_to_utf8_2bytes 94
 #define sizeof_utf8_to_euc_C2 64
 #define sizeof_utf8_to_euc_E5B8 64
 #define sizeof_utf8_to_euc_2bytes 112
-#define sizeof_utf8_to_euc_3bytes 112
+#define sizeof_utf8_to_euc_3bytes 16
 #endif
 
 /* MIME preprocessor */
@@ -300,14 +313,41 @@ STATIC  void    set_iconv PROTO((int f, int (*iconv_func)(int c2,int c1,int c0))
 STATIC  int     s_iconv PROTO((int c2,int c1,int c0));
 STATIC  int     s2e_conv PROTO((int c2, int c1, int *p2, int *p1));
 STATIC  int     e_iconv PROTO((int c2,int c1,int c0));
+#if defined(UTF8_INPUT_ENABLE) || defined(UTF8_OUTPUT_ENABLE)
+/* UCS Mapping
+ * 0: Shift_JIS, eucJP-ascii
+ * 1: eucJP-ms
+ * 2: CP932, CP51932
+ */
+#define UCS_MAP_ASCII 0
+#define UCS_MAP_MS    1
+#define UCS_MAP_CP932 2
+STATIC int ms_ucs_map_f = UCS_MAP_ASCII;
+#endif
 #ifdef UTF8_INPUT_ENABLE
+/* no NEC special, NEC-selected IBM extended and IBM extended characters */
+STATIC  int     no_cp932ext_f = FALSE;
+/* ignore ZERO WIDTH NO-BREAK SPACE */
+STATIC  int     ignore_zwnbsp_f = TRUE;
+STATIC  int     no_best_fit_chars_f = FALSE;
+STATIC  int     unicode_subchar = '?'; /* the regular substitution character */
+STATIC  void    encode_fallback_html PROTO((int c));
+STATIC  void    encode_fallback_xml PROTO((int c));
+STATIC  void    encode_fallback_java PROTO((int c));
+STATIC  void    encode_fallback_perl PROTO((int c));
+STATIC  void    encode_fallback_subchar PROTO((int c));
+STATIC  void    (*encode_fallback)PROTO((int c)) = NULL;
 STATIC  int     w2e_conv PROTO((int c2,int c1,int c0,int *p2,int *p1));
 STATIC  int     w_iconv PROTO((int c2,int c1,int c0));
 STATIC  int     w_iconv16 PROTO((int c2,int c1,int c0));
+STATIC  int	unicode_to_jis_common PROTO((int c2,int c1,int c0,int *p2,int *p1));
 STATIC  int	w_iconv_common PROTO((int c1,int c0,const unsigned short *const *pp,int psize,int *p2,int *p1));
 STATIC  int     ww16_conv PROTO((int c2, int c1, int c0));
+STATIC  int     w16e_conv PROTO((unsigned short val,int *p2,int *p1));
 #endif
 #ifdef UTF8_OUTPUT_ENABLE
+STATIC  int     unicode_bom_f= 0;   /* Output Unicode BOM */
+STATIC  int     w_oconv16_LE = 0;   /* utf-16 little endian */
 STATIC  int     e2w_conv PROTO((int c2,int c1));
 STATIC  void    w_oconv PROTO((int c2,int c1));
 STATIC  void    w_oconv16 PROTO((int c2,int c1));
@@ -400,14 +440,6 @@ STATIC int             x0201_f = TRUE;         /* Assume JISX0201 kana */
 STATIC int             x0201_f = NO_X0201;     /* Assume NO JISX0201 */
 #endif
 STATIC int             iso2022jp_f = FALSE;    /* convert ISO-2022-JP */
-#if defined(UTF8_OUTPUT_ENABLE) && defined(UTF8_INPUT_ENABLE)
-STATIC int             internal_unicode_f = FALSE;   /* Internal Unicode Processing */
-#endif
-#ifdef UTF8_OUTPUT_ENABLE
-STATIC int             unicode_bom_f= 0;   /* Output Unicode BOM */
-STATIC int             w_oconv16_LE = 0;   /* utf-16 little endian */
-STATIC int             ms_ucs_map_f = FALSE;   /* Microsoft UCS Mapping Compatible */
-#endif
 
 #ifdef UNICODE_NORMALIZATION
 STATIC int nfc_f = FALSE;
@@ -462,10 +494,12 @@ STATIC int exec_f = 0;
 #endif
 
 #ifdef SHIFTJIS_CP932
-STATIC int cp932_f = TRUE;
+/* invert IBM extended characters to others */
+STATIC int cp51932_f = TRUE;
 #define CP932_TABLE_BEGIN (0xfa)
 #define CP932_TABLE_END   (0xfc)
 
+/* invert NEC-selected IBM extended characters to IBM extended characters */
 STATIC int cp932inv_f = TRUE;
 #define CP932INV_TABLE_BEGIN (0xed)
 #define CP932INV_TABLE_END   (0xee)
@@ -478,6 +512,7 @@ STATIC int x0212_f = FALSE;
 STATIC int x0212_shift PROTO((int c));
 STATIC int x0212_unshift PROTO((int c));
 #endif
+STATIC int x0213_f = FALSE;
 
 STATIC unsigned char prefix_table[256];
 
@@ -670,9 +705,13 @@ unsigned char fv[] = {
 
 #define    CRLF      1
 
-STATIC int             file_out = FALSE;
+STATIC int             file_out_f = FALSE;
 #ifdef OVERWRITE
-STATIC int             overwrite = FALSE;
+STATIC int             overwrite_f = FALSE;
+STATIC int             preserve_time_f = FALSE;
+STATIC int             backup_f = FALSE;
+STATIC char            *backup_suffix = "";
+STATIC char *get_backup_filename PROTO((const char *suffix, const char *filename));
 #endif
 
 STATIC int             crmode_f = 0;   /* CR, NL, CRLF */
@@ -783,9 +822,9 @@ main(argc, argv)
 #endif
 
 /* reopen file for stdout */
-              if (file_out == TRUE) {
+              if (file_out_f == TRUE) {
 #ifdef OVERWRITE
-                  if (overwrite){
+                  if (overwrite_f){
                       outfname = malloc(strlen(origfname)
                                         + strlen(".nkftmpXXXXXX")
                                         + 1);
@@ -807,7 +846,7 @@ main(argc, argv)
                       }
                       strcat(outfname, "ntXXXXXX");
                       mktemp(outfname);
-                      fd = open(outfname, O_WRONLY | O_CREAT | O_TRUNC,
+			fd = open(outfname, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL,
                                 S_IREAD | S_IWRITE);
 #else
                       strcat(outfname, ".nkftmpXXXXXX");
@@ -860,7 +899,7 @@ main(argc, argv)
               }
               fclose(fin);
 #ifdef OVERWRITE
-              if (overwrite) {
+              if (overwrite_f) {
                   struct stat     sb;
 #if defined(MSDOS) && !defined(__MINGW32__) && !defined(__WIN32__)
                   time_t tb[2];
@@ -882,23 +921,37 @@ main(argc, argv)
                   }
 
                   /* $B%?%$%`%9%?%s%W$rI|85(B */
+		    if(preserve_time_f){
 #if defined(MSDOS) && !defined(__MINGW32__) && !defined(__WIN32__)
-                  tb[0] = tb[1] = sb.st_mtime;
-                  if (utime(outfname, tb)) {
-                      fprintf(stderr, "Can't set timestamp %s\n", outfname);
-                  }
+			tb[0] = tb[1] = sb.st_mtime;
+			if (utime(outfname, tb)) {
+			    fprintf(stderr, "Can't set timestamp %s\n", outfname);
+			}
 #else
-                  tb.actime  = sb.st_atime;
-                  tb.modtime = sb.st_mtime;
-                  if (utime(outfname, &tb)) {
-                      fprintf(stderr, "Can't set timestamp %s\n", outfname);
-                  }
+			tb.actime  = sb.st_atime;
+			tb.modtime = sb.st_mtime;
+			if (utime(outfname, &tb)) {
+			    fprintf(stderr, "Can't set timestamp %s\n", outfname);
+			}
+#endif
+		    }
+		    if(backup_f){
+			char *backup_filename = get_backup_filename(backup_suffix, origfname);
+#ifdef MSDOS
+			unlink(backup_filename);
 #endif
+			if (rename(origfname, backup_filename)) {
+			    perror(backup_filename);
+			    fprintf(stderr, "Can't rename %s to %s\n",
+				    origfname, backup_filename);
+			}
+		    }else{
 #ifdef MSDOS
-                  if (unlink(origfname)){
-                      perror(origfname);
-                  }
+			if (unlink(origfname)){
+			    perror(origfname);
+			}
 #endif
+		    }
                   if (rename(outfname, origfname)) {
                       perror(origfname);
                       fprintf(stderr, "Can't rename %s to %s\n",
@@ -911,23 +964,68 @@ main(argc, argv)
       }
     }
 #ifdef EASYWIN /*Easy Win */
-    if (file_out == FALSE) 
+    if (file_out_f == FALSE) 
         scanf("%d",&end_check);
     else 
         fclose(stdout);
 #else /* for Other OS */
-    if (file_out == TRUE) 
+    if (file_out_f == TRUE) 
         fclose(stdout);
 #endif /*Easy Win */
     return (0);
 }
 #endif /* WIN32DLL */
 
+#ifdef OVERWRITE
+char *get_backup_filename(suffix, filename)
+    const char *suffix;
+    const char *filename;
+{
+    char *backup_filename = NULL;
+    int asterisk_count = 0;
+    int i, j;
+    int filename_length = strlen(filename);
+
+    for(i = 0; suffix[i]; i++){
+	if(suffix[i] == '*') asterisk_count++;
+    }
+
+    if(asterisk_count){
+	backup_filename = malloc(strlen(suffix) + (asterisk_count * (filename_length - 1)) + 1);
+	if (!backup_filename){
+	    perror("Can't malloc backup filename.");
+	    return NULL;
+	}
+
+	for(i = 0, j = 0; suffix[i];){
+	    if(suffix[i] == '*'){
+		backup_filename[j] = '\0';
+		strncat(backup_filename, filename, filename_length);
+		i++;
+		j += filename_length;
+	    }else{
+		backup_filename[j++] = suffix[i++];
+	    }
+	}
+	backup_filename[j] = '\0';
+    }else{
+	j = strlen(suffix) + filename_length;
+	backup_filename = malloc( + 1);
+	strcpy(backup_filename, filename);
+	strcat(backup_filename, suffix);
+	backup_filename[j] = '\0';
+    }
+    return backup_filename;
+}
+#endif
+
 STATIC const
 struct {
     const char *name;
     const char *alias;
 } long_option[] = {
+    {"ic=", ""},
+    {"oc=", ""},
     {"base64","jMB"},
     {"euc","e"},
     {"euc-input","E"},
@@ -953,23 +1051,32 @@ struct {
 #ifdef X0212_ENABLE
     {"x0212", ""},
 #endif
-#if defined(UTF8_OUTPUT_ENABLE) && defined(UTF8_INPUT_ENABLE)
-    {"internal-unicode", ""},
-#endif
 #ifdef UTF8_OUTPUT_ENABLE
     {"utf8", "w"},
     {"utf16", "w16"},
     {"ms-ucs-map", ""},
+    {"fb-skip", ""},
+    {"fb-html", ""},
+    {"fb-xml", ""},
+    {"fb-perl", ""},
+    {"fb-java", ""},
+    {"fb-subchar", ""},
+    {"fb-subchar=", ""},
 #endif
 #ifdef UTF8_INPUT_ENABLE
     {"utf8-input", "W"},
     {"utf16-input", "W16"},
+    {"no-cp932ext", ""},
+    {"no-best-fit-chars",""},
 #endif
 #ifdef UNICODE_NORMALIZATION
     {"utf8mac-input", ""},
 #endif
 #ifdef OVERWRITE
     {"overwrite", ""},
+    {"overwrite=", ""},
+    {"in-place", ""},
+    {"in-place=", ""},
 #endif
 #ifdef INPUT_OPTION
     {"cap-input", ""},
@@ -998,40 +1105,328 @@ void
 options(cp) 
      unsigned char *cp;
 {
-    int i;
+    int i, j;
     unsigned char *p = NULL;
+    unsigned char *cp_back = NULL;
+    unsigned char codeset[32];
 
     if (option_mode==1)
 	return;
     while(*cp && *cp++!='-');
-    while (*cp) {
+    while (*cp || cp_back) {
+	if(!*cp){
+	    cp = cp_back;
+	    cp_back = NULL;
+	    continue;
+	}
 	p = 0;
         switch (*cp++) {
         case '-':  /* literal options */
-	    if (!*cp) {        /* ignore the rest of arguments */
+	    if (!*cp || *cp == SPACE) {        /* ignore the rest of arguments */
 		option_mode = 1;
 		return;
 	    }
             for (i=0;i<sizeof(long_option)/sizeof(long_option[0]);i++) {
-		int j;
                 p = (unsigned char *)long_option[i].name;
                 for (j=0;*p && *p != '=' && *p == cp[j];p++, j++);
 		if (*p == cp[j] || cp[j] == ' '){
-		    p = &cp[j];
+		    p = &cp[j] + 1;
 		    break;
 		}
 		p = 0;
             }
 	    if (p == 0) return;
-            cp = (unsigned char *)long_option[i].alias;
-            if (!*cp){
-	        cp = p;
+	    while(*cp && *cp != SPACE && cp++);
+            if (long_option[i].alias[0]){
+		cp_back = cp;
+		cp = (unsigned char *)long_option[i].alias;
+	    }else{
+                if (strcmp(long_option[i].name, "ic=") == 0){
+		    for (i=0; i < 16 && SPACE < p[i] && p[i] < DEL; i++){
+			codeset[i] = nkf_toupper(p[i]);
+		    }
+		    codeset[i] = 0;
+		    if(strcmp(codeset, "ISO-2022-JP") == 0 ||
+		      strcmp(codeset, "X-ISO2022JP-CP932") == 0 ||
+		      strcmp(codeset, "CP50220") == 0 ||
+		      strcmp(codeset, "CP50221") == 0 ||
+		      strcmp(codeset, "CP50222") == 0 ||
+		      strcmp(codeset, "ISO-2022-JP-MS") == 0){
+			input_f = JIS_INPUT;
+		    }else if(strcmp(codeset, "ISO-2022-JP-1") == 0){
+			input_f = JIS_INPUT;
+#ifdef X0212_ENABLE
+			x0212_f = TRUE;
+#endif
+		    }else if(strcmp(codeset, "ISO-2022-JP-3") == 0){
+			input_f = JIS_INPUT;
+#ifdef X0212_ENABLE
+			x0212_f = TRUE;
+#endif
+			x0213_f = TRUE;
+		    }else if(strcmp(codeset, "SHIFT_JIS") == 0){
+			input_f = SJIS_INPUT;
+			if (x0201_f==NO_X0201) x0201_f=TRUE;
+		    }else if(strcmp(codeset, "WINDOWS-31J") == 0 ||
+			     strcmp(codeset, "CSWINDOWS31J") == 0 ||
+			     strcmp(codeset, "CP932") == 0 ||
+			     strcmp(codeset, "MS932") == 0){
+			input_f = SJIS_INPUT;
+			x0201_f = FALSE;
+#ifdef SHIFTJIS_CP932
+			cp51932_f = TRUE;
+#endif
+#ifdef UTF8_OUTPUT_ENABLE
+			ms_ucs_map_f = UCS_MAP_CP932;
+#endif
+		    }else if(strcmp(codeset, "EUCJP") == 0 ||
+			     strcmp(codeset, "EUC-JP") == 0){
+			input_f = JIS_INPUT;
+		    }else if(strcmp(codeset, "CP51932") == 0){
+			input_f = JIS_INPUT;
+			x0201_f = FALSE;
+#ifdef SHIFTJIS_CP932
+			cp51932_f = TRUE;
+#endif
+#ifdef UTF8_OUTPUT_ENABLE
+			ms_ucs_map_f = UCS_MAP_CP932;
+#endif
+		    }else if(strcmp(codeset, "EUC-JP-MS") == 0 ||
+			     strcmp(codeset, "EUCJP-MS") == 0 ||
+			     strcmp(codeset, "EUCJPMS") == 0){
+			input_f = JIS_INPUT;
+			x0201_f = FALSE;
+#ifdef SHIFTJIS_CP932
+			cp51932_f = FALSE;
+#endif
+#ifdef UTF8_OUTPUT_ENABLE
+			ms_ucs_map_f = UCS_MAP_MS;
+#endif
+		    }else if(strcmp(codeset, "EUC-JP-ASCII") == 0 ||
+			     strcmp(codeset, "EUCJP-ASCII") == 0){
+			input_f = JIS_INPUT;
+			x0201_f = FALSE;
+#ifdef SHIFTJIS_CP932
+			cp51932_f = FALSE;
+#endif
+#ifdef UTF8_OUTPUT_ENABLE
+			ms_ucs_map_f = UCS_MAP_ASCII;
+#endif
+		    }else if(strcmp(codeset, "SHIFT_JISX0213") == 0 ||
+			     strcmp(codeset, "SHIFT_JIS-2004") == 0){
+			input_f = SJIS_INPUT;
+			x0213_f = TRUE;
+#ifdef SHIFTJIS_CP932
+			cp51932_f = FALSE;
+			cp932inv_f = FALSE;
+#endif
+			if (x0201_f==NO_X0201) x0201_f=TRUE;
+		    }else if(strcmp(codeset, "EUC-JISX0213") == 0 ||
+			     strcmp(codeset, "EUC-JIS-2004") == 0){
+			input_f = JIS_INPUT;
+			x0201_f = FALSE;
+			x0213_f = TRUE;
+#ifdef SHIFTJIS_CP932
+			cp51932_f = FALSE;
+			cp932inv_f = FALSE;
+#endif
+#ifdef UTF8_INPUT_ENABLE
+		    }else if(strcmp(codeset, "UTF-8") == 0 ||
+			     strcmp(codeset, "UTF-8N") == 0 ||
+			     strcmp(codeset, "UTF-8-BOM") == 0){
+			input_f = UTF8_INPUT;
+#ifdef UNICODE_NORMALIZATION
+		    }else if(strcmp(codeset, "UTF8-MAC") == 0 ||
+			     strcmp(codeset, "UTF-8-MAC") == 0){
+			input_f = UTF8_INPUT;
+			nfc_f = TRUE;
+#endif
+		    }else if(strcmp(codeset, "UTF-16") == 0){
+			input_f = UTF16BE_INPUT;
+			utf16_mode = UTF16BE_INPUT;
+		    }else if(strcmp(codeset, "UTF-16BE") == 0 ||
+			     strcmp(codeset, "UTF-16BE-BOM") == 0){
+			input_f = UTF16BE_INPUT;
+			utf16_mode = UTF16BE_INPUT;
+		    }else if(strcmp(codeset, "UTF-16LE") == 0 ||
+			     strcmp(codeset, "UTF-16LE-BOM") == 0){
+			input_f = UTF16LE_INPUT;
+			utf16_mode = UTF16LE_INPUT;
+#endif
+		    }
+                    continue;
+		}
+                if (strcmp(long_option[i].name, "oc=") == 0){
+		    for (i=0; i < 16 && SPACE < p[i] && p[i] < DEL; i++){
+			codeset[i] = nkf_toupper(p[i]);
+		    }
+		    codeset[i] = 0;
+		    if(strcmp(codeset, "ISO-2022-JP") == 0 ||
+		       strcmp(codeset, "CP50220") == 0){
+			output_conv = j_oconv;
+		    }else if(strcmp(codeset, "X-ISO2022JP-CP932") == 0){
+			output_conv = j_oconv;
+			no_cp932ext_f = TRUE;
+		    }else if(strcmp(codeset, "CP50221") == 0 ||
+			     strcmp(codeset, "ISO-2022-JP-MS") == 0){
+			output_conv = j_oconv;
+			x0201_f = FALSE;
+		    }else if(strcmp(codeset, "ISO-2022-JP-1") == 0){
+			output_conv = j_oconv;
+#ifdef X0212_ENABLE
+			x0212_f = TRUE;
+#endif
+#ifdef SHIFTJIS_CP932
+			cp51932_f = FALSE;
+#endif
+		    }else if(strcmp(codeset, "ISO-2022-JP-3") == 0){
+			output_conv = j_oconv;
+#ifdef X0212_ENABLE
+			x0212_f = TRUE;
+#endif
+			x0213_f = TRUE;
+#ifdef SHIFTJIS_CP932
+			cp51932_f = FALSE;
+#endif
+		    }else if(strcmp(codeset, "ISO-2022-JP-MS") == 0){
+			output_conv = j_oconv;
+			x0201_f = FALSE;
+#ifdef X0212_ENABLE
+			x0212_f = TRUE;
+#endif
+#ifdef SHIFTJIS_CP932
+			cp51932_f = FALSE;
+#endif
+		    }else if(strcmp(codeset, "SHIFT_JIS") == 0){
+			output_conv = s_oconv;
+		    }else if(strcmp(codeset, "WINDOWS-31J") == 0 ||
+			     strcmp(codeset, "CSWINDOWS31J") == 0 ||
+			     strcmp(codeset, "CP932") == 0 ||
+			     strcmp(codeset, "MS932") == 0){
+			output_conv = s_oconv;
+			x0201_f = FALSE;
+#ifdef SHIFTJIS_CP932
+			cp51932_f = TRUE;
+			cp932inv_f = TRUE;
+#endif
+#ifdef UTF8_OUTPUT_ENABLE
+			ms_ucs_map_f = UCS_MAP_CP932;
+#endif
+		    }else if(strcmp(codeset, "EUCJP") == 0 ||
+			     strcmp(codeset, "EUC-JP") == 0){
+			output_conv = e_oconv;
+		    }else if(strcmp(codeset, "CP51932") == 0){
+			output_conv = e_oconv;
+			x0201_f = FALSE;
+#ifdef SHIFTJIS_CP932
+			cp51932_f = TRUE;
+#endif
+#ifdef UTF8_OUTPUT_ENABLE
+			ms_ucs_map_f = UCS_MAP_CP932;
+#endif
+		    }else if(strcmp(codeset, "EUC-JP-MS") == 0 ||
+			     strcmp(codeset, "EUCJP-MS") == 0 ||
+			     strcmp(codeset, "EUCJPMS") == 0){
+			output_conv = e_oconv;
+			x0201_f = FALSE;
+#ifdef X0212_ENABLE
+			x0212_f = TRUE;
+#endif
+#ifdef SHIFTJIS_CP932
+			cp51932_f = FALSE;
+#endif
+#ifdef UTF8_OUTPUT_ENABLE
+			ms_ucs_map_f = UCS_MAP_MS;
+#endif
+		    }else if(strcmp(codeset, "EUC-JP-ASCII") == 0 ||
+			     strcmp(codeset, "EUCJP-ASCII") == 0){
+			output_conv = e_oconv;
+			x0201_f = FALSE;
+#ifdef X0212_ENABLE
+			x0212_f = TRUE;
+#endif
+#ifdef SHIFTJIS_CP932
+			cp51932_f = FALSE;
+#endif
+#ifdef UTF8_OUTPUT_ENABLE
+			ms_ucs_map_f = UCS_MAP_ASCII;
+#endif
+		    }else if(strcmp(codeset, "SHIFT_JISX0213") == 0 ||
+			     strcmp(codeset, "SHIFT_JIS-2004") == 0){
+			output_conv = s_oconv;
+			x0213_f = TRUE;
+#ifdef SHIFTJIS_CP932
+			cp932inv_f = FALSE;
+#endif
+		    }else if(strcmp(codeset, "EUC-JISX0213") == 0 ||
+			     strcmp(codeset, "EUC-JIS-2004") == 0){
+			output_conv = e_oconv;
+#ifdef X0212_ENABLE
+			x0212_f = TRUE;
+#endif
+			x0213_f = TRUE;
+#ifdef SHIFTJIS_CP932
+			cp51932_f = FALSE;
+#endif
+#ifdef UTF8_OUTPUT_ENABLE
+		    }else if(strcmp(codeset, "UTF-8") == 0){
+			output_conv = w_oconv;
+		    }else if(strcmp(codeset, "UTF-8N") == 0){
+			output_conv = w_oconv;
+			unicode_bom_f=1;
+		    }else if(strcmp(codeset, "UTF-8-BOM") == 0){
+			output_conv = w_oconv;
+			unicode_bom_f=2;
+		    }else if(strcmp(codeset, "UTF-16BE") == 0){
+			output_conv = w_oconv16; 
+			unicode_bom_f=1;
+		    }else if(strcmp(codeset, "UTF-16") == 0 ||
+			     strcmp(codeset, "UTF-16BE-BOM") == 0){
+			output_conv = w_oconv16; 
+			unicode_bom_f=2;
+		    }else if(strcmp(codeset, "UTF-16LE") == 0){
+			output_conv = w_oconv16; 
+			w_oconv16_LE = 1;
+			unicode_bom_f=1;
+		    }else if(strcmp(codeset, "UTF-16LE-BOM") == 0){
+			output_conv = w_oconv16; 
+			w_oconv16_LE = 1;
+			unicode_bom_f=2;
+#endif
+		    }
+                    continue;
+		}
 #ifdef OVERWRITE
                 if (strcmp(long_option[i].name, "overwrite") == 0){
-                    file_out = TRUE;
-                    overwrite = TRUE;
+                    file_out_f = TRUE;
+                    overwrite_f = TRUE;
+		    preserve_time_f = TRUE;
                     continue;
                 }
+                if (strcmp(long_option[i].name, "overwrite=") == 0){
+                    file_out_f = TRUE;
+                    overwrite_f = TRUE;
+		    preserve_time_f = TRUE;
+		    backup_f = TRUE;
+		    backup_suffix = malloc(strlen(p) + 1);
+		    strcpy(backup_suffix, p);
+                    continue;
+                }
+                if (strcmp(long_option[i].name, "in-place") == 0){
+                    file_out_f = TRUE;
+                    overwrite_f = TRUE;
+		    preserve_time_f = FALSE;
+		    continue;
+                }
+                if (strcmp(long_option[i].name, "in-place=") == 0){
+                    file_out_f = TRUE;
+                    overwrite_f = TRUE;
+		    preserve_time_f = FALSE;
+		    backup_f = TRUE;
+		    backup_suffix = malloc(strlen(p) + 1);
+		    strcpy(backup_suffix, p);
+		    continue;
+                }
 #endif
 #ifdef INPUT_OPTION
                 if (strcmp(long_option[i].name, "cap-input") == 0){
@@ -1061,21 +1456,21 @@ options(cp)
 #endif
                 if (strcmp(long_option[i].name, "cp932") == 0){
 #ifdef SHIFTJIS_CP932
-                    cp932_f = TRUE;
+                    cp51932_f = TRUE;
                     cp932inv_f = TRUE;
 #endif
 #ifdef UTF8_OUTPUT_ENABLE
-                    ms_ucs_map_f = TRUE;
+                    ms_ucs_map_f = UCS_MAP_CP932;
 #endif
                     continue;
                 }
                 if (strcmp(long_option[i].name, "no-cp932") == 0){
 #ifdef SHIFTJIS_CP932
-                    cp932_f = FALSE;
+                    cp51932_f = FALSE;
                     cp932inv_f = FALSE;
 #endif
 #ifdef UTF8_OUTPUT_ENABLE
-                    ms_ucs_map_f = FALSE;
+                    ms_ucs_map_f = UCS_MAP_ASCII;
 #endif
                     continue;
                 }
@@ -1104,14 +1499,68 @@ options(cp)
                   }
 #endif
 #if defined(UTF8_OUTPUT_ENABLE) && defined(UTF8_INPUT_ENABLE)
-                if (strcmp(long_option[i].name, "internal-unicode") == 0){
-                    internal_unicode_f = TRUE;
+                if (strcmp(long_option[i].name, "no-cp932ext") == 0){
+		    no_cp932ext_f = TRUE;
+                    continue;
+                }
+		if (strcmp(long_option[i].name, "no-best-fit-chars") == 0){
+		    no_best_fit_chars_f = TRUE;
+		    continue;
+		}
+                if (strcmp(long_option[i].name, "fb-skip") == 0){
+		    encode_fallback = NULL;
+                    continue;
+                }
+                if (strcmp(long_option[i].name, "fb-html") == 0){
+		    encode_fallback = encode_fallback_html;
+                    continue;
+                }
+                if (strcmp(long_option[i].name, "fb-xml" ) == 0){
+		    encode_fallback = encode_fallback_xml;
+                    continue;
+                }
+                if (strcmp(long_option[i].name, "fb-java") == 0){
+		    encode_fallback = encode_fallback_java;
+                    continue;
+                }
+                if (strcmp(long_option[i].name, "fb-perl") == 0){
+		    encode_fallback = encode_fallback_perl;
+                    continue;
+                }
+                if (strcmp(long_option[i].name, "fb-subchar") == 0){
+		    encode_fallback = encode_fallback_subchar;
+                    continue;
+                }
+                if (strcmp(long_option[i].name, "fb-subchar=") == 0){
+		    encode_fallback = encode_fallback_subchar;
+		    unicode_subchar = 0;
+		    if (p[0] != '0'){
+			/* decimal number */
+			for (i = 0; i < 7 && nkf_isdigit(p[i]); i++){
+			    unicode_subchar *= 10;
+			    unicode_subchar += hex2bin(p[i]);
+			}
+		    }else if(p[1] == 'x' || p[1] == 'X'){
+			/* hexadecimal number */
+			for (i = 2; i < 8 && nkf_isxdigit(p[i]); i++){
+			    unicode_subchar <<= 4;
+			    unicode_subchar |= hex2bin(p[i]);
+			}
+		    }else{
+			/* octal number */
+			for (i = 1; i < 8 && nkf_isoctal(p[i]); i++){
+			    unicode_subchar *= 8;
+			    unicode_subchar += hex2bin(p[i]);
+			}
+		    }
+		    w16e_conv(unicode_subchar, &i, &j);
+		    unicode_subchar = i<<8 | j;
                     continue;
                 }
 #endif
 #ifdef UTF8_OUTPUT_ENABLE
                 if (strcmp(long_option[i].name, "ms-ucs-map") == 0){
-                    ms_ucs_map_f = TRUE;
+                    ms_ucs_map_f = UCS_MAP_MS;
                     continue;
                 }
 #endif
@@ -1123,9 +1572,9 @@ options(cp)
 		}
 #endif
                 if (strcmp(long_option[i].name, "prefix=") == 0){
-                    if (*p == '=' && ' ' < p[1] && p[1] < 128){
-                        for (i = 2; ' ' < p[i] && p[i] < 128; i++){
-                            prefix_table[p[i]] = p[1];
+                    if (' ' < p[0] && p[0] < 128){
+                        for (i = 1; ' ' < p[i] && p[i] < 128; i++){
+                            prefix_table[p[i]] = p[0];
                         }
                     }
                     continue;
@@ -1333,7 +1782,7 @@ options(cp)
             continue;
 #ifndef PERL_XS
         case 'O':/* for Output file */
-            file_out = TRUE;
+            file_out_f = TRUE;
             continue;
 #endif
         case 'c':/* add cr code */
@@ -1565,7 +2014,7 @@ void s_status(ptr, c)
               ptr->stat = 1;
               status_push_ch(ptr, c);
 #ifdef SHIFTJIS_CP932
-          }else if (cp932_f
+          }else if (cp51932_f
                     && CP932_TABLE_BEGIN <= c && c <= CP932_TABLE_END){
               ptr->stat = 2;
               status_push_ch(ptr, c);
@@ -1602,8 +2051,8 @@ void s_status(ptr, c)
 #endif /* SHIFTJIS_CP932 */
 #ifndef X0212_ENABLE
           status_disable(ptr);
-          break;
 #endif
+          break;
     }
 }
 
@@ -1947,6 +2396,14 @@ kanji_convert(f)
     module_connection();
     c2 = 0;
 
+    if(input_f == SJIS_INPUT
+#ifdef UTF8_INPUT_ENABLE
+       || input_f == UTF8_INPUT || input_f == UTF16BE_INPUT || input_f == UTF16LE_INPUT
+#endif
+      ){
+	is_8bit = TRUE;
+    }
+
 
     input_mode = ASCII;
     output_mode = ASCII;
@@ -1957,7 +2414,10 @@ kanji_convert(f)
 #define LAST break         /* end of loop, go closing  */
 
     while ((c1 = (*i_getc)(f)) != EOF) {
-        code_status(c1);
+#ifdef INPUT_CODE_FIX
+	if (!input_f)
+#endif
+	    code_status(c1);
         if (c2) {
             /* second byte */
             if (c2 > DEL) {
@@ -2067,7 +2527,8 @@ kanji_convert(f)
                         /* look like bogus code */
                         NEXT;
                     }
-                } else if (input_mode == X0208) {
+                } else if (input_mode == X0208 || input_mode == X0212 ||
+			   input_mode == X0213_1 || input_mode == X0213_2) {
                     /* in case of Kanji shifted */
                     c2 = c1;
                     NEXT;
@@ -2097,13 +2558,13 @@ kanji_convert(f)
                     /* normal ASCII code */ 
                     SEND;
                 }
-            } else if (c1 == SI) {
+            } else if (!is_8bit && c1 == SI) {
                 shift_mode = FALSE; 
                 NEXT;
-            } else if (c1 == SO) {
+            } else if (!is_8bit && c1 == SO) {
                 shift_mode = TRUE; 
                 NEXT;
-            } else if (c1 == ESC ) {
+            } else if (!is_8bit && c1 == ESC ) {
                 if ((c1 = (*i_getc)(f)) == EOF) {
                     /*  (*oconv)(0, ESC); don't send bogus code */
                     LAST;
@@ -2141,6 +2602,14 @@ kanji_convert(f)
                             shift_mode = FALSE;
                             NEXT;
 #endif /* X0212_ENABLE */
+                        } else if (c1 == (X0213_1&0x7F)){
+                            input_mode = X0213_1;
+                            shift_mode = FALSE;
+                            NEXT;
+                        } else if (c1 == (X0213_2&0x7F)){
+                            input_mode = X0213_2;
+                            shift_mode = FALSE;
+                            NEXT;
                         } else {
                             /* could be some special code */
                             (*oconv)(0, ESC);
@@ -2236,21 +2705,31 @@ kanji_convert(f)
                 SEND;
         }
         /* send: */
-        if (input_mode == X0208) 
-            (*oconv)(c2, c1);  /* this is JIS, not SJIS/EUC case */
+	switch(input_mode){
+	case ASCII:
+	    if ((*iconv)(c2, c1, 0) < 0){  /* can be EUC/SJIS */
+		int c0 = (*i_getc)(f);
+		if (c0 != EOF){
+		    code_status(c0);
+		    (*iconv)(c2, c1, c0);
+		}
+	    }
+	    break;
+	case X0208:
+	case X0213_1:
+	    (*oconv)(c2, c1); /* this is JIS, not SJIS/EUC case */
+	    break;
 #ifdef X0212_ENABLE
-        else if (input_mode == X0212) 
-            (*oconv)((0x8f << 8) | c2, c1);
+	case X0212:
+	    (*oconv)((0x8f << 8) | c2, c1);
+	    break;
 #endif /* X0212_ENABLE */
-        else if (input_mode) 
-            (*oconv)(input_mode, c1);  /* other special case */
-        else if ((*iconv)(c2, c1, 0) < 0){  /* can be EUC/SJIS */
-            int c0 = (*i_getc)(f);
-            if (c0 != EOF){
-                code_status(c0);
-                (*iconv)(c2, c1, c0);
-            }
-        }
+	case X0213_2:
+	    (*oconv)((0x8f << 8) | c2, c1);
+	    break;
+	default:
+	    (*oconv)(input_mode, c1);  /* other special case */
+	}
 
         c2 = 0;
         continue;
@@ -2391,8 +2870,9 @@ int s2e_conv(c2, c1, p2, p1)
 #if defined(SHIFTJIS_CP932) || defined(X0212_ENABLE)
     int val;
 #endif
+    STATIC const int shift_jisx0213_s1a3_table[5][2] ={ { 1, 8}, { 3, 4}, { 5,12}, {13,14}, {15, 0} };
 #ifdef SHIFTJIS_CP932
-    if (cp932_f && CP932_TABLE_BEGIN <= c2 && c2 <= CP932_TABLE_END){
+    if (cp51932_f && CP932_TABLE_BEGIN <= c2 && c2 <= CP932_TABLE_END){
         extern const unsigned short shiftjis_cp932[3][189];
         val = shiftjis_cp932[c2 - CP932_TABLE_BEGIN][c1 - 0x40];
         if (val){
@@ -2402,7 +2882,7 @@ int s2e_conv(c2, c1, p2, p1)
     }
 #endif /* SHIFTJIS_CP932 */
 #ifdef X0212_ENABLE
-    if (x0212_f && 0xfa <= c2 && c2 <= 0xfc){
+    if (!x0213_f && 0xfa <= c2 && c2 <= 0xfc){
         extern const unsigned short shiftjis_x0212[3][189];
         val = shiftjis_x0212[c2 - 0xfa][c1 - 0x40];
         if (val){
@@ -2419,18 +2899,27 @@ int s2e_conv(c2, c1, p2, p1)
         }
     }
 #endif
-    c2 = c2 + c2 - ((c2 <= 0x9f) ? SJ0162 : SJ6394);
-    if (c1 < 0x9f)
-        c1 = c1 - ((c1 > DEL) ? SPACE : 0x1f);
-    else {
-        c1 = c1 - 0x7e;
-        c2++;
+    if(c2 >= 0x80){
+	if(x0213_f && c2 >= 0xF0){
+	    if(c2 <= 0xF3 || (c2 == 0xF4 && c1 < 0x9F)){ /* k=1, 3<=k<=5, k=8, 12<=k<=15 */
+		c2 = 0x8F20 + shift_jisx0213_s1a3_table[c2 - 0xF0][0x9E < c1];
+	    }else{ /* 78<=k<=94 */
+		c2 = 0x8F00 | (c2 * 2 - 0x17B);
+		if (0x9E < c1) c2++;
+	    }
+	}else{
+	    c2 = c2 + c2 - ((c2 <= 0x9F) ? SJ0162 : SJ6394);
+	    if (0x9E < c1) c2++;
+	}
+	if (c1 < 0x9F)
+	    c1 = c1 - ((c1 > DEL) ? SPACE : 0x1F);
+	else {
+	    c1 = c1 - 0x7E;
+	}
     }
 
 #ifdef X0212_ENABLE
-    if (x0212_f){
-        c2 = x0212_unshift(c2);
-    }
+    c2 = x0212_unshift(c2);
 #endif
     if (p2) *p2 = c2;
     if (p1) *p1 = c1;
@@ -2469,7 +2958,7 @@ e_iconv(c2, c1, c0)
         c2 = (c2 << 8) | (c1 & 0x7f);
         c1 = c0 & 0x7f;
 #ifdef SHIFTJIS_CP932
-        if (cp932_f){
+        if (cp51932_f){
             int s2, s1;
             if (e2s_conv(c2, c1, &s2, &s1) == 0){
                 s2e_conv(s2, s1, &c2, &c1);
@@ -2500,33 +2989,21 @@ w2e_conv(c2, c1, c0, p2, p1)
     int    c2, c1, c0;
     int *p2, *p1;
 {
-    extern const unsigned short *const utf8_to_euc_2bytes[];
-    extern const unsigned short *const *const utf8_to_euc_3bytes[];
     int ret = 0;
 
-    if (0xc0 <= c2 && c2 <= 0xef) {
-        const unsigned short *const *pp;
-
-        if (0xe0 <= c2) {
-            if (c0 == 0) return -1;
-            pp = utf8_to_euc_3bytes[c2 - 0x80];
-            ret = w_iconv_common(c1, c0, pp, sizeof_utf8_to_euc_C2, p2, p1);
-        } else {
-            ret =  w_iconv_common(c2, c1, utf8_to_euc_2bytes, sizeof_utf8_to_euc_2bytes, p2, p1);
-        }
+    if (!c1){
+        *p2 = 0;
+        *p1 = c2;
+    }else if (0xc0 <= c2 && c2 <= 0xef) {
+	ret =  unicode_to_jis_common(c2, c1, c0, p2, p1);
 #ifdef NUMCHAR_OPTION
-        if (ret){
+        if (ret > 0){
             if (p2) *p2 = 0;
             if (p1) *p1 = CLASS_UTF16 | ww16_conv(c2, c1, c0);
             ret = 0;
         }
 #endif
-        return ret;
-    } else if (c2 == X0201) {
-        c1 &= 0x7f;
     }
-    if (p2) *p2 = c2;
-    if (p1) *p1 = c1;
     return ret;
 }
 
@@ -2537,12 +3014,20 @@ w_iconv(c2, c1, c0)
 {
     int ret = 0;
     
-    if (c0 == 0){
-	if (c2 == 0) /* 0x00-0x7f */
-	    ; /* 1byte */
-	else if ((c2 & 0xe0) == 0xc0) /* 0xc0-0xdf */
-	    ; /* 2ytes */
-	else if ((c2 & 0xf0) == 0xe0) /* 0xe0-0xef */
+    /* throw away ZERO WIDTH NO-BREAK SPACE (U+FEFF) */
+    if(ignore_zwnbsp_f){
+	ignore_zwnbsp_f = FALSE;
+	if(c2 == 0xef && c1 == 0xbb && c0 == 0xbf)
+	    return 0;
+    }
+    
+    if (c2 == 0) /* 0x00-0x7f */
+	c1 &= 0x7F; /* 1byte */
+    else if (c0 == 0){
+	if ((c2 & 0xe0) == 0xc0){ /* 0xc0-0xdf */
+	    /* 2ytes */
+	    if((c2 & 0xFE) == 0xC0 || c1 < 0x80 || 0xBF < c1) return 0;
+	}else if ((c2 & 0xf0) == 0xe0) /* 0xe0-0xef */
 	    return -1; /* 3bytes */
 #ifdef __COMMENT__
 	else if (0xf0 <= c2)
@@ -2551,21 +3036,20 @@ w_iconv(c2, c1, c0)
 	    return 0; /* trail byte */
 #endif
 	else return 0;
-    }
-    if (c2 == EOF);
-    else if (c2 == 0xef && c1 == 0xbb && c0 == 0xbf) {
-	return 0; /* throw BOM */
-#if defined(UTF8_OUTPUT_ENABLE) && defined(UTF8_INPUT_ENABLE)
-    } else if (internal_unicode_f && (output_conv == w_oconv || output_conv == w_oconv16)){
-	unsigned short val = 0;
-	if(c2 == 0){
-	    c2 = c1;
-	    c1 = 0;
-	}
-	val = ww16_conv(c2, c1, c0);
-	c2 = (val >> 8) & 0xff;
-	c1 = val & 0xff;
-#endif
+    }else{
+	/* must be 3bytes */
+	if(c2 == 0xE0){
+	    if(c1 < 0xA0 || 0xBF < c1 || c0 < 0x80 || 0xBF < c0)
+		return 0;
+	}else if(c2 == 0xED){
+	    if(c1 < 0x80 || 0x9F < c1 || c0 < 0x80 || 0xBF < c0)
+		return 0;
+	}else if((c2 & 0xf0) == 0xe0){
+	    if(c1 < 0x80 || 0xBF < c1 || c0 < 0x80 || 0xBF < c0)
+		return 0;
+	}else return 0;
+    }
+    if (c2 == 0 || c2 == EOF){
     } else {
 	ret = w2e_conv(c2, c1, c0, &c2, &c1);
     }
@@ -2574,7 +3058,9 @@ w_iconv(c2, c1, c0)
     }
     return ret;
 }
+#endif
 
+#if defined(UTF8_INPUT_ENABLE) || defined(UTF8_OUTPUT_ENABLE)
 void
 w16w_conv(val, p2, p1, p0)
      unsigned short val;
@@ -2594,13 +3080,17 @@ w16w_conv(val, p2, p1, p0)
         *p0 = 0x80 | (val        & 0x3f);
     }
 }
+#endif
 
+#ifdef UTF8_INPUT_ENABLE
 int
 ww16_conv(c2, c1, c0)
      int c2, c1, c0;
 {
     unsigned short val;
-    if (c2 >= 0xe0){
+    if (c2 >= 0xf0){
+	val = -1;
+    }else if (c2 >= 0xe0){
         val = (c2 & 0x0f) << 12;
         val |= (c1 & 0x3f) << 6;
         val |= (c0 & 0x3f);
@@ -2618,50 +3108,44 @@ w16e_conv(val, p2, p1)
      unsigned short val;
      int *p2, *p1;
 {
-    extern const unsigned short *const utf8_to_euc_2bytes[];
-    extern const unsigned short *const *const utf8_to_euc_3bytes[];
     int c2, c1, c0;
-    const unsigned short *const *pp;
-    int psize;
     int ret = 0;
 
-    w16w_conv(val, &c2, &c1, &c0);
-    if (c1){
-        if (c0){
-            pp = utf8_to_euc_3bytes[c2 - 0x80];
-            psize = sizeof_utf8_to_euc_C2;
-            ret =  w_iconv_common(c1, c0, pp, psize, p2, p1);
-        }else{
-            pp = utf8_to_euc_2bytes;
-            psize = sizeof_utf8_to_euc_2bytes;
-            ret =  w_iconv_common(c2, c1, pp, psize, p2, p1);
-        }
+    if (val < 0x80){
+        *p2 = 0;
+        *p1 = val;
+    }else{
+	w16w_conv(val, &c2, &c1, &c0);
+	ret =  unicode_to_jis_common(c2, c1, c0, p2, p1);
 #ifdef NUMCHAR_OPTION
-        if (ret){
-            *p2 = 0;
-            *p1 = CLASS_UTF16 | val;
-            ret = 0;
-        }
+	if (ret > 0){
+	    *p2 = 0;
+	    *p1 = CLASS_UTF16 | val;
+	    ret = 0;
+	}
 #endif
-    }else{
-        *p2 = 0;
-        *p1 = c2;
     }
     return ret;
 }
+#endif
 
+#ifdef UTF8_INPUT_ENABLE
 int
 w_iconv16(c2, c1, c0)
     int    c2, c1,c0;
 {
     int ret = 0;
 
-    if (c2==0376 && c1==0377){
-	utf16_mode = UTF16BE_INPUT;
-	return 0;    
-    } else if (c2==0377 && c1==0376){
-	utf16_mode = UTF16LE_INPUT;
-	return 0;    
+    /* throw away ZERO WIDTH NO-BREAK SPACE (U+FEFF) */
+    if(ignore_zwnbsp_f){
+	ignore_zwnbsp_f = FALSE;
+	if (c2==0376 && c1==0377){
+	    utf16_mode = UTF16BE_INPUT;
+	    return 0;
+	}else if(c2==0377 && c1==0376){
+	    utf16_mode = UTF16LE_INPUT;
+	    return 0;
+	}
     }
     if (c2 != EOF && utf16_mode == UTF16LE_INPUT) {
 	int tmp;
@@ -2670,16 +3154,131 @@ w_iconv16(c2, c1, c0)
     if ((c2==0 && c1 < 0x80) || c2==EOF) {
 	(*oconv)(c2, c1);
 	return 0;
-    }
-#if defined(UTF8_OUTPUT_ENABLE) && defined(UTF8_INPUT_ENABLE)
-    if (internal_unicode_f && (output_conv == w_oconv || output_conv == w_oconv16));
-#endif
-    else ret = w16e_conv(((c2<<8)&0xff00) + c1, &c2, &c1);
+    }else if((c2>>3)==27){ /* surrogate pair */
+	return 1;
+    }else ret = w16e_conv(((c2<<8)&0xff00) + c1, &c2, &c1);
     if (ret) return ret;
     (*oconv)(c2, c1);
     return 0;
 }
 
+int
+unicode_to_jis_common(c2, c1, c0, p2, p1)
+    int c2, c1, c0;
+    int *p2, *p1;
+{
+    extern const unsigned short *const utf8_to_euc_2bytes[];
+    extern const unsigned short *const utf8_to_euc_2bytes_ms[];
+    extern const unsigned short *const utf8_to_euc_2bytes_932[];
+    extern const unsigned short *const *const utf8_to_euc_3bytes[];
+    extern const unsigned short *const *const utf8_to_euc_3bytes_ms[];
+    extern const unsigned short *const *const utf8_to_euc_3bytes_932[];
+    const unsigned short *const *pp;
+    const unsigned short *const *const *ppp;
+    STATIC const int no_best_fit_chars_table_C2[] =
+    {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1,
+	0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0};
+    STATIC const int no_best_fit_chars_table_C2_ascii[] =
+    {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+	0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0,
+	0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0};
+    STATIC const int no_best_fit_chars_table_932_C2[] =
+    {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+	0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1,
+	0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0};
+    STATIC const int no_best_fit_chars_table_932_C3[] =
+    {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1};
+    int ret = 0;
+
+    if(c2 < 0x80){
+	*p2 = 0;
+	*p1 = c2;
+    }else if(c2 < 0xe0){
+	if(no_best_fit_chars_f){
+	    if(ms_ucs_map_f == UCS_MAP_CP932){
+		switch(c2){
+		case 0xC2:
+		    if(no_best_fit_chars_table_932_C2[c1&0x3F]) return 1;
+		    break;
+		case 0xC3:
+		    if(no_best_fit_chars_table_932_C3[c1&0x3F]) return 1;
+		    break;
+		}
+	    }else if(cp51932_f){
+		if(c2 == 0xC2 && no_best_fit_chars_table_C2[c1&0x3F]) return 1;
+	    }else{
+		if(c2 == 0xC2 && no_best_fit_chars_table_C2_ascii[c1&0x3F]) return 1;
+	    }
+	}
+	pp =
+	    ms_ucs_map_f == UCS_MAP_CP932 ? utf8_to_euc_2bytes_932 :
+	    ms_ucs_map_f == UCS_MAP_MS ? utf8_to_euc_2bytes_ms :
+	    utf8_to_euc_2bytes;
+	ret =  w_iconv_common(c2, c1, pp, sizeof_utf8_to_euc_2bytes, p2, p1);
+    }else if(c0){
+	if(no_best_fit_chars_f){
+	    if(ms_ucs_map_f == UCS_MAP_CP932){
+		if(c2 == 0xE3 && c1 == 0x82 && c0 == 0x94) return 1;
+	    }else if(ms_ucs_map_f == UCS_MAP_MS){
+		switch(c2){
+		case 0xE2:
+		    switch(c1){
+		    case 0x80:
+			if(c0 == 0x94 || c0 == 0x96 || c0 == 0xBE) return 1;
+			break;
+		    case 0x88:
+			if(c0 == 0x92) return 1;
+			break;
+		    }
+		    break;
+		case 0xE3:
+		    if(c1 == 0x80 || c0 == 0x9C) return 1;
+		    break;
+		}
+	    }else{
+		switch(c2){
+		case 0xE2:
+		    switch(c1){
+		    case 0x80:
+			if(c0 == 0x95) return 1;
+			break;
+		    case 0x88:
+			if(c0 == 0xA5) return 1;
+			break;
+		    }
+		    break;
+		case 0xEF:
+		    switch(c1){
+		    case 0xBC:
+			if(c0 == 0x8D) return 1;
+			break;
+		    case 0xBD:
+			if(c0 == 0x9E && cp51932_f) return 1;
+			break;
+		    case 0xBF:
+			if(0xA0 <= c0 && c0 <= 0xA5) return 1;
+			break;
+		    }
+		    break;
+		}
+	    }
+	}
+	ppp =
+	    ms_ucs_map_f == UCS_MAP_CP932 ? utf8_to_euc_3bytes_932 :
+	    ms_ucs_map_f == UCS_MAP_MS ? utf8_to_euc_3bytes_ms :
+	    utf8_to_euc_3bytes;
+	ret = w_iconv_common(c1, c0, ppp[c2 - 0xE0], sizeof_utf8_to_euc_C2, p2, p1);
+    }else return -1;
+    return ret;
+}
+
 int
 w_iconv_common(c1, c0, pp, psize, p2, p1)
     int    c1,c0;
@@ -2699,9 +3298,13 @@ w_iconv_common(c1, c0, pp, psize, p2, p1)
     if (p == 0)  return 1;
 
     c0 -= 0x80;
-    if (c0 < 0 || sizeof_utf8_to_euc_E5B8 <= c0) return 1;
+    if (c0 < 0 || sizeof_utf8_to_euc_C2 <= c0) return 1;
     val = p[c0];
     if (val == 0) return 1;
+    if (no_cp932ext_f && (
+	(val>>8) == 0x2D || /* NEC special characters */
+	val > 0xF300 /* NEC special characters */
+	)) return 1;
 
     c2 = val >> 8;
     if (val & 0x8000){
@@ -2715,6 +3318,118 @@ w_iconv_common(c1, c0, pp, psize, p2, p1)
     return 0;
 }
 
+void
+nkf_each_char_to_hex(f, c)
+    void (*f)PROTO((int c2,int c1));
+    int c;
+{
+    const char *hex = "0123456789ABCDEF";
+    c &= 0x00FFFFFF;
+    int shift = 20;
+    while(shift >= 0){
+	if(c >= 1<<shift){
+	    while(shift >= 0){
+		(*f)(0, hex[(c>>shift)&0xF]);
+		shift -= 4;
+	    }
+	}else{
+	    shift -= 4;
+	}
+    }
+    return;
+}
+
+void
+encode_fallback_html(c)
+    int c;
+{
+    (*oconv)(0, '&');
+    (*oconv)(0, '#');
+    c &= 0x00FFFFFF;
+    if(c >= 1000000)
+	(*oconv)(0, 0x30+(c/1000000)%10);
+    if(c >= 100000)
+	(*oconv)(0, 0x30+(c/100000 )%10);
+    if(c >= 10000)
+	(*oconv)(0, 0x30+(c/10000  )%10);
+    if(c >= 1000)
+	(*oconv)(0, 0x30+(c/1000   )%10);
+    if(c >= 100)
+	(*oconv)(0, 0x30+(c/100    )%10);
+    if(c >= 10)
+	(*oconv)(0, 0x30+(c/10     )%10);
+    if(c >= 0)
+	(*oconv)(0, 0x30+ c         %10);
+    (*oconv)(0, ';');
+    return;
+}
+
+void
+encode_fallback_xml(c)
+    int c;
+{
+    (*oconv)(0, '&');
+    (*oconv)(0, '#');
+    (*oconv)(0, 'x');
+    nkf_each_char_to_hex(oconv, c);
+    (*oconv)(0, ';');
+    return;
+}
+
+void
+encode_fallback_java(c)
+    int c;
+{
+    const char *hex = "0123456789ABCDEF";
+    (*oconv)(0, '\\');
+    if((c&0x00FFFFFF) > 0xFFFF){
+	(*oconv)(0, 'U');
+	(*oconv)(0, '0');
+	(*oconv)(0, '0');
+	(*oconv)(0, hex[(c>>20)&0xF]);
+	(*oconv)(0, hex[(c>>16)&0xF]);
+    }else{
+	(*oconv)(0, 'u');
+    }
+    (*oconv)(0, hex[(c>>12)&0xF]);
+    (*oconv)(0, hex[(c>> 8)&0xF]);
+    (*oconv)(0, hex[(c>> 4)&0xF]);
+    (*oconv)(0, hex[ c     &0xF]);
+    return;
+}
+
+void
+encode_fallback_perl(c)
+    int c;
+{
+    (*oconv)(0, '\\');
+    (*oconv)(0, 'x');
+    (*oconv)(0, '{');
+    nkf_each_char_to_hex(oconv, c);
+    (*oconv)(0, '}');
+    return;
+}
+
+void
+encode_fallback_subchar(c)
+    int c;
+{
+    c = unicode_subchar;
+    (*oconv)((c>>8)&0xFF, c&0xFF);
+    return;
+    int shift = 16;
+    while(shift >= 0){
+	if(c >= 1<<shift){
+	    while(shift >= 0){
+		(*oconv)(0, (c>>shift)&0xFF);
+		shift -= 8;
+	    }
+	}else{
+	    shift -= 8;
+	}
+    }
+    return;
+}
 #endif
 
 #ifdef UTF8_OUTPUT_ENABLE
@@ -2731,6 +3446,9 @@ e2w_conv(c2, c1)
         p = euc_to_utf8_1byte;
 #ifdef X0212_ENABLE
     } else if (c2 >> 8 == 0x8f){
+	if(ms_ucs_map_f == UCS_MAP_ASCII&& c2 == 0x8F22 && c1 == 0x43){
+	    return 0xA6;
+	}
         extern const unsigned short *const x0212_to_utf8_2bytes[];
         c2 = (c2&0x7f) - 0x21;
         if (0<=c2 && c2<sizeof_euc_to_utf8_2bytes)
@@ -2742,7 +3460,7 @@ e2w_conv(c2, c1)
         c2 &= 0x7f;
         c2 = (c2&0x7f) - 0x21;
         if (0<=c2 && c2<sizeof_euc_to_utf8_2bytes)
-            p = ms_ucs_map_f ? euc_to_utf8_2bytes_ms[c2] : euc_to_utf8_2bytes[c2];
+            p = ms_ucs_map_f != UCS_MAP_ASCII ? euc_to_utf8_2bytes_ms[c2] : euc_to_utf8_2bytes[c2];
 	else
 	    return 0;
     }
@@ -2792,9 +3510,7 @@ w_oconv(c2, c1)
         (*o_putc)(c1 | 0x080);
     } else {
         output_mode = UTF8;
-	if (internal_unicode_f && (iconv == w_iconv || iconv == w_iconv16))
-	    val = ((c2<<8)&0xff00) + c1;
-	else val = e2w_conv(c2, c1);
+	val = e2w_conv(c2, c1);
         if (val){
             w16w_conv(val, &c2, &c1, &c0);
             (*o_putc)(c2);
@@ -2827,8 +3543,7 @@ w_oconv16(c2, c1)
 	unicode_bom_f=1;
     }
 
-    if (internal_unicode_f && (iconv == w_iconv || iconv == w_iconv16)){
-    } else if (c2 == ISO8859_1) {
+    if (c2 == ISO8859_1) {
         c2 = 0;
         c1 |= 0x80;
 #ifdef NUMCHAR_OPTION
@@ -2861,6 +3576,7 @@ e_oconv(c2, c1)
     if (c2 == 0 && (c1 & CLASS_MASK) == CLASS_UTF16){
         w16e_conv(c1, &c2, &c1);
         if (c2 == 0 && (c1 & CLASS_MASK) == CLASS_UTF16){
+	    if(encode_fallback)(*encode_fallback)(c1);
             return;
         }
     }
@@ -2881,14 +3597,17 @@ e_oconv(c2, c1)
     } else if ((c2 & 0xff00) >> 8 == 0x8f){
 	output_mode = JAPANESE_EUC;
 #ifdef SHIFTJIS_CP932
-        if (cp932_f){
+        if (cp51932_f){
             int s2, s1;
             if (e2s_conv(c2, c1, &s2, &s1) == 0){
                 s2e_conv(s2, s1, &c2, &c1);
             }
         }
 #endif
-        if ((c2 & 0xff00) >> 8 == 0x8f){
+        if (c2 == 0) {
+	    output_mode = ASCII;
+	    (*o_putc)(c1);
+	}else if ((c2 & 0xff00) >> 8 == 0x8f){
             if (x0212_f){
                 (*o_putc)(0x8f);
                 (*o_putc)((c2 & 0x7f) | 0x080);
@@ -2947,32 +3666,42 @@ int
 e2s_conv(c2, c1, p2, p1)
      int c2, c1, *p2, *p1;
 {
-#ifdef X0212_ENABLE
-    int val = 0;
-    const unsigned short *ptr;
     int ndx;
-    extern const unsigned short *const x0212_shiftjis[];
     if ((c2 & 0xff00) == 0x8f00){
-        ndx = c2 & 0x7f;
-        if (0x21 <= ndx && ndx <= 0x7e){
-            ptr = x0212_shiftjis[ndx - 0x21];
-            if (ptr){
-                val = ptr[(c1 & 0x7f) - 0x21];
-            }
-            if (val){
-                c2 = val >> 8;
-                c1 = val & 0xff;
-                if (p2) *p2 = c2;
-                if (p1) *p1 = c1;
-                return 0;
-            }
-        }
-        c2 = x0212_shift(c2);
-    }
+	ndx = c2 & 0xff;
+	if (x0213_f){
+	    if((0x21 <= ndx && ndx <= 0x2F)){
+		if (p2) *p2 = ((ndx - 1) >> 1) + 0xec - ndx / 8 * 3;
+		if (p1) *p1 = c1 + ((ndx & 1) ? ((c1 < 0x60) ? 0x1f : 0x20) : 0x7e);
+		return 0;
+	    }else if(0x6E <= ndx && ndx <= 0x7E){
+		if (p2) *p2 = ((ndx - 1) >> 1) + 0xbe;
+		if (p1) *p1 = c1 + ((ndx & 1) ? ((c1 < 0x60) ? 0x1f : 0x20) : 0x7e);
+		return 0;
+	    }
+	    return 1;
+	}
+#ifdef X0212_ENABLE
+	else if(0x21 <= ndx && ndx <= 0x7e){
+	    int val = 0;
+	    const unsigned short *ptr;
+	    extern const unsigned short *const x0212_shiftjis[];
+	    ptr = x0212_shiftjis[ndx - 0x21];
+	    if (ptr){
+		val = ptr[(c1 & 0x7f) - 0x21];
+	    }
+	    if (val){
+		c2 = val >> 8;
+		c1 = val & 0xff;
+		if (p2) *p2 = c2;
+		if (p1) *p1 = c1;
+		return 0;
+	    }
+	    c2 = x0212_shift(c2);
+	}
 #endif /* X0212_ENABLE */
-    if ((c2 & 0xff00) == 0x8f00){
-        return 1;
     }
+    if(0x7F < c2) return 1;
     if (p2) *p2 = ((c2 - 1) >> 1) + ((c2 <= 0x5e) ? 0x71 : 0xb1);
     if (p1) *p1 = c1 + ((c2 & 1) ? ((c1 < 0x60) ? 0x1f : 0x20) : 0x7e);
     return 0;
@@ -2986,6 +3715,10 @@ s_oconv(c2, c1)
 #ifdef NUMCHAR_OPTION
     if (c2 == 0 && (c1 & CLASS_MASK) == CLASS_UTF16){
         w16e_conv(c1, &c2, &c1);
+        if (c2 == 0 && (c1 & CLASS_MASK) == CLASS_UTF16){
+	    if(encode_fallback)(*encode_fallback)(c1);
+            return;
+        }
     }
 #endif
     if (c2 == EOF) {
@@ -3043,8 +3776,12 @@ j_oconv(c2, c1)
                     c1;
 {
 #ifdef NUMCHAR_OPTION
-    if ((c1 & CLASS_MASK) == CLASS_UTF16){
+    if (c2 == 0 && (c1 & CLASS_MASK) == CLASS_UTF16){
         w16e_conv(c1, &c2, &c1);
+        if (c2 == 0 && (c1 & CLASS_MASK) == CLASS_UTF16){
+	    if(encode_fallback)(*encode_fallback)(c1);
+            return;
+        }
     }
 #endif
     if (c2 == EOF) {
@@ -3057,12 +3794,22 @@ j_oconv(c2, c1)
         (*o_putc)(EOF);
 #ifdef X0212_ENABLE
     } else if ((c2 & 0xff00) >> 8 == 0x8f){
-        if (output_mode!=X0212) {
-            output_mode = X0212;
-            (*o_putc)(ESC);
-            (*o_putc)('$');
-            (*o_putc)('(');
-            (*o_putc)('D');
+	if(x0213_f){
+	    if(output_mode!=X0213_2){
+		output_mode = X0213_2;
+		(*o_putc)(ESC);
+		(*o_putc)('$');
+		(*o_putc)('(');
+		(*o_putc)(X0213_2&0x7F);
+	    }
+	}else{
+	    if(output_mode!=X0212){
+		output_mode = X0212;
+		(*o_putc)(ESC);
+		(*o_putc)('$');
+		(*o_putc)('(');
+		(*o_putc)(X0212&0x7F);
+	    }
         }
         (*o_putc)(c2 & 0x7f);
         (*o_putc)(c1);
@@ -3090,16 +3837,21 @@ j_oconv(c2, c1)
         }
         (*o_putc)(c1);
     } else {
-        if (output_mode != X0208) {
+	if(c2<0x20 || 0x7e<c2 || c1<0x20 || 0x7e<c1) return;
+	if(x0213_f){
+	    if (output_mode!=X0213_1) {
+		output_mode = X0213_1;
+		(*o_putc)(ESC);
+		(*o_putc)('$');
+		(*o_putc)('(');
+		(*o_putc)(X0213_1&0x7F);
+	    }
+	}else if (output_mode != X0208) {
             output_mode = X0208;
             (*o_putc)(ESC);
             (*o_putc)('$');
             (*o_putc)(kanji_intro);
         }
-        if (c1<0x20 || 0x7e<c1) 
-            return;
-        if (c2<0x20 || 0x7e<c2) 
-            return;
         (*o_putc)(c2);
         (*o_putc)(c1);
     }
@@ -3300,7 +4052,7 @@ int c2,c1;
         if (f_line<=fold_len) {   /* normal case */
             fold_state = 1;
         } else {
-            if (f_line>=fold_len+fold_margin) { /* too many kinsou suspension */
+            if (f_line>fold_len+fold_margin) { /* too many kinsoku suspension */
                 f_line = char_size(c2,c1);
                 fold_state =  '\n';       /* We can't wait, do fold now */
             } else if (c2==X0201) {
@@ -3568,7 +4320,7 @@ const unsigned char *mime_pattern[] = {
     (const unsigned char *)"\075?ISO-8859-1?B?",
     (const unsigned char *)"\075?ISO-2022-JP?B?",
     (const unsigned char *)"\075?ISO-2022-JP?Q?",
-#if defined(UTF8_INPUT_ENABLE) || defined(UTF8_OUTPUT_ENABLE)
+#if defined(UTF8_INPUT_ENABLE)
     (const unsigned char *)"\075?UTF-8?B?",
     (const unsigned char *)"\075?UTF-8?Q?",
 #endif
@@ -3580,7 +4332,7 @@ const unsigned char *mime_pattern[] = {
 /* $B3:Ev$9$k%3!<%I$NM%@hEY$r>e$2$k$?$a$NL\0u(B */
 int (*mime_priority_func[])PROTO((int c2, int c1, int c0)) = {
     e_iconv, s_iconv, 0, 0, 0, 0,
-#if defined(UTF8_INPUT_ENABLE) || defined(UTF8_OUTPUT_ENABLE)
+#if defined(UTF8_INPUT_ENABLE)
     w_iconv, w_iconv,
 #endif
     0,
@@ -3588,7 +4340,7 @@ int (*mime_priority_func[])PROTO((int c2, int c1, int c0)) = {
 
 const int mime_encode[] = {
     JAPANESE_EUC, SHIFT_JIS,ISO8859_1, ISO8859_1, X0208, X0201,
-#if defined(UTF8_INPUT_ENABLE) || defined(UTF8_OUTPUT_ENABLE)
+#if defined(UTF8_INPUT_ENABLE)
     UTF8, UTF8,
 #endif
     ASCII,
@@ -3597,7 +4349,7 @@ const int mime_encode[] = {
 
 const int mime_encode_method[] = {
     'B', 'B','Q', 'B', 'B', 'Q',
-#if defined(UTF8_INPUT_ENABLE) || defined(UTF8_OUTPUT_ENABLE)
+#if defined(UTF8_INPUT_ENABLE)
     'B', 'Q',
 #endif
     'Q',
@@ -3607,15 +4359,6 @@ const int mime_encode_method[] = {
 
 #define MAXRECOVER 20
 
-/* I don't trust portablity of toupper */
-#define nkf_toupper(c)  (('a'<=c && c<='z')?(c-('a'-'A')):c)
-#define nkf_isdigit(c)  ('0'<=c && c<='9')
-#define nkf_isxdigit(c)  (nkf_isdigit(c) || ('a'<=c && c<='f') || ('A'<=c && c <= 'F'))
-#define nkf_isblank(c) (c == SPACE || c == TAB)
-#define nkf_isspace(c) (nkf_isblank(c) || c == CR || c == NL)
-#define nkf_isalpha(c) (('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z'))
-#define nkf_isalnum(c) (nkf_isdigit(c) || nkf_isalpha(c))
-
 void
 switch_mime_getc()
 {
@@ -3823,14 +4566,6 @@ print_guessed_code (filename)
 }
 #endif /*WIN32DLL*/
 
-int
-hex2bin(x)
-     int x;
-{
-    if (nkf_isdigit(x)) return x - '0';
-    return nkf_toupper(x) - 'A' + 10;
-}
-
 #ifdef INPUT_OPTION 
 
 #ifdef ANSI_C_PROTOTYPE
@@ -4038,12 +4773,12 @@ FILE *f;
     if (mime_decode_mode == 'Q') {
         if ((c1 = (*i_mgetc)(f)) == EOF) return (EOF);
 restart_mime_q:
-        if (c1=='_') return ' ';
+        if (c1=='_' && mimebuf_f != FIXED_MIME) return ' ';
 	if (c1<=' ' || DEL<=c1) {
 	    mime_decode_mode = exit_mode; /* prepare for quit */
 	    return c1;
 	}
-        if (c1!='=' && c1!='?') {
+        if (c1!='=' && (c1!='?' || mimebuf_f == FIXED_MIME)) {
 	    return c1;
 	}
                 
@@ -4455,13 +5190,10 @@ mimeout_addchar(c)
 {
     switch(mimeout_mode) {
     case 'Q':
-	if(c==SPACE){
-	    (*o_mputc)('_');
-	    base64_count++;
-	} else if (c==CR||c==NL) {
+	if (c==CR||c==NL) {
 	    (*o_mputc)(c);
 	    base64_count = 0;
-	} else if(c<SPACE||c=='='||c=='?'||c=='_'||DEL<=c) {
+	} else if(!nkf_isalnum(c)) {
 	    (*o_mputc)('=');
 	    (*o_mputc)(itoh4(((c>>4)&0xf)));
 	    (*o_mputc)(itoh4((c&0xf)));
@@ -4749,13 +5481,19 @@ reinit()
      x0201_f = NO_X0201;
 #endif
     iso2022jp_f = FALSE;
-#if defined(UTF8_OUTPUT_ENABLE) && defined(UTF8_INPUT_ENABLE)
-    internal_unicode_f = FALSE;
+#if defined(UTF8_INPUT_ENABLE) || defined(UTF8_OUTPUT_ENABLE)
+    ms_ucs_map_f = UCS_MAP_ASCII;
+#endif
+#ifdef UTF8_INPUT_ENABLE
+    no_cp932ext_f = FALSE;
+    ignore_zwnbsp_f = TRUE;
+    no_best_fit_chars_f = FALSE;
+    encode_fallback = NULL;
+    unicode_subchar  = '?';
 #endif
 #ifdef UTF8_OUTPUT_ENABLE
     unicode_bom_f = 0;
     w_oconv16_LE = 0;
-    ms_ucs_map_f = FALSE;
 #endif
 #ifdef UNICODE_NORMALIZATION
     nfc_f = FALSE;
@@ -4776,8 +5514,12 @@ reinit()
     exec_f = 0;
 #endif
 #ifdef SHIFTJIS_CP932
-    cp932_f = TRUE;
+    cp51932_f = TRUE;
     cp932inv_f = TRUE;
+#endif
+#ifdef X0212_ENABLE
+    x0212_f = FALSE;
+    x0213_f = FALSE;
 #endif
     {
         int i;
@@ -4822,7 +5564,7 @@ reinit()
     input_mode =  ASCII;
     shift_mode =  FALSE;
     mime_decode_mode = FALSE;
-    file_out = FALSE;
+    file_out_f = FALSE;
     crmode_f = 0;
     option_mode = 0;
     broken_counter = 0;
@@ -4865,26 +5607,27 @@ usage()
     fprintf(stderr,"Flags:\n");
     fprintf(stderr,"b,u      Output is buffered (DEFAULT),Output is unbuffered\n");
 #ifdef DEFAULT_CODE_SJIS
-    fprintf(stderr,"j,s,e,w  Outout code is JIS 7 bit, Shift JIS (DEFAULT), AT&T JIS (EUC), UTF-8N\n");
+    fprintf(stderr,"j,s,e,w  Outout code is JIS 7 bit, Shift_JIS (DEFAULT), EUC-JP, UTF-8N\n");
 #endif
 #ifdef DEFAULT_CODE_JIS
-    fprintf(stderr,"j,s,e,w  Outout code is JIS 7 bit (DEFAULT), Shift JIS, AT&T JIS (EUC), UTF-8N\n");
+    fprintf(stderr,"j,s,e,w  Outout code is JIS 7 bit (DEFAULT), Shift JIS, EUC-JP, UTF-8N\n");
 #endif
 #ifdef DEFAULT_CODE_EUC
-    fprintf(stderr,"j,s,e,w  Outout code is JIS 7 bit, Shift JIS, AT&T JIS (EUC) (DEFAULT), UTF-8N\n");
+    fprintf(stderr,"j,s,e,w  Outout code is JIS 7 bit, Shift JIS, EUC-JP (DEFAULT), UTF-8N\n");
 #endif
 #ifdef DEFAULT_CODE_UTF8
-    fprintf(stderr,"j,s,e,w  Outout code is JIS 7 bit, Shift JIS, AT&T JIS (EUC), UTF-8N (DEFAULT)\n");
+    fprintf(stderr,"j,s,e,w  Outout code is JIS 7 bit, Shift JIS, EUC-JP, UTF-8N (DEFAULT)\n");
 #endif
 #ifdef UTF8_OUTPUT_ENABLE
-    fprintf(stderr,"         After 'w' you can add more options. (80?|16((B|L)0?)?) \n");
+    fprintf(stderr,"         After 'w' you can add more options. -w[ 8 [0], 16 [[BL] [0]] ]\n");
 #endif
-    fprintf(stderr,"J,S,E,W  Input assumption is JIS 7 bit , Shift JIS, AT&T JIS (EUC), UTF-8\n");
+    fprintf(stderr,"J,S,E,W  Input assumption is JIS 7 bit , Shift JIS, EUC-JP, UTF-8\n");
 #ifdef UTF8_INPUT_ENABLE
-    fprintf(stderr,"         After 'W' you can add more options. (8|16(B|L)?) \n");
+    fprintf(stderr,"         After 'W' you can add more options. -W[ 8, 16 [BL] ] \n");
 #endif
     fprintf(stderr,"t        no conversion\n");
-    fprintf(stderr,"i_/o_    Output sequence to designate JIS-kanji/ASCII (DEFAULT B)\n");
+    fprintf(stderr,"i[@B]    Specify the Esc Seq for JIS X 0208-1978/83 (DEFAULT B)\n");
+    fprintf(stderr,"o[BJH]   Specify the Esc Seq for ASCII/Roman        (DEFAULT B)\n");
     fprintf(stderr,"r        {de/en}crypt ROT13/47\n");
     fprintf(stderr,"h        1 katakana->hiragana, 2 hiragana->katakana, 3 both\n");
     fprintf(stderr,"v        Show this usage. V: show version\n");
@@ -4892,41 +5635,46 @@ usage()
     fprintf(stderr,"M[BQ]    MIME encode [B:base64 Q:quoted]\n");
     fprintf(stderr,"l        ISO8859-1 (Latin-1) support\n");
     fprintf(stderr,"f/F      Folding: -f60 or -f or -f60-10 (fold margin 10) F preserve nl\n");
-    fprintf(stderr,"Z[0-3]   Convert X0208 alphabet to ASCII  1: Kankaku to space,2: 2 spaces,\n");
-    fprintf(stderr,"                                          3: Convert HTML Entity\n");
+    fprintf(stderr,"Z[0-3]   Convert X0208 alphabet to ASCII\n");
+    fprintf(stderr,"         1: Kankaku to 1 space  2: to 2 spaces  3: Convert to HTML Entity\n");
     fprintf(stderr,"X,x      Assume X0201 kana in MS-Kanji, -x preserves X0201\n");
     fprintf(stderr,"B[0-2]   Broken input  0: missing ESC,1: any X on ESC-[($]-X,2: ASCII on NL\n");
 #ifdef MSDOS
     fprintf(stderr,"T        Text mode output\n");
 #endif
     fprintf(stderr,"O        Output to File (DEFAULT 'nkf.out')\n");
-    fprintf(stderr,"d,c      Delete \\r in line feed and \\032, Add \\r in line feed\n");
     fprintf(stderr,"I        Convert non ISO-2022-JP charactor to GETA\n");
+    fprintf(stderr,"d,c      Convert line breaks  -d: LF  -c: CRLF\n");
     fprintf(stderr,"-L[uwm]  line mode u:LF w:CRLF m:CR (DEFAULT noconversion)\n");
-    fprintf(stderr,"long name options\n");
-    fprintf(stderr," --fj,--unix,--mac,--windows                        convert for the system\n");
-    fprintf(stderr," --jis,--euc,--sjis,--utf8,--utf16,--mime,--base64  convert for the code\n");
-    fprintf(stderr," --hiragana, --katakana    Hiragana/Katakana Conversion\n");
-    fprintf(stderr," --x0212                   Convert JISX0212\n");
-    fprintf(stderr," --cp932, --no-cp932       CP932 compatibility\n");
-    fprintf(stderr," --prefix=    Insert escape before troublesome characters of Shift_JIS\n");
+    fprintf(stderr,"\n");
+    fprintf(stderr,"Long name options\n");
+    fprintf(stderr," --ic=<input codeset>  --oc=<output codeset>\n");
+    fprintf(stderr,"                   Specify the input or output codeset\n");
+    fprintf(stderr," --fj  --unix --mac  --windows\n");
+    fprintf(stderr," --jis  --euc  --sjis  --utf8  --utf16  --mime  --base64\n");
+    fprintf(stderr,"                   Convert for the system or code\n");
+    fprintf(stderr," --hiragana  --katakana  --katakana-hiragana\n");
+    fprintf(stderr,"                   To Hiragana/Katakana Conversion\n");
+    fprintf(stderr," --prefix=         Insert escape before troublesome characters of Shift_JIS\n");
 #ifdef INPUT_OPTION
     fprintf(stderr," --cap-input, --url-input  Convert hex after ':' or '%%'\n");
 #endif
 #ifdef NUMCHAR_OPTION
     fprintf(stderr," --numchar-input   Convert Unicode Character Reference\n");
 #endif
-#ifdef UNICODE_NORMALIZATION
-    fprintf(stderr," --utf8mac-input   UTF-8-MAC input\n");
-#endif
-#ifdef UTF8_OUTPUT_ENABLE
-    fprintf(stderr," --ms-ucs-map      Microsoft UCS Mapping Compatible\n");
+#ifdef UTF8_INPUT_ENABLE
+    fprintf(stderr," --fb-{skip, html, xml, perl, java, subchar}\n");
+    fprintf(stderr,"                   Specify how nkf handles unassigned characters\n");
 #endif
 #ifdef OVERWRITE
-    fprintf(stderr," --overwrite       Overwrite original listed files by filtered result\n");
-#endif
-    fprintf(stderr," -g, --guess       Guess the input code\n");
-    fprintf(stderr," --help,--version\n");
+    fprintf(stderr," --in-place[=SUFFIX]  --overwrite[=SUFFIX]\n");
+    fprintf(stderr,"                   Overwrite original listed files by filtered result\n");
+    fprintf(stderr,"                   --overwrite preserves timestamp of original files\n");
+#endif
+    fprintf(stderr," -g  --guess       Guess the input code\n");
+    fprintf(stderr," --help  --version Show this help/the version\n");
+    fprintf(stderr,"                   For more information, see also man nkf\n");
+    fprintf(stderr,"\n");
     version();
 }
 
diff --git a/ext/nkf/nkf-utf8/utf8tbl.c b/ext/nkf/nkf-utf8/utf8tbl.c
index ef89a7c815..450e877471 100644
--- a/ext/nkf/nkf-utf8/utf8tbl.c
+++ b/ext/nkf/nkf-utf8/utf8tbl.c
@@ -4,14 +4,14 @@
 const unsigned short euc_to_utf8_A1[] = {
          0x3000, 0x3001, 0x3002, 0xFF0C, 0xFF0E, 0x30FB, 0xFF1A,
  0xFF1B, 0xFF1F, 0xFF01, 0x309B, 0x309C, 0x00B4, 0xFF40, 0x00A8,
- 0xFF3E, 0xFFE3, 0xFF3F, 0x30FD, 0x30FE, 0x309D, 0x309E, 0x3003,
- 0x4EDD, 0x3005, 0x3006, 0x3007, 0x30FC, 0x2015, 0x2010, 0xFF0F,
+ 0xFF3E, 0x203E, 0xFF3F, 0x30FD, 0x30FE, 0x309D, 0x309E, 0x3003,
+ 0x4EDD, 0x3005, 0x3006, 0x3007, 0x30FC, 0x2014, 0x2010, 0xFF0F,
  0xFF3C, 0x301C, 0x2016, 0xFF5C, 0x2026, 0x2025, 0x2018, 0x2019,
  0x201C, 0x201D, 0xFF08, 0xFF09, 0x3014, 0x3015, 0xFF3B, 0xFF3D,
  0xFF5B, 0xFF5D, 0x3008, 0x3009, 0x300A, 0x300B, 0x300C, 0x300D,
  0x300E, 0x300F, 0x3010, 0x3011, 0xFF0B, 0x2212, 0x00B1, 0x00D7,
  0x00F7, 0xFF1D, 0x2260, 0xFF1C, 0xFF1E, 0x2266, 0x2267, 0x221E,
- 0x2234, 0x2642, 0x2640, 0x00B0, 0x2032, 0x2033, 0x2103, 0xFFE5,
+ 0x2234, 0x2642, 0x2640, 0x00B0, 0x2032, 0x2033, 0x2103, 0x00A5,
  0xFF04, 0x00A2, 0x00A3, 0xFF05, 0xFF03, 0xFF06, 0xFF0A, 0xFF20,
  0x00A7, 0x2606, 0x2605, 0x25CB, 0x25CF, 0x25CE, 0x25C7,
 };
@@ -1302,7 +1302,7 @@ const unsigned short euc_to_utf8_8FA2[] = {
       0,      0,      0,      0,      0,      0,      0, 0x02D8,
  0x02C7, 0x00B8, 0x02D9, 0x02DD, 0x00AF, 0x02DB, 0x02DA, 0xFF5E,
  0x0384, 0x0385,      0,      0,      0,      0,      0,      0,
-      0,      0, 0x00A1, 0x00A6, 0x00BF,      0,      0,      0,
+      0,      0, 0x00A1, 0xFFE4, 0x00BF,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
@@ -2249,6 +2249,34 @@ const unsigned short euc_to_utf8_8FED[] = {
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,
 };
+const unsigned short euc_to_utf8_8FF3[] = {
+              0,      0,      0,      0,      0,      0,      0,
+      0,      0,      0,      0,      0,      0,      0,      0,
+      0,      0,      0,      0,      0,      0,      0,      0,
+      0,      0,      0,      0,      0,      0,      0,      0,
+      0,      0,      0,      0,      0,      0,      0,      0,
+      0,      0,      0,      0,      0,      0,      0,      0,
+      0,      0,      0,      0,      0,      0,      0,      0,
+      0,      0,      0,      0,      0,      0,      0,      0,
+      0,      0,      0,      0,      0,      0,      0,      0,
+      0,      0,      0,      0,      0,      0,      0,      0,
+      0,      0,      0, 0x2170, 0x2171, 0x2172, 0x2173, 0x2174,
+ 0x2175, 0x2176, 0x2177, 0x2178, 0x2179, 0x2160, 0x2161,
+};
+const unsigned short euc_to_utf8_8FF4[] = {
+            0x2162, 0x2163, 0x2164, 0x2165, 0x2166, 0x2167, 0x2168,
+    0x2169, 0xff07, 0xff02, 0x3231, 0x2116, 0x2121, 0x70bb, 0x4efc,
+    0x50f4, 0x51ec, 0x5307, 0x5324, 0xfa0e, 0x548a, 0x5759, 0xfa0f,
+    0xfa10, 0x589e, 0x5bec, 0x5cf5, 0x5d53, 0xfa11, 0x5fb7, 0x6085,
+    0x6120, 0x654e, 0x663b, 0x6665, 0xfa12, 0xf929, 0x6801, 0xfa13,
+    0xfa14, 0x6a6b, 0x6ae2, 0x6df8, 0x6df2, 0x7028, 0xfa15, 0xfa16,
+    0x7501, 0x7682, 0x769e, 0xfa17, 0x7930, 0xfa18, 0xfa19, 0xfa1a,
+    0xfa1b, 0x7ae7, 0xfa1c, 0xfa1d, 0x7da0, 0x7dd6, 0xfa1e, 0x8362,
+    0xfa1f, 0x85b0, 0xfa20, 0xfa21, 0x8807, 0xfa22, 0x8b7f, 0x8cf4,
+    0x8d76, 0xfa23, 0xfa24, 0xfa25, 0x90de, 0xfa26, 0x9115, 0xfa27,
+    0xfa28, 0x9592, 0xf9dc, 0xfa29, 0x973b, 0x974d, 0x9751, 0xfa2a,
+    0xfa2b, 0xfa2c, 0x999e, 0x9ad9, 0x9b72, 0xfa2d, 0x9ed1,
+};
 #endif /* X0212_ENABLE */
 
 const unsigned short euc_to_utf8_1byte[] = {
@@ -2341,8 +2369,8 @@ const unsigned short *const x0212_to_utf8_2bytes[] = {
  euc_to_utf8_8FE4, euc_to_utf8_8FE5, euc_to_utf8_8FE6, euc_to_utf8_8FE7,
  euc_to_utf8_8FE8, euc_to_utf8_8FE9, euc_to_utf8_8FEA, euc_to_utf8_8FEB,
  euc_to_utf8_8FEC, euc_to_utf8_8FED,              0,              0,
-              0,              0,              0,              0,
-              0,              0,              0,              0,
+              0,              0,              0,       euc_to_utf8_8FF3,
+ euc_to_utf8_8FF4,            0,              0,              0,
               0,              0,              0,              0,
               0,              0,              0,};
 #endif /* X0212_ENABLE */
@@ -2354,11 +2382,31 @@ const unsigned short utf8_to_euc_C2[] = {
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
- 0x0E20, 0xA242, 0x2171, 0x2172, 0xA270,      0, 0xA243, 0x2178,
- 0x212F, 0x0E7D, 0xA26C,      0, 0x224C,      0, 0xA26E, 0xA234,
+      0, 0xA242, 0x2171, 0x2172, 0xA270, 0x216F, 0xA243, 0x2178,
+ 0x212F, 0xA26D, 0xA26C,      0, 0x224C,      0, 0xA26E, 0xA234,
+ 0x216B, 0x215E,      0,      0, 0x212D,      0, 0x2279,      0,
+ 0xA231,      0, 0xA26B,      0,      0,      0,      0, 0xA244,
+};
+const unsigned short utf8_to_euc_C2_ms[] = {
+      0,      0,      0,      0,      0,      0,      0,      0,
+      0,      0,      0,      0,      0,      0,      0,      0,
+      0,      0,      0,      0,      0,      0,      0,      0,
+      0,      0,      0,      0,      0,      0,      0,      0,
+      0, 0xA242, 0x2171, 0x2172, 0xA270,   0x5C, 0xA243, 0x2178,
+ 0x212F, 0xA26D, 0xA26C,      0, 0x224C,      0, 0xA26E, 0xA234,
  0x216B, 0x215E,      0,      0, 0x212D,      0, 0x2279,      0,
  0xA231,      0, 0xA26B,      0,      0,      0,      0, 0xA244,
 };
+const unsigned short utf8_to_euc_C2_932[] = {
+      0,      0,      0,      0,      0,      0,      0,      0,
+      0,      0,      0,      0,      0,      0,      0,      0,
+      0,      0,      0,      0,      0,      0,      0,      0,
+      0,      0,      0,      0,      0,      0,      0,      0,
+      0,   0x21, 0x2171, 0x2172,      0,   0x5C,   0x7C, 0x2178,
+ 0x212F,   0x63,   0x61, 0x2263, 0x224C,   0x2D,   0x52, 0x2131,
+ 0x216B, 0x215E,   0x32,   0x33, 0x212D, 0x264C, 0x2279, 0x2126,
+ 0x2124,   0x31,   0x6F, 0x2264,      0,      0,      0,      0,
+};
 const unsigned short utf8_to_euc_C3[] = {
  0xAA22, 0xAA21, 0xAA24, 0xAA2A, 0xAA23, 0xAA29, 0xA921, 0xAA2E,
  0xAA32, 0xAA31, 0xAA34, 0xAA33, 0xAA40, 0xAA3F, 0xAA42, 0xAA41,
@@ -2369,6 +2417,16 @@ const unsigned short utf8_to_euc_C3[] = {
  0xA943, 0xAB50, 0xAB52, 0xAB51, 0xAB54, 0xAB58, 0xAB53, 0x2160,
  0xA94C, 0xAB63, 0xAB62, 0xAB65, 0xAB64, 0xAB72, 0xA950, 0xAB73,
 };
+const unsigned short utf8_to_euc_C3_932[] = {
+   0x41,   0x41,   0x41,   0x41,   0x41,   0x41,   0x41,   0x43,
+   0x45,   0x45,   0x45,   0x45,   0x49,   0x49,   0x49,   0x49,
+   0x44,   0x4E,   0x4F,   0x4F,   0x4F,   0x4F,   0x4F, 0x215F,
+   0x4F,   0x55,   0x55,   0x55,   0x55,   0x59,   0x54,   0x73,
+   0x61,   0x61,   0x61,   0x61,   0x61,   0x61,   0x61,   0x63,
+   0x65,   0x65,   0x65,   0x65,   0x69,   0x69,   0x69,   0x69,
+   0x64,   0x6E,   0x6F,   0x6F,   0x6F,   0x6F,   0x6F, 0x2160,
+   0x6F,   0x75,   0x75,   0x75,   0x75,   0x79,   0x74,   0x79,
+};
 const unsigned short utf8_to_euc_C4[] = {
  0xAA27, 0xAB27, 0xAA25, 0xAB25, 0xAA28, 0xAB28, 0xAA2B, 0xAB2B,
  0xAA2C, 0xAB2C, 0xAA2F, 0xAB2F, 0xAA2D, 0xAB2D, 0xAA30, 0xAB30,
@@ -2454,6 +2512,26 @@ const unsigned short utf8_to_euc_E280[] = {
       0,      0,      0,      0,      0,      0,      0,      0,
  0x213E,      0,      0,      0, 0x213D, 0x213D, 0x2142,      0,
  0x2146, 0x2147,      0,      0, 0x2148, 0x2149,      0,      0,
+ 0x2277, 0x2278,      0,      0,      0, 0x2145, 0x2144,      0,
+      0,      0,      0,      0,      0,      0,      0,      0,
+ 0x2273,      0, 0x216C, 0x216D,      0,      0,      0,      0,
+      0,      0,      0, 0x2228,      0,      0, 0x2131,      0,
+};
+const unsigned short utf8_to_euc_E280_ms[] = {
+      0,      0,      0,      0,      0,      0,      0,      0,
+      0,      0,      0,      0,      0,      0,      0,      0,
+ 0x213E,      0,      0,      0, 0x213D, 0x213D, 0x2142,      0,
+ 0x2146, 0x2147,      0,      0, 0x2148, 0x2149,      0,      0,
+ 0x2277, 0x2278,      0,      0,      0, 0x2145, 0x2144,      0,
+      0,      0,      0,      0,      0,      0,      0,      0,
+ 0x2273,      0, 0x216C, 0x216D,      0,      0,      0,      0,
+      0,      0,      0, 0x2228,      0,      0,   0x7E,      0,
+};
+const unsigned short utf8_to_euc_E280_932[] = {
+      0,      0,      0,      0,      0,      0,      0,      0,
+      0,      0,      0,      0,      0,      0,      0,      0,
+ 0x213E,      0,      0,      0,      0, 0x213D,      0,      0,
+ 0x2146, 0x2147,      0,      0, 0x2148, 0x2149,      0,      0,
  0x2277, 0x2278,      0,      0,      0, 0x2145, 0x2144,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
  0x2273,      0, 0x216C, 0x216D,      0,      0,      0,      0,
@@ -2461,10 +2539,10 @@ const unsigned short utf8_to_euc_E280[] = {
 };
 const unsigned short utf8_to_euc_E284[] = {
       0,      0,      0, 0x216E,      0,      0,      0,      0,
-      0, 0x2B37,      0,      0,      0,      0,      0,      0,
-      0,      0,      0, 0x2B31,      0,      0, 0x2D62,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
-      0, 0x2D64, 0x0E7E,      0,      0,      0,      0,      0,
+      0,      0,      0,      0,      0,      0, 0x2D62,      0,
+      0,      0,      0,      0,      0,      0,      0,      0,
+      0, 0x2D64, 0xA26F,      0,      0,      0,      0,      0,
       0,      0,      0, 0x2272,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
@@ -2475,9 +2553,9 @@ const unsigned short utf8_to_euc_E285[] = {
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
  0x2D35, 0x2D36, 0x2D37, 0x2D38, 0x2D39, 0x2D3A, 0x2D3B, 0x2D3C,
- 0x2D3D, 0x2D3E, 0x2A2B, 0x2A2C,      0,      0,      0,      0,
- 0x7C71, 0x7C72, 0x7C73, 0x7C74, 0x7C75, 0x7C76, 0x7C77, 0x7C78,
- 0x7C79, 0x7C7A, 0x2A3F, 0x2A40,      0,      0,      0,      0,
+ 0x2D3D, 0x2D3E,      0,      0,      0,      0,      0,      0,
+ 0xF373, 0xF374, 0xF375, 0xF376, 0xF377, 0xF378, 0xF379, 0xF37A,
+ 0xF37B, 0xF37C,      0,      0,      0,      0,      0,      0,
 };
 const unsigned short utf8_to_euc_E286[] = {
       0,      0,      0,      0,      0,      0,      0,      0,
@@ -2490,12 +2568,12 @@ const unsigned short utf8_to_euc_E286[] = {
       0,      0,      0,      0,      0,      0,      0,      0,
 };
 const unsigned short utf8_to_euc_E287[] = {
-      0,      0,      0,      0, 0x2C4E, 0x2C4F, 0x2C4D,      0,
+      0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0, 0x224D,      0, 0x224E,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
-      0,      0,      0,      0,      0,      0, 0x2C52, 0x2C53,
- 0x2C51, 0x2C54,      0,      0,      0,      0,      0,      0,
+      0,      0,      0,      0,      0,      0,      0,      0,
+      0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
 };
@@ -2509,6 +2587,16 @@ const unsigned short utf8_to_euc_E288[] = {
       0,      0,      0,      0, 0x2168, 0x2268,      0,      0,
       0,      0,      0,      0,      0, 0x2266,      0,      0,
 };
+const unsigned short utf8_to_euc_E288_932[] = {
+ 0x224F,      0, 0x225F, 0x2250,      0,      0,      0, 0x2260,
+ 0x223A,      0,      0, 0x223B,      0,      0,      0,      0,
+      0, 0x2D74,      0,      0,      0,      0,      0,      0,
+      0,      0, 0x2265,      0,      0, 0x2267, 0x2167, 0x2D78,
+ 0x225C,      0,      0,      0,      0, 0x2142,      0, 0x224A,
+ 0x224B, 0x2241, 0x2240, 0x2269, 0x226A,      0, 0x2D73,      0,
+      0,      0,      0,      0, 0x2168, 0x2268,      0,      0,
+      0,      0,      0,      0,      0, 0x2266,      0,      0,
+};
 const unsigned short utf8_to_euc_E289[] = {
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
@@ -2546,17 +2634,7 @@ const unsigned short utf8_to_euc_E291[] = {
       0,      0,      0,      0,      0,      0,      0,      0,
  0x2D21, 0x2D22, 0x2D23, 0x2D24, 0x2D25, 0x2D26, 0x2D27, 0x2D28,
  0x2D29, 0x2D2A, 0x2D2B, 0x2D2C, 0x2D2D, 0x2D2E, 0x2D2F, 0x2D30,
- 0x2D31, 0x2D32, 0x2D33, 0x2D34, 0x293F, 0x2940, 0x2941, 0x2942,
- 0x2943, 0x2944, 0x2945, 0x2946, 0x2947, 0x2948, 0x2949, 0x294A,
-};
-const unsigned short utf8_to_euc_E292[] = {
- 0x294B, 0x294C, 0x294D, 0x294E, 0x294F, 0x2950, 0x2951, 0x2952,
- 0x2972, 0x2973, 0x2974, 0x2975, 0x2976, 0x2977, 0x2978, 0x2979,
- 0x297A,      0,      0,      0,      0,      0,      0,      0,
-      0,      0,      0,      0, 0x2A5D, 0x2A5E, 0x2A5F, 0x2A60,
- 0x2A61, 0x2A62, 0x2A63, 0x2A64, 0x2A65, 0x2A66, 0x2A67, 0x2A68,
- 0x2A69, 0x2A6A, 0x2A6B, 0x2A6C, 0x2A6D, 0x2A6E, 0x2A6F, 0x2A70,
- 0x2A71, 0x2A72, 0x2A73, 0x2A74, 0x2A75, 0x2A76,      0,      0,
+ 0x2D31, 0x2D32, 0x2D33, 0x2D34,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
 };
 const unsigned short utf8_to_euc_E294[] = {
@@ -2601,9 +2679,9 @@ const unsigned short utf8_to_euc_E297[] = {
 };
 const unsigned short utf8_to_euc_E298[] = {
       0,      0,      0,      0,      0, 0x217A, 0x2179,      0,
-      0,      0,      0,      0,      0,      0, 0x2C36,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
-      0,      0,      0,      0, 0x2C4A, 0x2C4B, 0x2C49, 0x2C4C,
+      0,      0,      0,      0,      0,      0,      0,      0,
+      0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
@@ -2614,27 +2692,27 @@ const unsigned short utf8_to_euc_E299[] = {
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
- 0x2C25, 0x2C23, 0x2C24, 0x2C26, 0x2C21, 0x2C27, 0x2C28, 0x2C22,
+      0,      0,      0,      0,      0,      0,      0,      0,
       0,      0, 0x2276,      0,      0, 0x2275,      0, 0x2274,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
 };
-const unsigned short utf8_to_euc_E29D[] = {
-      0,      0,      0,      0,      0,      0,      0,      0,
-      0,      0,      0,      0,      0,      0,      0,      0,
+const unsigned short utf8_to_euc_E380[] = {
+ 0x2121, 0x2122, 0x2123, 0x2137,      0, 0x2139, 0x213A, 0x213B,
+ 0x2152, 0x2153, 0x2154, 0x2155, 0x2156, 0x2157, 0x2158, 0x2159,
+ 0x215A, 0x215B, 0x2229, 0x222E, 0x214C, 0x214D,      0,      0,
+      0,      0,      0,      0, 0x2141, 0x2D60,      0, 0x2D61,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
-      0,      0,      0,      0,      0,      0, 0x295D, 0x295E,
- 0x295F, 0x2960, 0x2961, 0x2962, 0x2963, 0x2964, 0x2965,      0,
 };
-const unsigned short utf8_to_euc_E380[] = {
- 0x2121, 0x2122, 0x2123, 0x2137, 0x2C37, 0x2139, 0x213A, 0x213B,
+const unsigned short utf8_to_euc_E380_932[] = {
+ 0x2121, 0x2122, 0x2123, 0x2137,      0, 0x2139, 0x213A, 0x213B,
  0x2152, 0x2153, 0x2154, 0x2155, 0x2156, 0x2157, 0x2158, 0x2159,
  0x215A, 0x215B, 0x2229, 0x222E, 0x214C, 0x214D,      0,      0,
-      0,      0,      0,      0, 0x2141, 0x2D60,      0, 0x2D61,
- 0x2C35,      0,      0,      0,      0,      0,      0,      0,
+      0,      0,      0,      0,      0, 0x2D60,      0, 0x2D61,
+      0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
@@ -2652,8 +2730,18 @@ const unsigned short utf8_to_euc_E381[] = {
 const unsigned short utf8_to_euc_E382[] = {
  0x2460, 0x2461, 0x2462, 0x2463, 0x2464, 0x2465, 0x2466, 0x2467,
  0x2468, 0x2469, 0x246A, 0x246B, 0x246C, 0x246D, 0x246E, 0x246F,
- 0x2470, 0x2471, 0x2472, 0x2473, 0x2F49,      0,      0,      0,
-      0, 0x0E5E, 0x0E5F, 0x212B, 0x212C, 0x2135, 0x2136,      0,
+ 0x2470, 0x2471, 0x2472, 0x2473,      0,      0,      0,      0,
+      0,      0,      0, 0x212B, 0x212C, 0x2135, 0x2136,      0,
+      0, 0x2521, 0x2522, 0x2523, 0x2524, 0x2525, 0x2526, 0x2527,
+ 0x2528, 0x2529, 0x252A, 0x252B, 0x252C, 0x252D, 0x252E, 0x252F,
+ 0x2530, 0x2531, 0x2532, 0x2533, 0x2534, 0x2535, 0x2536, 0x2537,
+ 0x2538, 0x2539, 0x253A, 0x253B, 0x253C, 0x253D, 0x253E, 0x253F,
+};
+const unsigned short utf8_to_euc_E382_932[] = {
+ 0x2460, 0x2461, 0x2462, 0x2463, 0x2464, 0x2465, 0x2466, 0x2467,
+ 0x2468, 0x2469, 0x246A, 0x246B, 0x246C, 0x246D, 0x246E, 0x246F,
+ 0x2470, 0x2471, 0x2472, 0x2473, 0x2574,      0,      0,      0,
+      0,      0,      0, 0x212B, 0x212C, 0x2135, 0x2136,      0,
       0, 0x2521, 0x2522, 0x2523, 0x2524, 0x2525, 0x2526, 0x2527,
  0x2528, 0x2529, 0x252A, 0x252B, 0x252C, 0x252D, 0x252E, 0x252F,
  0x2530, 0x2531, 0x2532, 0x2533, 0x2534, 0x2535, 0x2536, 0x2537,
@@ -2666,73 +2754,63 @@ const unsigned short utf8_to_euc_E383[] = {
  0x2558, 0x2559, 0x255A, 0x255B, 0x255C, 0x255D, 0x255E, 0x255F,
  0x2560, 0x2561, 0x2562, 0x2563, 0x2564, 0x2565, 0x2566, 0x2567,
  0x2568, 0x2569, 0x256A, 0x256B, 0x256C, 0x256D, 0x256E, 0x256F,
- 0x2570, 0x2571, 0x2572, 0x2573, 0x2574, 0x2575, 0x2576, 0x2F4B,
- 0x2F4C, 0x2F4D, 0x2F4E, 0x2126, 0x213C, 0x2133, 0x2134,      0,
+ 0x2570, 0x2571, 0x2572, 0x2573, 0x2574, 0x2575, 0x2576,      0,
+      0,      0,      0, 0x2126, 0x213C, 0x2133, 0x2134,      0,
 };
 const unsigned short utf8_to_euc_E388[] = {
-      0,      0,      0,      0,      0,      0,      0,      0,
-      0,      0,      0,      0,      0,      0,      0,      0,
-      0,      0,      0,      0,      0,      0,      0,      0,
-      0,      0,      0,      0,      0,      0,      0,      0,
-      0,      0,      0,      0,      0,      0,      0,      0,
-      0,      0, 0x2D22, 0x2D23, 0x2D24, 0x2D25, 0x2D26, 0x2D27,
- 0x2D21, 0x2D6A, 0x2D6B, 0x2D34, 0x2D30, 0x2D35, 0x2D33, 0x2D29,
- 0x2D39, 0x2D6C, 0x2D2D, 0x2D32, 0x2D36, 0x2D37, 0x2D2F, 0x2D38,
-};
-const unsigned short utf8_to_euc_E389[] = {
- 0x2D28,      0, 0x2D2A, 0x2D2B,      0,      0,      0,      0,
-      0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
+      0, 0x2D6A, 0x2D6B,      0,      0,      0,      0,      0,
+      0, 0x2D6C,      0,      0,      0,      0,      0,      0,
 };
 const unsigned short utf8_to_euc_E38A[] = {
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
-      0,      0,      0,      0,      0,      0, 0x2D79,      0,
- 0x2D7B, 0x2D7E,      0,      0,      0, 0x2D7A, 0x2D7C,      0,
+      0,      0,      0,      0,      0,      0,      0,      0,
+      0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0, 0x2D65, 0x2D66, 0x2D67, 0x2D68,
- 0x2D69, 0x2D78,      0,      0,      0,      0,      0,      0,
+ 0x2D69,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
 };
 const unsigned short utf8_to_euc_E38C[] = {
- 0x2E3F,      0,      0, 0x2D46,      0, 0x2E26,      0,      0,
+      0,      0,      0, 0x2D46,      0,      0,      0,      0,
       0,      0,      0,      0,      0, 0x2D4A,      0,      0,
-      0,      0,      0,      0, 0x2D41, 0x2E2C, 0x2E25,      0,
- 0x2D44,      0,      0,      0,      0,      0, 0x2E40,      0,
+      0,      0,      0,      0, 0x2D41,      0,      0,      0,
+ 0x2D44,      0,      0,      0,      0,      0,      0,      0,
       0,      0, 0x2D42, 0x2D4C,      0,      0, 0x2D4B, 0x2D45,
-      0,      0, 0x2E41, 0x2D4D,      0,      0,      0,      0,
-      0, 0x2E42,      0, 0x2E27,      0,      0, 0x2D47,      0,
-      0, 0x2E30,      0, 0x2D4F,      0,      0,      0,      0,
+      0,      0,      0, 0x2D4D,      0,      0,      0,      0,
+      0,      0,      0,      0,      0,      0, 0x2D47,      0,
+      0,      0,      0, 0x2D4F,      0,      0,      0,      0,
 };
 const unsigned short utf8_to_euc_E38D[] = {
-      0,      0, 0x2E33,      0,      0,      0,      0, 0x2E43,
-      0, 0x2D40, 0x2D4E,      0,      0, 0x2D43, 0x2E28,      0,
+      0,      0,      0,      0,      0,      0,      0,      0,
+      0, 0x2D40, 0x2D4E,      0,      0, 0x2D43,      0,      0,
       0, 0x2D48,      0,      0,      0,      0,      0, 0x2D49,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
-      0,      0,      0, 0x2D5F, 0x2D6F, 0x2D6E, 0x2D6D, 0x2E7C,
+      0,      0,      0, 0x2D5F, 0x2D6F, 0x2D6E, 0x2D6D,      0,
 };
 const unsigned short utf8_to_euc_E38E[] = {
-      0,      0,      0,      0,      0, 0x2B3B, 0x2B3C, 0x2B3D,
+      0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0, 0x2D53, 0x2D54,
- 0x2B3A,      0,      0,      0,      0,      0, 0x2B2F, 0x2B30,
- 0x2B32,      0,      0,      0, 0x2D50, 0x2D51, 0x2D52, 0x2B22,
- 0x2B24, 0x2D56, 0x2B2A,      0, 0x2B25, 0x2B28,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
- 0x2B36, 0x2B35, 0x2B34, 0x2B33,      0,      0,      0,      0,
+      0,      0,      0,      0, 0x2D50, 0x2D51, 0x2D52,      0,
+      0, 0x2D56,      0,      0,      0,      0,      0,      0,
+      0,      0,      0,      0,      0,      0,      0,      0,
+      0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
 };
 const unsigned short utf8_to_euc_E38F[] = {
       0,      0,      0,      0, 0x2D55,      0,      0,      0,
-      0,      0,      0, 0x2B39,      0, 0x2D63,      0,      0,
-      0,      0,      0,      0, 0x2B38,      0,      0,      0,
+      0,      0,      0,      0,      0, 0x2D63,      0,      0,
+      0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
@@ -2745,7 +2823,7 @@ const unsigned short utf8_to_euc_E4B8[] = {
  0x5022, 0x312F, 0xB025,      0, 0x336E, 0x5023, 0x4024, 0x5242,
  0x3556, 0x4A3A,      0,      0,      0,      0, 0x3E67, 0xB026,
       0, 0x4E3E,      0, 0xB027, 0xB028,      0, 0x4A42,      0,
- 0x792D,      0, 0x5024, 0xB02A,      0, 0x4366, 0xB02B, 0xB02C,
+ 0xB029,      0, 0x5024, 0xB02A,      0, 0x4366, 0xB02B, 0xB02C,
  0xB02D, 0x5025, 0x367A,      0,      0, 0xB02E, 0x5026,      0,
  0x345D, 0x4330,      0, 0x3C67, 0x5027,      0,      0, 0x5028,
 };
@@ -2774,25 +2852,25 @@ const unsigned short utf8_to_euc_E4BB[] = {
       0,      0, 0x3A23, 0x3270,      0, 0x503B, 0x503A, 0x4A29,
  0xB044,      0,      0,      0, 0x3B46, 0x3B45, 0x423E, 0x503F,
  0x4955, 0x4067, 0xB045, 0xB046,      0, 0x2138, 0x5040, 0x5042,
- 0xB047, 0x792E, 0xB049, 0x4265, 0x4E61, 0x304A,      0,      0,
+ 0xB047, 0xB048, 0xB049, 0x4265, 0x4E61, 0x304A,      0,      0,
  0xB04A,      0,      0,      0,      0, 0x5041, 0x323E, 0xB04B,
  0x3644, 0xB04C, 0x4367, 0xB04D,      0, 0xB04E, 0x376F, 0x5043,
-      0,      0,      0, 0x4724, 0x792F, 0xB04F, 0xB050, 0xB051,
+      0,      0,      0, 0x4724, 0xF42F, 0xB04F, 0xB050, 0xB051,
 };
 const unsigned short utf8_to_euc_E4BC[] = {
- 0x7930, 0x346B, 0xB053, 0x7931,      0,      0,      0,      0,
+ 0xB052, 0x346B, 0xB053, 0xB054,      0,      0,      0,      0,
  0xB055, 0x5044, 0x304B, 0xB056, 0xB057, 0x3860, 0x346C, 0x497A,
  0x4832, 0x3559, 0xB058,      0,      0, 0xB059, 0xB05A, 0xB05B,
       0, 0xB05C, 0x3271,      0, 0x5067, 0x4541,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0, 0xB05D, 0x476C,
  0x5046, 0xB05E,      0, 0xB060, 0x483C, 0xB061, 0x4E62, 0xB062,
- 0x3F2D, 0x7932, 0x3B47, 0xB064, 0x3B77, 0x3240, 0xB065,      0,
+ 0x3F2D, 0xB063, 0x3B47, 0xB064, 0x3B77, 0x3240, 0xB065,      0,
 };
 const unsigned short utf8_to_euc_E4BD[] = {
  0xB066,      0, 0xB067, 0x4451,      0,      0, 0x4322, 0x504A,
  0xB068, 0xB069,      0, 0xB06A, 0xB06B, 0x304C, 0x4463, 0x3D3B,
- 0x3A34, 0x4D24, 0xB06C, 0x424E, 0xB06D, 0x323F, 0x7933, 0x5049,
+ 0x3A34, 0x4D24, 0xB06C, 0x424E, 0xB06D, 0x323F, 0xB06E, 0x5049,
  0xB06F, 0x4D3E, 0x5045, 0x5047, 0x3A6E, 0x5048, 0x5524, 0xB070,
  0xB05F,      0,      0, 0xB071,      0,      0,      0,      0,
       0, 0x5050, 0xB072,      0, 0xB073,      0, 0xB074, 0x5053,
@@ -2801,9 +2879,9 @@ const unsigned short utf8_to_euc_E4BD[] = {
 };
 const unsigned short utf8_to_euc_E4BE[] = {
       0, 0xB07C, 0xB07D, 0x3426, 0xB07E, 0xB121, 0x5054,      0,
- 0x504C, 0xB122, 0x7935, 0x4E63, 0xB124, 0x3B78, 0xB125, 0x504D,
- 0xB126, 0x5052, 0x7934, 0xB128, 0x7937,      0, 0x5055, 0xB12A,
- 0x504E, 0xB12B, 0x7936, 0x3621,      0, 0x304D, 0xB12D, 0xB12E,
+ 0x504C, 0xB122, 0xB123, 0x4E63, 0xB124, 0x3B78, 0xB125, 0x504D,
+ 0xB126, 0x5052, 0xB127, 0xB128, 0xB129,      0, 0x5055, 0xB12A,
+ 0x504E, 0xB12B, 0xB12C, 0x3621,      0, 0x304D, 0xB12D, 0xB12E,
  0x3622, 0x3241,      0,      0,      0,      0,      0,      0,
       0,      0,      0, 0x5525,      0, 0x4B79, 0x496E, 0x3874,
       0,      0, 0xB12F,      0,      0, 0x3F2F, 0x4E37, 0xB130,
@@ -2811,38 +2889,38 @@ const unsigned short utf8_to_euc_E4BE[] = {
 };
 const unsigned short utf8_to_euc_E4BF[] = {
  0xB136, 0xB137, 0x3738, 0x4225, 0x3264, 0xB138, 0xB139,      0,
- 0xB13A, 0x7926, 0x3D53, 0xB13C, 0xB13D, 0x7938, 0x5059, 0xB13F,
+ 0xB13A, 0xB13B, 0x3D53, 0xB13C, 0xB13D, 0xB13E, 0x5059, 0xB13F,
  0x505E, 0x505C, 0xB140,      0, 0x5057,      0,      0, 0x422F,
  0x505A,      0, 0x505D, 0x505B, 0xB141, 0x4A5D,      0, 0x5058,
  0xB142, 0x3F2E, 0xB143, 0x4B73, 0x505F, 0x5060,      0,      0,
       0,      0,      0,      0,      0,      0, 0x3D24, 0x506D,
  0xB144,      0, 0xB145, 0x4750,      0, 0x4936, 0x5068,      0,
- 0x4A70,      0, 0x3236,      0, 0xB146, 0xB147, 0x506C, 0x793B,
+ 0x4A70,      0, 0x3236,      0, 0xB146, 0xB147, 0x506C, 0xB148,
 };
 const unsigned short utf8_to_euc_E580[] = {
  0xB149, 0xB14A,      0,      0, 0xB14B, 0x5066, 0x506F, 0xB14C,
       0, 0x4152, 0xB14D, 0x3844, 0xB14E, 0x475C, 0xB14F, 0x6047,
  0xB150, 0x506E, 0x455D, 0xB151, 0x5063,      0, 0x3876, 0xB152,
- 0xB153, 0x3875, 0x5061, 0xB154, 0xB155, 0xB156, 0x793C, 0x3C5A,
-      0, 0x5069, 0x793A, 0x4A6F, 0x434D, 0x5065, 0x3771, 0xB159,
+ 0xB153, 0x3875, 0x5061, 0xB154, 0xB155, 0xB156, 0xB157, 0x3C5A,
+      0, 0x5069, 0xB158, 0x4A6F, 0x434D, 0x5065, 0x3771, 0xB159,
  0x5062, 0x506A, 0x5064, 0x4E51, 0x506B, 0x4F41, 0xB15A,      0,
  0xB15B,      0, 0xB15C, 0xB15D,      0, 0xB15E, 0x3666,      0,
       0, 0x3770,      0, 0xB176,      0,      0,      0,      0,
 };
 const unsigned short utf8_to_euc_E581[] = {
- 0x7939, 0xB160, 0x793F, 0x5070,      0, 0xB162, 0x793D, 0x5071,
+ 0xB15F, 0xB160, 0xB161, 0x5070,      0, 0xB162, 0xB163, 0x5071,
  0x5075, 0x304E, 0xB164,      0, 0xB165,      0, 0xB166, 0x4A50,
  0x5074, 0xB167, 0xB168, 0xB169,      0, 0x5073, 0x5077, 0xB16A,
       0, 0xB16B, 0x5076,      0, 0x4464,      0,      0, 0xB16C,
  0xB16D,      0, 0xB16E, 0xB16F,      0, 0x3772, 0xB170, 0xB171,
       0,      0, 0xB172,      0, 0x5078, 0xB173,      0,      0,
- 0x793E, 0xB175, 0x3C45,      0, 0x4226, 0x4465, 0x3676,      0,
+ 0xB174, 0xB175, 0x3C45,      0, 0x4226, 0x4465, 0x3676,      0,
  0x5079,      0,      0,      0,      0, 0x3536,      0,      0,
 };
 const unsigned short utf8_to_euc_E582[] = {
  0x507A, 0xB177,      0, 0xB178, 0xB179, 0x507C, 0xB17A,      0,
       0,      0, 0xB17B,      0,      0, 0x4B35, 0xB17C, 0xB17D,
- 0xB17E, 0x3766, 0xB221, 0xB222, 0x7940,      0, 0xB224,      0,
+ 0xB17E, 0x3766, 0xB221, 0xB222, 0xB223,      0, 0xB224,      0,
  0x3B31, 0x4877, 0x507B, 0xB225, 0xB226,      0, 0xB227, 0xB228,
  0xB229, 0xB22A, 0xB22B,      0,      0,      0,      0,      0,
       0,      0, 0xB22C,      0, 0x3A45, 0x4D43,      0, 0xB22D,
@@ -2853,10 +2931,10 @@ const unsigned short utf8_to_euc_E583[] = {
  0xB232,      0, 0x5124, 0xB233, 0xB234, 0x364F,      0, 0xB235,
       0, 0x5121, 0x5122,      0, 0xB236, 0x462F, 0xB237, 0x417C,
  0xB238, 0x3623,      0, 0xB239, 0xB23A, 0x4B4D, 0x5125,      0,
- 0x7942,      0, 0x4E3D,      0, 0xB23C, 0xB23D, 0x5126, 0xB23E,
+ 0xB23B,      0, 0x4E3D,      0, 0xB23C, 0xB23D, 0x5126, 0xB23E,
       0,      0, 0xB23F, 0x5129, 0xB240, 0x5127, 0xB241, 0x414E,
  0xB242, 0xB243,      0,      0,      0, 0x5128, 0x512A, 0xB244,
-      0, 0xB245, 0xB251,      0, 0x7941, 0x512C, 0xB246,      0,
+      0, 0xB245, 0xB251,      0, 0xF430, 0x512C, 0xB246,      0,
       0, 0x512B, 0xB247, 0x4A48,      0,      0, 0xB248,      0,
 };
 const unsigned short utf8_to_euc_E584[] = {
@@ -2871,10 +2949,10 @@ const unsigned short utf8_to_euc_E584[] = {
 };
 const unsigned short utf8_to_euc_E585[] = {
  0x513A, 0x3074, 0xB265, 0x3835, 0x373B, 0x3D3C, 0x437B, 0x3624,
- 0x4068, 0x3877, 0x7943, 0x396E, 0x513C, 0x4C48, 0x4546, 0xB267,
+ 0x4068, 0x3877, 0xB266, 0x396E, 0x513C, 0x4C48, 0x4546, 0xB267,
  0x3B79,      0, 0x513B, 0xB268, 0x513D, 0xB269,      0, 0xB26A,
  0xB26B,      0, 0x455E,      0, 0x3375,      0,      0, 0xB26C,
-      0,      0, 0x513E,      0, 0x7944, 0x467E, 0xB26E,      0,
+      0,      0, 0x513E,      0, 0xB26D, 0x467E, 0xB26E,      0,
  0x4134, 0x5140, 0x5141, 0x482C, 0x3878, 0x4F3B, 0x5142,      0,
       0, 0x3626,      0,      0,      0, 0x4A3C, 0x4236, 0x3671,
  0x4535,      0,      0,      0, 0x3773,      0, 0xB26F,      0,
@@ -2883,11 +2961,11 @@ const unsigned short utf8_to_euc_E586[] = {
  0x5143,      0, 0x5144, 0xB270, 0xB271, 0x4662, 0x315F,      0,
       0, 0x5147, 0x3A7D, 0xB272, 0x5146, 0x3A46, 0xB273, 0x5148,
  0x666E, 0x5149, 0x4B41, 0x514A,      0, 0x514B, 0x514C, 0x3E69,
- 0xB274, 0x3C4C,      0,      0,      0, 0x7945,      0,      0,
+ 0xB274, 0x3C4C,      0,      0,      0, 0xB275,      0,      0,
  0x3427, 0xB276, 0x514F, 0xB277, 0x514D, 0x4C3D, 0x514E,      0,
  0x495A, 0x5150, 0x5151, 0x5152, 0x455F, 0xB278,      0,      0,
  0x5156, 0x5154, 0x5155, 0x5153, 0x3A63, 0x5157, 0x4C6A, 0x4E64,
- 0xB279,      0, 0xB27A,      0, 0xB27B, 0x5158, 0x7946, 0xB27D,
+ 0xB279,      0, 0xB27A,      0, 0xB27B, 0x5158, 0xB27C, 0xB27D,
 };
 const unsigned short utf8_to_euc_E587[] = {
       0,      0, 0xB27E,      0, 0x4028, 0x5159, 0x3D5A,      0,
@@ -2895,14 +2973,14 @@ const unsigned short utf8_to_euc_E587[] = {
       0, 0xB323, 0xB324, 0xB325,      0, 0xB326, 0x5245,      0,
  0xB327,      0,      0, 0x515B, 0x7425, 0x3645, 0xB328,      0,
  0x515C, 0x4B5E, 0xB329,      0,      0, 0xB32A, 0x3D68, 0x427C,
-      0, 0x515E, 0x4664,      0, 0x7947, 0x515F, 0xB32B,      0,
+      0, 0x515E, 0x4664,      0, 0xF431, 0x515F, 0xB32B,      0,
  0x5160, 0x332E, 0xB32C, 0xB32D, 0xB32E, 0x5161, 0x3627, 0xB32F,
  0x464C, 0x317A, 0x3D50,      0,      0, 0x4821, 0x5162,      0,
 };
 const unsigned short utf8_to_euc_E588[] = {
  0x4561, 0xB330, 0xB331, 0x3F4F, 0x5163, 0xB332, 0x4A2C, 0x405A,
  0x3422,      0, 0x3429, 0x5164,      0,      0, 0x5166,      0,
-      0, 0x373A, 0xB333, 0xB334, 0x5165, 0x7948, 0xB336, 0x4E73,
+      0, 0x373A, 0xB333, 0xB334, 0x5165, 0xB335, 0xB336, 0x4E73,
  0xB337,      0,      0,      0,      0, 0x3D69,      0,      0,
       0,      0, 0xB338,      0, 0x483D, 0x4A4C,      0, 0x5167,
  0xB339, 0x4D78, 0x5168,      0,      0,      0, 0x5169,      0,
@@ -2923,28 +3001,28 @@ const unsigned short utf8_to_euc_E58A[] = {
  0xB34D,      0, 0xB34E, 0x3344,      0, 0xB34F,      0, 0x3760,
  0x517C, 0x4E2D, 0xB350,      0, 0xB351, 0x5178,      0,      0,
       0, 0x517D, 0x517A, 0xB352, 0x5179, 0xB353, 0xB354, 0xB355,
- 0xB356,      0, 0xB357, 0x4E4F, 0x7949,      0,      0, 0x3879,
- 0x3243,      0,      0, 0x4E74, 0xB359, 0xB35A, 0x794A, 0xB35C,
-      0, 0x3D75, 0x4558, 0x3965, 0x5222, 0x5223,      0, 0x7B3C,
+ 0xB356,      0, 0xB357, 0x4E4F, 0xB358,      0,      0, 0x3879,
+ 0x3243,      0,      0, 0x4E74, 0xB359, 0xB35A, 0xB35B, 0xB35C,
+      0, 0x3D75, 0x4558, 0x3965, 0x5222, 0x5223,      0, 0xB35D,
  0xB35E, 0x4E65,      0,      0, 0x4F2B, 0x5225, 0xB35F, 0xB360,
  0xB361, 0x387A, 0xB362, 0xB363, 0x5224, 0xB364, 0x332F,      0,
 };
 const unsigned short utf8_to_euc_E58B[] = {
- 0x794B, 0x5226,      0, 0x4B56, 0xB366, 0x443C, 0xB367, 0x4D26,
+ 0xB365, 0x5226,      0, 0x4B56, 0xB366, 0x443C, 0xB367, 0x4D26,
  0xB368, 0x4A59,      0,      0, 0xB369, 0x5227,      0, 0xB36A,
       0, 0xB36B, 0x7055,      0, 0xB36C, 0x4630, 0xB36D, 0x5228,
- 0x342A, 0x4C33,      0, 0x794C, 0xB36F, 0x3E21, 0x5229, 0x4A67,
+ 0x342A, 0x4C33,      0, 0xB36E, 0xB36F, 0x3E21, 0x5229, 0x4A67,
  0x522D, 0xB370, 0x402A, 0x522A, 0x3650, 0xB371, 0x522B, 0x342B,
  0xB372, 0xB373, 0xB374,      0, 0xB375,      0,      0,      0,
  0xB376, 0xB377, 0x372E, 0x522E, 0xB378, 0x522F, 0xB379, 0xB37A,
  0x5230, 0x5231, 0x3C5B,      0,      0,      0, 0x387B, 0x4C5E,
 };
 const unsigned short utf8_to_euc_E58C[] = {
- 0x794D, 0x4C68, 0x4677, 0xB37C,      0, 0x4A71, 0x5232, 0x794E,
+ 0xB37B, 0x4C68, 0x4677, 0xB37C,      0, 0x4A71, 0x5232, 0xF432,
  0x5233,      0, 0xB37D, 0xB37E, 0xB421, 0x5235,      0, 0x5237,
  0x5236, 0xB422,      0, 0xB423,      0, 0x5238, 0x323D, 0x4B4C,
  0xB424, 0x3A7C, 0x5239, 0xB425, 0xB426, 0x4159, 0xB427, 0xB428,
- 0x3E22, 0x3629,      0, 0x523A, 0x794F, 0xB429,      0, 0xB42A,
+ 0x3E22, 0x3629,      0, 0x523A, 0xF433, 0xB429,      0, 0xB42A,
  0xB42B, 0xB42C, 0x485B, 0xB42D, 0xB42E, 0xB42F,      0, 0x523B,
  0xB430, 0x523C, 0xB431, 0x523D,      0, 0xB432,      0,      0,
  0x523E, 0x4924, 0x3668, 0x3065, 0xB433, 0xB434, 0xB435, 0x463F,
@@ -2956,24 +3034,24 @@ const unsigned short utf8_to_euc_E58D[] = {
  0x4331, 0xB439, 0x476E, 0xB43A, 0x4B4E,      0, 0x5246,      0,
  0x406A, 0xB43B,      0, 0xB43C,      0, 0xB43D, 0x3735,      0,
       0, 0x5247,      0,      0, 0xB43E, 0xB43F, 0x5248, 0x312C,
- 0x3075, 0x346D, 0x7950, 0x4228, 0x3551, 0x4D71,      0, 0x524B,
+ 0x3075, 0x346D, 0xB440, 0x4228, 0x3551, 0x4D71,      0, 0x524B,
  0x3237, 0xB441,      0, 0x524A,      0,      0, 0xB442, 0x362A,
 };
 const unsigned short utf8_to_euc_E58E[] = {
       0,      0, 0x524C, 0xB443, 0x4C71,      0,      0, 0xB444,
  0xB445,      0,      0,      0,      0,      0, 0xB446,      0,
-      0,      0,      0, 0x7951, 0xB448,      0, 0x524D,      0,
+      0,      0,      0, 0xB447, 0xB448,      0, 0x524D,      0,
  0x4E52, 0xB449, 0x387C,      0,      0, 0xB44A,      0, 0x3836,
  0x524E, 0xB44B,      0,      0, 0xB44C, 0x5250, 0x524F,      0,
  0x3F5F, 0x3139, 0xB44D, 0xB44E,      0, 0x315E, 0x5251, 0xB44F,
- 0x5252,      0, 0x7952, 0x3837, 0xB451, 0xB452, 0x5253, 0xB453,
+ 0x5252,      0, 0xB450, 0x3837, 0xB451, 0xB452, 0x5253, 0xB453,
  0xB454,      0, 0xB455, 0x356E,      0, 0xB456,      0,      0,
 };
 const unsigned short utf8_to_euc_E58F[] = {
  0xB457,      0, 0x3B32, 0x5254,      0, 0xB458,      0,      0,
  0x4B74, 0x3A35, 0x355A, 0x4D27, 0x4150, 0x483F, 0x3C7D, 0xB459,
       0,      0, 0xB45A, 0xB45B, 0x3D47, 0xB45C, 0x3C68, 0x3C75,
-      0, 0x3D76, 0xB45D, 0x4840,      0, 0x7953, 0xB45F, 0x5257,
+      0, 0x3D76, 0xB45D, 0x4840,      0, 0xB45E, 0xB45F, 0x5257,
  0xB460, 0x3143, 0x4151, 0x387D, 0x3845, 0x3667, 0xB461, 0xB462,
  0x525B, 0x4321, 0x427E, 0x362B, 0x3E24, 0x525C, 0x525A, 0x3244,
  0x4266, 0x3C38, 0x3B4B, 0x3126,      0, 0xB463, 0x3370, 0x3966,
@@ -3001,11 +3079,11 @@ const unsigned short utf8_to_euc_E591[] = {
 };
 const unsigned short utf8_to_euc_E592[] = {
  0x5272, 0xB521,      0, 0xB522, 0x5274, 0xB523, 0x5276,      0,
- 0xB524, 0xB525, 0x7956, 0x3A70, 0x4F42, 0xB526, 0x526B, 0x5269,
+ 0xB524, 0xB525, 0xF435, 0x3A70, 0x4F42, 0xB526, 0x526B, 0x5269,
  0x5275, 0xB527, 0x5270,      0,      0, 0xB528, 0xB529,      0,
-      0,      0,      0,      0, 0x7955,      0,      0, 0xB52B,
+      0,      0,      0,      0, 0xB52A,      0,      0, 0xB52B,
       0, 0xB52C, 0x5278,      0, 0x5323, 0x527A, 0xB52D, 0xB52E,
- 0x527E, 0x7957, 0xB530, 0x5321, 0x527B, 0xB531, 0xB532, 0x533E,
+ 0x527E, 0xB52F, 0xB530, 0x5321, 0x527B, 0xB531, 0xB532, 0x533E,
       0, 0xB533, 0x3A69, 0x3331,      0,      0,      0, 0xB534,
  0x5279, 0xB535, 0xB536, 0xB537, 0x5325, 0x3076, 0x5324, 0xB538,
 };
@@ -3017,7 +3095,7 @@ const unsigned short utf8_to_euc_E593[] = {
  0xB53D, 0x3077, 0x532F,      0,      0, 0x5327, 0x5328,      0,
  0x3E25, 0x4B69, 0xB53E,      0, 0xB53F, 0x532D, 0x532C, 0xB540,
       0,      0, 0x452F,      0,      0,      0, 0xB541,      0,
-      0,      0, 0x532E,      0, 0xB542, 0x532B, 0xB543, 0x7958,
+      0,      0, 0x532E,      0, 0xB542, 0x532B, 0xB543, 0xB544,
 };
 const unsigned short utf8_to_euc_E594[] = {
  0xB545, 0xB546,      0,      0, 0x3134, 0xB547, 0x3A36, 0x3F30,
@@ -3040,7 +3118,7 @@ const unsigned short utf8_to_euc_E595[] = {
       0,      0,      0, 0x5341, 0x5346,      0, 0x5342, 0xB565,
 };
 const unsigned short utf8_to_euc_E596[] = {
- 0x533D, 0xB566, 0xB567, 0x5347, 0x4131,      0, 0x7959, 0x5349,
+ 0x533D, 0xB566, 0xB567, 0x5347, 0x4131,      0, 0xB568, 0x5349,
  0xB569, 0x3922, 0x533F, 0x437D,      0,      0, 0xB56A, 0xB56B,
       0, 0xB56C, 0xB56D, 0xB56E, 0xB56F,      0,      0, 0xB570,
  0x5343, 0x533C, 0x342D,      0, 0x346E, 0x3365, 0x5344, 0x5340,
@@ -3113,8 +3191,8 @@ const unsigned short utf8_to_euc_E59D[] = {
  0x542E,      0, 0x3A64,      0,      0, 0xB73C, 0xB73D, 0x3651,
       0,      0, 0x4B37,      0, 0xB73E, 0xB73F, 0x542C, 0x542F,
  0x3A41, 0x3923, 0xB740,      0,      0,      0,      0,      0,
-      0, 0x795A,      0,      0,      0,      0,      0,      0,
-      0, 0x5433, 0xB741,      0, 0x3A25, 0x795B, 0x4333, 0xB743,
+      0, 0xF436,      0,      0,      0,      0,      0,      0,
+      0, 0x5433, 0xB741,      0, 0x3A25, 0xB742, 0x4333, 0xB743,
  0xB744, 0x5430, 0x445A, 0xB745,      0, 0xB746, 0xB747, 0xB748,
  0xB749, 0xB74A,      0, 0xB74B, 0xB74C, 0xB74D,      0, 0xB74E,
       0, 0xB74F, 0xB750, 0xB751, 0xB752,      0, 0xB753, 0x5434,
@@ -3125,13 +3203,13 @@ const unsigned short utf8_to_euc_E59E[] = {
       0,      0,      0, 0x5436, 0xB757, 0xB760,      0, 0xB758,
       0, 0xB759, 0xB75A,      0, 0xB75B, 0xB75C, 0xB75D, 0xB75E,
  0x5437, 0xB75F, 0x3924, 0x3340, 0x5439,      0,      0, 0xB761,
- 0xB762, 0xB763, 0x543A,      0, 0x795C,      0,      0,      0,
+ 0xB762, 0xB763, 0x543A,      0, 0xB764,      0,      0,      0,
  0x543B,      0,      0, 0x5438,      0,      0,      0,      0,
  0xB765,      0,      0,      0,      0, 0xB766,      0,      0,
 };
 const unsigned short utf8_to_euc_E59F[] = {
- 0x5431,      0,      0, 0x543C,      0,      0, 0x543D, 0x795E,
- 0x795D,      0,      0, 0x4B64, 0xB769,      0, 0x3E6B, 0xB76A,
+ 0x5431,      0,      0, 0x543C,      0,      0, 0x543D, 0xB767,
+ 0xB768,      0,      0, 0x4B64, 0xB769,      0, 0x3E6B, 0xB76A,
       0,      0, 0x543F, 0x5440, 0x543E, 0xB76B, 0x5442,      0,
       0,      0,      0,      0, 0x4738, 0xB76C, 0xB76D, 0x3068,
  0x4956, 0xB77E,      0, 0x5443, 0xB76E,      0, 0xB76F, 0xB770,
@@ -3163,10 +3241,10 @@ const unsigned short utf8_to_euc_E5A2[] = {
  0xB83B, 0xB83C,      0, 0x362D,      0, 0x5450,      0, 0xB83D,
  0xB83E, 0xB83F, 0xB840,      0, 0xB841, 0xB842,      0, 0xB843,
  0xB844,      0,      0, 0x4A68, 0xB845,      0, 0xB846, 0x417D,
-      0,      0,      0,      0, 0x4446, 0xB847, 0x7961, 0x5452,
+      0,      0,      0,      0, 0x4446, 0xB847, 0xF439, 0x5452,
  0xB848, 0xB849, 0xB84A,      0,      0,      0, 0xB84B,      0,
  0x4B4F, 0xB84C,      0, 0x5453,      0,      0, 0x5458,      0,
-      0, 0xB84D, 0x7962, 0x4A2F,      0,      0,      0,      0,
+      0, 0xB84D, 0xB84E, 0x4A2F,      0,      0,      0,      0,
  0x5457, 0x5451, 0x5454, 0x5456, 0xB850,      0, 0x3A26,      0,
 };
 const unsigned short utf8_to_euc_E5A3[] = {
@@ -3181,7 +3259,7 @@ const unsigned short utf8_to_euc_E5A3[] = {
 };
 const unsigned short utf8_to_euc_E5A4[] = {
       0,      0, 0x5469,      0,      0, 0xB85F, 0xB860,      0,
-      0, 0x4A51, 0x546A, 0x7963, 0xB862,      0,      0, 0x3246,
+      0, 0x4A51, 0x546A, 0xB861, 0xB862,      0,      0, 0x3246,
  0x546B,      0, 0xB863, 0xB864, 0xB865, 0x4D3C, 0x3330,      0,
  0x5249, 0x3D48, 0x423F, 0x546C, 0x4C6B, 0xB867,      0,      0,
       0, 0xB868, 0x4C34, 0xB869, 0xB86A, 0x546E,      0, 0x4267,
@@ -3192,9 +3270,9 @@ const unsigned short utf8_to_euc_E5A4[] = {
 const unsigned short utf8_to_euc_E5A5[] = {
       0,      0,      0, 0xB872, 0x3162,      0, 0xB873, 0x3471,
  0x4660, 0x4A74,      0,      0,      0,      0, 0x5477, 0x4155,
- 0x5476, 0x3740, 0xB874, 0x7964, 0x4B5B, 0x5475,      0, 0x4565,
- 0x5479, 0xB876, 0x5478, 0x7965,      0, 0x7966, 0xB879, 0xB87A,
- 0x547B, 0xB87B, 0x547A, 0x7967,      0, 0x317C,      0, 0x547C,
+ 0x5476, 0x3740, 0xB874, 0xB875, 0x4B5B, 0x5475,      0, 0x4565,
+ 0x5479, 0xB876, 0x5478, 0xB877,      0, 0xB878, 0xB879, 0xB87A,
+ 0x547B, 0xB87B, 0x547A, 0xB87C,      0, 0x317C,      0, 0x547C,
  0x3E29, 0x547E, 0x4325, 0xB87D, 0x547D, 0xB87E, 0x4A33, 0xB921,
       0,      0, 0xB922, 0x3D77, 0x455B, 0xB923, 0xB924,      0,
  0x5521, 0xB925,      0, 0xB926, 0xB927, 0x3925,      0,      0,
@@ -3204,10 +3282,10 @@ const unsigned short utf8_to_euc_E5A6[] = {
       0,      0, 0x4725, 0xB928, 0xB929, 0x552B, 0xB92A,      0,
       0,      0, 0xB92B, 0x3538,      0, 0xB92C, 0x4D45, 0xB92D,
       0, 0x4C2F,      0, 0x562C,      0, 0x5523,      0, 0xB92E,
-      0,      0,      0, 0x5526, 0x7968, 0x4245,      0, 0xB930,
+      0,      0,      0, 0x5526, 0xB92F, 0x4245,      0, 0xB930,
  0x4B38,      0,      0,      0, 0x454A, 0xB931, 0xB932, 0xB933,
  0xB934,      0, 0x5527, 0xB935,      0,      0,      0, 0xB936,
-      0, 0x4B65, 0x7969, 0x3A4A, 0xB938,      0, 0x3E2A,      0,
+      0, 0x4B65, 0xB937, 0x3A4A, 0xB938,      0, 0x3E2A,      0,
 };
 const unsigned short utf8_to_euc_E5A7[] = {
       0, 0xB939,      0, 0xB93A, 0xB93B,      0, 0x5528,      0,
@@ -3272,7 +3350,7 @@ const unsigned short utf8_to_euc_E5AC[] = {
 const unsigned short utf8_to_euc_E5AD[] = {
  0x5552, 0xBA3A,      0, 0x5550,      0, 0x5551,      0,      0,
       0,      0,      0, 0xBA3B, 0xBA3C,      0,      0,      0,
- 0x3B52, 0x5553, 0xBA3D,      0, 0x3926, 0x5554, 0x796A, 0x3B7A,
+ 0x3B52, 0x5553, 0xBA3D,      0, 0x3926, 0x5554, 0xBA3E, 0x3B7A,
  0x4238,      0, 0x5555, 0x5556, 0x3B5A, 0x3927, 0xBA3F, 0x4C52,
       0,      0,      0, 0x3528, 0x3849, 0x5557, 0x3358,      0,
  0xBA40, 0x5558,      0, 0x4239,      0,      0, 0xBA41, 0xBA42,
@@ -3290,12 +3368,12 @@ const unsigned short utf8_to_euc_E5AE[] = {
  0x5562, 0x4D46, 0xBA59,      0, 0xBA5A,      0,      0, 0x3D49,
 };
 const unsigned short utf8_to_euc_E5AF[] = {
- 0x796B, 0xBA5C, 0x3C64, 0x5563, 0x3473, 0x4652, 0x4C29, 0x5564,
+ 0xBA5B, 0xBA5C, 0x3C64, 0x5563, 0x3473, 0x4652, 0x4C29, 0x5564,
       0, 0x5565,      0,      0, 0x4959, 0xBA5D,      0, 0xBA5E,
  0x5567,      0, 0x3428, 0x3677, 0x5566,      0, 0xBA5F, 0xBA60,
- 0x796D, 0xBA62, 0xBA63, 0x3432,      0, 0x3F32, 0x556B, 0x3B21,
+ 0xBA61, 0xBA62, 0xBA63, 0x3432,      0, 0x3F32, 0x556B, 0x3B21,
  0xBA64, 0x3249, 0x556A,      0, 0x5568, 0x556C, 0x5569, 0x472B,
- 0x5C4D, 0x3F33,      0, 0x556D, 0x796E,      0, 0x4E40, 0xBA65,
+ 0x5C4D, 0x3F33,      0, 0x556D, 0xF43A,      0, 0x4E40, 0xBA65,
  0x556E, 0xBA66,      0, 0x5570, 0xBA67, 0x437E, 0x556F,      0,
  0x4023,      0, 0x3B7B,      0,      0, 0xBA68, 0x4250, 0x3C77,
 };
@@ -3303,7 +3381,7 @@ const unsigned short utf8_to_euc_E5B0[] = {
       0, 0x4975, 0x406C,      0, 0x3C4D, 0x5571, 0x3E2D, 0x5572,
  0x5573, 0x3053, 0x423A, 0x3F52, 0xBA69, 0x5574, 0x4633, 0x3E2E,
       0, 0x3E2F,      0, 0x5575,      0,      0, 0x406D, 0xBA6A,
-      0,      0, 0x3E30,      0,      0,      0, 0x796F, 0xBA6C,
+      0,      0, 0x3E30,      0,      0,      0, 0xBA6B, 0xBA6C,
  0x5576,      0, 0x5577, 0xBA6D, 0x4C60,      0, 0xBA6E,      0,
  0x5578, 0xBA6F,      0, 0xBA70, 0xBA71, 0x3646, 0xBA72,      0,
  0xBA73, 0x3D22, 0xBA74,      0,      0, 0xBA75, 0xBA76,      0,
@@ -3324,10 +3402,10 @@ const unsigned short utf8_to_euc_E5B2[] = {
  0xBB2A,      0, 0xBB2B,      0, 0x5629,      0,      0, 0xBB2C,
  0x3474, 0x562A, 0xBB2D,      0, 0x562B,      0,      0,      0,
       0,      0,      0,      0,      0, 0xBB2E,      0, 0xBB2F,
- 0xBB30, 0x322C, 0xBB31, 0xBB32,      0,      0, 0x7970,      0,
+ 0xBB30, 0x322C, 0xBB31, 0xBB32,      0,      0, 0xBB33,      0,
  0x413B, 0x3464, 0xBB34, 0x562D, 0x4C28,      0,      0,      0,
       0, 0x4252, 0xBB35, 0x3359, 0xBB36, 0xBB37, 0x562F, 0x5631,
- 0x345F,      0, 0x7971, 0x562E, 0x5630,      0, 0x5633,      0,
+ 0x345F,      0, 0xBB38, 0x562E, 0x5630,      0, 0x5633,      0,
 };
 const unsigned short utf8_to_euc_E5B3[] = {
       0,      0,      0,      0,      0, 0x5632,      0, 0x5634,
@@ -3336,7 +3414,7 @@ const unsigned short utf8_to_euc_E5B3[] = {
       0, 0x5635,      0,      0,      0, 0xBB3C,      0,      0,
  0x463D, 0x362E,      0,      0,      0,      0,      0,      0,
  0x3265, 0x5636, 0x563B,      0,      0, 0x5639, 0xBB3E, 0x4A77,
- 0x4A76, 0xBB3F, 0xBB40,      0, 0xBB41, 0x7972, 0x4567,      0,
+ 0x4A76, 0xBB3F, 0xBB40,      0, 0xBB41, 0xF43B, 0x4567,      0,
       0,      0, 0x5638, 0x3D54,      0, 0x5637,      0,      0,
 };
 const unsigned short utf8_to_euc_E5B4[] = {
@@ -3344,18 +3422,18 @@ const unsigned short utf8_to_euc_E5B4[] = {
       0,      0,      0, 0x563C,      0, 0xBB44, 0x3A6A,      0,
       0, 0x5642, 0xBB45,      0, 0x5643, 0x563D, 0x3333, 0x563E,
  0x5647, 0x5646, 0x5645, 0x5641,      0,      0,      0, 0x5640,
-      0,      0, 0x5644, 0xBB47, 0xBB48,      0, 0xBB49, 0x7973,
+      0,      0, 0x5644, 0xBB47, 0xBB48,      0, 0xBB49, 0xBB4A,
       0, 0x4A78,      0, 0xBB46,      0,      0,      0,      0,
       0, 0xBB4B,      0,      0, 0xBB4C,      0,      0,      0,
       0, 0xBB4D,      0,      0,      0, 0xBB4E,      0, 0xBB4F,
 };
 const unsigned short utf8_to_euc_E5B5[] = {
-      0,      0, 0x7976, 0xBB51,      0,      0, 0xBB52,      0,
+      0,      0, 0xBB50, 0xBB51,      0,      0, 0xBB52,      0,
  0xBB53,      0, 0xBB57, 0x564B, 0x5648,      0, 0x564A,      0,
- 0x4D72, 0xBB55, 0x5649, 0x7974,      0, 0xBB54,      0,      0,
+ 0x4D72, 0xBB55, 0x5649, 0xF43C,      0, 0xBB54,      0,      0,
       0, 0xBB56,      0,      0, 0x563F,      0,      0, 0xBB58,
  0xBB59, 0xBB5A, 0xBB5B,      0, 0xBB5C,      0,      0,      0,
-      0, 0x3F73, 0xBB5D,      0, 0x564C, 0x7977,      0, 0x3A37,
+      0, 0x3F73, 0xBB5D,      0, 0x564C, 0xBB5E,      0, 0x3A37,
  0xBB5F,      0,      0, 0x564D,      0,      0, 0x564E,      0,
       0, 0xBB60, 0xBB61,      0,      0,      0, 0xBB62, 0xBB63,
 };
@@ -3367,12 +3445,12 @@ const unsigned short utf8_to_euc_E5B6[] = {
  0xBB6F,      0, 0x5652,      0,      0,      0,      0, 0xBB70,
       0,      0,      0, 0xBB71, 0x5654,      0, 0x5655,      0,
  0xBB72,      0, 0xE674,      0, 0xBB73,      0,      0, 0x5658,
- 0x7978, 0x7979, 0x4E66,      0, 0x5659, 0x5656,      0,      0,
+ 0xBB74, 0xBB75, 0x4E66,      0, 0x5659, 0x5656,      0,      0,
 };
 const unsigned short utf8_to_euc_E5B7[] = {
       0,      0,      0, 0xBB76,      0,      0,      0, 0xBB77,
       0, 0x565A,      0, 0xBB78, 0x3460, 0x565B, 0xBB7A,      0,
- 0x797A,      0, 0x565D, 0x565C,      0,      0, 0x565E,      0,
+ 0xBB79,      0, 0x565D, 0x565C,      0,      0, 0x565E,      0,
  0xBB7B, 0xBB7C,      0, 0x565F,      0, 0x406E, 0x3D23,      0,
  0xBB7D, 0x3D64,      0, 0x4163, 0xBB7E, 0x3929, 0x3A38, 0x392A,
  0x3570, 0xBC21,      0, 0x5660,      0,      0, 0x3A39,      0,
@@ -3424,17 +3502,17 @@ const unsigned short utf8_to_euc_E5BC[] = {
  0xBC5F, 0x5732, 0x4A40, 0x5735, 0x5021, 0x5031, 0xBC60, 0x3C30,
  0x4675, 0x5736,      0, 0x355D, 0x4424, 0x307A, 0x5737, 0x4A26,
  0x3930, 0xBC61,      0, 0x4350, 0xBC62, 0xBC63,      0, 0x446F,
-      0, 0x797B, 0xBC65, 0xBC66, 0xBC67, 0x4C6F, 0x3839, 0x384C,
+      0, 0xBC64, 0xBC65, 0xBC66, 0xBC67, 0x4C6F, 0x3839, 0x384C,
  0xBC68, 0x5738,      0, 0xBC69, 0xBC6A, 0x5739, 0xBC6B, 0x573F,
- 0xBC6C, 0x3C65,      0,      0, 0x797C, 0x4425, 0xBC6E, 0x362F,
+ 0xBC6C, 0x3C65,      0,      0, 0xBC6D, 0x4425, 0xBC6E, 0x362F,
  0x573A,      0,      0, 0xBC6F, 0x492B, 0xBC70, 0x4346, 0xBC71,
 };
 const unsigned short utf8_to_euc_E5BD[] = {
- 0xBC72, 0x573B,      0,      0, 0xBC73, 0x792C,      0, 0xBC75,
+ 0xBC72, 0x573B,      0,      0, 0xBC73, 0xBC74,      0, 0xBC75,
  0x573C,      0, 0x3630,      0, 0x573D, 0xBC76, 0x573E,      0,
  0xBC77, 0x5740,      0, 0x4576, 0xBC78,      0, 0x5741, 0x5742,
  0xBC79, 0x5743,      0, 0xBC7A, 0x5734, 0x5733,      0,      0,
- 0xBC7B, 0x5744, 0x3741, 0xBC7C, 0xBC7D,      0, 0x4927, 0x797D,
+ 0xBC7B, 0x5744, 0x3741, 0xBC7C, 0xBC7D,      0, 0x4927, 0xBC7E,
       0, 0x3A4C, 0x4937, 0x4426, 0x494B, 0x5745,      0, 0xBD21,
  0x3E34, 0x3146, 0xBD22, 0x5746, 0xBD23, 0xBD24,      0, 0x5747,
  0xBD25, 0x4C72, 0xBD26,      0, 0x4860, 0xBD27, 0xBD28, 0x574A,
@@ -3446,14 +3524,14 @@ const unsigned short utf8_to_euc_E5BE[] = {
  0x5751, 0x5750,      0,      0, 0xBD2D, 0xBD2E, 0x574F,      0,
  0x5752, 0x3866, 0xBD2F,      0, 0xBD32,      0,      0, 0xBD30,
  0x5753, 0x497C, 0x3D5B, 0xBD31, 0xBD33, 0x5754, 0x4879, 0xBD34,
- 0xBD35, 0xBD36,      0, 0x4641, 0x4427,      0,      0, 0x797E,
+ 0xBD35, 0xBD36,      0, 0x4641, 0x4427,      0,      0, 0xF43E,
  0xBD37, 0x4530,      0,      0, 0x5755, 0x352B,      0,      0,
 };
 const unsigned short utf8_to_euc_E5BF[] = {
       0,      0,      0, 0x3F34, 0xBD38, 0x492C,      0, 0xBD39,
  0xBD3A, 0xBD3B,      0, 0xBD3C, 0x3477, 0x4726,      0,      0,
  0xBD3D, 0xBD3E, 0xBD3F, 0xBD40, 0xBD41,      0, 0x5756, 0x3B56,
- 0x4B3A, 0x4B3B,      0,      0, 0x317E, 0x575B, 0x7A21,      0,
+ 0x4B3A, 0x4B3B,      0,      0, 0x317E, 0x575B, 0xBD42,      0,
  0x4369, 0xBD43, 0xBD44,      0, 0x5758,      0,      0,      0,
  0xBD45, 0xBD46, 0xBD47, 0x3277, 0xBD48, 0xBD49, 0xBD4A, 0xBD4B,
  0x582D, 0x575A, 0xBD4C, 0xBD4D,      0, 0x4730, 0xBD4E,      0,
@@ -3473,15 +3551,15 @@ const unsigned short utf8_to_euc_E681[] = {
  0xBD5E, 0x576C, 0x5776, 0x5774,      0,      0, 0x5771, 0xBD5F,
  0xBD60, 0xBD61, 0x5770, 0x4E78, 0xBD62, 0x5772,      0,      0,
  0x3632, 0xBD63, 0x3931,      0, 0xBD64, 0x3D7A, 0xBD65, 0xBD66,
-      0, 0x5779, 0x576B,      0,      0, 0x7A22,      0, 0x576F,
+      0, 0x5779, 0x576B,      0,      0, 0xBD67,      0, 0x576F,
  0x575F, 0xBD68, 0x327A, 0x5773, 0x5775, 0x4351,      0, 0xBD69,
  0x3A28, 0x3238, 0x576D, 0x5778, 0x5777, 0x3633,      0, 0x4229,
  0x3366, 0xBD6A,      0,      0,      0, 0x3743,      0, 0x576E,
       0,      0,      0,      0,      0,      0, 0xBD6B, 0xBD6C,
 };
 const unsigned short utf8_to_euc_E682[] = {
-      0, 0x577A, 0xBD6D, 0x577D, 0x5821, 0x7A23, 0xBD6E,      0,
- 0xBD6F, 0x3C3D, 0x7A24, 0x5827, 0x4470, 0x577B, 0xBD71,      0,
+      0, 0x577A, 0xBD6D, 0x577D, 0x5821, 0xF43F, 0xBD6E,      0,
+ 0xBD6F, 0x3C3D, 0xBD70, 0x5827, 0x4470, 0x577B, 0xBD71,      0,
       0, 0xBD72, 0x5825, 0xBD73, 0x3279, 0xBD74, 0x5823, 0x5824,
  0xBD75,      0, 0x577E, 0x5822,      0, 0xBD76, 0xBD77, 0x3867,
  0x4D2A,      0, 0xBD78, 0x3435, 0xBD79, 0xBD7A, 0x3159, 0x5826,
@@ -3492,21 +3570,21 @@ const unsigned short utf8_to_euc_E682[] = {
 const unsigned short utf8_to_euc_E683[] = {
       0,      0, 0xBE23,      0, 0xBE24, 0x3E70, 0x582F, 0x4657,
  0xBE25, 0xBE26, 0xBE27, 0xBE28,      0,      0, 0xBE29, 0xBE2A,
-      0, 0x4F47,      0, 0x582B, 0xBE2B, 0x7A26,      0,      0,
- 0x5831, 0xBE2D, 0x397B, 0xBE2E, 0x404B, 0xBE2F, 0x7A25, 0x3054,
+      0, 0x4F47,      0, 0x582B, 0xBE2B, 0xBE2C,      0,      0,
+ 0x5831, 0xBE2D, 0x397B, 0xBE2E, 0x404B, 0xBE2F, 0xBE30, 0x3054,
  0x582A, 0x5828, 0xBE31, 0x415A,      0, 0xBE32,      0, 0x577C,
  0x3B34,      0,      0,      0,      0,      0,      0,      0,
- 0x4246, 0x583D, 0x7A28, 0x415B, 0x5838, 0xBE34, 0x5835, 0x5836,
+ 0x4246, 0x583D, 0xBE33, 0x415B, 0x5838, 0xBE34, 0x5835, 0x5836,
  0xBE35, 0x3C66, 0x5839, 0x583C, 0xBE36, 0xBE37,      0,      0,
 };
 const unsigned short utf8_to_euc_E684[] = {
  0x5837, 0x3D25, 0xBE38, 0x583A,      0,      0, 0x5834, 0xBE39,
  0x4C7C, 0x4C7B, 0xBE3A,      0, 0xBE3B, 0x583E, 0x583F, 0x3055,
- 0xBE3C, 0x7A29, 0xBE3E, 0xBE3F, 0xBE40, 0x5833, 0xBE41, 0xBE42,
+ 0xBE3C, 0xBE3D, 0xBE3E, 0xBE3F, 0xBE40, 0x5833, 0xBE41, 0xBE42,
       0, 0xBE43, 0x3672, 0x3026, 0xBE44,      0, 0xBE45, 0x3436,
- 0x7A27, 0x583B, 0xBE46,      0,      0,      0,      0, 0x5843,
+ 0xF440, 0x583B, 0xBE46,      0,      0,      0,      0, 0x5843,
  0x5842,      0, 0xBE47, 0xBE48, 0x5847,      0,      0,      0,
- 0x7A2B, 0xBE4A,      0,      0, 0x5848, 0xBE4B, 0xBE4C, 0x7A2A,
+ 0xBE49, 0xBE4A,      0,      0, 0x5848, 0xBE4B, 0xBE4C, 0xBE4D,
       0, 0xBE4E,      0,      0, 0x5846, 0x5849, 0x5841, 0x5845,
 };
 const unsigned short utf8_to_euc_E685[] = {
@@ -3523,7 +3601,7 @@ const unsigned short utf8_to_euc_E686[] = {
  0xBE5B, 0xBE5C, 0x4D2B, 0xBE5D, 0xBE5E,      0,      0, 0x585C,
       0,      0, 0x5860, 0xBE5F,      0, 0xBE60, 0x417E,      0,
  0x4E79, 0x5861, 0xBE61, 0xBE62, 0x585E,      0, 0x585B, 0xBE63,
- 0x7A2C, 0x585A, 0x585F,      0, 0xBE65, 0xBE66,      0, 0xBE67,
+ 0xBE64, 0x585A, 0x585F,      0, 0xBE65, 0xBE66,      0, 0xBE67,
  0xBE68,      0,      0,      0, 0x4A30, 0xBE69,      0, 0x4634,
  0xBE6A, 0x3746, 0xBE6B, 0x5862, 0x585D, 0xBE6C, 0x5863,      0,
       0,      0, 0x377B,      0,      0,      0, 0x3231,      0,
@@ -3542,7 +3620,7 @@ const unsigned short utf8_to_euc_E687[] = {
 const unsigned short utf8_to_euc_E688[] = {
  0x5878, 0xBF24,      0, 0xBF25, 0xBF26,      0,      0, 0xBF27,
  0x5879, 0x587A, 0x4A6A,      0, 0x587C, 0x587B, 0x3D3F,      0,
- 0x402E, 0x3266, 0x327C, 0x7A2D, 0x587D, 0xBF29, 0x303F,      0,
+ 0x402E, 0x3266, 0x327C, 0xBF28, 0x587D, 0xBF29, 0x303F,      0,
       0,      0, 0x404C, 0x587E, 0xBF2A, 0x6C43, 0x5921, 0x3761,
  0xBF2B, 0x5922, 0xBF2C, 0xBF2D,      0,      0, 0x406F, 0xBF2E,
       0, 0xBF2F, 0x5923, 0xBF30,      0,      0, 0x5924, 0x353A,
@@ -3564,7 +3642,7 @@ const unsigned short utf8_to_euc_E68A[] = {
       0, 0x5931, 0x4744,      0,      0, 0xBF45, 0xBF46, 0xBF47,
  0xBF48, 0x4D5E, 0x5933, 0x5934, 0x5938, 0x456A, 0x5935, 0x3933,
  0x405E,      0,      0, 0x5946, 0x4834,      0, 0x4272,      0,
-      0,      0,      0,      0,      0,      0, 0x7A2E,      0,
+      0,      0,      0,      0,      0,      0, 0xBF49,      0,
  0xBF4A,      0,      0, 0x4864, 0x5A2D,      0,      0,      0,
       0, 0x4A7A,      0, 0xBF4B,      0, 0x4471, 0xBF4C, 0xBF4D,
       0, 0x4B75, 0xBF4E, 0x593B, 0x3221, 0x436A, 0xBF4F, 0xBF50,
@@ -3616,7 +3694,7 @@ const unsigned short utf8_to_euc_E68F[] = {
       0,      0, 0x4D48, 0x3439, 0xC03D,      0,      0,      0,
  0xC03E, 0x302E,      0, 0x5965,      0, 0xC03F,      0,      0,
       0, 0x5962, 0xC040,      0, 0xC041,      0, 0x3478,      0,
-      0,      0, 0xC042, 0xC043, 0x3167, 0x7A2F, 0x5968,      0,
+      0,      0, 0xC042, 0xC043, 0x3167, 0xC044, 0x5968,      0,
  0xC045, 0xC046, 0x4D49,      0,      0,      0,      0,      0,
 };
 const unsigned short utf8_to_euc_E690[] = {
@@ -3634,7 +3712,7 @@ const unsigned short utf8_to_euc_E691[] = {
       0,      0,      0, 0xC059,      0,      0, 0x5977, 0xC05A,
       0, 0xC05B, 0xC05C, 0xC05D, 0xC05E,      0,      0,      0,
  0x4526,      0, 0xC05F, 0xC060, 0xC061, 0xC062,      0, 0xC063,
- 0x7A30, 0xC065,      0, 0xC066,      0,      0,      0, 0x5974,
+ 0xC064, 0xC065,      0, 0xC066,      0,      0,      0, 0x5974,
       0, 0x4B60,      0,      0,      0, 0xC067,      0, 0x5975,
       0,      0,      0, 0xC068, 0xC069,      0, 0x5976,      0,
  0x4C4E,      0, 0x4022, 0xC06A,      0, 0xC06B,      0,      0,
@@ -3643,7 +3721,7 @@ const unsigned short utf8_to_euc_E692[] = {
       0,      0,      0, 0x3762,      0, 0xC06C,      0, 0xC06D,
  0x597D,      0,      0,      0,      0,      0,      0, 0xC06E,
  0xC06F, 0xC070, 0x3B35, 0x597A,      0, 0x5979,      0,      0,
- 0xC071, 0xC072, 0x4732, 0xC073,      0, 0x7A31, 0x4635, 0xC075,
+ 0xC071, 0xC072, 0x4732, 0xC073,      0, 0xC074, 0x4635, 0xC075,
       0, 0xC076,      0, 0xC077, 0x4531, 0x597B, 0xC078,      0,
  0xC079, 0x597C,      0, 0x496F, 0xC07A, 0x4745, 0x3B23,      0,
  0x4071,      0, 0x4B50, 0xC07B,      0,      0,      0,      0,
@@ -3651,7 +3729,7 @@ const unsigned short utf8_to_euc_E692[] = {
 };
 const unsigned short utf8_to_euc_E693[] = {
       0, 0x4D4A, 0x5A27,      0, 0xC121, 0x5A23,      0, 0x5A24,
-      0, 0xC122, 0xC123, 0xC124, 0xC125, 0x4160, 0x7A32,      0,
+      0, 0xC122, 0xC123, 0xC124, 0xC125, 0x4160, 0xC126,      0,
  0xC127, 0xC128, 0x5A22,      0, 0x593F, 0xC129,      0, 0xC12A,
  0x5A26,      0, 0x5A21,      0,      0,      0,      0,      0,
  0x5A2B, 0x5A2C, 0x4527, 0x5A2E, 0xC12B, 0xC12C, 0x3B24, 0x5A29,
@@ -3671,7 +3749,7 @@ const unsigned short utf8_to_euc_E694[] = {
 };
 const unsigned short utf8_to_euc_E695[] = {
       0,      0,      0, 0xC14A,      0, 0x384E,      0, 0xC14B,
- 0x5A43, 0xC14C,      0,      0,      0, 0x5A46, 0x7A33, 0x4952,
+ 0x5A43, 0xC14C,      0,      0,      0, 0x5A46, 0xF441, 0x4952,
  0xC14D, 0x355F, 0xC14E,      0, 0xC14F, 0x5A45, 0x5A44, 0x4754,
  0x5A47, 0x3635,      0,      0,      0, 0x5A49, 0x5A48, 0xC150,
  0xC151,      0, 0x343A, 0x3B36,      0,      0, 0x4658, 0xC152,
@@ -3700,34 +3778,34 @@ const unsigned short utf8_to_euc_E697[] = {
       0, 0xC172, 0x3222, 0x5A61,      0,      0, 0xC173, 0xC174,
 };
 const unsigned short utf8_to_euc_E698[] = {
- 0x7A34,      0, 0x3937, 0x5A60, 0xC176,      0, 0x3A2B, 0x3E3A,
- 0xC177, 0x7A37, 0x5A5F,      0, 0x3E3B, 0xC179, 0x4C40, 0x3A2A,
-      0, 0xC17A, 0xC17B, 0x3057, 0x404E, 0x7A35, 0xC17D,      0,
-      0,      0,      0,      0, 0x5A66, 0xC17E, 0x7A39, 0x4031,
- 0x3147, 0xC222, 0xC223, 0xC224, 0x7A3A, 0x3D55, 0xC226, 0x4B66,
- 0x3A72, 0xC227, 0xC228, 0xC229, 0xC22A, 0x3E3C, 0x7A38, 0x4027,
- 0xC22C, 0x7928,      0, 0xC22E, 0x5A65, 0x5A63, 0x5A64, 0xC230,
-      0, 0xC22F,      0, 0x7A36, 0x436B,      0,      0, 0x5B26,
+ 0xC175,      0, 0x3937, 0x5A60, 0xC176,      0, 0x3A2B, 0x3E3A,
+ 0xC177, 0xC178, 0x5A5F,      0, 0x3E3B, 0xC179, 0x4C40, 0x3A2A,
+      0, 0xC17A, 0xC17B, 0x3057, 0x404E, 0xC17C, 0xC17D,      0,
+      0,      0,      0,      0, 0x5A66, 0xC17E, 0xC221, 0x4031,
+ 0x3147, 0xC222, 0xC223, 0xC224, 0xC225, 0x3D55, 0xC226, 0x4B66,
+ 0x3A72, 0xC227, 0xC228, 0xC229, 0xC22A, 0x3E3C, 0xC22B, 0x4027,
+ 0xC22C, 0xC22D,      0, 0xC22E, 0x5A65, 0x5A63, 0x5A64, 0xC230,
+      0, 0xC22F,      0, 0xF442, 0x436B,      0,      0, 0x5B26,
 };
 const unsigned short utf8_to_euc_E699[] = {
  0xC231, 0x5A6A, 0x3B7E, 0x3938, 0x5A68, 0xC232, 0xC233,      0,
       0, 0x5A69, 0xC234, 0x3F38, 0xC235,      0, 0xC237, 0x5A67,
-      0, 0xC236, 0x3B2F,      0,      0,      0,      0, 0x7A3C,
- 0xC239, 0x7A3D,      0, 0xC23B, 0xC23C, 0x5A6C, 0x5A6B, 0x5A70,
- 0xC23D, 0xC23E, 0x5A71,      0, 0x5A6D, 0x7A3B, 0x3322, 0x5A6E,
+      0, 0xC236, 0x3B2F,      0,      0,      0,      0, 0xC238,
+ 0xC239, 0xC23A,      0, 0xC23B, 0xC23C, 0x5A6C, 0x5A6B, 0x5A70,
+ 0xC23D, 0xC23E, 0x5A71,      0, 0x5A6D, 0xF443, 0x3322, 0x5A6E,
  0x5A6F, 0x4855, 0xC240, 0xC241, 0xC242,      0, 0x4961, 0x374A,
- 0x5A72,      0,      0, 0x7A3F, 0x4032, 0xC245, 0x3E3D, 0xC247,
+ 0x5A72,      0,      0, 0xC244, 0x4032, 0xC245, 0x3E3D, 0xC247,
  0xC248, 0xC249, 0x4352, 0xC24A, 0xC24C,      0, 0xC243, 0xC246,
 };
 const unsigned short utf8_to_euc_E69A[] = {
  0xC24B, 0x3647,      0, 0x5A73, 0x5A77,      0,      0, 0x324B,
  0x5A74, 0x5A76,      0, 0xC24D, 0xC24E, 0xC24F, 0x5A75,      0,
  0xC250, 0x3D6B, 0xC251,      0,      0,      0, 0x4348, 0x3045,
- 0x5A78, 0x7A40, 0xC253, 0xC254, 0xC255, 0x5A79,      0, 0xC256,
- 0x7A41,      0, 0x442A,      0, 0xC258,      0, 0x4E71,      0,
+ 0x5A78, 0xC252, 0xC253, 0xC254, 0xC255, 0x5A79,      0, 0xC256,
+ 0xC257,      0, 0x442A,      0, 0xC258,      0, 0x4E71,      0,
       0,      0,      0, 0x3B43,      0, 0xC259, 0x4A6B,      0,
-      0, 0xC25A, 0x7A42,      0, 0x4B3D, 0xC25C,      0,      0,
- 0x5B22, 0x5A7B,      0, 0xC25D, 0x5A7E,      0, 0x5A7D, 0x7A43,
+      0, 0xC25A, 0xC25B,      0, 0x4B3D, 0xC25C,      0,      0,
+ 0x5B22, 0x5A7B,      0, 0xC25D, 0x5A7E,      0, 0x5A7D, 0xC25E,
 };
 const unsigned short utf8_to_euc_E69B[] = {
  0xC25F, 0x5A7A, 0xC260, 0xC261, 0x5B21,      0,      0, 0x465E,
@@ -3737,11 +3815,11 @@ const unsigned short utf8_to_euc_E69B[] = {
  0x5B25,      0,      0,      0,      0,      0, 0x5B27,      0,
  0xC269, 0x5B28,      0, 0xC26A, 0xC26B,      0, 0xC26C,      0,
  0x5B29,      0, 0x364A, 0x3148, 0x3939, 0x5B2A,      0, 0x5B2B,
- 0x3D71, 0x4162, 0x7A44, 0x792B, 0x5258, 0x413E, 0x413D, 0x4258,
+ 0x3D71, 0x4162, 0xC26D, 0xC23F, 0x5258, 0x413E, 0x413D, 0x4258,
 };
 const unsigned short utf8_to_euc_E69C[] = {
  0x3A47,      0,      0, 0x5072,      0, 0xC26E,      0, 0xC26F,
- 0x376E, 0x4D2D,      0, 0x4A7E,      0, 0x497E, 0x7A45, 0x5B2C,
+ 0x376E, 0x4D2D,      0, 0x4A7E,      0, 0x497E, 0xC270, 0x5B2C,
       0,      0,      0, 0xC271, 0x3A73, 0x443F, 0x5B2D, 0x4F2F,
       0, 0xC272,      0, 0x4B3E, 0xC273, 0x442B, 0x5B2E, 0x347C,
  0xC274,      0, 0xC275,      0,      0,      0, 0x5B2F, 0x5B30,
@@ -3754,7 +3832,7 @@ const unsigned short utf8_to_euc_E69D[] = {
  0xC27A, 0x3F79,      0,      0, 0xC27B,      0, 0x4D7B, 0x3049,
  0x3A60, 0x423C,      0, 0x3C5D, 0xC27C, 0xC27D, 0x3E73,      0,
       0, 0x5B3B,      0,      0, 0x454E, 0xC27E, 0x5B39, 0x422B,
- 0x5B3A, 0x3E72, 0x4C5D, 0x5B3C, 0x5B3D, 0x4D68, 0x7A47,      0,
+ 0x5B3A, 0x3E72, 0x4C5D, 0x5B3C, 0x5B3D, 0x4D68, 0xC321,      0,
       0,      0, 0x5B42,      0, 0xC322, 0x393A, 0xC323, 0x4755,
  0x5B3F, 0x456C, 0x5A5E, 0x5A62, 0xC324, 0x354F, 0xC325, 0x4747,
       0,      0,      0, 0xC326, 0x5B41,      0, 0x3E3E, 0x4844,
@@ -3767,10 +3845,10 @@ const unsigned short utf8_to_euc_E69E[] = {
  0x4F48, 0x5B46, 0x3F75,      0,      0,      0, 0x5B45,      0,
       0, 0x5B40,      0,      0,      0,      0,      0, 0x384F,
  0xC331, 0xC332, 0xC333, 0x5B4C, 0x5B4A, 0xC334, 0x324D, 0x5B48,
- 0x5B4E, 0x5B54,      0, 0x7A48, 0xC336, 0xC337,      0,      0,
+ 0x5B4E, 0x5B54,      0, 0xC335, 0xC336, 0xC337,      0,      0,
 };
 const unsigned short utf8_to_euc_E69F[] = {
- 0x7A4A, 0x4248, 0xC33A, 0xC33B, 0x4A41, 0xC33C, 0x5B56,      0,
+ 0xC339, 0x4248, 0xC33A, 0xC33B, 0x4A41, 0xC33C, 0x5B56,      0,
  0xC33D, 0xC33E, 0x4922,      0,      0,      0, 0x5B55, 0x4770,
  0x4B3F, 0x343B, 0xC33F, 0x4077, 0x3D40,      0,      0, 0xC340,
  0x4453, 0xC341, 0x4D2E,      0, 0xC342, 0x5B51, 0x5B50,      0,
@@ -3780,7 +3858,7 @@ const unsigned short utf8_to_euc_E69F[] = {
       0, 0xC338,      0, 0x3A3A,      0,      0, 0x4B6F, 0x3341,
 };
 const unsigned short utf8_to_euc_E6A0[] = {
-      0, 0x7A4B, 0x444E, 0x464A, 0x3149,      0,      0,      0,
+      0, 0xF446, 0x444E, 0x464A, 0x3149,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0, 0x4072, 0xC34A,      0, 0x4034, 0x372A,
       0, 0xC34B,      0,      0,      0, 0xC34C, 0x5B59, 0xC34D,
@@ -3790,9 +3868,9 @@ const unsigned short utf8_to_euc_E6A0[] = {
  0x334B, 0x3A2C,      0, 0xC356, 0x334A, 0x3A4F,      0, 0xC357,
 };
 const unsigned short utf8_to_euc_E6A1[] = {
- 0x5B5C, 0x3765, 0x374B, 0x456D, 0x7A4C, 0xC359, 0x5B5A,      0,
+ 0x5B5C, 0x3765, 0x374B, 0x456D, 0xC358, 0xC359, 0x5B5A,      0,
  0x3046,      0, 0xC35A,      0, 0xC35B, 0x5B5D, 0x5B5F,      0,
- 0x364D, 0x372C, 0x7A49, 0x343C, 0x354B, 0xC35C,      0, 0xC35D,
+ 0x364D, 0x372C, 0xC349, 0x343C, 0x354B, 0xC35C,      0, 0xC35D,
  0xC35E, 0x5B62,      0, 0xC35F, 0x3A79, 0x4B71,      0, 0x3B37,
       0,      0,      0, 0x5B63,      0,      0,      0, 0x4930,
       0,      0,      0, 0xC360,      0,      0, 0xC361, 0xC362,
@@ -3811,7 +3889,7 @@ const unsigned short utf8_to_euc_E6A2[] = {
 };
 const unsigned short utf8_to_euc_E6A3[] = {
       0,      0,      0,      0, 0x347E, 0xC37B, 0x5C32,      0,
- 0x7929, 0x4C49, 0x5B77, 0x347D, 0xC37D, 0x5B7E,      0, 0x7A4D,
+ 0xC37C, 0x4C49, 0x5B77, 0x347D, 0xC37D, 0x5B7E,      0, 0xC37E,
  0xC421, 0xC422, 0x4B40, 0xC423, 0x5C21, 0x5C23, 0xC424, 0x5C27,
  0x5B79, 0xC425, 0x432A,      0, 0xC426, 0xC427,      0, 0x456F,
  0x5C2B, 0x5B7C,      0, 0x5C28,      0, 0xC428,      0, 0x5C22,
@@ -3835,7 +3913,7 @@ const unsigned short utf8_to_euc_E6A5[] = {
       0,      0,      0, 0x4976, 0x5C38, 0x424A,      0, 0xC446,
       0, 0x5C3E, 0x413F, 0xC447, 0x5C35, 0x5C42, 0x5C41,      0,
  0x466F, 0x5C40, 0x466A, 0xC448, 0xC449, 0xC44A, 0xC44B,      0,
- 0x7A4F, 0xC44D, 0x5C44, 0x5C37, 0xC44E, 0x3648, 0x5C3A, 0x3D5D,
+ 0xC44C, 0xC44D, 0x5C44, 0x5C37, 0xC44E, 0x3648, 0x5C3A, 0x3D5D,
  0xC44F, 0xC450, 0xC451, 0x4760, 0x5C3C, 0x364B,      0, 0x5C34,
  0x5C36, 0x5C33, 0xC452, 0xC453, 0x4F30, 0x335A, 0x5C39, 0xC454,
 };
@@ -3843,7 +3921,7 @@ const unsigned short utf8_to_euc_E6A6[] = {
  0xC455, 0x5C43, 0x3335,      0,      0,      0,      0,      0,
       0,      0, 0x3A67,      0,      0, 0xC456, 0x315D,      0,
       0, 0x5C54, 0xC457,      0, 0x4F31, 0x5C57, 0xC458,      0,
- 0x7A51,      0,      0, 0x3F3A, 0x5C56,      0,      0,      0,
+ 0xC459,      0,      0, 0x3F3A, 0x5C56,      0,      0,      0,
  0x5C55, 0xC45A,      0,      0,      0, 0xC45B, 0xC45C, 0x5C52,
  0xC45D,      0,      0, 0xC45E,      0, 0xC45F, 0x5C46, 0xC460,
       0, 0x5C63, 0x5C45,      0, 0x5C58,      0,      0, 0xC461,
@@ -3854,7 +3932,7 @@ const unsigned short utf8_to_euc_E6A7[] = {
  0xC466,      0, 0x5C4E, 0x393D, 0x4448, 0x4164, 0x5C4C,      0,
  0x5C47, 0xC467,      0, 0x5C4A,      0,      0, 0xC468, 0xC469,
  0x4D4D, 0x4B6A,      0,      0,      0, 0x5C4F, 0x5C59,      0,
-      0,      0, 0x7A52,      0,      0, 0xC46B,      0, 0x5C61,
+      0,      0, 0xC46A,      0,      0, 0xC46B,      0, 0x5C61,
  0x5C5A,      0,      0, 0x5C67,      0, 0x5C65, 0xC46C, 0xC46D,
       0, 0xC46E, 0x5C60, 0xC46F,      0, 0xC470,      0,      0,
       0, 0x5C5F,      0, 0x4450,      0, 0x4165, 0xC471, 0x5C5D,
@@ -3866,18 +3944,18 @@ const unsigned short utf8_to_euc_E6A8[] = {
       0, 0x4938, 0xC478, 0x5C5C,      0, 0xC479, 0x5C64, 0x3E40,
  0xC47A, 0x4C4F, 0x5C78, 0x5C6B, 0xC47B,      0,      0,      0,
  0xC47C, 0x3822, 0x3223, 0x335F,      0,      0, 0x5C53,      0,
- 0x7A53,      0, 0xC47E,      0, 0xC521, 0x3E41, 0x5C70, 0xC522,
+ 0xC47D,      0, 0xC47E,      0, 0xC521, 0x3E41, 0x5C70, 0xC522,
  0x5C77, 0x3C79, 0x3372, 0xC523,      0, 0x432E, 0xC524, 0xC525,
 };
 const unsigned short utf8_to_euc_E6A9[] = {
-      0,      0,      0,      0, 0x5C6D, 0xC526, 0x7A55, 0x5C72,
+      0,      0,      0,      0, 0x5C6D, 0xC526, 0xC527, 0x5C72,
  0x5C76, 0xC528, 0xC529, 0x3636,      0,      0, 0xC52A,      0,
  0xC52B, 0xC52C, 0xC52D,      0,      0, 0xC52E, 0xC52F,      0,
  0x354C, 0x5C74,      0, 0xC530,      0,      0,      0, 0x3521,
       0, 0x464B, 0x5C73,      0, 0xC531,      0, 0x5C75, 0xC532,
-      0,      0, 0xC533, 0x7A54,      0,      0,      0,      0,
-      0, 0xC534, 0x5C6F, 0x7A56,      0,      0,      0,      0,
- 0x5C71,      0,      0,      0,      0,      0, 0x7A57, 0x3360,
+      0,      0, 0xC533, 0xF449,      0,      0,      0,      0,
+      0, 0xC534, 0x5C6F, 0xC535,      0,      0,      0,      0,
+ 0x5C71,      0,      0,      0,      0,      0, 0xC536, 0x3360,
 };
 const unsigned short utf8_to_euc_E6AA[] = {
  0x4349, 0xC537,      0, 0xC538, 0x5C7C,      0, 0xC539, 0xC53A,
@@ -3894,7 +3972,7 @@ const unsigned short utf8_to_euc_E6AB[] = {
  0xC54D, 0xC54C,      0,      0, 0xC54E,      0,      0,      0,
  0xC54F, 0x5D2A,      0, 0x4F26, 0xC550, 0xC551, 0xC552,      0,
       0,      0, 0x5D2D, 0x367B, 0xC553, 0xC554, 0x5D29, 0x5D2B,
-      0,      0, 0x7A58,      0, 0x7A59,      0,      0, 0xC556,
+      0,      0, 0xF44A,      0, 0xC555,      0,      0, 0xC556,
  0x4827,      0, 0x5D2E,      0, 0xC557,      0,      0,      0,
  0xC558, 0xC559, 0xC55A,      0,      0,      0,      0,      0,
       0,      0, 0x5D32, 0x5D2F, 0xC55B, 0xC55C,      0,      0,
@@ -3932,7 +4010,7 @@ const unsigned short utf8_to_euc_E6AE[] = {
 const unsigned short utf8_to_euc_E6AF[] = {
  0x544C,      0,      0, 0xC634, 0xC635, 0x3523, 0x5D58,      0,
       0, 0xC636,      0, 0x5D59, 0xC637, 0x4A6C, 0x4B68,      0,
-      0,      0, 0x4647, 0x5D5A, 0x4866,      0, 0x7A5A,      0,
+      0,      0, 0x4647, 0x5D5A, 0x4866,      0, 0xC638,      0,
  0x487B,      0, 0xC639, 0x4C53,      0,      0,      0, 0x5D5B,
       0, 0xC63A,      0, 0xC63B,      0,      0, 0xC63C, 0xC63D,
       0,      0,      0, 0x5D5D, 0x5D5C,      0, 0xC63E, 0x5D5F,
@@ -3947,20 +4025,20 @@ const unsigned short utf8_to_euc_E6B0[] = {
       0,      0,      0, 0x5D66, 0x5D65,      0, 0xC64D, 0xC64E,
  0xC64F,      0,      0,      0, 0xC650,      0, 0xC651,      0,
       0,      0,      0, 0xC652, 0x3F65, 0xC653, 0xC654, 0x4939,
- 0x314A,      0, 0xC655, 0xC656,      0,      0, 0x4845, 0x7A5B,
+ 0x314A,      0, 0xC655, 0xC656,      0,      0, 0x4845, 0xC657,
 };
 const unsigned short utf8_to_euc_E6B1[] = {
  0x4475, 0x3D41, 0x3561,      0,      0,      0,      0,      0,
       0,      0, 0xC658, 0xC659,      0, 0xC65A, 0x4846, 0xC65B,
  0x3C2E,      0, 0xC65C,      0, 0xC65D, 0x5D68,      0, 0x3440,
-      0, 0xC65E, 0x3178, 0xC65F, 0x7A5C, 0x4672, 0x5D67, 0x393E,
+      0, 0xC65E, 0x3178, 0xC65F, 0xC660, 0x4672, 0x5D67, 0x393E,
  0x4353,      0, 0x5D69,      0,      0,      0,      0, 0xC736,
- 0x5D71,      0, 0x5D6A, 0xC661,      0, 0xC662,      0, 0x7A5E,
+ 0x5D71,      0, 0x5D6A, 0xC661,      0, 0xC662,      0, 0xC663,
  0x4241,      0, 0x3562, 0x5D72, 0xC664,      0, 0xC665,      0,
  0xC666, 0xC667, 0x3768, 0xC668,      0, 0x3525, 0x5D70,      0,
 };
 const unsigned short utf8_to_euc_E6B2[] = {
-      0, 0x5D6E, 0x5D6B, 0x4D60,      0, 0xC669, 0x7A5D, 0xC66B,
+      0, 0x5D6E, 0x5D6B, 0x4D60,      0, 0xC669, 0xC66A, 0xC66B,
  0x4440, 0xC66C,      0,      0, 0x4659, 0x5D6C,      0,      0,
  0x5D74,      0, 0x5D73, 0x3723, 0xC66D, 0xC66E, 0x322D, 0xC66F,
  0xC670, 0x3A3B, 0x5D6D, 0x5D6F, 0xC671,      0,      0, 0xC672,
@@ -3973,14 +4051,14 @@ const unsigned short utf8_to_euc_E6B3[] = {
       0, 0x3637, 0xC676,      0, 0x5D75, 0x5D7A, 0xC677,      0,
       0, 0x4074, 0x4771,      0, 0x4867, 0xC678,      0, 0xC679,
  0xC67A, 0xC67B, 0xC67C, 0x5D77, 0xC67D, 0x4B21, 0xC67E, 0x5D79,
-      0, 0x5E24, 0x7A5F, 0x5E22, 0xC722, 0x5D7B,      0,      0,
+      0, 0x5E24, 0xC721, 0x5E22, 0xC722, 0x5D7B,      0,      0,
  0xC723, 0x4B22, 0x4748, 0x3563,      0, 0x4525,      0, 0xC724,
  0x436D, 0xC725, 0x5E25, 0xC726, 0xC727,      0, 0xC728, 0x5E23,
  0x4259, 0x5D76, 0xC729, 0x314B, 0xC72A,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
 };
 const unsigned short utf8_to_euc_E6B4[] = {
-      0,      0,      0,      0, 0x7A60,      0,      0, 0xC72C,
+      0,      0,      0,      0, 0xC72B,      0,      0, 0xC72C,
       0,      0, 0xC72D, 0x4D4E, 0x5E30,      0, 0xC72E, 0xC72F,
       0, 0xC730, 0x5E2F, 0xC731,      0,      0,      0, 0x4076,
       0, 0x5E2C, 0xC732, 0x4D6C,      0,      0, 0x4636, 0x5E26,
@@ -3995,45 +4073,45 @@ const unsigned short utf8_to_euc_E6B5[] = {
       0,      0,      0,      0,      0,      0,      0, 0xC73D,
       0, 0x5E36, 0x5E34,      0, 0x494D,      0, 0xC73E, 0xC73F,
       0, 0xC740,      0, 0x5E31, 0x5E33, 0xC741, 0x313A, 0xC742,
-      0, 0x3940, 0x4F32,      0, 0x333D,      0, 0x4962, 0x7A62,
+      0, 0x3940, 0x4F32,      0, 0x333D,      0, 0x4962, 0xC743,
  0xC744,      0,      0,      0, 0x4D61,      0,      0, 0x3324,
  0x3F3B, 0x5E35,      0,      0, 0xC745,      0,      0,      0,
 };
 const unsigned short utf8_to_euc_E6B6[] = {
-      0,      0, 0xC746,      0,      0, 0x5E3A,      0, 0x7A61,
+      0,      0, 0xC746,      0,      0, 0x5E3A,      0, 0xC747,
  0x3E43,      0,      0,      0, 0x4D30,      0, 0x5E37,      0,
-      0, 0xC748, 0xC749, 0x5E32, 0xC74A, 0x5E38, 0x7A63, 0xC74C,
+      0, 0xC748, 0xC749, 0x5E32, 0xC74A, 0x5E38, 0xC74B, 0xC74C,
  0xC74D, 0x4E5E,      0, 0x4573, 0x4642,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
-      0,      0, 0xC74E,      0, 0x7A64,      0,      0, 0x3336,
+      0,      0, 0xC74E,      0, 0xC74F,      0,      0, 0x3336,
       0,      0, 0x3155,      0, 0xC750, 0x5E3E,      0, 0xC751,
  0x5E41, 0xC752,      0,      0, 0x4E43, 0xC753,      0, 0xC754,
 };
 const unsigned short utf8_to_euc_E6B7[] = {
  0x4D64,      0,      0,      0, 0xC755, 0x5E48, 0x5E42, 0x5E3F,
- 0xC756,      0, 0xC757, 0x4E54, 0x5E45,      0, 0xC758, 0x7A65,
+ 0xC756,      0, 0xC757, 0x4E54, 0x5E45,      0, 0xC758, 0xC759,
       0, 0x3D4A, 0x5E47,      0,      0, 0x5E4C, 0xC75A,      0,
  0x4571, 0x5E4A,      0, 0xC75B,      0, 0xC75C, 0x5E44, 0xC75D,
  0xC75E, 0x4338, 0xC75F,      0, 0x5E4B, 0xC760, 0x5E40,      0,
  0x5E46, 0xC761, 0x5E4D, 0x307C, 0x5E43,      0, 0x5E4E, 0xC762,
- 0xC763, 0x3F3C, 0x7A67, 0x3D5F, 0xC764, 0x4A25, 0xC765, 0x3A2E,
- 0x7A66, 0x5E3B, 0x5E49, 0x453A, 0x7A68,      0,      0,      0,
+ 0xC763, 0x3F3C, 0xF44C, 0x3D5F, 0xC764, 0x4A25, 0xC765, 0x3A2E,
+ 0xF44B, 0x5E3B, 0x5E49, 0x453A, 0xC766,      0,      0,      0,
 };
 const unsigned short utf8_to_euc_E6B8[] = {
  0xC767,      0,      0,      0, 0xC768, 0x4036,      0, 0x3369,
  0x3A51, 0x3E44, 0x5E3D, 0x3D42,      0,      0,      0,      0,
       0,      0,      0, 0x374C,      0, 0x5E3C,      0,      0,
       0, 0x5E52, 0x3D6D, 0x383A,      0, 0x5E61, 0xC769, 0x5E5B,
- 0x3574, 0x454F, 0xC76A, 0x5E56, 0x5E5F, 0x302F, 0x3132, 0x7A6B,
+ 0x3574, 0x454F, 0xC76A, 0x5E56, 0x5E5F, 0x302F, 0x3132, 0xC76B,
       0, 0x3239,      0, 0x5E58, 0x422C, 0x5E4F, 0x5E51, 0x3941,
       0,      0, 0xC76C,      0,      0,      0, 0xC76D,      0,
- 0x5E62, 0x7A69, 0x5E5D, 0xC76F, 0x7A6C,      0, 0x5E55,      0,
+ 0x5E62, 0xC76E, 0x5E5D, 0xC76F, 0xC770,      0, 0x5E55,      0,
 };
 const unsigned short utf8_to_euc_E6B9[] = {
       0,      0,      0, 0x5E5C, 0xC771, 0xC772,      0,      0,
  0xC773, 0xC774, 0x4C2B, 0xC775,      0, 0x5E5A, 0x5E5E, 0xC776,
       0, 0xC777, 0xC778, 0xC779, 0xC77A,      0, 0x3850, 0xC77B,
- 0x3E45,      0,      0, 0x4339, 0x7A6A, 0xC77D, 0xC77E, 0x5E54,
+ 0x3E45,      0,      0, 0x4339, 0xC77C, 0xC77D, 0xC77E, 0x5E54,
       0,      0, 0xC821, 0xC822,      0,      0,      0, 0x4D2F,
  0xC823,      0,      0, 0x5E57,      0,      0, 0x5E50, 0x4572,
       0,      0, 0x5E53, 0xC824,      0,      0, 0x5E59,      0,
@@ -4047,7 +4125,7 @@ const unsigned short utf8_to_euc_E6BA[] = {
  0xC82A,      0, 0x306E,      0,      0, 0x5E70,      0, 0xC82B,
       0,      0, 0x5E64,      0,      0, 0xC82C, 0xC82D, 0x5E6A,
       0, 0xC82E, 0x5E6C, 0xC82F,      0,      0, 0x4D4F, 0x5E67,
-      0,      0, 0x452E, 0xC830,      0, 0x5E69,      0, 0x7A6D,
+      0,      0, 0x452E, 0xC830,      0, 0x5E69,      0, 0xC831,
 };
 const unsigned short utf8_to_euc_E6BB[] = {
  0xC832, 0xC833, 0x5E71, 0xC834, 0x5E6B, 0x4C47,      0, 0xC835,
@@ -4081,12 +4159,12 @@ const unsigned short utf8_to_euc_E6BD[] = {
 };
 const unsigned short utf8_to_euc_E6BE[] = {
  0x5F28, 0x5F27, 0x5F2D, 0xC863, 0x4021,      0, 0x5F24, 0xC864,
- 0x7A6E,      0,      0, 0xC866, 0xC867, 0xC868, 0x5F30,      0,
+ 0xC865,      0,      0, 0xC866, 0xC867, 0xC868, 0x5F30,      0,
  0xC869, 0x5F31, 0xC86A, 0xC86B, 0xC86C,      0, 0xC86D, 0x3442,
       0,      0, 0xC86E,      0,      0,      0,      0, 0xC86F,
  0xC870, 0x5F36,      0, 0x5F35, 0x5F37, 0xC871, 0xC872, 0xC873,
  0xC874,      0, 0x5F3A,      0,      0,      0, 0xC875, 0xC876,
- 0xC877, 0x4543,      0, 0x5F34,      0, 0x7A6F, 0xC879,      0,
+ 0xC877, 0x4543,      0, 0x5F34,      0, 0xC878, 0xC879,      0,
       0, 0x5F38,      0,      0, 0xC87A,      0,      0,      0,
 };
 const unsigned short utf8_to_euc_E6BF[] = {
@@ -4096,16 +4174,16 @@ const unsigned short utf8_to_euc_E6BF[] = {
  0x5F3F,      0, 0xC921, 0x5F42,      0,      0, 0xC922, 0x5F3B,
  0x396A, 0x4728,      0,      0, 0x5E39,      0,      0,      0,
  0xC923, 0xC924,      0, 0x4D74, 0x5F3D,      0, 0x5F41, 0x4275,
- 0xC925, 0x5F40,      0, 0x5F2B,      0, 0x7A70, 0x6F69,      0,
+ 0xC925, 0x5F40,      0, 0x5F2B,      0, 0xC926, 0x6F69,      0,
       0, 0xC927, 0x5F45,      0, 0xC928, 0xC929, 0x5F49,      0,
 };
 const unsigned short utf8_to_euc_E780[] = {
- 0xC92A, 0x5F47,      0,      0,      0, 0x7A71, 0xC92C, 0x7A72,
+ 0xC92A, 0x5F47,      0,      0,      0, 0xC92B, 0xC92C, 0xC92D,
       0, 0x5F43,      0, 0x5F44,      0, 0xC92E,      0, 0x5F48,
       0, 0x5F46,      0,      0,      0, 0x494E,      0, 0xC92F,
  0x5F4E,      0, 0x5F4B, 0x5F4A,      0, 0x5F4D, 0x4654, 0x5F4F,
  0xC930,      0,      0, 0xC931,      0,      0, 0x4375, 0x426D,
- 0x7A73,      0,      0,      0, 0x4025,      0,      0, 0xC932,
+ 0xF44D,      0,      0,      0, 0x4025,      0,      0, 0xC932,
  0x5F50,      0, 0x5F52,      0, 0xC933,      0,      0, 0xC934,
       0, 0xC935,      0,      0, 0xC936,      0, 0x5F51,      0,
 };
@@ -4120,14 +4198,14 @@ const unsigned short utf8_to_euc_E781[] = {
  0x3564,      0,      0,      0, 0x3C5E, 0x3A52, 0xC948,      0,
 };
 const unsigned short utf8_to_euc_E782[] = {
-      0, 0xC949,      0,      0,      0, 0x7A74, 0xC94B,      0,
+      0, 0xC949,      0,      0,      0, 0xC94A, 0xC94B,      0,
       0, 0x4F27, 0x3F66,      0,      0,      0, 0x316A,      0,
       0,      0, 0x5F56,      0, 0xC94C, 0xC94D, 0xC94E, 0xC94F,
  0xC950, 0x5F55,      0, 0xC951,      0,      0,      0,      0,
       0,      0,      0,      0, 0xC952,      0,      0,      0,
-      0,      0,      0, 0x7A75, 0x5F59, 0x433A, 0x5F5C, 0x5F57,
+      0,      0,      0, 0xC953, 0x5F59, 0x433A, 0x5F5C, 0x5F57,
  0xC954, 0xC955,      0, 0x5F5B, 0xC956,      0,      0, 0xC957,
- 0x5F5A, 0x4540, 0x3059, 0x7927,      0,      0,      0,      0,
+ 0x5F5A, 0x4540, 0x3059, 0xF42E,      0,      0,      0,      0,
 };
 const unsigned short utf8_to_euc_E783[] = {
       0,      0,      0,      0,      0,      0,      0,      0,
@@ -4140,8 +4218,8 @@ const unsigned short utf8_to_euc_E783[] = {
       0, 0x4B23, 0xC961,      0,      0, 0x5F62,      0,      0,
 };
 const unsigned short utf8_to_euc_E784[] = {
-      0,      0,      0, 0xC962, 0x7A77, 0xC964, 0xC965, 0xC966,
-      0, 0x5F61,      0, 0xC967, 0xC968,      0,      0, 0x7A76,
+      0,      0,      0, 0xC962, 0xC963, 0xC964, 0xC965, 0xC966,
+      0, 0x5F61,      0, 0xC967, 0xC968,      0,      0, 0xC969,
       0,      0,      0,      0, 0x316B,      0,      0,      0,
       0, 0x5F64, 0x4A32,      0, 0x5F63,      0, 0xC96A,      0,
  0xC96B, 0x4C35,      0,      0,      0,      0, 0x3E47,      0,
@@ -4150,10 +4228,10 @@ const unsigned short utf8_to_euc_E784[] = {
  0xC971,      0,      0,      0, 0x3E46,      0,      0,      0,
 };
 const unsigned short utf8_to_euc_E785[] = {
-      0, 0xC972,      0,      0,      0, 0xC973, 0x7A79, 0x7A7A,
+      0, 0xC972,      0,      0,      0, 0xC973, 0xC974, 0xC975,
       0, 0x4E7B, 0xC976, 0xC977, 0x5F6A,      0, 0x4079,      0,
  0xC978,      0, 0xC979,      0,      0, 0x5F66, 0x5F6B, 0xC97A,
-      0, 0x316C, 0xC97B,      0, 0x7A78,      0, 0xC97D,      0,
+      0, 0x316C, 0xC97B,      0, 0xC97C,      0, 0xC97D,      0,
  0xC97E,      0, 0x5F69,      0, 0x4761, 0x5F65, 0x5F68, 0x3E48,
  0xCA21, 0x4851,      0,      0, 0x5F6C,      0, 0x3C51,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
@@ -4170,14 +4248,14 @@ const unsigned short utf8_to_euc_E786[] = {
       0, 0x5F74, 0xCA30,      0,      0,      0, 0x5F75, 0xCA31,
 };
 const unsigned short utf8_to_euc_E787[] = {
- 0xCA32, 0x7A7C,      0, 0x4733, 0xCA34,      0,      0,      0,
+ 0xCA32, 0xCA33,      0, 0x4733, 0xCA34,      0,      0,      0,
  0x4575, 0x5F77,      0, 0xCA35, 0xCA36,      0, 0x5F79,      0,
  0x4E55,      0, 0x5F76, 0xCA37, 0x5F78, 0x316D, 0xCA38, 0x5F73,
       0, 0xCA39, 0xCA3A,      0, 0xCA3B,      0,      0, 0x535B,
  0x5F7A,      0,      0,      0,      0, 0x4167, 0x3B38, 0x5F7C,
       0,      0,      0,      0, 0x5F7B, 0x3F24, 0x5259,      0,
       0,      0,      0,      0,      0, 0x5F7D,      0,      0,
- 0xCA3C, 0x6021,      0, 0x5F6E, 0x5F7E,      0, 0x7A7D, 0x6022,
+ 0xCA3C, 0x6021,      0, 0x5F6E, 0x5F7E,      0, 0xCA3D, 0x6022,
 };
 const unsigned short utf8_to_euc_E788[] = {
  0xCA3E,      0,      0,      0,      0,      0, 0x477A, 0xCA3F,
@@ -4206,8 +4284,8 @@ const unsigned short utf8_to_euc_E78A[] = {
       0,      0,      0, 0xCA6B,      0,      0,      0,      0,
  0x353E,      0, 0x6039,      0,      0,      0,      0, 0x603A,
  0xCA6C,      0,      0,      0, 0x3824, 0xCA6D, 0xCA6E, 0x4848,
-      0, 0x7A7E, 0x603C,      0, 0xCA70,      0, 0x3E75,      0,
-      0, 0x603B,      0,      0,      0,      0, 0x7B21,      0,
+      0, 0xCA6F, 0x603C,      0, 0xCA70,      0, 0x3E75,      0,
+      0, 0x603B,      0,      0,      0,      0, 0xCA71,      0,
 };
 const unsigned short utf8_to_euc_E78B[] = {
       0, 0xCA72, 0x3638, 0x603D, 0x603F,      0, 0x603E, 0xCA73,
@@ -4224,7 +4302,7 @@ const unsigned short utf8_to_euc_E78C[] = {
       0,      0, 0x6049, 0xCB26,      0, 0xCB27,      0,      0,
       0,      0, 0xCB28, 0xCB29,      0,      0, 0x604B, 0x6048,
  0xCB2A, 0xCB2B,      0, 0x4C54, 0x604A, 0x604C, 0xCB2C, 0x4E44,
-      0,      0, 0xCB2D,      0, 0x7B22, 0x6050,      0, 0xCB2F,
+      0,      0, 0xCB2D,      0, 0xCB2E, 0x6050,      0, 0xCB2F,
  0xCB30, 0x604F, 0x4376, 0x472D, 0xCB31,      0, 0x3825, 0x604E,
       0, 0xCB32, 0xCB33,      0, 0x604D, 0xCB34, 0x4D31, 0x4D32,
       0,      0, 0xCB35, 0xCB36,      0, 0xCB37, 0x6051, 0x316E,
@@ -4236,7 +4314,7 @@ const unsigned short utf8_to_euc_E78D[] = {
  0xCB3D,      0,      0,      0,      0, 0xCB3E, 0xCB3F, 0xCB40,
  0xCB41,      0,      0, 0x3D43,      0,      0, 0xCB42, 0xCB43,
  0x6057, 0xCB44, 0x6056, 0xCB45, 0xCB46,      0, 0xCB47, 0xCB48,
- 0x6058, 0xCB49, 0x334D,      0,      0, 0x605A,      0, 0x7B24,
+ 0x6058, 0xCB49, 0x334D,      0,      0, 0x605A,      0, 0xCB4A,
  0x6059, 0xCB4B, 0x605C, 0x605B, 0xCB4C,      0,      0,      0,
 };
 const unsigned short utf8_to_euc_E78E[] = {
@@ -4247,25 +4325,25 @@ const unsigned short utf8_to_euc_E78E[] = {
  0xCB5B,      0, 0xCB5C,      0,      0, 0xCB5D, 0xCB5E,      0,
       0, 0x3461, 0xCB5F, 0xCB60,      0, 0xCB61,      0,      0,
       0,      0, 0x4E68, 0x605E,      0, 0xCB62,      0, 0xCB63,
-      0, 0xCB64,      0, 0x6060, 0xCB65, 0x7B25,      0, 0xCB67,
+      0, 0xCB64,      0, 0x6060, 0xCB65, 0xCB66,      0, 0xCB67,
 };
 const unsigned short utf8_to_euc_E78F[] = {
  0x6061,      0, 0x3251,      0,      0, 0xCB68, 0xCB69,      0,
- 0x605D, 0x7B26, 0x3B39, 0xCB6B, 0xCB6C, 0x4441, 0x605F, 0xCB6D,
-      0,      0, 0x7B29, 0xCB6F,      0,      0, 0x7B27,      0,
+ 0x605D, 0xCB6A, 0x3B39, 0xCB6B, 0xCB6C, 0x4441, 0x605F, 0xCB6D,
+      0,      0, 0xCB6E, 0xCB6F,      0,      0, 0xCB70,      0,
       0, 0xCB71,      0,      0,      0, 0xCB72, 0x6064,      0,
- 0x3C6E, 0xCB73,      0, 0x7B28,      0, 0x6062, 0xCB75, 0xCB76,
+ 0x3C6E, 0xCB73,      0, 0xCB74,      0, 0x6062, 0xCB75, 0xCB76,
       0, 0xCB77, 0x373E,      0,      0, 0x4849, 0x6063,      0,
-      0, 0x607E,      0,      0, 0xCB78, 0x7B2B,      0, 0xCB7A,
+      0, 0x607E,      0,      0, 0xCB78, 0xCB79,      0, 0xCB7A,
  0x6069, 0xCB7B, 0xCB7C, 0xCB7D,      0, 0xCB7E, 0x383D, 0xCC21,
 };
 const unsigned short utf8_to_euc_E790[] = {
- 0xCC22, 0xCC23,      0, 0x3565, 0xCC24, 0x6066, 0x4D7D, 0x7B2A,
+ 0xCC22, 0xCC23,      0, 0x3565, 0xCC24, 0x6066, 0x4D7D, 0xCC25,
       0, 0x4E30, 0xCC26,      0,      0,      0,      0,      0,
       0, 0xCC27,      0,      0,      0,      0,      0,      0,
       0,      0, 0xCC28, 0xCC29,      0,      0,      0,      0,
-      0,      0, 0x4276,      0, 0xCC2A, 0x6068, 0x7B2C,      0,
- 0xCC2C, 0x7B2E, 0x7B2D, 0xCC2F, 0xCC30, 0xCC31, 0x7B2F, 0xCC33,
+      0,      0, 0x4276,      0, 0xCC2A, 0x6068, 0xCC2B,      0,
+ 0xCC2C, 0xCC2D, 0xCC2E, 0xCC2F, 0xCC30, 0xCC31, 0xCC32, 0xCC33,
  0xCC34, 0xCC35, 0x606A, 0x4E56, 0x3657, 0x487C, 0x474A,      0,
       0, 0xCC36, 0x606B,      0,      0,      0,      0, 0x606D,
 };
@@ -4274,16 +4352,16 @@ const unsigned short utf8_to_euc_E791[] = {
       0,      0,      0, 0xCC3C,      0, 0xCC3D,      0,      0,
       0, 0xCC3E, 0xCC3F,      0,      0, 0x606C,      0, 0xCC40,
       0, 0x606F, 0x386A, 0x314D, 0x6071, 0xCC41, 0x3F70, 0x606E,
- 0x4E5C,      0, 0x7B30, 0x6074, 0x7424,      0, 0xCC43, 0xCC44,
+ 0x4E5C,      0, 0xCC42, 0x6074, 0x7424,      0, 0xCC43, 0xCC44,
  0xCC45, 0x6072, 0x6075, 0xCC46,      0, 0xCC47, 0xCC48, 0x6067,
  0x6073, 0xCC49, 0xCC4A, 0x3A3C,      0,      0, 0x6076,      0,
       0,      0,      0,      0,      0,      0, 0x6077,      0,
 };
 const unsigned short utf8_to_euc_E792[] = {
  0xCC4B, 0xCC4C,      0, 0x4D7E,      0, 0xCC4D, 0xCC4E, 0xCC4F,
-      0, 0x7B31,      0, 0x6078,      0,      0,      0, 0xCC51,
+      0, 0xCC50,      0, 0x6078,      0,      0,      0, 0xCC51,
  0xCC52, 0xCC53, 0xCC54,      0,      0,      0,      0,      0,
- 0xCC55, 0xCC56, 0xCC57,      0, 0xCC58,      0, 0x6079, 0x7B32,
+ 0xCC55, 0xCC56, 0xCC57,      0, 0xCC58,      0, 0x6079, 0xCC59,
  0xCC5A, 0xCC5B, 0x6065, 0xCC5C,      0,      0, 0xCC5D, 0x607A,
  0xCC5E, 0xCC5F, 0xCC60, 0xCC61,      0,      0, 0xCC62, 0xCC63,
  0x3444, 0xCC64, 0xCC65,      0,      0, 0xCC66,      0,      0,
@@ -4300,12 +4378,12 @@ const unsigned short utf8_to_euc_E793[] = {
  0x6129,      0, 0xCC7A, 0xCC7B, 0xCC7C,      0,      0, 0xCC7D,
 };
 const unsigned short utf8_to_euc_E794[] = {
-      0, 0x7B33,      0, 0x612C, 0x612B, 0x612D, 0xCC7E,      0,
+      0, 0xF450,      0, 0x612C, 0x612B, 0x612D, 0xCC7E,      0,
       0,      0,      0,      0, 0x612E, 0x6130, 0x612F,      0,
       0, 0x3979, 0xCD21, 0x6132,      0, 0x6131, 0xCD22, 0xCD23,
  0x3445,      0, 0x3F53,      0, 0x453C,      0, 0x6133, 0x4038,
  0xCD24, 0xCD25,      0, 0x3B3A, 0xCD26, 0x3179, 0x6134, 0xCD27,
- 0x4D51, 0xCD28, 0xCD29, 0x4A63, 0x6135,      0,      0, 0x796C,
+ 0x4D51, 0xCD28, 0xCD29, 0x4A63, 0x6135,      0,      0, 0xCD2A,
  0x4544, 0x4D33, 0x3943, 0x3F3D,      0,      0, 0xCD2B, 0x434B,
  0x5234, 0xCD2C, 0x442E, 0x3268, 0x6136, 0xCD2D, 0xCD2E, 0xCD2F,
 };
@@ -4315,7 +4393,7 @@ const unsigned short utf8_to_euc_E795[] = {
  0xCD35, 0x482A, 0xCD36,      0, 0x484A,      0,      0, 0xCD37,
       0, 0x4E31, 0x613D, 0x613B, 0x435C, 0x4026, 0xCD38, 0xCD39,
  0x482B, 0xCD3A, 0x492D,      0, 0x613F, 0x4E2C, 0x374D, 0x6140,
-      0, 0x613E, 0x4856, 0x6141,      0, 0x6142,      0, 0x7B34,
+      0, 0x613E, 0x4856, 0x6141,      0, 0x6142,      0, 0xCD3B,
  0x305B, 0xCD3C,      0, 0x3E76, 0x6147,      0, 0x6144, 0x466D,
  0x6143, 0xCD3D, 0xCD3E, 0xCD3F, 0xCD40, 0xCD41, 0xCD42, 0x3526,
 };
@@ -4360,11 +4438,11 @@ const unsigned short utf8_to_euc_E799[] = {
  0x6223,      0, 0x482F, 0x4550, 0x6224, 0x4772, 0x4934,      0,
 };
 const unsigned short utf8_to_euc_E79A[] = {
- 0x6225, 0xCE35, 0x7B35, 0x6226, 0x452A, 0xCE36, 0x3327, 0x3944,
+ 0x6225, 0xCE35, 0xF451, 0x6226, 0x452A, 0xCE36, 0x3327, 0x3944,
  0x6227,      0,      0, 0x6228, 0xCE37, 0xCE38, 0x6229,      0,
  0x3B29,      0,      0, 0x622B,      0, 0xCE39, 0x622A,      0,
-      0, 0x622C, 0x622D, 0x7B38, 0x7B36, 0xCE3C, 0x7B37, 0xCE3D,
- 0xCE3E,      0, 0xCE3F, 0xCE40, 0xCE41, 0xCE42, 0x7B39, 0xCE44,
+      0, 0x622C, 0x622D, 0xCE3A, 0xCE3B, 0xCE3C, 0xF452, 0xCE3D,
+ 0xCE3E,      0, 0xCE3F, 0xCE40, 0xCE41, 0xCE42, 0xCE43, 0xCE44,
  0xCE45,      0, 0xCE46,      0,      0, 0xCE47, 0x4869,      0,
  0x622E,      0,      0,      0, 0x622F,      0,      0, 0x7369,
  0x6230, 0x6231, 0x6232,      0,      0, 0xCE48,      0, 0x3B2E,
@@ -4390,7 +4468,7 @@ const unsigned short utf8_to_euc_E79C[] = {
  0x6248, 0xCE6D, 0x442F,      0, 0x3463, 0xCE6E, 0xCE6F,      0,
 };
 const unsigned short utf8_to_euc_E79D[] = {
- 0x4365,      0, 0xCE70,      0,      0, 0xCE71, 0x7B3B, 0x6249,
+ 0x4365,      0, 0xCE70,      0,      0, 0xCE71, 0xCE72, 0x6249,
       0,      0, 0xCE73,      0,      0, 0xCE74, 0xCE75, 0xCE76,
       0,      0, 0xCE77,      0,      0,      0, 0xCE78, 0xCE79,
       0,      0, 0x624A, 0x624D, 0xCE7A,      0, 0xCE7B, 0xCE7C,
@@ -4424,20 +4502,20 @@ const unsigned short utf8_to_euc_E7A0[] = {
       0, 0xCF50,      0,      0, 0x6266, 0xCF51, 0xCF52,      0,
       0, 0xCF53, 0x6267,      0, 0x3826, 0x3A55,      0,      0,
       0,      0,      0,      0,      0, 0xCF54,      0,      0,
- 0x6269, 0x7B3D, 0xCF56, 0xCF57,      0, 0x4556, 0x3A56, 0x354E,
+ 0x6269, 0xCF55, 0xCF56, 0xCF57,      0, 0x4556, 0x3A56, 0x354E,
       0,      0,      0,      0,      0, 0xCF58, 0xCF59,      0,
  0xCF5A,      0, 0x4B24,      0, 0x474B, 0xCF5B,      0, 0xCF5C,
       0,      0, 0x4557,      0,      0,      0,      0, 0x395C,
 };
 const unsigned short utf8_to_euc_E7A1[] = {
       0,      0,      0, 0xCF5D, 0xCF5E, 0x626B,      0, 0xCF5F,
- 0xCF60,      0,      0,      0, 0xCF61,      0, 0x7B3E,      0,
+ 0xCF60,      0,      0,      0, 0xCF61,      0, 0xCF62,      0,
       0,      0, 0xCF63,      0,      0,      0,      0,      0,
       0,      0,      0,      0, 0xCF64, 0x3E4B, 0xCF65,      0,
- 0xCF66, 0xCF67,      0, 0xCF68, 0x7B3F,      0,      0,      0,
+ 0xCF66, 0xCF67,      0, 0xCF68, 0xCF69,      0,      0,      0,
  0xCF6A,      0, 0xCF6B, 0x4E32, 0x3945,      0, 0xCF6C, 0x3827,
       0,      0, 0x4823,      0, 0x626D,      0,      0,      0,
-      0,      0, 0x7B40,      0, 0x626F,      0, 0xCF6E,      0,
+      0,      0, 0xCF6D,      0, 0x626F,      0, 0xCF6E,      0,
 };
 const unsigned short utf8_to_euc_E7A2[] = {
       0, 0x386B,      0,      0,      0,      0, 0x626E, 0x4476,
@@ -4466,7 +4544,7 @@ const unsigned short utf8_to_euc_E7A4[] = {
       0, 0x6328, 0xD03F,      0, 0xD040,      0, 0xD041, 0xD042,
  0xD043,      0,      0,      0,      0, 0xD044, 0x6268, 0xD045,
       0, 0xD046, 0x626A, 0x632A, 0x6329, 0xD047,      0,      0,
- 0x7B41, 0xD048,      0,      0, 0xD049, 0xD04A,      0,      0,
+ 0xF454, 0xD048,      0,      0, 0xD049, 0xD04A,      0,      0,
       0,      0, 0x3C28, 0xD04B, 0x4E69, 0xD04C, 0x3C52, 0xD04D,
 };
 const unsigned short utf8_to_euc_E7A5[] = {
@@ -4482,8 +4560,8 @@ const unsigned short utf8_to_euc_E7A5[] = {
 const unsigned short utf8_to_euc_E7A6[] = {
  0x6349, 0x3658,      0,      0, 0x4F3D, 0x4135,      0,      0,
       0,      0, 0x6334, 0xD061, 0xD062, 0x3252, 0x4477, 0x4A21,
-      0, 0xD063,      0, 0xD064, 0x7B45, 0xD066, 0xD067,      0,
- 0xD068,      0,      0, 0x7B47, 0xD06A, 0x6335,      0,      0,
+      0, 0xD063,      0, 0xD064, 0xD065, 0xD066, 0xD067,      0,
+ 0xD068,      0,      0, 0xD069, 0xD06A, 0x6335,      0,      0,
       0, 0xD06B,      0,      0,      0,      0, 0x357A, 0x6336,
  0xD06C, 0xD06D, 0x6338, 0xD06E,      0,      0, 0x6339, 0xD06F,
  0x4729, 0xD070,      0, 0x633A, 0xD071,      0,      0,      0,
@@ -4532,10 +4610,10 @@ const unsigned short utf8_to_euc_E7AA[] = {
 const unsigned short utf8_to_euc_E7AB[] = {
       0,      0,      0, 0x3376, 0x6362, 0x6361, 0xD164, 0x6365,
  0x635E, 0xD165, 0x6366, 0x4E29, 0xD166, 0x6367, 0xD167, 0x6368,
-      0, 0x7B48, 0x5474, 0x636A,      0, 0x6369,      0,      0,
+      0, 0xD168, 0x5474, 0x636A,      0, 0x6369,      0,      0,
       0, 0x636B, 0x636C, 0xD169, 0x4E35, 0x636D,      0, 0x706F,
- 0x3E4F, 0x636E, 0x636F, 0x3D57,      0, 0x4638, 0x6370, 0x7B49,
- 0xD16A, 0xD16B, 0x4328, 0x7B4B, 0xD16D, 0x6371,      0, 0x433C,
+ 0x3E4F, 0x636E, 0x636F, 0x3D57,      0, 0x4638, 0x6370, 0xF459,
+ 0xD16A, 0xD16B, 0x4328, 0xD16C, 0xD16D, 0x6371,      0, 0x433C,
  0x6372, 0xD16E,      0,      0, 0xD16F,      0, 0x3625,      0,
  0x513F, 0x435D, 0x3C33, 0xD170,      0, 0xD171, 0xD172, 0x3448,
 };
@@ -4563,7 +4641,7 @@ const unsigned short utf8_to_euc_E7AE[] = {
       0,      0,      0,      0, 0xD234,      0, 0x4A4F, 0x3255,
       0, 0xD235,      0, 0x6435,      0, 0x6432, 0xD236, 0x6437,
  0xD237, 0xD238, 0x6436,      0, 0x4773, 0x4C27, 0xD239, 0x3B3B,
- 0x6430, 0x6439, 0x6434, 0xD23A, 0x6433, 0x642F, 0x7B4C, 0x6431,
+ 0x6430, 0x6439, 0x6434, 0xD23A, 0x6433, 0x642F, 0xD23B, 0x6431,
  0xD23C, 0x3449,      0,      0,      0, 0xD23D,      0,      0,
       0,      0, 0x433D,      0, 0xD23E, 0x407D,      0, 0xD23F,
  0xD240, 0x4822, 0xD241,      0, 0x643E, 0xD242, 0xD243,      0,
@@ -4631,9 +4709,9 @@ const unsigned short utf8_to_euc_E7B4[] = {
 };
 const unsigned short utf8_to_euc_E7B5[] = {
  0xD35E, 0xD35F, 0x3D2A, 0x383E, 0x4148, 0x6525, 0x652B, 0xD360,
- 0x7B4E,      0,      0, 0x6526, 0x3750, 0xD362, 0x652E, 0x6532,
+ 0xD361,      0,      0, 0x6526, 0x3750, 0xD362, 0x652E, 0x6532,
  0x376B, 0xD363,      0, 0xD364,      0,      0, 0x652D, 0xD365,
-      0, 0xD366, 0xD367, 0x6536, 0x7B4F, 0xD369, 0x394A,      0,
+      0, 0xD366, 0xD367, 0x6536, 0xD368, 0xD369, 0x394A,      0,
       0, 0x4D6D, 0x303C, 0x6533,      0, 0xD36A, 0x356B, 0xD36B,
  0x6530,      0, 0xD36C,      0,      0,      0, 0x6531,      0,
  0xD36D, 0x457D, 0x652F, 0x652C,      0, 0x3328, 0x4064,      0,
@@ -4644,15 +4722,15 @@ const unsigned short utf8_to_euc_E7B6[] = {
  0xD377, 0x6535,      0, 0xD378, 0xD379, 0xD37A,      0, 0x6537,
       0, 0xD37B,      0, 0x6534,      0,      0, 0xD37C, 0xD37D,
       0, 0x3751, 0x4233, 0x6539, 0x416E, 0xD37E, 0xD421, 0x6546,
- 0x7B51,      0, 0x6542, 0x653C,      0,      0, 0xD422, 0xD423,
+ 0xF45C,      0, 0x6542, 0x653C,      0,      0, 0xD422, 0xD423,
       0,      0, 0xD424, 0x6540, 0x3C7A, 0x305D, 0x653B, 0x6543,
- 0x6547, 0x394B, 0x4C56, 0xD425, 0x4456, 0x653D, 0xD426, 0x7B50,
+ 0x6547, 0x394B, 0x4C56, 0xD425, 0x4456, 0x653D, 0xD426, 0xD427,
  0x6545, 0xD428, 0x653A, 0x433E,      0, 0x653F, 0x303D, 0x4C4A,
 };
 const unsigned short utf8_to_euc_E7B7[] = {
       0,      0, 0xD429, 0xD42A, 0xD42B, 0xD42C, 0xD42D, 0x653E,
       0,      0, 0x365B, 0x486C, 0xD42E, 0xD42F, 0xD430, 0x416D,
-      0, 0x4E50, 0x3D6F,      0,      0, 0x656E, 0x7B52, 0xD431,
+      0, 0x4E50, 0x3D6F,      0,      0, 0x656E, 0xF45D, 0xD431,
  0x6548, 0xD432, 0x407E,      0, 0x6544, 0x6549, 0x654B,      0,
  0x4479, 0x654E, 0xD434,      0, 0x654A, 0xD435, 0xD436,      0,
  0x4A54, 0x344B, 0xD437, 0xD438, 0x4C4B, 0xD439,      0, 0x305E,
@@ -4672,7 +4750,7 @@ const unsigned short utf8_to_euc_E7B8[] = {
 const unsigned short utf8_to_euc_E7B9[] = {
       0, 0x484B,      0, 0x655E, 0xD44F, 0xD450, 0x6559, 0xD451,
       0,      0, 0x4121, 0x3752,      0, 0x3D2B, 0xD452,      0,
- 0xD453,      0, 0x7B53,      0, 0x3F25, 0x4136, 0x6564,      0,
+ 0xD453,      0, 0xD454,      0, 0x3F25, 0x4136, 0x6564,      0,
  0xD455, 0x6566, 0x6567,      0,      0, 0x6563, 0x6565, 0xD456,
       0, 0xD457, 0xD458,      0,      0, 0xD459, 0x655A, 0x6562,
       0, 0x656A, 0x6569, 0xD45A,      0, 0x4B7A, 0xD45B, 0xD45C,
@@ -4681,7 +4759,7 @@ const unsigned short utf8_to_euc_E7B9[] = {
 };
 const unsigned short utf8_to_euc_E7BA[] = {
       0, 0xD460, 0x3B3C, 0x656D,      0,      0, 0xD461, 0xD462,
- 0x6572, 0x6573, 0x7921,      0, 0x6574, 0xD464, 0x657A, 0x453B,
+ 0x6572, 0x6573, 0xD463,      0, 0x6574, 0xD464, 0x657A, 0x453B,
  0x6576, 0xD465, 0x6575, 0x6577, 0x6578, 0xD466, 0x6579,      0,
  0xD467,      0, 0xD468, 0x657B, 0x657C, 0xD469, 0xD46A,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
@@ -4700,7 +4778,7 @@ const unsigned short utf8_to_euc_E7BC[] = {
  0x657D,      0, 0x657E, 0xD46C, 0xD46B, 0xD46D, 0xD46E, 0xD46F,
 };
 const unsigned short utf8_to_euc_E7BD[] = {
-      0,      0,      0, 0xD470, 0xD471, 0x6621,      0, 0x7B54,
+      0,      0,      0, 0xD470, 0xD471, 0x6621,      0, 0xD472,
       0,      0,      0,      0, 0x6622, 0x6623, 0x6624, 0xD473,
  0x6625, 0x6626, 0xD474, 0xD475, 0x6628, 0x6627,      0,      0,
  0x6629,      0,      0, 0xD476, 0xD477, 0xD478,      0, 0x662A,
@@ -4714,7 +4792,7 @@ const unsigned short utf8_to_euc_E7BE[] = {
  0x6633,      0, 0x4D53, 0xD526, 0x6635, 0xD527, 0x487E, 0xD528,
  0xD529, 0xD52A,      0,      0, 0x6636,      0, 0xD52B, 0xD52C,
       0,      0, 0x6639,      0, 0xD52D, 0x6638, 0x6637,      0,
-      0, 0x7B55, 0xD52F, 0x663A, 0x3732,      0, 0xD530,      0,
+      0, 0xD52E, 0xD52F, 0x663A, 0x3732,      0, 0xD530,      0,
  0x4122, 0x3541, 0xD531,      0,      0, 0xD532, 0x663E, 0x663B,
       0,      0, 0x663C,      0, 0xD533,      0, 0x663F,      0,
  0x6640, 0x663D,      0,      0, 0xD534, 0x3129,      0, 0xD535,
@@ -4850,7 +4928,7 @@ const unsigned short utf8_to_euc_E88B[] = {
       0, 0x6779, 0x6775, 0x6778,      0, 0xD75B, 0xD75C,      0,
 };
 const unsigned short utf8_to_euc_E88C[] = {
- 0xD75D, 0x7B57, 0x4C50, 0x6777, 0x3258, 0x337D, 0x677B, 0xD75F,
+ 0xD75D, 0xD75E, 0x4C50, 0x6777, 0x3258, 0x337D, 0x677B, 0xD75F,
  0xD760, 0x677D, 0xD761, 0xD762,      0,      0, 0x3754,      0,
       0,      0,      0,      0,      0,      0, 0x6823, 0x682C,
  0x682D,      0,      0, 0xD764, 0x302B, 0xD765, 0xD766, 0xD767,
@@ -4864,10 +4942,10 @@ const unsigned short utf8_to_euc_E88D[] = {
       0, 0x4170, 0x3755,      0,      0, 0xD777, 0xD778, 0x3141,
  0x6828, 0xD779, 0x3953, 0xD83E, 0xD763, 0xD77A, 0xD77B, 0xD77C,
  0x4171,      0,      0,      0,      0,      0,      0,      0,
-      0,      0, 0x7B58,      0,      0,      0,      0,      0,
+      0,      0, 0xF45F,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
  0xD77D,      0,      0, 0x683A,      0, 0x683B,      0, 0x3259,
- 0xD77E,      0,      0, 0x322E, 0x6838, 0xD821,      0, 0x7B59,
+ 0xD77E,      0,      0, 0x322E, 0x6838, 0xD821,      0, 0xD822,
 };
 const unsigned short utf8_to_euc_E88E[] = {
  0xD823,      0, 0xD824,      0, 0xD825, 0x682E, 0xD826, 0x6836,
@@ -4880,13 +4958,13 @@ const unsigned short utf8_to_euc_E88E[] = {
       0,      0,      0,      0,      0, 0x684F, 0xD834, 0xD835,
 };
 const unsigned short utf8_to_euc_E88F[] = {
- 0xD836, 0x6847,      0,      0,      0, 0x3F7B,      0, 0x7B5A,
+ 0xD836, 0x6847,      0,      0,      0, 0x3F7B,      0, 0xD837,
       0, 0xD838, 0x3546,      0, 0x365D,      0, 0x6842, 0xD839,
  0xD83A, 0xD83B,      0, 0x325B, 0xD83C,      0, 0x3E54,      0,
  0x6845,      0,      0,      0, 0x3A5A, 0xD83D,      0, 0x4551,
  0x684A,      0,      0,      0,      0,      0,      0,      0,
  0xD83F, 0x4A6E, 0xD840, 0x6841,      0,      0,      0, 0x325A,
- 0x3856, 0x4929, 0x684B,      0, 0x683F,      0, 0x7B5B, 0x6848,
+ 0x3856, 0x4929, 0x684B,      0, 0x683F,      0, 0xD841, 0x6848,
  0xD842, 0xD843,      0, 0x6852, 0xD844, 0x6843,      0,      0,
 };
 const unsigned short utf8_to_euc_E890[] = {
@@ -4901,7 +4979,7 @@ const unsigned short utf8_to_euc_E890[] = {
 };
 const unsigned short utf8_to_euc_E891[] = {
       0,      0,      0,      0,      0, 0xD84F, 0x685E, 0xD850,
- 0x7B5C, 0x4D55, 0xD852,      0,      0, 0xD853, 0x4E2A, 0xD854,
+ 0xD851, 0x4D55, 0xD852,      0,      0, 0xD853, 0x4E2A, 0xD854,
       0, 0xD855, 0xD856,      0,      0,      0, 0xD857, 0x4378,
  0xD858, 0xD859, 0xD85A, 0x336B, 0xD85B,      0,      0,      0,
  0xD85C, 0x4972, 0x6864, 0x4621, 0xD85D, 0xD85E, 0x3031, 0xD85F,
@@ -4916,14 +4994,14 @@ const unsigned short utf8_to_euc_E892[] = {
       0, 0x4C58,      0,      0, 0x4947,      0, 0xD86D, 0x6867,
       0, 0x6870,      0,      0,      0,      0, 0xD86E,      0,
  0xD86F, 0xD870, 0xD871,      0,      0, 0x685A,      0, 0xD872,
-      0, 0xD873, 0x3377,      0, 0x7B5D,      0,      0,      0,
+      0, 0xD873, 0x3377,      0, 0xD874,      0,      0,      0,
  0x3E78, 0x6865, 0xD875, 0x686A, 0x4173, 0xD876, 0xD877, 0x6866,
 };
 const unsigned short utf8_to_euc_E893[] = {
  0xD878, 0x686D, 0xD879,      0, 0x435F,      0, 0x686E, 0xD87A,
  0xD87B, 0x4D56, 0x6863, 0x3338, 0xD87C, 0x6869,      0, 0xD87D,
  0x686C, 0x4C2C,      0, 0xD87E,      0,      0, 0x686F,      0,
-      0, 0x6868, 0x686B,      0, 0x7925,      0,      0,      0,
+      0, 0x6868, 0x686B,      0, 0xD921,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0, 0xD922,
       0,      0, 0xD923,      0, 0x4B29,      0, 0x4F21, 0xD924,
  0xD925, 0xD926, 0xD927,      0, 0x6873,      0,      0, 0xD928,
@@ -4942,10 +5020,10 @@ const unsigned short utf8_to_euc_E894[] = {
 const unsigned short utf8_to_euc_E895[] = {
  0x687B, 0x6921,      0, 0x4859,      0,      0, 0xD941,      0,
  0x687E, 0x3E56, 0x3C49, 0x6923,      0,      0, 0x363E, 0xD942,
- 0xD943, 0xD944, 0xD945, 0x7B5E,      0, 0x6924, 0xD947, 0x4979,
- 0x687D, 0x7B5F, 0x6856,      0, 0xD949, 0xD94A, 0xD94B, 0xD94C,
+ 0xD943, 0xD944, 0xD945, 0xD946,      0, 0x6924, 0xD947, 0x4979,
+ 0x687D, 0xD948, 0x6856,      0, 0xD949, 0xD94A, 0xD94B, 0xD94C,
  0xD94D, 0xD94E, 0xD94F, 0x687C, 0xD950,      0,      0,      0,
- 0x4F4F, 0x4622, 0x4973, 0x7B60,      0, 0x692B,      0, 0xD952,
+ 0x4F4F, 0x4622, 0x4973, 0xD951,      0, 0x692B,      0, 0xD952,
       0,      0,      0,      0,      0,      0,      0, 0x6931,
       0, 0xD953, 0xD954, 0xD955,      0, 0xD956, 0x6932, 0xD957,
 };
@@ -4956,7 +5034,7 @@ const unsigned short utf8_to_euc_E896[] = {
  0xD960, 0x4665,      0, 0x692D, 0x6930, 0xD961,      0, 0xD962,
  0xD963,      0, 0xD964,      0, 0x6926, 0xD965, 0x4126, 0xD966,
  0x692A, 0x3B27, 0x3F45, 0x3730, 0x4C74, 0xD974, 0x4C79, 0x3D72,
- 0x7B62,      0,      0,      0, 0xD967,      0, 0xD968, 0xD969,
+ 0xF461,      0,      0,      0, 0xD967,      0, 0xD968, 0xD969,
  0xD96A, 0x6937, 0x6935,      0, 0xD96B, 0xD96C, 0xD96D, 0xD96E,
 };
 const unsigned short utf8_to_euc_E897[] = {
@@ -5050,7 +5128,7 @@ const unsigned short utf8_to_euc_E89F[] = {
  0xDB65, 0x332A, 0xDB66, 0x3542,      0,      0, 0x6A39, 0xDB67,
 };
 const unsigned short utf8_to_euc_E8A0[] = {
-      0, 0xDB68,      0, 0xDB69,      0, 0x6A24, 0xDB6A, 0x7B65,
+      0, 0xDB68,      0, 0xDB69,      0, 0x6A24, 0xDB6A, 0xF464,
       0, 0xDB6B, 0xDB6C, 0xDB6D,      0, 0x6A38, 0x6A3C, 0x6A37,
  0xDB6E, 0x6A3E, 0xDB70, 0xDB71, 0xDB72, 0x6A40, 0x6A3F,      0,
  0xDB73, 0xDB6F, 0xDB74, 0xDB75, 0xDB76,      0, 0xDB77, 0xDB78,
@@ -5086,14 +5164,14 @@ const unsigned short utf8_to_euc_E8A3[] = {
  0x6A64, 0x6A65,      0, 0xDC4D, 0x4A64, 0x6A66, 0xDC4E, 0x3A40,
       0, 0x4E23,      0,      0,      0,      0,      0, 0xDC4F,
  0x6A6B,      0,      0,      0,      0,      0,      0, 0xDC50,
- 0xDC51, 0xDC52, 0x6A6C, 0x3E58, 0x6A6A, 0x7B66,      0, 0xDC54,
+ 0xDC51, 0xDC52, 0x6A6C, 0x3E58, 0x6A6A, 0xDC53,      0, 0xDC54,
  0x4D67, 0x6A67,      0,      0, 0x6A69, 0x403D, 0x3F7E,      0,
 };
 const unsigned short utf8_to_euc_E8A4[] = {
       0, 0xDC55, 0x6A68,      0, 0x6A6D,      0, 0xDC56, 0x4A23,
       0,      0, 0x6A6F,      0, 0x6A6E, 0xDC57, 0xDC58, 0xDC59,
  0x336C,      0, 0x4B2B, 0x6A70,      0, 0xDC5A, 0xDC5B,      0,
- 0xDC5C, 0xDC5D, 0xDC5E,      0, 0x7922, 0x6A7C, 0x6A72,      0,
+ 0xDC5C, 0xDC5D, 0xDC5E,      0, 0xDC5F, 0x6A7C, 0x6A72,      0,
  0xDC60,      0,      0,      0,      0, 0x6A73, 0xDC61, 0xDC62,
  0xDC63,      0, 0x6A74, 0x6A75,      0,      0,      0,      0,
  0xDC64, 0xDC65, 0xDC66,      0,      0, 0xDC67, 0x6A79,      0,
@@ -5132,11 +5210,11 @@ const unsigned short utf8_to_euc_E8A7[] = {
 const unsigned short utf8_to_euc_E8A8[] = {
  0x3840,      0, 0x447B, 0x6B3E, 0xDD43, 0xDD44,      0, 0xDD45,
  0x3757,      0, 0x3F56,      0, 0x6B41,      0, 0x4624, 0xDD46,
- 0x6B40, 0xDD47, 0x7B67, 0x3731, 0xDD49, 0xDD4A, 0x6B3F, 0x4277,
+ 0x6B40, 0xDD47, 0xDD48, 0x3731, 0xDD49, 0xDD4A, 0x6B3F, 0x4277,
  0x352D,      0,      0, 0x6B42,      0, 0x6B43, 0xDD4B, 0x3E59,
  0xDD4C,      0, 0xDD4D, 0x376D, 0xDD4E, 0x6B44, 0xDD4F,      0,
       0,      0, 0x4B2C, 0xDD50, 0xDD51, 0x405F,      0, 0xDD52,
-      0, 0x3576,      0, 0x4C75, 0x414A, 0xDD53, 0x6B45, 0x7B68,
+      0, 0x3576,      0, 0x4C75, 0x414A, 0xDD53, 0x6B45, 0xDD54,
       0,      0, 0x3F47, 0x4370, 0x3E5A, 0xDD55, 0xDD56,      0,
 };
 const unsigned short utf8_to_euc_E8A9[] = {
@@ -5147,26 +5225,26 @@ const unsigned short utf8_to_euc_E8A9[] = {
  0x3153, 0xDD64, 0x6B4E, 0x3758,      0, 0xDD65, 0x3B6E, 0xDD66,
       0, 0x3B6D,      0, 0x4F4D, 0x6B4D, 0x6B4C, 0x4127,      0,
  0x354D, 0x4F43, 0x333A, 0x3E5C,      0, 0xDD67, 0xDD68, 0xDD69,
-      0, 0x7B69, 0xDD6B, 0xDD6C, 0x6B4B,      0, 0xDD6D, 0xDD6E,
+      0, 0xDD6A, 0xDD6B, 0xDD6C, 0x6B4B,      0, 0xDD6D, 0xDD6E,
 };
 const unsigned short utf8_to_euc_E8AA[] = {
  0xDD6F,      0, 0x6B50, 0xDD70, 0x6B51, 0x6B4F, 0xDD71, 0x3858,
       0, 0x4D40,      0, 0xDD72, 0x3B6F, 0x4727,      0, 0xDD73,
  0xDD74, 0x6B54, 0xDD75, 0x4040,      0, 0x4342, 0xDD76, 0xDD77,
  0x4D36, 0xDD78, 0x6B57,      0,      0,      0, 0x386C, 0xDD79,
- 0x403F, 0x6B53,      0, 0x6B58, 0x386D, 0x6B55, 0x6B56, 0x7B6A,
+ 0x403F, 0x6B53,      0, 0x6B58, 0x386D, 0x6B55, 0x6B56, 0xDD7A,
  0x6B52, 0xDD7B,      0,      0, 0x4062, 0x4649, 0xDD7C, 0xDD7D,
  0x432F,      0, 0x325D, 0xDD7E,      0,      0, 0xDE21, 0xDE22,
-      0, 0x4870,      0, 0xDE23, 0x3543,      0, 0x7B6B, 0x4434,
+      0, 0x4870,      0, 0xDE23, 0x3543,      0, 0xDE24, 0x4434,
 };
 const unsigned short utf8_to_euc_E8AB[] = {
       0,      0, 0x6B5B, 0xDE25, 0x6B59,      0, 0xDE26, 0x434C,
  0xDE27, 0xDE28, 0xDE29, 0x4041, 0x3452, 0x6B5A,      0, 0x3F5B,
       0, 0xDE2A, 0x4E4A, 0xDE2B, 0xDE2C, 0xDE2D, 0x4F40, 0xDE2E,
-      0,      0, 0x6B5C, 0x6B67, 0x4435, 0xDE2F, 0x6B66, 0x7B6C,
+      0,      0, 0x6B5C, 0x6B67, 0x4435, 0xDE2F, 0x6B66, 0xDE30,
  0x6B63, 0x6B6B, 0x6B64,      0, 0x6B60,      0, 0x447C, 0x6B5F,
       0,      0,      0, 0x6B5D, 0xDE31, 0x4D21, 0x3B70,      0,
- 0xDE32, 0x6B61,      0, 0x6B5E, 0xDE33, 0xDE34, 0x7B6E, 0x6B65,
+ 0xDE32, 0x6B61,      0, 0x6B5E, 0xDE33, 0xDE34, 0xDE35, 0x6B65,
  0x3D74,      0, 0x3841,      0, 0xDE36,      0, 0x427A, 0xDE37,
 };
 const unsigned short utf8_to_euc_E8AC[] = {
@@ -5182,12 +5260,12 @@ const unsigned short utf8_to_euc_E8AC[] = {
 const unsigned short utf8_to_euc_E8AD[] = {
       0, 0x6B76, 0xDE44, 0xDE45, 0xDE46, 0xDE47, 0xDE48,      0,
  0xDE49, 0x6B7A,      0,      0, 0x6B77, 0xDE4E, 0x6B79, 0x6B78,
-      0,      0, 0xDE4A, 0x7B6F, 0xDE4C,      0, 0x6B7B,      0,
+      0,      0, 0xDE4A, 0xDE4B, 0xDE4C,      0, 0x6B7B,      0,
  0x3C31, 0xDE4D, 0x6B7D, 0x6B7C, 0x4968,      0, 0xDE4F, 0x6C21,
       0,      0,      0, 0xDE50,      0,      0, 0x3759,      0,
       0,      0,      0, 0x6B7E, 0x6C22, 0xDE51,      0, 0x6C23,
  0x3544, 0x6641, 0x3E79,      0, 0x6C24,      0, 0xDE52, 0x386E,
- 0xDE53, 0xDE54,      0,      0, 0xDE55, 0x6C25, 0xDE56, 0x7B70,
+ 0xDE53, 0xDE54,      0,      0, 0xDE55, 0x6C25, 0xDE56, 0xF466,
 };
 const unsigned short utf8_to_euc_E8AE[] = {
  0x6C26, 0xDE57,      0, 0x3B3E, 0xDE58, 0xDE59,      0,      0,
@@ -5236,13 +5314,13 @@ const unsigned short utf8_to_euc_E8B3[] = {
       0, 0xDF33, 0x6C4F, 0x3B3F, 0x3B72, 0xDF34, 0x3E5E,      0,
  0x4765, 0xDF35, 0x382D, 0x6C4E, 0x6C4D,      0, 0x496A,      0,
  0xDF36,      0, 0x3C41,      0, 0xDF37, 0x4552,      0, 0xDF38,
- 0x7B71,      0, 0xDF3A,      0, 0x7B72, 0xDF3B,      0, 0xDF3C,
+ 0xDF39,      0, 0xDF3A,      0, 0xF467, 0xDF3B,      0, 0xDF3C,
  0xDF3D,      0, 0x6C51, 0x6C52, 0x3958, 0x6C50, 0xDF3E, 0xDF3F,
 };
 const unsigned short utf8_to_euc_E8B4[] = {
       0, 0xDF40,      0, 0xDF41, 0x6C53, 0x6C54,      0, 0x6C56,
  0x4223, 0xDF42, 0x6C55, 0x3466,      0, 0x6C58,      0, 0x6C57,
- 0x6C59,      0, 0x7B73, 0x6C5B, 0x6C5D,      0, 0x6C5E, 0xDF44,
+ 0x6C59,      0, 0xDF43, 0x6C5B, 0x6C5D,      0, 0x6C5E, 0xDF44,
       0,      0,      0, 0xDF45,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
@@ -5256,7 +5334,7 @@ const unsigned short utf8_to_euc_E8B5[] = {
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0, 0x4056, 0xDF46, 0x3C4F, 0x6C5F,
       0, 0xDF47,      0, 0x3352, 0xDF48, 0x6C60, 0xDF49,      0,
- 0x4176, 0x6C61,      0, 0x6C62, 0x496B,      0, 0x7B74, 0x352F,
+ 0x4176, 0x6C61,      0, 0x6C62, 0x496B,      0, 0xF468, 0x352F,
       0,      0,      0,      0,      0,      0,      0, 0xDF4A,
 };
 const unsigned short utf8_to_euc_E8B6[] = {
@@ -5311,7 +5389,7 @@ const unsigned short utf8_to_euc_E8BA[] = {
 };
 const unsigned short utf8_to_euc_E8BB[] = {
  0xE054, 0xE055,      0, 0xE056, 0xE057, 0x6D40, 0x6D3D, 0xE058,
- 0x6D41,      0, 0x3C56, 0x6D42, 0x3530, 0x3733,      0, 0x7B76,
+ 0x6D41,      0, 0x3C56, 0x6D42, 0x3530, 0x3733,      0, 0xE059,
       0, 0xE05A, 0x382E,      0, 0xE05B,      0,      0,      0,
       0,      0,      0, 0x6D43, 0xE05C,      0,      0, 0x4670,
       0,      0, 0x453E, 0x6D44,      0,      0,      0,      0,
@@ -5374,7 +5452,7 @@ const unsigned short utf8_to_euc_E981[] = {
       0, 0x6E26, 0x4D37, 0x313F, 0xE15D, 0x4A57, 0x3261, 0x6E21,
  0x6E22, 0x6E23, 0x6E24, 0x463B, 0x4323, 0x3063, 0x6E28,      0,
  0x6E29, 0x7423,      0, 0xE15E, 0x423D, 0xE15F, 0x6E2A,      0,
- 0x3173, 0x414C, 0xE160, 0x382F,      0, 0x4D5A, 0xE161, 0x7B79,
+ 0x3173, 0x414C, 0xE160, 0x382F,      0, 0x4D5A, 0xE161, 0xE162,
  0x6E2B, 0x452C,      0,      0, 0xE163, 0x4178, 0x3C57, 0x6E2C,
  0xE164,      0, 0x6E2F,      0, 0xE165, 0x3D65, 0x6E2D, 0x412B,
  0x412A, 0xE166, 0x3064,      0, 0x4E4B, 0x6E31,      0, 0x4872,
@@ -5393,7 +5471,7 @@ const unsigned short utf8_to_euc_E983[] = {
       0, 0x306A,      0, 0xE17E, 0xE221, 0xE222,      0, 0xE223,
  0xE224,      0, 0x3959,      0, 0xE17C,      0, 0x4F3A,      0,
       0,      0, 0xE22D,      0,      0, 0xE225,      0, 0xE226,
- 0xE227, 0xE228,      0, 0x6E3E, 0xE229, 0xE22A, 0x7B7A, 0xE22B,
+ 0xE227, 0xE228,      0, 0x6E3E, 0xE229, 0xE22A, 0xF46C, 0xE22B,
       0, 0x3734, 0x6E3B,      0, 0x6E3C, 0xE22C,      0,      0,
  0x4974,      0,      0, 0xE22F,      0, 0x3354,      0, 0xE230,
  0xE231,      0,      0,      0, 0xE232, 0x4D39, 0xE22E, 0x363F,
@@ -5402,9 +5480,9 @@ const unsigned short utf8_to_euc_E983[] = {
 const unsigned short utf8_to_euc_E984[] = {
  0xE235,      0, 0x6E3F,      0, 0xE236, 0xE237, 0xE238,      0,
  0xE239,      0,      0,      0,      0, 0xE23A,      0,      0,
- 0xE23B,      0, 0x6E40,      0, 0xE23C, 0x7B7C, 0xE23D, 0xE23E,
+ 0xE23B,      0, 0x6E40,      0, 0xE23C, 0xF46E, 0xE23D, 0xE23E,
  0xE23F, 0x6E41, 0xE240,      0, 0xE241,      0, 0xE242,      0,
- 0xE243,      0, 0xE245, 0xE246,      0, 0xE244,      0, 0x7B7D,
+ 0xE243,      0, 0xE245, 0xE246,      0, 0xE244,      0, 0xE247,
       0, 0xE248,      0,      0,      0, 0x4522, 0xE249, 0xE24A,
  0x6E43, 0xE24B, 0x6E42,      0, 0xE24C,      0, 0xE24D, 0xE24E,
       0, 0xE24F, 0xE250,      0, 0xE251, 0xE252,      0,      0,
@@ -5432,39 +5510,39 @@ const unsigned short utf8_to_euc_E986[] = {
 const unsigned short utf8_to_euc_E987[] = {
  0x6E56, 0x6E57, 0xE321, 0xE322,      0, 0xE323, 0x4850, 0x3A53,
  0x3C61, 0x6E58,      0, 0x6E59, 0x4E24, 0x3D45, 0x4C6E, 0x4E4C,
- 0x6E5A, 0x3662,      0, 0xE324, 0xE325,      0, 0x6E5B, 0x7C21,
- 0x4523, 0xE327, 0x7B7E, 0x6E5E, 0x3378, 0x3F4B, 0x7C22, 0x6E5C,
-      0, 0x6E5D,      0, 0x4460, 0x7C25, 0x7C26, 0x4B55, 0x367C,
-      0, 0xE32C, 0xE32D,      0, 0xE32E, 0x7C23, 0x7C24, 0xE331,
+ 0x6E5A, 0x3662,      0, 0xE324, 0xE325,      0, 0x6E5B, 0xE326,
+ 0x4523, 0xE327, 0xE328, 0x6E5E, 0x3378, 0x3F4B, 0xE329, 0x6E5C,
+      0, 0x6E5D,      0, 0x4460, 0xE32A, 0xE32B, 0x4B55, 0x367C,
+      0, 0xE32C, 0xE32D,      0, 0xE32E, 0xE32F, 0xE330, 0xE331,
  0xE332, 0xE333,      0,      0,      0, 0x6E60, 0x6E61, 0xE334,
       0, 0xE335,      0, 0xE336, 0x6E5F, 0xE337,      0, 0x6E63,
 };
 const unsigned short utf8_to_euc_E988[] = {
- 0xE338, 0xE339,      0,      0, 0xE33A, 0xE33B, 0x7C27, 0xE33D,
-      0, 0xE33E, 0x7C29,      0, 0xE340, 0x465F, 0x3343,      0,
- 0x7C28, 0x6E67, 0xE342, 0xE343, 0x6E64, 0x6E66, 0xE344,      0,
+ 0xE338, 0xE339,      0,      0, 0xE33A, 0xE33B, 0xE33C, 0xE33D,
+      0, 0xE33E, 0xE33F,      0, 0xE340, 0x465F, 0x3343,      0,
+ 0xE341, 0x6E67, 0xE342, 0xE343, 0x6E64, 0x6E66, 0xE344,      0,
  0xE345,      0,      0,      0, 0xE346, 0xE347, 0x6E62,      0,
       0,      0,      0, 0xE348, 0xE349, 0xE34A, 0xE34B,      0,
  0xE34C, 0x6F4F,      0,      0, 0x6E65,      0, 0xE34D, 0xE34E,
  0xE34F,      0,      0, 0xE350, 0x4E6B, 0xE351, 0xE352, 0x385A,
- 0xE353, 0x7C30, 0x7C2A,      0, 0x7C2C,      0, 0xE357, 0x6E6F,
+ 0xE353, 0xE354, 0xE355,      0, 0xE356,      0, 0xE357, 0x6E6F,
 };
 const unsigned short utf8_to_euc_E989[] = {
- 0x7C2B,      0, 0xE359, 0xE35A, 0x4534, 0x6E6A, 0xE35B, 0xE35C,
- 0x6E6D, 0x6E6B, 0xE35D, 0x6E70,      0, 0xE35E, 0x7C2D, 0xE360,
- 0x6E71, 0x7C2F,      0,      0,      0,      0,      0, 0x6E69,
- 0xE362, 0x7C2E, 0x6E76, 0x3174, 0xE364, 0xE365, 0x6E68,      0,
- 0xE366, 0xE367, 0x482D,      0, 0x6E6C, 0xE368, 0x3E60, 0x7C31,
+ 0xE358,      0, 0xE359, 0xE35A, 0x4534, 0x6E6A, 0xE35B, 0xE35C,
+ 0x6E6D, 0x6E6B, 0xE35D, 0x6E70,      0, 0xE35E, 0xE35F, 0xE360,
+ 0x6E71, 0xE361,      0,      0,      0,      0,      0, 0x6E69,
+ 0xE362, 0xE363, 0x6E76, 0x3174, 0xE364, 0xE365, 0x6E68,      0,
+ 0xE366, 0xE367, 0x482D,      0, 0x6E6C, 0xE368, 0x3E60, 0xE369,
  0xE36A, 0xE36B,      0,      0,      0,      0, 0xE36C, 0xE36D,
- 0xE36E, 0x395B,      0,      0,      0, 0xE36F, 0xE370, 0x7C33,
- 0x7C34, 0xE373,      0, 0xE374, 0xE375, 0xE376, 0x4B48, 0xE377,
+ 0xE36E, 0x395B,      0,      0,      0, 0xE36F, 0xE370, 0xE371,
+ 0xE372, 0xE373,      0, 0xE374, 0xE375, 0xE376, 0x4B48, 0xE377,
 };
 const unsigned short utf8_to_euc_E98A[] = {
  0x3664,      0,      0, 0x3D46,      0, 0x463C,      0,      0,
- 0x7924, 0xE379, 0xE37A,      0,      0, 0xE37B, 0xE37C,      0,
+ 0xE378, 0xE379, 0xE37A,      0,      0, 0xE37B, 0xE37C,      0,
       0, 0x412D, 0xE37D, 0x6E74,      0, 0x6E6E, 0x6E73, 0xE37E,
  0x4C43, 0xE421, 0x4438, 0x6E75, 0x6E72,      0,      0, 0xE422,
- 0xE423,      0,      0,      0, 0xE424, 0xE425,      0, 0x7C32,
+ 0xE423,      0,      0,      0, 0xE424, 0xE425,      0, 0xE426,
  0xE427,      0,      0, 0xE428,      0, 0x412C,      0, 0xE429,
       0,      0, 0xE42A,      0,      0,      0, 0xE42B, 0x6E79,
  0xE42C, 0x6E78, 0xE42D, 0xE42E, 0xE42F, 0xE430,      0, 0xE431,
@@ -5472,31 +5550,31 @@ const unsigned short utf8_to_euc_E98A[] = {
 const unsigned short utf8_to_euc_E98B[] = {
  0xE432, 0xE433, 0xE434, 0xE435,      0, 0xE436, 0xE437, 0xE438,
  0xE439,      0,      0, 0xE43A, 0xE43B, 0xE43C, 0xE43D, 0x6E77,
- 0x7C38,      0, 0x4B2F, 0x7C3C,      0, 0x7C3A,      0, 0x7C36,
- 0xE442, 0x7C37,      0,      0, 0xE444, 0xE445,      0, 0xE446,
- 0x7C3B, 0xE448,      0, 0xE449, 0x3D7B, 0xE44A,      0, 0x7C35,
+ 0xE43E,      0, 0x4B2F, 0xE43F,      0, 0xE440,      0, 0xE441,
+ 0xE442, 0xE443,      0,      0, 0xE444, 0xE445,      0, 0xE446,
+ 0xE447, 0xE448,      0, 0xE449, 0x3D7B, 0xE44A,      0, 0xE44B,
  0xE44C, 0x6E7A, 0x4A5F,      0, 0xE44D, 0x3154, 0xE44E,      0,
  0xE44F,      0, 0x4946, 0x4372,      0,      0,      0,      0,
- 0x3578, 0x792A, 0x6E7C, 0x7C3F, 0x395D,      0,      0, 0x7C42,
+ 0x3578, 0xE450, 0x6E7C, 0xE451, 0x395D,      0,      0, 0xE452,
 };
 const unsigned short utf8_to_euc_E98C[] = {
- 0xE453,      0, 0x7C44,      0,      0,      0, 0x3B2C,      0,
+ 0xE453,      0, 0xE454,      0,      0,      0, 0x3B2C,      0,
  0xE455,      0,      0,      0,      0, 0xE456,      0, 0x6E7B,
  0x3F6D, 0xE457,      0,      0, 0xE458, 0xE459,      0,      0,
- 0x3F6E, 0x6F21, 0x6F23,      0, 0xE45A, 0x7C43, 0x7C41, 0xE45D,
- 0x3E7B, 0x7C3E, 0x6F22, 0x6F24, 0xE45F, 0x7C3D, 0x3653, 0xE461,
+ 0x3F6E, 0x6F21, 0x6F23,      0, 0xE45A, 0xE45B, 0xE45C, 0xE45D,
+ 0x3E7B, 0xE45E, 0x6F22, 0x6F24, 0xE45F, 0xE460, 0x3653, 0xE461,
  0x4945, 0xE462, 0xE463, 0x3C62, 0x4F23,      0, 0x6E7E, 0x3A78,
       0,      0, 0x4F3F, 0xE464, 0xE465, 0x6F26, 0xE466, 0xE467,
       0,      0, 0x6F25, 0x6F27,      0,      0,      0,      0,
 };
 const unsigned short utf8_to_euc_E98D[] = {
       0,      0,      0,      0, 0x6E7D,      0,      0, 0xE468,
- 0x7923, 0xE46A,      0, 0x4669,      0, 0x4555,      0,      0,
- 0xE46B, 0xE46C, 0xE46D,      0, 0x4457, 0xE46E, 0x6F2C, 0x7C46,
+ 0xE469, 0xE46A,      0, 0x4669,      0, 0x4555,      0,      0,
+ 0xE46B, 0xE46C, 0xE46D,      0, 0x4457, 0xE46E, 0x6F2C, 0xE46F,
  0xE470,      0, 0xE471, 0x4343, 0x6F28,      0, 0xE472,      0,
  0x6F29,      0,      0,      0, 0xE473, 0xE474,      0, 0xE475,
       0, 0xE476, 0xE477,      0, 0x372D, 0xE478, 0x6F2B, 0xE479,
- 0x7C45, 0xE47B,      0, 0xE47C, 0xE47D, 0x3830, 0xE47E,      0,
+ 0xE47A, 0xE47B,      0, 0xE47C, 0xE47D, 0x3830, 0xE47E,      0,
       0,      0, 0xE521,      0, 0x6F2A, 0xE522, 0x3E61, 0xE523,
 };
 const unsigned short utf8_to_euc_E98E[] = {
@@ -5504,20 +5582,20 @@ const unsigned short utf8_to_euc_E98E[] = {
  0xE527,      0, 0xE528, 0xE529, 0x3379, 0xE52A,      0, 0xE52B,
       0,      0, 0xE52C,      0, 0x6F30, 0xE52D, 0x3A3F, 0x4179,
  0xE52E,      0, 0x444A, 0xE52F,      0,      0, 0xE530,      0,
-      0, 0xE531,      0, 0xE532, 0x7C47,      0, 0xE534, 0x333B,
+      0, 0xE531,      0, 0xE532, 0xE533,      0, 0xE534, 0x333B,
  0xE535, 0xE53B,      0, 0xE536, 0x6F2E, 0x6F2F, 0x4443,      0,
  0x6F2D,      0,      0,      0, 0xE537, 0xE538, 0xE539,      0,
       0, 0x6F31, 0xE53A,      0,      0,      0,      0,      0,
 };
 const unsigned short utf8_to_euc_E98F[] = {
-      0, 0xE53C,      0, 0x6F37, 0xE53D, 0xE53E, 0x7C48, 0xE540,
+      0, 0xE53C,      0, 0x6F37, 0xE53D, 0xE53E, 0xE53F, 0xE540,
  0x6F3A, 0xE541, 0xE542, 0xE543, 0xE544, 0xE545,      0,      0,
  0x6F39, 0x452D,      0, 0xE546,      0,      0, 0x6F32, 0x6F33,
- 0x6F36, 0xE547,      0,      0, 0xE548, 0x6F38, 0x7C49, 0xE54A,
+ 0x6F36, 0xE547,      0,      0, 0xE548, 0x6F38, 0xE549, 0xE54A,
       0, 0x3640, 0xE54B,      0, 0x6F3B, 0x6F35, 0xE54C, 0xE54D,
  0x6F34,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0, 0xE54F,
- 0x7C4A, 0xE54E, 0xE551, 0xE552,      0, 0xE553,      0,      0,
+ 0xE550, 0xE54E, 0xE551, 0xE552,      0, 0xE553,      0,      0,
 };
 const unsigned short utf8_to_euc_E990[] = {
       0, 0xE554, 0xE555, 0x6F3F, 0xE556,      0,      0, 0x6F40,
@@ -5526,12 +5604,12 @@ const unsigned short utf8_to_euc_E990[] = {
  0x3E62, 0x462A, 0x6F3C,      0,      0,      0,      0, 0xE55F,
       0, 0x6F45,      0,      0,      0,      0,      0,      0,
       0,      0,      0, 0x6F43,      0,      0, 0xE560, 0xE561,
-      0, 0x7C4B, 0xE563, 0xE564, 0xE565, 0x6F44, 0x6F42,      0,
+      0, 0xE562, 0xE563, 0xE564, 0xE565, 0x6F44, 0x6F42,      0,
  0x4278,      0, 0x6F46, 0xE566,      0, 0xE568,      0, 0xE567,
 };
 const unsigned short utf8_to_euc_E991[] = {
-      0, 0x6F47,      0, 0xE569, 0x6F49, 0x7C4C,      0,      0,
- 0x7C4D,      0, 0xE56C,      0, 0xE56D,      0,      0,      0,
+      0, 0x6F47,      0, 0xE569, 0x6F49, 0xE56A,      0,      0,
+ 0xE56B,      0, 0xE56C,      0, 0xE56D,      0,      0,      0,
       0, 0x3455, 0x6F48, 0x4C7A,      0, 0xE56E,      0,      0,
       0, 0xE56F, 0x6F54, 0x6F4A, 0xE570,      0, 0x6F4D, 0xE571,
  0x6F4B, 0xE572, 0x6F4C, 0xE573,      0,      0,      0,      0,
@@ -5562,7 +5640,7 @@ const unsigned short utf8_to_euc_E995[] = {
 const unsigned short utf8_to_euc_E996[] = {
  0x4C67,      0, 0x6F59, 0x412E, 0xE622,      0,      0, 0x6F5A,
  0xE623, 0x4A44, 0x6F5B, 0x332B, 0xE624, 0xE625, 0xE626, 0x313C,
-      0, 0x3457, 0x7C4E, 0x3456, 0x6F5C,      0, 0x6F5D,      0,
+      0, 0x3457, 0xF471, 0x3456, 0x6F5C,      0, 0x6F5D,      0,
  0x6F5E, 0x6F5F,      0,      0,      0, 0xE627, 0xE628, 0xE629,
  0x6F60, 0xE62A, 0x3458, 0x3355, 0x395E, 0x4836, 0xE62B, 0x6F62,
  0x6F61, 0xE62C,      0, 0xE62D, 0xE62E, 0x6F63,      0,      0,
@@ -5603,9 +5681,9 @@ const unsigned short utf8_to_euc_E99A[] = {
       0, 0xE660, 0xE661, 0xE662, 0xE663, 0x3679, 0x4E34,      0,
  0x3728, 0xE664, 0x4262, 0x6721,      0, 0x7026, 0x332C, 0x3F6F,
       0, 0xE665,      0,      0, 0x3356, 0x7028, 0xE666, 0x7029,
- 0x7027, 0x3764, 0xE667, 0x3A5D, 0x3E63, 0x7C51,      0, 0xE669,
+ 0x7027, 0x3764, 0xE667, 0x3A5D, 0x3E63, 0xE668,      0, 0xE669,
  0x3123,      0,      0, 0x4E59, 0xE66A, 0xE66B, 0xE66C, 0x702B,
- 0x6E2E, 0xE66D, 0x702A,      0,      0,      0, 0xE66E, 0x7C52,
+ 0x6E2E, 0xE66D, 0x702A,      0,      0,      0, 0xE66E, 0xE66F,
  0x702E, 0x702C, 0x702D, 0xE670, 0x702F,      0, 0x7030, 0x4E6C,
  0x7031, 0x7032, 0xE671, 0x4049, 0x483B,      0,      0,      0,
 };
@@ -5626,13 +5704,13 @@ const unsigned short utf8_to_euc_E99C[] = {
       0, 0x7044, 0xE724, 0xE725, 0x417A, 0xE726, 0x3262,      0,
       0, 0xE727, 0xE728, 0xE729, 0x7045,      0,      0, 0x4C38,
  0xE72A,      0, 0x7046,      0,      0,      0,      0,      0,
- 0x7047, 0xE72B, 0x4F2A, 0x7C53,      0,      0,      0,      0,
- 0x5B31, 0x7048,      0, 0x7C54,      0, 0x7049, 0x704A,      0,
+ 0x7047, 0xE72B, 0x4F2A, 0xE72C,      0,      0,      0,      0,
+ 0x5B31, 0x7048,      0, 0xF474,      0, 0x7049, 0x704A,      0,
 };
 const unsigned short utf8_to_euc_E99D[] = {
-      0, 0xE72D, 0x704E, 0x7C55, 0x704B,      0, 0x704C,      0,
- 0x704D, 0x704F, 0xE72F,      0,      0, 0x7C56, 0xE730, 0x7C57,
-      0, 0x7C58, 0x4044,      0,      0, 0x7C59, 0x4C77, 0xE733,
+      0, 0xE72D, 0x704E, 0xE72E, 0x704B,      0, 0x704C,      0,
+ 0x704D, 0x704F, 0xE72F,      0,      0, 0xF475, 0xE730, 0xE731,
+      0, 0xF476, 0x4044,      0,      0, 0xE732, 0x4C77, 0xE733,
  0xE734, 0x4045, 0xE735, 0xE736, 0x7050,      0, 0x4873,      0,
  0x7051, 0x7353, 0x4C4C, 0xE737, 0x7052,      0, 0x7053, 0xE738,
  0x7054, 0x3357, 0xE739, 0x7056,      0, 0x3F59, 0xE73A,      0,
@@ -5672,9 +5750,9 @@ const unsigned short utf8_to_euc_E9A0[] = {
 const unsigned short utf8_to_euc_E9A1[] = {
       0,      0,      0,      0, 0xE82A,      0, 0x7079, 0xE82B,
       0,      0, 0xE82C, 0x707B, 0x426A, 0x335B, 0x335C, 0x707A,
-      0, 0xE82D, 0xE82E, 0xE82F, 0x3469, 0x3832, 0xE830, 0x7C5A,
+      0, 0xE82D, 0xE82E, 0xE82F, 0x3469, 0x3832, 0xE830, 0xE831,
  0x346A, 0xE832, 0xE833, 0x453F,      0,      0, 0x4E60,      0,
-      0,      0, 0xE834, 0xE835,      0, 0x7C5B, 0xE837, 0x385C,
+      0,      0, 0xE834, 0xE835,      0, 0xE836, 0xE837, 0x385C,
       0,      0, 0xE838, 0x707C, 0xE839,      0,      0, 0x707D,
  0x707E, 0x7121,      0, 0x7123, 0x7122,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
@@ -5704,7 +5782,7 @@ const unsigned short utf8_to_euc_E9A4[] = {
  0xE852, 0x712E, 0x4D5C,      0, 0x3142,      0,      0,      0,
  0x3B41, 0xE853, 0x712F, 0x326E, 0x7130, 0xE854, 0xE855, 0xE856,
  0x7131,      0, 0xE857, 0xE858, 0xE859, 0x7133, 0x7134, 0xE85A,
- 0x7136, 0x7132, 0xE85B,      0, 0x7135,      0, 0xE85C, 0x7C5E,
+ 0x7136, 0x7132, 0xE85B,      0, 0x7135,      0, 0xE85C, 0xE85D,
  0x345B,      0,      0, 0xE85E, 0x7137,      0, 0x7138,      0,
       0, 0xE85F, 0xE860, 0xE861, 0xE862, 0xE863,      0,      0,
       0, 0xE864, 0xE865, 0xE866, 0xE867, 0x7139, 0x713A,      0,
@@ -5723,7 +5801,7 @@ const unsigned short utf8_to_euc_E9A6[] = {
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0, 0x3C73, 0x7144,
- 0x7145, 0x3961,      0, 0xE877,      0, 0xE878, 0x7C60, 0xE879,
+ 0x7145, 0x3961,      0, 0xE877,      0, 0xE878, 0xF47A, 0xE879,
       0,      0,      0,      0,      0, 0x7146, 0xE87A,      0,
  0x333E,      0,      0,      0, 0x474F, 0x7147, 0x7148,      0,
  0xE87B, 0xE87C, 0xE87D, 0x435A, 0x466B, 0xE87E,      0,      0,
@@ -5751,7 +5829,7 @@ const unsigned short utf8_to_euc_E9A8[] = {
 };
 const unsigned short utf8_to_euc_E9A9[] = {
  0x715E, 0xE94C, 0x715D, 0x715F, 0xE94D, 0x715C,      0, 0xE94B,
-      0,      0, 0xE94E, 0xE94F, 0xE950, 0x7162, 0x7C61,      0,
+      0,      0, 0xE94E, 0xE94F, 0xE950, 0x7162, 0xE951,      0,
       0, 0xE952,      0,      0, 0xE953, 0x7161, 0xE954, 0x7164,
       0,      0, 0x3643, 0x7163,      0, 0xE955,      0, 0x7165,
       0,      0, 0x7166,      0, 0x7168, 0x7167,      0,      0,
@@ -5773,7 +5851,7 @@ const unsigned short utf8_to_euc_E9AB[] = {
  0x716F, 0xE962,      0, 0xE963, 0x3F71,      0, 0xE964,      0,
  0xE965,      0,      0,      0,      0,      0, 0xE966, 0x7170,
  0xE967, 0x7171, 0xE968, 0x7172, 0x7173, 0xE969, 0xE96A, 0xE96B,
- 0x3962, 0x7C62,      0, 0xE96C, 0x7C63,      0, 0x7174, 0x7175,
+ 0x3962, 0xF47B,      0, 0xE96C, 0xE96D,      0, 0x7174, 0x7175,
  0xE96E,      0, 0x7176, 0x7177, 0xE96F, 0xE970, 0x7178, 0xE971,
       0, 0xE972, 0x4831, 0x717A, 0xE973, 0x4926, 0x717B, 0x7179,
       0, 0x717D, 0xE974, 0xE975, 0x717C, 0xE976,      0, 0x717E,
@@ -5796,18 +5874,18 @@ const unsigned short utf8_to_euc_E9AD[] = {
  0x7236,      0, 0x357B, 0xEA40,      0,      0, 0xEA41,      0,
       0, 0xEA42,      0, 0xEA43,      0, 0xEA44, 0xEA45,      0,
  0xEA46,      0, 0xEA47, 0xEA48, 0xEA49, 0xEA4A, 0xEA4B, 0x4F25,
-      0,      0, 0x7C65, 0xEA4C, 0x7237, 0x7C64,      0, 0xEA4E,
+      0,      0, 0xF47C, 0xEA4C, 0x7237, 0xEA4D,      0, 0xEA4E,
  0xEA4F, 0xEA50,      0,      0,      0,      0,      0, 0xEA51,
 };
 const unsigned short utf8_to_euc_E9AE[] = {
  0xEA52,      0,      0, 0x7239, 0xEA53, 0xEA54, 0xEA55, 0xEA56,
-      0, 0xEA57, 0xEA58, 0xEA59,      0, 0xEA5A, 0x303E, 0x7C66,
+      0, 0xEA57, 0xEA58, 0xEA59,      0, 0xEA5A, 0x303E, 0xEA5B,
  0xEA5C, 0x723A, 0x4A2B, 0x7238, 0xEA5D,      0, 0x723B, 0x723C,
       0,      0, 0xEA5E,      0,      0, 0xEA5F, 0xEA60, 0x723D,
  0x723E,      0,      0,      0,      0,      0, 0xEA61, 0xEA62,
  0x723F, 0xEA63, 0x4B6E, 0x3B2D, 0xEA64, 0x3A7A, 0x412F,      0,
- 0xEA65, 0x7C67, 0xEA67,      0, 0x7240,      0,      0, 0xEA68,
- 0xEA69, 0x7243,      0, 0x7C68, 0xEA6B,      0, 0xEA6C, 0xEA6D,
+ 0xEA65, 0xEA66, 0xEA67,      0, 0x7240,      0,      0, 0xEA68,
+ 0xEA69, 0x7243,      0, 0xEA6A, 0xEA6B,      0, 0xEA6C, 0xEA6D,
 };
 const unsigned short utf8_to_euc_E9AF[] = {
  0x7241, 0xEA6E,      0,      0,      0,      0, 0x7244, 0xEA6F,
@@ -5820,7 +5898,7 @@ const unsigned short utf8_to_euc_E9AF[] = {
  0xEA7E, 0xEB21, 0xEB22,      0,      0, 0xEB23,      0, 0xEB24,
 };
 const unsigned short utf8_to_euc_E9B0[] = {
- 0x7C69,      0, 0xEB26,      0, 0x725A,      0, 0x7256,      0,
+ 0xEB25,      0, 0xEB26,      0, 0x725A,      0, 0x7256,      0,
  0x7257, 0x7253, 0x7259, 0xEB27, 0x7255, 0x3362,      0, 0xEB28,
  0x4F4C, 0xEB29, 0x7258, 0x7254, 0x7252, 0x7251, 0xEB2A,      0,
  0xEB2B, 0xEB2C, 0xEB2D, 0x725C, 0xEB2E,      0, 0xEB2F,      0,
@@ -5865,8 +5943,8 @@ const unsigned short utf8_to_euc_E9B5[] = {
  0x7325, 0x7324,      0, 0xEB72, 0xEB73,      0,      0,      0,
       0, 0x7326,      0,      0, 0x312D, 0x7321, 0x7322, 0xEB74,
  0x3974, 0x4C39, 0xEB76, 0xEB75, 0x7323, 0xEB77,      0,      0,
-      0, 0xEB78, 0xEB79, 0x7C6B, 0x4B32,      0,      0, 0x732B,
- 0x7C6A,      0, 0x7327,      0,      0,      0, 0xEB7C, 0xEB7D,
+      0, 0xEB78, 0xEB79, 0xEB7A, 0x4B32,      0,      0, 0x732B,
+ 0xEB7B,      0, 0x7327,      0,      0,      0, 0xEB7C, 0xEB7D,
       0,      0, 0x732C, 0xEB7E, 0xEC21,      0, 0xEC22,      0,
 };
 const unsigned short utf8_to_euc_E9B6[] = {
@@ -5893,7 +5971,7 @@ const unsigned short utf8_to_euc_E9B8[] = {
       0,      0, 0xEC4E,      0,      0,      0,      0, 0xEC4F,
       0,      0, 0xEC4D,      0,      0,      0, 0xEC50,      0,
  0xEC51, 0xEC52, 0xEC53,      0,      0, 0xEC54, 0xEC55,      0,
-      0, 0x7C6D, 0x7340, 0x7341, 0xEC57, 0xEC58, 0x7342,      0,
+      0, 0xEC56, 0x7340, 0x7341, 0xEC57, 0xEC58, 0x7342,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
@@ -5922,7 +6000,7 @@ const unsigned short utf8_to_euc_E9BA[] = {
 const unsigned short utf8_to_euc_E9BB[] = {
       0,      0,      0,      0, 0x322B,      0, 0xEC71,      0,
  0xEC72,      0,      0, 0xEC73, 0x7354, 0x3550, 0x7355, 0x7356,
- 0x7357, 0x7C6E, 0x3975,      0, 0x7358, 0xEC74,      0,      0,
+ 0x7357, 0xF47E, 0x3975,      0, 0x7358, 0xEC74,      0,      0,
  0x6054, 0x4C5B,      0, 0x4263, 0x7359, 0x735B, 0x735A, 0xEC75,
  0x735C,      0,      0,      0, 0xEC76, 0x735D,      0, 0xEC77,
  0x735E,      0,      0,      0, 0xEC78, 0xEC79, 0xEC7A, 0x735F,
@@ -5965,7 +6043,7 @@ const unsigned short utf8_to_euc_EFA4[] = {
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
-      0, 0x7A46,      0,      0,      0,      0,      0,      0,
+      0, 0xF445,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
 };
@@ -5973,7 +6051,7 @@ const unsigned short utf8_to_euc_EFA7[] = {
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
-      0,      0,      0,      0, 0x7C4F,      0,      0,      0,
+      0,      0,      0,      0, 0xF472,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
@@ -5981,36 +6059,16 @@ const unsigned short utf8_to_euc_EFA7[] = {
 };
 const unsigned short utf8_to_euc_EFA8[] = {
       0,      0,      0,      0,      0,      0,      0,      0,
-      0,      0,      0,      0,      0,      0, 0x7954, 0x795F,
- 0x7960, 0x7975, 0x7A3E, 0x7A4E, 0x7A50, 0x7A7B, 0x7B23, 0x7B3A,
- 0x7B42, 0x7B43, 0x7B44, 0x7B46, 0x7B4A, 0x7B4D, 0x7B56, 0x7B61,
- 0x7B63, 0x7B64, 0x7B6D, 0x7B75, 0x7B77, 0x7B78, 0x7B7B, 0x7C39,
- 0x7C40, 0x7C50, 0x7C5C, 0x7C5D, 0x7C5F, 0x7C6C,      0,      0,
-      0,      0,      0,      0,      0,      0,      0,      0,
-      0,      0,      0,      0,      0,      0,      0,      0,
-};
-const unsigned short utf8_to_euc_EFB8[] = {
-      0,      0,      0,      0,      0,      0,      0,      0,
-      0,      0,      0,      0,      0,      0,      0,      0,
-      0,      0,      0,      0,      0,      0,      0,      0,
-      0,      0,      0,      0,      0,      0,      0,      0,
-      0,      0,      0,      0,      0,      0,      0,      0,
-      0,      0,      0,      0,      0,      0,      0,      0,
- 0x7545, 0x753D,      0, 0x7532,      0, 0x754A, 0x754B, 0x7550,
- 0x7551, 0x754C, 0x754D, 0x755A, 0x755B, 0x7554, 0x7555, 0x7552,
-};
-const unsigned short utf8_to_euc_EFB9[] = {
- 0x7553, 0x7556, 0x7557, 0x7558, 0x7559,      0,      0,      0,
-      0,      0,      0,      0,      0,      0,      0,      0,
-      0,      0,      0,      0,      0,      0,      0,      0,
-      0,      0,      0,      0,      0,      0,      0,      0,
-      0,      0,      0,      0,      0,      0,      0,      0,
-      0,      0,      0,      0,      0,      0,      0,      0,
+      0,      0,      0,      0,      0,      0, 0xF434, 0xF437,
+ 0xF438, 0xF43D, 0xF444, 0xF447, 0xF448, 0xF44E, 0xF44F, 0xF453,
+ 0xF455, 0xF456, 0xF457, 0xF458, 0xF45A, 0xF45B, 0xF45E, 0xF460,
+ 0xF462, 0xF463, 0xF465, 0xF469, 0xF46A, 0xF46B, 0xF46D, 0xF46F,
+ 0xF470, 0xF473, 0xF477, 0xF478, 0xF479, 0xF47D,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
 };
 const unsigned short utf8_to_euc_EFBC[] = {
-      0, 0x212A, 0x7C7E, 0x2174, 0x2170, 0x2173, 0x2175, 0x7C7D,
+      0, 0x212A, 0xF42A, 0x2174, 0x2170, 0x2173, 0x2175, 0xF429,
  0x214A, 0x214B, 0x2176, 0x215C, 0x2124, 0x215D, 0x2125, 0x213F,
  0x2330, 0x2331, 0x2332, 0x2333, 0x2334, 0x2335, 0x2336, 0x2337,
  0x2338, 0x2339, 0x2127, 0x2128, 0x2163, 0x2161, 0x2164, 0x2129,
@@ -6020,6 +6078,16 @@ const unsigned short utf8_to_euc_EFBC[] = {
  0x2358, 0x2359, 0x235A, 0x214E, 0x2140, 0x214F, 0x2130, 0x2132,
 };
 const unsigned short utf8_to_euc_EFBD[] = {
+ 0x212E, 0x2361, 0x2362, 0x2363, 0x2364, 0x2365, 0x2366, 0x2367,
+ 0x2368, 0x2369, 0x236A, 0x236B, 0x236C, 0x236D, 0x236E, 0x236F,
+ 0x2370, 0x2371, 0x2372, 0x2373, 0x2374, 0x2375, 0x2376, 0x2377,
+ 0x2378, 0x2379, 0x237A, 0x2150, 0x2143, 0x2151, 0xA237,      0,
+      0, 0x0E21, 0x0E22, 0x0E23, 0x0E24, 0x0E25, 0x0E26, 0x0E27,
+ 0x0E28, 0x0E29, 0x0E2A, 0x0E2B, 0x0E2C, 0x0E2D, 0x0E2E, 0x0E2F,
+ 0x0E30, 0x0E31, 0x0E32, 0x0E33, 0x0E34, 0x0E35, 0x0E36, 0x0E37,
+ 0x0E38, 0x0E39, 0x0E3A, 0x0E3B, 0x0E3C, 0x0E3D, 0x0E3E, 0x0E3F,
+};
+const unsigned short utf8_to_euc_EFBD_ms[] = {
  0x212E, 0x2361, 0x2362, 0x2363, 0x2364, 0x2365, 0x2366, 0x2367,
  0x2368, 0x2369, 0x236A, 0x236B, 0x236C, 0x236D, 0x236E, 0x236F,
  0x2370, 0x2371, 0x2372, 0x2373, 0x2374, 0x2375, 0x2376, 0x2377,
@@ -6044,7 +6112,7 @@ const unsigned short utf8_to_euc_EFBF[] = {
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
- 0x2171, 0x2172, 0x224C, 0x2131, 0x7C7C, 0x216F,      0,      0,
+ 0x2171, 0x2172, 0x224C, 0x2131, 0xA243, 0x216F,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
@@ -6054,10 +6122,46 @@ const unsigned short *const utf8_to_euc_E2[] = {
  utf8_to_euc_E284, utf8_to_euc_E285, utf8_to_euc_E286, utf8_to_euc_E287,
  utf8_to_euc_E288, utf8_to_euc_E289, utf8_to_euc_E28A,                0,
  utf8_to_euc_E28C,                0,                0,                0,
-                0, utf8_to_euc_E291, utf8_to_euc_E292,                0,
+                0, utf8_to_euc_E291,                0,                0,
+ utf8_to_euc_E294, utf8_to_euc_E295, utf8_to_euc_E296, utf8_to_euc_E297,
+ utf8_to_euc_E298, utf8_to_euc_E299,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+};
+const unsigned short *const utf8_to_euc_E2_ms[] = {
+ utf8_to_euc_E280_ms,                0,                0,                0,
+ utf8_to_euc_E284, utf8_to_euc_E285, utf8_to_euc_E286, utf8_to_euc_E287,
+ utf8_to_euc_E288, utf8_to_euc_E289, utf8_to_euc_E28A,                0,
+ utf8_to_euc_E28C,                0,                0,                0,
+                0, utf8_to_euc_E291,                0,                0,
  utf8_to_euc_E294, utf8_to_euc_E295, utf8_to_euc_E296, utf8_to_euc_E297,
  utf8_to_euc_E298, utf8_to_euc_E299,                0,                0,
-                0, utf8_to_euc_E29D,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+};
+const unsigned short *const utf8_to_euc_E2_932[] = {
+ utf8_to_euc_E280_932,                0,                0,                0,
+ utf8_to_euc_E284, utf8_to_euc_E285, utf8_to_euc_E286, utf8_to_euc_E287,
+ utf8_to_euc_E288_932, utf8_to_euc_E289, utf8_to_euc_E28A,                0,
+ utf8_to_euc_E28C,                0,                0,                0,
+                0, utf8_to_euc_E291,                0,                0,
+ utf8_to_euc_E294, utf8_to_euc_E295, utf8_to_euc_E296, utf8_to_euc_E297,
+ utf8_to_euc_E298, utf8_to_euc_E299,                0,                0,
+                0,                0,                0,                0,
                 0,                0,                0,                0,
                 0,                0,                0,                0,
                 0,                0,                0,                0,
@@ -6070,7 +6174,25 @@ const unsigned short *const utf8_to_euc_E2[] = {
 const unsigned short *const utf8_to_euc_E3[] = {
  utf8_to_euc_E380, utf8_to_euc_E381, utf8_to_euc_E382, utf8_to_euc_E383,
                 0,                0,                0,                0,
- utf8_to_euc_E388, utf8_to_euc_E389, utf8_to_euc_E38A,                0,
+ utf8_to_euc_E388,                0, utf8_to_euc_E38A,                0,
+ utf8_to_euc_E38C, utf8_to_euc_E38D, utf8_to_euc_E38E, utf8_to_euc_E38F,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+};
+const unsigned short *const utf8_to_euc_E3_932[] = {
+ utf8_to_euc_E380_932, utf8_to_euc_E381, utf8_to_euc_E382_932, utf8_to_euc_E383,
+                0,                0,                0,                0,
+ utf8_to_euc_E388,                0, utf8_to_euc_E38A,                0,
  utf8_to_euc_E38C, utf8_to_euc_E38D, utf8_to_euc_E38E, utf8_to_euc_E38F,
                 0,                0,                0,                0,
                 0,                0,                0,                0,
@@ -6208,9 +6330,27 @@ const unsigned short *const utf8_to_euc_EF[] = {
                 0,                0,                0,                0,
                 0,                0,                0,                0,
                 0,                0,                0,                0,
- utf8_to_euc_EFB8, utf8_to_euc_EFB9,                0,                0,
+                0,                0,                0,                0,
  utf8_to_euc_EFBC, utf8_to_euc_EFBD, utf8_to_euc_EFBE, utf8_to_euc_EFBF,
 };
+const unsigned short *const utf8_to_euc_EF_ms[] = {
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+ utf8_to_euc_EFA4,                0,                0, utf8_to_euc_EFA7,
+ utf8_to_euc_EFA8,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+                0,                0,                0,                0,
+ utf8_to_euc_EFBC, utf8_to_euc_EFBD_ms, utf8_to_euc_EFBE, utf8_to_euc_EFBF,
+};
 const unsigned short *const utf8_to_euc_2bytes[] = {
               0,              0,              0,              0,
               0,              0,              0,              0,
@@ -6241,13 +6381,38 @@ const unsigned short *const utf8_to_euc_2bytes[] = {
               0,              0,              0,              0,
               0,              0,              0,              0,
 };
-const unsigned short *const *const utf8_to_euc_3bytes[] = {
+const unsigned short *const utf8_to_euc_2bytes_ms[] = {
+              0,              0,              0,              0,
+              0,              0,              0,              0,
+              0,              0,              0,              0,
+              0,              0,              0,              0,
+              0,              0,              0,              0,
+              0,              0,              0,              0,
+              0,              0,              0,              0,
+              0,              0,              0,              0,
+              0,              0,              0,              0,
+              0,              0,              0,              0,
+              0,              0,              0,              0,
+              0,              0,              0,              0,
+              0,              0,              0,              0,
+              0,              0,              0,              0,
+              0,              0,              0,              0,
+              0,              0,              0,              0,
+              0,              0, utf8_to_euc_C2_ms, utf8_to_euc_C3,
+ utf8_to_euc_C4, utf8_to_euc_C5,              0, utf8_to_euc_C7,
+              0,              0,              0, utf8_to_euc_CB,
+              0,              0, utf8_to_euc_CE, utf8_to_euc_CF,
+ utf8_to_euc_D0, utf8_to_euc_D1,              0,              0,
+              0,              0,              0,              0,
               0,              0,              0,              0,
               0,              0,              0,              0,
               0,              0,              0,              0,
               0,              0,              0,              0,
               0,              0,              0,              0,
               0,              0,              0,              0,
+};
+const unsigned short *const utf8_to_euc_2bytes_932[] = {
+              0,              0,              0,              0,
               0,              0,              0,              0,
               0,              0,              0,              0,
               0,              0,              0,              0,
@@ -6262,15 +6427,38 @@ const unsigned short *const *const utf8_to_euc_3bytes[] = {
               0,              0,              0,              0,
               0,              0,              0,              0,
               0,              0,              0,              0,
+              0,              0,              0,              0,
+              0,              0, utf8_to_euc_C2_932, utf8_to_euc_C3_932,
+ utf8_to_euc_C4, utf8_to_euc_C5,              0, utf8_to_euc_C7,
+              0,              0,              0, utf8_to_euc_CB,
+              0,              0, utf8_to_euc_CE, utf8_to_euc_CF,
+ utf8_to_euc_D0, utf8_to_euc_D1,              0,              0,
               0,              0,              0,              0,
               0,              0,              0,              0,
               0,              0,              0,              0,
               0,              0,              0,              0,
+              0,              0,              0,              0,
+              0,              0,              0,              0,
+              0,              0,              0,              0,
+};
+const unsigned short *const *const utf8_to_euc_3bytes[] = {
               0,              0, utf8_to_euc_E2, utf8_to_euc_E3,
  utf8_to_euc_E4, utf8_to_euc_E5, utf8_to_euc_E6, utf8_to_euc_E7,
  utf8_to_euc_E8, utf8_to_euc_E9,              0,              0,
               0,              0,              0, utf8_to_euc_EF,
 };
+const unsigned short *const *const utf8_to_euc_3bytes_ms[] = {
+              0,              0, utf8_to_euc_E2_ms, utf8_to_euc_E3,
+ utf8_to_euc_E4, utf8_to_euc_E5, utf8_to_euc_E6, utf8_to_euc_E7,
+ utf8_to_euc_E8, utf8_to_euc_E9,              0,              0,
+              0,              0,              0, utf8_to_euc_EF_ms,
+};
+const unsigned short *const *const utf8_to_euc_3bytes_932[] = {
+              0,              0, utf8_to_euc_E2_932, utf8_to_euc_E3_932,
+ utf8_to_euc_E4, utf8_to_euc_E5, utf8_to_euc_E6, utf8_to_euc_E7,
+ utf8_to_euc_E8, utf8_to_euc_E9,              0,              0,
+              0,              0,              0, utf8_to_euc_EF_ms,
+};
 
 #ifdef UNICODE_NORMALIZATION
 
@@ -7444,9 +7632,9 @@ const unsigned short shiftjis_x0212[3][189] = {
 };
 
 const unsigned short x0212_shiftjis_A2[] = {
-              0,      0,      0,      0,      0,      0,      0,
-      0,      0,      0,      0,      0,      0,      0,      0,
+         0x819F,      0,      0,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
+      0, 0x8143,      0,      0, 0x8150,      0,      0, 0x8160,
       0,      0,      0,      0,      0,      0,      0,      0,
       0,      0,      0, 0xFA55,      0,      0,      0,      0,
       0,      0,      0,      0,      0,      0,      0,      0,
diff --git a/ext/nkf/nkf.c b/ext/nkf/nkf.c
index 65442a130c..8eb92b6cd6 100644
--- a/ext/nkf/nkf.c
+++ b/ext/nkf/nkf.c
@@ -1,9 +1,9 @@
 /*
- * NKF Module for Ruby base on nkf 2.x
+ *  NKF - Ruby extension for Network Kanji Filter
  *
- * original nkf2.x is maintained at http://sourceforge.jp/projects/nkf/
+ *  original nkf2.x is maintained at http://sourceforge.jp/projects/nkf/
  *
- * $Id$
+ *  $Id$
  *
  */
 
@@ -78,6 +78,69 @@ rb_nkf_putchar(c)
 #include "nkf-utf8/utf8tbl.c"
 #include "nkf-utf8/nkf.c"
 
+int nkf_split_options(arg)
+    const char* arg;
+{
+    int count = 0;
+    char option[256];
+    int i = 0, j = 0;
+    int is_escaped = FALSE;
+    int is_single_quoted = FALSE;
+    int is_double_quoted = FALSE;
+    for(i = 0; arg[i]; i++){
+	if(j == 255){
+	    return -1;
+	}else if(is_single_quoted){
+	    if(arg[i] == '\''){
+		is_single_quoted = FALSE;
+	    }else{
+		option[j++] = arg[i];
+	    }
+	}else if(is_escaped){
+	    is_escaped = FALSE;
+	    option[j++] = arg[i];
+	}else if(arg[i] == '\\'){
+	    is_escaped = TRUE;
+	}else if(is_double_quoted){
+	    if(arg[i] == '"'){
+		is_double_quoted = FALSE;
+	    }else{
+		option[j++] = arg[i];
+	    }
+	}else if(arg[i] == '\''){
+	    is_single_quoted = TRUE;
+	}else if(arg[i] == '"'){
+	    is_double_quoted = TRUE;
+	}else if(arg[i] == ' '){
+	    option[j] = '\0';
+	    options(option);
+	    j = 0;
+	}else{
+	    option[j++] = arg[i];
+	}
+    }
+    if(j){
+	option[j] = '\0';
+	options(option);
+    }
+    return count;
+}
+
+/*
+ *  call-seq:
+ *     NKF.nkf(opt, str)   -> string
+ *
+ *  Convert _str_ and return converted result.
+ *  Conversion details are specified by _opt_ as String.
+ *
+ *     require 'nkf'
+ *     output = NKF.nkf("-s", input)
+ *
+ *  *Note*
+ *  By default, nkf decodes MIME encoded string.
+ *  If you want not to decode input, use NKF.nkf with <b>-m0</b> flag.
+ */
+
 static VALUE
 rb_nkf_kconv(obj, opt, src)
   VALUE obj, opt, src;
@@ -89,7 +152,7 @@ rb_nkf_kconv(obj, opt, src)
   StringValue(opt);
   opt_ptr = RSTRING(opt)->ptr;
   opt_end = opt_ptr + RSTRING(opt)->len;
-  options(opt_ptr);
+  nkf_split_options(opt_ptr);
 
   incsize = INCSIZE;
 
@@ -118,11 +181,27 @@ rb_nkf_kconv(obj, opt, src)
 
 
 /*
- * NKF.guess1
+ *  call-seq:
+ *     NKF.guess1(str)  -> integer
+ *
+ *  Returns guessed encoding of _str_ as integer.
+ *
+ *  Algorithm described in:
+ *  Ken Lunde. `Understanding Japanese Information Processing'
+ *  Sebastopol, CA: O'Reilly & Associates.
  *
- * Character code detection - Algorithm described in:
- * Ken Lunde. `Understanding Japanese Information Processing'
- * Sebastopol, CA: O'Reilly & Associates.
+ *      case NKF.guess1(input)
+ *      when NKF::JIS
+ *        "ISO-2022-JP"
+ *      when NKF::SJIS
+ *        "Shift_JIS"
+ *      when NKF::EUC
+ *        "EUC-JP"
+ *      when NKF::UNKNOWN
+ *        "UNKNOWN(ASCII)"
+ *      when NKF::BINARY
+ *        "BINARY"
+ *      end
  */
 
 static VALUE
@@ -214,9 +293,29 @@ rb_nkf_guess1(obj, src)
 
 
 /*
- * NKF.guess2
+ *  call-seq:
+ *     NKF.guess2(str)  -> integer
  *
- * Guess Encoding By NKF2.0 Routine 
+ *  Returns guessed encoding of _str_ as integer by nkf routine.
+ *
+ *     case NKF.guess(input)
+ *     when NKF::ASCII
+ *       "ASCII"
+ *     when NKF::JIS
+ *       "ISO-2022-JP"
+ *     when NKF::SJIS
+ *       "Shift_JIS"
+ *     when NKF::EUC
+ *       "EUC-JP"
+ *     when NKF::UTF8
+ *       "UTF-8"
+ *     when NKF::UTF16
+ *       "UTF-16"
+ *     when NKF::UNKNOWN
+ *       "UNKNOWN"
+ *     when NKF::BINARY
+ *       "BINARY"
+ *     end
  */
 
 static VALUE
@@ -261,32 +360,295 @@ rb_nkf_guess2(obj, src)
 }
 
 
-/* Initialize NKF Module */
+/*
+ *  NKF - Ruby extension for Network Kanji Filter 
+ *
+ *  == Description
+ *
+ *  This is a Ruby Extension version of nkf (Netowrk Kanji Filter).
+ *  It converts the first argument and return converted result. Conversion
+ *  details are specified by flags as the first argument.
+ *
+ *  *Nkf* is a yet another kanji code converter among networks, hosts and terminals.
+ *  It converts input kanji code to designated kanji code
+ *  such as ISO-2022-JP, Shift_JIS, EUC-JP, UTF-8 or UTF-16.
+ *
+ *  One of the most unique faculty of *nkf* is the guess of the input kanji encodings.
+ *  It currently recognizes ISO-2022-JP, Shift_JIS, EUC-JP, UTF-8 and UTF-16.
+ *  So users needn't set the input kanji code explicitly.
+ *
+ *  By default, X0201 kana is converted into X0208 kana.
+ *  For X0201 kana, SO/SI, SSO and ESC-(-I methods are supported.
+ *  For automatic code detection, nkf assumes no X0201 kana in Shift_JIS.
+ *  To accept X0201 in Shift_JIS, use <b>-X</b>, <b>-x</b> or <b>-S</b>.
+ *
+ *  == Flags
+ *
+ *  === -b -u
+ *
+ *  Output is buffered (DEFAULT), Output is unbuffered.
+ *
+ *  === -j -s -e -w -w16
+ *
+ *  Output code is ISO-2022-JP (7bit JIS), Shift_JIS, EUC-JP,
+ *  UTF-8N, UTF-16BE.
+ *  Without this option and compile option, ISO-2022-JP is assumed.
+ *
+ *  === -J -S -E -W -W16
+ *
+ *  Input assumption is JIS 7 bit, Shift_JIS, EUC-JP,
+ *  UTF-8, UTF-16LE.
+ *
+ *  ==== -J
+ *
+ *  Assume  JIS input. It also accepts EUC-JP.
+ *  This is the default. This flag does not exclude Shift_JIS.
+ *
+ *  ==== -S
+ *
+ *  Assume Shift_JIS and X0201 kana input. It also accepts JIS.
+ *  EUC-JP is recognized as X0201 kana. Without <b>-x</b> flag,
+ *  X0201 kana (halfwidth kana) is converted into X0208.
+ *
+ *  ==== -E
+ *
+ *  Assume EUC-JP input. It also accepts JIS.
+ *  Same as -J.
+ *
+ *  === -t
+ *
+ *  No conversion.
+ *
+ *  === -i_
+ *
+ *  Output sequence to designate JIS-kanji. (DEFAULT B)
+ *
+ *  === -o_
+ *
+ *  Output sequence to designate ASCII. (DEFAULT B)
+ *
+ *  === -r
+ *
+ *  {de/en}crypt ROT13/47
+ *
+ *  === -h[123] --hiragana --katakana --katakana-hiragana
+ *
+ *  [-h1 --hiragana] Katakana to Hiragana conversion.
+ *
+ *  [-h2 --katakana] Hiragana to Katakana conversion.
+ *
+ *  [-h3 --katakana-hiragana] Katakana to Hiragana and Hiragana to Katakana conversion.
+ *
+ *  === -T
+ *
+ *  Text mode output (MS-DOS)
+ *
+ *  === -l
+ *
+ *  ISO8859-1 (Latin-1) support
+ *
+ *  === -f[<code>m</code> [- <code>n</code>]]
+ *
+ *  Folding on <code>m</code> length with <code>n</code> margin in a line.
+ *  Without this option, fold length is 60 and fold margin is 10.
+ *
+ *  === -F
+ *
+ *  New line preserving line folding.
+ *
+ *  === -Z[0-3]
+ *
+ *  Convert X0208 alphabet (Fullwidth Alphabets) to ASCII.
+ *
+ *  [-Z -Z0] Convert X0208 alphabet to ASCII.
+ *
+ *  [-Z1] Converts X0208 kankaku to single ASCII space.
+ *
+ *  [-Z2] Converts X0208 kankaku to double ASCII spaces.
+ *
+ *  [-Z3] Replacing Fullwidth >, <, ", & into '&gt;', '&lt;', '&quot;', '&amp;' as in HTML.
+ *
+ *  === -X -x
+ *
+ *  Assume X0201 kana in MS-Kanji.
+ *  With <b>-X</b> or without this option, X0201 is converted into X0208 Kana.
+ *  With <b>-x</b>, try to preserve X0208 kana and do not convert X0201 kana to X0208.
+ *  In JIS output, ESC-(-I is used. In EUC output, SSO is used.
+ *
+ *  === -B[0-2]
+ *
+ *  Assume broken JIS-Kanji input, which lost ESC.
+ *  Useful when your site is using old B-News Nihongo patch.
+ *
+ *  [-B1] allows any char after ESC-( or ESC-$.
+ *
+ *  [-B2] forces ASCII after NL.
+ *
+ *  === -I
+ *
+ *  Replacing non iso-2022-jp char into a geta character
+ *  (substitute character in Japanese).
+ *
+ *  === -d -c
+ *
+ *  Delete \r in line feed, Add \r in line feed.
+ *
+ *  === -m[BQN0]
+ *
+ *  MIME ISO-2022-JP/ISO8859-1 decode. (DEFAULT)
+ *  To see ISO8859-1 (Latin-1) -l is necessary.
+ *
+ *  [-mB] Decode MIME base64 encoded stream. Remove header or other part before
+ *  conversion. 
+ *
+ *  [-mQ] Decode MIME quoted stream. '_' in quoted stream is converted to space.
+ *
+ *  [-mN] Non-strict decoding.
+ *  It allows line break in the middle of the base64 encoding.
+ *
+ *  [-m0] No MIME decode.
+ *
+ *  === -M
+ *
+ *  MIME encode. Header style. All ASCII code and control characters are intact.
+ *  Kanji conversion is performed before encoding, so this cannot be used as a picture encoder.
+ *
+ *  [-MB] MIME encode Base64 stream.
+ *
+ *  [-MQ] Perfome quoted encoding.
+ *
+ *  === -l
+ *
+ *  Input and output code is ISO8859-1 (Latin-1) and ISO-2022-JP.
+ *  <b>-s</b>, <b>-e</b> and <b>-x</b> are not compatible with this option.
+ *
+ *  === -L[uwm]
+ *
+ *  new line mode
+ *  Without this option, nkf doesn't convert line breaks.
+ *
+ *  [-Lu] unix (LF)
+ *
+ *  [-Lw] windows (CRLF)
+ *
+ *  [-Lm] mac (CR)
+ *
+ *  === --fj --unix --mac --msdos --windows
+ *
+ *  convert for these system
+ *
+ *  === --jis --euc --sjis --mime --base64
+ *
+ *  convert for named code
+ *
+ *  === --jis-input --euc-input --sjis-input --mime-input --base64-input
+ *
+ *  assume input system
+ *
+ *  === --ic=<code>input codeset</code> --oc=<code>output codeset</code>
+ *
+ *  Set the input or output codeset.
+ *  NKF supports following codesets and those codeset name are case insensitive.
+ *
+ *  [ISO-2022-JP] a.k.a. RFC1468, 7bit JIS, JUNET
+ *
+ *  [EUC-JP (eucJP-nkf)] a.k.a. AT&T JIS, Japanese EUC, UJIS
+ *
+ *  [eucJP-ascii] a.k.a. x-eucjp-open-19970715-ascii
+ *
+ *  [eucJP-ms] a.k.a. x-eucjp-open-19970715-ms
+ *
+ *  [CP51932] Microsoft Version of EUC-JP.
+ *
+ *  [Shift_JIS] SJIS, MS-Kanji
+ *
+ *  [CP932] a.k.a. Windows-31J
+ *
+ *  [UTF-8] same as UTF-8N
+ *
+ *  [UTF-8N] UTF-8 without BOM
+ *
+ *  [UTF-8-BOM] UTF-8 with BOM
+ *
+ *  [UTF-16] same as UTF-16BE
+ *
+ *  [UTF-16BE] UTF-16 Big Endian without BOM
+ *
+ *  [UTF-16BE-BOM] UTF-16 Big Endian with BOM
+ *
+ *  [UTF-16LE] UTF-16 Little Endian without BOM
+ *
+ *  [UTF-16LE-BOM] UTF-16 Little Endian with BOM
+ *
+ *  [UTF8-MAC] NKDed UTF-8, a.k.a. UTF8-NFD (input only)
+ *
+ *  === --fb-{skip, html, xml, perl, java, subchar}
+ *
+ *  Specify the way that nkf handles unassigned characters.
+ *  Without this option, --fb-skip is assumed.
+ *
+ *  === --prefix= <code>escape character</code> <code>target character</code> ..
+ *
+ *  When nkf converts to Shift_JIS,
+ *  nkf adds a specified escape character to specified 2nd byte of Shift_JIS characters.
+ *  1st byte of argument is the escape character and following bytes are target characters.
+ *
+ *  === --disable-cp932ext
+ *
+ *  Handle the characters extended in CP932 as unassigned characters.
+ *
+ *  === --cap-input
+ *
+ *  Decode hex encoded characters.
+ *
+ *  === --url-input
+ *
+ *  Unescape percent escaped characters.
+ *
+ *  === --
+ *
+ *  Ignore rest of -option.
+ */
 
 void
 Init_nkf()
 {
-  VALUE mKconv = rb_define_module("NKF");
-
-  rb_define_module_function(mKconv, "nkf", rb_nkf_kconv, 2);
-  rb_define_module_function(mKconv, "guess", rb_nkf_guess2, 1);
-  rb_define_module_function(mKconv, "guess1", rb_nkf_guess1, 1);
-  rb_define_module_function(mKconv, "guess2", rb_nkf_guess2, 1);
-
-  rb_define_const(mKconv, "AUTO", INT2FIX(_AUTO));
-  rb_define_const(mKconv, "JIS", INT2FIX(_JIS));
-  rb_define_const(mKconv, "EUC", INT2FIX(_EUC));
-  rb_define_const(mKconv, "SJIS", INT2FIX(_SJIS));
-  rb_define_const(mKconv, "BINARY", INT2FIX(_BINARY));
-  rb_define_const(mKconv, "NOCONV", INT2FIX(_NOCONV));
-  rb_define_const(mKconv, "ASCII", INT2FIX(_ASCII));
-  rb_define_const(mKconv, "UTF8", INT2FIX(_UTF8));
-  rb_define_const(mKconv, "UTF16", INT2FIX(_UTF16));
-  rb_define_const(mKconv, "UTF32", INT2FIX(_UTF32));
-  rb_define_const(mKconv, "UNKNOWN", INT2FIX(_UNKNOWN));
-  rb_define_const(mKconv, "VERSION", rb_str_new2(RUBY_NKF_VERSION));
-  /* for debug */
-  rb_define_const(mKconv, "NKF_VERSION", rb_str_new2(NKF_VERSION));
-  rb_define_const(mKconv, "NKF_RELEASE_DATE", rb_str_new2(NKF_RELEASE_DATE));
-  rb_define_const(mKconv, "REVISION", rb_str_new2(RUBY_NKF_REVISION));
+    /* hoge */
+    VALUE mKconv = rb_define_module("NKF");
+    /* hoge */
+
+    rb_define_module_function(mKconv, "nkf", rb_nkf_kconv, 2);
+    rb_define_module_function(mKconv, "guess1", rb_nkf_guess1, 1);
+    rb_define_module_function(mKconv, "guess2", rb_nkf_guess2, 1);
+    rb_define_alias(mKconv, "guess", "guess2");
+    rb_define_alias(rb_singleton_class(mKconv), "guess", "guess2");
+
+    /* Auto-Detect */
+    rb_define_const(mKconv, "AUTO", INT2FIX(_AUTO));
+    /* ISO-2022-JP */
+    rb_define_const(mKconv, "JIS", INT2FIX(_JIS));
+    /* EUC-JP */
+    rb_define_const(mKconv, "EUC", INT2FIX(_EUC));
+    /* Shift_JIS */
+    rb_define_const(mKconv, "SJIS", INT2FIX(_SJIS));
+    /* BINARY */
+    rb_define_const(mKconv, "BINARY", INT2FIX(_BINARY));
+    /* No conversion */
+    rb_define_const(mKconv, "NOCONV", INT2FIX(_NOCONV));
+    /* ASCII */
+    rb_define_const(mKconv, "ASCII", INT2FIX(_ASCII));
+    /* UTF-8 */
+    rb_define_const(mKconv, "UTF8", INT2FIX(_UTF8));
+    /* UTF-16 */
+    rb_define_const(mKconv, "UTF16", INT2FIX(_UTF16));
+    /* UTF-32 */
+    rb_define_const(mKconv, "UTF32", INT2FIX(_UTF32));
+    /* UNKNOWN */
+    rb_define_const(mKconv, "UNKNOWN", INT2FIX(_UNKNOWN));
+    /* Full version string of nkf */
+    rb_define_const(mKconv, "VERSION", rb_str_new2(RUBY_NKF_VERSION));
+    /* Version of nkf */
+    rb_define_const(mKconv, "NKF_VERSION", rb_str_new2(NKF_VERSION));
+    /* Release date of nkf */
+    rb_define_const(mKconv, "NKF_RELEASE_DATE", rb_str_new2(NKF_RELEASE_DATE));
 }
diff --git a/ext/nkf/test.rb b/ext/nkf/test.rb
deleted file mode 100644
index b3406cbb6c..0000000000
--- a/ext/nkf/test.rb
+++ /dev/null
@@ -1,864 +0,0 @@
-#!/usr/local/bin/ruby
-#
-# nkf test program for nkf-2
-#
-# $Id$
-#
-#    Shinji KONO <kono@ie.u-ryukyu.ac.jp>
-# Sun Aug 18 12:25:40 JST 1996
-# Sun Nov  8 00:16:06 JST 1998
-#
-# This is useful when you add new patch on nkf.
-# Since this test is too strict, faileurs may not mean
-# wrong conversion. 
-#
-# nkf 1.5 differs on MIME decoding
-# nkf 1.4 passes Basic Conversion tests
-# nkf PDS version passes Basic Conversion tests  using "nkf -iB -oB "
-#
-
-$counter = 0
-def result(result, message = nil)
-  $counter += 1
-  printf("%s %d%s\n",
-	 result ? 'ok' : 'no', 
-	 $counter, 
-	 message ? ' ... ' + message : '')
-end
-
-begin
-  require 'nkf'
-  include NKF
-rescue LoadError
-  result(false)
-end
-result(true)
-
-if nkf('-me', '1')
-  result(true);
-else
-  result(false);
-end
-
-output = nkf('-e', "\033\$@#1#3#2%B")
-if output
-  # print output, "\n"
-  result(true, output)
-else
-  result(false)
-end
-
-output = nkf('-Zj', "\033\$@#1#3#2%B")
-if output
-  # print output, "\n"
-  result(true, output)
-else
-  result(false)
-end
-
-output = "\244\306 " * 1024
-old =  output.length
-output = nkf("-j", output)
-if output
-  # print output, "\n"
-  result(true, "#{old} #{output.length}")
-else
-    result(false)
-end
-
-
-$detail = false
-def test(opt, input, expects)
-  print "\nINPUT:\n", input if $detail
-  print "\nEXPECT:\n", expects.to_s if $detail
-  result = nkf(opt, input)
-  result.delete!(' ') if opt.include?('-m')
-  print "\nGOT:\n", result if $detail
-
-  expects.each do |e|
-    e.delete!(' ') if opt.include?('-m')
-    if result == e then
-      puts "Ok"
-      return result
-    end
-  end
-  puts "Fail"
-  puts result.unpack('H*').first
-  puts expects.map{|x|x.unpack('H*').first}.join("\n\n")
-end
-
-
-$example = Hash.new
-
-
-# Basic Conversion
-print "\nBasic Conversion test\n\n";
-
-# I gave up simple literal quote because there are big difference
-# on perl4 and perl5 on literal quote. Of course we cannot use
-# jperl.
-
-$example['jis'] = <<'eofeof'.unpack('u')[0]
-M1FER<W0@4W1A9V4@&R1"(3DQ(3%^2R%+?D]3&RA"(%-E8V]N9"!3=&%G92`;
-M)$)0)TU:&RA"($AI<F%G86YA(!LD0B0B)"0D)B0H)"HD;R1R)',;*$(*2V%T
-M86MA;F$@&R1")2(E)"4F)2@E*B5O)7(E<QLH0B!+:6=O=2`;)$(A)B%G(S`C
-/029!)E@G(B=!*$`;*$(*
-eofeof
-
-$example['sjis'] = <<'eofeof'.unpack('u')[0]
-M1FER<W0@4W1A9V4@@5B)0(F>ED"6GIAR(%-E8V]N9"!3=&%G92"8I9=Y($AI
-M<F%G86YA((*@@J*"I(*F@JB"[8+P@O$*2V%T86MA;F$@@T&#0X-%@T>#28./
->@Y*#DR!+:6=O=2"!18&'@D^"8(._@]:$081@A+X*
-eofeof
-
-$example['euc'] = <<'eofeof'.unpack('u')[0]
-M1FER<W0@4W1A9V4@H;FQH;'^RZ'+_L_3(%-E8V]N9"!3=&%G92#0I\W:($AI
-M<F%G86YA(*2BI*2DIJ2HI*JD[Z3RI/,*2V%T86MA;F$@I:*EI*6FI:BEJJ7O
->I?*E\R!+:6=O=2"AIJ'GH["CP:;!IMBGHJ?!J,`*
-eofeof
-
-$example['utf8'] = <<'eofeof'.unpack('u')[0]
-M[[N_1FER<W0@4W1A9V4@XX"%Z9FBY;^<YK.5YKJ`Z(65(%-E8V]N9"!3=&%G
-M92#DN+SI@:4@2&ER86=A;F$@XX&"XX&$XX&&XX&(XX&*XX*/XX*2XX*3"DMA
-M=&%K86YA(.."HN."I.."IN."J.."JN.#K^.#LN.#LR!+:6=O=2#C@[OBB)[O
-1O)#OO*'.L<^)T)'0K^*5@@H`
-eofeof
-
-$example['utf8N'] = <<'eofeof'.unpack('u')[0]
-M1FER<W0@4W1A9V4@XX"%Z9FBY;^<YK.5YKJ`Z(65(%-E8V]N9"!3=&%G92#D
-MN+SI@:4@2&ER86=A;F$@XX&"XX&$XX&&XX&(XX&*XX*/XX*2XX*3"DMA=&%K
-M86YA(.."HN."I.."IN."J.."JN.#K^.#LN.#LR!+:6=O=2#C@[OBB)[OO)#O
-.O*'.L<^)T)'0K^*5@@H`
-eofeof
-
-$example['u16L'] = <<'eofeof'.unpack('u')[0]
-M__Y&`&D`<@!S`'0`(`!3`'0`80!G`&4`(``%,&*6W%_5;(!N58$@`%,`90!C
-M`&\`;@!D`"``4P!T`&$`9P!E`"``/$YED"``2`!I`'(`80!G`&$`;@!A`"``
-M0C!$,$8P2#!*,(\PDC"3,`H`2P!A`'0`80!K`&$`;@!A`"``HC"D,*8PJ#"J
-I,.\P\C#S,"``2P!I`&<`;P!U`"``^S`>(A#_(?^Q`\D#$00O!$(E"@``
-eofeof
-
-$example['u16L0'] = <<'eofeof'.unpack('u')[0]
-M1@!I`'(`<P!T`"``4P!T`&$`9P!E`"``!3!BEMQ?U6R`;E6!(`!3`&4`8P!O
-M`&X`9``@`%,`=`!A`&<`90`@`#Q.99`@`$@`:0!R`&$`9P!A`&X`80`@`$(P
-M1#!&,$@P2C"/,)(PDS`*`$L`80!T`&$`:P!A`&X`80`@`*(PI#"F,*@PJC#O
-G,/(P\S`@`$L`:0!G`&\`=0`@`/LP'B(0_R'_L0/)`Q$$+P1")0H`
-eofeof
-
-$example['u16B'] = <<'eofeof'.unpack('u')[0]
-M_O\`1@!I`'(`<P!T`"``4P!T`&$`9P!E`"`P!99B7]QLU6Z`@54`(`!3`&4`
-M8P!O`&X`9``@`%,`=`!A`&<`90`@3CR090`@`$@`:0!R`&$`9P!A`&X`80`@
-M,$(P1#!&,$@P2C"/,)(PDP`*`$L`80!T`&$`:P!A`&X`80`@,*(PI#"F,*@P
-IJC#O,/(P\P`@`$L`:0!G`&\`=0`@,/LB'O\0_R$#L0/)!!$$+R5"``H`
-eofeof
-
-$example['u16B0'] = <<'eofeof'.unpack('u')[0]
-M`$8`:0!R`',`=``@`%,`=`!A`&<`90`@,`668E_<;-5N@(%5`"``4P!E`&,`
-M;P!N`&0`(`!3`'0`80!G`&4`($X\D&4`(`!(`&D`<@!A`&<`80!N`&$`(#!"
-M,$0P1C!(,$HPCS"2,),`"@!+`&$`=`!A`&L`80!N`&$`(#"B,*0PIC"H,*HP
-G[S#R,/,`(`!+`&D`9P!O`'4`(##[(A[_$/\A`[$#R001!"\E0@`*
-eofeof
-
-$example['jis1'] = <<'eofeof'.unpack('u')[0]
-M&R1";3%Q<$$L&RA""ALD0F4Z3F\;*$(*&R1"<FT;*$()&R1"/F5.3D]+&RA"
-#"0D*
-eofeof
-
-$example['sjis1'] = <<'eofeof'.unpack('u')[0]
-8YU#ID)%+"N-9E^T*Z>L)C^.7S)AJ"0D*
-eofeof
-
-$example['euc1'] = <<'eofeof'.unpack('u')[0]
-8[;'Q\,&L"N6ZSN\*\NT)ON7.SL_+"0D*
-eofeof
-
-$example['utf1'] = <<'eofeof'.unpack('u')[0]
-AZ+J%Z:N/Z8JM"N>VNNFZEPKIM(D)Y+B*Z:"8Y+J8"0D*
-eofeof
-
-$example['jis2'] = <<'eofeof'.unpack('u')[0]
-+&R1".EA&(QLH0@H`
-eofeof
-
-$example['sjis2'] = <<'eofeof'.unpack('u')[0]
-%C=:3H0H`
-eofeof
-
-$example['euc2'] = <<'eofeof'.unpack('u')[0]
-%NMC&HPH`
-eofeof
-
-$example['utf2'] = <<'eofeof'.unpack('u')[0]
-'YI:.Z)>D"@``
-eofeof
-
-# From JIS
-
-print "JIS  to JIS ... ";test("-j",$example['jis'],[$example['jis']])
-print "JIS  to SJIS... ";test("-s",$example['jis'],[$example['sjis']])
-print "JIS  to EUC ... ";test("-e",$example['jis'],[$example['euc']])
-print "JIS  to UTF8... ";test("-w",$example['jis'],[$example['utf8N']])
-print "JIS  to U16L... ";test("-w16L",$example['jis'],[$example['u16L']])
-print "JIS  to U16B... ";test("-w16B",$example['jis'],[$example['u16B']])
-
-# From SJIS
-
-print "SJIS to JIS ... ";test("-j",$example['sjis'],[$example['jis']])
-print "SJIS to SJIS... ";test("-s",$example['sjis'],[$example['sjis']])
-print "SJIS to EUC ... ";test("-e",$example['sjis'],[$example['euc']])
-print "SJIS to UTF8... ";test("-w",$example['sjis'],[$example['utf8N']])
-print "SJIS to U16L... ";test("-w16L",$example['sjis'],[$example['u16L']])
-print "SJIS to U16B... ";test("-w16B",$example['sjis'],[$example['u16B']])
-
-# From EUC
-
-print "EUC  to JIS ... ";test("-j",$example['euc'],[$example['jis']])
-print "EUC  to SJIS... ";test("-s",$example['euc'],[$example['sjis']])
-print "EUC  to EUC ... ";test("-e",$example['euc'],[$example['euc']])
-print "EUC  to UTF8... ";test("-w",$example['euc'],[$example['utf8N']])
-print "EUC  to U16L... ";test("-w16L",$example['euc'],[$example['u16L']])
-print "EUC  to U16B... ";test("-w16B",$example['euc'],[$example['u16B']])
-
-# From UTF8
-
-print "UTF8 to JIS ... ";test("-j",	$example['utf8N'],[$example['jis']])
-print "UTF8 to SJIS... ";test("-s",	$example['utf8N'],[$example['sjis']])
-print "UTF8 to EUC ... ";test("-e",	$example['utf8N'],[$example['euc']])
-print "UTF8 to UTF8N.. ";test("-w",	$example['utf8N'],[$example['utf8N']])
-print "UTF8 to UTF8... ";test("-w8",	$example['utf8N'],[$example['utf8']])
-print "UTF8 to UTF8N.. ";test("-w80",	$example['utf8N'],[$example['utf8N']])
-print "UTF8 to U16L... ";test("-w16L",	$example['utf8N'],[$example['u16L']])
-print "UTF8 to U16L0.. ";test("-w16L0",	$example['utf8N'],[$example['u16L0']])
-print "UTF8 to U16B... ";test("-w16B",	$example['utf8N'],[$example['u16B']])
-print "UTF8 to U16B0.. ";test("-w16B0",	$example['utf8N'],[$example['u16B0']])
-
-
-
-# From JIS
-
-print "JIS  to JIS ... ";test("-j",$example['jis1'],[$example['jis1']])
-print "JIS  to SJIS... ";test("-s",$example['jis1'],[$example['sjis1']])
-print "JIS  to EUC ... ";test("-e",$example['jis1'],[$example['euc1']])
-print "JIS  to UTF8... ";test("-w",$example['jis1'],[$example['utf1']])
-
-# From SJIS
-
-print "SJIS to JIS ... ";test("-j",$example['sjis1'],[$example['jis1']])
-print "SJIS to SJIS... ";test("-s",$example['sjis1'],[$example['sjis1']])
-print "SJIS to EUC ... ";test("-e",$example['sjis1'],[$example['euc1']])
-print "SJIS to UTF8... ";test("-w",$example['sjis1'],[$example['utf1']])
-
-# From EUC
-
-print "EUC  to JIS ... ";test("-j",$example['euc1'],[$example['jis1']])
-print "EUC  to SJIS... ";test("-s",$example['euc1'],[$example['sjis1']])
-print "EUC  to EUC ... ";test("-e",$example['euc1'],[$example['euc1']])
-print "EUC  to UTF8... ";test("-w",$example['euc1'],[$example['utf1']])
-
-# From UTF8
-
-print "UTF8 to JIS ... ";test("-j",$example['utf1'],[$example['jis1']])
-print "UTF8 to SJIS... ";test("-s",$example['utf1'],[$example['sjis1']])
-print "UTF8 to EUC ... ";test("-e",$example['utf1'],[$example['euc1']])
-print "UTF8 to UTF8... ";test("-w",$example['utf1'],[$example['utf1']])
-
-# Ambigous Case
-
-$example['amb'] = <<'eofeof'.unpack('u')[0]
-MI<*PL:7"L+&EPK"QI<*PL:7"L+&EPK"QI<*PL:7"L+&EPK"QI<*PL:7"L+&E
-MPK"QI<*PL:7"L+&EPK"QI<(*I<*PL:7"L+&EPK"QI<*PL:7"L+&EPK"QI<*P
-ML:7"L+&EPK"QI<*PL:7"L+&EPK"QI<*PL:7"L+&EPK"QI<(*I<*PL:7"L+&E
-MPK"QI<*PL:7"L+&EPK"QI<*PL:7"L+&EPK"QI<*PL:7"L+&EPK"QI<*PL:7"
-ML+&EPK"QI<(*I<*PL:7"L+&EPK"QI<*PL:7"L+&EPK"QI<*PL:7"L+&EPK"Q
-MI<*PL:7"L+&EPK"QI<*PL:7"L+&EPK"QI<(*I<*PL:7"L+&EPK"QI<*PL:7"
-ML+&EPK"QI<*PL:7"L+&EPK"QI<*PL:7"L+&EPK"QI<*PL:7"L+&EPK"QI<(*
-eofeof
-
-$example['amb.euc'] = <<'eofeof'.unpack('u')[0]
-M&R1")4(P,25",#$E0C`Q)4(P,25",#$E0C`Q)4(P,25",#$E0C`Q)4(P,25"
-M,#$E0C`Q)4(P,25",#$E0C`Q)4(;*$(*&R1")4(P,25",#$E0C`Q)4(P,25"
-M,#$E0C`Q)4(P,25",#$E0C`Q)4(P,25",#$E0C`Q)4(P,25",#$E0C`Q)4(;
-M*$(*&R1")4(P,25",#$E0C`Q)4(P,25",#$E0C`Q)4(P,25",#$E0C`Q)4(P
-M,25",#$E0C`Q)4(P,25",#$E0C`Q)4(;*$(*&R1")4(P,25",#$E0C`Q)4(P
-M,25",#$E0C`Q)4(P,25",#$E0C`Q)4(P,25",#$E0C`Q)4(P,25",#$E0C`Q
-M)4(;*$(*&R1")4(P,25",#$E0C`Q)4(P,25",#$E0C`Q)4(P,25",#$E0C`Q
->)4(P,25",#$E0C`Q)4(P,25",#$E0C`Q)4(;*$(*
-eofeof
-
-$example['amb.sjis'] = <<'eofeof'.unpack('u')[0]
-M&RA))4(P,25",#$E0C`Q)4(P,25",#$E0C`Q)4(P,25",#$E0C`Q)4(P,25"
-M,#$E0C`Q)4(P,25",#$E0C`Q)4(;*$(*&RA))4(P,25",#$E0C`Q)4(P,25"
-M,#$E0C`Q)4(P,25",#$E0C`Q)4(P,25",#$E0C`Q)4(P,25",#$E0C`Q)4(;
-M*$(*&RA))4(P,25",#$E0C`Q)4(P,25",#$E0C`Q)4(P,25",#$E0C`Q)4(P
-M,25",#$E0C`Q)4(P,25",#$E0C`Q)4(;*$(*&RA))4(P,25",#$E0C`Q)4(P
-M,25",#$E0C`Q)4(P,25",#$E0C`Q)4(P,25",#$E0C`Q)4(P,25",#$E0C`Q
-M)4(;*$(*&RA))4(P,25",#$E0C`Q)4(P,25",#$E0C`Q)4(P,25",#$E0C`Q
->)4(P,25",#$E0C`Q)4(P,25",#$E0C`Q)4(;*$(*
-eofeof
-
-print "Ambiguous Case. ";
-    test("-j",$example['amb'],[$example['amb.euc']])
-
-# Input assumption
-
-print "SJIS  Input assumption ";
-    test("-jSx",$example['amb'],[$example['amb.sjis']])
-
-# Broken JIS
-
-print "Broken JIS ";
-    $input = $example['jis'];
-    $input.gsub!("\033",'')
-    test("-Be",$input,[$example['euc']]);
-print "Broken JIS is safe on Normal JIS? ";
-    $input = $example['jis'];
-    test("-Be",$input,[$example['euc']]);
-
-# test_data/cp932
-
-$example['test_data/cp932'] = <<'eofeof'.unpack('u')[0]
-%^D`@_$L`
-eofeof
-
-$example['test_data/cp932.ans'] = <<'eofeof'.unpack('u')[0]
-%_/$@_.X`
-eofeof
-
-print "test_data/cp932    ";
-    test("-eS",$example['test_data/cp932'],[$example['test_data/cp932.ans']])
-
-# test_data/cp932inv
-print "test_data/cp932inv    ";
-    test("-sE --cp932inv",$example['test_data/cp932.ans'],[$example['test_data/cp932']])
-
-# test_data/no-cp932inv
-
-$example['test_data/no-cp932inv.ans'] = <<'eofeof'.unpack('u')[0]
-%[N\@[NP`
-eofeof
-
-print "test_data/no-cp932inv    ";
-test("-sE --no-cp932",$example['test_data/cp932.ans'],[$example['test_data/no-cp932inv.ans']])
-
-# test_data/irv
-
-# $example['test_data/irv'] = <<'eofeof'.unpack('u')[0]
-# %#B`/(!L`
-# eofeof
-# 
-# $example['test_data/irv.ans'] = <<'eofeof'.unpack('u')[0]
-# %#B`/(!L`
-# eofeof
-# 
-# print "test_data/irv    ";
-#    test("-wE",$example['test_data/irv'],[$example['test_data/irv.ans']])
-
-
-# UCS Mapping Test
-print "\n\nUCS Mapping Test\n";
-
-print "Shift_JIS to UTF-16\n";
-$example['ms_ucs_map_1_sjis'] = "\x81\x60\x81\x61\x81\x7C\x81\x91\x81\x92\x81\xCA";
-$example['ms_ucs_map_1_utf16'] = "\x30\x1C\x20\x16\x22\x12\x00\xA2\x00\xA3\x00\xAC";
-$example['ms_ucs_map_1_utf16_ms'] = "\xFF\x5E\x22\x25\xFF\x0D\xFF\xE0\xFF\xE1\xFF\xE2";
-
-print "Normal UCS Mapping : ";
-    test("-w16B0 -S",$example['ms_ucs_map_1_sjis'],[$example['ms_ucs_map_1_utf16']])
-
-print "Microsoft UCS Mapping : ";
-    test("-w16B0 -S --ms-ucs-map",$example['ms_ucs_map_1_sjis'],[$example['ms_ucs_map_1_utf16_ms']])
-
-print"\n";
-
-# X0201 仮名
-# X0201->X0208 conversion
-# X0208 aphabet -> ASCII
-# X0201 相互変換
-
-print "\nX0201 test\n\n";
-
-$example['x0201.sjis'] = <<'eofeof'.unpack('u')[0]
-MD5.*<(-*@TR#3H-0@U*#2X--@T^#48-3"I%3B7""8()A@F*"8X)D@F6"9H*!
-M@H*"@X*$@H6"AH*'"I%3BTR-AH%)@9>!E(&0@9.!3X&5@9:!:8%J@7R!>X&!
-M@6V!;H%O@7"!CPJ4O(IPMK>X/;FZMMZWWKC>N=ZZWH+&"I2\BG#*W\O?S-_-
-MW\[?M]^QW@K*W\O?S`IH86YK86MU(,K?R]_,I`K*W\O?S-VA"I2\BG""S(SC
-!"@!"
-eofeof
-
-$example['x0201.euc'] = <<'eofeof'.unpack('u')[0]
-MP;2ST:6KI:VEKZ6QI;.EK*6NI;"ELJ6T"L&TL=&CP:/"H\.CQ*/%H\:CQZ/A
-MH^*CXZ/DH^6CYJ/G"L&TM:VYYJ&JH?>A]*'PH?.AL*'UH?:ARJ'+H=VAW*'A
-MH<ZASZ'0H=&A[PK(OK/1CK:.MXZX/8ZYCKJ.MH[>CK>.WHZXCMZ.N8[>CKJ.
-MWJ3("LB^L]&.RH[?CLN.WX[,CM^.S8[?CLZ.WXZWCM^.L8[>"H[*CM^.RX[?
-MCLP*:&%N:V%K=2".RH[?CLN.WX[,CJ0*CLJ.WX[+CM^.S([=CJ$*R+ZST:3.
-#N.4*
-eofeof
-
-$example['x0201.utf'] = <<'eofeof'.unpack('u')[0]
-MY86HZ*>2XX*KXX*MXX*OXX*QXX*SXX*LXX*NXX*PXX*RXX*T"N6%J.B+L>^\
-MH>^\HN^\H^^\I.^\I>^\IN^\I^^]@>^]@N^]@^^]A.^]A>^]AN^]APKEA:CH
-MJ)CEC[?OO('OO*#OO(/OO(3OO(7OO+[OO(;OO(KOO(COO(GBB)+OO(OOO)WO
-MO+OOO+WOO9OOO9WOOZ4*Y8V*Z*>2[[VV[[VW[[VX/>^]N>^]NN^]MN^^GN^]
-MM^^^GN^]N.^^GN^]N>^^GN^]NN^^GN.!J`KEC8KHIY+OOHKOOI_OOHOOOI_O
-MOHSOOI_OOHWOOI_OOH[OOI_OO;?OOI_OO;'OOIX*[[Z*[[Z?[[Z+[[Z?[[Z,
-M"FAA;FMA:W4@[[Z*[[Z?[[Z+[[Z?[[Z,[[VD"N^^BN^^G^^^B^^^G^^^C.^^
-2G>^]H0KEC8KHIY+C@:[EOHP*
-eofeof
-
-$example['x0201.jis'] = <<'eofeof'.unpack('u')[0]
-M&R1"030S424K)2TE+R4Q)3,E+"4N)3`E,B4T&RA""ALD0D$T,5$C02-"(T,C
-M1"-%(T8C1R-A(V(C8R-D(V4C9B-G&RA""ALD0D$T-2TY9B$J(7<A="%P(7,A
-M,"%U(78A2B%+(5TA7"%A(4XA3R%0(5$A;QLH0@H;)$)(/C-1&RA)-C<X&RA"
-M/1LH23DZ-EXW7CA>.5XZ7ALD0B1(&RA""ALD0D@^,U$;*$E*7TM?3%]-7TY?
-M-U\Q7ALH0@H;*$E*7TM?3!LH0@IH86YK86MU(!LH24I?2U],)!LH0@H;*$E*
-97TM?3%TA&RA""ALD0D@^,U$D3CAE&RA""@``
-eofeof
-
-$example['x0201.sosi'] = <<'eofeof'.unpack('u')[0]
-M&R1"030S424K)2TE+R4Q)3,E+"4N)3`E,B4T&RA*"ALD0D$T,5$C02-"(T,C
-M1"-%(T8C1R-A(V(C8R-D(V4C9B-G&RA*"ALD0D$T-2TY9B$J(7<A="%P(7,A
-M,"%U(78A2B%+(5TA7"%A(4XA3R%0(5$A;QLH2@H;)$)(/C-1&RA*#C8W.`\;
-M*$H]#CDZ-EXW7CA>.5XZ7@\;)$(D2!LH2@H;)$)(/C-1&RA*#DI?2U],7TU?
-M3E\W7S%>#PH.2E]+7TP/&RA*"FAA;FMA:W4@#DI?2U],)`\;*$H*#DI?2U],
-672$/&RA*"ALD0D@^,U$D3CAE&RA""@``
-eofeof
-
-$example['x0201.x0208'] = <<'eofeof'.unpack('u')[0]
-M&R1"030S424K)2TE+R4Q)3,E+"4N)3`E,B4T&RA""ALD0D$T,5$;*$)!0D-$
-M149'86)C9&5F9PH;)$)!-#4M.68;*$(A0",D)5XF*B@I+2L]6UU[?1LD0B%O
-M&RA""ALD0D@^,U$E*R4M)2\;*$(]&R1")3$E,R4L)2XE,"4R)30D2!LH0@H;
-M)$)(/C-1)5$E5"57)5HE724M(2PE(B$K&RA""ALD0B51)50E51LH0@IH86YK
-M86MU(!LD0B51)50E52$B&RA""ALD0B51)50E525S(2,;*$(*&R1"2#XS421.
-&.&4;*$(*
-eofeof
-
-# -X is necessary to allow X0201 in SJIS
-# -Z convert X0208 alphabet to ASCII
-print "X0201 conversion: SJIS ";
-    test("-jXZ",$example['x0201.sjis'],[$example['x0201.x0208']])
-print "X0201 conversion: JIS  ";
-    test("-jZ",$example['x0201.jis'],[$example['x0201.x0208']])
-print "X0201 conversion:SI/SO ";
-    test("-jZ",$example['x0201.sosi'],[$example['x0201.x0208']])
-print "X0201 conversion: EUC  ";
-    test("-jZ",$example['x0201.euc'],[$example['x0201.x0208']])
-print "X0201 conversion: UTF8 ";
-    test("-jZ",$example['x0201.utf'],[$example['x0201.x0208']])
-# -x means X0201 output
-print "X0201 output: SJIS     ";
-    test("-xs",$example['x0201.euc'],[$example['x0201.sjis']])
-print "X0201 output: JIS      ";
-    test("-xj",$example['x0201.sjis'],[$example['x0201.jis']])
-print "X0201 output: EUC      ";
-    test("-xe",$example['x0201.jis'],[$example['x0201.euc']])
-print "X0201 output: UTF8     ";
-    test("-xw",$example['x0201.jis'],[$example['x0201.utf']])
-
-# MIME decode
-
-print "\nMIME test\n\n";
-
-# MIME ISO-2022-JP
-
-$example['mime.iso2022'] = <<'eofeof'.unpack('u')[0]
-M/3])4T\M,C`R,BU*4#]"/T=Y4D%.144W96E23TI566Q/4U9)1WEH2S\]"CT_
-M:7-O+3(P,C(M2E`_0C]'>5)!3D5%-V5I4D]*55EL3U-624=Y:$L_/0H]/VES
-M;RTR,#(R+4I0/U$_/3%")$(D1B11/3%"*$)?96YD/ST*&R1`)#TD)B0K)$H;
-M*$H@/3])4T\M,C`R,BU*4#]"/T=Y4D%.144W96E23U!Y:S=D:'-O4V<]/3\]
-M(&5N9"!O9B!L:6YE"CT_25-/+3(P,C(M2E`_0C]'>5)!3D5%-V5I4D]0>6LW
-M9&AS;U-G/3T_/2`]/TE33RTR,#(R+4I0/T(_1WE204Y%13=E:5)/4'EK-V1H
-M<V]39ST]/ST*0G)O:V5N(&-A<V4*/3])4T\M,C`R,BU*4#]"/T=Y4D%.144W
-M96E23U!Y:S=D"FAS;U-G/3T_/2`]/TE33RTR,`HR,BU*4#]"/T=Y4D%.144W
-M96E23U!Y:S=D:'-O4V<]/3\]"CT_25-/+3(P,C(M2E`_0C]'>5)!3D5%-V5I
-44D]*55EL3QM;2U-624=Y:$L_/0H_
-eofeof
-
-$example['mime.ans.strict'] = <<'eofeof'.unpack('u')[0]
-M&R1"-$$[>B1.)48E.25(&RA""ALD0C1!.WHD3B5&)3DE2!LH0@H;)$(D1B11
-M&RA"(&5N9`H;)$(D/20F)"LD2ALH0B`;)$(T03MZ)$X_*3MV&RA"96YD(&]F
-M(&QI;F4*&R1"-$$[>B1./RD[=C1!.WHD3C\I.W8;*$(*0G)O:V5N(&-A<V4*
-M/3])4T\M,C`R,BU*4#]"/T=Y4D%.144W96E23U!Y:S=D"FAS;U-G/3T_/2`]
-M/TE33RTR,`HR,BU*4#]"/T=Y4D%.144W96E23U!Y:S=D:'-O4V<]/3\]"CT_
-L25-/+3(P,C(M2E`_0C]'>5)!3D5%-V5I4D]*55EL3QM;2U-624=Y:$L_/0H_
-eofeof
-
-$example['mime.unbuf.strict'] = <<'eofeof'.unpack('u')[0]
-M&R1"-$$[>B1.)48E.25(&RA""ALD0C1!.WHD3B5&)3DE2!LH0@H;)$(D1B11
-M&RA"(&5N9`H;)$(D/20F)"LD2ALH0B`;)$(T03MZ)$X_*3MV&RA"96YD(&]F
-M(&QI;F4*&R1"-$$[>B1./RD[=C1!.WHD3C\I.W8;*$(*0G)O:V5N(&-A<V4*
-M&R1"-$$[>B1./RD;*$)H<V]39ST]/ST@/3])4T\M,C`*,C(M2E`_0C]'>5)!
-M3D5%-V5I4D]0>6LW9&AS;U-G/3T_/0H;)$(T03MZ)$XE1ALH0EM+4U9)1WEH
-$2S\]"F5I
-eofeof
-
-$example['mime.ans'] = <<'eofeof'.unpack('u')[0]
-M&R1"-$$[>B1.)48E.25(&RA""ALD0C1!.WHD3B5&)3DE2!LH0@H;)$(D1B11
-M&RA"(&5N9`H;)$(D/20F)"LD2ALH0B`;)$(T03MZ)$X_*3MV&RA"96YD(&]F
-M(&QI;F4*&R1"-$$[>B1./RD[=C1!.WHD3C\I.W8;*$(*0G)O:V5N(&-A<V4*
-M&R1"-$$[>B1./RD;*$)H<V]39ST]/ST@&R1"-$$[>B1./RD[=ALH0@H;)$(T
-603MZ)$XE1ALH0EM+4U9)1WEH2S\]"@`*
-eofeof
-
-$example['mime.unbuf'] = <<'eofeof'.unpack('u')[0]
-M&R1"-$$[>B1.)48E.25(&RA""ALD0C1!.WHD3B5&)3DE2!LH0@H;)$(D1B11
-M&RA"(&5N9`H;)$(D/20F)"LD2ALH0B`;)$(T03MZ)$X_*3MV&RA"96YD(&]F
-M(&QI;F4*&R1"-$$[>B1./RD[=C1!.WHD3C\I.W8;*$(*0G)O:V5N(&-A<V4*
-M&R1"-$$[>B1./RD;*$)H<V]39ST]/ST@&R1"-$$[>B1./RD[=ALH0@H;)$(T
-603MZ)$XE1ALH0EM+4U9)1WEH2S\]"@`*
-eofeof
-
-$example['mime.base64'] = <<'eofeof'.unpack('u')[0]
-M9W-M5"])3&YG<FU#>$I+-&=Q=4,S24LS9W%Q0E%:3TUI-39,,S0Q-&=S5T)1
-M43!+9VUA1%9O3T@*9S)+1%1O3'=K8C)1;$E+;V=Q2T-X24MG9W5M0W%*3EEG
-<<T=#>$E+9V=U;4,X64Q&9W)70S592VMG<6U""F=Q
-eofeof
-
-$example['mime.base64.ans'] = <<'eofeof'.unpack('u')[0]
-M&R1")$M&?B1I)#LD1D0Z)"TD7B0Y)"PA(D5L-7XV83E9)$<A(ALH0@T*&R1"
-M(T<E-R5G)4,E+R1R0C\_="0J)"0D1B0B)&LD*D4Y)$,D1B0B)&LD<R1')#<D
-(9R0F)"L;*$(E
-eofeof
-
-# print "Next test is expected to Fail.\n";
-print "MIME decode (strict)   ";
-    $tmp = test("-j -mS",$example['mime.iso2022'],[$example['mime.ans.strict']])
-
-$example['mime.ans.alt'] = <<'eofeof'.unpack('u')[0]
-M&R1"-$$[>B1.)48E.25(&RA""ALD0C1!.WHD3B5&)3DE2!LH0@H;)$(D1B11
-M&RA"96YD"ALD0B0])"8D*R1*&RA"&R1"-$$[>B1./RD[=ALH0F5N9&]F;&EN
-M90H;)$(T03MZ)$X_*3MV-$$[>B1./RD[=ALH0@I"<F]K96YC87-E"ALD0C1!
-H.WHD3C\I.W8T03MZ)$X_*3MV&RA""ALD0C1!.WHD3B5&)3DE)!LH0@``
-eofeof
-
-$example['mime.unbuf.alt'] = <<'eofeof'.unpack('u')[0]
-M&R1"-$$[>B1.)48E.25(&RA""ALD0C1!.WHD3B5&)3DE2!LH0@H;)$(D1B11
-M&RA"96YD"ALD0B0])"8D*R1*&RA"&R1"-$$[>B1./RD[=ALH0F5N9&]F;&EN
-M90H;)$(T03MZ)$X_*3MV-$$[>B1./RD[=ALH0@I"<F]K96YC87-E"ALD0C1!
-H.WHD3C\I.W8T03MZ)$X_*3MV&RA""ALD0C1!.WHD3B5&)3DE)!LH0@``
-eofeof
-
-print "MIME decode (nonstrict)";
-    $tmp = test("-j -mN",$example['mime.iso2022'],[$example['mime.ans'],$example['mime.ans.alt']])
-    # open(OUT,">tmp1");print OUT pack('u',$tmp);close(OUT);
-# unbuf mode implies more pessimistic decode
-print "MIME decode (unbuf)    ";
-    $tmp = test("-j -mNu",$example['mime.iso2022'],[$example['mime.unbuf'],$example['mime.unbuf.alt']])
-    # open(OUT,">tmp2");print OUT pack('u',$tmp);close(OUT);
-print "MIME decode (base64)   ";
-    test("-j -mB",$example['mime.base64'],[$example['mime.base64.ans']])
-
-# MIME ISO-8859-1
-
-$example['mime.is8859'] = <<'eofeof'.unpack('u')[0]
-M/3])4T\M.#@U.2TQ/U$_*CU#-V%V83\_/2`*4&5E<B!4]G)N9W)E;@I,87-S
-M92!(:6QL97+X92!0971E<G-E;B`@7"`B36EN(&MA97!H97-T(&AA<B!F86%E
-M="!E="!F;V5L(2(*06%R:'5S(%5N:79E<G-I='DL($1%3DU!4DL@(%P@(DUI
-<;B!KYG!H97-T(&AA<B!FY65T(&5T(&;X;"$B"@!K
-eofeof
-
-$example['mime.is8859.ans'] = <<'eofeof'.unpack('u')[0]
-M*L=A=F$_(`I0965R(%3V<FYG<F5N"DQA<W-E($AI;&QE<OAE(%!E=&5R<V5N
-M("!<(")-:6X@:V%E<&AE<W0@:&%R(&9A865T(&5T(&9O96PA(@I!87)H=7,@
-M56YI=F5R<VET>2P@1$5.34%22R`@7"`B36EN(&OF<&AE<W0@:&%R(&;E970@
-)970@9OAL(2(*
-eofeof
-
-# Without -l, ISO-8859-1 was handled as X0201.
-
-print "MIME ISO-8859-1 (Q)    ";
-    test("-ml",$example['mime.is8859'],[$example['mime.is8859.ans']])
-
-# test for -f is not so simple.
-
-print "\nBug Fixes\n\n";
-
-# test_data/cr
-
-$example['test_data/cr'] = <<'eofeof'.unpack('u')[0]
-1I,:DN:3(#71E<W0-=&5S=`T`
-eofeof
-
-$example['test_data/cr.ans'] = <<'eofeof'.unpack('u')[0]
-7&R1")$8D.21(&RA""G1E<W0*=&5S=`H`
-eofeof
-
-print "test_data/cr    ";
-    test("-jd",$example['test_data/cr'],[$example['test_data/cr.ans']])
-# test_data/fixed-qencode
-
-$example['test_data/fixed-qencode'] = <<'eofeof'.unpack('u')[0]
-M("`@("`@("`],4(D0CYE/STS1#TQ0BA""B`@("`@("`@/3%")$(^93TS1CTS
-'1#TQ0BA""@``
-eofeof
-
-$example['test_data/fixed-qencode.ans'] = <<'eofeof'.unpack('u')[0]
-F("`@("`@("`;)$(^93\]&RA""B`@("`@("`@&R1"/F4_/1LH0@H`
-eofeof
-
-print "test_data/fixed-qencode    ";
-    test("-jmQ",$example['test_data/fixed-qencode'],[$example['test_data/fixed-qencode.ans']])
-# test_data/long-fold-1
-
-$example['test_data/long-fold-1'] = <<'eofeof'.unpack('u')[0]
-MI,JDK*2DI,JDK*2DI,JDK*'!I*2DKJ3GI*:DK*2BI.JDWJ2WI,:AHJ2SI.RD
-M\J2]I,ZDWJ3>I**DQ*2KI*:DR*&BI,FDIJ3BI-^DT*2HI*RD[Z3KI*2DMZ&B
-MI,BDP:3EI*:DQZ3!I.>D\Z2NI.RDZZ2KI.*DMZ3SI,JDI*&C"J2SI+.DSR!#
-M4B],1B"DSKG4H:,-"J2SI+.DSR!#4B"DSKG4H:,-I+.DLZ3/($Q&+T-2(*3.
-9N=2AHPH-"J2SI+.DSR!,1B"DSKG4H:,*"@``
-eofeof
-
-$example['test_data/long-fold-1.ans'] = <<'eofeof'.unpack('u')[0]
-M&R1")$HD+"0D)$HD+"0D)$HD+"%!)"0D+B1G)"8D+"0B)&HD7B0W)$8A(B0S
-M)&PD<B0])$XD7B1>)"(D1"0K&RA""ALD0B0F)$@A(B1))"8D8B1?)%`D*"0L
-M)&\D:R0D)#<A(B1()$$D920F)$<D021G)',D+B1L)&LD*R1B)#<D<QLH0@H;
-M)$(D2B0D(2,;*$(*&R1")#,D,R1/&RA"($-2+TQ&(!LD0B1..50A(QLH0@H;
-M)$(D,R0S)$\;*$(@0U(@&R1")$XY5"$C&RA""ALD0B0S)#,D3QLH0B!,1B]#
-M4B`;)$(D3CE4(2,;*$(*"ALD0B0S)#,D3QLH0B!,1B`;)$(D3CE4(2,;*$(*
-!"@``
-eofeof
-
-print "test_data/long-fold-1    ";
-    test("-jF60",$example['test_data/long-fold-1'],[$example['test_data/long-fold-1.ans']])
-# test_data/long-fold
-
-$example['test_data/long-fold'] = <<'eofeof'.unpack('u')[0]
-MI,JDK*2DI,JDK*2DI,JDK*'!I*2DKJ3GI*:DK*2BI.JDWJ2WI,:AHJ2SI.RD
-M\J2]I,ZDWJ3>I**DQ*2KI*:DR*&BI,FDIJ3BI-^DT*2HI*RD[Z3KI*2DMZ&B
-MI,BDP:3EI*:DQZ3!I.>D\Z2NI.RDZZ2KI.*DMZ3SI,JDI*&C"J2SI+.DS\.[
-'I*2YU*&C"@``
-eofeof
-
-$example['test_data/long-fold.ans'] = <<'eofeof'.unpack('u')[0]
-M&R1")$HD+"0D)$HD+"0D)$HD+"%!)"0D+B1G)"8D+"0B)&HD7B0W)$8A(B0S
-M)&PD<B0])$XD7B1>)"(D1"0K&RA""ALD0B0F)$@A(B1))"8D8B1?)%`D*"0L
-M)&\D:R0D)#<A(B1()$$D920F)$<D021G)',D+B1L)&LD*R1B)#<D<QLH0@H;
-:)$(D2B0D(2,D,R0S)$]#.R0D.50A(QLH0@H`
-eofeof
-
-print "test_data/long-fold    ";
-    test("-jf60",$example['test_data/long-fold'],[$example['test_data/long-fold.ans']])
-# test_data/mime_out
-
-$example['test_data/mime_out'] = <<'eofeof'.unpack('u')[0]
-M"BTM+2T*4W5B:F5C=#H@86%A82!A86%A(&%A86$@86%A82!A86%A(&%A86$@
-M86%A82!A86%A(&%A86$@86%A82!A86%A(&%A86$@86%A82!A86%A"BTM+2T*
-M4W5B:F5C=#H@I**DI*2FI*BDJJ2KI*VDKZ2QI+.DM:2WI+FDNZ2]I+^DP:3$
-MI,:DR*3*I,NDS*3-I,ZDSZ32I-6DV*3;I-ZDWZ3@I.&DXJ3DI*2DYJ2HI.@*
-M+2TM+0I3=6)J96-T.B!A86%A(&%A86$@86%A82!A86%A(&%A86$@86%A82!A
-I86%A(*2BI*2DIJ2HI*H@86%A82!A86%A(&%A86$@86%A80HM+2TM"@H`
-eofeof
-
-$example['test_data/mime_out.ans'] = <<'eofeof'.unpack('u')[0]
-M"BTM+2T*4W5B:F5C=#H@86%A82!A86%A(&%A86$@86%A82!A86%A(&%A86$@
-M86%A82!A86%A(&%A86$@86%A80H@86%A82!A86%A(&%A86$@86%A82!A86%A
-M"BTM+2T*4W5B:F5C=#H@/3])4T\M,C`R,BU*4#]"/T=Y4D-*0TEK2D-1;4I#
-M9VM+:5%R2D,P:TQY47A*1$UK3E-1,T=Y:$,_/0H@/3])4T\M,C`R,BU*4#]"
-M/T=Y4D-*1&MK3WE1.4I$.&M14U)%2D59:U-#4DM*17-K5$-23DI%-&M4>5)3
-M2D95:U=#4F)'>6A#/ST*(#T_25-/+3(P,C(M2E`_0C]'>5)#2D8T:UAY4F=*
-M1T5K66E2:TI#46M::5%O2D=G8DM%23T_/0HM+2TM"E-U8FIE8W0Z(&%A86$@
-M86%A82!A86%A(&%A86$@86%A82!A86%A(&%A86$*(#T_25-/+3(P,C(M2E`_
-M0C]'>5)#2D-):TI#46U*0V=K2VAS;U%G/3T_/2!A86%A(&%A86$@86%A82!A
-086%A"B!A86%A"BTM+2T*"@``
-eofeof
-
-print "test_data/mime_out    ";
-    test("-jM",$example['test_data/mime_out'],[$example['test_data/mime_out.ans']])
-# test_data/mime_out2
-
-$example['test_data/mime_out2'] = <<'eofeof'.unpack('u')[0]
-M5&AI<R!M96UO(&1E<V-R:6)E<R!S:6UI;&%R('1E8VAN:7%U97,@=&\@86QL
-M;W<@=&AE(&5N8V]D:6YG(&]F(&YO;BU!4T-)22!T97AT(&EN('9A<FEO=7,@
-M<&]R=&EO;G,@;V8@82!21D,@.#(R(%LR72!M97-S86=E(&AE861E<BP@:6X@
-M82!M86YN97(@=VAI8V@@:7,@=6YL:6ME;'D@=&\@8V]N9G5S92!E>&ES=&EN
-M9R!M97-S86=E(&AA;F1L:6YG('-O9G1W87)E+@H*4W5B:F5C=#H@=&5S=#$@
-M=&5S=#(@@L2"MX+&@J<@=&5S=#,@@L2"MX+&@O$@=&5S=#0*"E-U8FIE8W0Z
-M('1E<W0Q("!T97-T,B""Q"""MR""QB""IR!T97-T,R`@@L2"MX+&@O$@('1E
-M<W0T"@I!4T-)22"3^I9[C.H@05-#24D@05-#24D@D_J6>XSJ()/ZEGN,ZB!!
-M4T-)22!!4T-)29/ZEGN,ZB!!4T-)20H*@J`@@J(@@J0@@J8@@J@@@JD@@JL@
-M@JT@@J\@@K$@@K,@@K4@@K<@@KD@@KL@@KT@@K\@@L(@@L0@@L8@@L@@@LD@
-8@LH@@LL@@LP*"@H*"@H*"@H*"@H*"@H*
-eofeof
-
-$example['test_data/mime_out2.ans'] = <<'eofeof'.unpack('u')[0]
-M5&AI<R!M96UO(&1E<V-R:6)E<R!S:6UI;&%R('1E8VAN:7%U97,@=&\@86QL
-M;W<@=&AE(&5N8V]D:6YG(&5N8V]D:6YG"B!O9B!N;VXM05-#24D@=&5X="!I
-M;B!V87)I;W5S('!O<G1I;VYS(&]F(&$@80H@4D9#(#@R,B!;,ET@;65S<V%G
-M92!H96%D97(L(&EN(&$@;6%N;F5R('=H:6-H(&ES('5N;&EK96QY('5N;&EK
-M96QY"B!T;R!C;VYF=7-E(&5X:7-T:6YG(&UE<W-A9V4@:&%N9&QI;F<@<V]F
-M='=A<F4N"@I3=6)J96-T.B!T97-T,2!T97-T,B`]/TE33RTR,#(R+4I0/T(_
-M1WE20TI%66M/4U))2D-K8DM%23T_/2!T97-T,PH@/3])4T\M,C`R,BU*4#]"
-M/T=Y4D-*15EK3U-224I(36)+14D]/ST@=&5S=#0*"E-U8FIE8W0Z('1E<W0Q
-M("!T97-T,B`]/TE33RTR,#(R+4I0/T(_1WE20TI%66)+14EG1WE20TI$:V)+
-M14EG1WE20TI%9V)+14D]/ST*(#T_25-/+3(P,C(M2E`_0C]'>5)#1WEH0TE"
-M<VM1:5%P1WEH0S\]('1E<W0S(`H@/3])4T\M,C`R,BU*4#]"/T=Y4D-*15EK
-M3U-224I(36)+14D]/ST@('1E<W0T"@I!4T-)22`]/TE33RTR,#(R+4I0/T(_
-M1WE20U)N>$Q81&AS1WEH0S\]($%30TE)($%30TE)"B`]/TE33RTR,#(R+4I0
-M/T(_1WE20U)N>$Q81&AS1WEH0TE"<VM1:UHX4S%W-&)"<V]19ST]/ST@05-#
-M24D*(#T_25-/+3(P,C(M2E`_0C]15DY$4U5K8DI%2D=F171C3T=W8DM%23T_
-M/2!!4T-)20H*/3])4T\M,C`R,BU*4#]"/T=Y4D-*0TEB2T5)9T=Y4D-*0U%B
-M2T5)9T=Y4D-*0UEB2T5)9T=Y4D-*0V=B2T5)/3\]"B`]/TE33RTR,#(R+4I0
-M/T(_24)S:U%I47%'>6A#24)S:U%I47)'>6A#24)S:U%I471'>6A#24)S:U%I
-M479'>6A#/ST*(#T_25-/+3(P,C(M2E`_0C])0G-K46E1>$=Y:$-)0G-K46E1
-M>D=Y:$-)0G-K46E1,4=Y:$-)0G-K46E1,T=Y:$,_/0H@/3])4T\M,C`R,BU*
-M4#]"/TE"<VM1:5$U1WEH0TE"<VM1:5$W1WEH0TE"<VM1:5$Y1WEH0TE"<VM1
-M:5$O1WEH0S\]"B`]/TE33RTR,#(R+4I0/T(_24)S:U%I4D)'>6A#24)S:U%I
-M4D5'>6A#24)S:U%I4D='>6A#24)S:U%I4DE'>6A#/ST*(#T_25-/+3(P,C(M
-M2E`_0C])0G-K46E22T=Y:$-)0G-K46E23$=Y:$-)0G-K46E234=Y:$-)0G-K
-M46E23D=Y:$,_/0H@/3])4T\M,C`R,BU*4#]"/TE"<VM1:5)/1WEH0S\]"@H*
--"@H*"@H*"@H*"@H*"@``
-eofeof
-
-print "test_data/mime_out2    ";
-    test("-jM",$example['test_data/mime_out2'],[$example['test_data/mime_out2.ans']])
-# test_data/multi-line
-
-$example['test_data/multi-line'] = <<'eofeof'.unpack('u')[0]
-MI,JDK*2DI,JDK*2DI,JDK*'!I*2DKJ3GI*:DK*2BI.JDWJ2WI,:AH@"DLZ3L
-MI/*DO:3.I-ZDWJ2BI,2DJZ2FI,BAHJ3)I*:DXJ3?I-"DJ*2LI.^DZZ2DI+>A
-MHJ3(I,&DY:2FI,>DP:3GI/.DKJ3LI.NDJZ3BI+>D\Z3*I*2AHPJDLZ2SI,_#
-8NZ2DN=2AHP`*I+.DLZ3/P[NDI+G4H:,*
-eofeof
-
-$example['test_data/multi-line.ans'] = <<'eofeof'.unpack('u')[0]
-MI,JDK*2DI,JDK*2DI,JDK*'!I*2DKJ3GI*:DK*2BI.JDWJ2WI,:AH@"DLZ3L
-MI/*DO:3.I-ZDWJ2BI,2DJZ2FI,BAHJ3)I*:DXJ3?I-"DJ*2LI.^DZZ2DI+>A
-MHJ3(I,&DY:2FI,>DP:3GI/.DKJ3LI.NDJZ3BI+>D\Z3*I*2AHPJDLZ2SI,_#
-8NZ2DN=2AHP`*I+.DLZ3/P[NDI+G4H:,*
-eofeof
-
-print "test_data/multi-line    ";
-    test("-e",$example['test_data/multi-line'],[$example['test_data/multi-line.ans']])
-# test_data/nkf-19-bug-1
-
-$example['test_data/nkf-19-bug-1'] = <<'eofeof'.unpack('u')[0]
-,I*:DJZ2D"KK8QJ,*
-eofeof
-
-$example['test_data/nkf-19-bug-1.ans'] = <<'eofeof'.unpack('u')[0]
-8&R1")"8D*R0D&RA""ALD0CI81B,;*$(*
-eofeof
-
-print "test_data/nkf-19-bug-1    ";
-    test("-Ej",$example['test_data/nkf-19-bug-1'],[$example['test_data/nkf-19-bug-1.ans']])
-# test_data/nkf-19-bug-2
-
-$example['test_data/nkf-19-bug-2'] = <<'eofeof'.unpack('u')[0]
-%I-NDL@H`
-eofeof
-
-$example['test_data/nkf-19-bug-2.ans'] = <<'eofeof'.unpack('u')[0]
-%I-NDL@H`
-eofeof
-
-print "test_data/nkf-19-bug-2    ";
-    test("-Ee",$example['test_data/nkf-19-bug-2'],[$example['test_data/nkf-19-bug-2.ans']])
-# test_data/nkf-19-bug-3
-
-$example['test_data/nkf-19-bug-3'] = <<'eofeof'.unpack('u')[0]
-8[;'Q\,&L"N6ZSN\*\NT)ON7.SL_+"0D*
-eofeof
-
-$example['test_data/nkf-19-bug-3.ans'] = <<'eofeof'.unpack('u')[0]
-8[;'Q\,&L"N6ZSN\*\NT)ON7.SL_+"0D*
-eofeof
-
-print "test_data/nkf-19-bug-3    ";
-    test("-e",$example['test_data/nkf-19-bug-3'],[$example['test_data/nkf-19-bug-3.ans']])
-# test_data/non-strict-mime
-
-$example['test_data/non-strict-mime'] = <<'eofeof'.unpack('u')[0]
-M/3])4T\M,C`R,BU*4#]"/PIG<U-#;V]+.6=R-D-O;TQ%9W1Y0W0T1D-$46].
-M0V\V16=S,D]N;T999S1Y1%=)3$IG=4-0:UD*2W!G<FU#>$E+:6=R,D-V;TMI
-,9W-30V]O3&,*/ST*
-eofeof
-
-$example['test_data/non-strict-mime.ans'] = <<'eofeof'.unpack('u')[0]
-M&R1")$8D)"0_)$`D)"1&)%XD.2$C&RA"#0H-"ALD0CMD)$\[?B$Y)6PE.21+
-<)&(]<20K)#LD1B0D)#\D0"0D)$8D)"1>&RA""@``
-eofeof
-
-print "test_data/non-strict-mime    ";
-    test("-jmN",$example['test_data/non-strict-mime'],[$example['test_data/non-strict-mime.ans']])
-# test_data/q-encode-softrap
-
-$example['test_data/q-encode-softrap'] = <<'eofeof'.unpack('u')[0]
-H/3%")$(T03MZ)3T*,R$\)4DD3CTQ0BA""CTQ0B1"2E$T.3TQ0BA""@``
-eofeof
-
-$example['test_data/q-encode-softrap.ans'] = <<'eofeof'.unpack('u')[0]
->&R1"-$$[>B4S(3PE221.&RA""ALD0DI1-#D;*$(*
-eofeof
-
-print "test_data/q-encode-softrap    ";
-    test("-jmQ",$example['test_data/q-encode-softrap'],[$example['test_data/q-encode-softrap.ans']])
-# test_data/rot13
-
-$example['test_data/rot13'] = <<'eofeof'.unpack('u')[0]
-MI+.D\Z3+I,&DSZ&BS:W"]*3(I*2DI*3>I+FAHPH*;FMF('9E<BXQ+CDR(*3R
-MS?C-T:2UI+NDQJ2DI+^DP*2DI,:DI*3>I+FDK*&B05-#24D@I,O"T*2WI,8@
-M4D]4,3,@I*P*P+6DMZ2OQK"DI*3&I*2DRJ2DI.BDIJ3'H:*PRK*\I,ZDZ*2F
-MI,O*T;2YI+6D[*3>I+ND\Z&C"@HE(&5C:&\@)VAO9V4G('P@;FMF("UR"FAO
-#9V4*
-eofeof
-
-$example['test_data/rot13.ans'] = <<'eofeof'.unpack('u')[0]
-M&R1"4V)31%-Z4W!3?E!1?%QQ15-W4U-34U,O4VA04ALH0@H*87AS(&ER92XQ
-M+CDR(!LD0E-#?$E\(E-D4VI3=5-34VY3;U-34W534U,O4VA36U!1&RA"3D90
-M5E8@&R1"4WIQ(5-F4W4;*$(@14)',3,@&R1"4UL;*$(*&R1";V139E->=5]3
-M4U-U4U-3>5-34SE355-V4%%?>6%K4WU3.5-54WIY(F-H4V13/5,O4VI31%!2
-A&RA""@HE(')P=6(@)W5B='(G('P@87AS("UE"G5B='(*
-eofeof
-
-print "test_data/rot13    ";
-    test("-jr",$example['test_data/rot13'],[$example['test_data/rot13.ans']])
-# test_data/slash
-
-$example['test_data/slash'] = <<'eofeof'.unpack('u')[0]
-7("`]/U8\5"U5.5=%2RTK.U<U32LE+PH`
-eofeof
-
-$example['test_data/slash.ans'] = <<'eofeof'.unpack('u')[0]
-7("`]/U8\5"U5.5=%2RTK.U<U32LE+PH`
-eofeof
-
-print "test_data/slash    ";
-    test(" ",$example['test_data/slash'],[$example['test_data/slash.ans']])
-# test_data/z1space-0
-
-$example['test_data/z1space-0'] = <<'eofeof'.unpack('u')[0]
-"H:$`
-eofeof
-
-$example['test_data/z1space-0.ans'] = <<'eofeof'.unpack('u')[0]
-"H:$`
-eofeof
-
-print "test_data/z1space-0    ";
-    test("-e -Z",$example['test_data/z1space-0'],[$example['test_data/z1space-0.ans']])
-# test_data/z1space-1
-
-$example['test_data/z1space-1'] = <<'eofeof'.unpack('u')[0]
-"H:$`
-eofeof
-
-$example['test_data/z1space-1.ans'] = <<'eofeof'.unpack('u')[0]
-!(```
-eofeof
-
-print "test_data/z1space-1    ";
-    test("-e -Z1",$example['test_data/z1space-1'],[$example['test_data/z1space-1.ans']])
-# test_data/z1space-2
-
-$example['test_data/z1space-2'] = <<'eofeof'.unpack('u')[0]
-"H:$`
-eofeof
-
-$example['test_data/z1space-2.ans'] = <<'eofeof'.unpack('u')[0]
-"("``
-eofeof
-
-print "test_data/z1space-2    ";
-    test("-e -Z2",$example['test_data/z1space-2'],[$example['test_data/z1space-2.ans']])
-
-
-# end
-- 
cgit v1.2.3