[Boost-commit] svn:boost r55427 - in sandbox/SOC/2009/unicode: boost/unicode boost/unicode/ucd boost/unicode/ucd/detail libs/unicode/data_parser libs/unicode/data_parser/UNIDATA libs/unicode/doc libs/unicode/example libs/unicode/src libs/unicode/src/ucd

Subject: [Boost-commit] svn:boost r55427 - in sandbox/SOC/2009/unicode: boost/unicode boost/unicode/ucd boost/unicode/ucd/detail libs/unicode/data_parser libs/unicode/data_parser/UNIDATA libs/unicode/doc libs/unicode/example libs/unicode/src libs/unicode/src/ucd
From: loufoque_at_[hidden]
Date: 2009-08-06 03:26:44

Author: mgaunard
Date: 2009-08-06 03:26:39 EDT (Thu, 06 Aug 2009)
New Revision: 55427
URL: http://svn.boost.org/trac/boost/changeset/55427

Log:
Introducing composition support
Added:
   sandbox/SOC/2009/unicode/boost/unicode/compose_fwd.hpp   (contents, props changed)
   sandbox/SOC/2009/unicode/boost/unicode/pipe_def.hpp   (contents, props changed)
   sandbox/SOC/2009/unicode/libs/unicode/data_parser/UNIDATA/CompositionExclusions.txt   (contents, props changed)
   sandbox/SOC/2009/unicode/libs/unicode/data_parser/read_character_properties_compex.cpp   (contents, props changed)
   sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_compose_data.ipp   (contents, props changed)
Text files modified: 
   sandbox/SOC/2009/unicode/boost/unicode/compose.hpp                                    |    37                                         
   sandbox/SOC/2009/unicode/boost/unicode/hangul.hpp                                     |    11                                         
   sandbox/SOC/2009/unicode/boost/unicode/ucd/detail/unichar_data.hpp                    |    18                                         
   sandbox/SOC/2009/unicode/boost/unicode/ucd/properties.hpp                             |     8                                         
   sandbox/SOC/2009/unicode/boost/unicode/utf.hpp                                        |    95 -                                       
   sandbox/SOC/2009/unicode/libs/unicode/data_parser/Jamfile.v2                          |     1                                         
   sandbox/SOC/2009/unicode/libs/unicode/data_parser/read_character_properties.cpp       |     3                                         
   sandbox/SOC/2009/unicode/libs/unicode/data_parser/read_character_properties.hpp       |     5                                         
   sandbox/SOC/2009/unicode/libs/unicode/data_parser/read_character_properties_files.hpp |     7                                         
   sandbox/SOC/2009/unicode/libs/unicode/data_parser/write_character_properties.cpp      |    82 +                                       
   sandbox/SOC/2009/unicode/libs/unicode/data_parser/write_character_properties.hpp      |     3                                         
   sandbox/SOC/2009/unicode/libs/unicode/doc/Jamfile.v2                                  |     5                                         
   sandbox/SOC/2009/unicode/libs/unicode/example/compose.cpp                             |    47                                         
   sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data.cpp         |     1                                         
   sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_1.ipp       |   888 ++++++------                            
   sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_2.ipp       |    76                                         
   sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_3.ipp       |  1882 +++++++++++++-------------              
   sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_4.ipp       |   740 +++++-----                              
   sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_5.ipp       |  1054 +++++++-------                          
   sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_6.ipp       |  1566 +++++++++++-----------                  
   sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_7.ipp       |  1502 ++++++++++----------                    
   sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_8.ipp       |  2786 ++++++++++++++++++++--------------------
   sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_9.ipp       |   316 ++--                                    
   sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_sort_data.ipp    |     1                                         
   sandbox/SOC/2009/unicode/libs/unicode/src/unicode_blocks.cpp                          |    14                                         
   25 files changed, 5580 insertions(+), 5568 deletions(-)

Modified: sandbox/SOC/2009/unicode/boost/unicode/compose.hpp
==============================================================================
--- sandbox/SOC/2009/unicode/boost/unicode/compose.hpp	(original)
+++ sandbox/SOC/2009/unicode/boost/unicode/compose.hpp	2009-08-06 03:26:39 EDT (Thu, 06 Aug 2009)
@@ -1,45 +1,16 @@
 #ifndef BOOST_UNICODE_COMPOSE_HPP
 #define BOOST_UNICODE_COMPOSE_HPP
 
-#include <boost/unicode/ucd/properties.hpp>
-#include <boost/unicode/hangul.hpp>
-
-#include <boost/integer/static_pow.hpp>
-#include <climits>
+#include <boost/unicode/compose_fwd.hpp>
+#include <boost/unicode/pipe_def.hpp>
 
 namespace boost
 {
 namespace unicode
 {
-    
-#define BOOST_UNICODE_OPTION(o) (boost::static_pow<2, (o)>::value)
-#ifdef BOOST_UNICODE_DOXYGEN_INVOKED
-#undef BOOST_UNICODE_OPTION
-#endif
 
-/** Model of \c \xmlonly<conceptname>OneManyPipe</conceptname>\endxmlonly
- * that decomposes a code point, i.e. it converts a code point into a
- * sequence of code points.
- * It applies UCD decompositions that match \c mask as well as the Hangul decompositions. */
-template<unsigned mask = BOOST_UNICODE_OPTION(ucd::decomposition_type::canonical)>
-struct decomposer
-{
-    template<typename Out>
-    Out operator()(char32 ch, Out out)
-    {
-        const char32* p = ucd::get_decomposition(ch);
-        if(p && ((1 << ucd::get_decomposition_type(ch)) & mask))
-        {
-            for(; *p; ++p)
-                *out++ = *p;
-        }
-        else
-        {
-            out = hangul_decomposer()(ch, out);
-        }
-        return out;
-    }
-};
+BOOST_UNICODE_PIPE_DEF(compose, 1)
+BOOST_UNICODE_ONE_MANY_PIPE_DEF(decompose, 1)
 
 } // namespace unicode
 } // namespace boost

Added: sandbox/SOC/2009/unicode/boost/unicode/compose_fwd.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/unicode/compose_fwd.hpp	2009-08-06 03:26:39 EDT (Thu, 06 Aug 2009)
@@ -0,0 +1,222 @@
+#ifndef BOOST_UNICODE_COMPOSE_FWD_HPP
+#define BOOST_UNICODE_COMPOSE_FWD_HPP
+
+#include <boost/unicode/ucd/properties.hpp>
+#include <boost/unicode/hangul.hpp>
+
+#include <boost/integer/static_pow.hpp>
+#include <climits>
+
+#include <boost/range/algorithm/copy.hpp>
+#include <boost/range/distance.hpp>
+#include <boost/range/adaptor/filtered.hpp>
+
+#include <vector>
+
+namespace boost
+{
+namespace unicode
+{
+    
+#define BOOST_UNICODE_OPTION(o) (boost::static_pow<2, (o)>::value)
+#ifdef BOOST_UNICODE_DOXYGEN_INVOKED
+#undef BOOST_UNICODE_OPTION
+#endif
+
+/** Model of \c \xmlonly<conceptname>OneManyPipe</conceptname>\endxmlonly
+ * that decomposes a code point, i.e. it converts a code point into a
+ * sequence of code points.
+ * It applies UCD decompositions that match \c mask as well as the Hangul decompositions. */
+struct decomposer
+{
+    typedef char32 input_type;
+    typedef char32 output_type;
+    
+    decomposer(unsigned mask_ = BOOST_UNICODE_OPTION(ucd::decomposition_type::canonical)) : mask(mask_)
+    {
+    }
+    
+    template<typename Out>
+    Out operator()(char32 ch, Out out)
+    {
+        iterator_range<const char32*> dec = ucd::get_decomposition(ch);
+        if(!empty(dec) && ((1 << ucd::get_decomposition_type(ch)) & mask))
+        {
+            out = copy(dec, out);
+        }
+        else
+        {
+            out = hangul_decomposer()(ch, out);
+        }
+        return out;
+    }
+    
+private:
+    unsigned mask;
+};
+
+
+namespace detail
+{
+    template<typename In>
+    struct composition_find
+    {
+        typedef bool result_type;
+        
+        composition_find(std::size_t offset_) : offset(offset_)
+        {
+        }
+        
+        bool operator()(const ucd::unichar_compose_data_entry& lft, const ucd::unichar_compose_data_entry& rgt) const
+        {
+            return std::lexicographical_compare(
+                lft.decomp+1, lft.decomp+1+std::min(lft.decomp[0], rgt.decomp[0]),
+                rgt.decomp+1, rgt.decomp+1+std::min(lft.decomp[0], rgt.decomp[0])
+            );
+        }
+        
+        bool operator()(const ucd::unichar_compose_data_entry& lft, In rgt) const
+        {   
+            return lft.decomp[0] > offset && lft.decomp[1+offset] < *rgt;
+        }
+        
+        bool operator()(In lft, const ucd::unichar_compose_data_entry& rgt) const
+        {
+            return rgt.decomp[0] > offset && *lft < rgt.decomp[1+offset];
+        }
+        
+    private:
+        std::size_t offset;
+    };
+    
+    struct mask_compose_data_entry
+    {
+        mask_compose_data_entry(unsigned mask_) : mask(mask_)
+        {
+        }
+        
+        bool operator()(const ucd::unichar_compose_data_entry& entry) const
+        {
+            return ((1 << ucd::get_decomposition_type(entry.ch)) & mask) != 0;
+        }
+        
+    private:
+        unsigned mask;
+    };
+}
+
+/** Model of \c \xmlonly<conceptname>Pipe</conceptname>\endxmlonly
+ * that composes a sequence of code points, i.e. it converts a sequence
+ * of code points into a single code point.
+ * It applies UCD compositions that match \c mask as well as the Hangul
+ * compositions, excluding the ones from the composition
+ * exclusion table. */
+struct composer
+{
+    typedef char32 input_type;
+    typedef char32 output_type;
+    
+    composer(unsigned mask_ = BOOST_UNICODE_OPTION(ucd::decomposition_type::canonical)) : mask(mask_)
+    {
+    }
+    
+    template<typename In, typename Out>
+    std::pair<In, Out> ltr(In begin, In end, Out out)
+    {
+        const ucd::unichar_compose_data_entry* table_begin = ucd::__uni_compose_entry;
+        const ucd::unichar_compose_data_entry* table_end = table_begin + ucd::__uni_compose_entry_size;
+        
+        /* We reduce the set of possible results as we consider one more
+         * code point.
+         * The set of possible results is contiguous (before the mask filtering) since the table is sorted */
+        In pos = begin;
+        std::size_t offset = 0;
+        for(;;)
+        {
+            filter_range<
+                detail::mask_compose_data_entry,
+                const iterator_range<const ucd::unichar_compose_data_entry*>
+            > r =
+                make_filtered_range(
+                    make_iterator_range(
+                        std::equal_range(
+                            table_begin, table_end,
+                            pos,
+                            detail::composition_find<In>(offset)
+                        )
+                    ),
+                    detail::mask_compose_data_entry(mask)
+                );
+            
+            std::ptrdiff_t sz = distance(r);
+            if(sz == 1 && offset == (r.begin()->decomp[0]-1))
+            {
+                *out++ = r.begin()->ch;
+                return std::make_pair(++pos, out);
+            }
+            else if(sz == 0 || ++pos == end)
+            {
+                return hangul_composer().ltr(begin, end, out);
+            }
+            
+            table_begin = r.begin().base();
+            table_end = r.end().base();
+            ++offset;
+        }
+    }
+    
+    /* This could by made faster using a sorted table of reversed strings */
+    template<typename In, typename Out>
+    std::pair<In, Out> rtl(In begin, In end, Out out)
+    {
+        const ucd::unichar_compose_data_entry* table_begin = ucd::__uni_compose_entry;
+        const ucd::unichar_compose_data_entry* table_end = table_begin + ucd::__uni_compose_entry_size;
+        
+        std::vector<const ucd::unichar_compose_data_entry*> r;
+        std::size_t offset = 0;
+        In pos = end;
+        --pos;
+        
+        /* First pass, we copy the possible results into a vector */
+        for(const ucd::unichar_compose_data_entry* p = table_begin; p != table_end; ++p)
+        {
+            if(detail::mask_compose_data_entry(mask)(*p) && p->decomp[p->decomp[0]] == *pos)
+                r.push_back(p);
+        }
+        
+        /* i-th pass, we copy the possible results into another vector then swap it
+         * with the previous one */
+        for(;;)
+        {
+            if(r.size() == 1 && offset == (r.front()->decomp[0]-1))
+            {
+                *out++ = r.front()->ch;
+                return std::make_pair(pos, out);
+            }
+            else if(r.size() == 0 || pos == begin)
+            {
+                return hangul_composer().rtl(begin, end, out);
+            }
+
+            ++offset;
+            --pos;
+            std::vector<const ucd::unichar_compose_data_entry*> r2;
+            typedef std::vector<const ucd::unichar_compose_data_entry*>::const_iterator iterator;
+            for(iterator it = r.begin(); it != r.end(); ++it)
+            {
+                const ucd::unichar_compose_data_entry* p = *it;
+                if(detail::mask_compose_data_entry(mask)(*p) && p->decomp[0] > offset && p->decomp[p->decomp[0]-offset] == *pos)
+                    r2.push_back(p);
+            }
+            r.swap(r2);
+        }
+    }
+    
+private:
+    unsigned mask;
+};
+
+} // namespace unicode
+} // namespace boost
+
+#endif

Modified: sandbox/SOC/2009/unicode/boost/unicode/hangul.hpp
==============================================================================
--- sandbox/SOC/2009/unicode/boost/unicode/hangul.hpp	(original)
+++ sandbox/SOC/2009/unicode/boost/unicode/hangul.hpp	2009-08-06 03:26:39 EDT (Thu, 06 Aug 2009)
@@ -71,9 +71,9 @@
     typedef char32 output_type;
     typedef mpl::int_<1> max_output;
     
-    /*template<typename In, typename Out>
+    template<typename In, typename Out>
     std::pair<In, Out> ltr(In begin, In end, Out out)
-    {
+    {/*
         using namespace detail;
 
         char32 last = *begin; // copy first char
@@ -115,14 +115,17 @@
             last = ch;
             result.append(ch);
         }
-
+        */
+        *out++ = *begin++;
         return std::make_pair(begin, out);
     }
     
     template<typename In, typename Out>
     std::pair<In, Out> rtl(In begin, In end, Out out)
     {
-    }*/
+        *out++ = *--end;
+        return std::make_pair(end, out);
+    }
 };
 
 } // namespace unicode

Added: sandbox/SOC/2009/unicode/boost/unicode/pipe_def.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/unicode/pipe_def.hpp	2009-08-06 03:26:39 EDT (Thu, 06 Aug 2009)
@@ -0,0 +1,155 @@
+#ifndef BOOST_UNICODE_PIPE_DEF_HPP
+#define BOOST_UNICODE_PIPE_DEF_HPP
+
+#include <boost/preprocessor/punctuation/comma_if.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/repeat.hpp>
+#include <boost/preprocessor/tuple/elem.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/arithmetic/inc.hpp>
+
+#include <boost/detail/unspecified.hpp>
+
+#include <boost/iterator/pipe_iterator.hpp>
+
+namespace boost
+{
+
+/** INTERNAL ONLY */    
+template<typename Pipe>
+struct identity_pipe : Pipe
+{
+    identity_pipe() {}
+    identity_pipe(Pipe p) : Pipe(p) {}
+};
+
+/** INTERNAL ONLY */
+template<typename Pipe>
+identity_pipe<Pipe> make_identity_pipe(Pipe p)
+{
+    return identity_pipe<Pipe>(p);
+}
+
+}
+
+#ifdef BOOST_UNICODE_DOXYGEN_INVOKED
+/** INTERNAL ONLY */
+#define BOOST_UNICODE_PIPE_EAGER_DEF(z, n, text) \
+/** Eagerly evaluates \c unicode##::##text##r until the whole input
+   range \c range has been treated, copying the result to \c out and
+   returning the past-the-end output iterator. */ \
+template<typename Range, typename OutputIterator, typename... T> \
+OutputIterator text(const Range& range, OutputIterator out, const T&... args);
+#else
+#define BOOST_UNICODE_PIPE_EAGER_DEF(z, n, text) \
+template<typename Range, typename OutputIterator BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename T)> \
+OutputIterator BOOST_PP_TUPLE_ELEM(2, 0, text)(const Range& range, OutputIterator out BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_BINARY_PARAMS(n, const T, & t)) \
+{ \
+    return pipe( \
+        range, \
+        BOOST_PP_CAT(make_, BOOST_PP_TUPLE_ELEM(2, 1, text))(BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2, 0, text), r)(BOOST_PP_ENUM_PARAMS(n, t))), \
+        out \
+    ); \
+}
+#endif 
+
+#ifdef BOOST_UNICODE_DOXYGEN_INVOKED
+/** INTERNAL ONLY */
+#define BOOST_UNICODE_PIPE_LAZY_DEF(z, n, text) \
+/** Lazily evalutes \c unicode::##text##r by returning a range
+   adapter that wraps the range \c range and converts it step-by-step as
+   the range is advanced. */ \
+template<typename Range, typename... T> \
+detail::unspecified<void> BOOST_PP_CAT(text, d)(const Range& range, const T&... args);
+#else
+#define BOOST_UNICODE_PIPE_LAZY_DEF(z, n, text) \
+template<typename Range BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename T)> \
+iterator_range< \
+    pipe_iterator< \
+        typename range_iterator<const Range>::type, \
+        BOOST_PP_TUPLE_ELEM(2, 1, text) < \
+            unicode::BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2, 0, text), r) \
+        > \
+    > \
+> \
+BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2, 0, text), d)(const Range& range BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_BINARY_PARAMS(n, const T, & t)) \
+{ \
+    return piped(range, BOOST_PP_CAT(make_, BOOST_PP_TUPLE_ELEM(2, 1, text))(unicode::BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2, 0, text), r)(BOOST_PP_ENUM_PARAMS(n, t)))); \
+}
+#endif
+
+#ifdef BOOST_UNICODE_DOXYGEN_INVOKED
+/** INTERNAL ONLY */
+#define BOOST_UNICODE_PIPE_LAZY_2_DEF(z, n, text) \
+/** Lazily evalutes \c unicode::##text##r by returning a range
+   adapter that wraps the range \c range and converts it step-by-step as
+   the range is advanced. */ \
+template<typename Range, typename... T> \
+detail::unspecified<void> BOOST_PP_CAT(text, d)(Range& range, const T&... args);
+#else
+#define BOOST_UNICODE_PIPE_LAZY_2_DEF(z, n, text) \
+template<typename Range BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename T)> \
+iterator_range< \
+    pipe_iterator< \
+        typename range_iterator<Range>::type, \
+        BOOST_PP_TUPLE_ELEM(2, 1, text) < \
+            unicode::BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2, 0, text), r) \
+        > \
+    > \
+> \
+BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2, 0, text), d)(Range& range BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_BINARY_PARAMS(n, const T, & t)) \
+{ \
+    return piped(range, BOOST_PP_CAT(make_, BOOST_PP_TUPLE_ELEM(2, 1, text))(unicode::BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2, 0, text), r)(BOOST_PP_ENUM_PARAMS(n, t)))); \
+}
+#endif
+
+#ifdef BOOST_UNICODE_DOXYGEN_INVOKED
+/** INTERNAL ONLY */
+#define BOOST_UNICODE_REPEAT(n, macro, tuple) \
+BOOST_PP_REPEAT(n, macro, BOOST_PP_TUPLE_ELEM(2, 0, tuple))
+#else
+#define BOOST_UNICODE_REPEAT(n, macro, tuple) \
+BOOST_PP_REPEAT(n, macro, tuple)
+#endif
+
+/** INTERNAL ONLY */
+#define BOOST_UNICODE_PIPE_COMMON_DEF(name, wrapper, n) \
+BOOST_UNICODE_REPEAT(BOOST_PP_INC(n), BOOST_UNICODE_PIPE_EAGER_DEF, (name, wrapper)) \
+BOOST_UNICODE_REPEAT(BOOST_PP_INC(n), BOOST_UNICODE_PIPE_LAZY_DEF, (name, wrapper)) \
+BOOST_UNICODE_REPEAT(BOOST_PP_INC(n), BOOST_UNICODE_PIPE_LAZY_2_DEF, (name, wrapper))
+
+#ifdef BOOST_UNICODE_DOXYGEN_INVOKED
+/** INTERNAL ONLY */
+#define BOOST_UNICODE_PIPE_OUTPUT_DEF(z, n, text) \
+/** Lazily evalutes \c unicode::##text##r by returning an output
+  iterator that wraps \c out and converts every pushed element. */ \
+template<typename OutputIterator, typename... T> \
+detail::unspecified<void> \
+BOOST_PP_CAT(text, d_out)(OutputIterator out, const T&... args);
+#else
+#define BOOST_UNICODE_PIPE_OUTPUT_DEF(z, n, text) \
+template<typename OutputIterator BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename T)> \
+pipe_output_iterator< \
+    OutputIterator, \
+    unicode::BOOST_PP_CAT(text, r) \
+> BOOST_PP_CAT(text, d_out)(OutputIterator out BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_BINARY_PARAMS(n, const T, & t)) \
+{ \
+	return piped_output(out, unicode::BOOST_PP_CAT(text, r)(BOOST_PP_ENUM_PARAMS(n, t))); \
+}
+#endif
+
+/** Defines helper functions for usage of a \c \xmlonly<conceptname>OneManyPipe</conceptname>\endxmlonly.
+ * \arg \c name Name of the type modelling the \c \xmlonly<conceptname>OneManyPipe</conceptname>\endxmlonly.
+ * \arg \c n Maximum number of optional arguments. */
+#define BOOST_UNICODE_ONE_MANY_PIPE_DEF(name, n) \
+BOOST_UNICODE_PIPE_COMMON_DEF(name, one_many_pipe, n) \
+BOOST_UNICODE_REPEAT(BOOST_PP_INC(n), BOOST_UNICODE_PIPE_OUTPUT_DEF, name)
+
+/** Defines helper functions for usage of a \c \xmlonly<conceptname>Pipe</conceptname>\endxmlonly.
+ * \arg \c name Name of the type modelling the \c \xmlonly<conceptname>Pipe</conceptname>\endxmlonly.
+ * \arg \c n Maximum number of optional arguments. */
+#define BOOST_UNICODE_PIPE_DEF(name, n) \
+BOOST_UNICODE_PIPE_COMMON_DEF(name, identity_pipe, n)
+
+#endif

Modified: sandbox/SOC/2009/unicode/boost/unicode/ucd/detail/unichar_data.hpp
==============================================================================
--- sandbox/SOC/2009/unicode/boost/unicode/ucd/detail/unichar_data.hpp	(original)
+++ sandbox/SOC/2009/unicode/boost/unicode/ucd/detail/unichar_data.hpp	2009-08-06 03:26:39 EDT (Thu, 06 Aug 2009)
@@ -41,6 +41,12 @@
         const char32 *      following_chars;
         const uint16_t      following_chars_count;
     };
+    
+    struct unichar_compose_data_entry
+    {
+        const char32* decomp;
+        char32 ch;
+    };
 
     struct unichar_complex_case_internal
     {
@@ -133,13 +139,15 @@
         const char*      name;
     };
 
-    BOOST_UNICODE_DECL extern const boost::unicode::ucd::unichar_data_internal* __uni_char_data[];
-    BOOST_UNICODE_DECL extern const boost::unicode::ucd::unichar_blocks_internal __uni_block_data[];
+    BOOST_UNICODE_DECL extern const unichar_data_internal* __uni_char_data[];
+    BOOST_UNICODE_DECL extern const unichar_blocks_internal __uni_block_data[];
+    BOOST_UNICODE_DECL extern const size_t __uni_block_data_size;
 #ifdef BOOST_UNICODE_UCD_BIG
-    BOOST_UNICODE_DECL extern const boost::unicode::ucd::unichar_sort_data_entry __uni_sort_entry[];
+    BOOST_UNICODE_DECL extern const unichar_sort_data_entry __uni_sort_entry[];
 #endif
-    
-    BOOST_UNICODE_DECL extern const size_t __uni_block_data_size;
+    BOOST_UNICODE_DECL extern const unichar_compose_data_entry __uni_compose_entry[];
+    BOOST_UNICODE_DECL extern const size_t __uni_compose_entry_size;
+
     
     inline const unichar_data_internal& get_data_internal(char32 ch)
     {

Modified: sandbox/SOC/2009/unicode/boost/unicode/ucd/properties.hpp
==============================================================================
--- sandbox/SOC/2009/unicode/boost/unicode/ucd/properties.hpp	(original)
+++ sandbox/SOC/2009/unicode/boost/unicode/ucd/properties.hpp	2009-08-06 03:26:39 EDT (Thu, 06 Aug 2009)
@@ -7,8 +7,7 @@
 
 #include <boost/unicode/ucd/detail/unichar_data.hpp>
 
-#include <algorithm>
-#include <iostream>
+#include <boost/range.hpp>
 
 /** BOOST_UNICODE_UCD_VERSION / 1000 is the major version
  * BOOST_UNICODE_UCD_VERSION % 1000 is the minor version */
@@ -77,9 +76,10 @@
 /** Returns the decomposition associated with \c ch as a zero-terminated
  * sequence of code points.
  * See the \c decomposition_type property to know what kind of decomposition it is. */
-inline const char32* get_decomposition(char32 ch)
+inline iterator_range<const char32*> get_decomposition(char32 ch)
 {
-    return ucd::get_data_internal(ch).decomp;
+    const char32* p = ucd::get_data_internal(ch).decomp;
+    return make_iterator_range(p+1, p+1+p[0]);
 }
 
 } // namespace ucd

Modified: sandbox/SOC/2009/unicode/boost/unicode/utf.hpp
==============================================================================
--- sandbox/SOC/2009/unicode/boost/unicode/utf.hpp	(original)
+++ sandbox/SOC/2009/unicode/boost/unicode/utf.hpp	2009-08-06 03:26:39 EDT (Thu, 06 Aug 2009)
@@ -5,7 +5,7 @@
 #include <boost/iterator/pipe_iterator.hpp>
 #include <boost/iterator/consumer_iterator.hpp>
 
-#include <boost/detail/unspecified.hpp>
+#include <boost/unicode/pipe_def.hpp>
 
 namespace boost
 {
@@ -14,102 +14,13 @@
 
 /** INTERNAL ONLY */
 #define BOOST_UNICODE_ENCODER_DEF(Name)                                \
-/** Eagerly evaluates \c unicode::##Name##_encoder until the whole input
-   range \c range has been treated, copying the result to \c out and
-   returning the past-the-end output iterator */                       \
-template<typename Range, typename OutputIterator>                      \
-OutputIterator Name##_encode(const Range& range, OutputIterator out)   \
-{                                                                      \
-    return pipe(                                                       \
-        range,                                                         \
-        make_one_many_pipe(unicode::Name##_encoder()), out             \
-    );                                                                 \
-}                                                                      \
-                                                                       \
-/** Lazily evalutes \c unicode::##Name##_encoder by returning a range
-   adapter that wraps the range \c range and converts it step-by-step as
-   the range is advanced */                                            \
-template<typename Range>                                               \
-iterator_range<typename boost::detail::unspecified<                    \
-    pipe_iterator<                                                     \
-        typename range_iterator<const Range>::type,                    \
-        one_many_pipe<unicode::Name##_encoder>                         \
-    >                                                                  \
->::type>                                                               \
-Name##_encoded(const Range& range)                                     \
-{                                                                      \
-    return piped(range, make_one_many_pipe(unicode::Name##_encoder()));\
-}                                                                      \
-                                                                       \
-/** Lazily evalutes \c unicode::##Name##_encoder by returning a range
-   adapter that wraps the range \c range and converts it step-by-step as
-   the range is advanced */                                            \
-template<typename Range>                                               \
-iterator_range<typename boost::detail::unspecified<                    \
-    pipe_iterator<                                                     \
-        typename range_iterator<Range>::type,                          \
-        one_many_pipe<unicode::Name##_encoder>                         \
-    >                                                                  \
->::type>                                                               \
-Name##_encoded(Range& range)                                           \
-{                                                                      \
-    return piped(range, make_one_many_pipe(unicode::Name##_encoder()));\
-}                                                                      \
-                                                                       \
-/** Lazily evalutes \c unicode::##Name##_encoder by returning an output
-  iterator that wraps \c out and converts every pushed element. */     \
-template<typename OutputIterator>                                      \
-typename boost::detail::unspecified<pipe_output_iterator<              \
-    OutputIterator,                                                    \
-    unicode::Name##_encoder                                            \
-> >::type Name##_encoded_out(OutputIterator out)                       \
-{                                                                      \
-	return piped_output(out, unicode::Name##_encoder());               \
-}                                                                      \
-
+BOOST_UNICODE_ONE_MANY_PIPE_DEF(Name##_encode, 0)
 
 /* */
 
 /** INTERNAL ONLY */
 #define BOOST_UNICODE_DECODER_DEF(Name)                                \
-/** Eagerly evaluates \c unicode::##Name##_decoder until the whole input
-   range \c range has been treated, copying the result to \c out and
-   returning the past-the-end output iterator */                       \
-template<typename Range, typename OutputIterator>                      \
-OutputIterator Name##_decode(const Range& range, OutputIterator out)   \
-{                                                                      \
-    return pipe(range, unicode::Name##_decoder(), out);                \
-}                                                                      \
-                                                                       \
-/** Lazily evalutes \c unicode::##Name##_decoder by returning a range
-   adapter that wraps the range \c range and converts it step-by-step as
-   the range is advanced */                                            \
-template<typename Range>                                               \
-iterator_range<typename boost::detail::unspecified<                    \
-    pipe_iterator<                                                     \
-        typename range_iterator<const Range>::type,                    \
-        unicode::Name##_decoder                                        \
-    >                                                                  \
->::type>                                                               \
-Name##_decoded(const Range& range)                                     \
-{                                                                      \
-    return piped(range, unicode::Name##_decoder());                    \
-}                                                                      \
-                                                                       \
-/** Lazily evalutes \c unicode::##Name##_decoder by returning a range
-   adapter that wraps the range \c range and converts it step-by-step as
-   the range is advanced */                                            \
-template<typename Range>                                               \
-iterator_range<typename boost::detail::unspecified<                    \
-    pipe_iterator<                                                     \
-        typename range_iterator<Range>::type,                          \
-        unicode::Name##_decoder                                        \
-    >                                                                  \
->::type>                                                               \
-Name##_decoded(Range& range)                                           \
-{                                                                      \
-    return piped(range, unicode::Name##_decoder());                    \
-}                                                                      \
+BOOST_UNICODE_PIPE_DEF(Name##_decode, 0)                               \
                                                                        \
 /** Adapts the range of Name units \c range into a range of ranges of
 Name units, each subrange being a decoded unit. */                     \

Modified: sandbox/SOC/2009/unicode/libs/unicode/data_parser/Jamfile.v2
==============================================================================
--- sandbox/SOC/2009/unicode/libs/unicode/data_parser/Jamfile.v2	(original)
+++ sandbox/SOC/2009/unicode/libs/unicode/data_parser/Jamfile.v2	2009-08-06 03:26:39 EDT (Thu, 06 Aug 2009)
@@ -24,6 +24,7 @@
     read_character_properties_unicodedata.cpp
     read_character_properties_word_break.cpp
     read_collation_data.cpp
+    read_character_properties_compex.cpp
     write_character_properties.cpp
 
     ../src/unicode_properties.cpp

Added: sandbox/SOC/2009/unicode/libs/unicode/data_parser/UNIDATA/CompositionExclusions.txt
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/libs/unicode/data_parser/UNIDATA/CompositionExclusions.txt	2009-08-06 03:26:39 EDT (Thu, 06 Aug 2009)
@@ -0,0 +1,197 @@
+# CompositionExclusions-5.1.0.txt
+# Date: 2008-03-20, 17:45:00 PDT [KW]
+#
+# This file lists the characters for the Composition Exclusion Table
+# defined in UAX #15, Unicode Normalization Forms.
+#
+# This file is a normative contributory data file in the
+# Unicode Character Database.
+#
+# Copyright (c) 1991-2008 Unicode, Inc.
+# For terms of use, see http://www.unicode.org/terms_of_use.html
+#
+# For more information, see
+# http://www.unicode.org/unicode/reports/tr15/#Primary Exclusion List Table
+#
+# For a full derivation of composition exclusions, see the derived property
+# Full_Composition_Exclusion in DerivedNormalizationProps.txt
+#
+
+# ================================================
+# (1) Script Specifics
+#
+# This list of characters cannot be derived from the UnicodeData.txt file.
+# ================================================
+
+0958    #  DEVANAGARI LETTER QA
+0959    #  DEVANAGARI LETTER KHHA
+095A    #  DEVANAGARI LETTER GHHA
+095B    #  DEVANAGARI LETTER ZA
+095C    #  DEVANAGARI LETTER DDDHA
+095D    #  DEVANAGARI LETTER RHA
+095E    #  DEVANAGARI LETTER FA
+095F    #  DEVANAGARI LETTER YYA
+09DC    #  BENGALI LETTER RRA
+09DD    #  BENGALI LETTER RHA
+09DF    #  BENGALI LETTER YYA
+0A33    #  GURMUKHI LETTER LLA
+0A36    #  GURMUKHI LETTER SHA
+0A59    #  GURMUKHI LETTER KHHA
+0A5A    #  GURMUKHI LETTER GHHA
+0A5B    #  GURMUKHI LETTER ZA
+0A5E    #  GURMUKHI LETTER FA
+0B5C    #  ORIYA LETTER RRA
+0B5D    #  ORIYA LETTER RHA
+0F43    #  TIBETAN LETTER GHA
+0F4D    #  TIBETAN LETTER DDHA
+0F52    #  TIBETAN LETTER DHA
+0F57    #  TIBETAN LETTER BHA
+0F5C    #  TIBETAN LETTER DZHA
+0F69    #  TIBETAN LETTER KSSA
+0F76    #  TIBETAN VOWEL SIGN VOCALIC R
+0F78    #  TIBETAN VOWEL SIGN VOCALIC L
+0F93    #  TIBETAN SUBJOINED LETTER GHA
+0F9D    #  TIBETAN SUBJOINED LETTER DDHA
+0FA2    #  TIBETAN SUBJOINED LETTER DHA
+0FA7    #  TIBETAN SUBJOINED LETTER BHA
+0FAC    #  TIBETAN SUBJOINED LETTER DZHA
+0FB9    #  TIBETAN SUBJOINED LETTER KSSA
+FB1D    #  HEBREW LETTER YOD WITH HIRIQ
+FB1F    #  HEBREW LIGATURE YIDDISH YOD YOD PATAH
+FB2A    #  HEBREW LETTER SHIN WITH SHIN DOT
+FB2B    #  HEBREW LETTER SHIN WITH SIN DOT
+FB2C    #  HEBREW LETTER SHIN WITH DAGESH AND SHIN DOT
+FB2D    #  HEBREW LETTER SHIN WITH DAGESH AND SIN DOT
+FB2E    #  HEBREW LETTER ALEF WITH PATAH
+FB2F    #  HEBREW LETTER ALEF WITH QAMATS
+FB30    #  HEBREW LETTER ALEF WITH MAPIQ
+FB31    #  HEBREW LETTER BET WITH DAGESH
+FB32    #  HEBREW LETTER GIMEL WITH DAGESH
+FB33    #  HEBREW LETTER DALET WITH DAGESH
+FB34    #  HEBREW LETTER HE WITH MAPIQ
+FB35    #  HEBREW LETTER VAV WITH DAGESH
+FB36    #  HEBREW LETTER ZAYIN WITH DAGESH
+FB38    #  HEBREW LETTER TET WITH DAGESH
+FB39    #  HEBREW LETTER YOD WITH DAGESH
+FB3A    #  HEBREW LETTER FINAL KAF WITH DAGESH
+FB3B    #  HEBREW LETTER KAF WITH DAGESH
+FB3C    #  HEBREW LETTER LAMED WITH DAGESH
+FB3E    #  HEBREW LETTER MEM WITH DAGESH
+FB40    #  HEBREW LETTER NUN WITH DAGESH
+FB41    #  HEBREW LETTER SAMEKH WITH DAGESH
+FB43    #  HEBREW LETTER FINAL PE WITH DAGESH
+FB44    #  HEBREW LETTER PE WITH DAGESH
+FB46    #  HEBREW LETTER TSADI WITH DAGESH
+FB47    #  HEBREW LETTER QOF WITH DAGESH
+FB48    #  HEBREW LETTER RESH WITH DAGESH
+FB49    #  HEBREW LETTER SHIN WITH DAGESH
+FB4A    #  HEBREW LETTER TAV WITH DAGESH
+FB4B    #  HEBREW LETTER VAV WITH HOLAM
+FB4C    #  HEBREW LETTER BET WITH RAFE
+FB4D    #  HEBREW LETTER KAF WITH RAFE
+FB4E    #  HEBREW LETTER PE WITH RAFE
+
+# Total code points: 67
+
+# ================================================
+# (2) Post Composition Version precomposed characters
+#
+# These characters cannot be derived solely from the UnicodeData.txt file
+# in this version of Unicode.
+#
+# Note that characters added to the standard after the
+# Composition Version and which have canonical decomposition mappings
+# are not automatically added to this list of Post Composition
+# Version precomposed characters.
+# ================================================
+
+2ADC    #  FORKING
+1D15E   #  MUSICAL SYMBOL HALF NOTE
+1D15F   #  MUSICAL SYMBOL QUARTER NOTE
+1D160   #  MUSICAL SYMBOL EIGHTH NOTE
+1D161   #  MUSICAL SYMBOL SIXTEENTH NOTE
+1D162   #  MUSICAL SYMBOL THIRTY-SECOND NOTE
+1D163   #  MUSICAL SYMBOL SIXTY-FOURTH NOTE
+1D164   #  MUSICAL SYMBOL ONE HUNDRED TWENTY-EIGHTH NOTE
+1D1BB   #  MUSICAL SYMBOL MINIMA
+1D1BC   #  MUSICAL SYMBOL MINIMA BLACK
+1D1BD   #  MUSICAL SYMBOL SEMIMINIMA WHITE
+1D1BE   #  MUSICAL SYMBOL SEMIMINIMA BLACK
+1D1BF   #  MUSICAL SYMBOL FUSA WHITE
+1D1C0   #  MUSICAL SYMBOL FUSA BLACK
+
+# Total code points: 14
+
+# ================================================
+# (3) Singleton Decompositions
+#
+# These characters can be derived from the UnicodeData.txt file
+# by including all characters whose canonical decomposition
+# consists of a single character.
+#
+# These characters are simply quoted here for reference.
+# See also Full_Composition_Exclusion in DerivedNormalizationProps.txt
+# ================================================
+
+# 0340..0341       [2] COMBINING GRAVE TONE MARK..COMBINING ACUTE TONE MARK
+# 0343                 COMBINING GREEK KORONIS
+# 0374                 GREEK NUMERAL SIGN
+# 037E                 GREEK QUESTION MARK
+# 0387                 GREEK ANO TELEIA
+# 1F71                 GREEK SMALL LETTER ALPHA WITH OXIA
+# 1F73                 GREEK SMALL LETTER EPSILON WITH OXIA
+# 1F75                 GREEK SMALL LETTER ETA WITH OXIA
+# 1F77                 GREEK SMALL LETTER IOTA WITH OXIA
+# 1F79                 GREEK SMALL LETTER OMICRON WITH OXIA
+# 1F7B                 GREEK SMALL LETTER UPSILON WITH OXIA
+# 1F7D                 GREEK SMALL LETTER OMEGA WITH OXIA
+# 1FBB                 GREEK CAPITAL LETTER ALPHA WITH OXIA
+# 1FBE                 GREEK PROSGEGRAMMENI
+# 1FC9                 GREEK CAPITAL LETTER EPSILON WITH OXIA
+# 1FCB                 GREEK CAPITAL LETTER ETA WITH OXIA
+# 1FD3                 GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA
+# 1FDB                 GREEK CAPITAL LETTER IOTA WITH OXIA
+# 1FE3                 GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND OXIA
+# 1FEB                 GREEK CAPITAL LETTER UPSILON WITH OXIA
+# 1FEE..1FEF       [2] GREEK DIALYTIKA AND OXIA..GREEK VARIA
+# 1FF9                 GREEK CAPITAL LETTER OMICRON WITH OXIA
+# 1FFB                 GREEK CAPITAL LETTER OMEGA WITH OXIA
+# 1FFD                 GREEK OXIA
+# 2000..2001       [2] EN QUAD..EM QUAD
+# 2126                 OHM SIGN
+# 212A..212B       [2] KELVIN SIGN..ANGSTROM SIGN
+# 2329                 LEFT-POINTING ANGLE BRACKET
+# 232A                 RIGHT-POINTING ANGLE BRACKET
+# F900..FA0D     [270] CJK COMPATIBILITY IDEOGRAPH-F900..CJK COMPATIBILITY IDEOGRAPH-FA0D
+# FA10                 CJK COMPATIBILITY IDEOGRAPH-FA10
+# FA12                 CJK COMPATIBILITY IDEOGRAPH-FA12
+# FA15..FA1E      [10] CJK COMPATIBILITY IDEOGRAPH-FA15..CJK COMPATIBILITY IDEOGRAPH-FA1E
+# FA20                 CJK COMPATIBILITY IDEOGRAPH-FA20
+# FA22                 CJK COMPATIBILITY IDEOGRAPH-FA22
+# FA25..FA26       [2] CJK COMPATIBILITY IDEOGRAPH-FA25..CJK COMPATIBILITY IDEOGRAPH-FA26
+# FA2A..FA2D       [4] CJK COMPATIBILITY IDEOGRAPH-FA2A..CJK COMPATIBILITY IDEOGRAPH-FA2D
+# FA30..FA6A      [59] CJK COMPATIBILITY IDEOGRAPH-FA30..CJK COMPATIBILITY IDEOGRAPH-FA6A
+# FA70..FAD9     [106] CJK COMPATIBILITY IDEOGRAPH-FA70..CJK COMPATIBILITY IDEOGRAPH-FAD9
+# 2F800..2FA1D   [542] CJK COMPATIBILITY IDEOGRAPH-2F800..CJK COMPATIBILITY IDEOGRAPH-2FA1D
+
+# Total code points: 1030
+
+# ================================================
+# (4) Non-Starter Decompositions
+#
+# These characters can be derived from the UnicodeData file
+# by including all characters whose canonical decomposition consists
+# of a sequence of characters, the first of which has a non-zero
+# combining class.
+#
+# These characters are simply quoted here for reference.
+# See also Full_Composition_Exclusion in DerivedNormalizationProps.txt
+# ================================================
+
+# 0344                 COMBINING GREEK DIALYTIKA TONOS
+# 0F73                 TIBETAN VOWEL SIGN II
+# 0F75                 TIBETAN VOWEL SIGN UU
+# 0F81                 TIBETAN VOWEL SIGN REVERSED II
+
+# Total code points: 4
+

Modified: sandbox/SOC/2009/unicode/libs/unicode/data_parser/read_character_properties.cpp
==============================================================================
--- sandbox/SOC/2009/unicode/libs/unicode/data_parser/read_character_properties.cpp	(original)
+++ sandbox/SOC/2009/unicode/libs/unicode/data_parser/read_character_properties.cpp	2009-08-06 03:26:39 EDT (Thu, 06 Aug 2009)
@@ -73,6 +73,9 @@
         read_character_properties_sentence (props, "./USERDATA/auxiliary/SentenceBreakProperty.txt", false);
     read_collation_data(props, "./UNIDATA/UCA/allkeys.txt", true);
     read_collation_data(props, "./USERDATA/UCA/allkeys.txt", false);
+    
+    read_character_properties_compex (props, "./UNIDATA/CompositionExclusions.txt", true);
+    read_character_properties_compex (props, "./USERDATA/CompositionExclusions.txt", false);
 
         add_unknown_character(props);
 }

Modified: sandbox/SOC/2009/unicode/libs/unicode/data_parser/read_character_properties.hpp
==============================================================================
--- sandbox/SOC/2009/unicode/libs/unicode/data_parser/read_character_properties.hpp	(original)
+++ sandbox/SOC/2009/unicode/libs/unicode/data_parser/read_character_properties.hpp	2009-08-06 03:26:39 EDT (Thu, 06 Aug 2009)
@@ -113,6 +113,8 @@
 
                                 line_break::type			line_break;
                                 join_type::type				joining;
+                
+                bool                        comp_ex;
 
                                 enum	{ CHARACTER_DOES_NOT_EXIST = 0x400000	};
 
@@ -136,7 +138,8 @@
                                         lowercase (0),
                                         titlecase (0),
                     line_break (line_break::type (-1)),
-                    joining (join_type::none)
+                    joining (join_type::none),
+                    comp_ex (false)
                                 {}
                         };
 

Added: sandbox/SOC/2009/unicode/libs/unicode/data_parser/read_character_properties_compex.cpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/libs/unicode/data_parser/read_character_properties_compex.cpp	2009-08-06 03:26:39 EDT (Thu, 06 Aug 2009)
@@ -0,0 +1,138 @@
+// Read Unicode character properties from the database.
+// Though this file is under the Boost license, it is NOT (or not yet) part of
+// Boost!
+
+// Copyright Graham Barnett, Rogier van Dalen 2005.
+// Use, modification, and distribution are subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+
+#include <iostream>
+#include <iomanip>
+#include <stdexcept>
+#include <string>
+#include <sstream>
+#include <algorithm>
+
+#include <boost/spirit/include/classic.hpp>
+#include <boost/lambda/lambda.hpp>
+
+#include "read_character_properties.hpp"
+#include "read_character_properties_files.hpp"
+
+using namespace boost::spirit::classic;
+using namespace boost::unicode;
+using namespace boost::unicode::ucd;
+using namespace boost::lambda;
+
+using boost::char32;
+
+namespace boost { namespace unicode { namespace ucd {
+
+const int PROGRESS_INDICATION_EVERY  = 200;
+
+void read_character_properties_compex (
+	                std::map <char32, character_properties> & props, 
+                                    const char* filename, bool required)
+{
+	std::cout << "+Reading composition exclusions from " << filename << "\n";
+
+	parse_info <file_iterator<> > info;
+	file_iterator<> curr, last;
+
+	try
+	{
+		curr = get_file_iterator (filename);
+	}
+	catch (file_read_error)
+	{
+		if (required)
+		{
+			throw;
+		}
+		else
+		{
+			std::cout << "-Reading composition exclusions from optional file - not present\n";
+			return;
+		}
+	}
+	last = curr.make_end();
+
+	eat_comments (curr, last);
+
+	int progress = PROGRESS_INDICATION_EVERY;
+	std::cout << " ";
+
+	do
+	{
+		char32 first_code;
+		char32 last_code;
+
+		// The line being decoded is formatted as:
+		// Start Code..End Code
+        // or 
+        // Code                
+		// e.g. 
+		// 007F..009F    
+        // 00AD          
+
+		info = parse (curr, last,
+            (
+            // start code
+			(hex_p [assign_a (first_code)] >> ".." >>
+			// end code
+			hex_p [assign_a (last_code)])
+            |
+            // single code
+            (hex_p [assign_a (first_code)][assign_a (last_code)])
+            )
+            >> 
+			// Skip any remaining entries, i.e., parse future versions
+			// of the table as well.
+			//*(anychar_p - ('#' | eol_p))
+            *(anychar_p - eol_p)
+			, blank_p);
+
+		if (!info.hit)
+		{
+			throw syntax_error (filename, curr, last);
+		}
+		curr = info.stop;
+
+		eat_comments (curr, last);
+
+		// now process from first to last putting the composition exclusion into the character data
+        if (progress-- <= 0)
+		{
+			progress = PROGRESS_INDICATION_EVERY;
+			std::cout << ".";
+		}
+
+		char32 curr_code = first_code;
+
+		do
+		{
+			std::map <char32, character_properties>::iterator prop = props.find (curr_code);
+			if (prop == props.end())
+			{
+				std::stringstream ss;
+				ss << "codepoint 0x" << std::hex << curr_code
+					<< " is in CompositionExclusions, but not in UnicodeData.txt while processing "
+					<< filename;
+				throw std::runtime_error (ss.str());
+			} 
+            
+            prop->second.comp_ex = true;
+
+            ++ curr_code;
+		}
+		while (curr_code <= last_code);
+
+	} while (curr != last);
+	std::cout << "\n";
+
+	std::cout << "-Reading composition exclusions from " << filename << "\n";
+}
+
+}}}	// namespaces

Modified: sandbox/SOC/2009/unicode/libs/unicode/data_parser/read_character_properties_files.hpp
==============================================================================
--- sandbox/SOC/2009/unicode/libs/unicode/data_parser/read_character_properties_files.hpp	(original)
+++ sandbox/SOC/2009/unicode/libs/unicode/data_parser/read_character_properties_files.hpp	2009-08-06 03:26:39 EDT (Thu, 06 Aug 2009)
@@ -17,6 +17,7 @@
 UNIDATA/LineBreak.txt
 UNIDATA/ArabicShaping.txt
 UCA/allkeys.txt
+UNIDATA/CompositionExclusions.txt
 */
 
 #ifndef BOOST_UNICODE_READ_CHARACTER_PROPERTIES_FILES_HPP_INCLUDED
@@ -98,10 +99,14 @@
                         void read_character_properties_sentence (
                                 std::map <char32, character_properties> & prop, const char* filename, bool required);
 
-            // Read from Allkeys.txt
+            /// Read from Allkeys.txt
             void read_collation_data (
                                 std::map <char32, character_properties> & props, 
                                 const char* filename, bool required);
+                                
+            /// Read from CompositionExclusions.txt
+            void read_character_properties_compex (
+                std::map <char32, character_properties> & prop, const char* filename, bool required);
 
 
                 }	// namespace ucd

Modified: sandbox/SOC/2009/unicode/libs/unicode/data_parser/write_character_properties.cpp
==============================================================================
--- sandbox/SOC/2009/unicode/libs/unicode/data_parser/write_character_properties.cpp	(original)
+++ sandbox/SOC/2009/unicode/libs/unicode/data_parser/write_character_properties.cpp	2009-08-06 03:26:39 EDT (Thu, 06 Aug 2009)
@@ -226,11 +226,12 @@
         std::stringstream ss;
         ss << "static const char32 __uni_decomp_data_0x" << std::hex << data.chr << "[] = { ";
         size_t size = data.decomposition.size();
+    ss << size << ", ";
         for (size_t n = 0; n < size; n++)
         {
                 ss << "0x" << std::hex << data.decomposition[n] << ", ";
         }
-	ss << "0, };\n";
+	ss << "};\n";
 
         // write the data to the file
         file << ss.str();
@@ -457,6 +458,7 @@
                 file << "#include \"uni_ucd_interface_impl_data_" << std::dec << (int)(n + 1) << ".ipp\"\n";
         }
         file << "#include \"uni_ucd_interface_impl_sort_data.ipp\"\n";
+    file << "#include \"uni_ucd_interface_impl_compose_data.ipp\"\n";
         file << "\n\nnamespace boost { namespace unicode { namespace ucd {\n\n";
 
         // ---- block table -------------------------------------------------------
@@ -944,7 +946,7 @@
                         data.tbl_decomp.push_back(decomp_entry(cp, props_char.decomposition));
                 }
 
-		// check for decompostion data
+		// check for complex case data
                 if (!props_char.complex_case.empty())
                 {
                         complex_case_index = (int)data.tbl_complex_case.size();
@@ -1141,6 +1143,7 @@
         }
         std::cout << "\n";
 
+    data.props = &props;
         std::cout << "-Preparing to write data\n";
 }
 
@@ -1205,7 +1208,7 @@
         file << "/**** This file is automatically generated and should not be modified.****/\n";
         file << "/**** Data in this file should not be accessed directly except        ****/\n";
         file << "/**** through the single published interface as documented in Boost   ****/\n";
-	file << "\n\nusing namespace boost::unicode;\n\n";
+	file << "\n\nusing namespace boost::unicode;\n";
         file << "\n\nnamespace boost { namespace unicode { namespace ucd {\n";
 
 #ifdef BOOST_UNICODE_UCD_BIG
@@ -1296,6 +1299,78 @@
         file.close();
 }
 
+struct lexico_sort
+{
+    bool operator()(const decomp_entry& lft, const decomp_entry& rgt) const
+    {
+        return std::lexicographical_compare(
+            lft.decomposition.begin(), lft.decomposition.end(),
+            rgt.decomposition.begin(), rgt.decomposition.end()
+        );
+    }
+};
+
+const character_properties& get_properties(const std::map<char32, character_properties>& props, char32 ch)
+{
+    std::map<char32, character_properties>::const_iterator it = props.find(ch);
+    if(it == props.end())
+    {
+		std::stringstream ss;
+		ss << "Code points associated with decomposition not found";
+		throw std::runtime_error (ss.str());
+    }
+    return it->second;
+}
+
+void write_compose(const write_data& data, const char * dest_path)
+{
+    std::cout << " writing "<< dest_path
+		<< "uni_ucd_interface_impl_compose_data.ipp\n";
+
+    // open file
+	std::stringstream fss;
+	fss << dest_path;
+	fss << "uni_ucd_interface_impl_compose_data.ipp";
+	std::fstream file;
+	file.open(fss.str().c_str(), std::ios_base::out);
+
+	write_license(file);
+	file << "/**** This file should not be included in any file manually           ****/\n";
+	file << "/**** This file is automatically generated and should not be modified.****/\n";
+	file << "/**** Data in this file should not be accessed directly except        ****/\n";
+	file << "/**** through the single published interface as documented in Boost   ****/\n";
+	file << "\n\nusing namespace boost::unicode;\n";
+	file << "\n\nnamespace boost { namespace unicode { namespace ucd {\n";
+
+	// ---- compose data table ------------------------------------------------------
+    
+    std::vector<decomp_entry> tmp = data.tbl_decomp;
+    std::sort(tmp.begin(), tmp.end(), lexico_sort());
+
+    file << "\nBOOST_UNICODE_DECL extern const unichar_compose_data_entry __uni_compose_entry[] = {\n";
+    
+    for(std::vector<decomp_entry>::const_iterator it = tmp.begin(); it != tmp.end(); ++it)
+    {
+        /* We exclude singletons, decompositions that start with non-starters, and code points from the exclusion table */
+        if(
+            it->decomposition.size() > 1
+        && get_properties(*data.props, it->decomposition[0]).combining == 0
+        && !get_properties(*data.props, it->chr).comp_ex
+        )
+            file << "\t{__uni_decomp_data_0x" << std::hex << it->chr << ", 0x" << it->chr << "},\n";
+    }
+    
+    file << "};\n\n";
+    file << "BOOST_UNICODE_DECL extern const size_t __uni_compose_entry_size = sizeof __uni_compose_entry / sizeof __uni_compose_entry[0];\n\n";
+
+    // ----------------------------------------------------------------------------
+    
+    file << "}}}  // namespaces\n\n";
+	
+	file.flush();
+	file.close();
+}
+
 /*******************************************************************
 ** write
 ** Writes the blocks to the output file
@@ -1366,6 +1441,7 @@
         write_block_tables_and_blocks(blocks, data.tbl_block_ident, dest_path, file_index);
         write_block_enum(blocks, dest_path_ucd_props);
     write_sort(data, dest_path);
+    write_compose(data, dest_path);
 
         std::cout << "-Writing data\n";
 }

Modified: sandbox/SOC/2009/unicode/libs/unicode/data_parser/write_character_properties.hpp
==============================================================================
--- sandbox/SOC/2009/unicode/libs/unicode/data_parser/write_character_properties.hpp	(original)
+++ sandbox/SOC/2009/unicode/libs/unicode/data_parser/write_character_properties.hpp	2009-08-06 03:26:39 EDT (Thu, 06 Aug 2009)
@@ -81,7 +81,6 @@
         decomp_entry();
         decomp_entry(char32 ch, const std::vector<char32>& decomp);
 
-private:
         char32				chr;
         std::vector<char32>	decomposition;
 
@@ -151,6 +150,8 @@
     // vector of tuple where first is cp for comments, and second are following chrs
     std::vector<tuple<char32, bool, char32> > tbl_sort_following_chars;
     std::vector<tuple<char32, sort_data_entry> > tbl_sort_entries;
+    
+    const std::map<char32, character_properties>* props;
 };
 
 // prepare to write the data out

Modified: sandbox/SOC/2009/unicode/libs/unicode/doc/Jamfile.v2
==============================================================================
--- sandbox/SOC/2009/unicode/libs/unicode/doc/Jamfile.v2	(original)
+++ sandbox/SOC/2009/unicode/libs/unicode/doc/Jamfile.v2	2009-08-06 03:26:39 EDT (Thu, 06 Aug 2009)
@@ -40,6 +40,7 @@
         <doxygen:param>ENABLE_PREPROCESSING=YES
         <doxygen:param>MACRO_EXPANSION=YES
 #        <doxygen:param>EXPAND_ONLY_PREDEF=YES
-#        <doxygen:param>SEARCH_INCLUDES=YES
-#        <doxygen:param>INCLUDE_PATH=$(BOOST_ROOT)
+        <doxygen:param>SEARCH_INCLUDES=YES
+        <doxygen:param>"INCLUDE_PATH=$(BOOST_ROOT) \\
+                                     ../../../"
         ;

Modified: sandbox/SOC/2009/unicode/libs/unicode/example/compose.cpp
==============================================================================
--- sandbox/SOC/2009/unicode/libs/unicode/example/compose.cpp	(original)
+++ sandbox/SOC/2009/unicode/libs/unicode/example/compose.cpp	2009-08-06 03:26:39 EDT (Thu, 06 Aug 2009)
@@ -1,34 +1,63 @@
 //[ compose
 #include <boost/unicode/compose.hpp>
+#include <boost/foreach.hpp>
+#include <boost/range/as_array.hpp>
 #include <iostream>
 #include <iterator>
 
 namespace unicode = boost::unicode;
 namespace ucd = unicode::ucd;
 
+namespace boost
+{
+    
+template<typename T>
+iterator_range<T*> list_of(T& t)
+{
+    return make_iterator_range(&t, &t+1);
+}
+
+template<typename T>
+iterator_range<const T*> list_of(const T& t)
+{
+    return make_iterator_range(&t, &t+1);
+}
+
+}
+
 int main()
 {
     boost::char32 cp = 0x1E17;
     
     std::cout << "Decomposition of U+01E17 within the UCD: ";
-    for(const boost::char32* p = ucd::get_decomposition(cp); *p; ++p)
-        std::cout << "0x" << std::hex << *p << ' ';
+    BOOST_FOREACH(boost::char32 c, ucd::get_decomposition(cp))
+        std::cout << "0x" << std::hex << c << ' ';
     std::cout << std::endl;
     std::cout << "Decomposition type: " << as_string(ucd::get_decomposition_type(cp)) << std::endl;
-    std::cout << std::endl;
-    
-    unicode::decomposer<> canon_decomp;
-    unicode::decomposer<UINT_MAX> compat_decomp;
     
     std::cout << "Canonical decomposition: ";
-    canon_decomp(cp, std::ostream_iterator<boost::char32>(std::cout, " "));
+    unicode::decompose(boost::list_of(cp), std::ostream_iterator<boost::char32>(std::cout, " "));
     std::cout << std::endl << std::endl;
     
     std::cout << "Canonical decomposition of U+00A8: ";
-    canon_decomp(0xA8, std::ostream_iterator<boost::char32>(std::cout, " "));
+    unicode::decompose(boost::list_of(0xA8), std::ostream_iterator<boost::char32>(std::cout, " "));
     std::cout << std::endl;
     std::cout << "Compatibility decomposition of U+00A8: ";
-    compat_decomp(0xA8, std::ostream_iterator<boost::char32>(std::cout, " "));
+    unicode::decompose(boost::list_of(0xA8), std::ostream_iterator<boost::char32>(std::cout, " "), UINT_MAX);
+    std::cout << std::endl;
+    std::cout << std::endl;
+    
+    boost::char32 foo[] = { 0x113, 0x301 };
+    std::cout << "Canonical composition of { " << boost::as_array(foo) << " }: ";
+    unicode::compose(foo, std::ostream_iterator<boost::char32>(std::cout, " "));
+    std::cout << std::endl;
+    
+    boost::char32 bar[] = { 0x20, 0x308 };
+    std::cout << "Canonical composition of { " << boost::as_array(bar) << " }: ";
+    unicode::compose(bar, std::ostream_iterator<boost::char32>(std::cout, " "));
+    std::cout << std::endl;
+    std::cout << "Compatibility composition of { " << boost::as_array(bar) << " }: ";
+    unicode::compose(bar, std::ostream_iterator<boost::char32>(std::cout, " "), UINT_MAX);
     std::cout << std::endl;
 }
 //]

Added: sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_compose_data.ipp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_compose_data.ipp	2009-08-06 03:26:39 EDT (Thu, 06 Aug 2009)
@@ -0,0 +1,2040 @@
+// Though this file is under the Boost license, it is NOT (or not yet) part of
+// Boost!
+
+// Copyright Graham Barnett, Rogier van Dalen 2005.
+// Use, modification, and distribution are subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// This file was created using information from the
+// www.unicode.org web site
+// License http://www.unicode.org/copyright.html 
+
+/**** This file should not be included in any file manually           ****/
+/**** This file is automatically generated and should not be modified.****/
+/**** Data in this file should not be accessed directly except        ****/
+/**** through the single published interface as documented in Boost   ****/
+
+
+using namespace boost::unicode;
+
+
+namespace boost { namespace unicode { namespace ucd {
+
+BOOST_UNICODE_DECL extern const unichar_compose_data_entry __uni_compose_entry[] = {
+	{__uni_decomp_data_0xb4, 0xb4},
+	{__uni_decomp_data_0x384, 0x384},
+	{__uni_decomp_data_0x2dc, 0x2dc},
+	{__uni_decomp_data_0xaf, 0xaf},
+	{__uni_decomp_data_0x203e, 0x203e},
+	{__uni_decomp_data_0x2d8, 0x2d8},
+	{__uni_decomp_data_0x2d9, 0x2d9},
+	{__uni_decomp_data_0xa8, 0xa8},
+	{__uni_decomp_data_0x2da, 0x2da},
+	{__uni_decomp_data_0x2dd, 0x2dd},
+	{__uni_decomp_data_0x1fbf, 0x1fbf},
+	{__uni_decomp_data_0x1fbd, 0x1fbd},
+	{__uni_decomp_data_0x1ffe, 0x1ffe},
+	{__uni_decomp_data_0xb8, 0xb8},
+	{__uni_decomp_data_0x2db, 0x2db},
+	{__uni_decomp_data_0x2017, 0x2017},
+	{__uni_decomp_data_0x1fc0, 0x1fc0},
+	{__uni_decomp_data_0x37a, 0x37a},
+	{__uni_decomp_data_0xfe70, 0xfe70},
+	{__uni_decomp_data_0xfe72, 0xfe72},
+	{__uni_decomp_data_0xfc5e, 0xfc5e},
+	{__uni_decomp_data_0xfe74, 0xfe74},
+	{__uni_decomp_data_0xfc5f, 0xfc5f},
+	{__uni_decomp_data_0xfe76, 0xfe76},
+	{__uni_decomp_data_0xfc60, 0xfc60},
+	{__uni_decomp_data_0xfe78, 0xfe78},
+	{__uni_decomp_data_0xfc61, 0xfc61},
+	{__uni_decomp_data_0xfe7a, 0xfe7a},
+	{__uni_decomp_data_0xfc62, 0xfc62},
+	{__uni_decomp_data_0xfe7c, 0xfe7c},
+	{__uni_decomp_data_0xfc63, 0xfc63},
+	{__uni_decomp_data_0xfe7e, 0xfe7e},
+	{__uni_decomp_data_0x309b, 0x309b},
+	{__uni_decomp_data_0x309c, 0x309c},
+	{__uni_decomp_data_0x203c, 0x203c},
+	{__uni_decomp_data_0x2049, 0x2049},
+	{__uni_decomp_data_0x2474, 0x2474},
+	{__uni_decomp_data_0x247d, 0x247d},
+	{__uni_decomp_data_0x247e, 0x247e},
+	{__uni_decomp_data_0x247f, 0x247f},
+	{__uni_decomp_data_0x2480, 0x2480},
+	{__uni_decomp_data_0x2481, 0x2481},
+	{__uni_decomp_data_0x2482, 0x2482},
+	{__uni_decomp_data_0x2483, 0x2483},
+	{__uni_decomp_data_0x2484, 0x2484},
+	{__uni_decomp_data_0x2485, 0x2485},
+	{__uni_decomp_data_0x2486, 0x2486},
+	{__uni_decomp_data_0x2475, 0x2475},
+	{__uni_decomp_data_0x2487, 0x2487},
+	{__uni_decomp_data_0x2476, 0x2476},
+	{__uni_decomp_data_0x2477, 0x2477},
+	{__uni_decomp_data_0x2478, 0x2478},
+	{__uni_decomp_data_0x2479, 0x2479},
+	{__uni_decomp_data_0x247a, 0x247a},
+	{__uni_decomp_data_0x247b, 0x247b},
+	{__uni_decomp_data_0x247c, 0x247c},
+	{__uni_decomp_data_0x249c, 0x249c},
+	{__uni_decomp_data_0x249d, 0x249d},
+	{__uni_decomp_data_0x249e, 0x249e},
+	{__uni_decomp_data_0x249f, 0x249f},
+	{__uni_decomp_data_0x24a0, 0x24a0},
+	{__uni_decomp_data_0x24a1, 0x24a1},
+	{__uni_decomp_data_0x24a2, 0x24a2},
+	{__uni_decomp_data_0x24a3, 0x24a3},
+	{__uni_decomp_data_0x24a4, 0x24a4},
+	{__uni_decomp_data_0x24a5, 0x24a5},
+	{__uni_decomp_data_0x24a6, 0x24a6},
+	{__uni_decomp_data_0x24a7, 0x24a7},
+	{__uni_decomp_data_0x24a8, 0x24a8},
+	{__uni_decomp_data_0x24a9, 0x24a9},
+	{__uni_decomp_data_0x24aa, 0x24aa},
+	{__uni_decomp_data_0x24ab, 0x24ab},
+	{__uni_decomp_data_0x24ac, 0x24ac},
+	{__uni_decomp_data_0x24ad, 0x24ad},
+	{__uni_decomp_data_0x24ae, 0x24ae},
+	{__uni_decomp_data_0x24af, 0x24af},
+	{__uni_decomp_data_0x24b0, 0x24b0},
+	{__uni_decomp_data_0x24b1, 0x24b1},
+	{__uni_decomp_data_0x24b2, 0x24b2},
+	{__uni_decomp_data_0x24b3, 0x24b3},
+	{__uni_decomp_data_0x24b4, 0x24b4},
+	{__uni_decomp_data_0x24b5, 0x24b5},
+	{__uni_decomp_data_0x3200, 0x3200},
+	{__uni_decomp_data_0x320e, 0x320e},
+	{__uni_decomp_data_0x3201, 0x3201},
+	{__uni_decomp_data_0x320f, 0x320f},
+	{__uni_decomp_data_0x3202, 0x3202},
+	{__uni_decomp_data_0x3210, 0x3210},
+	{__uni_decomp_data_0x3203, 0x3203},
+	{__uni_decomp_data_0x3211, 0x3211},
+	{__uni_decomp_data_0x3204, 0x3204},
+	{__uni_decomp_data_0x3212, 0x3212},
+	{__uni_decomp_data_0x3205, 0x3205},
+	{__uni_decomp_data_0x3213, 0x3213},
+	{__uni_decomp_data_0x3206, 0x3206},
+	{__uni_decomp_data_0x3214, 0x3214},
+	{__uni_decomp_data_0x3207, 0x3207},
+	{__uni_decomp_data_0x3215, 0x3215},
+	{__uni_decomp_data_0x321d, 0x321d},
+	{__uni_decomp_data_0x321e, 0x321e},
+	{__uni_decomp_data_0x3208, 0x3208},
+	{__uni_decomp_data_0x3216, 0x3216},
+	{__uni_decomp_data_0x321c, 0x321c},
+	{__uni_decomp_data_0x3209, 0x3209},
+	{__uni_decomp_data_0x3217, 0x3217},
+	{__uni_decomp_data_0x320a, 0x320a},
+	{__uni_decomp_data_0x3218, 0x3218},
+	{__uni_decomp_data_0x320b, 0x320b},
+	{__uni_decomp_data_0x3219, 0x3219},
+	{__uni_decomp_data_0x320c, 0x320c},
+	{__uni_decomp_data_0x321a, 0x321a},
+	{__uni_decomp_data_0x320d, 0x320d},
+	{__uni_decomp_data_0x321b, 0x321b},
+	{__uni_decomp_data_0x3220, 0x3220},
+	{__uni_decomp_data_0x3226, 0x3226},
+	{__uni_decomp_data_0x3222, 0x3222},
+	{__uni_decomp_data_0x3228, 0x3228},
+	{__uni_decomp_data_0x3221, 0x3221},
+	{__uni_decomp_data_0x3224, 0x3224},
+	{__uni_decomp_data_0x3239, 0x3239},
+	{__uni_decomp_data_0x323d, 0x323d},
+	{__uni_decomp_data_0x3241, 0x3241},
+	{__uni_decomp_data_0x3227, 0x3227},
+	{__uni_decomp_data_0x3225, 0x3225},
+	{__uni_decomp_data_0x3238, 0x3238},
+	{__uni_decomp_data_0x3229, 0x3229},
+	{__uni_decomp_data_0x323f, 0x323f},
+	{__uni_decomp_data_0x3234, 0x3234},
+	{__uni_decomp_data_0x323a, 0x323a},
+	{__uni_decomp_data_0x3223, 0x3223},
+	{__uni_decomp_data_0x322f, 0x322f},
+	{__uni_decomp_data_0x323b, 0x323b},
+	{__uni_decomp_data_0x3230, 0x3230},
+	{__uni_decomp_data_0x322a, 0x322a},
+	{__uni_decomp_data_0x3232, 0x3232},
+	{__uni_decomp_data_0x322d, 0x322d},
+	{__uni_decomp_data_0x3231, 0x3231},
+	{__uni_decomp_data_0x322c, 0x322c},
+	{__uni_decomp_data_0x322b, 0x322b},
+	{__uni_decomp_data_0x3235, 0x3235},
+	{__uni_decomp_data_0x323c, 0x323c},
+	{__uni_decomp_data_0x3233, 0x3233},
+	{__uni_decomp_data_0x3237, 0x3237},
+	{__uni_decomp_data_0x3240, 0x3240},
+	{__uni_decomp_data_0x3242, 0x3242},
+	{__uni_decomp_data_0x3243, 0x3243},
+	{__uni_decomp_data_0x3236, 0x3236},
+	{__uni_decomp_data_0x323e, 0x323e},
+	{__uni_decomp_data_0x322e, 0x322e},
+	{__uni_decomp_data_0x2025, 0x2025},
+	{__uni_decomp_data_0x2026, 0x2026},
+	{__uni_decomp_data_0x3358, 0x3358},
+	{__uni_decomp_data_0x2488, 0x2488},
+	{__uni_decomp_data_0x2469, 0x2469},
+	{__uni_decomp_data_0x2491, 0x2491},
+	{__uni_decomp_data_0x33e9, 0x33e9},
+	{__uni_decomp_data_0x32c9, 0x32c9},
+	{__uni_decomp_data_0x3362, 0x3362},
+	{__uni_decomp_data_0x246a, 0x246a},
+	{__uni_decomp_data_0x2492, 0x2492},
+	{__uni_decomp_data_0x33ea, 0x33ea},
+	{__uni_decomp_data_0x32ca, 0x32ca},
+	{__uni_decomp_data_0x3363, 0x3363},
+	{__uni_decomp_data_0x246b, 0x246b},
+	{__uni_decomp_data_0x2493, 0x2493},
+	{__uni_decomp_data_0x33eb, 0x33eb},
+	{__uni_decomp_data_0x32cb, 0x32cb},
+	{__uni_decomp_data_0x3364, 0x3364},
+	{__uni_decomp_data_0x246c, 0x246c},
+	{__uni_decomp_data_0x2494, 0x2494},
+	{__uni_decomp_data_0x33ec, 0x33ec},
+	{__uni_decomp_data_0x3365, 0x3365},
+	{__uni_decomp_data_0x246d, 0x246d},
+	{__uni_decomp_data_0x2495, 0x2495},
+	{__uni_decomp_data_0x33ed, 0x33ed},
+	{__uni_decomp_data_0x3366, 0x3366},
+	{__uni_decomp_data_0x246e, 0x246e},
+	{__uni_decomp_data_0x2496, 0x2496},
+	{__uni_decomp_data_0x33ee, 0x33ee},
+	{__uni_decomp_data_0x3367, 0x3367},
+	{__uni_decomp_data_0x246f, 0x246f},
+	{__uni_decomp_data_0x2497, 0x2497},
+	{__uni_decomp_data_0x33ef, 0x33ef},
+	{__uni_decomp_data_0x3368, 0x3368},
+	{__uni_decomp_data_0x2470, 0x2470},
+	{__uni_decomp_data_0x2498, 0x2498},
+	{__uni_decomp_data_0x33f0, 0x33f0},
+	{__uni_decomp_data_0x3369, 0x3369},
+	{__uni_decomp_data_0x2471, 0x2471},
+	{__uni_decomp_data_0x2499, 0x2499},
+	{__uni_decomp_data_0x33f1, 0x33f1},
+	{__uni_decomp_data_0x336a, 0x336a},
+	{__uni_decomp_data_0x2472, 0x2472},
+	{__uni_decomp_data_0x249a, 0x249a},
+	{__uni_decomp_data_0x33f2, 0x33f2},
+	{__uni_decomp_data_0x336b, 0x336b},
+	{__uni_decomp_data_0x215f, 0x215f},
+	{__uni_decomp_data_0xbd, 0xbd},
+	{__uni_decomp_data_0x2153, 0x2153},
+	{__uni_decomp_data_0xbc, 0xbc},
+	{__uni_decomp_data_0x2155, 0x2155},
+	{__uni_decomp_data_0x2159, 0x2159},
+	{__uni_decomp_data_0x215b, 0x215b},
+	{__uni_decomp_data_0x33e0, 0x33e0},
+	{__uni_decomp_data_0x32c0, 0x32c0},
+	{__uni_decomp_data_0x3359, 0x3359},
+	{__uni_decomp_data_0x2489, 0x2489},
+	{__uni_decomp_data_0x2473, 0x2473},
+	{__uni_decomp_data_0x249b, 0x249b},
+	{__uni_decomp_data_0x33f3, 0x33f3},
+	{__uni_decomp_data_0x336c, 0x336c},
+	{__uni_decomp_data_0x3251, 0x3251},
+	{__uni_decomp_data_0x33f4, 0x33f4},
+	{__uni_decomp_data_0x336d, 0x336d},
+	{__uni_decomp_data_0x3252, 0x3252},
+	{__uni_decomp_data_0x33f5, 0x33f5},
+	{__uni_decomp_data_0x336e, 0x336e},
+	{__uni_decomp_data_0x3253, 0x3253},
+	{__uni_decomp_data_0x33f6, 0x33f6},
+	{__uni_decomp_data_0x336f, 0x336f},
+	{__uni_decomp_data_0x3254, 0x3254},
+	{__uni_decomp_data_0x33f7, 0x33f7},
+	{__uni_decomp_data_0x3370, 0x3370},
+	{__uni_decomp_data_0x3255, 0x3255},
+	{__uni_decomp_data_0x33f8, 0x33f8},
+	{__uni_decomp_data_0x3256, 0x3256},
+	{__uni_decomp_data_0x33f9, 0x33f9},
+	{__uni_decomp_data_0x3257, 0x3257},
+	{__uni_decomp_data_0x33fa, 0x33fa},
+	{__uni_decomp_data_0x3258, 0x3258},
+	{__uni_decomp_data_0x33fb, 0x33fb},
+	{__uni_decomp_data_0x3259, 0x3259},
+	{__uni_decomp_data_0x33fc, 0x33fc},
+	{__uni_decomp_data_0x2154, 0x2154},
+	{__uni_decomp_data_0x2156, 0x2156},
+	{__uni_decomp_data_0x33e1, 0x33e1},
+	{__uni_decomp_data_0x32c1, 0x32c1},
+	{__uni_decomp_data_0x335a, 0x335a},
+	{__uni_decomp_data_0x248a, 0x248a},
+	{__uni_decomp_data_0x325a, 0x325a},
+	{__uni_decomp_data_0x33fd, 0x33fd},
+	{__uni_decomp_data_0x325b, 0x325b},
+	{__uni_decomp_data_0x33fe, 0x33fe},
+	{__uni_decomp_data_0x325c, 0x325c},
+	{__uni_decomp_data_0x325d, 0x325d},
+	{__uni_decomp_data_0x325e, 0x325e},
+	{__uni_decomp_data_0x325f, 0x325f},
+	{__uni_decomp_data_0x32b1, 0x32b1},
+	{__uni_decomp_data_0x32b2, 0x32b2},
+	{__uni_decomp_data_0x32b3, 0x32b3},
+	{__uni_decomp_data_0x32b4, 0x32b4},
+	{__uni_decomp_data_0xbe, 0xbe},
+	{__uni_decomp_data_0x2157, 0x2157},
+	{__uni_decomp_data_0x215c, 0x215c},
+	{__uni_decomp_data_0x33e2, 0x33e2},
+	{__uni_decomp_data_0x32c2, 0x32c2},
+	{__uni_decomp_data_0x335b, 0x335b},
+	{__uni_decomp_data_0x248b, 0x248b},
+	{__uni_decomp_data_0x32b5, 0x32b5},
+	{__uni_decomp_data_0x32b6, 0x32b6},
+	{__uni_decomp_data_0x32b7, 0x32b7},
+	{__uni_decomp_data_0x32b8, 0x32b8},
+	{__uni_decomp_data_0x32b9, 0x32b9},
+	{__uni_decomp_data_0x32ba, 0x32ba},
+	{__uni_decomp_data_0x32bb, 0x32bb},
+	{__uni_decomp_data_0x32bc, 0x32bc},
+	{__uni_decomp_data_0x32bd, 0x32bd},
+	{__uni_decomp_data_0x32be, 0x32be},
+	{__uni_decomp_data_0x2158, 0x2158},
+	{__uni_decomp_data_0x33e3, 0x33e3},
+	{__uni_decomp_data_0x32c3, 0x32c3},
+	{__uni_decomp_data_0x335c, 0x335c},
+	{__uni_decomp_data_0x248c, 0x248c},
+	{__uni_decomp_data_0x32bf, 0x32bf},
+	{__uni_decomp_data_0x215a, 0x215a},
+	{__uni_decomp_data_0x215d, 0x215d},
+	{__uni_decomp_data_0x33e4, 0x33e4},
+	{__uni_decomp_data_0x32c4, 0x32c4},
+	{__uni_decomp_data_0x335d, 0x335d},
+	{__uni_decomp_data_0x248d, 0x248d},
+	{__uni_decomp_data_0x33e5, 0x33e5},
+	{__uni_decomp_data_0x32c5, 0x32c5},
+	{__uni_decomp_data_0x335e, 0x335e},
+	{__uni_decomp_data_0x248e, 0x248e},
+	{__uni_decomp_data_0x215e, 0x215e},
+	{__uni_decomp_data_0x33e6, 0x33e6},
+	{__uni_decomp_data_0x32c6, 0x32c6},
+	{__uni_decomp_data_0x335f, 0x335f},
+	{__uni_decomp_data_0x248f, 0x248f},
+	{__uni_decomp_data_0x33e7, 0x33e7},
+	{__uni_decomp_data_0x32c7, 0x32c7},
+	{__uni_decomp_data_0x3360, 0x3360},
+	{__uni_decomp_data_0x2490, 0x2490},
+	{__uni_decomp_data_0x33e8, 0x33e8},
+	{__uni_decomp_data_0x32c8, 0x32c8},
+	{__uni_decomp_data_0x3361, 0x3361},
+	{__uni_decomp_data_0x2a74, 0x2a74},
+	{__uni_decomp_data_0x226e, 0x226e},
+	{__uni_decomp_data_0x2a75, 0x2a75},
+	{__uni_decomp_data_0x2a76, 0x2a76},
+	{__uni_decomp_data_0x2260, 0x2260},
+	{__uni_decomp_data_0x226f, 0x226f},
+	{__uni_decomp_data_0x2048, 0x2048},
+	{__uni_decomp_data_0x2047, 0x2047},
+	{__uni_decomp_data_0x3373, 0x3373},
+	{__uni_decomp_data_0xc0, 0xc0},
+	{__uni_decomp_data_0xc1, 0xc1},
+	{__uni_decomp_data_0xc2, 0xc2},
+	{__uni_decomp_data_0xc3, 0xc3},
+	{__uni_decomp_data_0x100, 0x100},
+	{__uni_decomp_data_0x102, 0x102},
+	{__uni_decomp_data_0x226, 0x226},
+	{__uni_decomp_data_0xc4, 0xc4},
+	{__uni_decomp_data_0x1ea2, 0x1ea2},
+	{__uni_decomp_data_0xc5, 0xc5},
+	{__uni_decomp_data_0x1cd, 0x1cd},
+	{__uni_decomp_data_0x200, 0x200},
+	{__uni_decomp_data_0x202, 0x202},
+	{__uni_decomp_data_0x1ea0, 0x1ea0},
+	{__uni_decomp_data_0x1e00, 0x1e00},
+	{__uni_decomp_data_0x104, 0x104},
+	{__uni_decomp_data_0x33df, 0x33df},
+	{__uni_decomp_data_0x33c3, 0x33c3},
+	{__uni_decomp_data_0x1e02, 0x1e02},
+	{__uni_decomp_data_0x1e04, 0x1e04},
+	{__uni_decomp_data_0x1e06, 0x1e06},
+	{__uni_decomp_data_0x33c7, 0x33c7},
+	{__uni_decomp_data_0x106, 0x106},
+	{__uni_decomp_data_0x108, 0x108},
+	{__uni_decomp_data_0x10a, 0x10a},
+	{__uni_decomp_data_0x10c, 0x10c},
+	{__uni_decomp_data_0xc7, 0xc7},
+	{__uni_decomp_data_0x33c6, 0x33c6},
+	{__uni_decomp_data_0x1f1, 0x1f1},
+	{__uni_decomp_data_0x1f2, 0x1f2},
+	{__uni_decomp_data_0x1c4, 0x1c4},
+	{__uni_decomp_data_0x1c5, 0x1c5},
+	{__uni_decomp_data_0x1e0a, 0x1e0a},
+	{__uni_decomp_data_0x10e, 0x10e},
+	{__uni_decomp_data_0x1e0c, 0x1e0c},
+	{__uni_decomp_data_0x1e10, 0x1e10},
+	{__uni_decomp_data_0x1e12, 0x1e12},
+	{__uni_decomp_data_0x1e0e, 0x1e0e},
+	{__uni_decomp_data_0xc8, 0xc8},
+	{__uni_decomp_data_0xc9, 0xc9},
+	{__uni_decomp_data_0xca, 0xca},
+	{__uni_decomp_data_0x1ebc, 0x1ebc},
+	{__uni_decomp_data_0x112, 0x112},
+	{__uni_decomp_data_0x114, 0x114},
+	{__uni_decomp_data_0x116, 0x116},
+	{__uni_decomp_data_0xcb, 0xcb},
+	{__uni_decomp_data_0x1eba, 0x1eba},
+	{__uni_decomp_data_0x11a, 0x11a},
+	{__uni_decomp_data_0x204, 0x204},
+	{__uni_decomp_data_0x206, 0x206},
+	{__uni_decomp_data_0x1eb8, 0x1eb8},
+	{__uni_decomp_data_0x228, 0x228},
+	{__uni_decomp_data_0x118, 0x118},
+	{__uni_decomp_data_0x1e18, 0x1e18},
+	{__uni_decomp_data_0x1e1a, 0x1e1a},
+	{__uni_decomp_data_0x213b, 0x213b},
+	{__uni_decomp_data_0x1e1e, 0x1e1e},
+	{__uni_decomp_data_0x3387, 0x3387},
+	{__uni_decomp_data_0x3393, 0x3393},
+	{__uni_decomp_data_0x33ac, 0x33ac},
+	{__uni_decomp_data_0x33c9, 0x33c9},
+	{__uni_decomp_data_0x1f4, 0x1f4},
+	{__uni_decomp_data_0x11c, 0x11c},
+	{__uni_decomp_data_0x1e20, 0x1e20},
+	{__uni_decomp_data_0x11e, 0x11e},
+	{__uni_decomp_data_0x120, 0x120},
+	{__uni_decomp_data_0x1e6, 0x1e6},
+	{__uni_decomp_data_0x122, 0x122},
+	{__uni_decomp_data_0x33cb, 0x33cb},
+	{__uni_decomp_data_0x32cc, 0x32cc},
+	{__uni_decomp_data_0x3390, 0x3390},
+	{__uni_decomp_data_0x124, 0x124},
+	{__uni_decomp_data_0x1e22, 0x1e22},
+	{__uni_decomp_data_0x1e26, 0x1e26},
+	{__uni_decomp_data_0x21e, 0x21e},
+	{__uni_decomp_data_0x1e24, 0x1e24},
+	{__uni_decomp_data_0x1e28, 0x1e28},
+	{__uni_decomp_data_0x1e2a, 0x1e2a},
+	{__uni_decomp_data_0x2161, 0x2161},
+	{__uni_decomp_data_0x2162, 0x2162},
+	{__uni_decomp_data_0x132, 0x132},
+	{__uni_decomp_data_0x337a, 0x337a},
+	{__uni_decomp_data_0x2163, 0x2163},
+	{__uni_decomp_data_0x2168, 0x2168},
+	{__uni_decomp_data_0xcc, 0xcc},
+	{__uni_decomp_data_0xcd, 0xcd},
+	{__uni_decomp_data_0xce, 0xce},
+	{__uni_decomp_data_0x128, 0x128},
+	{__uni_decomp_data_0x12a, 0x12a},
+	{__uni_decomp_data_0x12c, 0x12c},
+	{__uni_decomp_data_0x130, 0x130},
+	{__uni_decomp_data_0xcf, 0xcf},
+	{__uni_decomp_data_0x1ec8, 0x1ec8},
+	{__uni_decomp_data_0x1cf, 0x1cf},
+	{__uni_decomp_data_0x208, 0x208},
+	{__uni_decomp_data_0x20a, 0x20a},
+	{__uni_decomp_data_0x1eca, 0x1eca},
+	{__uni_decomp_data_0x12e, 0x12e},
+	{__uni_decomp_data_0x1e2c, 0x1e2c},
+	{__uni_decomp_data_0x134, 0x134},
+	{__uni_decomp_data_0x3385, 0x3385},
+	{__uni_decomp_data_0x33cd, 0x33cd},
+	{__uni_decomp_data_0x33ce, 0x33ce},
+	{__uni_decomp_data_0x1e30, 0x1e30},
+	{__uni_decomp_data_0x1e8, 0x1e8},
+	{__uni_decomp_data_0x1e32, 0x1e32},
+	{__uni_decomp_data_0x136, 0x136},
+	{__uni_decomp_data_0x1e34, 0x1e34},
+	{__uni_decomp_data_0x1c7, 0x1c7},
+	{__uni_decomp_data_0x32cf, 0x32cf},
+	{__uni_decomp_data_0x1c8, 0x1c8},
+	{__uni_decomp_data_0x13f, 0x13f},
+	{__uni_decomp_data_0x139, 0x139},
+	{__uni_decomp_data_0x13d, 0x13d},
+	{__uni_decomp_data_0x1e36, 0x1e36},
+	{__uni_decomp_data_0x13b, 0x13b},
+	{__uni_decomp_data_0x1e3c, 0x1e3c},
+	{__uni_decomp_data_0x1e3a, 0x1e3a},
+	{__uni_decomp_data_0x3386, 0x3386},
+	{__uni_decomp_data_0x3392, 0x3392},
+	{__uni_decomp_data_0x33ab, 0x33ab},
+	{__uni_decomp_data_0x33b9, 0x33b9},
+	{__uni_decomp_data_0x33bf, 0x33bf},
+	{__uni_decomp_data_0x1e3e, 0x1e3e},
+	{__uni_decomp_data_0x1e40, 0x1e40},
+	{__uni_decomp_data_0x1e42, 0x1e42},
+	{__uni_decomp_data_0x33c1, 0x33c1},
+	{__uni_decomp_data_0x1ca, 0x1ca},
+	{__uni_decomp_data_0x1cb, 0x1cb},
+	{__uni_decomp_data_0x2116, 0x2116},
+	{__uni_decomp_data_0x1f8, 0x1f8},
+	{__uni_decomp_data_0x143, 0x143},
+	{__uni_decomp_data_0xd1, 0xd1},
+	{__uni_decomp_data_0x1e44, 0x1e44},
+	{__uni_decomp_data_0x147, 0x147},
+	{__uni_decomp_data_0x1e46, 0x1e46},
+	{__uni_decomp_data_0x145, 0x145},
+	{__uni_decomp_data_0x1e4a, 0x1e4a},
+	{__uni_decomp_data_0x1e48, 0x1e48},
+	{__uni_decomp_data_0xd2, 0xd2},
+	{__uni_decomp_data_0xd3, 0xd3},
+	{__uni_decomp_data_0xd4, 0xd4},
+	{__uni_decomp_data_0xd5, 0xd5},
+	{__uni_decomp_data_0x14c, 0x14c},
+	{__uni_decomp_data_0x14e, 0x14e},
+	{__uni_decomp_data_0x22e, 0x22e},
+	{__uni_decomp_data_0xd6, 0xd6},
+	{__uni_decomp_data_0x1ece, 0x1ece},
+	{__uni_decomp_data_0x150, 0x150},
+	{__uni_decomp_data_0x1d1, 0x1d1},
+	{__uni_decomp_data_0x20c, 0x20c},
+	{__uni_decomp_data_0x20e, 0x20e},
+	{__uni_decomp_data_0x1a0, 0x1a0},
+	{__uni_decomp_data_0x1ecc, 0x1ecc},
+	{__uni_decomp_data_0x1ea, 0x1ea},
+	{__uni_decomp_data_0x33d7, 0x33d7},
+	{__uni_decomp_data_0x33d9, 0x33d9},
+	{__uni_decomp_data_0x33da, 0x33da},
+	{__uni_decomp_data_0x3250, 0x3250},
+	{__uni_decomp_data_0x33a9, 0x33a9},
+	{__uni_decomp_data_0x1e54, 0x1e54},
+	{__uni_decomp_data_0x1e56, 0x1e56},
+	{__uni_decomp_data_0x20a8, 0x20a8},
+	{__uni_decomp_data_0x154, 0x154},
+	{__uni_decomp_data_0x1e58, 0x1e58},
+	{__uni_decomp_data_0x158, 0x158},
+	{__uni_decomp_data_0x210, 0x210},
+	{__uni_decomp_data_0x212, 0x212},
+	{__uni_decomp_data_0x1e5a, 0x1e5a},
+	{__uni_decomp_data_0x156, 0x156},
+	{__uni_decomp_data_0x1e5e, 0x1e5e},
+	{__uni_decomp_data_0x2120, 0x2120},
+	{__uni_decomp_data_0x33dc, 0x33dc},
+	{__uni_decomp_data_0x15a, 0x15a},
+	{__uni_decomp_data_0x15c, 0x15c},
+	{__uni_decomp_data_0x1e60, 0x1e60},
+	{__uni_decomp_data_0x160, 0x160},
+	{__uni_decomp_data_0x1e62, 0x1e62},
+	{__uni_decomp_data_0x218, 0x218},
+	{__uni_decomp_data_0x15e, 0x15e},
+	{__uni_decomp_data_0x2121, 0x2121},
+	{__uni_decomp_data_0x3394, 0x3394},
+	{__uni_decomp_data_0x2122, 0x2122},
+	{__uni_decomp_data_0x1e6a, 0x1e6a},
+	{__uni_decomp_data_0x164, 0x164},
+	{__uni_decomp_data_0x1e6c, 0x1e6c},
+	{__uni_decomp_data_0x21a, 0x21a},
+	{__uni_decomp_data_0x162, 0x162},
+	{__uni_decomp_data_0x1e70, 0x1e70},
+	{__uni_decomp_data_0x1e6e, 0x1e6e},
+	{__uni_decomp_data_0xd9, 0xd9},
+	{__uni_decomp_data_0xda, 0xda},
+	{__uni_decomp_data_0xdb, 0xdb},
+	{__uni_decomp_data_0x168, 0x168},
+	{__uni_decomp_data_0x16a, 0x16a},
+	{__uni_decomp_data_0x16c, 0x16c},
+	{__uni_decomp_data_0xdc, 0xdc},
+	{__uni_decomp_data_0x1ee6, 0x1ee6},
+	{__uni_decomp_data_0x16e, 0x16e},
+	{__uni_decomp_data_0x170, 0x170},
+	{__uni_decomp_data_0x1d3, 0x1d3},
+	{__uni_decomp_data_0x214, 0x214},
+	{__uni_decomp_data_0x216, 0x216},
+	{__uni_decomp_data_0x1af, 0x1af},
+	{__uni_decomp_data_0x1ee4, 0x1ee4},
+	{__uni_decomp_data_0x1e72, 0x1e72},
+	{__uni_decomp_data_0x172, 0x172},
+	{__uni_decomp_data_0x1e76, 0x1e76},
+	{__uni_decomp_data_0x1e74, 0x1e74},
+	{__uni_decomp_data_0x2165, 0x2165},
+	{__uni_decomp_data_0x2166, 0x2166},
+	{__uni_decomp_data_0x2167, 0x2167},
+	{__uni_decomp_data_0x1e7c, 0x1e7c},
+	{__uni_decomp_data_0x1e7e, 0x1e7e},
+	{__uni_decomp_data_0x33de, 0x33de},
+	{__uni_decomp_data_0x33dd, 0x33dd},
+	{__uni_decomp_data_0x1e80, 0x1e80},
+	{__uni_decomp_data_0x1e82, 0x1e82},
+	{__uni_decomp_data_0x174, 0x174},
+	{__uni_decomp_data_0x1e86, 0x1e86},
+	{__uni_decomp_data_0x1e84, 0x1e84},
+	{__uni_decomp_data_0x1e88, 0x1e88},
+	{__uni_decomp_data_0x216a, 0x216a},
+	{__uni_decomp_data_0x216b, 0x216b},
+	{__uni_decomp_data_0x1e8a, 0x1e8a},
+	{__uni_decomp_data_0x1e8c, 0x1e8c},
+	{__uni_decomp_data_0x1ef2, 0x1ef2},
+	{__uni_decomp_data_0xdd, 0xdd},
+	{__uni_decomp_data_0x176, 0x176},
+	{__uni_decomp_data_0x1ef8, 0x1ef8},
+	{__uni_decomp_data_0x232, 0x232},
+	{__uni_decomp_data_0x1e8e, 0x1e8e},
+	{__uni_decomp_data_0x178, 0x178},
+	{__uni_decomp_data_0x1ef6, 0x1ef6},
+	{__uni_decomp_data_0x1ef4, 0x1ef4},
+	{__uni_decomp_data_0x179, 0x179},
+	{__uni_decomp_data_0x1e90, 0x1e90},
+	{__uni_decomp_data_0x17b, 0x17b},
+	{__uni_decomp_data_0x17d, 0x17d},
+	{__uni_decomp_data_0x1e92, 0x1e92},
+	{__uni_decomp_data_0x1e94, 0x1e94},
+	{__uni_decomp_data_0x33c2, 0x33c2},
+	{__uni_decomp_data_0x2100, 0x2100},
+	{__uni_decomp_data_0x2101, 0x2101},
+	{__uni_decomp_data_0x1e9a, 0x1e9a},
+	{__uni_decomp_data_0xe0, 0xe0},
+	{__uni_decomp_data_0xe1, 0xe1},
+	{__uni_decomp_data_0xe2, 0xe2},
+	{__uni_decomp_data_0xe3, 0xe3},
+	{__uni_decomp_data_0x101, 0x101},
+	{__uni_decomp_data_0x103, 0x103},
+	{__uni_decomp_data_0x227, 0x227},
+	{__uni_decomp_data_0xe4, 0xe4},
+	{__uni_decomp_data_0x1ea3, 0x1ea3},
+	{__uni_decomp_data_0xe5, 0xe5},
+	{__uni_decomp_data_0x1ce, 0x1ce},
+	{__uni_decomp_data_0x201, 0x201},
+	{__uni_decomp_data_0x203, 0x203},
+	{__uni_decomp_data_0x1ea1, 0x1ea1},
+	{__uni_decomp_data_0x1e01, 0x1e01},
+	{__uni_decomp_data_0x105, 0x105},
+	{__uni_decomp_data_0x3374, 0x3374},
+	{__uni_decomp_data_0x1e03, 0x1e03},
+	{__uni_decomp_data_0x1e05, 0x1e05},
+	{__uni_decomp_data_0x1e07, 0x1e07},
+	{__uni_decomp_data_0x2105, 0x2105},
+	{__uni_decomp_data_0x2106, 0x2106},
+	{__uni_decomp_data_0x3388, 0x3388},
+	{__uni_decomp_data_0x33c4, 0x33c4},
+	{__uni_decomp_data_0x33c5, 0x33c5},
+	{__uni_decomp_data_0x339d, 0x339d},
+	{__uni_decomp_data_0x33a0, 0x33a0},
+	{__uni_decomp_data_0x33a4, 0x33a4},
+	{__uni_decomp_data_0x107, 0x107},
+	{__uni_decomp_data_0x109, 0x109},
+	{__uni_decomp_data_0x10b, 0x10b},
+	{__uni_decomp_data_0x10d, 0x10d},
+	{__uni_decomp_data_0xe7, 0xe7},
+	{__uni_decomp_data_0x33c8, 0x33c8},
+	{__uni_decomp_data_0x3372, 0x3372},
+	{__uni_decomp_data_0x3377, 0x3377},
+	{__uni_decomp_data_0x3378, 0x3378},
+	{__uni_decomp_data_0x3379, 0x3379},
+	{__uni_decomp_data_0x1f3, 0x1f3},
+	{__uni_decomp_data_0x1c6, 0x1c6},
+	{__uni_decomp_data_0x1e0b, 0x1e0b},
+	{__uni_decomp_data_0x10f, 0x10f},
+	{__uni_decomp_data_0x1e0d, 0x1e0d},
+	{__uni_decomp_data_0x1e11, 0x1e11},
+	{__uni_decomp_data_0x1e13, 0x1e13},
+	{__uni_decomp_data_0x1e0f, 0x1e0f},
+	{__uni_decomp_data_0x3397, 0x3397},
+	{__uni_decomp_data_0x32ce, 0x32ce},
+	{__uni_decomp_data_0x32cd, 0x32cd},
+	{__uni_decomp_data_0xe8, 0xe8},
+	{__uni_decomp_data_0xe9, 0xe9},
+	{__uni_decomp_data_0xea, 0xea},
+	{__uni_decomp_data_0x1ebd, 0x1ebd},
+	{__uni_decomp_data_0x113, 0x113},
+	{__uni_decomp_data_0x115, 0x115},
+	{__uni_decomp_data_0x117, 0x117},
+	{__uni_decomp_data_0xeb, 0xeb},
+	{__uni_decomp_data_0x1ebb, 0x1ebb},
+	{__uni_decomp_data_0x11b, 0x11b},
+	{__uni_decomp_data_0x205, 0x205},
+	{__uni_decomp_data_0x207, 0x207},
+	{__uni_decomp_data_0x1eb9, 0x1eb9},
+	{__uni_decomp_data_0x229, 0x229},
+	{__uni_decomp_data_0x119, 0x119},
+	{__uni_decomp_data_0x1e19, 0x1e19},
+	{__uni_decomp_data_0x1e1b, 0x1e1b},
+	{__uni_decomp_data_0xfb00, 0xfb00},
+	{__uni_decomp_data_0xfb03, 0xfb03},
+	{__uni_decomp_data_0xfb04, 0xfb04},
+	{__uni_decomp_data_0xfb01, 0xfb01},
+	{__uni_decomp_data_0xfb02, 0xfb02},
+	{__uni_decomp_data_0x3399, 0x3399},
+	{__uni_decomp_data_0x1e1f, 0x1e1f},
+	{__uni_decomp_data_0x33ff, 0x33ff},
+	{__uni_decomp_data_0x1f5, 0x1f5},
+	{__uni_decomp_data_0x11d, 0x11d},
+	{__uni_decomp_data_0x1e21, 0x1e21},
+	{__uni_decomp_data_0x11f, 0x11f},
+	{__uni_decomp_data_0x121, 0x121},
+	{__uni_decomp_data_0x1e7, 0x1e7},
+	{__uni_decomp_data_0x123, 0x123},
+	{__uni_decomp_data_0x3371, 0x3371},
+	{__uni_decomp_data_0x33ca, 0x33ca},
+	{__uni_decomp_data_0x125, 0x125},
+	{__uni_decomp_data_0x1e23, 0x1e23},
+	{__uni_decomp_data_0x1e27, 0x1e27},
+	{__uni_decomp_data_0x21f, 0x21f},
+	{__uni_decomp_data_0x1e25, 0x1e25},
+	{__uni_decomp_data_0x1e29, 0x1e29},
+	{__uni_decomp_data_0x1e2b, 0x1e2b},
+	{__uni_decomp_data_0x1e96, 0x1e96},
+	{__uni_decomp_data_0x2171, 0x2171},
+	{__uni_decomp_data_0x2172, 0x2172},
+	{__uni_decomp_data_0x133, 0x133},
+	{__uni_decomp_data_0x33cc, 0x33cc},
+	{__uni_decomp_data_0x2173, 0x2173},
+	{__uni_decomp_data_0x2178, 0x2178},
+	{__uni_decomp_data_0xec, 0xec},
+	{__uni_decomp_data_0xed, 0xed},
+	{__uni_decomp_data_0xee, 0xee},
+	{__uni_decomp_data_0x129, 0x129},
+	{__uni_decomp_data_0x12b, 0x12b},
+	{__uni_decomp_data_0x12d, 0x12d},
+	{__uni_decomp_data_0xef, 0xef},
+	{__uni_decomp_data_0x1ec9, 0x1ec9},
+	{__uni_decomp_data_0x1d0, 0x1d0},
+	{__uni_decomp_data_0x209, 0x209},
+	{__uni_decomp_data_0x20b, 0x20b},
+	{__uni_decomp_data_0x1ecb, 0x1ecb},
+	{__uni_decomp_data_0x12f, 0x12f},
+	{__uni_decomp_data_0x1e2d, 0x1e2d},
+	{__uni_decomp_data_0x135, 0x135},
+	{__uni_decomp_data_0x1f0, 0x1f0},
+	{__uni_decomp_data_0x3384, 0x3384},
+	{__uni_decomp_data_0x3391, 0x3391},
+	{__uni_decomp_data_0x33aa, 0x33aa},
+	{__uni_decomp_data_0x33b8, 0x33b8},
+	{__uni_decomp_data_0x33be, 0x33be},
+	{__uni_decomp_data_0x3389, 0x3389},
+	{__uni_decomp_data_0x338f, 0x338f},
+	{__uni_decomp_data_0x339e, 0x339e},
+	{__uni_decomp_data_0x33a2, 0x33a2},
+	{__uni_decomp_data_0x33a6, 0x33a6},
+	{__uni_decomp_data_0x33cf, 0x33cf},
+	{__uni_decomp_data_0x1e31, 0x1e31},
+	{__uni_decomp_data_0x1e9, 0x1e9},
+	{__uni_decomp_data_0x1e33, 0x1e33},
+	{__uni_decomp_data_0x137, 0x137},
+	{__uni_decomp_data_0x1e35, 0x1e35},
+	{__uni_decomp_data_0x33c0, 0x33c0},
+	{__uni_decomp_data_0x3398, 0x3398},
+	{__uni_decomp_data_0x1c9, 0x1c9},
+	{__uni_decomp_data_0x33d0, 0x33d0},
+	{__uni_decomp_data_0x33d1, 0x33d1},
+	{__uni_decomp_data_0x33d2, 0x33d2},
+	{__uni_decomp_data_0x33d3, 0x33d3},
+	{__uni_decomp_data_0x140, 0x140},
+	{__uni_decomp_data_0x13a, 0x13a},
+	{__uni_decomp_data_0x13e, 0x13e},
+	{__uni_decomp_data_0x1e37, 0x1e37},
+	{__uni_decomp_data_0x13c, 0x13c},
+	{__uni_decomp_data_0x1e3d, 0x1e3d},
+	{__uni_decomp_data_0x1e3b, 0x1e3b},
+	{__uni_decomp_data_0x3383, 0x3383},
+	{__uni_decomp_data_0x33b7, 0x33b7},
+	{__uni_decomp_data_0x33bd, 0x33bd},
+	{__uni_decomp_data_0x33d4, 0x33d4},
+	{__uni_decomp_data_0x338e, 0x338e},
+	{__uni_decomp_data_0x33d5, 0x33d5},
+	{__uni_decomp_data_0x339c, 0x339c},
+	{__uni_decomp_data_0x339f, 0x339f},
+	{__uni_decomp_data_0x33a3, 0x33a3},
+	{__uni_decomp_data_0x33d6, 0x33d6},
+	{__uni_decomp_data_0x33b3, 0x33b3},
+	{__uni_decomp_data_0x33a1, 0x33a1},
+	{__uni_decomp_data_0x33a5, 0x33a5},
+	{__uni_decomp_data_0x1e3f, 0x1e3f},
+	{__uni_decomp_data_0x1e41, 0x1e41},
+	{__uni_decomp_data_0x1e43, 0x1e43},
+	{__uni_decomp_data_0x3396, 0x3396},
+	{__uni_decomp_data_0x33a7, 0x33a7},
+	{__uni_decomp_data_0x33a8, 0x33a8},
+	{__uni_decomp_data_0x3381, 0x3381},
+	{__uni_decomp_data_0x338b, 0x338b},
+	{__uni_decomp_data_0x33b5, 0x33b5},
+	{__uni_decomp_data_0x33bb, 0x33bb},
+	{__uni_decomp_data_0x1cc, 0x1cc},
+	{__uni_decomp_data_0x339a, 0x339a},
+	{__uni_decomp_data_0x33b1, 0x33b1},
+	{__uni_decomp_data_0x1f9, 0x1f9},
+	{__uni_decomp_data_0x144, 0x144},
+	{__uni_decomp_data_0xf1, 0xf1},
+	{__uni_decomp_data_0x1e45, 0x1e45},
+	{__uni_decomp_data_0x148, 0x148},
+	{__uni_decomp_data_0x1e47, 0x1e47},
+	{__uni_decomp_data_0x146, 0x146},
+	{__uni_decomp_data_0x1e4b, 0x1e4b},
+	{__uni_decomp_data_0x1e49, 0x1e49},
+	{__uni_decomp_data_0x3375, 0x3375},
+	{__uni_decomp_data_0xf2, 0xf2},
+	{__uni_decomp_data_0xf3, 0xf3},
+	{__uni_decomp_data_0xf4, 0xf4},
+	{__uni_decomp_data_0xf5, 0xf5},
+	{__uni_decomp_data_0x14d, 0x14d},
+	{__uni_decomp_data_0x14f, 0x14f},
+	{__uni_decomp_data_0x22f, 0x22f},
+	{__uni_decomp_data_0xf6, 0xf6},
+	{__uni_decomp_data_0x1ecf, 0x1ecf},
+	{__uni_decomp_data_0x151, 0x151},
+	{__uni_decomp_data_0x1d2, 0x1d2},
+	{__uni_decomp_data_0x20d, 0x20d},
+	{__uni_decomp_data_0x20f, 0x20f},
+	{__uni_decomp_data_0x1a1, 0x1a1},
+	{__uni_decomp_data_0x1ecd, 0x1ecd},
+	{__uni_decomp_data_0x1eb, 0x1eb},
+	{__uni_decomp_data_0x33d8, 0x33d8},
+	{__uni_decomp_data_0x3380, 0x3380},
+	{__uni_decomp_data_0x338a, 0x338a},
+	{__uni_decomp_data_0x33b4, 0x33b4},
+	{__uni_decomp_data_0x33ba, 0x33ba},
+	{__uni_decomp_data_0x3376, 0x3376},
+	{__uni_decomp_data_0x33b0, 0x33b0},
+	{__uni_decomp_data_0x1e55, 0x1e55},
+	{__uni_decomp_data_0x1e57, 0x1e57},
+	{__uni_decomp_data_0x33ad, 0x33ad},
+	{__uni_decomp_data_0x33ae, 0x33ae},
+	{__uni_decomp_data_0x33af, 0x33af},
+	{__uni_decomp_data_0x155, 0x155},
+	{__uni_decomp_data_0x1e59, 0x1e59},
+	{__uni_decomp_data_0x159, 0x159},
+	{__uni_decomp_data_0x211, 0x211},
+	{__uni_decomp_data_0x213, 0x213},
+	{__uni_decomp_data_0x1e5b, 0x1e5b},
+	{__uni_decomp_data_0x157, 0x157},
+	{__uni_decomp_data_0x1e5f, 0x1e5f},
+	{__uni_decomp_data_0x33db, 0x33db},
+	{__uni_decomp_data_0xfb06, 0xfb06},
+	{__uni_decomp_data_0x15b, 0x15b},
+	{__uni_decomp_data_0x15d, 0x15d},
+	{__uni_decomp_data_0x1e61, 0x1e61},
+	{__uni_decomp_data_0x161, 0x161},
+	{__uni_decomp_data_0x1e63, 0x1e63},
+	{__uni_decomp_data_0x219, 0x219},
+	{__uni_decomp_data_0x15f, 0x15f},
+	{__uni_decomp_data_0x1e6b, 0x1e6b},
+	{__uni_decomp_data_0x1e97, 0x1e97},
+	{__uni_decomp_data_0x165, 0x165},
+	{__uni_decomp_data_0x1e6d, 0x1e6d},
+	{__uni_decomp_data_0x21b, 0x21b},
+	{__uni_decomp_data_0x163, 0x163},
+	{__uni_decomp_data_0x1e71, 0x1e71},
+	{__uni_decomp_data_0x1e6f, 0x1e6f},
+	{__uni_decomp_data_0xf9, 0xf9},
+	{__uni_decomp_data_0xfa, 0xfa},
+	{__uni_decomp_data_0xfb, 0xfb},
+	{__uni_decomp_data_0x169, 0x169},
+	{__uni_decomp_data_0x16b, 0x16b},
+	{__uni_decomp_data_0x16d, 0x16d},
+	{__uni_decomp_data_0xfc, 0xfc},
+	{__uni_decomp_data_0x1ee7, 0x1ee7},
+	{__uni_decomp_data_0x16f, 0x16f},
+	{__uni_decomp_data_0x171, 0x171},
+	{__uni_decomp_data_0x1d4, 0x1d4},
+	{__uni_decomp_data_0x215, 0x215},
+	{__uni_decomp_data_0x217, 0x217},
+	{__uni_decomp_data_0x1b0, 0x1b0},
+	{__uni_decomp_data_0x1ee5, 0x1ee5},
+	{__uni_decomp_data_0x1e73, 0x1e73},
+	{__uni_decomp_data_0x173, 0x173},
+	{__uni_decomp_data_0x1e77, 0x1e77},
+	{__uni_decomp_data_0x1e75, 0x1e75},
+	{__uni_decomp_data_0x2175, 0x2175},
+	{__uni_decomp_data_0x2176, 0x2176},
+	{__uni_decomp_data_0x2177, 0x2177},
+	{__uni_decomp_data_0x1e7d, 0x1e7d},
+	{__uni_decomp_data_0x1e7f, 0x1e7f},
+	{__uni_decomp_data_0x1e81, 0x1e81},
+	{__uni_decomp_data_0x1e83, 0x1e83},
+	{__uni_decomp_data_0x175, 0x175},
+	{__uni_decomp_data_0x1e87, 0x1e87},
+	{__uni_decomp_data_0x1e85, 0x1e85},
+	{__uni_decomp_data_0x1e98, 0x1e98},
+	{__uni_decomp_data_0x1e89, 0x1e89},
+	{__uni_decomp_data_0x217a, 0x217a},
+	{__uni_decomp_data_0x217b, 0x217b},
+	{__uni_decomp_data_0x1e8b, 0x1e8b},
+	{__uni_decomp_data_0x1e8d, 0x1e8d},
+	{__uni_decomp_data_0x1ef3, 0x1ef3},
+	{__uni_decomp_data_0xfd, 0xfd},
+	{__uni_decomp_data_0x177, 0x177},
+	{__uni_decomp_data_0x1ef9, 0x1ef9},
+	{__uni_decomp_data_0x233, 0x233},
+	{__uni_decomp_data_0x1e8f, 0x1e8f},
+	{__uni_decomp_data_0xff, 0xff},
+	{__uni_decomp_data_0x1ef7, 0x1ef7},
+	{__uni_decomp_data_0x1e99, 0x1e99},
+	{__uni_decomp_data_0x1ef5, 0x1ef5},
+	{__uni_decomp_data_0x17a, 0x17a},
+	{__uni_decomp_data_0x1e91, 0x1e91},
+	{__uni_decomp_data_0x17c, 0x17c},
+	{__uni_decomp_data_0x17e, 0x17e},
+	{__uni_decomp_data_0x1e93, 0x1e93},
+	{__uni_decomp_data_0x1e95, 0x1e95},
+	{__uni_decomp_data_0x1fed, 0x1fed},
+	{__uni_decomp_data_0x385, 0x385},
+	{__uni_decomp_data_0x1fc1, 0x1fc1},
+	{__uni_decomp_data_0x2103, 0x2103},
+	{__uni_decomp_data_0x2109, 0x2109},
+	{__uni_decomp_data_0x1ea6, 0x1ea6},
+	{__uni_decomp_data_0x1ea4, 0x1ea4},
+	{__uni_decomp_data_0x1eaa, 0x1eaa},
+	{__uni_decomp_data_0x1ea8, 0x1ea8},
+	{__uni_decomp_data_0x1de, 0x1de},
+	{__uni_decomp_data_0x1fa, 0x1fa},
+	{__uni_decomp_data_0x1fc, 0x1fc},
+	{__uni_decomp_data_0x1e2, 0x1e2},
+	{__uni_decomp_data_0x1e08, 0x1e08},
+	{__uni_decomp_data_0x1ec0, 0x1ec0},
+	{__uni_decomp_data_0x1ebe, 0x1ebe},
+	{__uni_decomp_data_0x1ec4, 0x1ec4},
+	{__uni_decomp_data_0x1ec2, 0x1ec2},
+	{__uni_decomp_data_0x1e2e, 0x1e2e},
+	{__uni_decomp_data_0x1ed2, 0x1ed2},
+	{__uni_decomp_data_0x1ed0, 0x1ed0},
+	{__uni_decomp_data_0x1ed6, 0x1ed6},
+	{__uni_decomp_data_0x1ed4, 0x1ed4},
+	{__uni_decomp_data_0x1e4c, 0x1e4c},
+	{__uni_decomp_data_0x22c, 0x22c},
+	{__uni_decomp_data_0x1e4e, 0x1e4e},
+	{__uni_decomp_data_0x22a, 0x22a},
+	{__uni_decomp_data_0x1fe, 0x1fe},
+	{__uni_decomp_data_0x1db, 0x1db},
+	{__uni_decomp_data_0x1d7, 0x1d7},
+	{__uni_decomp_data_0x1d5, 0x1d5},
+	{__uni_decomp_data_0x1d9, 0x1d9},
+	{__uni_decomp_data_0x1ea7, 0x1ea7},
+	{__uni_decomp_data_0x1ea5, 0x1ea5},
+	{__uni_decomp_data_0x1eab, 0x1eab},
+	{__uni_decomp_data_0x1ea9, 0x1ea9},
+	{__uni_decomp_data_0x1df, 0x1df},
+	{__uni_decomp_data_0x1fb, 0x1fb},
+	{__uni_decomp_data_0x1fd, 0x1fd},
+	{__uni_decomp_data_0x1e3, 0x1e3},
+	{__uni_decomp_data_0x1e09, 0x1e09},
+	{__uni_decomp_data_0x1ec1, 0x1ec1},
+	{__uni_decomp_data_0x1ebf, 0x1ebf},
+	{__uni_decomp_data_0x1ec5, 0x1ec5},
+	{__uni_decomp_data_0x1ec3, 0x1ec3},
+	{__uni_decomp_data_0x1e2f, 0x1e2f},
+	{__uni_decomp_data_0x1ed3, 0x1ed3},
+	{__uni_decomp_data_0x1ed1, 0x1ed1},
+	{__uni_decomp_data_0x1ed7, 0x1ed7},
+	{__uni_decomp_data_0x1ed5, 0x1ed5},
+	{__uni_decomp_data_0x1e4d, 0x1e4d},
+	{__uni_decomp_data_0x22d, 0x22d},
+	{__uni_decomp_data_0x1e4f, 0x1e4f},
+	{__uni_decomp_data_0x22b, 0x22b},
+	{__uni_decomp_data_0x1ff, 0x1ff},
+	{__uni_decomp_data_0x1dc, 0x1dc},
+	{__uni_decomp_data_0x1d8, 0x1d8},
+	{__uni_decomp_data_0x1d6, 0x1d6},
+	{__uni_decomp_data_0x1da, 0x1da},
+	{__uni_decomp_data_0x1eb0, 0x1eb0},
+	{__uni_decomp_data_0x1eae, 0x1eae},
+	{__uni_decomp_data_0x1eb4, 0x1eb4},
+	{__uni_decomp_data_0x1eb2, 0x1eb2},
+	{__uni_decomp_data_0x1eb1, 0x1eb1},
+	{__uni_decomp_data_0x1eaf, 0x1eaf},
+	{__uni_decomp_data_0x1eb5, 0x1eb5},
+	{__uni_decomp_data_0x1eb3, 0x1eb3},
+	{__uni_decomp_data_0x1e14, 0x1e14},
+	{__uni_decomp_data_0x1e16, 0x1e16},
+	{__uni_decomp_data_0x1e15, 0x1e15},
+	{__uni_decomp_data_0x1e17, 0x1e17},
+	{__uni_decomp_data_0x1e50, 0x1e50},
+	{__uni_decomp_data_0x1e52, 0x1e52},
+	{__uni_decomp_data_0x1e51, 0x1e51},
+	{__uni_decomp_data_0x1e53, 0x1e53},
+	{__uni_decomp_data_0x1e64, 0x1e64},
+	{__uni_decomp_data_0x1e65, 0x1e65},
+	{__uni_decomp_data_0x1e66, 0x1e66},
+	{__uni_decomp_data_0x1e67, 0x1e67},
+	{__uni_decomp_data_0x1e78, 0x1e78},
+	{__uni_decomp_data_0x1e79, 0x1e79},
+	{__uni_decomp_data_0x1e7a, 0x1e7a},
+	{__uni_decomp_data_0x1e7b, 0x1e7b},
+	{__uni_decomp_data_0xfb05, 0xfb05},
+	{__uni_decomp_data_0x1e9b, 0x1e9b},
+	{__uni_decomp_data_0x1edc, 0x1edc},
+	{__uni_decomp_data_0x1eda, 0x1eda},
+	{__uni_decomp_data_0x1ee0, 0x1ee0},
+	{__uni_decomp_data_0x1ede, 0x1ede},
+	{__uni_decomp_data_0x1ee2, 0x1ee2},
+	{__uni_decomp_data_0x1edd, 0x1edd},
+	{__uni_decomp_data_0x1edb, 0x1edb},
+	{__uni_decomp_data_0x1ee1, 0x1ee1},
+	{__uni_decomp_data_0x1edf, 0x1edf},
+	{__uni_decomp_data_0x1ee3, 0x1ee3},
+	{__uni_decomp_data_0x1eea, 0x1eea},
+	{__uni_decomp_data_0x1ee8, 0x1ee8},
+	{__uni_decomp_data_0x1eee, 0x1eee},
+	{__uni_decomp_data_0x1eec, 0x1eec},
+	{__uni_decomp_data_0x1ef0, 0x1ef0},
+	{__uni_decomp_data_0x1eeb, 0x1eeb},
+	{__uni_decomp_data_0x1ee9, 0x1ee9},
+	{__uni_decomp_data_0x1eef, 0x1eef},
+	{__uni_decomp_data_0x1eed, 0x1eed},
+	{__uni_decomp_data_0x1ef1, 0x1ef1},
+	{__uni_decomp_data_0x1ee, 0x1ee},
+	{__uni_decomp_data_0x1ec, 0x1ec},
+	{__uni_decomp_data_0x1ed, 0x1ed},
+	{__uni_decomp_data_0x1e0, 0x1e0},
+	{__uni_decomp_data_0x1e1, 0x1e1},
+	{__uni_decomp_data_0x1e1c, 0x1e1c},
+	{__uni_decomp_data_0x1e1d, 0x1e1d},
+	{__uni_decomp_data_0x230, 0x230},
+	{__uni_decomp_data_0x231, 0x231},
+	{__uni_decomp_data_0x1ef, 0x1ef},
+	{__uni_decomp_data_0x149, 0x149},
+	{__uni_decomp_data_0x1fba, 0x1fba},
+	{__uni_decomp_data_0x386, 0x386},
+	{__uni_decomp_data_0x1fb9, 0x1fb9},
+	{__uni_decomp_data_0x1fb8, 0x1fb8},
+	{__uni_decomp_data_0x1f08, 0x1f08},
+	{__uni_decomp_data_0x1f09, 0x1f09},
+	{__uni_decomp_data_0x1fbc, 0x1fbc},
+	{__uni_decomp_data_0x1fc8, 0x1fc8},
+	{__uni_decomp_data_0x388, 0x388},
+	{__uni_decomp_data_0x1f18, 0x1f18},
+	{__uni_decomp_data_0x1f19, 0x1f19},
+	{__uni_decomp_data_0x1fca, 0x1fca},
+	{__uni_decomp_data_0x389, 0x389},
+	{__uni_decomp_data_0x1f28, 0x1f28},
+	{__uni_decomp_data_0x1f29, 0x1f29},
+	{__uni_decomp_data_0x1fcc, 0x1fcc},
+	{__uni_decomp_data_0x1fda, 0x1fda},
+	{__uni_decomp_data_0x38a, 0x38a},
+	{__uni_decomp_data_0x1fd9, 0x1fd9},
+	{__uni_decomp_data_0x1fd8, 0x1fd8},
+	{__uni_decomp_data_0x3aa, 0x3aa},
+	{__uni_decomp_data_0x1f38, 0x1f38},
+	{__uni_decomp_data_0x1f39, 0x1f39},
+	{__uni_decomp_data_0x1ff8, 0x1ff8},
+	{__uni_decomp_data_0x38c, 0x38c},
+	{__uni_decomp_data_0x1f48, 0x1f48},
+	{__uni_decomp_data_0x1f49, 0x1f49},
+	{__uni_decomp_data_0x1fec, 0x1fec},
+	{__uni_decomp_data_0x1fea, 0x1fea},
+	{__uni_decomp_data_0x38e, 0x38e},
+	{__uni_decomp_data_0x1fe9, 0x1fe9},
+	{__uni_decomp_data_0x1fe8, 0x1fe8},
+	{__uni_decomp_data_0x3ab, 0x3ab},
+	{__uni_decomp_data_0x1f59, 0x1f59},
+	{__uni_decomp_data_0x1ffa, 0x1ffa},
+	{__uni_decomp_data_0x38f, 0x38f},
+	{__uni_decomp_data_0x1f68, 0x1f68},
+	{__uni_decomp_data_0x1f69, 0x1f69},
+	{__uni_decomp_data_0x1ffc, 0x1ffc},
+	{__uni_decomp_data_0x1fb4, 0x1fb4},
+	{__uni_decomp_data_0x1fc4, 0x1fc4},
+	{__uni_decomp_data_0x1f70, 0x1f70},
+	{__uni_decomp_data_0x3ac, 0x3ac},
+	{__uni_decomp_data_0x1fb1, 0x1fb1},
+	{__uni_decomp_data_0x1fb0, 0x1fb0},
+	{__uni_decomp_data_0x1f00, 0x1f00},
+	{__uni_decomp_data_0x1f01, 0x1f01},
+	{__uni_decomp_data_0x1fb6, 0x1fb6},
+	{__uni_decomp_data_0x1fb3, 0x1fb3},
+	{__uni_decomp_data_0x1f72, 0x1f72},
+	{__uni_decomp_data_0x3ad, 0x3ad},
+	{__uni_decomp_data_0x1f10, 0x1f10},
+	{__uni_decomp_data_0x1f11, 0x1f11},
+	{__uni_decomp_data_0x1f74, 0x1f74},
+	{__uni_decomp_data_0x3ae, 0x3ae},
+	{__uni_decomp_data_0x1f20, 0x1f20},
+	{__uni_decomp_data_0x1f21, 0x1f21},
+	{__uni_decomp_data_0x1fc6, 0x1fc6},
+	{__uni_decomp_data_0x1fc3, 0x1fc3},
+	{__uni_decomp_data_0x1f76, 0x1f76},
+	{__uni_decomp_data_0x3af, 0x3af},
+	{__uni_decomp_data_0x1fd1, 0x1fd1},
+	{__uni_decomp_data_0x1fd0, 0x1fd0},
+	{__uni_decomp_data_0x3ca, 0x3ca},
+	{__uni_decomp_data_0x1f30, 0x1f30},
+	{__uni_decomp_data_0x1f31, 0x1f31},
+	{__uni_decomp_data_0x1fd6, 0x1fd6},
+	{__uni_decomp_data_0x3382, 0x3382},
+	{__uni_decomp_data_0x338c, 0x338c},
+	{__uni_decomp_data_0x33b6, 0x33b6},
+	{__uni_decomp_data_0x33bc, 0x33bc},
+	{__uni_decomp_data_0x338d, 0x338d},
+	{__uni_decomp_data_0x339b, 0x339b},
+	{__uni_decomp_data_0x33b2, 0x33b2},
+	{__uni_decomp_data_0x3395, 0x3395},
+	{__uni_decomp_data_0x1f78, 0x1f78},
+	{__uni_decomp_data_0x3cc, 0x3cc},
+	{__uni_decomp_data_0x1f40, 0x1f40},
+	{__uni_decomp_data_0x1f41, 0x1f41},
+	{__uni_decomp_data_0x1fe4, 0x1fe4},
+	{__uni_decomp_data_0x1fe5, 0x1fe5},
+	{__uni_decomp_data_0x1f7a, 0x1f7a},
+	{__uni_decomp_data_0x3cd, 0x3cd},
+	{__uni_decomp_data_0x1fe1, 0x1fe1},
+	{__uni_decomp_data_0x1fe0, 0x1fe0},
+	{__uni_decomp_data_0x3cb, 0x3cb},
+	{__uni_decomp_data_0x1f50, 0x1f50},
+	{__uni_decomp_data_0x1f51, 0x1f51},
+	{__uni_decomp_data_0x1fe6, 0x1fe6},
+	{__uni_decomp_data_0x1f7c, 0x1f7c},
+	{__uni_decomp_data_0x3ce, 0x3ce},
+	{__uni_decomp_data_0x1f60, 0x1f60},
+	{__uni_decomp_data_0x1f61, 0x1f61},
+	{__uni_decomp_data_0x1ff6, 0x1ff6},
+	{__uni_decomp_data_0x1ff3, 0x1ff3},
+	{__uni_decomp_data_0x1fd2, 0x1fd2},
+	{__uni_decomp_data_0x390, 0x390},
+	{__uni_decomp_data_0x1fd7, 0x1fd7},
+	{__uni_decomp_data_0x1fe2, 0x1fe2},
+	{__uni_decomp_data_0x3b0, 0x3b0},
+	{__uni_decomp_data_0x1fe7, 0x1fe7},
+	{__uni_decomp_data_0x1ff4, 0x1ff4},
+	{__uni_decomp_data_0x3d3, 0x3d3},
+	{__uni_decomp_data_0x3d4, 0x3d4},
+	{__uni_decomp_data_0x407, 0x407},
+	{__uni_decomp_data_0x4d0, 0x4d0},
+	{__uni_decomp_data_0x4d2, 0x4d2},
+	{__uni_decomp_data_0x403, 0x403},
+	{__uni_decomp_data_0x400, 0x400},
+	{__uni_decomp_data_0x4d6, 0x4d6},
+	{__uni_decomp_data_0x401, 0x401},
+	{__uni_decomp_data_0x4c1, 0x4c1},
+	{__uni_decomp_data_0x4dc, 0x4dc},
+	{__uni_decomp_data_0x4de, 0x4de},
+	{__uni_decomp_data_0x40d, 0x40d},
+	{__uni_decomp_data_0x4e2, 0x4e2},
+	{__uni_decomp_data_0x419, 0x419},
+	{__uni_decomp_data_0x4e4, 0x4e4},
+	{__uni_decomp_data_0x40c, 0x40c},
+	{__uni_decomp_data_0x4e6, 0x4e6},
+	{__uni_decomp_data_0x4ee, 0x4ee},
+	{__uni_decomp_data_0x40e, 0x40e},
+	{__uni_decomp_data_0x4f0, 0x4f0},
+	{__uni_decomp_data_0x4f2, 0x4f2},
+	{__uni_decomp_data_0x4f4, 0x4f4},
+	{__uni_decomp_data_0x4f8, 0x4f8},
+	{__uni_decomp_data_0x4ec, 0x4ec},
+	{__uni_decomp_data_0x4d1, 0x4d1},
+	{__uni_decomp_data_0x4d3, 0x4d3},
+	{__uni_decomp_data_0x453, 0x453},
+	{__uni_decomp_data_0x450, 0x450},
+	{__uni_decomp_data_0x4d7, 0x4d7},
+	{__uni_decomp_data_0x451, 0x451},
+	{__uni_decomp_data_0x4c2, 0x4c2},
+	{__uni_decomp_data_0x4dd, 0x4dd},
+	{__uni_decomp_data_0x4df, 0x4df},
+	{__uni_decomp_data_0x45d, 0x45d},
+	{__uni_decomp_data_0x4e3, 0x4e3},
+	{__uni_decomp_data_0x439, 0x439},
+	{__uni_decomp_data_0x4e5, 0x4e5},
+	{__uni_decomp_data_0x45c, 0x45c},
+	{__uni_decomp_data_0x4e7, 0x4e7},
+	{__uni_decomp_data_0x4ef, 0x4ef},
+	{__uni_decomp_data_0x45e, 0x45e},
+	{__uni_decomp_data_0x4f1, 0x4f1},
+	{__uni_decomp_data_0x4f3, 0x4f3},
+	{__uni_decomp_data_0x4f5, 0x4f5},
+	{__uni_decomp_data_0x4f9, 0x4f9},
+	{__uni_decomp_data_0x4ed, 0x4ed},
+	{__uni_decomp_data_0x457, 0x457},
+	{__uni_decomp_data_0x476, 0x476},
+	{__uni_decomp_data_0x477, 0x477},
+	{__uni_decomp_data_0x4da, 0x4da},
+	{__uni_decomp_data_0x4db, 0x4db},
+	{__uni_decomp_data_0x4ea, 0x4ea},
+	{__uni_decomp_data_0x4eb, 0x4eb},
+	{__uni_decomp_data_0x587, 0x587},
+	{__uni_decomp_data_0xfb14, 0xfb14},
+	{__uni_decomp_data_0xfb15, 0xfb15},
+	{__uni_decomp_data_0xfb17, 0xfb17},
+	{__uni_decomp_data_0xfb13, 0xfb13},
+	{__uni_decomp_data_0xfb16, 0xfb16},
+	{__uni_decomp_data_0xfb4f, 0xfb4f},
+	{__uni_decomp_data_0xfbea, 0xfbea},
+	{__uni_decomp_data_0xfbeb, 0xfbeb},
+	{__uni_decomp_data_0xfc00, 0xfc00},
+	{__uni_decomp_data_0xfc97, 0xfc97},
+	{__uni_decomp_data_0xfc98, 0xfc98},
+	{__uni_decomp_data_0xfc01, 0xfc01},
+	{__uni_decomp_data_0xfc99, 0xfc99},
+	{__uni_decomp_data_0xfc64, 0xfc64},
+	{__uni_decomp_data_0xfc65, 0xfc65},
+	{__uni_decomp_data_0xfc66, 0xfc66},
+	{__uni_decomp_data_0xfc02, 0xfc02},
+	{__uni_decomp_data_0xfcdf, 0xfcdf},
+	{__uni_decomp_data_0xfc9a, 0xfc9a},
+	{__uni_decomp_data_0xfc67, 0xfc67},
+	{__uni_decomp_data_0xfce0, 0xfce0},
+	{__uni_decomp_data_0xfc9b, 0xfc9b},
+	{__uni_decomp_data_0xfbef, 0xfbef},
+	{__uni_decomp_data_0xfbee, 0xfbee},
+	{__uni_decomp_data_0xfbf9, 0xfbf9},
+	{__uni_decomp_data_0xfbfa, 0xfbfa},
+	{__uni_decomp_data_0xfbfb, 0xfbfb},
+	{__uni_decomp_data_0xfc03, 0xfc03},
+	{__uni_decomp_data_0xfc68, 0xfc68},
+	{__uni_decomp_data_0xfc04, 0xfc04},
+	{__uni_decomp_data_0xfc69, 0xfc69},
+	{__uni_decomp_data_0xfbf2, 0xfbf2},
+	{__uni_decomp_data_0xfbf3, 0xfbf3},
+	{__uni_decomp_data_0xfbf0, 0xfbf0},
+	{__uni_decomp_data_0xfbf1, 0xfbf1},
+	{__uni_decomp_data_0xfbf4, 0xfbf4},
+	{__uni_decomp_data_0xfbf5, 0xfbf5},
+	{__uni_decomp_data_0xfbf8, 0xfbf8},
+	{__uni_decomp_data_0xfbf6, 0xfbf6},
+	{__uni_decomp_data_0xfbf7, 0xfbf7},
+	{__uni_decomp_data_0xfbed, 0xfbed},
+	{__uni_decomp_data_0xfbec, 0xfbec},
+	{__uni_decomp_data_0xfdf3, 0xfdf3},
+	{__uni_decomp_data_0xfdf2, 0xfdf2},
+	{__uni_decomp_data_0xfd3c, 0xfd3c},
+	{__uni_decomp_data_0xfd3d, 0xfd3d},
+	{__uni_decomp_data_0x622, 0x622},
+	{__uni_decomp_data_0x623, 0x623},
+	{__uni_decomp_data_0x625, 0x625},
+	{__uni_decomp_data_0x675, 0x675},
+	{__uni_decomp_data_0xfc9c, 0xfc9c},
+	{__uni_decomp_data_0xfc05, 0xfc05},
+	{__uni_decomp_data_0xfc9d, 0xfc9d},
+	{__uni_decomp_data_0xfc06, 0xfc06},
+	{__uni_decomp_data_0xfdc2, 0xfdc2},
+	{__uni_decomp_data_0xfc9e, 0xfc9e},
+	{__uni_decomp_data_0xfc07, 0xfc07},
+	{__uni_decomp_data_0xfd9e, 0xfd9e},
+	{__uni_decomp_data_0xfc6a, 0xfc6a},
+	{__uni_decomp_data_0xfc6b, 0xfc6b},
+	{__uni_decomp_data_0xfce1, 0xfce1},
+	{__uni_decomp_data_0xfc9f, 0xfc9f},
+	{__uni_decomp_data_0xfc6c, 0xfc6c},
+	{__uni_decomp_data_0xfc08, 0xfc08},
+	{__uni_decomp_data_0xfc6d, 0xfc6d},
+	{__uni_decomp_data_0xfca0, 0xfca0},
+	{__uni_decomp_data_0xfce2, 0xfce2},
+	{__uni_decomp_data_0xfc6e, 0xfc6e},
+	{__uni_decomp_data_0xfc09, 0xfc09},
+	{__uni_decomp_data_0xfc0a, 0xfc0a},
+	{__uni_decomp_data_0xfc6f, 0xfc6f},
+	{__uni_decomp_data_0xfc0b, 0xfc0b},
+	{__uni_decomp_data_0xfca1, 0xfca1},
+	{__uni_decomp_data_0xfd50, 0xfd50},
+	{__uni_decomp_data_0xfda0, 0xfda0},
+	{__uni_decomp_data_0xfd9f, 0xfd9f},
+	{__uni_decomp_data_0xfc0c, 0xfc0c},
+	{__uni_decomp_data_0xfca2, 0xfca2},
+	{__uni_decomp_data_0xfd51, 0xfd51},
+	{__uni_decomp_data_0xfd52, 0xfd52},
+	{__uni_decomp_data_0xfd53, 0xfd53},
+	{__uni_decomp_data_0xfca3, 0xfca3},
+	{__uni_decomp_data_0xfc0d, 0xfc0d},
+	{__uni_decomp_data_0xfd54, 0xfd54},
+	{__uni_decomp_data_0xfda2, 0xfda2},
+	{__uni_decomp_data_0xfda1, 0xfda1},
+	{__uni_decomp_data_0xfc70, 0xfc70},
+	{__uni_decomp_data_0xfc71, 0xfc71},
+	{__uni_decomp_data_0xfc72, 0xfc72},
+	{__uni_decomp_data_0xfc0e, 0xfc0e},
+	{__uni_decomp_data_0xfca4, 0xfca4},
+	{__uni_decomp_data_0xfce3, 0xfce3},
+	{__uni_decomp_data_0xfd55, 0xfd55},
+	{__uni_decomp_data_0xfd56, 0xfd56},
+	{__uni_decomp_data_0xfd57, 0xfd57},
+	{__uni_decomp_data_0xfda4, 0xfda4},
+	{__uni_decomp_data_0xfda3, 0xfda3},
+	{__uni_decomp_data_0xfc73, 0xfc73},
+	{__uni_decomp_data_0xfca5, 0xfca5},
+	{__uni_decomp_data_0xfce4, 0xfce4},
+	{__uni_decomp_data_0xfc0f, 0xfc0f},
+	{__uni_decomp_data_0xfc74, 0xfc74},
+	{__uni_decomp_data_0xfc10, 0xfc10},
+	{__uni_decomp_data_0xfc75, 0xfc75},
+	{__uni_decomp_data_0xfc11, 0xfc11},
+	{__uni_decomp_data_0xfc76, 0xfc76},
+	{__uni_decomp_data_0xfc77, 0xfc77},
+	{__uni_decomp_data_0xfc12, 0xfc12},
+	{__uni_decomp_data_0xfc78, 0xfc78},
+	{__uni_decomp_data_0xfca6, 0xfca6},
+	{__uni_decomp_data_0xfce5, 0xfce5},
+	{__uni_decomp_data_0xfc79, 0xfc79},
+	{__uni_decomp_data_0xfce6, 0xfce6},
+	{__uni_decomp_data_0xfc13, 0xfc13},
+	{__uni_decomp_data_0xfc7a, 0xfc7a},
+	{__uni_decomp_data_0xfc7b, 0xfc7b},
+	{__uni_decomp_data_0xfc14, 0xfc14},
+	{__uni_decomp_data_0xfca7, 0xfca7},
+	{__uni_decomp_data_0xfc15, 0xfc15},
+	{__uni_decomp_data_0xfda6, 0xfda6},
+	{__uni_decomp_data_0xfdbe, 0xfdbe},
+	{__uni_decomp_data_0xfdfb, 0xfdfb},
+	{__uni_decomp_data_0xfca8, 0xfca8},
+	{__uni_decomp_data_0xfc16, 0xfc16},
+	{__uni_decomp_data_0xfd58, 0xfd58},
+	{__uni_decomp_data_0xfd59, 0xfd59},
+	{__uni_decomp_data_0xfda7, 0xfda7},
+	{__uni_decomp_data_0xfda5, 0xfda5},
+	{__uni_decomp_data_0xfd1d, 0xfd1d},
+	{__uni_decomp_data_0xfd01, 0xfd01},
+	{__uni_decomp_data_0xfd1e, 0xfd1e},
+	{__uni_decomp_data_0xfd02, 0xfd02},
+	{__uni_decomp_data_0xfc17, 0xfc17},
+	{__uni_decomp_data_0xfca9, 0xfca9},
+	{__uni_decomp_data_0xfdbf, 0xfdbf},
+	{__uni_decomp_data_0xfcaa, 0xfcaa},
+	{__uni_decomp_data_0xfc18, 0xfc18},
+	{__uni_decomp_data_0xfd5b, 0xfd5b},
+	{__uni_decomp_data_0xfd5a, 0xfd5a},
+	{__uni_decomp_data_0xfd1b, 0xfd1b},
+	{__uni_decomp_data_0xfcff, 0xfcff},
+	{__uni_decomp_data_0xfd1c, 0xfd1c},
+	{__uni_decomp_data_0xfd00, 0xfd00},
+	{__uni_decomp_data_0xfcab, 0xfcab},
+	{__uni_decomp_data_0xfc19, 0xfc19},
+	{__uni_decomp_data_0xfc1a, 0xfc1a},
+	{__uni_decomp_data_0xfc1b, 0xfc1b},
+	{__uni_decomp_data_0xfcac, 0xfcac},
+	{__uni_decomp_data_0xfd1f, 0xfd1f},
+	{__uni_decomp_data_0xfd03, 0xfd03},
+	{__uni_decomp_data_0xfd20, 0xfd20},
+	{__uni_decomp_data_0xfd04, 0xfd04},
+	{__uni_decomp_data_0xfc5b, 0xfc5b},
+	{__uni_decomp_data_0xfdf6, 0xfdf6},
+	{__uni_decomp_data_0xfc5c, 0xfc5c},
+	{__uni_decomp_data_0xfdfc, 0xfdfc},
+	{__uni_decomp_data_0xfcad, 0xfcad},
+	{__uni_decomp_data_0xfc1c, 0xfc1c},
+	{__uni_decomp_data_0xfd34, 0xfd34},
+	{__uni_decomp_data_0xfd5d, 0xfd5d},
+	{__uni_decomp_data_0xfd5e, 0xfd5e},
+	{__uni_decomp_data_0xfc1d, 0xfc1d},
+	{__uni_decomp_data_0xfcae, 0xfcae},
+	{__uni_decomp_data_0xfd35, 0xfd35},
+	{__uni_decomp_data_0xfd5c, 0xfd5c},
+	{__uni_decomp_data_0xfc1e, 0xfc1e},
+	{__uni_decomp_data_0xfcaf, 0xfcaf},
+	{__uni_decomp_data_0xfd36, 0xfd36},
+	{__uni_decomp_data_0xfda8, 0xfda8},
+	{__uni_decomp_data_0xfdc6, 0xfdc6},
+	{__uni_decomp_data_0xfd0e, 0xfd0e},
+	{__uni_decomp_data_0xfd2a, 0xfd2a},
+	{__uni_decomp_data_0xfcb0, 0xfcb0},
+	{__uni_decomp_data_0xfce7, 0xfce7},
+	{__uni_decomp_data_0xfc1f, 0xfc1f},
+	{__uni_decomp_data_0xfd61, 0xfd61},
+	{__uni_decomp_data_0xfd60, 0xfd60},
+	{__uni_decomp_data_0xfd5f, 0xfd5f},
+	{__uni_decomp_data_0xfd62, 0xfd62},
+	{__uni_decomp_data_0xfd63, 0xfd63},
+	{__uni_decomp_data_0xfd31, 0xfd31},
+	{__uni_decomp_data_0xfce8, 0xfce8},
+	{__uni_decomp_data_0xfd17, 0xfd17},
+	{__uni_decomp_data_0xfcfb, 0xfcfb},
+	{__uni_decomp_data_0xfd18, 0xfd18},
+	{__uni_decomp_data_0xfcfc, 0xfcfc},
+	{__uni_decomp_data_0xfd25, 0xfd25},
+	{__uni_decomp_data_0xfd2d, 0xfd2d},
+	{__uni_decomp_data_0xfd09, 0xfd09},
+	{__uni_decomp_data_0xfd37, 0xfd37},
+	{__uni_decomp_data_0xfd69, 0xfd69},
+	{__uni_decomp_data_0xfd38, 0xfd38},
+	{__uni_decomp_data_0xfd0a, 0xfd0a},
+	{__uni_decomp_data_0xfd26, 0xfd26},
+	{__uni_decomp_data_0xfd2e, 0xfd2e},
+	{__uni_decomp_data_0xfd68, 0xfd68},
+	{__uni_decomp_data_0xfd67, 0xfd67},
+	{__uni_decomp_data_0xfdaa, 0xfdaa},
+	{__uni_decomp_data_0xfd0b, 0xfd0b},
+	{__uni_decomp_data_0xfd39, 0xfd39},
+	{__uni_decomp_data_0xfd27, 0xfd27},
+	{__uni_decomp_data_0xfd2f, 0xfd2f},
+	{__uni_decomp_data_0xfd29, 0xfd29},
+	{__uni_decomp_data_0xfd0d, 0xfd0d},
+	{__uni_decomp_data_0xfd28, 0xfd28},
+	{__uni_decomp_data_0xfce9, 0xfce9},
+	{__uni_decomp_data_0xfd30, 0xfd30},
+	{__uni_decomp_data_0xfd0c, 0xfd0c},
+	{__uni_decomp_data_0xfd6b, 0xfd6b},
+	{__uni_decomp_data_0xfd6a, 0xfd6a},
+	{__uni_decomp_data_0xfd6d, 0xfd6d},
+	{__uni_decomp_data_0xfd6c, 0xfd6c},
+	{__uni_decomp_data_0xfd32, 0xfd32},
+	{__uni_decomp_data_0xfcea, 0xfcea},
+	{__uni_decomp_data_0xfcfd, 0xfcfd},
+	{__uni_decomp_data_0xfd19, 0xfd19},
+	{__uni_decomp_data_0xfd1a, 0xfd1a},
+	{__uni_decomp_data_0xfcfe, 0xfcfe},
+	{__uni_decomp_data_0xfcb1, 0xfcb1},
+	{__uni_decomp_data_0xfc20, 0xfc20},
+	{__uni_decomp_data_0xfd65, 0xfd65},
+	{__uni_decomp_data_0xfd64, 0xfd64},
+	{__uni_decomp_data_0xfda9, 0xfda9},
+	{__uni_decomp_data_0xfcb2, 0xfcb2},
+	{__uni_decomp_data_0xfd0f, 0xfd0f},
+	{__uni_decomp_data_0xfd2b, 0xfd2b},
+	{__uni_decomp_data_0xfdf5, 0xfdf5},
+	{__uni_decomp_data_0xfdf9, 0xfdf9},
+	{__uni_decomp_data_0xfdfa, 0xfdfa},
+	{__uni_decomp_data_0xfdf0, 0xfdf0},
+	{__uni_decomp_data_0xfc21, 0xfc21},
+	{__uni_decomp_data_0xfcb3, 0xfcb3},
+	{__uni_decomp_data_0xfdc5, 0xfdc5},
+	{__uni_decomp_data_0xfd66, 0xfd66},
+	{__uni_decomp_data_0xfd05, 0xfd05},
+	{__uni_decomp_data_0xfd21, 0xfd21},
+	{__uni_decomp_data_0xfd06, 0xfd06},
+	{__uni_decomp_data_0xfd22, 0xfd22},
+	{__uni_decomp_data_0xfcb4, 0xfcb4},
+	{__uni_decomp_data_0xfc22, 0xfc22},
+	{__uni_decomp_data_0xfc23, 0xfc23},
+	{__uni_decomp_data_0xfcb5, 0xfcb5},
+	{__uni_decomp_data_0xfd6e, 0xfd6e},
+	{__uni_decomp_data_0xfdab, 0xfdab},
+	{__uni_decomp_data_0xfc24, 0xfc24},
+	{__uni_decomp_data_0xfcb6, 0xfcb6},
+	{__uni_decomp_data_0xfd6f, 0xfd6f},
+	{__uni_decomp_data_0xfd70, 0xfd70},
+	{__uni_decomp_data_0xfd2c, 0xfd2c},
+	{__uni_decomp_data_0xfd10, 0xfd10},
+	{__uni_decomp_data_0xfcb7, 0xfcb7},
+	{__uni_decomp_data_0xfc25, 0xfc25},
+	{__uni_decomp_data_0xfd23, 0xfd23},
+	{__uni_decomp_data_0xfd07, 0xfd07},
+	{__uni_decomp_data_0xfd24, 0xfd24},
+	{__uni_decomp_data_0xfd08, 0xfd08},
+	{__uni_decomp_data_0xfcb8, 0xfcb8},
+	{__uni_decomp_data_0xfc26, 0xfc26},
+	{__uni_decomp_data_0xfd3a, 0xfd3a},
+	{__uni_decomp_data_0xfc27, 0xfc27},
+	{__uni_decomp_data_0xfd33, 0xfd33},
+	{__uni_decomp_data_0xfd72, 0xfd72},
+	{__uni_decomp_data_0xfd71, 0xfd71},
+	{__uni_decomp_data_0xfd73, 0xfd73},
+	{__uni_decomp_data_0xfd74, 0xfd74},
+	{__uni_decomp_data_0xfd11, 0xfd11},
+	{__uni_decomp_data_0xfcf5, 0xfcf5},
+	{__uni_decomp_data_0xfd12, 0xfd12},
+	{__uni_decomp_data_0xfcf6, 0xfcf6},
+	{__uni_decomp_data_0xfcb9, 0xfcb9},
+	{__uni_decomp_data_0xfd3b, 0xfd3b},
+	{__uni_decomp_data_0xfc28, 0xfc28},
+	{__uni_decomp_data_0xfcba, 0xfcba},
+	{__uni_decomp_data_0xfc29, 0xfc29},
+	{__uni_decomp_data_0xfdc4, 0xfdc4},
+	{__uni_decomp_data_0xfd75, 0xfd75},
+	{__uni_decomp_data_0xfdf7, 0xfdf7},
+	{__uni_decomp_data_0xfcbb, 0xfcbb},
+	{__uni_decomp_data_0xfc2a, 0xfc2a},
+	{__uni_decomp_data_0xfd77, 0xfd77},
+	{__uni_decomp_data_0xfd76, 0xfd76},
+	{__uni_decomp_data_0xfd78, 0xfd78},
+	{__uni_decomp_data_0xfdb6, 0xfdb6},
+	{__uni_decomp_data_0xfd13, 0xfd13},
+	{__uni_decomp_data_0xfcf7, 0xfcf7},
+	{__uni_decomp_data_0xfd14, 0xfd14},
+	{__uni_decomp_data_0xfcf8, 0xfcf8},
+	{__uni_decomp_data_0xfc2b, 0xfc2b},
+	{__uni_decomp_data_0xfcbc, 0xfcbc},
+	{__uni_decomp_data_0xfc2c, 0xfc2c},
+	{__uni_decomp_data_0xfcbd, 0xfcbd},
+	{__uni_decomp_data_0xfd79, 0xfd79},
+	{__uni_decomp_data_0xfd7b, 0xfd7b},
+	{__uni_decomp_data_0xfd7a, 0xfd7a},
+	{__uni_decomp_data_0xfcf9, 0xfcf9},
+	{__uni_decomp_data_0xfd15, 0xfd15},
+	{__uni_decomp_data_0xfcfa, 0xfcfa},
+	{__uni_decomp_data_0xfd16, 0xfd16},
+	{__uni_decomp_data_0xfe71, 0xfe71},
+	{__uni_decomp_data_0xfe77, 0xfe77},
+	{__uni_decomp_data_0xfcf2, 0xfcf2},
+	{__uni_decomp_data_0xfe79, 0xfe79},
+	{__uni_decomp_data_0xfcf3, 0xfcf3},
+	{__uni_decomp_data_0xfe7b, 0xfe7b},
+	{__uni_decomp_data_0xfcf4, 0xfcf4},
+	{__uni_decomp_data_0xfe7d, 0xfe7d},
+	{__uni_decomp_data_0xfe7f, 0xfe7f},
+	{__uni_decomp_data_0xfc2d, 0xfc2d},
+	{__uni_decomp_data_0xfcbe, 0xfcbe},
+	{__uni_decomp_data_0xfc2e, 0xfc2e},
+	{__uni_decomp_data_0xfcbf, 0xfcbf},
+	{__uni_decomp_data_0xfc2f, 0xfc2f},
+	{__uni_decomp_data_0xfcc0, 0xfcc0},
+	{__uni_decomp_data_0xfd7d, 0xfd7d},
+	{__uni_decomp_data_0xfd7c, 0xfd7c},
+	{__uni_decomp_data_0xfc30, 0xfc30},
+	{__uni_decomp_data_0xfcc1, 0xfcc1},
+	{__uni_decomp_data_0xfdc1, 0xfdc1},
+	{__uni_decomp_data_0xfc31, 0xfc31},
+	{__uni_decomp_data_0xfc7c, 0xfc7c},
+	{__uni_decomp_data_0xfc7d, 0xfc7d},
+	{__uni_decomp_data_0xfc32, 0xfc32},
+	{__uni_decomp_data_0xfcc2, 0xfcc2},
+	{__uni_decomp_data_0xfc33, 0xfc33},
+	{__uni_decomp_data_0xfdf1, 0xfdf1},
+	{__uni_decomp_data_0xfc34, 0xfc34},
+	{__uni_decomp_data_0xfcc3, 0xfcc3},
+	{__uni_decomp_data_0xfdb4, 0xfdb4},
+	{__uni_decomp_data_0xfd7e, 0xfd7e},
+	{__uni_decomp_data_0xfd7f, 0xfd7f},
+	{__uni_decomp_data_0xfdb2, 0xfdb2},
+	{__uni_decomp_data_0xfc35, 0xfc35},
+	{__uni_decomp_data_0xfc7e, 0xfc7e},
+	{__uni_decomp_data_0xfc36, 0xfc36},
+	{__uni_decomp_data_0xfc7f, 0xfc7f},
+	{__uni_decomp_data_0xfc80, 0xfc80},
+	{__uni_decomp_data_0xfc37, 0xfc37},
+	{__uni_decomp_data_0xfcc4, 0xfcc4},
+	{__uni_decomp_data_0xfc38, 0xfc38},
+	{__uni_decomp_data_0xfc39, 0xfc39},
+	{__uni_decomp_data_0xfcc5, 0xfcc5},
+	{__uni_decomp_data_0xfcc6, 0xfcc6},
+	{__uni_decomp_data_0xfc3a, 0xfc3a},
+	{__uni_decomp_data_0xfcc7, 0xfcc7},
+	{__uni_decomp_data_0xfceb, 0xfceb},
+	{__uni_decomp_data_0xfc81, 0xfc81},
+	{__uni_decomp_data_0xfc3b, 0xfc3b},
+	{__uni_decomp_data_0xfcc8, 0xfcc8},
+	{__uni_decomp_data_0xfc82, 0xfc82},
+	{__uni_decomp_data_0xfc3c, 0xfc3c},
+	{__uni_decomp_data_0xfcec, 0xfcec},
+	{__uni_decomp_data_0xfdc3, 0xfdc3},
+	{__uni_decomp_data_0xfdbb, 0xfdbb},
+	{__uni_decomp_data_0xfdb7, 0xfdb7},
+	{__uni_decomp_data_0xfc83, 0xfc83},
+	{__uni_decomp_data_0xfc3d, 0xfc3d},
+	{__uni_decomp_data_0xfc3e, 0xfc3e},
+	{__uni_decomp_data_0xfc84, 0xfc84},
+	{__uni_decomp_data_0xfef6, 0xfef6},
+	{__uni_decomp_data_0xfef5, 0xfef5},
+	{__uni_decomp_data_0xfef7, 0xfef7},
+	{__uni_decomp_data_0xfef8, 0xfef8},
+	{__uni_decomp_data_0xfef9, 0xfef9},
+	{__uni_decomp_data_0xfefa, 0xfefa},
+	{__uni_decomp_data_0xfefb, 0xfefb},
+	{__uni_decomp_data_0xfefc, 0xfefc},
+	{__uni_decomp_data_0xfc3f, 0xfc3f},
+	{__uni_decomp_data_0xfcc9, 0xfcc9},
+	{__uni_decomp_data_0xfd84, 0xfd84},
+	{__uni_decomp_data_0xfd83, 0xfd83},
+	{__uni_decomp_data_0xfdbc, 0xfdbc},
+	{__uni_decomp_data_0xfdba, 0xfdba},
+	{__uni_decomp_data_0xfdac, 0xfdac},
+	{__uni_decomp_data_0xfcca, 0xfcca},
+	{__uni_decomp_data_0xfc40, 0xfc40},
+	{__uni_decomp_data_0xfd80, 0xfd80},
+	{__uni_decomp_data_0xfdb5, 0xfdb5},
+	{__uni_decomp_data_0xfd82, 0xfd82},
+	{__uni_decomp_data_0xfd81, 0xfd81},
+	{__uni_decomp_data_0xfccb, 0xfccb},
+	{__uni_decomp_data_0xfc41, 0xfc41},
+	{__uni_decomp_data_0xfd85, 0xfd85},
+	{__uni_decomp_data_0xfd86, 0xfd86},
+	{__uni_decomp_data_0xfccc, 0xfccc},
+	{__uni_decomp_data_0xfced, 0xfced},
+	{__uni_decomp_data_0xfc42, 0xfc42},
+	{__uni_decomp_data_0xfc85, 0xfc85},
+	{__uni_decomp_data_0xfd87, 0xfd87},
+	{__uni_decomp_data_0xfd88, 0xfd88},
+	{__uni_decomp_data_0xfdad, 0xfdad},
+	{__uni_decomp_data_0xfccd, 0xfccd},
+	{__uni_decomp_data_0xfc86, 0xfc86},
+	{__uni_decomp_data_0xfc43, 0xfc43},
+	{__uni_decomp_data_0xfc87, 0xfc87},
+	{__uni_decomp_data_0xfc44, 0xfc44},
+	{__uni_decomp_data_0xfc88, 0xfc88},
+	{__uni_decomp_data_0xfcce, 0xfcce},
+	{__uni_decomp_data_0xfc45, 0xfc45},
+	{__uni_decomp_data_0xfd8c, 0xfd8c},
+	{__uni_decomp_data_0xfd92, 0xfd92},
+	{__uni_decomp_data_0xfd8d, 0xfd8d},
+	{__uni_decomp_data_0xfdc0, 0xfdc0},
+	{__uni_decomp_data_0xfccf, 0xfccf},
+	{__uni_decomp_data_0xfc46, 0xfc46},
+	{__uni_decomp_data_0xfd89, 0xfd89},
+	{__uni_decomp_data_0xfd8a, 0xfd8a},
+	{__uni_decomp_data_0xfdf4, 0xfdf4},
+	{__uni_decomp_data_0xfd8b, 0xfd8b},
+	{__uni_decomp_data_0xfc47, 0xfc47},
+	{__uni_decomp_data_0xfcd0, 0xfcd0},
+	{__uni_decomp_data_0xfd8e, 0xfd8e},
+	{__uni_decomp_data_0xfd8f, 0xfd8f},
+	{__uni_decomp_data_0xfdb9, 0xfdb9},
+	{__uni_decomp_data_0xfc48, 0xfc48},
+	{__uni_decomp_data_0xfcd1, 0xfcd1},
+	{__uni_decomp_data_0xfc89, 0xfc89},
+	{__uni_decomp_data_0xfdb1, 0xfdb1},
+	{__uni_decomp_data_0xfc49, 0xfc49},
+	{__uni_decomp_data_0xfc4a, 0xfc4a},
+	{__uni_decomp_data_0xfcd2, 0xfcd2},
+	{__uni_decomp_data_0xfc4b, 0xfc4b},
+	{__uni_decomp_data_0xfdbd, 0xfdbd},
+	{__uni_decomp_data_0xfdb8, 0xfdb8},
+	{__uni_decomp_data_0xfd98, 0xfd98},
+	{__uni_decomp_data_0xfd97, 0xfd97},
+	{__uni_decomp_data_0xfd99, 0xfd99},
+	{__uni_decomp_data_0xfdc7, 0xfdc7},
+	{__uni_decomp_data_0xfc4c, 0xfc4c},
+	{__uni_decomp_data_0xfcd3, 0xfcd3},
+	{__uni_decomp_data_0xfd95, 0xfd95},
+	{__uni_decomp_data_0xfd96, 0xfd96},
+	{__uni_decomp_data_0xfdb3, 0xfdb3},
+	{__uni_decomp_data_0xfc4d, 0xfc4d},
+	{__uni_decomp_data_0xfcd4, 0xfcd4},
+	{__uni_decomp_data_0xfc8a, 0xfc8a},
+	{__uni_decomp_data_0xfc8b, 0xfc8b},
+	{__uni_decomp_data_0xfc4e, 0xfc4e},
+	{__uni_decomp_data_0xfcd5, 0xfcd5},
+	{__uni_decomp_data_0xfc8c, 0xfc8c},
+	{__uni_decomp_data_0xfcee, 0xfcee},
+	{__uni_decomp_data_0xfd9b, 0xfd9b},
+	{__uni_decomp_data_0xfd9a, 0xfd9a},
+	{__uni_decomp_data_0xfc8d, 0xfc8d},
+	{__uni_decomp_data_0xfcd6, 0xfcd6},
+	{__uni_decomp_data_0xfcef, 0xfcef},
+	{__uni_decomp_data_0xfc8e, 0xfc8e},
+	{__uni_decomp_data_0xfc4f, 0xfc4f},
+	{__uni_decomp_data_0xfc8f, 0xfc8f},
+	{__uni_decomp_data_0xfc50, 0xfc50},
+	{__uni_decomp_data_0xfc51, 0xfc51},
+	{__uni_decomp_data_0xfcd7, 0xfcd7},
+	{__uni_decomp_data_0xfc52, 0xfc52},
+	{__uni_decomp_data_0xfcd8, 0xfcd8},
+	{__uni_decomp_data_0xfd93, 0xfd93},
+	{__uni_decomp_data_0xfd94, 0xfd94},
+	{__uni_decomp_data_0xfc53, 0xfc53},
+	{__uni_decomp_data_0xfc54, 0xfc54},
+	{__uni_decomp_data_0xfcd9, 0xfcd9},
+	{__uni_decomp_data_0xfdf8, 0xfdf8},
+	{__uni_decomp_data_0x624, 0x624},
+	{__uni_decomp_data_0x676, 0x676},
+	{__uni_decomp_data_0xfc90, 0xfc90},
+	{__uni_decomp_data_0xfc5d, 0xfc5d},
+	{__uni_decomp_data_0xfc55, 0xfc55},
+	{__uni_decomp_data_0xfcda, 0xfcda},
+	{__uni_decomp_data_0xfdaf, 0xfdaf},
+	{__uni_decomp_data_0xfc56, 0xfc56},
+	{__uni_decomp_data_0xfcdb, 0xfcdb},
+	{__uni_decomp_data_0xfdae, 0xfdae},
+	{__uni_decomp_data_0xfc57, 0xfc57},
+	{__uni_decomp_data_0xfcdc, 0xfcdc},
+	{__uni_decomp_data_0xfc91, 0xfc91},
+	{__uni_decomp_data_0xfc92, 0xfc92},
+	{__uni_decomp_data_0xfcf0, 0xfcf0},
+	{__uni_decomp_data_0xfcdd, 0xfcdd},
+	{__uni_decomp_data_0xfc58, 0xfc58},
+	{__uni_decomp_data_0xfc93, 0xfc93},
+	{__uni_decomp_data_0xfd9c, 0xfd9c},
+	{__uni_decomp_data_0xfd9d, 0xfd9d},
+	{__uni_decomp_data_0xfdb0, 0xfdb0},
+	{__uni_decomp_data_0xfc94, 0xfc94},
+	{__uni_decomp_data_0xfcf1, 0xfcf1},
+	{__uni_decomp_data_0xfcde, 0xfcde},
+	{__uni_decomp_data_0xfc59, 0xfc59},
+	{__uni_decomp_data_0xfc95, 0xfc95},
+	{__uni_decomp_data_0xfc5a, 0xfc5a},
+	{__uni_decomp_data_0xfc96, 0xfc96},
+	{__uni_decomp_data_0x626, 0x626},
+	{__uni_decomp_data_0x678, 0x678},
+	{__uni_decomp_data_0x6c2, 0x6c2},
+	{__uni_decomp_data_0x677, 0x677},
+	{__uni_decomp_data_0x6d3, 0x6d3},
+	{__uni_decomp_data_0x6c0, 0x6c0},
+	{__uni_decomp_data_0x929, 0x929},
+	{__uni_decomp_data_0x931, 0x931},
+	{__uni_decomp_data_0x934, 0x934},
+	{__uni_decomp_data_0x9cb, 0x9cb},
+	{__uni_decomp_data_0x9cc, 0x9cc},
+	{__uni_decomp_data_0xb4b, 0xb4b},
+	{__uni_decomp_data_0xb48, 0xb48},
+	{__uni_decomp_data_0xb4c, 0xb4c},
+	{__uni_decomp_data_0xb94, 0xb94},
+	{__uni_decomp_data_0xbca, 0xbca},
+	{__uni_decomp_data_0xbcc, 0xbcc},
+	{__uni_decomp_data_0xbcb, 0xbcb},
+	{__uni_decomp_data_0xc48, 0xc48},
+	{__uni_decomp_data_0xcc0, 0xcc0},
+	{__uni_decomp_data_0xcca, 0xcca},
+	{__uni_decomp_data_0xcc7, 0xcc7},
+	{__uni_decomp_data_0xcc8, 0xcc8},
+	{__uni_decomp_data_0xccb, 0xccb},
+	{__uni_decomp_data_0xd4a, 0xd4a},
+	{__uni_decomp_data_0xd4c, 0xd4c},
+	{__uni_decomp_data_0xd4b, 0xd4b},
+	{__uni_decomp_data_0xdda, 0xdda},
+	{__uni_decomp_data_0xddc, 0xddc},
+	{__uni_decomp_data_0xdde, 0xdde},
+	{__uni_decomp_data_0xddd, 0xddd},
+	{__uni_decomp_data_0xe33, 0xe33},
+	{__uni_decomp_data_0xedc, 0xedc},
+	{__uni_decomp_data_0xedd, 0xedd},
+	{__uni_decomp_data_0xeb3, 0xeb3},
+	{__uni_decomp_data_0xf77, 0xf77},
+	{__uni_decomp_data_0xf79, 0xf79},
+	{__uni_decomp_data_0x1026, 0x1026},
+	{__uni_decomp_data_0x326e, 0x326e},
+	{__uni_decomp_data_0x326f, 0x326f},
+	{__uni_decomp_data_0x3270, 0x3270},
+	{__uni_decomp_data_0x3271, 0x3271},
+	{__uni_decomp_data_0x3272, 0x3272},
+	{__uni_decomp_data_0x3273, 0x3273},
+	{__uni_decomp_data_0x3274, 0x3274},
+	{__uni_decomp_data_0x3275, 0x3275},
+	{__uni_decomp_data_0x327e, 0x327e},
+	{__uni_decomp_data_0x3276, 0x3276},
+	{__uni_decomp_data_0x327d, 0x327d},
+	{__uni_decomp_data_0x3277, 0x3277},
+	{__uni_decomp_data_0x327c, 0x327c},
+	{__uni_decomp_data_0x3278, 0x3278},
+	{__uni_decomp_data_0x3279, 0x3279},
+	{__uni_decomp_data_0x327a, 0x327a},
+	{__uni_decomp_data_0x327b, 0x327b},
+	{__uni_decomp_data_0x1b06, 0x1b06},
+	{__uni_decomp_data_0x1b08, 0x1b08},
+	{__uni_decomp_data_0x1b0a, 0x1b0a},
+	{__uni_decomp_data_0x1b0c, 0x1b0c},
+	{__uni_decomp_data_0x1b0e, 0x1b0e},
+	{__uni_decomp_data_0x1b12, 0x1b12},
+	{__uni_decomp_data_0x1b3b, 0x1b3b},
+	{__uni_decomp_data_0x1b3d, 0x1b3d},
+	{__uni_decomp_data_0x1b40, 0x1b40},
+	{__uni_decomp_data_0x1b41, 0x1b41},
+	{__uni_decomp_data_0x1b43, 0x1b43},
+	{__uni_decomp_data_0x1e38, 0x1e38},
+	{__uni_decomp_data_0x1e39, 0x1e39},
+	{__uni_decomp_data_0x1e5c, 0x1e5c},
+	{__uni_decomp_data_0x1e5d, 0x1e5d},
+	{__uni_decomp_data_0x1e68, 0x1e68},
+	{__uni_decomp_data_0x1e69, 0x1e69},
+	{__uni_decomp_data_0x1eac, 0x1eac},
+	{__uni_decomp_data_0x1eb6, 0x1eb6},
+	{__uni_decomp_data_0x1ead, 0x1ead},
+	{__uni_decomp_data_0x1eb7, 0x1eb7},
+	{__uni_decomp_data_0x1ec6, 0x1ec6},
+	{__uni_decomp_data_0x1ec7, 0x1ec7},
+	{__uni_decomp_data_0x1ed8, 0x1ed8},
+	{__uni_decomp_data_0x1ed9, 0x1ed9},
+	{__uni_decomp_data_0x1f02, 0x1f02},
+	{__uni_decomp_data_0x1f04, 0x1f04},
+	{__uni_decomp_data_0x1f06, 0x1f06},
+	{__uni_decomp_data_0x1f80, 0x1f80},
+	{__uni_decomp_data_0x1f03, 0x1f03},
+	{__uni_decomp_data_0x1f05, 0x1f05},
+	{__uni_decomp_data_0x1f07, 0x1f07},
+	{__uni_decomp_data_0x1f81, 0x1f81},
+	{__uni_decomp_data_0x1f82, 0x1f82},
+	{__uni_decomp_data_0x1f83, 0x1f83},
+	{__uni_decomp_data_0x1f84, 0x1f84},
+	{__uni_decomp_data_0x1f85, 0x1f85},
+	{__uni_decomp_data_0x1f86, 0x1f86},
+	{__uni_decomp_data_0x1f87, 0x1f87},
+	{__uni_decomp_data_0x1f0a, 0x1f0a},
+	{__uni_decomp_data_0x1f0c, 0x1f0c},
+	{__uni_decomp_data_0x1f0e, 0x1f0e},
+	{__uni_decomp_data_0x1f88, 0x1f88},
+	{__uni_decomp_data_0x1f0b, 0x1f0b},
+	{__uni_decomp_data_0x1f0d, 0x1f0d},
+	{__uni_decomp_data_0x1f0f, 0x1f0f},
+	{__uni_decomp_data_0x1f89, 0x1f89},
+	{__uni_decomp_data_0x1f8a, 0x1f8a},
+	{__uni_decomp_data_0x1f8b, 0x1f8b},
+	{__uni_decomp_data_0x1f8c, 0x1f8c},
+	{__uni_decomp_data_0x1f8d, 0x1f8d},
+	{__uni_decomp_data_0x1f8e, 0x1f8e},
+	{__uni_decomp_data_0x1f8f, 0x1f8f},
+	{__uni_decomp_data_0x1f12, 0x1f12},
+	{__uni_decomp_data_0x1f14, 0x1f14},
+	{__uni_decomp_data_0x1f13, 0x1f13},
+	{__uni_decomp_data_0x1f15, 0x1f15},
+	{__uni_decomp_data_0x1f1a, 0x1f1a},
+	{__uni_decomp_data_0x1f1c, 0x1f1c},
+	{__uni_decomp_data_0x1f1b, 0x1f1b},
+	{__uni_decomp_data_0x1f1d, 0x1f1d},
+	{__uni_decomp_data_0x1f22, 0x1f22},
+	{__uni_decomp_data_0x1f24, 0x1f24},
+	{__uni_decomp_data_0x1f26, 0x1f26},
+	{__uni_decomp_data_0x1f90, 0x1f90},
+	{__uni_decomp_data_0x1f23, 0x1f23},
+	{__uni_decomp_data_0x1f25, 0x1f25},
+	{__uni_decomp_data_0x1f27, 0x1f27},
+	{__uni_decomp_data_0x1f91, 0x1f91},
+	{__uni_decomp_data_0x1f92, 0x1f92},
+	{__uni_decomp_data_0x1f93, 0x1f93},
+	{__uni_decomp_data_0x1f94, 0x1f94},
+	{__uni_decomp_data_0x1f95, 0x1f95},
+	{__uni_decomp_data_0x1f96, 0x1f96},
+	{__uni_decomp_data_0x1f97, 0x1f97},
+	{__uni_decomp_data_0x1f2a, 0x1f2a},
+	{__uni_decomp_data_0x1f2c, 0x1f2c},
+	{__uni_decomp_data_0x1f2e, 0x1f2e},
+	{__uni_decomp_data_0x1f98, 0x1f98},
+	{__uni_decomp_data_0x1f2b, 0x1f2b},
+	{__uni_decomp_data_0x1f2d, 0x1f2d},
+	{__uni_decomp_data_0x1f2f, 0x1f2f},
+	{__uni_decomp_data_0x1f99, 0x1f99},
+	{__uni_decomp_data_0x1f9a, 0x1f9a},
+	{__uni_decomp_data_0x1f9b, 0x1f9b},
+	{__uni_decomp_data_0x1f9c, 0x1f9c},
+	{__uni_decomp_data_0x1f9d, 0x1f9d},
+	{__uni_decomp_data_0x1f9e, 0x1f9e},
+	{__uni_decomp_data_0x1f9f, 0x1f9f},
+	{__uni_decomp_data_0x1f32, 0x1f32},
+	{__uni_decomp_data_0x1f34, 0x1f34},
+	{__uni_decomp_data_0x1f36, 0x1f36},
+	{__uni_decomp_data_0x1f33, 0x1f33},
+	{__uni_decomp_data_0x1f35, 0x1f35},
+	{__uni_decomp_data_0x1f37, 0x1f37},
+	{__uni_decomp_data_0x1f3a, 0x1f3a},
+	{__uni_decomp_data_0x1f3c, 0x1f3c},
+	{__uni_decomp_data_0x1f3e, 0x1f3e},
+	{__uni_decomp_data_0x1f3b, 0x1f3b},
+	{__uni_decomp_data_0x1f3d, 0x1f3d},
+	{__uni_decomp_data_0x1f3f, 0x1f3f},
+	{__uni_decomp_data_0x1f42, 0x1f42},
+	{__uni_decomp_data_0x1f44, 0x1f44},
+	{__uni_decomp_data_0x1f43, 0x1f43},
+	{__uni_decomp_data_0x1f45, 0x1f45},
+	{__uni_decomp_data_0x1f4a, 0x1f4a},
+	{__uni_decomp_data_0x1f4c, 0x1f4c},
+	{__uni_decomp_data_0x1f4b, 0x1f4b},
+	{__uni_decomp_data_0x1f4d, 0x1f4d},
+	{__uni_decomp_data_0x1f52, 0x1f52},
+	{__uni_decomp_data_0x1f54, 0x1f54},
+	{__uni_decomp_data_0x1f56, 0x1f56},
+	{__uni_decomp_data_0x1f53, 0x1f53},
+	{__uni_decomp_data_0x1f55, 0x1f55},
+	{__uni_decomp_data_0x1f57, 0x1f57},
+	{__uni_decomp_data_0x1f5b, 0x1f5b},
+	{__uni_decomp_data_0x1f5d, 0x1f5d},
+	{__uni_decomp_data_0x1f5f, 0x1f5f},
+	{__uni_decomp_data_0x1f62, 0x1f62},
+	{__uni_decomp_data_0x1f64, 0x1f64},
+	{__uni_decomp_data_0x1f66, 0x1f66},
+	{__uni_decomp_data_0x1fa0, 0x1fa0},
+	{__uni_decomp_data_0x1f63, 0x1f63},
+	{__uni_decomp_data_0x1f65, 0x1f65},
+	{__uni_decomp_data_0x1f67, 0x1f67},
+	{__uni_decomp_data_0x1fa1, 0x1fa1},
+	{__uni_decomp_data_0x1fa2, 0x1fa2},
+	{__uni_decomp_data_0x1fa3, 0x1fa3},
+	{__uni_decomp_data_0x1fa4, 0x1fa4},
+	{__uni_decomp_data_0x1fa5, 0x1fa5},
+	{__uni_decomp_data_0x1fa6, 0x1fa6},
+	{__uni_decomp_data_0x1fa7, 0x1fa7},
+	{__uni_decomp_data_0x1f6a, 0x1f6a},
+	{__uni_decomp_data_0x1f6c, 0x1f6c},
+	{__uni_decomp_data_0x1f6e, 0x1f6e},
+	{__uni_decomp_data_0x1fa8, 0x1fa8},
+	{__uni_decomp_data_0x1f6b, 0x1f6b},
+	{__uni_decomp_data_0x1f6d, 0x1f6d},
+	{__uni_decomp_data_0x1f6f, 0x1f6f},
+	{__uni_decomp_data_0x1fa9, 0x1fa9},
+	{__uni_decomp_data_0x1faa, 0x1faa},
+	{__uni_decomp_data_0x1fab, 0x1fab},
+	{__uni_decomp_data_0x1fac, 0x1fac},
+	{__uni_decomp_data_0x1fad, 0x1fad},
+	{__uni_decomp_data_0x1fae, 0x1fae},
+	{__uni_decomp_data_0x1faf, 0x1faf},
+	{__uni_decomp_data_0x1fb2, 0x1fb2},
+	{__uni_decomp_data_0x1fc2, 0x1fc2},
+	{__uni_decomp_data_0x1ff2, 0x1ff2},
+	{__uni_decomp_data_0x1fb7, 0x1fb7},
+	{__uni_decomp_data_0x1fcd, 0x1fcd},
+	{__uni_decomp_data_0x1fce, 0x1fce},
+	{__uni_decomp_data_0x1fcf, 0x1fcf},
+	{__uni_decomp_data_0x1fc7, 0x1fc7},
+	{__uni_decomp_data_0x1ff7, 0x1ff7},
+	{__uni_decomp_data_0x1fdd, 0x1fdd},
+	{__uni_decomp_data_0x1fde, 0x1fde},
+	{__uni_decomp_data_0x1fdf, 0x1fdf},
+	{__uni_decomp_data_0x2033, 0x2033},
+	{__uni_decomp_data_0x2034, 0x2034},
+	{__uni_decomp_data_0x2057, 0x2057},
+	{__uni_decomp_data_0x2036, 0x2036},
+	{__uni_decomp_data_0x2037, 0x2037},
+	{__uni_decomp_data_0x219a, 0x219a},
+	{__uni_decomp_data_0x219b, 0x219b},
+	{__uni_decomp_data_0x21ae, 0x21ae},
+	{__uni_decomp_data_0x21cd, 0x21cd},
+	{__uni_decomp_data_0x21cf, 0x21cf},
+	{__uni_decomp_data_0x21ce, 0x21ce},
+	{__uni_decomp_data_0x2204, 0x2204},
+	{__uni_decomp_data_0x2209, 0x2209},
+	{__uni_decomp_data_0x220c, 0x220c},
+	{__uni_decomp_data_0x2224, 0x2224},
+	{__uni_decomp_data_0x2226, 0x2226},
+	{__uni_decomp_data_0x222c, 0x222c},
+	{__uni_decomp_data_0x222d, 0x222d},
+	{__uni_decomp_data_0x2a0c, 0x2a0c},
+	{__uni_decomp_data_0x222f, 0x222f},
+	{__uni_decomp_data_0x2230, 0x2230},
+	{__uni_decomp_data_0x2241, 0x2241},
+	{__uni_decomp_data_0x2244, 0x2244},
+	{__uni_decomp_data_0x2247, 0x2247},
+	{__uni_decomp_data_0x2249, 0x2249},
+	{__uni_decomp_data_0x226d, 0x226d},
+	{__uni_decomp_data_0x2262, 0x2262},
+	{__uni_decomp_data_0x2270, 0x2270},
+	{__uni_decomp_data_0x2271, 0x2271},
+	{__uni_decomp_data_0x2274, 0x2274},
+	{__uni_decomp_data_0x2275, 0x2275},
+	{__uni_decomp_data_0x2278, 0x2278},
+	{__uni_decomp_data_0x2279, 0x2279},
+	{__uni_decomp_data_0x2280, 0x2280},
+	{__uni_decomp_data_0x2281, 0x2281},
+	{__uni_decomp_data_0x22e0, 0x22e0},
+	{__uni_decomp_data_0x22e1, 0x22e1},
+	{__uni_decomp_data_0x2284, 0x2284},
+	{__uni_decomp_data_0x2285, 0x2285},
+	{__uni_decomp_data_0x2288, 0x2288},
+	{__uni_decomp_data_0x2289, 0x2289},
+	{__uni_decomp_data_0x22e2, 0x22e2},
+	{__uni_decomp_data_0x22e3, 0x22e3},
+	{__uni_decomp_data_0x22ac, 0x22ac},
+	{__uni_decomp_data_0x22ad, 0x22ad},
+	{__uni_decomp_data_0x22ae, 0x22ae},
+	{__uni_decomp_data_0x22af, 0x22af},
+	{__uni_decomp_data_0x22ea, 0x22ea},
+	{__uni_decomp_data_0x22eb, 0x22eb},
+	{__uni_decomp_data_0x22ec, 0x22ec},
+	{__uni_decomp_data_0x22ed, 0x22ed},
+	{__uni_decomp_data_0x3094, 0x3094},
+	{__uni_decomp_data_0x304c, 0x304c},
+	{__uni_decomp_data_0x304e, 0x304e},
+	{__uni_decomp_data_0x3050, 0x3050},
+	{__uni_decomp_data_0x3052, 0x3052},
+	{__uni_decomp_data_0x3054, 0x3054},
+	{__uni_decomp_data_0x3056, 0x3056},
+	{__uni_decomp_data_0x3058, 0x3058},
+	{__uni_decomp_data_0x305a, 0x305a},
+	{__uni_decomp_data_0x305c, 0x305c},
+	{__uni_decomp_data_0x305e, 0x305e},
+	{__uni_decomp_data_0x3060, 0x3060},
+	{__uni_decomp_data_0x3062, 0x3062},
+	{__uni_decomp_data_0x3065, 0x3065},
+	{__uni_decomp_data_0x3067, 0x3067},
+	{__uni_decomp_data_0x3069, 0x3069},
+	{__uni_decomp_data_0x3070, 0x3070},
+	{__uni_decomp_data_0x3071, 0x3071},
+	{__uni_decomp_data_0x3073, 0x3073},
+	{__uni_decomp_data_0x3074, 0x3074},
+	{__uni_decomp_data_0x3076, 0x3076},
+	{__uni_decomp_data_0x3077, 0x3077},
+	{__uni_decomp_data_0x3079, 0x3079},
+	{__uni_decomp_data_0x307a, 0x307a},
+	{__uni_decomp_data_0x307c, 0x307c},
+	{__uni_decomp_data_0x307d, 0x307d},
+	{__uni_decomp_data_0x309f, 0x309f},
+	{__uni_decomp_data_0x309e, 0x309e},
+	{__uni_decomp_data_0x3300, 0x3300},
+	{__uni_decomp_data_0x3301, 0x3301},
+	{__uni_decomp_data_0x3302, 0x3302},
+	{__uni_decomp_data_0x3303, 0x3303},
+	{__uni_decomp_data_0x3304, 0x3304},
+	{__uni_decomp_data_0x3305, 0x3305},
+	{__uni_decomp_data_0x30f4, 0x30f4},
+	{__uni_decomp_data_0x3306, 0x3306},
+	{__uni_decomp_data_0x3307, 0x3307},
+	{__uni_decomp_data_0x3308, 0x3308},
+	{__uni_decomp_data_0x3309, 0x3309},
+	{__uni_decomp_data_0x330a, 0x330a},
+	{__uni_decomp_data_0x30ac, 0x30ac},
+	{__uni_decomp_data_0x330b, 0x330b},
+	{__uni_decomp_data_0x330c, 0x330c},
+	{__uni_decomp_data_0x330d, 0x330d},
+	{__uni_decomp_data_0x330e, 0x330e},
+	{__uni_decomp_data_0x330f, 0x330f},
+	{__uni_decomp_data_0x30ae, 0x30ae},
+	{__uni_decomp_data_0x3312, 0x3312},
+	{__uni_decomp_data_0x3314, 0x3314},
+	{__uni_decomp_data_0x3315, 0x3315},
+	{__uni_decomp_data_0x3316, 0x3316},
+	{__uni_decomp_data_0x3317, 0x3317},
+	{__uni_decomp_data_0x3310, 0x3310},
+	{__uni_decomp_data_0x3311, 0x3311},
+	{__uni_decomp_data_0x3313, 0x3313},
+	{__uni_decomp_data_0x30b0, 0x30b0},
+	{__uni_decomp_data_0x331a, 0x331a},
+	{__uni_decomp_data_0x331b, 0x331b},
+	{__uni_decomp_data_0x3318, 0x3318},
+	{__uni_decomp_data_0x3319, 0x3319},
+	{__uni_decomp_data_0x30b2, 0x30b2},
+	{__uni_decomp_data_0x331c, 0x331c},
+	{__uni_decomp_data_0x30b4, 0x30b4},
+	{__uni_decomp_data_0x30ff, 0x30ff},
+	{__uni_decomp_data_0x331d, 0x331d},
+	{__uni_decomp_data_0x331e, 0x331e},
+	{__uni_decomp_data_0x30b6, 0x30b6},
+	{__uni_decomp_data_0x331f, 0x331f},
+	{__uni_decomp_data_0x3320, 0x3320},
+	{__uni_decomp_data_0x30b8, 0x30b8},
+	{__uni_decomp_data_0x3321, 0x3321},
+	{__uni_decomp_data_0x30ba, 0x30ba},
+	{__uni_decomp_data_0x30bc, 0x30bc},
+	{__uni_decomp_data_0x3322, 0x3322},
+	{__uni_decomp_data_0x3323, 0x3323},
+	{__uni_decomp_data_0x30be, 0x30be},
+	{__uni_decomp_data_0x30c0, 0x30c0},
+	{__uni_decomp_data_0x3324, 0x3324},
+	{__uni_decomp_data_0x30c2, 0x30c2},
+	{__uni_decomp_data_0x30c5, 0x30c5},
+	{__uni_decomp_data_0x30c7, 0x30c7},
+	{__uni_decomp_data_0x3325, 0x3325},
+	{__uni_decomp_data_0x30c9, 0x30c9},
+	{__uni_decomp_data_0x3327, 0x3327},
+	{__uni_decomp_data_0x3326, 0x3326},
+	{__uni_decomp_data_0x3328, 0x3328},
+	{__uni_decomp_data_0x3329, 0x3329},
+	{__uni_decomp_data_0x30d0, 0x30d0},
+	{__uni_decomp_data_0x30d1, 0x30d1},
+	{__uni_decomp_data_0x332a, 0x332a},
+	{__uni_decomp_data_0x332d, 0x332d},
+	{__uni_decomp_data_0x332b, 0x332b},
+	{__uni_decomp_data_0x332c, 0x332c},
+	{__uni_decomp_data_0x30d3, 0x30d3},
+	{__uni_decomp_data_0x30d4, 0x30d4},
+	{__uni_decomp_data_0x3331, 0x3331},
+	{__uni_decomp_data_0x332e, 0x332e},
+	{__uni_decomp_data_0x332f, 0x332f},
+	{__uni_decomp_data_0x3330, 0x3330},
+	{__uni_decomp_data_0x30d6, 0x30d6},
+	{__uni_decomp_data_0x30d7, 0x30d7},
+	{__uni_decomp_data_0x3332, 0x3332},
+	{__uni_decomp_data_0x3333, 0x3333},
+	{__uni_decomp_data_0x3335, 0x3335},
+	{__uni_decomp_data_0x3334, 0x3334},
+	{__uni_decomp_data_0x30d9, 0x30d9},
+	{__uni_decomp_data_0x30da, 0x30da},
+	{__uni_decomp_data_0x3336, 0x3336},
+	{__uni_decomp_data_0x3339, 0x3339},
+	{__uni_decomp_data_0x333c, 0x333c},
+	{__uni_decomp_data_0x3337, 0x3337},
+	{__uni_decomp_data_0x3338, 0x3338},
+	{__uni_decomp_data_0x333a, 0x333a},
+	{__uni_decomp_data_0x333b, 0x333b},
+	{__uni_decomp_data_0x30dc, 0x30dc},
+	{__uni_decomp_data_0x30dd, 0x30dd},
+	{__uni_decomp_data_0x333f, 0x333f},
+	{__uni_decomp_data_0x3341, 0x3341},
+	{__uni_decomp_data_0x3342, 0x3342},
+	{__uni_decomp_data_0x333e, 0x333e},
+	{__uni_decomp_data_0x333d, 0x333d},
+	{__uni_decomp_data_0x3340, 0x3340},
+	{__uni_decomp_data_0x3343, 0x3343},
+	{__uni_decomp_data_0x3344, 0x3344},
+	{__uni_decomp_data_0x3345, 0x3345},
+	{__uni_decomp_data_0x3346, 0x3346},
+	{__uni_decomp_data_0x3347, 0x3347},
+	{__uni_decomp_data_0x3348, 0x3348},
+	{__uni_decomp_data_0x3349, 0x3349},
+	{__uni_decomp_data_0x334a, 0x334a},
+	{__uni_decomp_data_0x334b, 0x334b},
+	{__uni_decomp_data_0x334c, 0x334c},
+	{__uni_decomp_data_0x334d, 0x334d},
+	{__uni_decomp_data_0x334e, 0x334e},
+	{__uni_decomp_data_0x334f, 0x334f},
+	{__uni_decomp_data_0x3350, 0x3350},
+	{__uni_decomp_data_0x3351, 0x3351},
+	{__uni_decomp_data_0x3352, 0x3352},
+	{__uni_decomp_data_0x3353, 0x3353},
+	{__uni_decomp_data_0x3354, 0x3354},
+	{__uni_decomp_data_0x3355, 0x3355},
+	{__uni_decomp_data_0x3356, 0x3356},
+	{__uni_decomp_data_0x30f7, 0x30f7},
+	{__uni_decomp_data_0x3357, 0x3357},
+	{__uni_decomp_data_0x30f8, 0x30f8},
+	{__uni_decomp_data_0x30f9, 0x30f9},
+	{__uni_decomp_data_0x30fa, 0x30fa},
+	{__uni_decomp_data_0x30fe, 0x30fe},
+	{__uni_decomp_data_0x337d, 0x337d},
+	{__uni_decomp_data_0x337b, 0x337b},
+	{__uni_decomp_data_0x337e, 0x337e},
+	{__uni_decomp_data_0x337c, 0x337c},
+	{__uni_decomp_data_0x337f, 0x337f},
+};
+
+BOOST_UNICODE_DECL extern const size_t __uni_compose_entry_size = sizeof __uni_compose_entry / sizeof __uni_compose_entry[0];
+
+}}}  // namespaces
+

Modified: sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data.cpp
==============================================================================
--- sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data.cpp	(original)
+++ sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data.cpp	2009-08-06 03:26:39 EDT (Thu, 06 Aug 2009)
@@ -31,6 +31,7 @@
 #include "uni_ucd_interface_impl_data_8.ipp"
 #include "uni_ucd_interface_impl_data_9.ipp"
 #include "uni_ucd_interface_impl_sort_data.ipp"
+#include "uni_ucd_interface_impl_compose_data.ipp"
 
 
 namespace boost { namespace unicode { namespace ucd {

Modified: sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_1.ipp
==============================================================================
--- sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_1.ipp	(original)
+++ sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_1.ipp	2009-08-06 03:26:39 EDT (Thu, 06 Aug 2009)
@@ -1694,73 +1694,73 @@
 };
 
 
-static const char32 __uni_decomp_data_0xa0[] = { 0x20, 0, };
-static const char32 __uni_decomp_data_0xa8[] = { 0x20, 0x308, 0, };
-static const char32 __uni_decomp_data_0xaa[] = { 0x61, 0, };
-static const char32 __uni_decomp_data_0xaf[] = { 0x20, 0x304, 0, };
-static const char32 __uni_decomp_data_0xb2[] = { 0x32, 0, };
-static const char32 __uni_decomp_data_0xb3[] = { 0x33, 0, };
-static const char32 __uni_decomp_data_0xb4[] = { 0x20, 0x301, 0, };
-static const char32 __uni_decomp_data_0xb5[] = { 0x3bc, 0, };
-static const char32 __uni_decomp_data_0xb8[] = { 0x20, 0x327, 0, };
-static const char32 __uni_decomp_data_0xb9[] = { 0x31, 0, };
-static const char32 __uni_decomp_data_0xba[] = { 0x6f, 0, };
-static const char32 __uni_decomp_data_0xbc[] = { 0x31, 0x2044, 0x34, 0, };
-static const char32 __uni_decomp_data_0xbd[] = { 0x31, 0x2044, 0x32, 0, };
-static const char32 __uni_decomp_data_0xbe[] = { 0x33, 0x2044, 0x34, 0, };
-static const char32 __uni_decomp_data_0xc0[] = { 0x41, 0x300, 0, };
-static const char32 __uni_decomp_data_0xc1[] = { 0x41, 0x301, 0, };
-static const char32 __uni_decomp_data_0xc2[] = { 0x41, 0x302, 0, };
-static const char32 __uni_decomp_data_0xc3[] = { 0x41, 0x303, 0, };
-static const char32 __uni_decomp_data_0xc4[] = { 0x41, 0x308, 0, };
-static const char32 __uni_decomp_data_0xc5[] = { 0x41, 0x30a, 0, };
-static const char32 __uni_decomp_data_0xc7[] = { 0x43, 0x327, 0, };
-static const char32 __uni_decomp_data_0xc8[] = { 0x45, 0x300, 0, };
-static const char32 __uni_decomp_data_0xc9[] = { 0x45, 0x301, 0, };
-static const char32 __uni_decomp_data_0xca[] = { 0x45, 0x302, 0, };
-static const char32 __uni_decomp_data_0xcb[] = { 0x45, 0x308, 0, };
-static const char32 __uni_decomp_data_0xcc[] = { 0x49, 0x300, 0, };
-static const char32 __uni_decomp_data_0xcd[] = { 0x49, 0x301, 0, };
-static const char32 __uni_decomp_data_0xce[] = { 0x49, 0x302, 0, };
-static const char32 __uni_decomp_data_0xcf[] = { 0x49, 0x308, 0, };
-static const char32 __uni_decomp_data_0xd1[] = { 0x4e, 0x303, 0, };
-static const char32 __uni_decomp_data_0xd2[] = { 0x4f, 0x300, 0, };
-static const char32 __uni_decomp_data_0xd3[] = { 0x4f, 0x301, 0, };
-static const char32 __uni_decomp_data_0xd4[] = { 0x4f, 0x302, 0, };
-static const char32 __uni_decomp_data_0xd5[] = { 0x4f, 0x303, 0, };
-static const char32 __uni_decomp_data_0xd6[] = { 0x4f, 0x308, 0, };
-static const char32 __uni_decomp_data_0xd9[] = { 0x55, 0x300, 0, };
-static const char32 __uni_decomp_data_0xda[] = { 0x55, 0x301, 0, };
-static const char32 __uni_decomp_data_0xdb[] = { 0x55, 0x302, 0, };
-static const char32 __uni_decomp_data_0xdc[] = { 0x55, 0x308, 0, };
-static const char32 __uni_decomp_data_0xdd[] = { 0x59, 0x301, 0, };
-static const char32 __uni_decomp_data_0xe0[] = { 0x61, 0x300, 0, };
-static const char32 __uni_decomp_data_0xe1[] = { 0x61, 0x301, 0, };
-static const char32 __uni_decomp_data_0xe2[] = { 0x61, 0x302, 0, };
-static const char32 __uni_decomp_data_0xe3[] = { 0x61, 0x303, 0, };
-static const char32 __uni_decomp_data_0xe4[] = { 0x61, 0x308, 0, };
-static const char32 __uni_decomp_data_0xe5[] = { 0x61, 0x30a, 0, };
-static const char32 __uni_decomp_data_0xe7[] = { 0x63, 0x327, 0, };
-static const char32 __uni_decomp_data_0xe8[] = { 0x65, 0x300, 0, };
-static const char32 __uni_decomp_data_0xe9[] = { 0x65, 0x301, 0, };
-static const char32 __uni_decomp_data_0xea[] = { 0x65, 0x302, 0, };
-static const char32 __uni_decomp_data_0xeb[] = { 0x65, 0x308, 0, };
-static const char32 __uni_decomp_data_0xec[] = { 0x69, 0x300, 0, };
-static const char32 __uni_decomp_data_0xed[] = { 0x69, 0x301, 0, };
-static const char32 __uni_decomp_data_0xee[] = { 0x69, 0x302, 0, };
-static const char32 __uni_decomp_data_0xef[] = { 0x69, 0x308, 0, };
-static const char32 __uni_decomp_data_0xf1[] = { 0x6e, 0x303, 0, };
-static const char32 __uni_decomp_data_0xf2[] = { 0x6f, 0x300, 0, };
-static const char32 __uni_decomp_data_0xf3[] = { 0x6f, 0x301, 0, };
-static const char32 __uni_decomp_data_0xf4[] = { 0x6f, 0x302, 0, };
-static const char32 __uni_decomp_data_0xf5[] = { 0x6f, 0x303, 0, };
-static const char32 __uni_decomp_data_0xf6[] = { 0x6f, 0x308, 0, };
-static const char32 __uni_decomp_data_0xf9[] = { 0x75, 0x300, 0, };
-static const char32 __uni_decomp_data_0xfa[] = { 0x75, 0x301, 0, };
-static const char32 __uni_decomp_data_0xfb[] = { 0x75, 0x302, 0, };
-static const char32 __uni_decomp_data_0xfc[] = { 0x75, 0x308, 0, };
-static const char32 __uni_decomp_data_0xfd[] = { 0x79, 0x301, 0, };
-static const char32 __uni_decomp_data_0xff[] = { 0x79, 0x308, 0, };
+static const char32 __uni_decomp_data_0xa0[] = { 1, 0x20, };
+static const char32 __uni_decomp_data_0xa8[] = { 2, 0x20, 0x308, };
+static const char32 __uni_decomp_data_0xaa[] = { 1, 0x61, };
+static const char32 __uni_decomp_data_0xaf[] = { 2, 0x20, 0x304, };
+static const char32 __uni_decomp_data_0xb2[] = { 1, 0x32, };
+static const char32 __uni_decomp_data_0xb3[] = { 1, 0x33, };
+static const char32 __uni_decomp_data_0xb4[] = { 2, 0x20, 0x301, };
+static const char32 __uni_decomp_data_0xb5[] = { 1, 0x3bc, };
+static const char32 __uni_decomp_data_0xb8[] = { 2, 0x20, 0x327, };
+static const char32 __uni_decomp_data_0xb9[] = { 1, 0x31, };
+static const char32 __uni_decomp_data_0xba[] = { 1, 0x6f, };
+static const char32 __uni_decomp_data_0xbc[] = { 3, 0x31, 0x2044, 0x34, };
+static const char32 __uni_decomp_data_0xbd[] = { 3, 0x31, 0x2044, 0x32, };
+static const char32 __uni_decomp_data_0xbe[] = { 3, 0x33, 0x2044, 0x34, };
+static const char32 __uni_decomp_data_0xc0[] = { 2, 0x41, 0x300, };
+static const char32 __uni_decomp_data_0xc1[] = { 2, 0x41, 0x301, };
+static const char32 __uni_decomp_data_0xc2[] = { 2, 0x41, 0x302, };
+static const char32 __uni_decomp_data_0xc3[] = { 2, 0x41, 0x303, };
+static const char32 __uni_decomp_data_0xc4[] = { 2, 0x41, 0x308, };
+static const char32 __uni_decomp_data_0xc5[] = { 2, 0x41, 0x30a, };
+static const char32 __uni_decomp_data_0xc7[] = { 2, 0x43, 0x327, };
+static const char32 __uni_decomp_data_0xc8[] = { 2, 0x45, 0x300, };
+static const char32 __uni_decomp_data_0xc9[] = { 2, 0x45, 0x301, };
+static const char32 __uni_decomp_data_0xca[] = { 2, 0x45, 0x302, };
+static const char32 __uni_decomp_data_0xcb[] = { 2, 0x45, 0x308, };
+static const char32 __uni_decomp_data_0xcc[] = { 2, 0x49, 0x300, };
+static const char32 __uni_decomp_data_0xcd[] = { 2, 0x49, 0x301, };
+static const char32 __uni_decomp_data_0xce[] = { 2, 0x49, 0x302, };
+static const char32 __uni_decomp_data_0xcf[] = { 2, 0x49, 0x308, };
+static const char32 __uni_decomp_data_0xd1[] = { 2, 0x4e, 0x303, };
+static const char32 __uni_decomp_data_0xd2[] = { 2, 0x4f, 0x300, };
+static const char32 __uni_decomp_data_0xd3[] = { 2, 0x4f, 0x301, };
+static const char32 __uni_decomp_data_0xd4[] = { 2, 0x4f, 0x302, };
+static const char32 __uni_decomp_data_0xd5[] = { 2, 0x4f, 0x303, };
+static const char32 __uni_decomp_data_0xd6[] = { 2, 0x4f, 0x308, };
+static const char32 __uni_decomp_data_0xd9[] = { 2, 0x55, 0x300, };
+static const char32 __uni_decomp_data_0xda[] = { 2, 0x55, 0x301, };
+static const char32 __uni_decomp_data_0xdb[] = { 2, 0x55, 0x302, };
+static const char32 __uni_decomp_data_0xdc[] = { 2, 0x55, 0x308, };
+static const char32 __uni_decomp_data_0xdd[] = { 2, 0x59, 0x301, };
+static const char32 __uni_decomp_data_0xe0[] = { 2, 0x61, 0x300, };
+static const char32 __uni_decomp_data_0xe1[] = { 2, 0x61, 0x301, };
+static const char32 __uni_decomp_data_0xe2[] = { 2, 0x61, 0x302, };
+static const char32 __uni_decomp_data_0xe3[] = { 2, 0x61, 0x303, };
+static const char32 __uni_decomp_data_0xe4[] = { 2, 0x61, 0x308, };
+static const char32 __uni_decomp_data_0xe5[] = { 2, 0x61, 0x30a, };
+static const char32 __uni_decomp_data_0xe7[] = { 2, 0x63, 0x327, };
+static const char32 __uni_decomp_data_0xe8[] = { 2, 0x65, 0x300, };
+static const char32 __uni_decomp_data_0xe9[] = { 2, 0x65, 0x301, };
+static const char32 __uni_decomp_data_0xea[] = { 2, 0x65, 0x302, };
+static const char32 __uni_decomp_data_0xeb[] = { 2, 0x65, 0x308, };
+static const char32 __uni_decomp_data_0xec[] = { 2, 0x69, 0x300, };
+static const char32 __uni_decomp_data_0xed[] = { 2, 0x69, 0x301, };
+static const char32 __uni_decomp_data_0xee[] = { 2, 0x69, 0x302, };
+static const char32 __uni_decomp_data_0xef[] = { 2, 0x69, 0x308, };
+static const char32 __uni_decomp_data_0xf1[] = { 2, 0x6e, 0x303, };
+static const char32 __uni_decomp_data_0xf2[] = { 2, 0x6f, 0x300, };
+static const char32 __uni_decomp_data_0xf3[] = { 2, 0x6f, 0x301, };
+static const char32 __uni_decomp_data_0xf4[] = { 2, 0x6f, 0x302, };
+static const char32 __uni_decomp_data_0xf5[] = { 2, 0x6f, 0x303, };
+static const char32 __uni_decomp_data_0xf6[] = { 2, 0x6f, 0x308, };
+static const char32 __uni_decomp_data_0xf9[] = { 2, 0x75, 0x300, };
+static const char32 __uni_decomp_data_0xfa[] = { 2, 0x75, 0x301, };
+static const char32 __uni_decomp_data_0xfb[] = { 2, 0x75, 0x302, };
+static const char32 __uni_decomp_data_0xfc[] = { 2, 0x75, 0x308, };
+static const char32 __uni_decomp_data_0xfd[] = { 2, 0x79, 0x301, };
+static const char32 __uni_decomp_data_0xff[] = { 2, 0x79, 0x308, };
 
 
 
@@ -3434,120 +3434,120 @@
 };
 
 
-static const char32 __uni_decomp_data_0x100[] = { 0x41, 0x304, 0, };
-static const char32 __uni_decomp_data_0x101[] = { 0x61, 0x304, 0, };
-static const char32 __uni_decomp_data_0x102[] = { 0x41, 0x306, 0, };
-static const char32 __uni_decomp_data_0x103[] = { 0x61, 0x306, 0, };
-static const char32 __uni_decomp_data_0x104[] = { 0x41, 0x328, 0, };
-static const char32 __uni_decomp_data_0x105[] = { 0x61, 0x328, 0, };
-static const char32 __uni_decomp_data_0x106[] = { 0x43, 0x301, 0, };
-static const char32 __uni_decomp_data_0x107[] = { 0x63, 0x301, 0, };
-static const char32 __uni_decomp_data_0x108[] = { 0x43, 0x302, 0, };
-static const char32 __uni_decomp_data_0x109[] = { 0x63, 0x302, 0, };
-static const char32 __uni_decomp_data_0x10a[] = { 0x43, 0x307, 0, };
-static const char32 __uni_decomp_data_0x10b[] = { 0x63, 0x307, 0, };
-static const char32 __uni_decomp_data_0x10c[] = { 0x43, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x10d[] = { 0x63, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x10e[] = { 0x44, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x10f[] = { 0x64, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x112[] = { 0x45, 0x304, 0, };
-static const char32 __uni_decomp_data_0x113[] = { 0x65, 0x304, 0, };
-static const char32 __uni_decomp_data_0x114[] = { 0x45, 0x306, 0, };
-static const char32 __uni_decomp_data_0x115[] = { 0x65, 0x306, 0, };
-static const char32 __uni_decomp_data_0x116[] = { 0x45, 0x307, 0, };
-static const char32 __uni_decomp_data_0x117[] = { 0x65, 0x307, 0, };
-static const char32 __uni_decomp_data_0x118[] = { 0x45, 0x328, 0, };
-static const char32 __uni_decomp_data_0x119[] = { 0x65, 0x328, 0, };
-static const char32 __uni_decomp_data_0x11a[] = { 0x45, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x11b[] = { 0x65, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x11c[] = { 0x47, 0x302, 0, };
-static const char32 __uni_decomp_data_0x11d[] = { 0x67, 0x302, 0, };
-static const char32 __uni_decomp_data_0x11e[] = { 0x47, 0x306, 0, };
-static const char32 __uni_decomp_data_0x11f[] = { 0x67, 0x306, 0, };
-static const char32 __uni_decomp_data_0x120[] = { 0x47, 0x307, 0, };
-static const char32 __uni_decomp_data_0x121[] = { 0x67, 0x307, 0, };
-static const char32 __uni_decomp_data_0x122[] = { 0x47, 0x327, 0, };
-static const char32 __uni_decomp_data_0x123[] = { 0x67, 0x327, 0, };
-static const char32 __uni_decomp_data_0x124[] = { 0x48, 0x302, 0, };
-static const char32 __uni_decomp_data_0x125[] = { 0x68, 0x302, 0, };
-static const char32 __uni_decomp_data_0x128[] = { 0x49, 0x303, 0, };
-static const char32 __uni_decomp_data_0x129[] = { 0x69, 0x303, 0, };
-static const char32 __uni_decomp_data_0x12a[] = { 0x49, 0x304, 0, };
-static const char32 __uni_decomp_data_0x12b[] = { 0x69, 0x304, 0, };
-static const char32 __uni_decomp_data_0x12c[] = { 0x49, 0x306, 0, };
-static const char32 __uni_decomp_data_0x12d[] = { 0x69, 0x306, 0, };
-static const char32 __uni_decomp_data_0x12e[] = { 0x49, 0x328, 0, };
-static const char32 __uni_decomp_data_0x12f[] = { 0x69, 0x328, 0, };
-static const char32 __uni_decomp_data_0x130[] = { 0x49, 0x307, 0, };
-static const char32 __uni_decomp_data_0x132[] = { 0x49, 0x4a, 0, };
-static const char32 __uni_decomp_data_0x133[] = { 0x69, 0x6a, 0, };
-static const char32 __uni_decomp_data_0x134[] = { 0x4a, 0x302, 0, };
-static const char32 __uni_decomp_data_0x135[] = { 0x6a, 0x302, 0, };
-static const char32 __uni_decomp_data_0x136[] = { 0x4b, 0x327, 0, };
-static const char32 __uni_decomp_data_0x137[] = { 0x6b, 0x327, 0, };
-static const char32 __uni_decomp_data_0x139[] = { 0x4c, 0x301, 0, };
-static const char32 __uni_decomp_data_0x13a[] = { 0x6c, 0x301, 0, };
-static const char32 __uni_decomp_data_0x13b[] = { 0x4c, 0x327, 0, };
-static const char32 __uni_decomp_data_0x13c[] = { 0x6c, 0x327, 0, };
-static const char32 __uni_decomp_data_0x13d[] = { 0x4c, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x13e[] = { 0x6c, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x13f[] = { 0x4c, 0xb7, 0, };
-static const char32 __uni_decomp_data_0x140[] = { 0x6c, 0xb7, 0, };
-static const char32 __uni_decomp_data_0x143[] = { 0x4e, 0x301, 0, };
-static const char32 __uni_decomp_data_0x144[] = { 0x6e, 0x301, 0, };
-static const char32 __uni_decomp_data_0x145[] = { 0x4e, 0x327, 0, };
-static const char32 __uni_decomp_data_0x146[] = { 0x6e, 0x327, 0, };
-static const char32 __uni_decomp_data_0x147[] = { 0x4e, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x148[] = { 0x6e, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x149[] = { 0x2bc, 0x6e, 0, };
-static const char32 __uni_decomp_data_0x14c[] = { 0x4f, 0x304, 0, };
-static const char32 __uni_decomp_data_0x14d[] = { 0x6f, 0x304, 0, };
-static const char32 __uni_decomp_data_0x14e[] = { 0x4f, 0x306, 0, };
-static const char32 __uni_decomp_data_0x14f[] = { 0x6f, 0x306, 0, };
-static const char32 __uni_decomp_data_0x150[] = { 0x4f, 0x30b, 0, };
-static const char32 __uni_decomp_data_0x151[] = { 0x6f, 0x30b, 0, };
-static const char32 __uni_decomp_data_0x154[] = { 0x52, 0x301, 0, };
-static const char32 __uni_decomp_data_0x155[] = { 0x72, 0x301, 0, };
-static const char32 __uni_decomp_data_0x156[] = { 0x52, 0x327, 0, };
-static const char32 __uni_decomp_data_0x157[] = { 0x72, 0x327, 0, };
-static const char32 __uni_decomp_data_0x158[] = { 0x52, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x159[] = { 0x72, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x15a[] = { 0x53, 0x301, 0, };
-static const char32 __uni_decomp_data_0x15b[] = { 0x73, 0x301, 0, };
-static const char32 __uni_decomp_data_0x15c[] = { 0x53, 0x302, 0, };
-static const char32 __uni_decomp_data_0x15d[] = { 0x73, 0x302, 0, };
-static const char32 __uni_decomp_data_0x15e[] = { 0x53, 0x327, 0, };
-static const char32 __uni_decomp_data_0x15f[] = { 0x73, 0x327, 0, };
-static const char32 __uni_decomp_data_0x160[] = { 0x53, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x161[] = { 0x73, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x162[] = { 0x54, 0x327, 0, };
-static const char32 __uni_decomp_data_0x163[] = { 0x74, 0x327, 0, };
-static const char32 __uni_decomp_data_0x164[] = { 0x54, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x165[] = { 0x74, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x168[] = { 0x55, 0x303, 0, };
-static const char32 __uni_decomp_data_0x169[] = { 0x75, 0x303, 0, };
-static const char32 __uni_decomp_data_0x16a[] = { 0x55, 0x304, 0, };
-static const char32 __uni_decomp_data_0x16b[] = { 0x75, 0x304, 0, };
-static const char32 __uni_decomp_data_0x16c[] = { 0x55, 0x306, 0, };
-static const char32 __uni_decomp_data_0x16d[] = { 0x75, 0x306, 0, };
-static const char32 __uni_decomp_data_0x16e[] = { 0x55, 0x30a, 0, };
-static const char32 __uni_decomp_data_0x16f[] = { 0x75, 0x30a, 0, };
-static const char32 __uni_decomp_data_0x170[] = { 0x55, 0x30b, 0, };
-static const char32 __uni_decomp_data_0x171[] = { 0x75, 0x30b, 0, };
-static const char32 __uni_decomp_data_0x172[] = { 0x55, 0x328, 0, };
-static const char32 __uni_decomp_data_0x173[] = { 0x75, 0x328, 0, };
-static const char32 __uni_decomp_data_0x174[] = { 0x57, 0x302, 0, };
-static const char32 __uni_decomp_data_0x175[] = { 0x77, 0x302, 0, };
-static const char32 __uni_decomp_data_0x176[] = { 0x59, 0x302, 0, };
-static const char32 __uni_decomp_data_0x177[] = { 0x79, 0x302, 0, };
-static const char32 __uni_decomp_data_0x178[] = { 0x59, 0x308, 0, };
-static const char32 __uni_decomp_data_0x179[] = { 0x5a, 0x301, 0, };
-static const char32 __uni_decomp_data_0x17a[] = { 0x7a, 0x301, 0, };
-static const char32 __uni_decomp_data_0x17b[] = { 0x5a, 0x307, 0, };
-static const char32 __uni_decomp_data_0x17c[] = { 0x7a, 0x307, 0, };
-static const char32 __uni_decomp_data_0x17d[] = { 0x5a, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x17e[] = { 0x7a, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x17f[] = { 0x73, 0, };
+static const char32 __uni_decomp_data_0x100[] = { 2, 0x41, 0x304, };
+static const char32 __uni_decomp_data_0x101[] = { 2, 0x61, 0x304, };
+static const char32 __uni_decomp_data_0x102[] = { 2, 0x41, 0x306, };
+static const char32 __uni_decomp_data_0x103[] = { 2, 0x61, 0x306, };
+static const char32 __uni_decomp_data_0x104[] = { 2, 0x41, 0x328, };
+static const char32 __uni_decomp_data_0x105[] = { 2, 0x61, 0x328, };
+static const char32 __uni_decomp_data_0x106[] = { 2, 0x43, 0x301, };
+static const char32 __uni_decomp_data_0x107[] = { 2, 0x63, 0x301, };
+static const char32 __uni_decomp_data_0x108[] = { 2, 0x43, 0x302, };
+static const char32 __uni_decomp_data_0x109[] = { 2, 0x63, 0x302, };
+static const char32 __uni_decomp_data_0x10a[] = { 2, 0x43, 0x307, };
+static const char32 __uni_decomp_data_0x10b[] = { 2, 0x63, 0x307, };
+static const char32 __uni_decomp_data_0x10c[] = { 2, 0x43, 0x30c, };
+static const char32 __uni_decomp_data_0x10d[] = { 2, 0x63, 0x30c, };
+static const char32 __uni_decomp_data_0x10e[] = { 2, 0x44, 0x30c, };
+static const char32 __uni_decomp_data_0x10f[] = { 2, 0x64, 0x30c, };
+static const char32 __uni_decomp_data_0x112[] = { 2, 0x45, 0x304, };
+static const char32 __uni_decomp_data_0x113[] = { 2, 0x65, 0x304, };
+static const char32 __uni_decomp_data_0x114[] = { 2, 0x45, 0x306, };
+static const char32 __uni_decomp_data_0x115[] = { 2, 0x65, 0x306, };
+static const char32 __uni_decomp_data_0x116[] = { 2, 0x45, 0x307, };
+static const char32 __uni_decomp_data_0x117[] = { 2, 0x65, 0x307, };
+static const char32 __uni_decomp_data_0x118[] = { 2, 0x45, 0x328, };
+static const char32 __uni_decomp_data_0x119[] = { 2, 0x65, 0x328, };
+static const char32 __uni_decomp_data_0x11a[] = { 2, 0x45, 0x30c, };
+static const char32 __uni_decomp_data_0x11b[] = { 2, 0x65, 0x30c, };
+static const char32 __uni_decomp_data_0x11c[] = { 2, 0x47, 0x302, };
+static const char32 __uni_decomp_data_0x11d[] = { 2, 0x67, 0x302, };
+static const char32 __uni_decomp_data_0x11e[] = { 2, 0x47, 0x306, };
+static const char32 __uni_decomp_data_0x11f[] = { 2, 0x67, 0x306, };
+static const char32 __uni_decomp_data_0x120[] = { 2, 0x47, 0x307, };
+static const char32 __uni_decomp_data_0x121[] = { 2, 0x67, 0x307, };
+static const char32 __uni_decomp_data_0x122[] = { 2, 0x47, 0x327, };
+static const char32 __uni_decomp_data_0x123[] = { 2, 0x67, 0x327, };
+static const char32 __uni_decomp_data_0x124[] = { 2, 0x48, 0x302, };
+static const char32 __uni_decomp_data_0x125[] = { 2, 0x68, 0x302, };
+static const char32 __uni_decomp_data_0x128[] = { 2, 0x49, 0x303, };
+static const char32 __uni_decomp_data_0x129[] = { 2, 0x69, 0x303, };
+static const char32 __uni_decomp_data_0x12a[] = { 2, 0x49, 0x304, };
+static const char32 __uni_decomp_data_0x12b[] = { 2, 0x69, 0x304, };
+static const char32 __uni_decomp_data_0x12c[] = { 2, 0x49, 0x306, };
+static const char32 __uni_decomp_data_0x12d[] = { 2, 0x69, 0x306, };
+static const char32 __uni_decomp_data_0x12e[] = { 2, 0x49, 0x328, };
+static const char32 __uni_decomp_data_0x12f[] = { 2, 0x69, 0x328, };
+static const char32 __uni_decomp_data_0x130[] = { 2, 0x49, 0x307, };
+static const char32 __uni_decomp_data_0x132[] = { 2, 0x49, 0x4a, };
+static const char32 __uni_decomp_data_0x133[] = { 2, 0x69, 0x6a, };
+static const char32 __uni_decomp_data_0x134[] = { 2, 0x4a, 0x302, };
+static const char32 __uni_decomp_data_0x135[] = { 2, 0x6a, 0x302, };
+static const char32 __uni_decomp_data_0x136[] = { 2, 0x4b, 0x327, };
+static const char32 __uni_decomp_data_0x137[] = { 2, 0x6b, 0x327, };
+static const char32 __uni_decomp_data_0x139[] = { 2, 0x4c, 0x301, };
+static const char32 __uni_decomp_data_0x13a[] = { 2, 0x6c, 0x301, };
+static const char32 __uni_decomp_data_0x13b[] = { 2, 0x4c, 0x327, };
+static const char32 __uni_decomp_data_0x13c[] = { 2, 0x6c, 0x327, };
+static const char32 __uni_decomp_data_0x13d[] = { 2, 0x4c, 0x30c, };
+static const char32 __uni_decomp_data_0x13e[] = { 2, 0x6c, 0x30c, };
+static const char32 __uni_decomp_data_0x13f[] = { 2, 0x4c, 0xb7, };
+static const char32 __uni_decomp_data_0x140[] = { 2, 0x6c, 0xb7, };
+static const char32 __uni_decomp_data_0x143[] = { 2, 0x4e, 0x301, };
+static const char32 __uni_decomp_data_0x144[] = { 2, 0x6e, 0x301, };
+static const char32 __uni_decomp_data_0x145[] = { 2, 0x4e, 0x327, };
+static const char32 __uni_decomp_data_0x146[] = { 2, 0x6e, 0x327, };
+static const char32 __uni_decomp_data_0x147[] = { 2, 0x4e, 0x30c, };
+static const char32 __uni_decomp_data_0x148[] = { 2, 0x6e, 0x30c, };
+static const char32 __uni_decomp_data_0x149[] = { 2, 0x2bc, 0x6e, };
+static const char32 __uni_decomp_data_0x14c[] = { 2, 0x4f, 0x304, };
+static const char32 __uni_decomp_data_0x14d[] = { 2, 0x6f, 0x304, };
+static const char32 __uni_decomp_data_0x14e[] = { 2, 0x4f, 0x306, };
+static const char32 __uni_decomp_data_0x14f[] = { 2, 0x6f, 0x306, };
+static const char32 __uni_decomp_data_0x150[] = { 2, 0x4f, 0x30b, };
+static const char32 __uni_decomp_data_0x151[] = { 2, 0x6f, 0x30b, };
+static const char32 __uni_decomp_data_0x154[] = { 2, 0x52, 0x301, };
+static const char32 __uni_decomp_data_0x155[] = { 2, 0x72, 0x301, };
+static const char32 __uni_decomp_data_0x156[] = { 2, 0x52, 0x327, };
+static const char32 __uni_decomp_data_0x157[] = { 2, 0x72, 0x327, };
+static const char32 __uni_decomp_data_0x158[] = { 2, 0x52, 0x30c, };
+static const char32 __uni_decomp_data_0x159[] = { 2, 0x72, 0x30c, };
+static const char32 __uni_decomp_data_0x15a[] = { 2, 0x53, 0x301, };
+static const char32 __uni_decomp_data_0x15b[] = { 2, 0x73, 0x301, };
+static const char32 __uni_decomp_data_0x15c[] = { 2, 0x53, 0x302, };
+static const char32 __uni_decomp_data_0x15d[] = { 2, 0x73, 0x302, };
+static const char32 __uni_decomp_data_0x15e[] = { 2, 0x53, 0x327, };
+static const char32 __uni_decomp_data_0x15f[] = { 2, 0x73, 0x327, };
+static const char32 __uni_decomp_data_0x160[] = { 2, 0x53, 0x30c, };
+static const char32 __uni_decomp_data_0x161[] = { 2, 0x73, 0x30c, };
+static const char32 __uni_decomp_data_0x162[] = { 2, 0x54, 0x327, };
+static const char32 __uni_decomp_data_0x163[] = { 2, 0x74, 0x327, };
+static const char32 __uni_decomp_data_0x164[] = { 2, 0x54, 0x30c, };
+static const char32 __uni_decomp_data_0x165[] = { 2, 0x74, 0x30c, };
+static const char32 __uni_decomp_data_0x168[] = { 2, 0x55, 0x303, };
+static const char32 __uni_decomp_data_0x169[] = { 2, 0x75, 0x303, };
+static const char32 __uni_decomp_data_0x16a[] = { 2, 0x55, 0x304, };
+static const char32 __uni_decomp_data_0x16b[] = { 2, 0x75, 0x304, };
+static const char32 __uni_decomp_data_0x16c[] = { 2, 0x55, 0x306, };
+static const char32 __uni_decomp_data_0x16d[] = { 2, 0x75, 0x306, };
+static const char32 __uni_decomp_data_0x16e[] = { 2, 0x55, 0x30a, };
+static const char32 __uni_decomp_data_0x16f[] = { 2, 0x75, 0x30a, };
+static const char32 __uni_decomp_data_0x170[] = { 2, 0x55, 0x30b, };
+static const char32 __uni_decomp_data_0x171[] = { 2, 0x75, 0x30b, };
+static const char32 __uni_decomp_data_0x172[] = { 2, 0x55, 0x328, };
+static const char32 __uni_decomp_data_0x173[] = { 2, 0x75, 0x328, };
+static const char32 __uni_decomp_data_0x174[] = { 2, 0x57, 0x302, };
+static const char32 __uni_decomp_data_0x175[] = { 2, 0x77, 0x302, };
+static const char32 __uni_decomp_data_0x176[] = { 2, 0x59, 0x302, };
+static const char32 __uni_decomp_data_0x177[] = { 2, 0x79, 0x302, };
+static const char32 __uni_decomp_data_0x178[] = { 2, 0x59, 0x308, };
+static const char32 __uni_decomp_data_0x179[] = { 2, 0x5a, 0x301, };
+static const char32 __uni_decomp_data_0x17a[] = { 2, 0x7a, 0x301, };
+static const char32 __uni_decomp_data_0x17b[] = { 2, 0x5a, 0x307, };
+static const char32 __uni_decomp_data_0x17c[] = { 2, 0x7a, 0x307, };
+static const char32 __uni_decomp_data_0x17d[] = { 2, 0x5a, 0x30c, };
+static const char32 __uni_decomp_data_0x17e[] = { 2, 0x7a, 0x30c, };
+static const char32 __uni_decomp_data_0x17f[] = { 1, 0x73, };
 
 
 
@@ -5221,65 +5221,65 @@
 };
 
 
-static const char32 __uni_decomp_data_0x1a0[] = { 0x4f, 0x31b, 0, };
-static const char32 __uni_decomp_data_0x1a1[] = { 0x6f, 0x31b, 0, };
-static const char32 __uni_decomp_data_0x1af[] = { 0x55, 0x31b, 0, };
-static const char32 __uni_decomp_data_0x1b0[] = { 0x75, 0x31b, 0, };
-static const char32 __uni_decomp_data_0x1c4[] = { 0x44, 0x17d, 0, };
-static const char32 __uni_decomp_data_0x1c5[] = { 0x44, 0x17e, 0, };
-static const char32 __uni_decomp_data_0x1c6[] = { 0x64, 0x17e, 0, };
-static const char32 __uni_decomp_data_0x1c7[] = { 0x4c, 0x4a, 0, };
-static const char32 __uni_decomp_data_0x1c8[] = { 0x4c, 0x6a, 0, };
-static const char32 __uni_decomp_data_0x1c9[] = { 0x6c, 0x6a, 0, };
-static const char32 __uni_decomp_data_0x1ca[] = { 0x4e, 0x4a, 0, };
-static const char32 __uni_decomp_data_0x1cb[] = { 0x4e, 0x6a, 0, };
-static const char32 __uni_decomp_data_0x1cc[] = { 0x6e, 0x6a, 0, };
-static const char32 __uni_decomp_data_0x1cd[] = { 0x41, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x1ce[] = { 0x61, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x1cf[] = { 0x49, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x1d0[] = { 0x69, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x1d1[] = { 0x4f, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x1d2[] = { 0x6f, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x1d3[] = { 0x55, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x1d4[] = { 0x75, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x1d5[] = { 0xdc, 0x304, 0, };
-static const char32 __uni_decomp_data_0x1d6[] = { 0xfc, 0x304, 0, };
-static const char32 __uni_decomp_data_0x1d7[] = { 0xdc, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1d8[] = { 0xfc, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1d9[] = { 0xdc, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x1da[] = { 0xfc, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x1db[] = { 0xdc, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1dc[] = { 0xfc, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1de[] = { 0xc4, 0x304, 0, };
-static const char32 __uni_decomp_data_0x1df[] = { 0xe4, 0x304, 0, };
-static const char32 __uni_decomp_data_0x1e0[] = { 0x226, 0x304, 0, };
-static const char32 __uni_decomp_data_0x1e1[] = { 0x227, 0x304, 0, };
-static const char32 __uni_decomp_data_0x1e2[] = { 0xc6, 0x304, 0, };
-static const char32 __uni_decomp_data_0x1e3[] = { 0xe6, 0x304, 0, };
-static const char32 __uni_decomp_data_0x1e6[] = { 0x47, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x1e7[] = { 0x67, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x1e8[] = { 0x4b, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x1e9[] = { 0x6b, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x1ea[] = { 0x4f, 0x328, 0, };
-static const char32 __uni_decomp_data_0x1eb[] = { 0x6f, 0x328, 0, };
-static const char32 __uni_decomp_data_0x1ec[] = { 0x1ea, 0x304, 0, };
-static const char32 __uni_decomp_data_0x1ed[] = { 0x1eb, 0x304, 0, };
-static const char32 __uni_decomp_data_0x1ee[] = { 0x1b7, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x1ef[] = { 0x292, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x1f0[] = { 0x6a, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x1f1[] = { 0x44, 0x5a, 0, };
-static const char32 __uni_decomp_data_0x1f2[] = { 0x44, 0x7a, 0, };
-static const char32 __uni_decomp_data_0x1f3[] = { 0x64, 0x7a, 0, };
-static const char32 __uni_decomp_data_0x1f4[] = { 0x47, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1f5[] = { 0x67, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1f8[] = { 0x4e, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f9[] = { 0x6e, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1fa[] = { 0xc5, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1fb[] = { 0xe5, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1fc[] = { 0xc6, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1fd[] = { 0xe6, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1fe[] = { 0xd8, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1ff[] = { 0xf8, 0x301, 0, };
+static const char32 __uni_decomp_data_0x1a0[] = { 2, 0x4f, 0x31b, };
+static const char32 __uni_decomp_data_0x1a1[] = { 2, 0x6f, 0x31b, };
+static const char32 __uni_decomp_data_0x1af[] = { 2, 0x55, 0x31b, };
+static const char32 __uni_decomp_data_0x1b0[] = { 2, 0x75, 0x31b, };
+static const char32 __uni_decomp_data_0x1c4[] = { 2, 0x44, 0x17d, };
+static const char32 __uni_decomp_data_0x1c5[] = { 2, 0x44, 0x17e, };
+static const char32 __uni_decomp_data_0x1c6[] = { 2, 0x64, 0x17e, };
+static const char32 __uni_decomp_data_0x1c7[] = { 2, 0x4c, 0x4a, };
+static const char32 __uni_decomp_data_0x1c8[] = { 2, 0x4c, 0x6a, };
+static const char32 __uni_decomp_data_0x1c9[] = { 2, 0x6c, 0x6a, };
+static const char32 __uni_decomp_data_0x1ca[] = { 2, 0x4e, 0x4a, };
+static const char32 __uni_decomp_data_0x1cb[] = { 2, 0x4e, 0x6a, };
+static const char32 __uni_decomp_data_0x1cc[] = { 2, 0x6e, 0x6a, };
+static const char32 __uni_decomp_data_0x1cd[] = { 2, 0x41, 0x30c, };
+static const char32 __uni_decomp_data_0x1ce[] = { 2, 0x61, 0x30c, };
+static const char32 __uni_decomp_data_0x1cf[] = { 2, 0x49, 0x30c, };
+static const char32 __uni_decomp_data_0x1d0[] = { 2, 0x69, 0x30c, };
+static const char32 __uni_decomp_data_0x1d1[] = { 2, 0x4f, 0x30c, };
+static const char32 __uni_decomp_data_0x1d2[] = { 2, 0x6f, 0x30c, };
+static const char32 __uni_decomp_data_0x1d3[] = { 2, 0x55, 0x30c, };
+static const char32 __uni_decomp_data_0x1d4[] = { 2, 0x75, 0x30c, };
+static const char32 __uni_decomp_data_0x1d5[] = { 2, 0xdc, 0x304, };
+static const char32 __uni_decomp_data_0x1d6[] = { 2, 0xfc, 0x304, };
+static const char32 __uni_decomp_data_0x1d7[] = { 2, 0xdc, 0x301, };
+static const char32 __uni_decomp_data_0x1d8[] = { 2, 0xfc, 0x301, };
+static const char32 __uni_decomp_data_0x1d9[] = { 2, 0xdc, 0x30c, };
+static const char32 __uni_decomp_data_0x1da[] = { 2, 0xfc, 0x30c, };
+static const char32 __uni_decomp_data_0x1db[] = { 2, 0xdc, 0x300, };
+static const char32 __uni_decomp_data_0x1dc[] = { 2, 0xfc, 0x300, };
+static const char32 __uni_decomp_data_0x1de[] = { 2, 0xc4, 0x304, };
+static const char32 __uni_decomp_data_0x1df[] = { 2, 0xe4, 0x304, };
+static const char32 __uni_decomp_data_0x1e0[] = { 2, 0x226, 0x304, };
+static const char32 __uni_decomp_data_0x1e1[] = { 2, 0x227, 0x304, };
+static const char32 __uni_decomp_data_0x1e2[] = { 2, 0xc6, 0x304, };
+static const char32 __uni_decomp_data_0x1e3[] = { 2, 0xe6, 0x304, };
+static const char32 __uni_decomp_data_0x1e6[] = { 2, 0x47, 0x30c, };
+static const char32 __uni_decomp_data_0x1e7[] = { 2, 0x67, 0x30c, };
+static const char32 __uni_decomp_data_0x1e8[] = { 2, 0x4b, 0x30c, };
+static const char32 __uni_decomp_data_0x1e9[] = { 2, 0x6b, 0x30c, };
+static const char32 __uni_decomp_data_0x1ea[] = { 2, 0x4f, 0x328, };
+static const char32 __uni_decomp_data_0x1eb[] = { 2, 0x6f, 0x328, };
+static const char32 __uni_decomp_data_0x1ec[] = { 2, 0x1ea, 0x304, };
+static const char32 __uni_decomp_data_0x1ed[] = { 2, 0x1eb, 0x304, };
+static const char32 __uni_decomp_data_0x1ee[] = { 2, 0x1b7, 0x30c, };
+static const char32 __uni_decomp_data_0x1ef[] = { 2, 0x292, 0x30c, };
+static const char32 __uni_decomp_data_0x1f0[] = { 2, 0x6a, 0x30c, };
+static const char32 __uni_decomp_data_0x1f1[] = { 2, 0x44, 0x5a, };
+static const char32 __uni_decomp_data_0x1f2[] = { 2, 0x44, 0x7a, };
+static const char32 __uni_decomp_data_0x1f3[] = { 2, 0x64, 0x7a, };
+static const char32 __uni_decomp_data_0x1f4[] = { 2, 0x47, 0x301, };
+static const char32 __uni_decomp_data_0x1f5[] = { 2, 0x67, 0x301, };
+static const char32 __uni_decomp_data_0x1f8[] = { 2, 0x4e, 0x300, };
+static const char32 __uni_decomp_data_0x1f9[] = { 2, 0x6e, 0x300, };
+static const char32 __uni_decomp_data_0x1fa[] = { 2, 0xc5, 0x301, };
+static const char32 __uni_decomp_data_0x1fb[] = { 2, 0xe5, 0x301, };
+static const char32 __uni_decomp_data_0x1fc[] = { 2, 0xc6, 0x301, };
+static const char32 __uni_decomp_data_0x1fd[] = { 2, 0xe6, 0x301, };
+static const char32 __uni_decomp_data_0x1fe[] = { 2, 0xd8, 0x301, };
+static const char32 __uni_decomp_data_0x1ff[] = { 2, 0xf8, 0x301, };
 
 
 
@@ -6953,50 +6953,50 @@
 };
 
 
-static const char32 __uni_decomp_data_0x200[] = { 0x41, 0x30f, 0, };
-static const char32 __uni_decomp_data_0x201[] = { 0x61, 0x30f, 0, };
-static const char32 __uni_decomp_data_0x202[] = { 0x41, 0x311, 0, };
-static const char32 __uni_decomp_data_0x203[] = { 0x61, 0x311, 0, };
-static const char32 __uni_decomp_data_0x204[] = { 0x45, 0x30f, 0, };
-static const char32 __uni_decomp_data_0x205[] = { 0x65, 0x30f, 0, };
-static const char32 __uni_decomp_data_0x206[] = { 0x45, 0x311, 0, };
-static const char32 __uni_decomp_data_0x207[] = { 0x65, 0x311, 0, };
-static const char32 __uni_decomp_data_0x208[] = { 0x49, 0x30f, 0, };
-static const char32 __uni_decomp_data_0x209[] = { 0x69, 0x30f, 0, };
-static const char32 __uni_decomp_data_0x20a[] = { 0x49, 0x311, 0, };
-static const char32 __uni_decomp_data_0x20b[] = { 0x69, 0x311, 0, };
-static const char32 __uni_decomp_data_0x20c[] = { 0x4f, 0x30f, 0, };
-static const char32 __uni_decomp_data_0x20d[] = { 0x6f, 0x30f, 0, };
-static const char32 __uni_decomp_data_0x20e[] = { 0x4f, 0x311, 0, };
-static const char32 __uni_decomp_data_0x20f[] = { 0x6f, 0x311, 0, };
-static const char32 __uni_decomp_data_0x210[] = { 0x52, 0x30f, 0, };
-static const char32 __uni_decomp_data_0x211[] = { 0x72, 0x30f, 0, };
-static const char32 __uni_decomp_data_0x212[] = { 0x52, 0x311, 0, };
-static const char32 __uni_decomp_data_0x213[] = { 0x72, 0x311, 0, };
-static const char32 __uni_decomp_data_0x214[] = { 0x55, 0x30f, 0, };
-static const char32 __uni_decomp_data_0x215[] = { 0x75, 0x30f, 0, };
-static const char32 __uni_decomp_data_0x216[] = { 0x55, 0x311, 0, };
-static const char32 __uni_decomp_data_0x217[] = { 0x75, 0x311, 0, };
-static const char32 __uni_decomp_data_0x218[] = { 0x53, 0x326, 0, };
-static const char32 __uni_decomp_data_0x219[] = { 0x73, 0x326, 0, };
-static const char32 __uni_decomp_data_0x21a[] = { 0x54, 0x326, 0, };
-static const char32 __uni_decomp_data_0x21b[] = { 0x74, 0x326, 0, };
-static const char32 __uni_decomp_data_0x21e[] = { 0x48, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x21f[] = { 0x68, 0x30c, 0, };
-static const char32 __uni_decomp_data_0x226[] = { 0x41, 0x307, 0, };
-static const char32 __uni_decomp_data_0x227[] = { 0x61, 0x307, 0, };
-static const char32 __uni_decomp_data_0x228[] = { 0x45, 0x327, 0, };
-static const char32 __uni_decomp_data_0x229[] = { 0x65, 0x327, 0, };
-static const char32 __uni_decomp_data_0x22a[] = { 0xd6, 0x304, 0, };
-static const char32 __uni_decomp_data_0x22b[] = { 0xf6, 0x304, 0, };
-static const char32 __uni_decomp_data_0x22c[] = { 0xd5, 0x304, 0, };
-static const char32 __uni_decomp_data_0x22d[] = { 0xf5, 0x304, 0, };
-static const char32 __uni_decomp_data_0x22e[] = { 0x4f, 0x307, 0, };
-static const char32 __uni_decomp_data_0x22f[] = { 0x6f, 0x307, 0, };
-static const char32 __uni_decomp_data_0x230[] = { 0x22e, 0x304, 0, };
-static const char32 __uni_decomp_data_0x231[] = { 0x22f, 0x304, 0, };
-static const char32 __uni_decomp_data_0x232[] = { 0x59, 0x304, 0, };
-static const char32 __uni_decomp_data_0x233[] = { 0x79, 0x304, 0, };
+static const char32 __uni_decomp_data_0x200[] = { 2, 0x41, 0x30f, };
+static const char32 __uni_decomp_data_0x201[] = { 2, 0x61, 0x30f, };
+static const char32 __uni_decomp_data_0x202[] = { 2, 0x41, 0x311, };
+static const char32 __uni_decomp_data_0x203[] = { 2, 0x61, 0x311, };
+static const char32 __uni_decomp_data_0x204[] = { 2, 0x45, 0x30f, };
+static const char32 __uni_decomp_data_0x205[] = { 2, 0x65, 0x30f, };
+static const char32 __uni_decomp_data_0x206[] = { 2, 0x45, 0x311, };
+static const char32 __uni_decomp_data_0x207[] = { 2, 0x65, 0x311, };
+static const char32 __uni_decomp_data_0x208[] = { 2, 0x49, 0x30f, };
+static const char32 __uni_decomp_data_0x209[] = { 2, 0x69, 0x30f, };
+static const char32 __uni_decomp_data_0x20a[] = { 2, 0x49, 0x311, };
+static const char32 __uni_decomp_data_0x20b[] = { 2, 0x69, 0x311, };
+static const char32 __uni_decomp_data_0x20c[] = { 2, 0x4f, 0x30f, };
+static const char32 __uni_decomp_data_0x20d[] = { 2, 0x6f, 0x30f, };
+static const char32 __uni_decomp_data_0x20e[] = { 2, 0x4f, 0x311, };
+static const char32 __uni_decomp_data_0x20f[] = { 2, 0x6f, 0x311, };
+static const char32 __uni_decomp_data_0x210[] = { 2, 0x52, 0x30f, };
+static const char32 __uni_decomp_data_0x211[] = { 2, 0x72, 0x30f, };
+static const char32 __uni_decomp_data_0x212[] = { 2, 0x52, 0x311, };
+static const char32 __uni_decomp_data_0x213[] = { 2, 0x72, 0x311, };
+static const char32 __uni_decomp_data_0x214[] = { 2, 0x55, 0x30f, };
+static const char32 __uni_decomp_data_0x215[] = { 2, 0x75, 0x30f, };
+static const char32 __uni_decomp_data_0x216[] = { 2, 0x55, 0x311, };
+static const char32 __uni_decomp_data_0x217[] = { 2, 0x75, 0x311, };
+static const char32 __uni_decomp_data_0x218[] = { 2, 0x53, 0x326, };
+static const char32 __uni_decomp_data_0x219[] = { 2, 0x73, 0x326, };
+static const char32 __uni_decomp_data_0x21a[] = { 2, 0x54, 0x326, };
+static const char32 __uni_decomp_data_0x21b[] = { 2, 0x74, 0x326, };
+static const char32 __uni_decomp_data_0x21e[] = { 2, 0x48, 0x30c, };
+static const char32 __uni_decomp_data_0x21f[] = { 2, 0x68, 0x30c, };
+static const char32 __uni_decomp_data_0x226[] = { 2, 0x41, 0x307, };
+static const char32 __uni_decomp_data_0x227[] = { 2, 0x61, 0x307, };
+static const char32 __uni_decomp_data_0x228[] = { 2, 0x45, 0x327, };
+static const char32 __uni_decomp_data_0x229[] = { 2, 0x65, 0x327, };
+static const char32 __uni_decomp_data_0x22a[] = { 2, 0xd6, 0x304, };
+static const char32 __uni_decomp_data_0x22b[] = { 2, 0xf6, 0x304, };
+static const char32 __uni_decomp_data_0x22c[] = { 2, 0xd5, 0x304, };
+static const char32 __uni_decomp_data_0x22d[] = { 2, 0xf5, 0x304, };
+static const char32 __uni_decomp_data_0x22e[] = { 2, 0x4f, 0x307, };
+static const char32 __uni_decomp_data_0x22f[] = { 2, 0x6f, 0x307, };
+static const char32 __uni_decomp_data_0x230[] = { 2, 0x22e, 0x304, };
+static const char32 __uni_decomp_data_0x231[] = { 2, 0x22f, 0x304, };
+static const char32 __uni_decomp_data_0x232[] = { 2, 0x59, 0x304, };
+static const char32 __uni_decomp_data_0x233[] = { 2, 0x79, 0x304, };
 
 
 
@@ -8670,26 +8670,26 @@
 };
 
 
-static const char32 __uni_decomp_data_0x2b0[] = { 0x68, 0, };
-static const char32 __uni_decomp_data_0x2b1[] = { 0x266, 0, };
-static const char32 __uni_decomp_data_0x2b2[] = { 0x6a, 0, };
-static const char32 __uni_decomp_data_0x2b3[] = { 0x72, 0, };
-static const char32 __uni_decomp_data_0x2b4[] = { 0x279, 0, };
-static const char32 __uni_decomp_data_0x2b5[] = { 0x27b, 0, };
-static const char32 __uni_decomp_data_0x2b6[] = { 0x281, 0, };
-static const char32 __uni_decomp_data_0x2b7[] = { 0x77, 0, };
-static const char32 __uni_decomp_data_0x2b8[] = { 0x79, 0, };
-static const char32 __uni_decomp_data_0x2d8[] = { 0x20, 0x306, 0, };
-static const char32 __uni_decomp_data_0x2d9[] = { 0x20, 0x307, 0, };
-static const char32 __uni_decomp_data_0x2da[] = { 0x20, 0x30a, 0, };
-static const char32 __uni_decomp_data_0x2db[] = { 0x20, 0x328, 0, };
-static const char32 __uni_decomp_data_0x2dc[] = { 0x20, 0x303, 0, };
-static const char32 __uni_decomp_data_0x2dd[] = { 0x20, 0x30b, 0, };
-static const char32 __uni_decomp_data_0x2e0[] = { 0x263, 0, };
-static const char32 __uni_decomp_data_0x2e1[] = { 0x6c, 0, };
-static const char32 __uni_decomp_data_0x2e2[] = { 0x73, 0, };
-static const char32 __uni_decomp_data_0x2e3[] = { 0x78, 0, };
-static const char32 __uni_decomp_data_0x2e4[] = { 0x295, 0, };
+static const char32 __uni_decomp_data_0x2b0[] = { 1, 0x68, };
+static const char32 __uni_decomp_data_0x2b1[] = { 1, 0x266, };
+static const char32 __uni_decomp_data_0x2b2[] = { 1, 0x6a, };
+static const char32 __uni_decomp_data_0x2b3[] = { 1, 0x72, };
+static const char32 __uni_decomp_data_0x2b4[] = { 1, 0x279, };
+static const char32 __uni_decomp_data_0x2b5[] = { 1, 0x27b, };
+static const char32 __uni_decomp_data_0x2b6[] = { 1, 0x281, };
+static const char32 __uni_decomp_data_0x2b7[] = { 1, 0x77, };
+static const char32 __uni_decomp_data_0x2b8[] = { 1, 0x79, };
+static const char32 __uni_decomp_data_0x2d8[] = { 2, 0x20, 0x306, };
+static const char32 __uni_decomp_data_0x2d9[] = { 2, 0x20, 0x307, };
+static const char32 __uni_decomp_data_0x2da[] = { 2, 0x20, 0x30a, };
+static const char32 __uni_decomp_data_0x2db[] = { 2, 0x20, 0x328, };
+static const char32 __uni_decomp_data_0x2dc[] = { 2, 0x20, 0x303, };
+static const char32 __uni_decomp_data_0x2dd[] = { 2, 0x20, 0x30b, };
+static const char32 __uni_decomp_data_0x2e0[] = { 1, 0x263, };
+static const char32 __uni_decomp_data_0x2e1[] = { 1, 0x6c, };
+static const char32 __uni_decomp_data_0x2e2[] = { 1, 0x73, };
+static const char32 __uni_decomp_data_0x2e3[] = { 1, 0x78, };
+static const char32 __uni_decomp_data_0x2e4[] = { 1, 0x295, };
 
 
 
@@ -10363,13 +10363,13 @@
 };
 
 
-static const char32 __uni_decomp_data_0x340[] = { 0x300, 0, };
-static const char32 __uni_decomp_data_0x341[] = { 0x301, 0, };
-static const char32 __uni_decomp_data_0x343[] = { 0x313, 0, };
-static const char32 __uni_decomp_data_0x344[] = { 0x308, 0x301, 0, };
-static const char32 __uni_decomp_data_0x374[] = { 0x2b9, 0, };
-static const char32 __uni_decomp_data_0x37a[] = { 0x20, 0x345, 0, };
-static const char32 __uni_decomp_data_0x37e[] = { 0x3b, 0, };
+static const char32 __uni_decomp_data_0x340[] = { 1, 0x300, };
+static const char32 __uni_decomp_data_0x341[] = { 1, 0x301, };
+static const char32 __uni_decomp_data_0x343[] = { 1, 0x313, };
+static const char32 __uni_decomp_data_0x344[] = { 2, 0x308, 0x301, };
+static const char32 __uni_decomp_data_0x374[] = { 1, 0x2b9, };
+static const char32 __uni_decomp_data_0x37a[] = { 2, 0x20, 0x345, };
+static const char32 __uni_decomp_data_0x37e[] = { 1, 0x3b, };
 
 
 
@@ -12043,42 +12043,42 @@
 };
 
 
-static const char32 __uni_decomp_data_0x384[] = { 0x20, 0x301, 0, };
-static const char32 __uni_decomp_data_0x385[] = { 0xa8, 0x301, 0, };
-static const char32 __uni_decomp_data_0x386[] = { 0x391, 0x301, 0, };
-static const char32 __uni_decomp_data_0x387[] = { 0xb7, 0, };
-static const char32 __uni_decomp_data_0x388[] = { 0x395, 0x301, 0, };
-static const char32 __uni_decomp_data_0x389[] = { 0x397, 0x301, 0, };
-static const char32 __uni_decomp_data_0x38a[] = { 0x399, 0x301, 0, };
-static const char32 __uni_decomp_data_0x38c[] = { 0x39f, 0x301, 0, };
-static const char32 __uni_decomp_data_0x38e[] = { 0x3a5, 0x301, 0, };
-static const char32 __uni_decomp_data_0x38f[] = { 0x3a9, 0x301, 0, };
-static const char32 __uni_decomp_data_0x390[] = { 0x3ca, 0x301, 0, };
-static const char32 __uni_decomp_data_0x3aa[] = { 0x399, 0x308, 0, };
-static const char32 __uni_decomp_data_0x3ab[] = { 0x3a5, 0x308, 0, };
-static const char32 __uni_decomp_data_0x3ac[] = { 0x3b1, 0x301, 0, };
-static const char32 __uni_decomp_data_0x3ad[] = { 0x3b5, 0x301, 0, };
-static const char32 __uni_decomp_data_0x3ae[] = { 0x3b7, 0x301, 0, };
-static const char32 __uni_decomp_data_0x3af[] = { 0x3b9, 0x301, 0, };
-static const char32 __uni_decomp_data_0x3b0[] = { 0x3cb, 0x301, 0, };
-static const char32 __uni_decomp_data_0x3ca[] = { 0x3b9, 0x308, 0, };
-static const char32 __uni_decomp_data_0x3cb[] = { 0x3c5, 0x308, 0, };
-static const char32 __uni_decomp_data_0x3cc[] = { 0x3bf, 0x301, 0, };
-static const char32 __uni_decomp_data_0x3cd[] = { 0x3c5, 0x301, 0, };
-static const char32 __uni_decomp_data_0x3ce[] = { 0x3c9, 0x301, 0, };
-static const char32 __uni_decomp_data_0x3d0[] = { 0x3b2, 0, };
-static const char32 __uni_decomp_data_0x3d1[] = { 0x3b8, 0, };
-static const char32 __uni_decomp_data_0x3d2[] = { 0x3a5, 0, };
-static const char32 __uni_decomp_data_0x3d3[] = { 0x3d2, 0x301, 0, };
-static const char32 __uni_decomp_data_0x3d4[] = { 0x3d2, 0x308, 0, };
-static const char32 __uni_decomp_data_0x3d5[] = { 0x3c6, 0, };
-static const char32 __uni_decomp_data_0x3d6[] = { 0x3c0, 0, };
-static const char32 __uni_decomp_data_0x3f0[] = { 0x3ba, 0, };
-static const char32 __uni_decomp_data_0x3f1[] = { 0x3c1, 0, };
-static const char32 __uni_decomp_data_0x3f2[] = { 0x3c2, 0, };
-static const char32 __uni_decomp_data_0x3f4[] = { 0x398, 0, };
-static const char32 __uni_decomp_data_0x3f5[] = { 0x3b5, 0, };
-static const char32 __uni_decomp_data_0x3f9[] = { 0x3a3, 0, };
+static const char32 __uni_decomp_data_0x384[] = { 2, 0x20, 0x301, };
+static const char32 __uni_decomp_data_0x385[] = { 2, 0xa8, 0x301, };
+static const char32 __uni_decomp_data_0x386[] = { 2, 0x391, 0x301, };
+static const char32 __uni_decomp_data_0x387[] = { 1, 0xb7, };
+static const char32 __uni_decomp_data_0x388[] = { 2, 0x395, 0x301, };
+static const char32 __uni_decomp_data_0x389[] = { 2, 0x397, 0x301, };
+static const char32 __uni_decomp_data_0x38a[] = { 2, 0x399, 0x301, };
+static const char32 __uni_decomp_data_0x38c[] = { 2, 0x39f, 0x301, };
+static const char32 __uni_decomp_data_0x38e[] = { 2, 0x3a5, 0x301, };
+static const char32 __uni_decomp_data_0x38f[] = { 2, 0x3a9, 0x301, };
+static const char32 __uni_decomp_data_0x390[] = { 2, 0x3ca, 0x301, };
+static const char32 __uni_decomp_data_0x3aa[] = { 2, 0x399, 0x308, };
+static const char32 __uni_decomp_data_0x3ab[] = { 2, 0x3a5, 0x308, };
+static const char32 __uni_decomp_data_0x3ac[] = { 2, 0x3b1, 0x301, };
+static const char32 __uni_decomp_data_0x3ad[] = { 2, 0x3b5, 0x301, };
+static const char32 __uni_decomp_data_0x3ae[] = { 2, 0x3b7, 0x301, };
+static const char32 __uni_decomp_data_0x3af[] = { 2, 0x3b9, 0x301, };
+static const char32 __uni_decomp_data_0x3b0[] = { 2, 0x3cb, 0x301, };
+static const char32 __uni_decomp_data_0x3ca[] = { 2, 0x3b9, 0x308, };
+static const char32 __uni_decomp_data_0x3cb[] = { 2, 0x3c5, 0x308, };
+static const char32 __uni_decomp_data_0x3cc[] = { 2, 0x3bf, 0x301, };
+static const char32 __uni_decomp_data_0x3cd[] = { 2, 0x3c5, 0x301, };
+static const char32 __uni_decomp_data_0x3ce[] = { 2, 0x3c9, 0x301, };
+static const char32 __uni_decomp_data_0x3d0[] = { 1, 0x3b2, };
+static const char32 __uni_decomp_data_0x3d1[] = { 1, 0x3b8, };
+static const char32 __uni_decomp_data_0x3d2[] = { 1, 0x3a5, };
+static const char32 __uni_decomp_data_0x3d3[] = { 2, 0x3d2, 0x301, };
+static const char32 __uni_decomp_data_0x3d4[] = { 2, 0x3d2, 0x308, };
+static const char32 __uni_decomp_data_0x3d5[] = { 1, 0x3c6, };
+static const char32 __uni_decomp_data_0x3d6[] = { 1, 0x3c0, };
+static const char32 __uni_decomp_data_0x3f0[] = { 1, 0x3ba, };
+static const char32 __uni_decomp_data_0x3f1[] = { 1, 0x3c1, };
+static const char32 __uni_decomp_data_0x3f2[] = { 1, 0x3c2, };
+static const char32 __uni_decomp_data_0x3f4[] = { 1, 0x398, };
+static const char32 __uni_decomp_data_0x3f5[] = { 1, 0x3b5, };
+static const char32 __uni_decomp_data_0x3f9[] = { 1, 0x3a3, };
 
 
 
@@ -13752,24 +13752,24 @@
 };
 
 
-static const char32 __uni_decomp_data_0x400[] = { 0x415, 0x300, 0, };
-static const char32 __uni_decomp_data_0x401[] = { 0x415, 0x308, 0, };
-static const char32 __uni_decomp_data_0x403[] = { 0x413, 0x301, 0, };
-static const char32 __uni_decomp_data_0x407[] = { 0x406, 0x308, 0, };
-static const char32 __uni_decomp_data_0x40c[] = { 0x41a, 0x301, 0, };
-static const char32 __uni_decomp_data_0x40d[] = { 0x418, 0x300, 0, };
-static const char32 __uni_decomp_data_0x40e[] = { 0x423, 0x306, 0, };
-static const char32 __uni_decomp_data_0x419[] = { 0x418, 0x306, 0, };
-static const char32 __uni_decomp_data_0x439[] = { 0x438, 0x306, 0, };
-static const char32 __uni_decomp_data_0x450[] = { 0x435, 0x300, 0, };
-static const char32 __uni_decomp_data_0x451[] = { 0x435, 0x308, 0, };
-static const char32 __uni_decomp_data_0x453[] = { 0x433, 0x301, 0, };
-static const char32 __uni_decomp_data_0x457[] = { 0x456, 0x308, 0, };
-static const char32 __uni_decomp_data_0x45c[] = { 0x43a, 0x301, 0, };
-static const char32 __uni_decomp_data_0x45d[] = { 0x438, 0x300, 0, };
-static const char32 __uni_decomp_data_0x45e[] = { 0x443, 0x306, 0, };
-static const char32 __uni_decomp_data_0x476[] = { 0x474, 0x30f, 0, };
-static const char32 __uni_decomp_data_0x477[] = { 0x475, 0x30f, 0, };
+static const char32 __uni_decomp_data_0x400[] = { 2, 0x415, 0x300, };
+static const char32 __uni_decomp_data_0x401[] = { 2, 0x415, 0x308, };
+static const char32 __uni_decomp_data_0x403[] = { 2, 0x413, 0x301, };
+static const char32 __uni_decomp_data_0x407[] = { 2, 0x406, 0x308, };
+static const char32 __uni_decomp_data_0x40c[] = { 2, 0x41a, 0x301, };
+static const char32 __uni_decomp_data_0x40d[] = { 2, 0x418, 0x300, };
+static const char32 __uni_decomp_data_0x40e[] = { 2, 0x423, 0x306, };
+static const char32 __uni_decomp_data_0x419[] = { 2, 0x418, 0x306, };
+static const char32 __uni_decomp_data_0x439[] = { 2, 0x438, 0x306, };
+static const char32 __uni_decomp_data_0x450[] = { 2, 0x435, 0x300, };
+static const char32 __uni_decomp_data_0x451[] = { 2, 0x435, 0x308, };
+static const char32 __uni_decomp_data_0x453[] = { 2, 0x433, 0x301, };
+static const char32 __uni_decomp_data_0x457[] = { 2, 0x456, 0x308, };
+static const char32 __uni_decomp_data_0x45c[] = { 2, 0x43a, 0x301, };
+static const char32 __uni_decomp_data_0x45d[] = { 2, 0x438, 0x300, };
+static const char32 __uni_decomp_data_0x45e[] = { 2, 0x443, 0x306, };
+static const char32 __uni_decomp_data_0x476[] = { 2, 0x474, 0x30f, };
+static const char32 __uni_decomp_data_0x477[] = { 2, 0x475, 0x30f, };
 
 
 
@@ -15443,40 +15443,40 @@
 };
 
 
-static const char32 __uni_decomp_data_0x4c1[] = { 0x416, 0x306, 0, };
-static const char32 __uni_decomp_data_0x4c2[] = { 0x436, 0x306, 0, };
-static const char32 __uni_decomp_data_0x4d0[] = { 0x410, 0x306, 0, };
-static const char32 __uni_decomp_data_0x4d1[] = { 0x430, 0x306, 0, };
-static const char32 __uni_decomp_data_0x4d2[] = { 0x410, 0x308, 0, };
-static const char32 __uni_decomp_data_0x4d3[] = { 0x430, 0x308, 0, };
-static const char32 __uni_decomp_data_0x4d6[] = { 0x415, 0x306, 0, };
-static const char32 __uni_decomp_data_0x4d7[] = { 0x435, 0x306, 0, };
-static const char32 __uni_decomp_data_0x4da[] = { 0x4d8, 0x308, 0, };
-static const char32 __uni_decomp_data_0x4db[] = { 0x4d9, 0x308, 0, };
-static const char32 __uni_decomp_data_0x4dc[] = { 0x416, 0x308, 0, };
-static const char32 __uni_decomp_data_0x4dd[] = { 0x436, 0x308, 0, };
-static const char32 __uni_decomp_data_0x4de[] = { 0x417, 0x308, 0, };
-static const char32 __uni_decomp_data_0x4df[] = { 0x437, 0x308, 0, };
-static const char32 __uni_decomp_data_0x4e2[] = { 0x418, 0x304, 0, };
-static const char32 __uni_decomp_data_0x4e3[] = { 0x438, 0x304, 0, };
-static const char32 __uni_decomp_data_0x4e4[] = { 0x418, 0x308, 0, };
-static const char32 __uni_decomp_data_0x4e5[] = { 0x438, 0x308, 0, };
-static const char32 __uni_decomp_data_0x4e6[] = { 0x41e, 0x308, 0, };
-static const char32 __uni_decomp_data_0x4e7[] = { 0x43e, 0x308, 0, };
-static const char32 __uni_decomp_data_0x4ea[] = { 0x4e8, 0x308, 0, };
-static const char32 __uni_decomp_data_0x4eb[] = { 0x4e9, 0x308, 0, };
-static const char32 __uni_decomp_data_0x4ec[] = { 0x42d, 0x308, 0, };
-static const char32 __uni_decomp_data_0x4ed[] = { 0x44d, 0x308, 0, };
-static const char32 __uni_decomp_data_0x4ee[] = { 0x423, 0x304, 0, };
-static const char32 __uni_decomp_data_0x4ef[] = { 0x443, 0x304, 0, };
-static const char32 __uni_decomp_data_0x4f0[] = { 0x423, 0x308, 0, };
-static const char32 __uni_decomp_data_0x4f1[] = { 0x443, 0x308, 0, };
-static const char32 __uni_decomp_data_0x4f2[] = { 0x423, 0x30b, 0, };
-static const char32 __uni_decomp_data_0x4f3[] = { 0x443, 0x30b, 0, };
-static const char32 __uni_decomp_data_0x4f4[] = { 0x427, 0x308, 0, };
-static const char32 __uni_decomp_data_0x4f5[] = { 0x447, 0x308, 0, };
-static const char32 __uni_decomp_data_0x4f8[] = { 0x42b, 0x308, 0, };
-static const char32 __uni_decomp_data_0x4f9[] = { 0x44b, 0x308, 0, };
+static const char32 __uni_decomp_data_0x4c1[] = { 2, 0x416, 0x306, };
+static const char32 __uni_decomp_data_0x4c2[] = { 2, 0x436, 0x306, };
+static const char32 __uni_decomp_data_0x4d0[] = { 2, 0x410, 0x306, };
+static const char32 __uni_decomp_data_0x4d1[] = { 2, 0x430, 0x306, };
+static const char32 __uni_decomp_data_0x4d2[] = { 2, 0x410, 0x308, };
+static const char32 __uni_decomp_data_0x4d3[] = { 2, 0x430, 0x308, };
+static const char32 __uni_decomp_data_0x4d6[] = { 2, 0x415, 0x306, };
+static const char32 __uni_decomp_data_0x4d7[] = { 2, 0x435, 0x306, };
+static const char32 __uni_decomp_data_0x4da[] = { 2, 0x4d8, 0x308, };
+static const char32 __uni_decomp_data_0x4db[] = { 2, 0x4d9, 0x308, };
+static const char32 __uni_decomp_data_0x4dc[] = { 2, 0x416, 0x308, };
+static const char32 __uni_decomp_data_0x4dd[] = { 2, 0x436, 0x308, };
+static const char32 __uni_decomp_data_0x4de[] = { 2, 0x417, 0x308, };
+static const char32 __uni_decomp_data_0x4df[] = { 2, 0x437, 0x308, };
+static const char32 __uni_decomp_data_0x4e2[] = { 2, 0x418, 0x304, };
+static const char32 __uni_decomp_data_0x4e3[] = { 2, 0x438, 0x304, };
+static const char32 __uni_decomp_data_0x4e4[] = { 2, 0x418, 0x308, };
+static const char32 __uni_decomp_data_0x4e5[] = { 2, 0x438, 0x308, };
+static const char32 __uni_decomp_data_0x4e6[] = { 2, 0x41e, 0x308, };
+static const char32 __uni_decomp_data_0x4e7[] = { 2, 0x43e, 0x308, };
+static const char32 __uni_decomp_data_0x4ea[] = { 2, 0x4e8, 0x308, };
+static const char32 __uni_decomp_data_0x4eb[] = { 2, 0x4e9, 0x308, };
+static const char32 __uni_decomp_data_0x4ec[] = { 2, 0x42d, 0x308, };
+static const char32 __uni_decomp_data_0x4ed[] = { 2, 0x44d, 0x308, };
+static const char32 __uni_decomp_data_0x4ee[] = { 2, 0x423, 0x304, };
+static const char32 __uni_decomp_data_0x4ef[] = { 2, 0x443, 0x304, };
+static const char32 __uni_decomp_data_0x4f0[] = { 2, 0x423, 0x308, };
+static const char32 __uni_decomp_data_0x4f1[] = { 2, 0x443, 0x308, };
+static const char32 __uni_decomp_data_0x4f2[] = { 2, 0x423, 0x30b, };
+static const char32 __uni_decomp_data_0x4f3[] = { 2, 0x443, 0x30b, };
+static const char32 __uni_decomp_data_0x4f4[] = { 2, 0x427, 0x308, };
+static const char32 __uni_decomp_data_0x4f5[] = { 2, 0x447, 0x308, };
+static const char32 __uni_decomp_data_0x4f8[] = { 2, 0x42b, 0x308, };
+static const char32 __uni_decomp_data_0x4f9[] = { 2, 0x44b, 0x308, };
 
 
 
@@ -18823,7 +18823,7 @@
 };
 
 
-static const char32 __uni_decomp_data_0x587[] = { 0x565, 0x582, 0, };
+static const char32 __uni_decomp_data_0x587[] = { 2, 0x565, 0x582, };
 
 
 
@@ -20497,15 +20497,15 @@
 };
 
 
-static const char32 __uni_decomp_data_0x622[] = { 0x627, 0x653, 0, };
-static const char32 __uni_decomp_data_0x623[] = { 0x627, 0x654, 0, };
-static const char32 __uni_decomp_data_0x624[] = { 0x648, 0x654, 0, };
-static const char32 __uni_decomp_data_0x625[] = { 0x627, 0x655, 0, };
-static const char32 __uni_decomp_data_0x626[] = { 0x64a, 0x654, 0, };
-static const char32 __uni_decomp_data_0x675[] = { 0x627, 0x674, 0, };
-static const char32 __uni_decomp_data_0x676[] = { 0x648, 0x674, 0, };
-static const char32 __uni_decomp_data_0x677[] = { 0x6c7, 0x674, 0, };
-static const char32 __uni_decomp_data_0x678[] = { 0x64a, 0x674, 0, };
+static const char32 __uni_decomp_data_0x622[] = { 2, 0x627, 0x653, };
+static const char32 __uni_decomp_data_0x623[] = { 2, 0x627, 0x654, };
+static const char32 __uni_decomp_data_0x624[] = { 2, 0x648, 0x654, };
+static const char32 __uni_decomp_data_0x625[] = { 2, 0x627, 0x655, };
+static const char32 __uni_decomp_data_0x626[] = { 2, 0x64a, 0x654, };
+static const char32 __uni_decomp_data_0x675[] = { 2, 0x627, 0x674, };
+static const char32 __uni_decomp_data_0x676[] = { 2, 0x648, 0x674, };
+static const char32 __uni_decomp_data_0x677[] = { 2, 0x6c7, 0x674, };
+static const char32 __uni_decomp_data_0x678[] = { 2, 0x64a, 0x674, };
 
 
 
@@ -22179,9 +22179,9 @@
 };
 
 
-static const char32 __uni_decomp_data_0x6c0[] = { 0x6d5, 0x654, 0, };
-static const char32 __uni_decomp_data_0x6c2[] = { 0x6c1, 0x654, 0, };
-static const char32 __uni_decomp_data_0x6d3[] = { 0x6d2, 0x654, 0, };
+static const char32 __uni_decomp_data_0x6c0[] = { 2, 0x6d5, 0x654, };
+static const char32 __uni_decomp_data_0x6c2[] = { 2, 0x6c1, 0x654, };
+static const char32 __uni_decomp_data_0x6d3[] = { 2, 0x6d2, 0x654, };
 
 
 
@@ -28874,17 +28874,17 @@
 };
 
 
-static const char32 __uni_decomp_data_0x929[] = { 0x928, 0x93c, 0, };
-static const char32 __uni_decomp_data_0x931[] = { 0x930, 0x93c, 0, };
-static const char32 __uni_decomp_data_0x934[] = { 0x933, 0x93c, 0, };
-static const char32 __uni_decomp_data_0x958[] = { 0x915, 0x93c, 0, };
-static const char32 __uni_decomp_data_0x959[] = { 0x916, 0x93c, 0, };
-static const char32 __uni_decomp_data_0x95a[] = { 0x917, 0x93c, 0, };
-static const char32 __uni_decomp_data_0x95b[] = { 0x91c, 0x93c, 0, };
-static const char32 __uni_decomp_data_0x95c[] = { 0x921, 0x93c, 0, };
-static const char32 __uni_decomp_data_0x95d[] = { 0x922, 0x93c, 0, };
-static const char32 __uni_decomp_data_0x95e[] = { 0x92b, 0x93c, 0, };
-static const char32 __uni_decomp_data_0x95f[] = { 0x92f, 0x93c, 0, };
+static const char32 __uni_decomp_data_0x929[] = { 2, 0x928, 0x93c, };
+static const char32 __uni_decomp_data_0x931[] = { 2, 0x930, 0x93c, };
+static const char32 __uni_decomp_data_0x934[] = { 2, 0x933, 0x93c, };
+static const char32 __uni_decomp_data_0x958[] = { 2, 0x915, 0x93c, };
+static const char32 __uni_decomp_data_0x959[] = { 2, 0x916, 0x93c, };
+static const char32 __uni_decomp_data_0x95a[] = { 2, 0x917, 0x93c, };
+static const char32 __uni_decomp_data_0x95b[] = { 2, 0x91c, 0x93c, };
+static const char32 __uni_decomp_data_0x95c[] = { 2, 0x921, 0x93c, };
+static const char32 __uni_decomp_data_0x95d[] = { 2, 0x922, 0x93c, };
+static const char32 __uni_decomp_data_0x95e[] = { 2, 0x92b, 0x93c, };
+static const char32 __uni_decomp_data_0x95f[] = { 2, 0x92f, 0x93c, };
 
 
 
@@ -30558,11 +30558,11 @@
 };
 
 
-static const char32 __uni_decomp_data_0x9cb[] = { 0x9c7, 0x9be, 0, };
-static const char32 __uni_decomp_data_0x9cc[] = { 0x9c7, 0x9d7, 0, };
-static const char32 __uni_decomp_data_0x9dc[] = { 0x9a1, 0x9bc, 0, };
-static const char32 __uni_decomp_data_0x9dd[] = { 0x9a2, 0x9bc, 0, };
-static const char32 __uni_decomp_data_0x9df[] = { 0x9af, 0x9bc, 0, };
+static const char32 __uni_decomp_data_0x9cb[] = { 2, 0x9c7, 0x9be, };
+static const char32 __uni_decomp_data_0x9cc[] = { 2, 0x9c7, 0x9d7, };
+static const char32 __uni_decomp_data_0x9dc[] = { 2, 0x9a1, 0x9bc, };
+static const char32 __uni_decomp_data_0x9dd[] = { 2, 0x9a2, 0x9bc, };
+static const char32 __uni_decomp_data_0x9df[] = { 2, 0x9af, 0x9bc, };
 
 
 
@@ -32236,12 +32236,12 @@
 };
 
 
-static const char32 __uni_decomp_data_0xa33[] = { 0xa32, 0xa3c, 0, };
-static const char32 __uni_decomp_data_0xa36[] = { 0xa38, 0xa3c, 0, };
-static const char32 __uni_decomp_data_0xa59[] = { 0xa16, 0xa3c, 0, };
-static const char32 __uni_decomp_data_0xa5a[] = { 0xa17, 0xa3c, 0, };
-static const char32 __uni_decomp_data_0xa5b[] = { 0xa1c, 0xa3c, 0, };
-static const char32 __uni_decomp_data_0xa5e[] = { 0xa2b, 0xa3c, 0, };
+static const char32 __uni_decomp_data_0xa33[] = { 2, 0xa32, 0xa3c, };
+static const char32 __uni_decomp_data_0xa36[] = { 2, 0xa38, 0xa3c, };
+static const char32 __uni_decomp_data_0xa59[] = { 2, 0xa16, 0xa3c, };
+static const char32 __uni_decomp_data_0xa5a[] = { 2, 0xa17, 0xa3c, };
+static const char32 __uni_decomp_data_0xa5b[] = { 2, 0xa1c, 0xa3c, };
+static const char32 __uni_decomp_data_0xa5e[] = { 2, 0xa2b, 0xa3c, };
 
 
 
@@ -35588,11 +35588,11 @@
 };
 
 
-static const char32 __uni_decomp_data_0xb48[] = { 0xb47, 0xb56, 0, };
-static const char32 __uni_decomp_data_0xb4b[] = { 0xb47, 0xb3e, 0, };
-static const char32 __uni_decomp_data_0xb4c[] = { 0xb47, 0xb57, 0, };
-static const char32 __uni_decomp_data_0xb5c[] = { 0xb21, 0xb3c, 0, };
-static const char32 __uni_decomp_data_0xb5d[] = { 0xb22, 0xb3c, 0, };
+static const char32 __uni_decomp_data_0xb48[] = { 2, 0xb47, 0xb56, };
+static const char32 __uni_decomp_data_0xb4b[] = { 2, 0xb47, 0xb3e, };
+static const char32 __uni_decomp_data_0xb4c[] = { 2, 0xb47, 0xb57, };
+static const char32 __uni_decomp_data_0xb5c[] = { 2, 0xb21, 0xb3c, };
+static const char32 __uni_decomp_data_0xb5d[] = { 2, 0xb22, 0xb3c, };
 
 
 
@@ -37266,10 +37266,10 @@
 };
 
 
-static const char32 __uni_decomp_data_0xb94[] = { 0xb92, 0xbd7, 0, };
-static const char32 __uni_decomp_data_0xbca[] = { 0xbc6, 0xbbe, 0, };
-static const char32 __uni_decomp_data_0xbcb[] = { 0xbc7, 0xbbe, 0, };
-static const char32 __uni_decomp_data_0xbcc[] = { 0xbc6, 0xbd7, 0, };
+static const char32 __uni_decomp_data_0xb94[] = { 2, 0xb92, 0xbd7, };
+static const char32 __uni_decomp_data_0xbca[] = { 2, 0xbc6, 0xbbe, };
+static const char32 __uni_decomp_data_0xbcb[] = { 2, 0xbc7, 0xbbe, };
+static const char32 __uni_decomp_data_0xbcc[] = { 2, 0xbc6, 0xbd7, };
 
 
 
@@ -38943,7 +38943,7 @@
 };
 
 
-static const char32 __uni_decomp_data_0xc48[] = { 0xc46, 0xc56, 0, };
+static const char32 __uni_decomp_data_0xc48[] = { 2, 0xc46, 0xc56, };
 
 
 

Modified: sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_2.ipp
==============================================================================
--- sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_2.ipp	(original)
+++ sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_2.ipp	2009-08-06 03:26:39 EDT (Thu, 06 Aug 2009)
@@ -21,11 +21,11 @@
 
 
 namespace boost { namespace unicode { namespace ucd {
-static const char32 __uni_decomp_data_0xcc0[] = { 0xcbf, 0xcd5, 0, };
-static const char32 __uni_decomp_data_0xcc7[] = { 0xcc6, 0xcd5, 0, };
-static const char32 __uni_decomp_data_0xcc8[] = { 0xcc6, 0xcd6, 0, };
-static const char32 __uni_decomp_data_0xcca[] = { 0xcc6, 0xcc2, 0, };
-static const char32 __uni_decomp_data_0xccb[] = { 0xcca, 0xcd5, 0, };
+static const char32 __uni_decomp_data_0xcc0[] = { 2, 0xcbf, 0xcd5, };
+static const char32 __uni_decomp_data_0xcc7[] = { 2, 0xcc6, 0xcd5, };
+static const char32 __uni_decomp_data_0xcc8[] = { 2, 0xcc6, 0xcd6, };
+static const char32 __uni_decomp_data_0xcca[] = { 2, 0xcc6, 0xcc2, };
+static const char32 __uni_decomp_data_0xccb[] = { 2, 0xcca, 0xcd5, };
 
 
 
@@ -1699,9 +1699,9 @@
 };
 
 
-static const char32 __uni_decomp_data_0xd4a[] = { 0xd46, 0xd3e, 0, };
-static const char32 __uni_decomp_data_0xd4b[] = { 0xd47, 0xd3e, 0, };
-static const char32 __uni_decomp_data_0xd4c[] = { 0xd46, 0xd57, 0, };
+static const char32 __uni_decomp_data_0xd4a[] = { 2, 0xd46, 0xd3e, };
+static const char32 __uni_decomp_data_0xd4b[] = { 2, 0xd47, 0xd3e, };
+static const char32 __uni_decomp_data_0xd4c[] = { 2, 0xd46, 0xd57, };
 
 
 
@@ -3375,10 +3375,10 @@
 };
 
 
-static const char32 __uni_decomp_data_0xdda[] = { 0xdd9, 0xdca, 0, };
-static const char32 __uni_decomp_data_0xddc[] = { 0xdd9, 0xdcf, 0, };
-static const char32 __uni_decomp_data_0xddd[] = { 0xddc, 0xdca, 0, };
-static const char32 __uni_decomp_data_0xdde[] = { 0xdd9, 0xddf, 0, };
+static const char32 __uni_decomp_data_0xdda[] = { 2, 0xdd9, 0xdca, };
+static const char32 __uni_decomp_data_0xddc[] = { 2, 0xdd9, 0xdcf, };
+static const char32 __uni_decomp_data_0xddd[] = { 2, 0xddc, 0xdca, };
+static const char32 __uni_decomp_data_0xdde[] = { 2, 0xdd9, 0xddf, };
 
 
 
@@ -5052,7 +5052,7 @@
 };
 
 
-static const char32 __uni_decomp_data_0xe33[] = { 0xe4d, 0xe32, 0, };
+static const char32 __uni_decomp_data_0xe33[] = { 2, 0xe4d, 0xe32, };
 
 
 
@@ -6726,9 +6726,9 @@
 };
 
 
-static const char32 __uni_decomp_data_0xeb3[] = { 0xecd, 0xeb2, 0, };
-static const char32 __uni_decomp_data_0xedc[] = { 0xeab, 0xe99, 0, };
-static const char32 __uni_decomp_data_0xedd[] = { 0xeab, 0xea1, 0, };
+static const char32 __uni_decomp_data_0xeb3[] = { 2, 0xecd, 0xeb2, };
+static const char32 __uni_decomp_data_0xedc[] = { 2, 0xeab, 0xe99, };
+static const char32 __uni_decomp_data_0xedd[] = { 2, 0xeab, 0xea1, };
 
 
 
@@ -8402,19 +8402,19 @@
 };
 
 
-static const char32 __uni_decomp_data_0xf0c[] = { 0xf0b, 0, };
-static const char32 __uni_decomp_data_0xf43[] = { 0xf42, 0xfb7, 0, };
-static const char32 __uni_decomp_data_0xf4d[] = { 0xf4c, 0xfb7, 0, };
-static const char32 __uni_decomp_data_0xf52[] = { 0xf51, 0xfb7, 0, };
-static const char32 __uni_decomp_data_0xf57[] = { 0xf56, 0xfb7, 0, };
-static const char32 __uni_decomp_data_0xf5c[] = { 0xf5b, 0xfb7, 0, };
-static const char32 __uni_decomp_data_0xf69[] = { 0xf40, 0xfb5, 0, };
-static const char32 __uni_decomp_data_0xf73[] = { 0xf71, 0xf72, 0, };
-static const char32 __uni_decomp_data_0xf75[] = { 0xf71, 0xf74, 0, };
-static const char32 __uni_decomp_data_0xf76[] = { 0xfb2, 0xf80, 0, };
-static const char32 __uni_decomp_data_0xf77[] = { 0xfb2, 0xf81, 0, };
-static const char32 __uni_decomp_data_0xf78[] = { 0xfb3, 0xf80, 0, };
-static const char32 __uni_decomp_data_0xf79[] = { 0xfb3, 0xf81, 0, };
+static const char32 __uni_decomp_data_0xf0c[] = { 1, 0xf0b, };
+static const char32 __uni_decomp_data_0xf43[] = { 2, 0xf42, 0xfb7, };
+static const char32 __uni_decomp_data_0xf4d[] = { 2, 0xf4c, 0xfb7, };
+static const char32 __uni_decomp_data_0xf52[] = { 2, 0xf51, 0xfb7, };
+static const char32 __uni_decomp_data_0xf57[] = { 2, 0xf56, 0xfb7, };
+static const char32 __uni_decomp_data_0xf5c[] = { 2, 0xf5b, 0xfb7, };
+static const char32 __uni_decomp_data_0xf69[] = { 2, 0xf40, 0xfb5, };
+static const char32 __uni_decomp_data_0xf73[] = { 2, 0xf71, 0xf72, };
+static const char32 __uni_decomp_data_0xf75[] = { 2, 0xf71, 0xf74, };
+static const char32 __uni_decomp_data_0xf76[] = { 2, 0xfb2, 0xf80, };
+static const char32 __uni_decomp_data_0xf77[] = { 2, 0xfb2, 0xf81, };
+static const char32 __uni_decomp_data_0xf78[] = { 2, 0xfb3, 0xf80, };
+static const char32 __uni_decomp_data_0xf79[] = { 2, 0xfb3, 0xf81, };
 
 
 
@@ -10088,13 +10088,13 @@
 };
 
 
-static const char32 __uni_decomp_data_0xf81[] = { 0xf71, 0xf80, 0, };
-static const char32 __uni_decomp_data_0xf93[] = { 0xf92, 0xfb7, 0, };
-static const char32 __uni_decomp_data_0xf9d[] = { 0xf9c, 0xfb7, 0, };
-static const char32 __uni_decomp_data_0xfa2[] = { 0xfa1, 0xfb7, 0, };
-static const char32 __uni_decomp_data_0xfa7[] = { 0xfa6, 0xfb7, 0, };
-static const char32 __uni_decomp_data_0xfac[] = { 0xfab, 0xfb7, 0, };
-static const char32 __uni_decomp_data_0xfb9[] = { 0xf90, 0xfb5, 0, };
+static const char32 __uni_decomp_data_0xf81[] = { 2, 0xf71, 0xf80, };
+static const char32 __uni_decomp_data_0xf93[] = { 2, 0xf92, 0xfb7, };
+static const char32 __uni_decomp_data_0xf9d[] = { 2, 0xf9c, 0xfb7, };
+static const char32 __uni_decomp_data_0xfa2[] = { 2, 0xfa1, 0xfb7, };
+static const char32 __uni_decomp_data_0xfa7[] = { 2, 0xfa6, 0xfb7, };
+static const char32 __uni_decomp_data_0xfac[] = { 2, 0xfab, 0xfb7, };
+static const char32 __uni_decomp_data_0xfb9[] = { 2, 0xf90, 0xfb5, };
 
 
 
@@ -11768,7 +11768,7 @@
 };
 
 
-static const char32 __uni_decomp_data_0x1026[] = { 0x1025, 0x102e, 0, };
+static const char32 __uni_decomp_data_0x1026[] = { 2, 0x1025, 0x102e, };
 
 
 
@@ -13442,7 +13442,7 @@
 };
 
 
-static const char32 __uni_decomp_data_0x10fc[] = { 0x10dc, 0, };
+static const char32 __uni_decomp_data_0x10fc[] = { 1, 0x10dc, };
 
 
 

Modified: sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_3.ipp
==============================================================================
--- sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_3.ipp	(original)
+++ sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_3.ipp	2009-08-06 03:26:39 EDT (Thu, 06 Aug 2009)
@@ -6713,17 +6713,17 @@
 };
 
 
-static const char32 __uni_decomp_data_0x1b06[] = { 0x1b05, 0x1b35, 0, };
-static const char32 __uni_decomp_data_0x1b08[] = { 0x1b07, 0x1b35, 0, };
-static const char32 __uni_decomp_data_0x1b0a[] = { 0x1b09, 0x1b35, 0, };
-static const char32 __uni_decomp_data_0x1b0c[] = { 0x1b0b, 0x1b35, 0, };
-static const char32 __uni_decomp_data_0x1b0e[] = { 0x1b0d, 0x1b35, 0, };
-static const char32 __uni_decomp_data_0x1b12[] = { 0x1b11, 0x1b35, 0, };
-static const char32 __uni_decomp_data_0x1b3b[] = { 0x1b3a, 0x1b35, 0, };
-static const char32 __uni_decomp_data_0x1b3d[] = { 0x1b3c, 0x1b35, 0, };
-static const char32 __uni_decomp_data_0x1b40[] = { 0x1b3e, 0x1b35, 0, };
-static const char32 __uni_decomp_data_0x1b41[] = { 0x1b3f, 0x1b35, 0, };
-static const char32 __uni_decomp_data_0x1b43[] = { 0x1b42, 0x1b35, 0, };
+static const char32 __uni_decomp_data_0x1b06[] = { 2, 0x1b05, 0x1b35, };
+static const char32 __uni_decomp_data_0x1b08[] = { 2, 0x1b07, 0x1b35, };
+static const char32 __uni_decomp_data_0x1b0a[] = { 2, 0x1b09, 0x1b35, };
+static const char32 __uni_decomp_data_0x1b0c[] = { 2, 0x1b0b, 0x1b35, };
+static const char32 __uni_decomp_data_0x1b0e[] = { 2, 0x1b0d, 0x1b35, };
+static const char32 __uni_decomp_data_0x1b12[] = { 2, 0x1b11, 0x1b35, };
+static const char32 __uni_decomp_data_0x1b3b[] = { 2, 0x1b3a, 0x1b35, };
+static const char32 __uni_decomp_data_0x1b3d[] = { 2, 0x1b3c, 0x1b35, };
+static const char32 __uni_decomp_data_0x1b40[] = { 2, 0x1b3e, 0x1b35, };
+static const char32 __uni_decomp_data_0x1b41[] = { 2, 0x1b3f, 0x1b35, };
+static const char32 __uni_decomp_data_0x1b43[] = { 2, 0x1b42, 0x1b35, };
 
 
 
@@ -11743,67 +11743,67 @@
 };
 
 
-static const char32 __uni_decomp_data_0x1d2c[] = { 0x41, 0, };
-static const char32 __uni_decomp_data_0x1d2d[] = { 0xc6, 0, };
-static const char32 __uni_decomp_data_0x1d2e[] = { 0x42, 0, };
-static const char32 __uni_decomp_data_0x1d30[] = { 0x44, 0, };
-static const char32 __uni_decomp_data_0x1d31[] = { 0x45, 0, };
-static const char32 __uni_decomp_data_0x1d32[] = { 0x18e, 0, };
-static const char32 __uni_decomp_data_0x1d33[] = { 0x47, 0, };
-static const char32 __uni_decomp_data_0x1d34[] = { 0x48, 0, };
-static const char32 __uni_decomp_data_0x1d35[] = { 0x49, 0, };
-static const char32 __uni_decomp_data_0x1d36[] = { 0x4a, 0, };
-static const char32 __uni_decomp_data_0x1d37[] = { 0x4b, 0, };
-static const char32 __uni_decomp_data_0x1d38[] = { 0x4c, 0, };
-static const char32 __uni_decomp_data_0x1d39[] = { 0x4d, 0, };
-static const char32 __uni_decomp_data_0x1d3a[] = { 0x4e, 0, };
-static const char32 __uni_decomp_data_0x1d3c[] = { 0x4f, 0, };
-static const char32 __uni_decomp_data_0x1d3d[] = { 0x222, 0, };
-static const char32 __uni_decomp_data_0x1d3e[] = { 0x50, 0, };
-static const char32 __uni_decomp_data_0x1d3f[] = { 0x52, 0, };
-static const char32 __uni_decomp_data_0x1d40[] = { 0x54, 0, };
-static const char32 __uni_decomp_data_0x1d41[] = { 0x55, 0, };
-static const char32 __uni_decomp_data_0x1d42[] = { 0x57, 0, };
-static const char32 __uni_decomp_data_0x1d43[] = { 0x61, 0, };
-static const char32 __uni_decomp_data_0x1d44[] = { 0x250, 0, };
-static const char32 __uni_decomp_data_0x1d45[] = { 0x251, 0, };
-static const char32 __uni_decomp_data_0x1d46[] = { 0x1d02, 0, };
-static const char32 __uni_decomp_data_0x1d47[] = { 0x62, 0, };
-static const char32 __uni_decomp_data_0x1d48[] = { 0x64, 0, };
-static const char32 __uni_decomp_data_0x1d49[] = { 0x65, 0, };
-static const char32 __uni_decomp_data_0x1d4a[] = { 0x259, 0, };
-static const char32 __uni_decomp_data_0x1d4b[] = { 0x25b, 0, };
-static const char32 __uni_decomp_data_0x1d4c[] = { 0x25c, 0, };
-static const char32 __uni_decomp_data_0x1d4d[] = { 0x67, 0, };
-static const char32 __uni_decomp_data_0x1d4f[] = { 0x6b, 0, };
-static const char32 __uni_decomp_data_0x1d50[] = { 0x6d, 0, };
-static const char32 __uni_decomp_data_0x1d51[] = { 0x14b, 0, };
-static const char32 __uni_decomp_data_0x1d52[] = { 0x6f, 0, };
-static const char32 __uni_decomp_data_0x1d53[] = { 0x254, 0, };
-static const char32 __uni_decomp_data_0x1d54[] = { 0x1d16, 0, };
-static const char32 __uni_decomp_data_0x1d55[] = { 0x1d17, 0, };
-static const char32 __uni_decomp_data_0x1d56[] = { 0x70, 0, };
-static const char32 __uni_decomp_data_0x1d57[] = { 0x74, 0, };
-static const char32 __uni_decomp_data_0x1d58[] = { 0x75, 0, };
-static const char32 __uni_decomp_data_0x1d59[] = { 0x1d1d, 0, };
-static const char32 __uni_decomp_data_0x1d5a[] = { 0x26f, 0, };
-static const char32 __uni_decomp_data_0x1d5b[] = { 0x76, 0, };
-static const char32 __uni_decomp_data_0x1d5c[] = { 0x1d25, 0, };
-static const char32 __uni_decomp_data_0x1d5d[] = { 0x3b2, 0, };
-static const char32 __uni_decomp_data_0x1d5e[] = { 0x3b3, 0, };
-static const char32 __uni_decomp_data_0x1d5f[] = { 0x3b4, 0, };
-static const char32 __uni_decomp_data_0x1d60[] = { 0x3c6, 0, };
-static const char32 __uni_decomp_data_0x1d61[] = { 0x3c7, 0, };
-static const char32 __uni_decomp_data_0x1d62[] = { 0x69, 0, };
-static const char32 __uni_decomp_data_0x1d63[] = { 0x72, 0, };
-static const char32 __uni_decomp_data_0x1d64[] = { 0x75, 0, };
-static const char32 __uni_decomp_data_0x1d65[] = { 0x76, 0, };
-static const char32 __uni_decomp_data_0x1d66[] = { 0x3b2, 0, };
-static const char32 __uni_decomp_data_0x1d67[] = { 0x3b3, 0, };
-static const char32 __uni_decomp_data_0x1d68[] = { 0x3c1, 0, };
-static const char32 __uni_decomp_data_0x1d69[] = { 0x3c6, 0, };
-static const char32 __uni_decomp_data_0x1d6a[] = { 0x3c7, 0, };
-static const char32 __uni_decomp_data_0x1d78[] = { 0x43d, 0, };
+static const char32 __uni_decomp_data_0x1d2c[] = { 1, 0x41, };
+static const char32 __uni_decomp_data_0x1d2d[] = { 1, 0xc6, };
+static const char32 __uni_decomp_data_0x1d2e[] = { 1, 0x42, };
+static const char32 __uni_decomp_data_0x1d30[] = { 1, 0x44, };
+static const char32 __uni_decomp_data_0x1d31[] = { 1, 0x45, };
+static const char32 __uni_decomp_data_0x1d32[] = { 1, 0x18e, };
+static const char32 __uni_decomp_data_0x1d33[] = { 1, 0x47, };
+static const char32 __uni_decomp_data_0x1d34[] = { 1, 0x48, };
+static const char32 __uni_decomp_data_0x1d35[] = { 1, 0x49, };
+static const char32 __uni_decomp_data_0x1d36[] = { 1, 0x4a, };
+static const char32 __uni_decomp_data_0x1d37[] = { 1, 0x4b, };
+static const char32 __uni_decomp_data_0x1d38[] = { 1, 0x4c, };
+static const char32 __uni_decomp_data_0x1d39[] = { 1, 0x4d, };
+static const char32 __uni_decomp_data_0x1d3a[] = { 1, 0x4e, };
+static const char32 __uni_decomp_data_0x1d3c[] = { 1, 0x4f, };
+static const char32 __uni_decomp_data_0x1d3d[] = { 1, 0x222, };
+static const char32 __uni_decomp_data_0x1d3e[] = { 1, 0x50, };
+static const char32 __uni_decomp_data_0x1d3f[] = { 1, 0x52, };
+static const char32 __uni_decomp_data_0x1d40[] = { 1, 0x54, };
+static const char32 __uni_decomp_data_0x1d41[] = { 1, 0x55, };
+static const char32 __uni_decomp_data_0x1d42[] = { 1, 0x57, };
+static const char32 __uni_decomp_data_0x1d43[] = { 1, 0x61, };
+static const char32 __uni_decomp_data_0x1d44[] = { 1, 0x250, };
+static const char32 __uni_decomp_data_0x1d45[] = { 1, 0x251, };
+static const char32 __uni_decomp_data_0x1d46[] = { 1, 0x1d02, };
+static const char32 __uni_decomp_data_0x1d47[] = { 1, 0x62, };
+static const char32 __uni_decomp_data_0x1d48[] = { 1, 0x64, };
+static const char32 __uni_decomp_data_0x1d49[] = { 1, 0x65, };
+static const char32 __uni_decomp_data_0x1d4a[] = { 1, 0x259, };
+static const char32 __uni_decomp_data_0x1d4b[] = { 1, 0x25b, };
+static const char32 __uni_decomp_data_0x1d4c[] = { 1, 0x25c, };
+static const char32 __uni_decomp_data_0x1d4d[] = { 1, 0x67, };
+static const char32 __uni_decomp_data_0x1d4f[] = { 1, 0x6b, };
+static const char32 __uni_decomp_data_0x1d50[] = { 1, 0x6d, };
+static const char32 __uni_decomp_data_0x1d51[] = { 1, 0x14b, };
+static const char32 __uni_decomp_data_0x1d52[] = { 1, 0x6f, };
+static const char32 __uni_decomp_data_0x1d53[] = { 1, 0x254, };
+static const char32 __uni_decomp_data_0x1d54[] = { 1, 0x1d16, };
+static const char32 __uni_decomp_data_0x1d55[] = { 1, 0x1d17, };
+static const char32 __uni_decomp_data_0x1d56[] = { 1, 0x70, };
+static const char32 __uni_decomp_data_0x1d57[] = { 1, 0x74, };
+static const char32 __uni_decomp_data_0x1d58[] = { 1, 0x75, };
+static const char32 __uni_decomp_data_0x1d59[] = { 1, 0x1d1d, };
+static const char32 __uni_decomp_data_0x1d5a[] = { 1, 0x26f, };
+static const char32 __uni_decomp_data_0x1d5b[] = { 1, 0x76, };
+static const char32 __uni_decomp_data_0x1d5c[] = { 1, 0x1d25, };
+static const char32 __uni_decomp_data_0x1d5d[] = { 1, 0x3b2, };
+static const char32 __uni_decomp_data_0x1d5e[] = { 1, 0x3b3, };
+static const char32 __uni_decomp_data_0x1d5f[] = { 1, 0x3b4, };
+static const char32 __uni_decomp_data_0x1d60[] = { 1, 0x3c6, };
+static const char32 __uni_decomp_data_0x1d61[] = { 1, 0x3c7, };
+static const char32 __uni_decomp_data_0x1d62[] = { 1, 0x69, };
+static const char32 __uni_decomp_data_0x1d63[] = { 1, 0x72, };
+static const char32 __uni_decomp_data_0x1d64[] = { 1, 0x75, };
+static const char32 __uni_decomp_data_0x1d65[] = { 1, 0x76, };
+static const char32 __uni_decomp_data_0x1d66[] = { 1, 0x3b2, };
+static const char32 __uni_decomp_data_0x1d67[] = { 1, 0x3b3, };
+static const char32 __uni_decomp_data_0x1d68[] = { 1, 0x3c1, };
+static const char32 __uni_decomp_data_0x1d69[] = { 1, 0x3c6, };
+static const char32 __uni_decomp_data_0x1d6a[] = { 1, 0x3c7, };
+static const char32 __uni_decomp_data_0x1d78[] = { 1, 0x43d, };
 
 
 
@@ -13477,43 +13477,43 @@
 };
 
 
-static const char32 __uni_decomp_data_0x1d9b[] = { 0x252, 0, };
-static const char32 __uni_decomp_data_0x1d9c[] = { 0x63, 0, };
-static const char32 __uni_decomp_data_0x1d9d[] = { 0x255, 0, };
-static const char32 __uni_decomp_data_0x1d9e[] = { 0xf0, 0, };
-static const char32 __uni_decomp_data_0x1d9f[] = { 0x25c, 0, };
-static const char32 __uni_decomp_data_0x1da0[] = { 0x66, 0, };
-static const char32 __uni_decomp_data_0x1da1[] = { 0x25f, 0, };
-static const char32 __uni_decomp_data_0x1da2[] = { 0x261, 0, };
-static const char32 __uni_decomp_data_0x1da3[] = { 0x265, 0, };
-static const char32 __uni_decomp_data_0x1da4[] = { 0x268, 0, };
-static const char32 __uni_decomp_data_0x1da5[] = { 0x269, 0, };
-static const char32 __uni_decomp_data_0x1da6[] = { 0x26a, 0, };
-static const char32 __uni_decomp_data_0x1da7[] = { 0x1d7b, 0, };
-static const char32 __uni_decomp_data_0x1da8[] = { 0x29d, 0, };
-static const char32 __uni_decomp_data_0x1da9[] = { 0x26d, 0, };
-static const char32 __uni_decomp_data_0x1daa[] = { 0x1d85, 0, };
-static const char32 __uni_decomp_data_0x1dab[] = { 0x29f, 0, };
-static const char32 __uni_decomp_data_0x1dac[] = { 0x271, 0, };
-static const char32 __uni_decomp_data_0x1dad[] = { 0x270, 0, };
-static const char32 __uni_decomp_data_0x1dae[] = { 0x272, 0, };
-static const char32 __uni_decomp_data_0x1daf[] = { 0x273, 0, };
-static const char32 __uni_decomp_data_0x1db0[] = { 0x274, 0, };
-static const char32 __uni_decomp_data_0x1db1[] = { 0x275, 0, };
-static const char32 __uni_decomp_data_0x1db2[] = { 0x278, 0, };
-static const char32 __uni_decomp_data_0x1db3[] = { 0x282, 0, };
-static const char32 __uni_decomp_data_0x1db4[] = { 0x283, 0, };
-static const char32 __uni_decomp_data_0x1db5[] = { 0x1ab, 0, };
-static const char32 __uni_decomp_data_0x1db6[] = { 0x289, 0, };
-static const char32 __uni_decomp_data_0x1db7[] = { 0x28a, 0, };
-static const char32 __uni_decomp_data_0x1db8[] = { 0x1d1c, 0, };
-static const char32 __uni_decomp_data_0x1db9[] = { 0x28b, 0, };
-static const char32 __uni_decomp_data_0x1dba[] = { 0x28c, 0, };
-static const char32 __uni_decomp_data_0x1dbb[] = { 0x7a, 0, };
-static const char32 __uni_decomp_data_0x1dbc[] = { 0x290, 0, };
-static const char32 __uni_decomp_data_0x1dbd[] = { 0x291, 0, };
-static const char32 __uni_decomp_data_0x1dbe[] = { 0x292, 0, };
-static const char32 __uni_decomp_data_0x1dbf[] = { 0x3b8, 0, };
+static const char32 __uni_decomp_data_0x1d9b[] = { 1, 0x252, };
+static const char32 __uni_decomp_data_0x1d9c[] = { 1, 0x63, };
+static const char32 __uni_decomp_data_0x1d9d[] = { 1, 0x255, };
+static const char32 __uni_decomp_data_0x1d9e[] = { 1, 0xf0, };
+static const char32 __uni_decomp_data_0x1d9f[] = { 1, 0x25c, };
+static const char32 __uni_decomp_data_0x1da0[] = { 1, 0x66, };
+static const char32 __uni_decomp_data_0x1da1[] = { 1, 0x25f, };
+static const char32 __uni_decomp_data_0x1da2[] = { 1, 0x261, };
+static const char32 __uni_decomp_data_0x1da3[] = { 1, 0x265, };
+static const char32 __uni_decomp_data_0x1da4[] = { 1, 0x268, };
+static const char32 __uni_decomp_data_0x1da5[] = { 1, 0x269, };
+static const char32 __uni_decomp_data_0x1da6[] = { 1, 0x26a, };
+static const char32 __uni_decomp_data_0x1da7[] = { 1, 0x1d7b, };
+static const char32 __uni_decomp_data_0x1da8[] = { 1, 0x29d, };
+static const char32 __uni_decomp_data_0x1da9[] = { 1, 0x26d, };
+static const char32 __uni_decomp_data_0x1daa[] = { 1, 0x1d85, };
+static const char32 __uni_decomp_data_0x1dab[] = { 1, 0x29f, };
+static const char32 __uni_decomp_data_0x1dac[] = { 1, 0x271, };
+static const char32 __uni_decomp_data_0x1dad[] = { 1, 0x270, };
+static const char32 __uni_decomp_data_0x1dae[] = { 1, 0x272, };
+static const char32 __uni_decomp_data_0x1daf[] = { 1, 0x273, };
+static const char32 __uni_decomp_data_0x1db0[] = { 1, 0x274, };
+static const char32 __uni_decomp_data_0x1db1[] = { 1, 0x275, };
+static const char32 __uni_decomp_data_0x1db2[] = { 1, 0x278, };
+static const char32 __uni_decomp_data_0x1db3[] = { 1, 0x282, };
+static const char32 __uni_decomp_data_0x1db4[] = { 1, 0x283, };
+static const char32 __uni_decomp_data_0x1db5[] = { 1, 0x1ab, };
+static const char32 __uni_decomp_data_0x1db6[] = { 1, 0x289, };
+static const char32 __uni_decomp_data_0x1db7[] = { 1, 0x28a, };
+static const char32 __uni_decomp_data_0x1db8[] = { 1, 0x1d1c, };
+static const char32 __uni_decomp_data_0x1db9[] = { 1, 0x28b, };
+static const char32 __uni_decomp_data_0x1dba[] = { 1, 0x28c, };
+static const char32 __uni_decomp_data_0x1dbb[] = { 1, 0x7a, };
+static const char32 __uni_decomp_data_0x1dbc[] = { 1, 0x290, };
+static const char32 __uni_decomp_data_0x1dbd[] = { 1, 0x291, };
+static const char32 __uni_decomp_data_0x1dbe[] = { 1, 0x292, };
+static const char32 __uni_decomp_data_0x1dbf[] = { 1, 0x3b8, };
 
 
 
@@ -15187,134 +15187,134 @@
 };
 
 
-static const char32 __uni_decomp_data_0x1e00[] = { 0x41, 0x325, 0, };
-static const char32 __uni_decomp_data_0x1e01[] = { 0x61, 0x325, 0, };
-static const char32 __uni_decomp_data_0x1e02[] = { 0x42, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e03[] = { 0x62, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e04[] = { 0x42, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1e05[] = { 0x62, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1e06[] = { 0x42, 0x331, 0, };
-static const char32 __uni_decomp_data_0x1e07[] = { 0x62, 0x331, 0, };
-static const char32 __uni_decomp_data_0x1e08[] = { 0xc7, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1e09[] = { 0xe7, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1e0a[] = { 0x44, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e0b[] = { 0x64, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e0c[] = { 0x44, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1e0d[] = { 0x64, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1e0e[] = { 0x44, 0x331, 0, };
-static const char32 __uni_decomp_data_0x1e0f[] = { 0x64, 0x331, 0, };
-static const char32 __uni_decomp_data_0x1e10[] = { 0x44, 0x327, 0, };
-static const char32 __uni_decomp_data_0x1e11[] = { 0x64, 0x327, 0, };
-static const char32 __uni_decomp_data_0x1e12[] = { 0x44, 0x32d, 0, };
-static const char32 __uni_decomp_data_0x1e13[] = { 0x64, 0x32d, 0, };
-static const char32 __uni_decomp_data_0x1e14[] = { 0x112, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1e15[] = { 0x113, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1e16[] = { 0x112, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1e17[] = { 0x113, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1e18[] = { 0x45, 0x32d, 0, };
-static const char32 __uni_decomp_data_0x1e19[] = { 0x65, 0x32d, 0, };
-static const char32 __uni_decomp_data_0x1e1a[] = { 0x45, 0x330, 0, };
-static const char32 __uni_decomp_data_0x1e1b[] = { 0x65, 0x330, 0, };
-static const char32 __uni_decomp_data_0x1e1c[] = { 0x228, 0x306, 0, };
-static const char32 __uni_decomp_data_0x1e1d[] = { 0x229, 0x306, 0, };
-static const char32 __uni_decomp_data_0x1e1e[] = { 0x46, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e1f[] = { 0x66, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e20[] = { 0x47, 0x304, 0, };
-static const char32 __uni_decomp_data_0x1e21[] = { 0x67, 0x304, 0, };
-static const char32 __uni_decomp_data_0x1e22[] = { 0x48, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e23[] = { 0x68, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e24[] = { 0x48, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1e25[] = { 0x68, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1e26[] = { 0x48, 0x308, 0, };
-static const char32 __uni_decomp_data_0x1e27[] = { 0x68, 0x308, 0, };
-static const char32 __uni_decomp_data_0x1e28[] = { 0x48, 0x327, 0, };
-static const char32 __uni_decomp_data_0x1e29[] = { 0x68, 0x327, 0, };
-static const char32 __uni_decomp_data_0x1e2a[] = { 0x48, 0x32e, 0, };
-static const char32 __uni_decomp_data_0x1e2b[] = { 0x68, 0x32e, 0, };
-static const char32 __uni_decomp_data_0x1e2c[] = { 0x49, 0x330, 0, };
-static const char32 __uni_decomp_data_0x1e2d[] = { 0x69, 0x330, 0, };
-static const char32 __uni_decomp_data_0x1e2e[] = { 0xcf, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1e2f[] = { 0xef, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1e30[] = { 0x4b, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1e31[] = { 0x6b, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1e32[] = { 0x4b, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1e33[] = { 0x6b, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1e34[] = { 0x4b, 0x331, 0, };
-static const char32 __uni_decomp_data_0x1e35[] = { 0x6b, 0x331, 0, };
-static const char32 __uni_decomp_data_0x1e36[] = { 0x4c, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1e37[] = { 0x6c, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1e38[] = { 0x1e36, 0x304, 0, };
-static const char32 __uni_decomp_data_0x1e39[] = { 0x1e37, 0x304, 0, };
-static const char32 __uni_decomp_data_0x1e3a[] = { 0x4c, 0x331, 0, };
-static const char32 __uni_decomp_data_0x1e3b[] = { 0x6c, 0x331, 0, };
-static const char32 __uni_decomp_data_0x1e3c[] = { 0x4c, 0x32d, 0, };
-static const char32 __uni_decomp_data_0x1e3d[] = { 0x6c, 0x32d, 0, };
-static const char32 __uni_decomp_data_0x1e3e[] = { 0x4d, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1e3f[] = { 0x6d, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1e40[] = { 0x4d, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e41[] = { 0x6d, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e42[] = { 0x4d, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1e43[] = { 0x6d, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1e44[] = { 0x4e, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e45[] = { 0x6e, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e46[] = { 0x4e, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1e47[] = { 0x6e, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1e48[] = { 0x4e, 0x331, 0, };
-static const char32 __uni_decomp_data_0x1e49[] = { 0x6e, 0x331, 0, };
-static const char32 __uni_decomp_data_0x1e4a[] = { 0x4e, 0x32d, 0, };
-static const char32 __uni_decomp_data_0x1e4b[] = { 0x6e, 0x32d, 0, };
-static const char32 __uni_decomp_data_0x1e4c[] = { 0xd5, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1e4d[] = { 0xf5, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1e4e[] = { 0xd5, 0x308, 0, };
-static const char32 __uni_decomp_data_0x1e4f[] = { 0xf5, 0x308, 0, };
-static const char32 __uni_decomp_data_0x1e50[] = { 0x14c, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1e51[] = { 0x14d, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1e52[] = { 0x14c, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1e53[] = { 0x14d, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1e54[] = { 0x50, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1e55[] = { 0x70, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1e56[] = { 0x50, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e57[] = { 0x70, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e58[] = { 0x52, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e59[] = { 0x72, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e5a[] = { 0x52, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1e5b[] = { 0x72, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1e5c[] = { 0x1e5a, 0x304, 0, };
-static const char32 __uni_decomp_data_0x1e5d[] = { 0x1e5b, 0x304, 0, };
-static const char32 __uni_decomp_data_0x1e5e[] = { 0x52, 0x331, 0, };
-static const char32 __uni_decomp_data_0x1e5f[] = { 0x72, 0x331, 0, };
-static const char32 __uni_decomp_data_0x1e60[] = { 0x53, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e61[] = { 0x73, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e62[] = { 0x53, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1e63[] = { 0x73, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1e64[] = { 0x15a, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e65[] = { 0x15b, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e66[] = { 0x160, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e67[] = { 0x161, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e68[] = { 0x1e62, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e69[] = { 0x1e63, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e6a[] = { 0x54, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e6b[] = { 0x74, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e6c[] = { 0x54, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1e6d[] = { 0x74, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1e6e[] = { 0x54, 0x331, 0, };
-static const char32 __uni_decomp_data_0x1e6f[] = { 0x74, 0x331, 0, };
-static const char32 __uni_decomp_data_0x1e70[] = { 0x54, 0x32d, 0, };
-static const char32 __uni_decomp_data_0x1e71[] = { 0x74, 0x32d, 0, };
-static const char32 __uni_decomp_data_0x1e72[] = { 0x55, 0x324, 0, };
-static const char32 __uni_decomp_data_0x1e73[] = { 0x75, 0x324, 0, };
-static const char32 __uni_decomp_data_0x1e74[] = { 0x55, 0x330, 0, };
-static const char32 __uni_decomp_data_0x1e75[] = { 0x75, 0x330, 0, };
-static const char32 __uni_decomp_data_0x1e76[] = { 0x55, 0x32d, 0, };
-static const char32 __uni_decomp_data_0x1e77[] = { 0x75, 0x32d, 0, };
-static const char32 __uni_decomp_data_0x1e78[] = { 0x168, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1e79[] = { 0x169, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1e7a[] = { 0x16a, 0x308, 0, };
-static const char32 __uni_decomp_data_0x1e7b[] = { 0x16b, 0x308, 0, };
-static const char32 __uni_decomp_data_0x1e7c[] = { 0x56, 0x303, 0, };
-static const char32 __uni_decomp_data_0x1e7d[] = { 0x76, 0x303, 0, };
-static const char32 __uni_decomp_data_0x1e7e[] = { 0x56, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1e7f[] = { 0x76, 0x323, 0, };
+static const char32 __uni_decomp_data_0x1e00[] = { 2, 0x41, 0x325, };
+static const char32 __uni_decomp_data_0x1e01[] = { 2, 0x61, 0x325, };
+static const char32 __uni_decomp_data_0x1e02[] = { 2, 0x42, 0x307, };
+static const char32 __uni_decomp_data_0x1e03[] = { 2, 0x62, 0x307, };
+static const char32 __uni_decomp_data_0x1e04[] = { 2, 0x42, 0x323, };
+static const char32 __uni_decomp_data_0x1e05[] = { 2, 0x62, 0x323, };
+static const char32 __uni_decomp_data_0x1e06[] = { 2, 0x42, 0x331, };
+static const char32 __uni_decomp_data_0x1e07[] = { 2, 0x62, 0x331, };
+static const char32 __uni_decomp_data_0x1e08[] = { 2, 0xc7, 0x301, };
+static const char32 __uni_decomp_data_0x1e09[] = { 2, 0xe7, 0x301, };
+static const char32 __uni_decomp_data_0x1e0a[] = { 2, 0x44, 0x307, };
+static const char32 __uni_decomp_data_0x1e0b[] = { 2, 0x64, 0x307, };
+static const char32 __uni_decomp_data_0x1e0c[] = { 2, 0x44, 0x323, };
+static const char32 __uni_decomp_data_0x1e0d[] = { 2, 0x64, 0x323, };
+static const char32 __uni_decomp_data_0x1e0e[] = { 2, 0x44, 0x331, };
+static const char32 __uni_decomp_data_0x1e0f[] = { 2, 0x64, 0x331, };
+static const char32 __uni_decomp_data_0x1e10[] = { 2, 0x44, 0x327, };
+static const char32 __uni_decomp_data_0x1e11[] = { 2, 0x64, 0x327, };
+static const char32 __uni_decomp_data_0x1e12[] = { 2, 0x44, 0x32d, };
+static const char32 __uni_decomp_data_0x1e13[] = { 2, 0x64, 0x32d, };
+static const char32 __uni_decomp_data_0x1e14[] = { 2, 0x112, 0x300, };
+static const char32 __uni_decomp_data_0x1e15[] = { 2, 0x113, 0x300, };
+static const char32 __uni_decomp_data_0x1e16[] = { 2, 0x112, 0x301, };
+static const char32 __uni_decomp_data_0x1e17[] = { 2, 0x113, 0x301, };
+static const char32 __uni_decomp_data_0x1e18[] = { 2, 0x45, 0x32d, };
+static const char32 __uni_decomp_data_0x1e19[] = { 2, 0x65, 0x32d, };
+static const char32 __uni_decomp_data_0x1e1a[] = { 2, 0x45, 0x330, };
+static const char32 __uni_decomp_data_0x1e1b[] = { 2, 0x65, 0x330, };
+static const char32 __uni_decomp_data_0x1e1c[] = { 2, 0x228, 0x306, };
+static const char32 __uni_decomp_data_0x1e1d[] = { 2, 0x229, 0x306, };
+static const char32 __uni_decomp_data_0x1e1e[] = { 2, 0x46, 0x307, };
+static const char32 __uni_decomp_data_0x1e1f[] = { 2, 0x66, 0x307, };
+static const char32 __uni_decomp_data_0x1e20[] = { 2, 0x47, 0x304, };
+static const char32 __uni_decomp_data_0x1e21[] = { 2, 0x67, 0x304, };
+static const char32 __uni_decomp_data_0x1e22[] = { 2, 0x48, 0x307, };
+static const char32 __uni_decomp_data_0x1e23[] = { 2, 0x68, 0x307, };
+static const char32 __uni_decomp_data_0x1e24[] = { 2, 0x48, 0x323, };
+static const char32 __uni_decomp_data_0x1e25[] = { 2, 0x68, 0x323, };
+static const char32 __uni_decomp_data_0x1e26[] = { 2, 0x48, 0x308, };
+static const char32 __uni_decomp_data_0x1e27[] = { 2, 0x68, 0x308, };
+static const char32 __uni_decomp_data_0x1e28[] = { 2, 0x48, 0x327, };
+static const char32 __uni_decomp_data_0x1e29[] = { 2, 0x68, 0x327, };
+static const char32 __uni_decomp_data_0x1e2a[] = { 2, 0x48, 0x32e, };
+static const char32 __uni_decomp_data_0x1e2b[] = { 2, 0x68, 0x32e, };
+static const char32 __uni_decomp_data_0x1e2c[] = { 2, 0x49, 0x330, };
+static const char32 __uni_decomp_data_0x1e2d[] = { 2, 0x69, 0x330, };
+static const char32 __uni_decomp_data_0x1e2e[] = { 2, 0xcf, 0x301, };
+static const char32 __uni_decomp_data_0x1e2f[] = { 2, 0xef, 0x301, };
+static const char32 __uni_decomp_data_0x1e30[] = { 2, 0x4b, 0x301, };
+static const char32 __uni_decomp_data_0x1e31[] = { 2, 0x6b, 0x301, };
+static const char32 __uni_decomp_data_0x1e32[] = { 2, 0x4b, 0x323, };
+static const char32 __uni_decomp_data_0x1e33[] = { 2, 0x6b, 0x323, };
+static const char32 __uni_decomp_data_0x1e34[] = { 2, 0x4b, 0x331, };
+static const char32 __uni_decomp_data_0x1e35[] = { 2, 0x6b, 0x331, };
+static const char32 __uni_decomp_data_0x1e36[] = { 2, 0x4c, 0x323, };
+static const char32 __uni_decomp_data_0x1e37[] = { 2, 0x6c, 0x323, };
+static const char32 __uni_decomp_data_0x1e38[] = { 2, 0x1e36, 0x304, };
+static const char32 __uni_decomp_data_0x1e39[] = { 2, 0x1e37, 0x304, };
+static const char32 __uni_decomp_data_0x1e3a[] = { 2, 0x4c, 0x331, };
+static const char32 __uni_decomp_data_0x1e3b[] = { 2, 0x6c, 0x331, };
+static const char32 __uni_decomp_data_0x1e3c[] = { 2, 0x4c, 0x32d, };
+static const char32 __uni_decomp_data_0x1e3d[] = { 2, 0x6c, 0x32d, };
+static const char32 __uni_decomp_data_0x1e3e[] = { 2, 0x4d, 0x301, };
+static const char32 __uni_decomp_data_0x1e3f[] = { 2, 0x6d, 0x301, };
+static const char32 __uni_decomp_data_0x1e40[] = { 2, 0x4d, 0x307, };
+static const char32 __uni_decomp_data_0x1e41[] = { 2, 0x6d, 0x307, };
+static const char32 __uni_decomp_data_0x1e42[] = { 2, 0x4d, 0x323, };
+static const char32 __uni_decomp_data_0x1e43[] = { 2, 0x6d, 0x323, };
+static const char32 __uni_decomp_data_0x1e44[] = { 2, 0x4e, 0x307, };
+static const char32 __uni_decomp_data_0x1e45[] = { 2, 0x6e, 0x307, };
+static const char32 __uni_decomp_data_0x1e46[] = { 2, 0x4e, 0x323, };
+static const char32 __uni_decomp_data_0x1e47[] = { 2, 0x6e, 0x323, };
+static const char32 __uni_decomp_data_0x1e48[] = { 2, 0x4e, 0x331, };
+static const char32 __uni_decomp_data_0x1e49[] = { 2, 0x6e, 0x331, };
+static const char32 __uni_decomp_data_0x1e4a[] = { 2, 0x4e, 0x32d, };
+static const char32 __uni_decomp_data_0x1e4b[] = { 2, 0x6e, 0x32d, };
+static const char32 __uni_decomp_data_0x1e4c[] = { 2, 0xd5, 0x301, };
+static const char32 __uni_decomp_data_0x1e4d[] = { 2, 0xf5, 0x301, };
+static const char32 __uni_decomp_data_0x1e4e[] = { 2, 0xd5, 0x308, };
+static const char32 __uni_decomp_data_0x1e4f[] = { 2, 0xf5, 0x308, };
+static const char32 __uni_decomp_data_0x1e50[] = { 2, 0x14c, 0x300, };
+static const char32 __uni_decomp_data_0x1e51[] = { 2, 0x14d, 0x300, };
+static const char32 __uni_decomp_data_0x1e52[] = { 2, 0x14c, 0x301, };
+static const char32 __uni_decomp_data_0x1e53[] = { 2, 0x14d, 0x301, };
+static const char32 __uni_decomp_data_0x1e54[] = { 2, 0x50, 0x301, };
+static const char32 __uni_decomp_data_0x1e55[] = { 2, 0x70, 0x301, };
+static const char32 __uni_decomp_data_0x1e56[] = { 2, 0x50, 0x307, };
+static const char32 __uni_decomp_data_0x1e57[] = { 2, 0x70, 0x307, };
+static const char32 __uni_decomp_data_0x1e58[] = { 2, 0x52, 0x307, };
+static const char32 __uni_decomp_data_0x1e59[] = { 2, 0x72, 0x307, };
+static const char32 __uni_decomp_data_0x1e5a[] = { 2, 0x52, 0x323, };
+static const char32 __uni_decomp_data_0x1e5b[] = { 2, 0x72, 0x323, };
+static const char32 __uni_decomp_data_0x1e5c[] = { 2, 0x1e5a, 0x304, };
+static const char32 __uni_decomp_data_0x1e5d[] = { 2, 0x1e5b, 0x304, };
+static const char32 __uni_decomp_data_0x1e5e[] = { 2, 0x52, 0x331, };
+static const char32 __uni_decomp_data_0x1e5f[] = { 2, 0x72, 0x331, };
+static const char32 __uni_decomp_data_0x1e60[] = { 2, 0x53, 0x307, };
+static const char32 __uni_decomp_data_0x1e61[] = { 2, 0x73, 0x307, };
+static const char32 __uni_decomp_data_0x1e62[] = { 2, 0x53, 0x323, };
+static const char32 __uni_decomp_data_0x1e63[] = { 2, 0x73, 0x323, };
+static const char32 __uni_decomp_data_0x1e64[] = { 2, 0x15a, 0x307, };
+static const char32 __uni_decomp_data_0x1e65[] = { 2, 0x15b, 0x307, };
+static const char32 __uni_decomp_data_0x1e66[] = { 2, 0x160, 0x307, };
+static const char32 __uni_decomp_data_0x1e67[] = { 2, 0x161, 0x307, };
+static const char32 __uni_decomp_data_0x1e68[] = { 2, 0x1e62, 0x307, };
+static const char32 __uni_decomp_data_0x1e69[] = { 2, 0x1e63, 0x307, };
+static const char32 __uni_decomp_data_0x1e6a[] = { 2, 0x54, 0x307, };
+static const char32 __uni_decomp_data_0x1e6b[] = { 2, 0x74, 0x307, };
+static const char32 __uni_decomp_data_0x1e6c[] = { 2, 0x54, 0x323, };
+static const char32 __uni_decomp_data_0x1e6d[] = { 2, 0x74, 0x323, };
+static const char32 __uni_decomp_data_0x1e6e[] = { 2, 0x54, 0x331, };
+static const char32 __uni_decomp_data_0x1e6f[] = { 2, 0x74, 0x331, };
+static const char32 __uni_decomp_data_0x1e70[] = { 2, 0x54, 0x32d, };
+static const char32 __uni_decomp_data_0x1e71[] = { 2, 0x74, 0x32d, };
+static const char32 __uni_decomp_data_0x1e72[] = { 2, 0x55, 0x324, };
+static const char32 __uni_decomp_data_0x1e73[] = { 2, 0x75, 0x324, };
+static const char32 __uni_decomp_data_0x1e74[] = { 2, 0x55, 0x330, };
+static const char32 __uni_decomp_data_0x1e75[] = { 2, 0x75, 0x330, };
+static const char32 __uni_decomp_data_0x1e76[] = { 2, 0x55, 0x32d, };
+static const char32 __uni_decomp_data_0x1e77[] = { 2, 0x75, 0x32d, };
+static const char32 __uni_decomp_data_0x1e78[] = { 2, 0x168, 0x301, };
+static const char32 __uni_decomp_data_0x1e79[] = { 2, 0x169, 0x301, };
+static const char32 __uni_decomp_data_0x1e7a[] = { 2, 0x16a, 0x308, };
+static const char32 __uni_decomp_data_0x1e7b[] = { 2, 0x16b, 0x308, };
+static const char32 __uni_decomp_data_0x1e7c[] = { 2, 0x56, 0x303, };
+static const char32 __uni_decomp_data_0x1e7d[] = { 2, 0x76, 0x303, };
+static const char32 __uni_decomp_data_0x1e7e[] = { 2, 0x56, 0x323, };
+static const char32 __uni_decomp_data_0x1e7f[] = { 2, 0x76, 0x323, };
 
 
 
@@ -16988,124 +16988,124 @@
 };
 
 
-static const char32 __uni_decomp_data_0x1e80[] = { 0x57, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1e81[] = { 0x77, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1e82[] = { 0x57, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1e83[] = { 0x77, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1e84[] = { 0x57, 0x308, 0, };
-static const char32 __uni_decomp_data_0x1e85[] = { 0x77, 0x308, 0, };
-static const char32 __uni_decomp_data_0x1e86[] = { 0x57, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e87[] = { 0x77, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e88[] = { 0x57, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1e89[] = { 0x77, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1e8a[] = { 0x58, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e8b[] = { 0x78, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e8c[] = { 0x58, 0x308, 0, };
-static const char32 __uni_decomp_data_0x1e8d[] = { 0x78, 0x308, 0, };
-static const char32 __uni_decomp_data_0x1e8e[] = { 0x59, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e8f[] = { 0x79, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1e90[] = { 0x5a, 0x302, 0, };
-static const char32 __uni_decomp_data_0x1e91[] = { 0x7a, 0x302, 0, };
-static const char32 __uni_decomp_data_0x1e92[] = { 0x5a, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1e93[] = { 0x7a, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1e94[] = { 0x5a, 0x331, 0, };
-static const char32 __uni_decomp_data_0x1e95[] = { 0x7a, 0x331, 0, };
-static const char32 __uni_decomp_data_0x1e96[] = { 0x68, 0x331, 0, };
-static const char32 __uni_decomp_data_0x1e97[] = { 0x74, 0x308, 0, };
-static const char32 __uni_decomp_data_0x1e98[] = { 0x77, 0x30a, 0, };
-static const char32 __uni_decomp_data_0x1e99[] = { 0x79, 0x30a, 0, };
-static const char32 __uni_decomp_data_0x1e9a[] = { 0x61, 0x2be, 0, };
-static const char32 __uni_decomp_data_0x1e9b[] = { 0x17f, 0x307, 0, };
-static const char32 __uni_decomp_data_0x1ea0[] = { 0x41, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1ea1[] = { 0x61, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1ea2[] = { 0x41, 0x309, 0, };
-static const char32 __uni_decomp_data_0x1ea3[] = { 0x61, 0x309, 0, };
-static const char32 __uni_decomp_data_0x1ea4[] = { 0xc2, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1ea5[] = { 0xe2, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1ea6[] = { 0xc2, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1ea7[] = { 0xe2, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1ea8[] = { 0xc2, 0x309, 0, };
-static const char32 __uni_decomp_data_0x1ea9[] = { 0xe2, 0x309, 0, };
-static const char32 __uni_decomp_data_0x1eaa[] = { 0xc2, 0x303, 0, };
-static const char32 __uni_decomp_data_0x1eab[] = { 0xe2, 0x303, 0, };
-static const char32 __uni_decomp_data_0x1eac[] = { 0x1ea0, 0x302, 0, };
-static const char32 __uni_decomp_data_0x1ead[] = { 0x1ea1, 0x302, 0, };
-static const char32 __uni_decomp_data_0x1eae[] = { 0x102, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1eaf[] = { 0x103, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1eb0[] = { 0x102, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1eb1[] = { 0x103, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1eb2[] = { 0x102, 0x309, 0, };
-static const char32 __uni_decomp_data_0x1eb3[] = { 0x103, 0x309, 0, };
-static const char32 __uni_decomp_data_0x1eb4[] = { 0x102, 0x303, 0, };
-static const char32 __uni_decomp_data_0x1eb5[] = { 0x103, 0x303, 0, };
-static const char32 __uni_decomp_data_0x1eb6[] = { 0x1ea0, 0x306, 0, };
-static const char32 __uni_decomp_data_0x1eb7[] = { 0x1ea1, 0x306, 0, };
-static const char32 __uni_decomp_data_0x1eb8[] = { 0x45, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1eb9[] = { 0x65, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1eba[] = { 0x45, 0x309, 0, };
-static const char32 __uni_decomp_data_0x1ebb[] = { 0x65, 0x309, 0, };
-static const char32 __uni_decomp_data_0x1ebc[] = { 0x45, 0x303, 0, };
-static const char32 __uni_decomp_data_0x1ebd[] = { 0x65, 0x303, 0, };
-static const char32 __uni_decomp_data_0x1ebe[] = { 0xca, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1ebf[] = { 0xea, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1ec0[] = { 0xca, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1ec1[] = { 0xea, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1ec2[] = { 0xca, 0x309, 0, };
-static const char32 __uni_decomp_data_0x1ec3[] = { 0xea, 0x309, 0, };
-static const char32 __uni_decomp_data_0x1ec4[] = { 0xca, 0x303, 0, };
-static const char32 __uni_decomp_data_0x1ec5[] = { 0xea, 0x303, 0, };
-static const char32 __uni_decomp_data_0x1ec6[] = { 0x1eb8, 0x302, 0, };
-static const char32 __uni_decomp_data_0x1ec7[] = { 0x1eb9, 0x302, 0, };
-static const char32 __uni_decomp_data_0x1ec8[] = { 0x49, 0x309, 0, };
-static const char32 __uni_decomp_data_0x1ec9[] = { 0x69, 0x309, 0, };
-static const char32 __uni_decomp_data_0x1eca[] = { 0x49, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1ecb[] = { 0x69, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1ecc[] = { 0x4f, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1ecd[] = { 0x6f, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1ece[] = { 0x4f, 0x309, 0, };
-static const char32 __uni_decomp_data_0x1ecf[] = { 0x6f, 0x309, 0, };
-static const char32 __uni_decomp_data_0x1ed0[] = { 0xd4, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1ed1[] = { 0xf4, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1ed2[] = { 0xd4, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1ed3[] = { 0xf4, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1ed4[] = { 0xd4, 0x309, 0, };
-static const char32 __uni_decomp_data_0x1ed5[] = { 0xf4, 0x309, 0, };
-static const char32 __uni_decomp_data_0x1ed6[] = { 0xd4, 0x303, 0, };
-static const char32 __uni_decomp_data_0x1ed7[] = { 0xf4, 0x303, 0, };
-static const char32 __uni_decomp_data_0x1ed8[] = { 0x1ecc, 0x302, 0, };
-static const char32 __uni_decomp_data_0x1ed9[] = { 0x1ecd, 0x302, 0, };
-static const char32 __uni_decomp_data_0x1eda[] = { 0x1a0, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1edb[] = { 0x1a1, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1edc[] = { 0x1a0, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1edd[] = { 0x1a1, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1ede[] = { 0x1a0, 0x309, 0, };
-static const char32 __uni_decomp_data_0x1edf[] = { 0x1a1, 0x309, 0, };
-static const char32 __uni_decomp_data_0x1ee0[] = { 0x1a0, 0x303, 0, };
-static const char32 __uni_decomp_data_0x1ee1[] = { 0x1a1, 0x303, 0, };
-static const char32 __uni_decomp_data_0x1ee2[] = { 0x1a0, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1ee3[] = { 0x1a1, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1ee4[] = { 0x55, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1ee5[] = { 0x75, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1ee6[] = { 0x55, 0x309, 0, };
-static const char32 __uni_decomp_data_0x1ee7[] = { 0x75, 0x309, 0, };
-static const char32 __uni_decomp_data_0x1ee8[] = { 0x1af, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1ee9[] = { 0x1b0, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1eea[] = { 0x1af, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1eeb[] = { 0x1b0, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1eec[] = { 0x1af, 0x309, 0, };
-static const char32 __uni_decomp_data_0x1eed[] = { 0x1b0, 0x309, 0, };
-static const char32 __uni_decomp_data_0x1eee[] = { 0x1af, 0x303, 0, };
-static const char32 __uni_decomp_data_0x1eef[] = { 0x1b0, 0x303, 0, };
-static const char32 __uni_decomp_data_0x1ef0[] = { 0x1af, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1ef1[] = { 0x1b0, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1ef2[] = { 0x59, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1ef3[] = { 0x79, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1ef4[] = { 0x59, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1ef5[] = { 0x79, 0x323, 0, };
-static const char32 __uni_decomp_data_0x1ef6[] = { 0x59, 0x309, 0, };
-static const char32 __uni_decomp_data_0x1ef7[] = { 0x79, 0x309, 0, };
-static const char32 __uni_decomp_data_0x1ef8[] = { 0x59, 0x303, 0, };
-static const char32 __uni_decomp_data_0x1ef9[] = { 0x79, 0x303, 0, };
+static const char32 __uni_decomp_data_0x1e80[] = { 2, 0x57, 0x300, };
+static const char32 __uni_decomp_data_0x1e81[] = { 2, 0x77, 0x300, };
+static const char32 __uni_decomp_data_0x1e82[] = { 2, 0x57, 0x301, };
+static const char32 __uni_decomp_data_0x1e83[] = { 2, 0x77, 0x301, };
+static const char32 __uni_decomp_data_0x1e84[] = { 2, 0x57, 0x308, };
+static const char32 __uni_decomp_data_0x1e85[] = { 2, 0x77, 0x308, };
+static const char32 __uni_decomp_data_0x1e86[] = { 2, 0x57, 0x307, };
+static const char32 __uni_decomp_data_0x1e87[] = { 2, 0x77, 0x307, };
+static const char32 __uni_decomp_data_0x1e88[] = { 2, 0x57, 0x323, };
+static const char32 __uni_decomp_data_0x1e89[] = { 2, 0x77, 0x323, };
+static const char32 __uni_decomp_data_0x1e8a[] = { 2, 0x58, 0x307, };
+static const char32 __uni_decomp_data_0x1e8b[] = { 2, 0x78, 0x307, };
+static const char32 __uni_decomp_data_0x1e8c[] = { 2, 0x58, 0x308, };
+static const char32 __uni_decomp_data_0x1e8d[] = { 2, 0x78, 0x308, };
+static const char32 __uni_decomp_data_0x1e8e[] = { 2, 0x59, 0x307, };
+static const char32 __uni_decomp_data_0x1e8f[] = { 2, 0x79, 0x307, };
+static const char32 __uni_decomp_data_0x1e90[] = { 2, 0x5a, 0x302, };
+static const char32 __uni_decomp_data_0x1e91[] = { 2, 0x7a, 0x302, };
+static const char32 __uni_decomp_data_0x1e92[] = { 2, 0x5a, 0x323, };
+static const char32 __uni_decomp_data_0x1e93[] = { 2, 0x7a, 0x323, };
+static const char32 __uni_decomp_data_0x1e94[] = { 2, 0x5a, 0x331, };
+static const char32 __uni_decomp_data_0x1e95[] = { 2, 0x7a, 0x331, };
+static const char32 __uni_decomp_data_0x1e96[] = { 2, 0x68, 0x331, };
+static const char32 __uni_decomp_data_0x1e97[] = { 2, 0x74, 0x308, };
+static const char32 __uni_decomp_data_0x1e98[] = { 2, 0x77, 0x30a, };
+static const char32 __uni_decomp_data_0x1e99[] = { 2, 0x79, 0x30a, };
+static const char32 __uni_decomp_data_0x1e9a[] = { 2, 0x61, 0x2be, };
+static const char32 __uni_decomp_data_0x1e9b[] = { 2, 0x17f, 0x307, };
+static const char32 __uni_decomp_data_0x1ea0[] = { 2, 0x41, 0x323, };
+static const char32 __uni_decomp_data_0x1ea1[] = { 2, 0x61, 0x323, };
+static const char32 __uni_decomp_data_0x1ea2[] = { 2, 0x41, 0x309, };
+static const char32 __uni_decomp_data_0x1ea3[] = { 2, 0x61, 0x309, };
+static const char32 __uni_decomp_data_0x1ea4[] = { 2, 0xc2, 0x301, };
+static const char32 __uni_decomp_data_0x1ea5[] = { 2, 0xe2, 0x301, };
+static const char32 __uni_decomp_data_0x1ea6[] = { 2, 0xc2, 0x300, };
+static const char32 __uni_decomp_data_0x1ea7[] = { 2, 0xe2, 0x300, };
+static const char32 __uni_decomp_data_0x1ea8[] = { 2, 0xc2, 0x309, };
+static const char32 __uni_decomp_data_0x1ea9[] = { 2, 0xe2, 0x309, };
+static const char32 __uni_decomp_data_0x1eaa[] = { 2, 0xc2, 0x303, };
+static const char32 __uni_decomp_data_0x1eab[] = { 2, 0xe2, 0x303, };
+static const char32 __uni_decomp_data_0x1eac[] = { 2, 0x1ea0, 0x302, };
+static const char32 __uni_decomp_data_0x1ead[] = { 2, 0x1ea1, 0x302, };
+static const char32 __uni_decomp_data_0x1eae[] = { 2, 0x102, 0x301, };
+static const char32 __uni_decomp_data_0x1eaf[] = { 2, 0x103, 0x301, };
+static const char32 __uni_decomp_data_0x1eb0[] = { 2, 0x102, 0x300, };
+static const char32 __uni_decomp_data_0x1eb1[] = { 2, 0x103, 0x300, };
+static const char32 __uni_decomp_data_0x1eb2[] = { 2, 0x102, 0x309, };
+static const char32 __uni_decomp_data_0x1eb3[] = { 2, 0x103, 0x309, };
+static const char32 __uni_decomp_data_0x1eb4[] = { 2, 0x102, 0x303, };
+static const char32 __uni_decomp_data_0x1eb5[] = { 2, 0x103, 0x303, };
+static const char32 __uni_decomp_data_0x1eb6[] = { 2, 0x1ea0, 0x306, };
+static const char32 __uni_decomp_data_0x1eb7[] = { 2, 0x1ea1, 0x306, };
+static const char32 __uni_decomp_data_0x1eb8[] = { 2, 0x45, 0x323, };
+static const char32 __uni_decomp_data_0x1eb9[] = { 2, 0x65, 0x323, };
+static const char32 __uni_decomp_data_0x1eba[] = { 2, 0x45, 0x309, };
+static const char32 __uni_decomp_data_0x1ebb[] = { 2, 0x65, 0x309, };
+static const char32 __uni_decomp_data_0x1ebc[] = { 2, 0x45, 0x303, };
+static const char32 __uni_decomp_data_0x1ebd[] = { 2, 0x65, 0x303, };
+static const char32 __uni_decomp_data_0x1ebe[] = { 2, 0xca, 0x301, };
+static const char32 __uni_decomp_data_0x1ebf[] = { 2, 0xea, 0x301, };
+static const char32 __uni_decomp_data_0x1ec0[] = { 2, 0xca, 0x300, };
+static const char32 __uni_decomp_data_0x1ec1[] = { 2, 0xea, 0x300, };
+static const char32 __uni_decomp_data_0x1ec2[] = { 2, 0xca, 0x309, };
+static const char32 __uni_decomp_data_0x1ec3[] = { 2, 0xea, 0x309, };
+static const char32 __uni_decomp_data_0x1ec4[] = { 2, 0xca, 0x303, };
+static const char32 __uni_decomp_data_0x1ec5[] = { 2, 0xea, 0x303, };
+static const char32 __uni_decomp_data_0x1ec6[] = { 2, 0x1eb8, 0x302, };
+static const char32 __uni_decomp_data_0x1ec7[] = { 2, 0x1eb9, 0x302, };
+static const char32 __uni_decomp_data_0x1ec8[] = { 2, 0x49, 0x309, };
+static const char32 __uni_decomp_data_0x1ec9[] = { 2, 0x69, 0x309, };
+static const char32 __uni_decomp_data_0x1eca[] = { 2, 0x49, 0x323, };
+static const char32 __uni_decomp_data_0x1ecb[] = { 2, 0x69, 0x323, };
+static const char32 __uni_decomp_data_0x1ecc[] = { 2, 0x4f, 0x323, };
+static const char32 __uni_decomp_data_0x1ecd[] = { 2, 0x6f, 0x323, };
+static const char32 __uni_decomp_data_0x1ece[] = { 2, 0x4f, 0x309, };
+static const char32 __uni_decomp_data_0x1ecf[] = { 2, 0x6f, 0x309, };
+static const char32 __uni_decomp_data_0x1ed0[] = { 2, 0xd4, 0x301, };
+static const char32 __uni_decomp_data_0x1ed1[] = { 2, 0xf4, 0x301, };
+static const char32 __uni_decomp_data_0x1ed2[] = { 2, 0xd4, 0x300, };
+static const char32 __uni_decomp_data_0x1ed3[] = { 2, 0xf4, 0x300, };
+static const char32 __uni_decomp_data_0x1ed4[] = { 2, 0xd4, 0x309, };
+static const char32 __uni_decomp_data_0x1ed5[] = { 2, 0xf4, 0x309, };
+static const char32 __uni_decomp_data_0x1ed6[] = { 2, 0xd4, 0x303, };
+static const char32 __uni_decomp_data_0x1ed7[] = { 2, 0xf4, 0x303, };
+static const char32 __uni_decomp_data_0x1ed8[] = { 2, 0x1ecc, 0x302, };
+static const char32 __uni_decomp_data_0x1ed9[] = { 2, 0x1ecd, 0x302, };
+static const char32 __uni_decomp_data_0x1eda[] = { 2, 0x1a0, 0x301, };
+static const char32 __uni_decomp_data_0x1edb[] = { 2, 0x1a1, 0x301, };
+static const char32 __uni_decomp_data_0x1edc[] = { 2, 0x1a0, 0x300, };
+static const char32 __uni_decomp_data_0x1edd[] = { 2, 0x1a1, 0x300, };
+static const char32 __uni_decomp_data_0x1ede[] = { 2, 0x1a0, 0x309, };
+static const char32 __uni_decomp_data_0x1edf[] = { 2, 0x1a1, 0x309, };
+static const char32 __uni_decomp_data_0x1ee0[] = { 2, 0x1a0, 0x303, };
+static const char32 __uni_decomp_data_0x1ee1[] = { 2, 0x1a1, 0x303, };
+static const char32 __uni_decomp_data_0x1ee2[] = { 2, 0x1a0, 0x323, };
+static const char32 __uni_decomp_data_0x1ee3[] = { 2, 0x1a1, 0x323, };
+static const char32 __uni_decomp_data_0x1ee4[] = { 2, 0x55, 0x323, };
+static const char32 __uni_decomp_data_0x1ee5[] = { 2, 0x75, 0x323, };
+static const char32 __uni_decomp_data_0x1ee6[] = { 2, 0x55, 0x309, };
+static const char32 __uni_decomp_data_0x1ee7[] = { 2, 0x75, 0x309, };
+static const char32 __uni_decomp_data_0x1ee8[] = { 2, 0x1af, 0x301, };
+static const char32 __uni_decomp_data_0x1ee9[] = { 2, 0x1b0, 0x301, };
+static const char32 __uni_decomp_data_0x1eea[] = { 2, 0x1af, 0x300, };
+static const char32 __uni_decomp_data_0x1eeb[] = { 2, 0x1b0, 0x300, };
+static const char32 __uni_decomp_data_0x1eec[] = { 2, 0x1af, 0x309, };
+static const char32 __uni_decomp_data_0x1eed[] = { 2, 0x1b0, 0x309, };
+static const char32 __uni_decomp_data_0x1eee[] = { 2, 0x1af, 0x303, };
+static const char32 __uni_decomp_data_0x1eef[] = { 2, 0x1b0, 0x303, };
+static const char32 __uni_decomp_data_0x1ef0[] = { 2, 0x1af, 0x323, };
+static const char32 __uni_decomp_data_0x1ef1[] = { 2, 0x1b0, 0x323, };
+static const char32 __uni_decomp_data_0x1ef2[] = { 2, 0x59, 0x300, };
+static const char32 __uni_decomp_data_0x1ef3[] = { 2, 0x79, 0x300, };
+static const char32 __uni_decomp_data_0x1ef4[] = { 2, 0x59, 0x323, };
+static const char32 __uni_decomp_data_0x1ef5[] = { 2, 0x79, 0x323, };
+static const char32 __uni_decomp_data_0x1ef6[] = { 2, 0x59, 0x309, };
+static const char32 __uni_decomp_data_0x1ef7[] = { 2, 0x79, 0x309, };
+static const char32 __uni_decomp_data_0x1ef8[] = { 2, 0x59, 0x303, };
+static const char32 __uni_decomp_data_0x1ef9[] = { 2, 0x79, 0x303, };
 
 
 
@@ -18779,120 +18779,120 @@
 };
 
 
-static const char32 __uni_decomp_data_0x1f00[] = { 0x3b1, 0x313, 0, };
-static const char32 __uni_decomp_data_0x1f01[] = { 0x3b1, 0x314, 0, };
-static const char32 __uni_decomp_data_0x1f02[] = { 0x1f00, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f03[] = { 0x1f01, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f04[] = { 0x1f00, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1f05[] = { 0x1f01, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1f06[] = { 0x1f00, 0x342, 0, };
-static const char32 __uni_decomp_data_0x1f07[] = { 0x1f01, 0x342, 0, };
-static const char32 __uni_decomp_data_0x1f08[] = { 0x391, 0x313, 0, };
-static const char32 __uni_decomp_data_0x1f09[] = { 0x391, 0x314, 0, };
-static const char32 __uni_decomp_data_0x1f0a[] = { 0x1f08, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f0b[] = { 0x1f09, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f0c[] = { 0x1f08, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1f0d[] = { 0x1f09, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1f0e[] = { 0x1f08, 0x342, 0, };
-static const char32 __uni_decomp_data_0x1f0f[] = { 0x1f09, 0x342, 0, };
-static const char32 __uni_decomp_data_0x1f10[] = { 0x3b5, 0x313, 0, };
-static const char32 __uni_decomp_data_0x1f11[] = { 0x3b5, 0x314, 0, };
-static const char32 __uni_decomp_data_0x1f12[] = { 0x1f10, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f13[] = { 0x1f11, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f14[] = { 0x1f10, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1f15[] = { 0x1f11, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1f18[] = { 0x395, 0x313, 0, };
-static const char32 __uni_decomp_data_0x1f19[] = { 0x395, 0x314, 0, };
-static const char32 __uni_decomp_data_0x1f1a[] = { 0x1f18, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f1b[] = { 0x1f19, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f1c[] = { 0x1f18, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1f1d[] = { 0x1f19, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1f20[] = { 0x3b7, 0x313, 0, };
-static const char32 __uni_decomp_data_0x1f21[] = { 0x3b7, 0x314, 0, };
-static const char32 __uni_decomp_data_0x1f22[] = { 0x1f20, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f23[] = { 0x1f21, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f24[] = { 0x1f20, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1f25[] = { 0x1f21, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1f26[] = { 0x1f20, 0x342, 0, };
-static const char32 __uni_decomp_data_0x1f27[] = { 0x1f21, 0x342, 0, };
-static const char32 __uni_decomp_data_0x1f28[] = { 0x397, 0x313, 0, };
-static const char32 __uni_decomp_data_0x1f29[] = { 0x397, 0x314, 0, };
-static const char32 __uni_decomp_data_0x1f2a[] = { 0x1f28, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f2b[] = { 0x1f29, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f2c[] = { 0x1f28, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1f2d[] = { 0x1f29, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1f2e[] = { 0x1f28, 0x342, 0, };
-static const char32 __uni_decomp_data_0x1f2f[] = { 0x1f29, 0x342, 0, };
-static const char32 __uni_decomp_data_0x1f30[] = { 0x3b9, 0x313, 0, };
-static const char32 __uni_decomp_data_0x1f31[] = { 0x3b9, 0x314, 0, };
-static const char32 __uni_decomp_data_0x1f32[] = { 0x1f30, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f33[] = { 0x1f31, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f34[] = { 0x1f30, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1f35[] = { 0x1f31, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1f36[] = { 0x1f30, 0x342, 0, };
-static const char32 __uni_decomp_data_0x1f37[] = { 0x1f31, 0x342, 0, };
-static const char32 __uni_decomp_data_0x1f38[] = { 0x399, 0x313, 0, };
-static const char32 __uni_decomp_data_0x1f39[] = { 0x399, 0x314, 0, };
-static const char32 __uni_decomp_data_0x1f3a[] = { 0x1f38, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f3b[] = { 0x1f39, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f3c[] = { 0x1f38, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1f3d[] = { 0x1f39, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1f3e[] = { 0x1f38, 0x342, 0, };
-static const char32 __uni_decomp_data_0x1f3f[] = { 0x1f39, 0x342, 0, };
-static const char32 __uni_decomp_data_0x1f40[] = { 0x3bf, 0x313, 0, };
-static const char32 __uni_decomp_data_0x1f41[] = { 0x3bf, 0x314, 0, };
-static const char32 __uni_decomp_data_0x1f42[] = { 0x1f40, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f43[] = { 0x1f41, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f44[] = { 0x1f40, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1f45[] = { 0x1f41, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1f48[] = { 0x39f, 0x313, 0, };
-static const char32 __uni_decomp_data_0x1f49[] = { 0x39f, 0x314, 0, };
-static const char32 __uni_decomp_data_0x1f4a[] = { 0x1f48, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f4b[] = { 0x1f49, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f4c[] = { 0x1f48, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1f4d[] = { 0x1f49, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1f50[] = { 0x3c5, 0x313, 0, };
-static const char32 __uni_decomp_data_0x1f51[] = { 0x3c5, 0x314, 0, };
-static const char32 __uni_decomp_data_0x1f52[] = { 0x1f50, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f53[] = { 0x1f51, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f54[] = { 0x1f50, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1f55[] = { 0x1f51, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1f56[] = { 0x1f50, 0x342, 0, };
-static const char32 __uni_decomp_data_0x1f57[] = { 0x1f51, 0x342, 0, };
-static const char32 __uni_decomp_data_0x1f59[] = { 0x3a5, 0x314, 0, };
-static const char32 __uni_decomp_data_0x1f5b[] = { 0x1f59, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f5d[] = { 0x1f59, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1f5f[] = { 0x1f59, 0x342, 0, };
-static const char32 __uni_decomp_data_0x1f60[] = { 0x3c9, 0x313, 0, };
-static const char32 __uni_decomp_data_0x1f61[] = { 0x3c9, 0x314, 0, };
-static const char32 __uni_decomp_data_0x1f62[] = { 0x1f60, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f63[] = { 0x1f61, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f64[] = { 0x1f60, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1f65[] = { 0x1f61, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1f66[] = { 0x1f60, 0x342, 0, };
-static const char32 __uni_decomp_data_0x1f67[] = { 0x1f61, 0x342, 0, };
-static const char32 __uni_decomp_data_0x1f68[] = { 0x3a9, 0x313, 0, };
-static const char32 __uni_decomp_data_0x1f69[] = { 0x3a9, 0x314, 0, };
-static const char32 __uni_decomp_data_0x1f6a[] = { 0x1f68, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f6b[] = { 0x1f69, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f6c[] = { 0x1f68, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1f6d[] = { 0x1f69, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1f6e[] = { 0x1f68, 0x342, 0, };
-static const char32 __uni_decomp_data_0x1f6f[] = { 0x1f69, 0x342, 0, };
-static const char32 __uni_decomp_data_0x1f70[] = { 0x3b1, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f71[] = { 0x3ac, 0, };
-static const char32 __uni_decomp_data_0x1f72[] = { 0x3b5, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f73[] = { 0x3ad, 0, };
-static const char32 __uni_decomp_data_0x1f74[] = { 0x3b7, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f75[] = { 0x3ae, 0, };
-static const char32 __uni_decomp_data_0x1f76[] = { 0x3b9, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f77[] = { 0x3af, 0, };
-static const char32 __uni_decomp_data_0x1f78[] = { 0x3bf, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f79[] = { 0x3cc, 0, };
-static const char32 __uni_decomp_data_0x1f7a[] = { 0x3c5, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f7b[] = { 0x3cd, 0, };
-static const char32 __uni_decomp_data_0x1f7c[] = { 0x3c9, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1f7d[] = { 0x3ce, 0, };
+static const char32 __uni_decomp_data_0x1f00[] = { 2, 0x3b1, 0x313, };
+static const char32 __uni_decomp_data_0x1f01[] = { 2, 0x3b1, 0x314, };
+static const char32 __uni_decomp_data_0x1f02[] = { 2, 0x1f00, 0x300, };
+static const char32 __uni_decomp_data_0x1f03[] = { 2, 0x1f01, 0x300, };
+static const char32 __uni_decomp_data_0x1f04[] = { 2, 0x1f00, 0x301, };
+static const char32 __uni_decomp_data_0x1f05[] = { 2, 0x1f01, 0x301, };
+static const char32 __uni_decomp_data_0x1f06[] = { 2, 0x1f00, 0x342, };
+static const char32 __uni_decomp_data_0x1f07[] = { 2, 0x1f01, 0x342, };
+static const char32 __uni_decomp_data_0x1f08[] = { 2, 0x391, 0x313, };
+static const char32 __uni_decomp_data_0x1f09[] = { 2, 0x391, 0x314, };
+static const char32 __uni_decomp_data_0x1f0a[] = { 2, 0x1f08, 0x300, };
+static const char32 __uni_decomp_data_0x1f0b[] = { 2, 0x1f09, 0x300, };
+static const char32 __uni_decomp_data_0x1f0c[] = { 2, 0x1f08, 0x301, };
+static const char32 __uni_decomp_data_0x1f0d[] = { 2, 0x1f09, 0x301, };
+static const char32 __uni_decomp_data_0x1f0e[] = { 2, 0x1f08, 0x342, };
+static const char32 __uni_decomp_data_0x1f0f[] = { 2, 0x1f09, 0x342, };
+static const char32 __uni_decomp_data_0x1f10[] = { 2, 0x3b5, 0x313, };
+static const char32 __uni_decomp_data_0x1f11[] = { 2, 0x3b5, 0x314, };
+static const char32 __uni_decomp_data_0x1f12[] = { 2, 0x1f10, 0x300, };
+static const char32 __uni_decomp_data_0x1f13[] = { 2, 0x1f11, 0x300, };
+static const char32 __uni_decomp_data_0x1f14[] = { 2, 0x1f10, 0x301, };
+static const char32 __uni_decomp_data_0x1f15[] = { 2, 0x1f11, 0x301, };
+static const char32 __uni_decomp_data_0x1f18[] = { 2, 0x395, 0x313, };
+static const char32 __uni_decomp_data_0x1f19[] = { 2, 0x395, 0x314, };
+static const char32 __uni_decomp_data_0x1f1a[] = { 2, 0x1f18, 0x300, };
+static const char32 __uni_decomp_data_0x1f1b[] = { 2, 0x1f19, 0x300, };
+static const char32 __uni_decomp_data_0x1f1c[] = { 2, 0x1f18, 0x301, };
+static const char32 __uni_decomp_data_0x1f1d[] = { 2, 0x1f19, 0x301, };
+static const char32 __uni_decomp_data_0x1f20[] = { 2, 0x3b7, 0x313, };
+static const char32 __uni_decomp_data_0x1f21[] = { 2, 0x3b7, 0x314, };
+static const char32 __uni_decomp_data_0x1f22[] = { 2, 0x1f20, 0x300, };
+static const char32 __uni_decomp_data_0x1f23[] = { 2, 0x1f21, 0x300, };
+static const char32 __uni_decomp_data_0x1f24[] = { 2, 0x1f20, 0x301, };
+static const char32 __uni_decomp_data_0x1f25[] = { 2, 0x1f21, 0x301, };
+static const char32 __uni_decomp_data_0x1f26[] = { 2, 0x1f20, 0x342, };
+static const char32 __uni_decomp_data_0x1f27[] = { 2, 0x1f21, 0x342, };
+static const char32 __uni_decomp_data_0x1f28[] = { 2, 0x397, 0x313, };
+static const char32 __uni_decomp_data_0x1f29[] = { 2, 0x397, 0x314, };
+static const char32 __uni_decomp_data_0x1f2a[] = { 2, 0x1f28, 0x300, };
+static const char32 __uni_decomp_data_0x1f2b[] = { 2, 0x1f29, 0x300, };
+static const char32 __uni_decomp_data_0x1f2c[] = { 2, 0x1f28, 0x301, };
+static const char32 __uni_decomp_data_0x1f2d[] = { 2, 0x1f29, 0x301, };
+static const char32 __uni_decomp_data_0x1f2e[] = { 2, 0x1f28, 0x342, };
+static const char32 __uni_decomp_data_0x1f2f[] = { 2, 0x1f29, 0x342, };
+static const char32 __uni_decomp_data_0x1f30[] = { 2, 0x3b9, 0x313, };
+static const char32 __uni_decomp_data_0x1f31[] = { 2, 0x3b9, 0x314, };
+static const char32 __uni_decomp_data_0x1f32[] = { 2, 0x1f30, 0x300, };
+static const char32 __uni_decomp_data_0x1f33[] = { 2, 0x1f31, 0x300, };
+static const char32 __uni_decomp_data_0x1f34[] = { 2, 0x1f30, 0x301, };
+static const char32 __uni_decomp_data_0x1f35[] = { 2, 0x1f31, 0x301, };
+static const char32 __uni_decomp_data_0x1f36[] = { 2, 0x1f30, 0x342, };
+static const char32 __uni_decomp_data_0x1f37[] = { 2, 0x1f31, 0x342, };
+static const char32 __uni_decomp_data_0x1f38[] = { 2, 0x399, 0x313, };
+static const char32 __uni_decomp_data_0x1f39[] = { 2, 0x399, 0x314, };
+static const char32 __uni_decomp_data_0x1f3a[] = { 2, 0x1f38, 0x300, };
+static const char32 __uni_decomp_data_0x1f3b[] = { 2, 0x1f39, 0x300, };
+static const char32 __uni_decomp_data_0x1f3c[] = { 2, 0x1f38, 0x301, };
+static const char32 __uni_decomp_data_0x1f3d[] = { 2, 0x1f39, 0x301, };
+static const char32 __uni_decomp_data_0x1f3e[] = { 2, 0x1f38, 0x342, };
+static const char32 __uni_decomp_data_0x1f3f[] = { 2, 0x1f39, 0x342, };
+static const char32 __uni_decomp_data_0x1f40[] = { 2, 0x3bf, 0x313, };
+static const char32 __uni_decomp_data_0x1f41[] = { 2, 0x3bf, 0x314, };
+static const char32 __uni_decomp_data_0x1f42[] = { 2, 0x1f40, 0x300, };
+static const char32 __uni_decomp_data_0x1f43[] = { 2, 0x1f41, 0x300, };
+static const char32 __uni_decomp_data_0x1f44[] = { 2, 0x1f40, 0x301, };
+static const char32 __uni_decomp_data_0x1f45[] = { 2, 0x1f41, 0x301, };
+static const char32 __uni_decomp_data_0x1f48[] = { 2, 0x39f, 0x313, };
+static const char32 __uni_decomp_data_0x1f49[] = { 2, 0x39f, 0x314, };
+static const char32 __uni_decomp_data_0x1f4a[] = { 2, 0x1f48, 0x300, };
+static const char32 __uni_decomp_data_0x1f4b[] = { 2, 0x1f49, 0x300, };
+static const char32 __uni_decomp_data_0x1f4c[] = { 2, 0x1f48, 0x301, };
+static const char32 __uni_decomp_data_0x1f4d[] = { 2, 0x1f49, 0x301, };
+static const char32 __uni_decomp_data_0x1f50[] = { 2, 0x3c5, 0x313, };
+static const char32 __uni_decomp_data_0x1f51[] = { 2, 0x3c5, 0x314, };
+static const char32 __uni_decomp_data_0x1f52[] = { 2, 0x1f50, 0x300, };
+static const char32 __uni_decomp_data_0x1f53[] = { 2, 0x1f51, 0x300, };
+static const char32 __uni_decomp_data_0x1f54[] = { 2, 0x1f50, 0x301, };
+static const char32 __uni_decomp_data_0x1f55[] = { 2, 0x1f51, 0x301, };
+static const char32 __uni_decomp_data_0x1f56[] = { 2, 0x1f50, 0x342, };
+static const char32 __uni_decomp_data_0x1f57[] = { 2, 0x1f51, 0x342, };
+static const char32 __uni_decomp_data_0x1f59[] = { 2, 0x3a5, 0x314, };
+static const char32 __uni_decomp_data_0x1f5b[] = { 2, 0x1f59, 0x300, };
+static const char32 __uni_decomp_data_0x1f5d[] = { 2, 0x1f59, 0x301, };
+static const char32 __uni_decomp_data_0x1f5f[] = { 2, 0x1f59, 0x342, };
+static const char32 __uni_decomp_data_0x1f60[] = { 2, 0x3c9, 0x313, };
+static const char32 __uni_decomp_data_0x1f61[] = { 2, 0x3c9, 0x314, };
+static const char32 __uni_decomp_data_0x1f62[] = { 2, 0x1f60, 0x300, };
+static const char32 __uni_decomp_data_0x1f63[] = { 2, 0x1f61, 0x300, };
+static const char32 __uni_decomp_data_0x1f64[] = { 2, 0x1f60, 0x301, };
+static const char32 __uni_decomp_data_0x1f65[] = { 2, 0x1f61, 0x301, };
+static const char32 __uni_decomp_data_0x1f66[] = { 2, 0x1f60, 0x342, };
+static const char32 __uni_decomp_data_0x1f67[] = { 2, 0x1f61, 0x342, };
+static const char32 __uni_decomp_data_0x1f68[] = { 2, 0x3a9, 0x313, };
+static const char32 __uni_decomp_data_0x1f69[] = { 2, 0x3a9, 0x314, };
+static const char32 __uni_decomp_data_0x1f6a[] = { 2, 0x1f68, 0x300, };
+static const char32 __uni_decomp_data_0x1f6b[] = { 2, 0x1f69, 0x300, };
+static const char32 __uni_decomp_data_0x1f6c[] = { 2, 0x1f68, 0x301, };
+static const char32 __uni_decomp_data_0x1f6d[] = { 2, 0x1f69, 0x301, };
+static const char32 __uni_decomp_data_0x1f6e[] = { 2, 0x1f68, 0x342, };
+static const char32 __uni_decomp_data_0x1f6f[] = { 2, 0x1f69, 0x342, };
+static const char32 __uni_decomp_data_0x1f70[] = { 2, 0x3b1, 0x300, };
+static const char32 __uni_decomp_data_0x1f71[] = { 1, 0x3ac, };
+static const char32 __uni_decomp_data_0x1f72[] = { 2, 0x3b5, 0x300, };
+static const char32 __uni_decomp_data_0x1f73[] = { 1, 0x3ad, };
+static const char32 __uni_decomp_data_0x1f74[] = { 2, 0x3b7, 0x300, };
+static const char32 __uni_decomp_data_0x1f75[] = { 1, 0x3ae, };
+static const char32 __uni_decomp_data_0x1f76[] = { 2, 0x3b9, 0x300, };
+static const char32 __uni_decomp_data_0x1f77[] = { 1, 0x3af, };
+static const char32 __uni_decomp_data_0x1f78[] = { 2, 0x3bf, 0x300, };
+static const char32 __uni_decomp_data_0x1f79[] = { 1, 0x3cc, };
+static const char32 __uni_decomp_data_0x1f7a[] = { 2, 0x3c5, 0x300, };
+static const char32 __uni_decomp_data_0x1f7b[] = { 1, 0x3cd, };
+static const char32 __uni_decomp_data_0x1f7c[] = { 2, 0x3c9, 0x300, };
+static const char32 __uni_decomp_data_0x1f7d[] = { 1, 0x3ce, };
 
 
 
@@ -20566,125 +20566,125 @@
 };
 
 
-static const char32 __uni_decomp_data_0x1f80[] = { 0x1f00, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1f81[] = { 0x1f01, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1f82[] = { 0x1f02, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1f83[] = { 0x1f03, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1f84[] = { 0x1f04, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1f85[] = { 0x1f05, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1f86[] = { 0x1f06, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1f87[] = { 0x1f07, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1f88[] = { 0x1f08, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1f89[] = { 0x1f09, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1f8a[] = { 0x1f0a, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1f8b[] = { 0x1f0b, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1f8c[] = { 0x1f0c, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1f8d[] = { 0x1f0d, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1f8e[] = { 0x1f0e, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1f8f[] = { 0x1f0f, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1f90[] = { 0x1f20, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1f91[] = { 0x1f21, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1f92[] = { 0x1f22, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1f93[] = { 0x1f23, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1f94[] = { 0x1f24, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1f95[] = { 0x1f25, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1f96[] = { 0x1f26, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1f97[] = { 0x1f27, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1f98[] = { 0x1f28, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1f99[] = { 0x1f29, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1f9a[] = { 0x1f2a, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1f9b[] = { 0x1f2b, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1f9c[] = { 0x1f2c, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1f9d[] = { 0x1f2d, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1f9e[] = { 0x1f2e, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1f9f[] = { 0x1f2f, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1fa0[] = { 0x1f60, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1fa1[] = { 0x1f61, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1fa2[] = { 0x1f62, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1fa3[] = { 0x1f63, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1fa4[] = { 0x1f64, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1fa5[] = { 0x1f65, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1fa6[] = { 0x1f66, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1fa7[] = { 0x1f67, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1fa8[] = { 0x1f68, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1fa9[] = { 0x1f69, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1faa[] = { 0x1f6a, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1fab[] = { 0x1f6b, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1fac[] = { 0x1f6c, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1fad[] = { 0x1f6d, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1fae[] = { 0x1f6e, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1faf[] = { 0x1f6f, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1fb0[] = { 0x3b1, 0x306, 0, };
-static const char32 __uni_decomp_data_0x1fb1[] = { 0x3b1, 0x304, 0, };
-static const char32 __uni_decomp_data_0x1fb2[] = { 0x1f70, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1fb3[] = { 0x3b1, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1fb4[] = { 0x3ac, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1fb6[] = { 0x3b1, 0x342, 0, };
-static const char32 __uni_decomp_data_0x1fb7[] = { 0x1fb6, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1fb8[] = { 0x391, 0x306, 0, };
-static const char32 __uni_decomp_data_0x1fb9[] = { 0x391, 0x304, 0, };
-static const char32 __uni_decomp_data_0x1fba[] = { 0x391, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1fbb[] = { 0x386, 0, };
-static const char32 __uni_decomp_data_0x1fbc[] = { 0x391, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1fbd[] = { 0x20, 0x313, 0, };
-static const char32 __uni_decomp_data_0x1fbe[] = { 0x3b9, 0, };
-static const char32 __uni_decomp_data_0x1fbf[] = { 0x20, 0x313, 0, };
-static const char32 __uni_decomp_data_0x1fc0[] = { 0x20, 0x342, 0, };
-static const char32 __uni_decomp_data_0x1fc1[] = { 0xa8, 0x342, 0, };
-static const char32 __uni_decomp_data_0x1fc2[] = { 0x1f74, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1fc3[] = { 0x3b7, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1fc4[] = { 0x3ae, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1fc6[] = { 0x3b7, 0x342, 0, };
-static const char32 __uni_decomp_data_0x1fc7[] = { 0x1fc6, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1fc8[] = { 0x395, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1fc9[] = { 0x388, 0, };
-static const char32 __uni_decomp_data_0x1fca[] = { 0x397, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1fcb[] = { 0x389, 0, };
-static const char32 __uni_decomp_data_0x1fcc[] = { 0x397, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1fcd[] = { 0x1fbf, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1fce[] = { 0x1fbf, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1fcf[] = { 0x1fbf, 0x342, 0, };
-static const char32 __uni_decomp_data_0x1fd0[] = { 0x3b9, 0x306, 0, };
-static const char32 __uni_decomp_data_0x1fd1[] = { 0x3b9, 0x304, 0, };
-static const char32 __uni_decomp_data_0x1fd2[] = { 0x3ca, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1fd3[] = { 0x390, 0, };
-static const char32 __uni_decomp_data_0x1fd6[] = { 0x3b9, 0x342, 0, };
-static const char32 __uni_decomp_data_0x1fd7[] = { 0x3ca, 0x342, 0, };
-static const char32 __uni_decomp_data_0x1fd8[] = { 0x399, 0x306, 0, };
-static const char32 __uni_decomp_data_0x1fd9[] = { 0x399, 0x304, 0, };
-static const char32 __uni_decomp_data_0x1fda[] = { 0x399, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1fdb[] = { 0x38a, 0, };
-static const char32 __uni_decomp_data_0x1fdd[] = { 0x1ffe, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1fde[] = { 0x1ffe, 0x301, 0, };
-static const char32 __uni_decomp_data_0x1fdf[] = { 0x1ffe, 0x342, 0, };
-static const char32 __uni_decomp_data_0x1fe0[] = { 0x3c5, 0x306, 0, };
-static const char32 __uni_decomp_data_0x1fe1[] = { 0x3c5, 0x304, 0, };
-static const char32 __uni_decomp_data_0x1fe2[] = { 0x3cb, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1fe3[] = { 0x3b0, 0, };
-static const char32 __uni_decomp_data_0x1fe4[] = { 0x3c1, 0x313, 0, };
-static const char32 __uni_decomp_data_0x1fe5[] = { 0x3c1, 0x314, 0, };
-static const char32 __uni_decomp_data_0x1fe6[] = { 0x3c5, 0x342, 0, };
-static const char32 __uni_decomp_data_0x1fe7[] = { 0x3cb, 0x342, 0, };
-static const char32 __uni_decomp_data_0x1fe8[] = { 0x3a5, 0x306, 0, };
-static const char32 __uni_decomp_data_0x1fe9[] = { 0x3a5, 0x304, 0, };
-static const char32 __uni_decomp_data_0x1fea[] = { 0x3a5, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1feb[] = { 0x38e, 0, };
-static const char32 __uni_decomp_data_0x1fec[] = { 0x3a1, 0x314, 0, };
-static const char32 __uni_decomp_data_0x1fed[] = { 0xa8, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1fee[] = { 0x385, 0, };
-static const char32 __uni_decomp_data_0x1fef[] = { 0x60, 0, };
-static const char32 __uni_decomp_data_0x1ff2[] = { 0x1f7c, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1ff3[] = { 0x3c9, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1ff4[] = { 0x3ce, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1ff6[] = { 0x3c9, 0x342, 0, };
-static const char32 __uni_decomp_data_0x1ff7[] = { 0x1ff6, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1ff8[] = { 0x39f, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1ff9[] = { 0x38c, 0, };
-static const char32 __uni_decomp_data_0x1ffa[] = { 0x3a9, 0x300, 0, };
-static const char32 __uni_decomp_data_0x1ffb[] = { 0x38f, 0, };
-static const char32 __uni_decomp_data_0x1ffc[] = { 0x3a9, 0x345, 0, };
-static const char32 __uni_decomp_data_0x1ffd[] = { 0xb4, 0, };
-static const char32 __uni_decomp_data_0x1ffe[] = { 0x20, 0x314, 0, };
+static const char32 __uni_decomp_data_0x1f80[] = { 2, 0x1f00, 0x345, };
+static const char32 __uni_decomp_data_0x1f81[] = { 2, 0x1f01, 0x345, };
+static const char32 __uni_decomp_data_0x1f82[] = { 2, 0x1f02, 0x345, };
+static const char32 __uni_decomp_data_0x1f83[] = { 2, 0x1f03, 0x345, };
+static const char32 __uni_decomp_data_0x1f84[] = { 2, 0x1f04, 0x345, };
+static const char32 __uni_decomp_data_0x1f85[] = { 2, 0x1f05, 0x345, };
+static const char32 __uni_decomp_data_0x1f86[] = { 2, 0x1f06, 0x345, };
+static const char32 __uni_decomp_data_0x1f87[] = { 2, 0x1f07, 0x345, };
+static const char32 __uni_decomp_data_0x1f88[] = { 2, 0x1f08, 0x345, };
+static const char32 __uni_decomp_data_0x1f89[] = { 2, 0x1f09, 0x345, };
+static const char32 __uni_decomp_data_0x1f8a[] = { 2, 0x1f0a, 0x345, };
+static const char32 __uni_decomp_data_0x1f8b[] = { 2, 0x1f0b, 0x345, };
+static const char32 __uni_decomp_data_0x1f8c[] = { 2, 0x1f0c, 0x345, };
+static const char32 __uni_decomp_data_0x1f8d[] = { 2, 0x1f0d, 0x345, };
+static const char32 __uni_decomp_data_0x1f8e[] = { 2, 0x1f0e, 0x345, };
+static const char32 __uni_decomp_data_0x1f8f[] = { 2, 0x1f0f, 0x345, };
+static const char32 __uni_decomp_data_0x1f90[] = { 2, 0x1f20, 0x345, };
+static const char32 __uni_decomp_data_0x1f91[] = { 2, 0x1f21, 0x345, };
+static const char32 __uni_decomp_data_0x1f92[] = { 2, 0x1f22, 0x345, };
+static const char32 __uni_decomp_data_0x1f93[] = { 2, 0x1f23, 0x345, };
+static const char32 __uni_decomp_data_0x1f94[] = { 2, 0x1f24, 0x345, };
+static const char32 __uni_decomp_data_0x1f95[] = { 2, 0x1f25, 0x345, };
+static const char32 __uni_decomp_data_0x1f96[] = { 2, 0x1f26, 0x345, };
+static const char32 __uni_decomp_data_0x1f97[] = { 2, 0x1f27, 0x345, };
+static const char32 __uni_decomp_data_0x1f98[] = { 2, 0x1f28, 0x345, };
+static const char32 __uni_decomp_data_0x1f99[] = { 2, 0x1f29, 0x345, };
+static const char32 __uni_decomp_data_0x1f9a[] = { 2, 0x1f2a, 0x345, };
+static const char32 __uni_decomp_data_0x1f9b[] = { 2, 0x1f2b, 0x345, };
+static const char32 __uni_decomp_data_0x1f9c[] = { 2, 0x1f2c, 0x345, };
+static const char32 __uni_decomp_data_0x1f9d[] = { 2, 0x1f2d, 0x345, };
+static const char32 __uni_decomp_data_0x1f9e[] = { 2, 0x1f2e, 0x345, };
+static const char32 __uni_decomp_data_0x1f9f[] = { 2, 0x1f2f, 0x345, };
+static const char32 __uni_decomp_data_0x1fa0[] = { 2, 0x1f60, 0x345, };
+static const char32 __uni_decomp_data_0x1fa1[] = { 2, 0x1f61, 0x345, };
+static const char32 __uni_decomp_data_0x1fa2[] = { 2, 0x1f62, 0x345, };
+static const char32 __uni_decomp_data_0x1fa3[] = { 2, 0x1f63, 0x345, };
+static const char32 __uni_decomp_data_0x1fa4[] = { 2, 0x1f64, 0x345, };
+static const char32 __uni_decomp_data_0x1fa5[] = { 2, 0x1f65, 0x345, };
+static const char32 __uni_decomp_data_0x1fa6[] = { 2, 0x1f66, 0x345, };
+static const char32 __uni_decomp_data_0x1fa7[] = { 2, 0x1f67, 0x345, };
+static const char32 __uni_decomp_data_0x1fa8[] = { 2, 0x1f68, 0x345, };
+static const char32 __uni_decomp_data_0x1fa9[] = { 2, 0x1f69, 0x345, };
+static const char32 __uni_decomp_data_0x1faa[] = { 2, 0x1f6a, 0x345, };
+static const char32 __uni_decomp_data_0x1fab[] = { 2, 0x1f6b, 0x345, };
+static const char32 __uni_decomp_data_0x1fac[] = { 2, 0x1f6c, 0x345, };
+static const char32 __uni_decomp_data_0x1fad[] = { 2, 0x1f6d, 0x345, };
+static const char32 __uni_decomp_data_0x1fae[] = { 2, 0x1f6e, 0x345, };
+static const char32 __uni_decomp_data_0x1faf[] = { 2, 0x1f6f, 0x345, };
+static const char32 __uni_decomp_data_0x1fb0[] = { 2, 0x3b1, 0x306, };
+static const char32 __uni_decomp_data_0x1fb1[] = { 2, 0x3b1, 0x304, };
+static const char32 __uni_decomp_data_0x1fb2[] = { 2, 0x1f70, 0x345, };
+static const char32 __uni_decomp_data_0x1fb3[] = { 2, 0x3b1, 0x345, };
+static const char32 __uni_decomp_data_0x1fb4[] = { 2, 0x3ac, 0x345, };
+static const char32 __uni_decomp_data_0x1fb6[] = { 2, 0x3b1, 0x342, };
+static const char32 __uni_decomp_data_0x1fb7[] = { 2, 0x1fb6, 0x345, };
+static const char32 __uni_decomp_data_0x1fb8[] = { 2, 0x391, 0x306, };
+static const char32 __uni_decomp_data_0x1fb9[] = { 2, 0x391, 0x304, };
+static const char32 __uni_decomp_data_0x1fba[] = { 2, 0x391, 0x300, };
+static const char32 __uni_decomp_data_0x1fbb[] = { 1, 0x386, };
+static const char32 __uni_decomp_data_0x1fbc[] = { 2, 0x391, 0x345, };
+static const char32 __uni_decomp_data_0x1fbd[] = { 2, 0x20, 0x313, };
+static const char32 __uni_decomp_data_0x1fbe[] = { 1, 0x3b9, };
+static const char32 __uni_decomp_data_0x1fbf[] = { 2, 0x20, 0x313, };
+static const char32 __uni_decomp_data_0x1fc0[] = { 2, 0x20, 0x342, };
+static const char32 __uni_decomp_data_0x1fc1[] = { 2, 0xa8, 0x342, };
+static const char32 __uni_decomp_data_0x1fc2[] = { 2, 0x1f74, 0x345, };
+static const char32 __uni_decomp_data_0x1fc3[] = { 2, 0x3b7, 0x345, };
+static const char32 __uni_decomp_data_0x1fc4[] = { 2, 0x3ae, 0x345, };
+static const char32 __uni_decomp_data_0x1fc6[] = { 2, 0x3b7, 0x342, };
+static const char32 __uni_decomp_data_0x1fc7[] = { 2, 0x1fc6, 0x345, };
+static const char32 __uni_decomp_data_0x1fc8[] = { 2, 0x395, 0x300, };
+static const char32 __uni_decomp_data_0x1fc9[] = { 1, 0x388, };
+static const char32 __uni_decomp_data_0x1fca[] = { 2, 0x397, 0x300, };
+static const char32 __uni_decomp_data_0x1fcb[] = { 1, 0x389, };
+static const char32 __uni_decomp_data_0x1fcc[] = { 2, 0x397, 0x345, };
+static const char32 __uni_decomp_data_0x1fcd[] = { 2, 0x1fbf, 0x300, };
+static const char32 __uni_decomp_data_0x1fce[] = { 2, 0x1fbf, 0x301, };
+static const char32 __uni_decomp_data_0x1fcf[] = { 2, 0x1fbf, 0x342, };
+static const char32 __uni_decomp_data_0x1fd0[] = { 2, 0x3b9, 0x306, };
+static const char32 __uni_decomp_data_0x1fd1[] = { 2, 0x3b9, 0x304, };
+static const char32 __uni_decomp_data_0x1fd2[] = { 2, 0x3ca, 0x300, };
+static const char32 __uni_decomp_data_0x1fd3[] = { 1, 0x390, };
+static const char32 __uni_decomp_data_0x1fd6[] = { 2, 0x3b9, 0x342, };
+static const char32 __uni_decomp_data_0x1fd7[] = { 2, 0x3ca, 0x342, };
+static const char32 __uni_decomp_data_0x1fd8[] = { 2, 0x399, 0x306, };
+static const char32 __uni_decomp_data_0x1fd9[] = { 2, 0x399, 0x304, };
+static const char32 __uni_decomp_data_0x1fda[] = { 2, 0x399, 0x300, };
+static const char32 __uni_decomp_data_0x1fdb[] = { 1, 0x38a, };
+static const char32 __uni_decomp_data_0x1fdd[] = { 2, 0x1ffe, 0x300, };
+static const char32 __uni_decomp_data_0x1fde[] = { 2, 0x1ffe, 0x301, };
+static const char32 __uni_decomp_data_0x1fdf[] = { 2, 0x1ffe, 0x342, };
+static const char32 __uni_decomp_data_0x1fe0[] = { 2, 0x3c5, 0x306, };
+static const char32 __uni_decomp_data_0x1fe1[] = { 2, 0x3c5, 0x304, };
+static const char32 __uni_decomp_data_0x1fe2[] = { 2, 0x3cb, 0x300, };
+static const char32 __uni_decomp_data_0x1fe3[] = { 1, 0x3b0, };
+static const char32 __uni_decomp_data_0x1fe4[] = { 2, 0x3c1, 0x313, };
+static const char32 __uni_decomp_data_0x1fe5[] = { 2, 0x3c1, 0x314, };
+static const char32 __uni_decomp_data_0x1fe6[] = { 2, 0x3c5, 0x342, };
+static const char32 __uni_decomp_data_0x1fe7[] = { 2, 0x3cb, 0x342, };
+static const char32 __uni_decomp_data_0x1fe8[] = { 2, 0x3a5, 0x306, };
+static const char32 __uni_decomp_data_0x1fe9[] = { 2, 0x3a5, 0x304, };
+static const char32 __uni_decomp_data_0x1fea[] = { 2, 0x3a5, 0x300, };
+static const char32 __uni_decomp_data_0x1feb[] = { 1, 0x38e, };
+static const char32 __uni_decomp_data_0x1fec[] = { 2, 0x3a1, 0x314, };
+static const char32 __uni_decomp_data_0x1fed[] = { 2, 0xa8, 0x300, };
+static const char32 __uni_decomp_data_0x1fee[] = { 1, 0x385, };
+static const char32 __uni_decomp_data_0x1fef[] = { 1, 0x60, };
+static const char32 __uni_decomp_data_0x1ff2[] = { 2, 0x1f7c, 0x345, };
+static const char32 __uni_decomp_data_0x1ff3[] = { 2, 0x3c9, 0x345, };
+static const char32 __uni_decomp_data_0x1ff4[] = { 2, 0x3ce, 0x345, };
+static const char32 __uni_decomp_data_0x1ff6[] = { 2, 0x3c9, 0x342, };
+static const char32 __uni_decomp_data_0x1ff7[] = { 2, 0x1ff6, 0x345, };
+static const char32 __uni_decomp_data_0x1ff8[] = { 2, 0x39f, 0x300, };
+static const char32 __uni_decomp_data_0x1ff9[] = { 1, 0x38c, };
+static const char32 __uni_decomp_data_0x1ffa[] = { 2, 0x3a9, 0x300, };
+static const char32 __uni_decomp_data_0x1ffb[] = { 1, 0x38f, };
+static const char32 __uni_decomp_data_0x1ffc[] = { 2, 0x3a9, 0x345, };
+static const char32 __uni_decomp_data_0x1ffd[] = { 1, 0xb4, };
+static const char32 __uni_decomp_data_0x1ffe[] = { 2, 0x20, 0x314, };
 
 
 
@@ -22358,48 +22358,48 @@
 };
 
 
-static const char32 __uni_decomp_data_0x2000[] = { 0x2002, 0, };
-static const char32 __uni_decomp_data_0x2001[] = { 0x2003, 0, };
-static const char32 __uni_decomp_data_0x2002[] = { 0x20, 0, };
-static const char32 __uni_decomp_data_0x2003[] = { 0x20, 0, };
-static const char32 __uni_decomp_data_0x2004[] = { 0x20, 0, };
-static const char32 __uni_decomp_data_0x2005[] = { 0x20, 0, };
-static const char32 __uni_decomp_data_0x2006[] = { 0x20, 0, };
-static const char32 __uni_decomp_data_0x2007[] = { 0x20, 0, };
-static const char32 __uni_decomp_data_0x2008[] = { 0x20, 0, };
-static const char32 __uni_decomp_data_0x2009[] = { 0x20, 0, };
-static const char32 __uni_decomp_data_0x200a[] = { 0x20, 0, };
-static const char32 __uni_decomp_data_0x2011[] = { 0x2010, 0, };
-static const char32 __uni_decomp_data_0x2017[] = { 0x20, 0x333, 0, };
-static const char32 __uni_decomp_data_0x2024[] = { 0x2e, 0, };
-static const char32 __uni_decomp_data_0x2025[] = { 0x2e, 0x2e, 0, };
-static const char32 __uni_decomp_data_0x2026[] = { 0x2e, 0x2e, 0x2e, 0, };
-static const char32 __uni_decomp_data_0x202f[] = { 0x20, 0, };
-static const char32 __uni_decomp_data_0x2033[] = { 0x2032, 0x2032, 0, };
-static const char32 __uni_decomp_data_0x2034[] = { 0x2032, 0x2032, 0x2032, 0, };
-static const char32 __uni_decomp_data_0x2036[] = { 0x2035, 0x2035, 0, };
-static const char32 __uni_decomp_data_0x2037[] = { 0x2035, 0x2035, 0x2035, 0, };
-static const char32 __uni_decomp_data_0x203c[] = { 0x21, 0x21, 0, };
-static const char32 __uni_decomp_data_0x203e[] = { 0x20, 0x305, 0, };
-static const char32 __uni_decomp_data_0x2047[] = { 0x3f, 0x3f, 0, };
-static const char32 __uni_decomp_data_0x2048[] = { 0x3f, 0x21, 0, };
-static const char32 __uni_decomp_data_0x2049[] = { 0x21, 0x3f, 0, };
-static const char32 __uni_decomp_data_0x2057[] = { 0x2032, 0x2032, 0x2032, 0x2032, 0, };
-static const char32 __uni_decomp_data_0x205f[] = { 0x20, 0, };
-static const char32 __uni_decomp_data_0x2070[] = { 0x30, 0, };
-static const char32 __uni_decomp_data_0x2071[] = { 0x69, 0, };
-static const char32 __uni_decomp_data_0x2074[] = { 0x34, 0, };
-static const char32 __uni_decomp_data_0x2075[] = { 0x35, 0, };
-static const char32 __uni_decomp_data_0x2076[] = { 0x36, 0, };
-static const char32 __uni_decomp_data_0x2077[] = { 0x37, 0, };
-static const char32 __uni_decomp_data_0x2078[] = { 0x38, 0, };
-static const char32 __uni_decomp_data_0x2079[] = { 0x39, 0, };
-static const char32 __uni_decomp_data_0x207a[] = { 0x2b, 0, };
-static const char32 __uni_decomp_data_0x207b[] = { 0x2212, 0, };
-static const char32 __uni_decomp_data_0x207c[] = { 0x3d, 0, };
-static const char32 __uni_decomp_data_0x207d[] = { 0x28, 0, };
-static const char32 __uni_decomp_data_0x207e[] = { 0x29, 0, };
-static const char32 __uni_decomp_data_0x207f[] = { 0x6e, 0, };
+static const char32 __uni_decomp_data_0x2000[] = { 1, 0x2002, };
+static const char32 __uni_decomp_data_0x2001[] = { 1, 0x2003, };
+static const char32 __uni_decomp_data_0x2002[] = { 1, 0x20, };
+static const char32 __uni_decomp_data_0x2003[] = { 1, 0x20, };
+static const char32 __uni_decomp_data_0x2004[] = { 1, 0x20, };
+static const char32 __uni_decomp_data_0x2005[] = { 1, 0x20, };
+static const char32 __uni_decomp_data_0x2006[] = { 1, 0x20, };
+static const char32 __uni_decomp_data_0x2007[] = { 1, 0x20, };
+static const char32 __uni_decomp_data_0x2008[] = { 1, 0x20, };
+static const char32 __uni_decomp_data_0x2009[] = { 1, 0x20, };
+static const char32 __uni_decomp_data_0x200a[] = { 1, 0x20, };
+static const char32 __uni_decomp_data_0x2011[] = { 1, 0x2010, };
+static const char32 __uni_decomp_data_0x2017[] = { 2, 0x20, 0x333, };
+static const char32 __uni_decomp_data_0x2024[] = { 1, 0x2e, };
+static const char32 __uni_decomp_data_0x2025[] = { 2, 0x2e, 0x2e, };
+static const char32 __uni_decomp_data_0x2026[] = { 3, 0x2e, 0x2e, 0x2e, };
+static const char32 __uni_decomp_data_0x202f[] = { 1, 0x20, };
+static const char32 __uni_decomp_data_0x2033[] = { 2, 0x2032, 0x2032, };
+static const char32 __uni_decomp_data_0x2034[] = { 3, 0x2032, 0x2032, 0x2032, };
+static const char32 __uni_decomp_data_0x2036[] = { 2, 0x2035, 0x2035, };
+static const char32 __uni_decomp_data_0x2037[] = { 3, 0x2035, 0x2035, 0x2035, };
+static const char32 __uni_decomp_data_0x203c[] = { 2, 0x21, 0x21, };
+static const char32 __uni_decomp_data_0x203e[] = { 2, 0x20, 0x305, };
+static const char32 __uni_decomp_data_0x2047[] = { 2, 0x3f, 0x3f, };
+static const char32 __uni_decomp_data_0x2048[] = { 2, 0x3f, 0x21, };
+static const char32 __uni_decomp_data_0x2049[] = { 2, 0x21, 0x3f, };
+static const char32 __uni_decomp_data_0x2057[] = { 4, 0x2032, 0x2032, 0x2032, 0x2032, };
+static const char32 __uni_decomp_data_0x205f[] = { 1, 0x20, };
+static const char32 __uni_decomp_data_0x2070[] = { 1, 0x30, };
+static const char32 __uni_decomp_data_0x2071[] = { 1, 0x69, };
+static const char32 __uni_decomp_data_0x2074[] = { 1, 0x34, };
+static const char32 __uni_decomp_data_0x2075[] = { 1, 0x35, };
+static const char32 __uni_decomp_data_0x2076[] = { 1, 0x36, };
+static const char32 __uni_decomp_data_0x2077[] = { 1, 0x37, };
+static const char32 __uni_decomp_data_0x2078[] = { 1, 0x38, };
+static const char32 __uni_decomp_data_0x2079[] = { 1, 0x39, };
+static const char32 __uni_decomp_data_0x207a[] = { 1, 0x2b, };
+static const char32 __uni_decomp_data_0x207b[] = { 1, 0x2212, };
+static const char32 __uni_decomp_data_0x207c[] = { 1, 0x3d, };
+static const char32 __uni_decomp_data_0x207d[] = { 1, 0x28, };
+static const char32 __uni_decomp_data_0x207e[] = { 1, 0x29, };
+static const char32 __uni_decomp_data_0x207f[] = { 1, 0x6e, };
 
 
 
@@ -24073,27 +24073,27 @@
 };
 
 
-static const char32 __uni_decomp_data_0x2080[] = { 0x30, 0, };
-static const char32 __uni_decomp_data_0x2081[] = { 0x31, 0, };
-static const char32 __uni_decomp_data_0x2082[] = { 0x32, 0, };
-static const char32 __uni_decomp_data_0x2083[] = { 0x33, 0, };
-static const char32 __uni_decomp_data_0x2084[] = { 0x34, 0, };
-static const char32 __uni_decomp_data_0x2085[] = { 0x35, 0, };
-static const char32 __uni_decomp_data_0x2086[] = { 0x36, 0, };
-static const char32 __uni_decomp_data_0x2087[] = { 0x37, 0, };
-static const char32 __uni_decomp_data_0x2088[] = { 0x38, 0, };
-static const char32 __uni_decomp_data_0x2089[] = { 0x39, 0, };
-static const char32 __uni_decomp_data_0x208a[] = { 0x2b, 0, };
-static const char32 __uni_decomp_data_0x208b[] = { 0x2212, 0, };
-static const char32 __uni_decomp_data_0x208c[] = { 0x3d, 0, };
-static const char32 __uni_decomp_data_0x208d[] = { 0x28, 0, };
-static const char32 __uni_decomp_data_0x208e[] = { 0x29, 0, };
-static const char32 __uni_decomp_data_0x2090[] = { 0x61, 0, };
-static const char32 __uni_decomp_data_0x2091[] = { 0x65, 0, };
-static const char32 __uni_decomp_data_0x2092[] = { 0x6f, 0, };
-static const char32 __uni_decomp_data_0x2093[] = { 0x78, 0, };
-static const char32 __uni_decomp_data_0x2094[] = { 0x259, 0, };
-static const char32 __uni_decomp_data_0x20a8[] = { 0x52, 0x73, 0, };
+static const char32 __uni_decomp_data_0x2080[] = { 1, 0x30, };
+static const char32 __uni_decomp_data_0x2081[] = { 1, 0x31, };
+static const char32 __uni_decomp_data_0x2082[] = { 1, 0x32, };
+static const char32 __uni_decomp_data_0x2083[] = { 1, 0x33, };
+static const char32 __uni_decomp_data_0x2084[] = { 1, 0x34, };
+static const char32 __uni_decomp_data_0x2085[] = { 1, 0x35, };
+static const char32 __uni_decomp_data_0x2086[] = { 1, 0x36, };
+static const char32 __uni_decomp_data_0x2087[] = { 1, 0x37, };
+static const char32 __uni_decomp_data_0x2088[] = { 1, 0x38, };
+static const char32 __uni_decomp_data_0x2089[] = { 1, 0x39, };
+static const char32 __uni_decomp_data_0x208a[] = { 1, 0x2b, };
+static const char32 __uni_decomp_data_0x208b[] = { 1, 0x2212, };
+static const char32 __uni_decomp_data_0x208c[] = { 1, 0x3d, };
+static const char32 __uni_decomp_data_0x208d[] = { 1, 0x28, };
+static const char32 __uni_decomp_data_0x208e[] = { 1, 0x29, };
+static const char32 __uni_decomp_data_0x2090[] = { 1, 0x61, };
+static const char32 __uni_decomp_data_0x2091[] = { 1, 0x65, };
+static const char32 __uni_decomp_data_0x2092[] = { 1, 0x6f, };
+static const char32 __uni_decomp_data_0x2093[] = { 1, 0x78, };
+static const char32 __uni_decomp_data_0x2094[] = { 1, 0x259, };
+static const char32 __uni_decomp_data_0x20a8[] = { 2, 0x52, 0x73, };
 
 
 
@@ -25767,107 +25767,107 @@
 };
 
 
-static const char32 __uni_decomp_data_0x2100[] = { 0x61, 0x2f, 0x63, 0, };
-static const char32 __uni_decomp_data_0x2101[] = { 0x61, 0x2f, 0x73, 0, };
-static const char32 __uni_decomp_data_0x2102[] = { 0x43, 0, };
-static const char32 __uni_decomp_data_0x2103[] = { 0xb0, 0x43, 0, };
-static const char32 __uni_decomp_data_0x2105[] = { 0x63, 0x2f, 0x6f, 0, };
-static const char32 __uni_decomp_data_0x2106[] = { 0x63, 0x2f, 0x75, 0, };
-static const char32 __uni_decomp_data_0x2107[] = { 0x190, 0, };
-static const char32 __uni_decomp_data_0x2109[] = { 0xb0, 0x46, 0, };
-static const char32 __uni_decomp_data_0x210a[] = { 0x67, 0, };
-static const char32 __uni_decomp_data_0x210b[] = { 0x48, 0, };
-static const char32 __uni_decomp_data_0x210c[] = { 0x48, 0, };
-static const char32 __uni_decomp_data_0x210d[] = { 0x48, 0, };
-static const char32 __uni_decomp_data_0x210e[] = { 0x68, 0, };
-static const char32 __uni_decomp_data_0x210f[] = { 0x127, 0, };
-static const char32 __uni_decomp_data_0x2110[] = { 0x49, 0, };
-static const char32 __uni_decomp_data_0x2111[] = { 0x49, 0, };
-static const char32 __uni_decomp_data_0x2112[] = { 0x4c, 0, };
-static const char32 __uni_decomp_data_0x2113[] = { 0x6c, 0, };
-static const char32 __uni_decomp_data_0x2115[] = { 0x4e, 0, };
-static const char32 __uni_decomp_data_0x2116[] = { 0x4e, 0x6f, 0, };
-static const char32 __uni_decomp_data_0x2119[] = { 0x50, 0, };
-static const char32 __uni_decomp_data_0x211a[] = { 0x51, 0, };
-static const char32 __uni_decomp_data_0x211b[] = { 0x52, 0, };
-static const char32 __uni_decomp_data_0x211c[] = { 0x52, 0, };
-static const char32 __uni_decomp_data_0x211d[] = { 0x52, 0, };
-static const char32 __uni_decomp_data_0x2120[] = { 0x53, 0x4d, 0, };
-static const char32 __uni_decomp_data_0x2121[] = { 0x54, 0x45, 0x4c, 0, };
-static const char32 __uni_decomp_data_0x2122[] = { 0x54, 0x4d, 0, };
-static const char32 __uni_decomp_data_0x2124[] = { 0x5a, 0, };
-static const char32 __uni_decomp_data_0x2126[] = { 0x3a9, 0, };
-static const char32 __uni_decomp_data_0x2128[] = { 0x5a, 0, };
-static const char32 __uni_decomp_data_0x212a[] = { 0x4b, 0, };
-static const char32 __uni_decomp_data_0x212b[] = { 0xc5, 0, };
-static const char32 __uni_decomp_data_0x212c[] = { 0x42, 0, };
-static const char32 __uni_decomp_data_0x212d[] = { 0x43, 0, };
-static const char32 __uni_decomp_data_0x212f[] = { 0x65, 0, };
-static const char32 __uni_decomp_data_0x2130[] = { 0x45, 0, };
-static const char32 __uni_decomp_data_0x2131[] = { 0x46, 0, };
-static const char32 __uni_decomp_data_0x2133[] = { 0x4d, 0, };
-static const char32 __uni_decomp_data_0x2134[] = { 0x6f, 0, };
-static const char32 __uni_decomp_data_0x2135[] = { 0x5d0, 0, };
-static const char32 __uni_decomp_data_0x2136[] = { 0x5d1, 0, };
-static const char32 __uni_decomp_data_0x2137[] = { 0x5d2, 0, };
-static const char32 __uni_decomp_data_0x2138[] = { 0x5d3, 0, };
-static const char32 __uni_decomp_data_0x2139[] = { 0x69, 0, };
-static const char32 __uni_decomp_data_0x213b[] = { 0x46, 0x41, 0x58, 0, };
-static const char32 __uni_decomp_data_0x213c[] = { 0x3c0, 0, };
-static const char32 __uni_decomp_data_0x213d[] = { 0x3b3, 0, };
-static const char32 __uni_decomp_data_0x213e[] = { 0x393, 0, };
-static const char32 __uni_decomp_data_0x213f[] = { 0x3a0, 0, };
-static const char32 __uni_decomp_data_0x2140[] = { 0x2211, 0, };
-static const char32 __uni_decomp_data_0x2145[] = { 0x44, 0, };
-static const char32 __uni_decomp_data_0x2146[] = { 0x64, 0, };
-static const char32 __uni_decomp_data_0x2147[] = { 0x65, 0, };
-static const char32 __uni_decomp_data_0x2148[] = { 0x69, 0, };
-static const char32 __uni_decomp_data_0x2149[] = { 0x6a, 0, };
-static const char32 __uni_decomp_data_0x2153[] = { 0x31, 0x2044, 0x33, 0, };
-static const char32 __uni_decomp_data_0x2154[] = { 0x32, 0x2044, 0x33, 0, };
-static const char32 __uni_decomp_data_0x2155[] = { 0x31, 0x2044, 0x35, 0, };
-static const char32 __uni_decomp_data_0x2156[] = { 0x32, 0x2044, 0x35, 0, };
-static const char32 __uni_decomp_data_0x2157[] = { 0x33, 0x2044, 0x35, 0, };
-static const char32 __uni_decomp_data_0x2158[] = { 0x34, 0x2044, 0x35, 0, };
-static const char32 __uni_decomp_data_0x2159[] = { 0x31, 0x2044, 0x36, 0, };
-static const char32 __uni_decomp_data_0x215a[] = { 0x35, 0x2044, 0x36, 0, };
-static const char32 __uni_decomp_data_0x215b[] = { 0x31, 0x2044, 0x38, 0, };
-static const char32 __uni_decomp_data_0x215c[] = { 0x33, 0x2044, 0x38, 0, };
-static const char32 __uni_decomp_data_0x215d[] = { 0x35, 0x2044, 0x38, 0, };
-static const char32 __uni_decomp_data_0x215e[] = { 0x37, 0x2044, 0x38, 0, };
-static const char32 __uni_decomp_data_0x215f[] = { 0x31, 0x2044, 0, };
-static const char32 __uni_decomp_data_0x2160[] = { 0x49, 0, };
-static const char32 __uni_decomp_data_0x2161[] = { 0x49, 0x49, 0, };
-static const char32 __uni_decomp_data_0x2162[] = { 0x49, 0x49, 0x49, 0, };
-static const char32 __uni_decomp_data_0x2163[] = { 0x49, 0x56, 0, };
-static const char32 __uni_decomp_data_0x2164[] = { 0x56, 0, };
-static const char32 __uni_decomp_data_0x2165[] = { 0x56, 0x49, 0, };
-static const char32 __uni_decomp_data_0x2166[] = { 0x56, 0x49, 0x49, 0, };
-static const char32 __uni_decomp_data_0x2167[] = { 0x56, 0x49, 0x49, 0x49, 0, };
-static const char32 __uni_decomp_data_0x2168[] = { 0x49, 0x58, 0, };
-static const char32 __uni_decomp_data_0x2169[] = { 0x58, 0, };
-static const char32 __uni_decomp_data_0x216a[] = { 0x58, 0x49, 0, };
-static const char32 __uni_decomp_data_0x216b[] = { 0x58, 0x49, 0x49, 0, };
-static const char32 __uni_decomp_data_0x216c[] = { 0x4c, 0, };
-static const char32 __uni_decomp_data_0x216d[] = { 0x43, 0, };
-static const char32 __uni_decomp_data_0x216e[] = { 0x44, 0, };
-static const char32 __uni_decomp_data_0x216f[] = { 0x4d, 0, };
-static const char32 __uni_decomp_data_0x2170[] = { 0x69, 0, };
-static const char32 __uni_decomp_data_0x2171[] = { 0x69, 0x69, 0, };
-static const char32 __uni_decomp_data_0x2172[] = { 0x69, 0x69, 0x69, 0, };
-static const char32 __uni_decomp_data_0x2173[] = { 0x69, 0x76, 0, };
-static const char32 __uni_decomp_data_0x2174[] = { 0x76, 0, };
-static const char32 __uni_decomp_data_0x2175[] = { 0x76, 0x69, 0, };
-static const char32 __uni_decomp_data_0x2176[] = { 0x76, 0x69, 0x69, 0, };
-static const char32 __uni_decomp_data_0x2177[] = { 0x76, 0x69, 0x69, 0x69, 0, };
-static const char32 __uni_decomp_data_0x2178[] = { 0x69, 0x78, 0, };
-static const char32 __uni_decomp_data_0x2179[] = { 0x78, 0, };
-static const char32 __uni_decomp_data_0x217a[] = { 0x78, 0x69, 0, };
-static const char32 __uni_decomp_data_0x217b[] = { 0x78, 0x69, 0x69, 0, };
-static const char32 __uni_decomp_data_0x217c[] = { 0x6c, 0, };
-static const char32 __uni_decomp_data_0x217d[] = { 0x63, 0, };
-static const char32 __uni_decomp_data_0x217e[] = { 0x64, 0, };
-static const char32 __uni_decomp_data_0x217f[] = { 0x6d, 0, };
+static const char32 __uni_decomp_data_0x2100[] = { 3, 0x61, 0x2f, 0x63, };
+static const char32 __uni_decomp_data_0x2101[] = { 3, 0x61, 0x2f, 0x73, };
+static const char32 __uni_decomp_data_0x2102[] = { 1, 0x43, };
+static const char32 __uni_decomp_data_0x2103[] = { 2, 0xb0, 0x43, };
+static const char32 __uni_decomp_data_0x2105[] = { 3, 0x63, 0x2f, 0x6f, };
+static const char32 __uni_decomp_data_0x2106[] = { 3, 0x63, 0x2f, 0x75, };
+static const char32 __uni_decomp_data_0x2107[] = { 1, 0x190, };
+static const char32 __uni_decomp_data_0x2109[] = { 2, 0xb0, 0x46, };
+static const char32 __uni_decomp_data_0x210a[] = { 1, 0x67, };
+static const char32 __uni_decomp_data_0x210b[] = { 1, 0x48, };
+static const char32 __uni_decomp_data_0x210c[] = { 1, 0x48, };
+static const char32 __uni_decomp_data_0x210d[] = { 1, 0x48, };
+static const char32 __uni_decomp_data_0x210e[] = { 1, 0x68, };
+static const char32 __uni_decomp_data_0x210f[] = { 1, 0x127, };
+static const char32 __uni_decomp_data_0x2110[] = { 1, 0x49, };
+static const char32 __uni_decomp_data_0x2111[] = { 1, 0x49, };
+static const char32 __uni_decomp_data_0x2112[] = { 1, 0x4c, };
+static const char32 __uni_decomp_data_0x2113[] = { 1, 0x6c, };
+static const char32 __uni_decomp_data_0x2115[] = { 1, 0x4e, };
+static const char32 __uni_decomp_data_0x2116[] = { 2, 0x4e, 0x6f, };
+static const char32 __uni_decomp_data_0x2119[] = { 1, 0x50, };
+static const char32 __uni_decomp_data_0x211a[] = { 1, 0x51, };
+static const char32 __uni_decomp_data_0x211b[] = { 1, 0x52, };
+static const char32 __uni_decomp_data_0x211c[] = { 1, 0x52, };
+static const char32 __uni_decomp_data_0x211d[] = { 1, 0x52, };
+static const char32 __uni_decomp_data_0x2120[] = { 2, 0x53, 0x4d, };
+static const char32 __uni_decomp_data_0x2121[] = { 3, 0x54, 0x45, 0x4c, };
+static const char32 __uni_decomp_data_0x2122[] = { 2, 0x54, 0x4d, };
+static const char32 __uni_decomp_data_0x2124[] = { 1, 0x5a, };
+static const char32 __uni_decomp_data_0x2126[] = { 1, 0x3a9, };
+static const char32 __uni_decomp_data_0x2128[] = { 1, 0x5a, };
+static const char32 __uni_decomp_data_0x212a[] = { 1, 0x4b, };
+static const char32 __uni_decomp_data_0x212b[] = { 1, 0xc5, };
+static const char32 __uni_decomp_data_0x212c[] = { 1, 0x42, };
+static const char32 __uni_decomp_data_0x212d[] = { 1, 0x43, };
+static const char32 __uni_decomp_data_0x212f[] = { 1, 0x65, };
+static const char32 __uni_decomp_data_0x2130[] = { 1, 0x45, };
+static const char32 __uni_decomp_data_0x2131[] = { 1, 0x46, };
+static const char32 __uni_decomp_data_0x2133[] = { 1, 0x4d, };
+static const char32 __uni_decomp_data_0x2134[] = { 1, 0x6f, };
+static const char32 __uni_decomp_data_0x2135[] = { 1, 0x5d0, };
+static const char32 __uni_decomp_data_0x2136[] = { 1, 0x5d1, };
+static const char32 __uni_decomp_data_0x2137[] = { 1, 0x5d2, };
+static const char32 __uni_decomp_data_0x2138[] = { 1, 0x5d3, };
+static const char32 __uni_decomp_data_0x2139[] = { 1, 0x69, };
+static const char32 __uni_decomp_data_0x213b[] = { 3, 0x46, 0x41, 0x58, };
+static const char32 __uni_decomp_data_0x213c[] = { 1, 0x3c0, };
+static const char32 __uni_decomp_data_0x213d[] = { 1, 0x3b3, };
+static const char32 __uni_decomp_data_0x213e[] = { 1, 0x393, };
+static const char32 __uni_decomp_data_0x213f[] = { 1, 0x3a0, };
+static const char32 __uni_decomp_data_0x2140[] = { 1, 0x2211, };
+static const char32 __uni_decomp_data_0x2145[] = { 1, 0x44, };
+static const char32 __uni_decomp_data_0x2146[] = { 1, 0x64, };
+static const char32 __uni_decomp_data_0x2147[] = { 1, 0x65, };
+static const char32 __uni_decomp_data_0x2148[] = { 1, 0x69, };
+static const char32 __uni_decomp_data_0x2149[] = { 1, 0x6a, };
+static const char32 __uni_decomp_data_0x2153[] = { 3, 0x31, 0x2044, 0x33, };
+static const char32 __uni_decomp_data_0x2154[] = { 3, 0x32, 0x2044, 0x33, };
+static const char32 __uni_decomp_data_0x2155[] = { 3, 0x31, 0x2044, 0x35, };
+static const char32 __uni_decomp_data_0x2156[] = { 3, 0x32, 0x2044, 0x35, };
+static const char32 __uni_decomp_data_0x2157[] = { 3, 0x33, 0x2044, 0x35, };
+static const char32 __uni_decomp_data_0x2158[] = { 3, 0x34, 0x2044, 0x35, };
+static const char32 __uni_decomp_data_0x2159[] = { 3, 0x31, 0x2044, 0x36, };
+static const char32 __uni_decomp_data_0x215a[] = { 3, 0x35, 0x2044, 0x36, };
+static const char32 __uni_decomp_data_0x215b[] = { 3, 0x31, 0x2044, 0x38, };
+static const char32 __uni_decomp_data_0x215c[] = { 3, 0x33, 0x2044, 0x38, };
+static const char32 __uni_decomp_data_0x215d[] = { 3, 0x35, 0x2044, 0x38, };
+static const char32 __uni_decomp_data_0x215e[] = { 3, 0x37, 0x2044, 0x38, };
+static const char32 __uni_decomp_data_0x215f[] = { 2, 0x31, 0x2044, };
+static const char32 __uni_decomp_data_0x2160[] = { 1, 0x49, };
+static const char32 __uni_decomp_data_0x2161[] = { 2, 0x49, 0x49, };
+static const char32 __uni_decomp_data_0x2162[] = { 3, 0x49, 0x49, 0x49, };
+static const char32 __uni_decomp_data_0x2163[] = { 2, 0x49, 0x56, };
+static const char32 __uni_decomp_data_0x2164[] = { 1, 0x56, };
+static const char32 __uni_decomp_data_0x2165[] = { 2, 0x56, 0x49, };
+static const char32 __uni_decomp_data_0x2166[] = { 3, 0x56, 0x49, 0x49, };
+static const char32 __uni_decomp_data_0x2167[] = { 4, 0x56, 0x49, 0x49, 0x49, };
+static const char32 __uni_decomp_data_0x2168[] = { 2, 0x49, 0x58, };
+static const char32 __uni_decomp_data_0x2169[] = { 1, 0x58, };
+static const char32 __uni_decomp_data_0x216a[] = { 2, 0x58, 0x49, };
+static const char32 __uni_decomp_data_0x216b[] = { 3, 0x58, 0x49, 0x49, };
+static const char32 __uni_decomp_data_0x216c[] = { 1, 0x4c, };
+static const char32 __uni_decomp_data_0x216d[] = { 1, 0x43, };
+static const char32 __uni_decomp_data_0x216e[] = { 1, 0x44, };
+static const char32 __uni_decomp_data_0x216f[] = { 1, 0x4d, };
+static const char32 __uni_decomp_data_0x2170[] = { 1, 0x69, };
+static const char32 __uni_decomp_data_0x2171[] = { 2, 0x69, 0x69, };
+static const char32 __uni_decomp_data_0x2172[] = { 3, 0x69, 0x69, 0x69, };
+static const char32 __uni_decomp_data_0x2173[] = { 2, 0x69, 0x76, };
+static const char32 __uni_decomp_data_0x2174[] = { 1, 0x76, };
+static const char32 __uni_decomp_data_0x2175[] = { 2, 0x76, 0x69, };
+static const char32 __uni_decomp_data_0x2176[] = { 3, 0x76, 0x69, 0x69, };
+static const char32 __uni_decomp_data_0x2177[] = { 4, 0x76, 0x69, 0x69, 0x69, };
+static const char32 __uni_decomp_data_0x2178[] = { 2, 0x69, 0x78, };
+static const char32 __uni_decomp_data_0x2179[] = { 1, 0x78, };
+static const char32 __uni_decomp_data_0x217a[] = { 2, 0x78, 0x69, };
+static const char32 __uni_decomp_data_0x217b[] = { 3, 0x78, 0x69, 0x69, };
+static const char32 __uni_decomp_data_0x217c[] = { 1, 0x6c, };
+static const char32 __uni_decomp_data_0x217d[] = { 1, 0x63, };
+static const char32 __uni_decomp_data_0x217e[] = { 1, 0x64, };
+static const char32 __uni_decomp_data_0x217f[] = { 1, 0x6d, };
 
 
 
@@ -27541,12 +27541,12 @@
 };
 
 
-static const char32 __uni_decomp_data_0x219a[] = { 0x2190, 0x338, 0, };
-static const char32 __uni_decomp_data_0x219b[] = { 0x2192, 0x338, 0, };
-static const char32 __uni_decomp_data_0x21ae[] = { 0x2194, 0x338, 0, };
-static const char32 __uni_decomp_data_0x21cd[] = { 0x21d0, 0x338, 0, };
-static const char32 __uni_decomp_data_0x21ce[] = { 0x21d4, 0x338, 0, };
-static const char32 __uni_decomp_data_0x21cf[] = { 0x21d2, 0x338, 0, };
+static const char32 __uni_decomp_data_0x219a[] = { 2, 0x2190, 0x338, };
+static const char32 __uni_decomp_data_0x219b[] = { 2, 0x2192, 0x338, };
+static const char32 __uni_decomp_data_0x21ae[] = { 2, 0x2194, 0x338, };
+static const char32 __uni_decomp_data_0x21cd[] = { 2, 0x21d0, 0x338, };
+static const char32 __uni_decomp_data_0x21ce[] = { 2, 0x21d4, 0x338, };
+static const char32 __uni_decomp_data_0x21cf[] = { 2, 0x21d2, 0x338, };
 
 
 
@@ -29220,30 +29220,30 @@
 };
 
 
-static const char32 __uni_decomp_data_0x2204[] = { 0x2203, 0x338, 0, };
-static const char32 __uni_decomp_data_0x2209[] = { 0x2208, 0x338, 0, };
-static const char32 __uni_decomp_data_0x220c[] = { 0x220b, 0x338, 0, };
-static const char32 __uni_decomp_data_0x2224[] = { 0x2223, 0x338, 0, };
-static const char32 __uni_decomp_data_0x2226[] = { 0x2225, 0x338, 0, };
-static const char32 __uni_decomp_data_0x222c[] = { 0x222b, 0x222b, 0, };
-static const char32 __uni_decomp_data_0x222d[] = { 0x222b, 0x222b, 0x222b, 0, };
-static const char32 __uni_decomp_data_0x222f[] = { 0x222e, 0x222e, 0, };
-static const char32 __uni_decomp_data_0x2230[] = { 0x222e, 0x222e, 0x222e, 0, };
-static const char32 __uni_decomp_data_0x2241[] = { 0x223c, 0x338, 0, };
-static const char32 __uni_decomp_data_0x2244[] = { 0x2243, 0x338, 0, };
-static const char32 __uni_decomp_data_0x2247[] = { 0x2245, 0x338, 0, };
-static const char32 __uni_decomp_data_0x2249[] = { 0x2248, 0x338, 0, };
-static const char32 __uni_decomp_data_0x2260[] = { 0x3d, 0x338, 0, };
-static const char32 __uni_decomp_data_0x2262[] = { 0x2261, 0x338, 0, };
-static const char32 __uni_decomp_data_0x226d[] = { 0x224d, 0x338, 0, };
-static const char32 __uni_decomp_data_0x226e[] = { 0x3c, 0x338, 0, };
-static const char32 __uni_decomp_data_0x226f[] = { 0x3e, 0x338, 0, };
-static const char32 __uni_decomp_data_0x2270[] = { 0x2264, 0x338, 0, };
-static const char32 __uni_decomp_data_0x2271[] = { 0x2265, 0x338, 0, };
-static const char32 __uni_decomp_data_0x2274[] = { 0x2272, 0x338, 0, };
-static const char32 __uni_decomp_data_0x2275[] = { 0x2273, 0x338, 0, };
-static const char32 __uni_decomp_data_0x2278[] = { 0x2276, 0x338, 0, };
-static const char32 __uni_decomp_data_0x2279[] = { 0x2277, 0x338, 0, };
+static const char32 __uni_decomp_data_0x2204[] = { 2, 0x2203, 0x338, };
+static const char32 __uni_decomp_data_0x2209[] = { 2, 0x2208, 0x338, };
+static const char32 __uni_decomp_data_0x220c[] = { 2, 0x220b, 0x338, };
+static const char32 __uni_decomp_data_0x2224[] = { 2, 0x2223, 0x338, };
+static const char32 __uni_decomp_data_0x2226[] = { 2, 0x2225, 0x338, };
+static const char32 __uni_decomp_data_0x222c[] = { 2, 0x222b, 0x222b, };
+static const char32 __uni_decomp_data_0x222d[] = { 3, 0x222b, 0x222b, 0x222b, };
+static const char32 __uni_decomp_data_0x222f[] = { 2, 0x222e, 0x222e, };
+static const char32 __uni_decomp_data_0x2230[] = { 3, 0x222e, 0x222e, 0x222e, };
+static const char32 __uni_decomp_data_0x2241[] = { 2, 0x223c, 0x338, };
+static const char32 __uni_decomp_data_0x2244[] = { 2, 0x2243, 0x338, };
+static const char32 __uni_decomp_data_0x2247[] = { 2, 0x2245, 0x338, };
+static const char32 __uni_decomp_data_0x2249[] = { 2, 0x2248, 0x338, };
+static const char32 __uni_decomp_data_0x2260[] = { 2, 0x3d, 0x338, };
+static const char32 __uni_decomp_data_0x2262[] = { 2, 0x2261, 0x338, };
+static const char32 __uni_decomp_data_0x226d[] = { 2, 0x224d, 0x338, };
+static const char32 __uni_decomp_data_0x226e[] = { 2, 0x3c, 0x338, };
+static const char32 __uni_decomp_data_0x226f[] = { 2, 0x3e, 0x338, };
+static const char32 __uni_decomp_data_0x2270[] = { 2, 0x2264, 0x338, };
+static const char32 __uni_decomp_data_0x2271[] = { 2, 0x2265, 0x338, };
+static const char32 __uni_decomp_data_0x2274[] = { 2, 0x2272, 0x338, };
+static const char32 __uni_decomp_data_0x2275[] = { 2, 0x2273, 0x338, };
+static const char32 __uni_decomp_data_0x2278[] = { 2, 0x2276, 0x338, };
+static const char32 __uni_decomp_data_0x2279[] = { 2, 0x2277, 0x338, };
 
 
 
@@ -30917,24 +30917,24 @@
 };
 
 
-static const char32 __uni_decomp_data_0x2280[] = { 0x227a, 0x338, 0, };
-static const char32 __uni_decomp_data_0x2281[] = { 0x227b, 0x338, 0, };
-static const char32 __uni_decomp_data_0x2284[] = { 0x2282, 0x338, 0, };
-static const char32 __uni_decomp_data_0x2285[] = { 0x2283, 0x338, 0, };
-static const char32 __uni_decomp_data_0x2288[] = { 0x2286, 0x338, 0, };
-static const char32 __uni_decomp_data_0x2289[] = { 0x2287, 0x338, 0, };
-static const char32 __uni_decomp_data_0x22ac[] = { 0x22a2, 0x338, 0, };
-static const char32 __uni_decomp_data_0x22ad[] = { 0x22a8, 0x338, 0, };
-static const char32 __uni_decomp_data_0x22ae[] = { 0x22a9, 0x338, 0, };
-static const char32 __uni_decomp_data_0x22af[] = { 0x22ab, 0x338, 0, };
-static const char32 __uni_decomp_data_0x22e0[] = { 0x227c, 0x338, 0, };
-static const char32 __uni_decomp_data_0x22e1[] = { 0x227d, 0x338, 0, };
-static const char32 __uni_decomp_data_0x22e2[] = { 0x2291, 0x338, 0, };
-static const char32 __uni_decomp_data_0x22e3[] = { 0x2292, 0x338, 0, };
-static const char32 __uni_decomp_data_0x22ea[] = { 0x22b2, 0x338, 0, };
-static const char32 __uni_decomp_data_0x22eb[] = { 0x22b3, 0x338, 0, };
-static const char32 __uni_decomp_data_0x22ec[] = { 0x22b4, 0x338, 0, };
-static const char32 __uni_decomp_data_0x22ed[] = { 0x22b5, 0x338, 0, };
+static const char32 __uni_decomp_data_0x2280[] = { 2, 0x227a, 0x338, };
+static const char32 __uni_decomp_data_0x2281[] = { 2, 0x227b, 0x338, };
+static const char32 __uni_decomp_data_0x2284[] = { 2, 0x2282, 0x338, };
+static const char32 __uni_decomp_data_0x2285[] = { 2, 0x2283, 0x338, };
+static const char32 __uni_decomp_data_0x2288[] = { 2, 0x2286, 0x338, };
+static const char32 __uni_decomp_data_0x2289[] = { 2, 0x2287, 0x338, };
+static const char32 __uni_decomp_data_0x22ac[] = { 2, 0x22a2, 0x338, };
+static const char32 __uni_decomp_data_0x22ad[] = { 2, 0x22a8, 0x338, };
+static const char32 __uni_decomp_data_0x22ae[] = { 2, 0x22a9, 0x338, };
+static const char32 __uni_decomp_data_0x22af[] = { 2, 0x22ab, 0x338, };
+static const char32 __uni_decomp_data_0x22e0[] = { 2, 0x227c, 0x338, };
+static const char32 __uni_decomp_data_0x22e1[] = { 2, 0x227d, 0x338, };
+static const char32 __uni_decomp_data_0x22e2[] = { 2, 0x2291, 0x338, };
+static const char32 __uni_decomp_data_0x22e3[] = { 2, 0x2292, 0x338, };
+static const char32 __uni_decomp_data_0x22ea[] = { 2, 0x22b2, 0x338, };
+static const char32 __uni_decomp_data_0x22eb[] = { 2, 0x22b3, 0x338, };
+static const char32 __uni_decomp_data_0x22ec[] = { 2, 0x22b4, 0x338, };
+static const char32 __uni_decomp_data_0x22ed[] = { 2, 0x22b5, 0x338, };
 
 
 
@@ -32608,8 +32608,8 @@
 };
 
 
-static const char32 __uni_decomp_data_0x2329[] = { 0x3008, 0, };
-static const char32 __uni_decomp_data_0x232a[] = { 0x3009, 0, };
+static const char32 __uni_decomp_data_0x2329[] = { 1, 0x3008, };
+static const char32 __uni_decomp_data_0x232a[] = { 1, 0x3009, };
 
 
 
@@ -35956,38 +35956,38 @@
 };
 
 
-static const char32 __uni_decomp_data_0x2460[] = { 0x31, 0, };
-static const char32 __uni_decomp_data_0x2461[] = { 0x32, 0, };
-static const char32 __uni_decomp_data_0x2462[] = { 0x33, 0, };
-static const char32 __uni_decomp_data_0x2463[] = { 0x34, 0, };
-static const char32 __uni_decomp_data_0x2464[] = { 0x35, 0, };
-static const char32 __uni_decomp_data_0x2465[] = { 0x36, 0, };
-static const char32 __uni_decomp_data_0x2466[] = { 0x37, 0, };
-static const char32 __uni_decomp_data_0x2467[] = { 0x38, 0, };
-static const char32 __uni_decomp_data_0x2468[] = { 0x39, 0, };
-static const char32 __uni_decomp_data_0x2469[] = { 0x31, 0x30, 0, };
-static const char32 __uni_decomp_data_0x246a[] = { 0x31, 0x31, 0, };
-static const char32 __uni_decomp_data_0x246b[] = { 0x31, 0x32, 0, };
-static const char32 __uni_decomp_data_0x246c[] = { 0x31, 0x33, 0, };
-static const char32 __uni_decomp_data_0x246d[] = { 0x31, 0x34, 0, };
-static const char32 __uni_decomp_data_0x246e[] = { 0x31, 0x35, 0, };
-static const char32 __uni_decomp_data_0x246f[] = { 0x31, 0x36, 0, };
-static const char32 __uni_decomp_data_0x2470[] = { 0x31, 0x37, 0, };
-static const char32 __uni_decomp_data_0x2471[] = { 0x31, 0x38, 0, };
-static const char32 __uni_decomp_data_0x2472[] = { 0x31, 0x39, 0, };
-static const char32 __uni_decomp_data_0x2473[] = { 0x32, 0x30, 0, };
-static const char32 __uni_decomp_data_0x2474[] = { 0x28, 0x31, 0x29, 0, };
-static const char32 __uni_decomp_data_0x2475[] = { 0x28, 0x32, 0x29, 0, };
-static const char32 __uni_decomp_data_0x2476[] = { 0x28, 0x33, 0x29, 0, };
-static const char32 __uni_decomp_data_0x2477[] = { 0x28, 0x34, 0x29, 0, };
-static const char32 __uni_decomp_data_0x2478[] = { 0x28, 0x35, 0x29, 0, };
-static const char32 __uni_decomp_data_0x2479[] = { 0x28, 0x36, 0x29, 0, };
-static const char32 __uni_decomp_data_0x247a[] = { 0x28, 0x37, 0x29, 0, };
-static const char32 __uni_decomp_data_0x247b[] = { 0x28, 0x38, 0x29, 0, };
-static const char32 __uni_decomp_data_0x247c[] = { 0x28, 0x39, 0x29, 0, };
-static const char32 __uni_decomp_data_0x247d[] = { 0x28, 0x31, 0x30, 0x29, 0, };
-static const char32 __uni_decomp_data_0x247e[] = { 0x28, 0x31, 0x31, 0x29, 0, };
-static const char32 __uni_decomp_data_0x247f[] = { 0x28, 0x31, 0x32, 0x29, 0, };
+static const char32 __uni_decomp_data_0x2460[] = { 1, 0x31, };
+static const char32 __uni_decomp_data_0x2461[] = { 1, 0x32, };
+static const char32 __uni_decomp_data_0x2462[] = { 1, 0x33, };
+static const char32 __uni_decomp_data_0x2463[] = { 1, 0x34, };
+static const char32 __uni_decomp_data_0x2464[] = { 1, 0x35, };
+static const char32 __uni_decomp_data_0x2465[] = { 1, 0x36, };
+static const char32 __uni_decomp_data_0x2466[] = { 1, 0x37, };
+static const char32 __uni_decomp_data_0x2467[] = { 1, 0x38, };
+static const char32 __uni_decomp_data_0x2468[] = { 1, 0x39, };
+static const char32 __uni_decomp_data_0x2469[] = { 2, 0x31, 0x30, };
+static const char32 __uni_decomp_data_0x246a[] = { 2, 0x31, 0x31, };
+static const char32 __uni_decomp_data_0x246b[] = { 2, 0x31, 0x32, };
+static const char32 __uni_decomp_data_0x246c[] = { 2, 0x31, 0x33, };
+static const char32 __uni_decomp_data_0x246d[] = { 2, 0x31, 0x34, };
+static const char32 __uni_decomp_data_0x246e[] = { 2, 0x31, 0x35, };
+static const char32 __uni_decomp_data_0x246f[] = { 2, 0x31, 0x36, };
+static const char32 __uni_decomp_data_0x2470[] = { 2, 0x31, 0x37, };
+static const char32 __uni_decomp_data_0x2471[] = { 2, 0x31, 0x38, };
+static const char32 __uni_decomp_data_0x2472[] = { 2, 0x31, 0x39, };
+static const char32 __uni_decomp_data_0x2473[] = { 2, 0x32, 0x30, };
+static const char32 __uni_decomp_data_0x2474[] = { 3, 0x28, 0x31, 0x29, };
+static const char32 __uni_decomp_data_0x2475[] = { 3, 0x28, 0x32, 0x29, };
+static const char32 __uni_decomp_data_0x2476[] = { 3, 0x28, 0x33, 0x29, };
+static const char32 __uni_decomp_data_0x2477[] = { 3, 0x28, 0x34, 0x29, };
+static const char32 __uni_decomp_data_0x2478[] = { 3, 0x28, 0x35, 0x29, };
+static const char32 __uni_decomp_data_0x2479[] = { 3, 0x28, 0x36, 0x29, };
+static const char32 __uni_decomp_data_0x247a[] = { 3, 0x28, 0x37, 0x29, };
+static const char32 __uni_decomp_data_0x247b[] = { 3, 0x28, 0x38, 0x29, };
+static const char32 __uni_decomp_data_0x247c[] = { 3, 0x28, 0x39, 0x29, };
+static const char32 __uni_decomp_data_0x247d[] = { 4, 0x28, 0x31, 0x30, 0x29, };
+static const char32 __uni_decomp_data_0x247e[] = { 4, 0x28, 0x31, 0x31, 0x29, };
+static const char32 __uni_decomp_data_0x247f[] = { 4, 0x28, 0x31, 0x32, 0x29, };
 
 
 
@@ -37661,113 +37661,113 @@
 };
 
 
-static const char32 __uni_decomp_data_0x2480[] = { 0x28, 0x31, 0x33, 0x29, 0, };
-static const char32 __uni_decomp_data_0x2481[] = { 0x28, 0x31, 0x34, 0x29, 0, };
-static const char32 __uni_decomp_data_0x2482[] = { 0x28, 0x31, 0x35, 0x29, 0, };
-static const char32 __uni_decomp_data_0x2483[] = { 0x28, 0x31, 0x36, 0x29, 0, };
-static const char32 __uni_decomp_data_0x2484[] = { 0x28, 0x31, 0x37, 0x29, 0, };
-static const char32 __uni_decomp_data_0x2485[] = { 0x28, 0x31, 0x38, 0x29, 0, };
-static const char32 __uni_decomp_data_0x2486[] = { 0x28, 0x31, 0x39, 0x29, 0, };
-static const char32 __uni_decomp_data_0x2487[] = { 0x28, 0x32, 0x30, 0x29, 0, };
-static const char32 __uni_decomp_data_0x2488[] = { 0x31, 0x2e, 0, };
-static const char32 __uni_decomp_data_0x2489[] = { 0x32, 0x2e, 0, };
-static const char32 __uni_decomp_data_0x248a[] = { 0x33, 0x2e, 0, };
-static const char32 __uni_decomp_data_0x248b[] = { 0x34, 0x2e, 0, };
-static const char32 __uni_decomp_data_0x248c[] = { 0x35, 0x2e, 0, };
-static const char32 __uni_decomp_data_0x248d[] = { 0x36, 0x2e, 0, };
-static const char32 __uni_decomp_data_0x248e[] = { 0x37, 0x2e, 0, };
-static const char32 __uni_decomp_data_0x248f[] = { 0x38, 0x2e, 0, };
-static const char32 __uni_decomp_data_0x2490[] = { 0x39, 0x2e, 0, };
-static const char32 __uni_decomp_data_0x2491[] = { 0x31, 0x30, 0x2e, 0, };
-static const char32 __uni_decomp_data_0x2492[] = { 0x31, 0x31, 0x2e, 0, };
-static const char32 __uni_decomp_data_0x2493[] = { 0x31, 0x32, 0x2e, 0, };
-static const char32 __uni_decomp_data_0x2494[] = { 0x31, 0x33, 0x2e, 0, };
-static const char32 __uni_decomp_data_0x2495[] = { 0x31, 0x34, 0x2e, 0, };
-static const char32 __uni_decomp_data_0x2496[] = { 0x31, 0x35, 0x2e, 0, };
-static const char32 __uni_decomp_data_0x2497[] = { 0x31, 0x36, 0x2e, 0, };
-static const char32 __uni_decomp_data_0x2498[] = { 0x31, 0x37, 0x2e, 0, };
-static const char32 __uni_decomp_data_0x2499[] = { 0x31, 0x38, 0x2e, 0, };
-static const char32 __uni_decomp_data_0x249a[] = { 0x31, 0x39, 0x2e, 0, };
-static const char32 __uni_decomp_data_0x249b[] = { 0x32, 0x30, 0x2e, 0, };
-static const char32 __uni_decomp_data_0x249c[] = { 0x28, 0x61, 0x29, 0, };
-static const char32 __uni_decomp_data_0x249d[] = { 0x28, 0x62, 0x29, 0, };
-static const char32 __uni_decomp_data_0x249e[] = { 0x28, 0x63, 0x29, 0, };
-static const char32 __uni_decomp_data_0x249f[] = { 0x28, 0x64, 0x29, 0, };
-static const char32 __uni_decomp_data_0x24a0[] = { 0x28, 0x65, 0x29, 0, };
-static const char32 __uni_decomp_data_0x24a1[] = { 0x28, 0x66, 0x29, 0, };
-static const char32 __uni_decomp_data_0x24a2[] = { 0x28, 0x67, 0x29, 0, };
-static const char32 __uni_decomp_data_0x24a3[] = { 0x28, 0x68, 0x29, 0, };
-static const char32 __uni_decomp_data_0x24a4[] = { 0x28, 0x69, 0x29, 0, };
-static const char32 __uni_decomp_data_0x24a5[] = { 0x28, 0x6a, 0x29, 0, };
-static const char32 __uni_decomp_data_0x24a6[] = { 0x28, 0x6b, 0x29, 0, };
-static const char32 __uni_decomp_data_0x24a7[] = { 0x28, 0x6c, 0x29, 0, };
-static const char32 __uni_decomp_data_0x24a8[] = { 0x28, 0x6d, 0x29, 0, };
-static const char32 __uni_decomp_data_0x24a9[] = { 0x28, 0x6e, 0x29, 0, };
-static const char32 __uni_decomp_data_0x24aa[] = { 0x28, 0x6f, 0x29, 0, };
-static const char32 __uni_decomp_data_0x24ab[] = { 0x28, 0x70, 0x29, 0, };
-static const char32 __uni_decomp_data_0x24ac[] = { 0x28, 0x71, 0x29, 0, };
-static const char32 __uni_decomp_data_0x24ad[] = { 0x28, 0x72, 0x29, 0, };
-static const char32 __uni_decomp_data_0x24ae[] = { 0x28, 0x73, 0x29, 0, };
-static const char32 __uni_decomp_data_0x24af[] = { 0x28, 0x74, 0x29, 0, };
-static const char32 __uni_decomp_data_0x24b0[] = { 0x28, 0x75, 0x29, 0, };
-static const char32 __uni_decomp_data_0x24b1[] = { 0x28, 0x76, 0x29, 0, };
-static const char32 __uni_decomp_data_0x24b2[] = { 0x28, 0x77, 0x29, 0, };
-static const char32 __uni_decomp_data_0x24b3[] = { 0x28, 0x78, 0x29, 0, };
-static const char32 __uni_decomp_data_0x24b4[] = { 0x28, 0x79, 0x29, 0, };
-static const char32 __uni_decomp_data_0x24b5[] = { 0x28, 0x7a, 0x29, 0, };
-static const char32 __uni_decomp_data_0x24b6[] = { 0x41, 0, };
-static const char32 __uni_decomp_data_0x24b7[] = { 0x42, 0, };
-static const char32 __uni_decomp_data_0x24b8[] = { 0x43, 0, };
-static const char32 __uni_decomp_data_0x24b9[] = { 0x44, 0, };
-static const char32 __uni_decomp_data_0x24ba[] = { 0x45, 0, };
-static const char32 __uni_decomp_data_0x24bb[] = { 0x46, 0, };
-static const char32 __uni_decomp_data_0x24bc[] = { 0x47, 0, };
-static const char32 __uni_decomp_data_0x24bd[] = { 0x48, 0, };
-static const char32 __uni_decomp_data_0x24be[] = { 0x49, 0, };
-static const char32 __uni_decomp_data_0x24bf[] = { 0x4a, 0, };
-static const char32 __uni_decomp_data_0x24c0[] = { 0x4b, 0, };
-static const char32 __uni_decomp_data_0x24c1[] = { 0x4c, 0, };
-static const char32 __uni_decomp_data_0x24c2[] = { 0x4d, 0, };
-static const char32 __uni_decomp_data_0x24c3[] = { 0x4e, 0, };
-static const char32 __uni_decomp_data_0x24c4[] = { 0x4f, 0, };
-static const char32 __uni_decomp_data_0x24c5[] = { 0x50, 0, };
-static const char32 __uni_decomp_data_0x24c6[] = { 0x51, 0, };
-static const char32 __uni_decomp_data_0x24c7[] = { 0x52, 0, };
-static const char32 __uni_decomp_data_0x24c8[] = { 0x53, 0, };
-static const char32 __uni_decomp_data_0x24c9[] = { 0x54, 0, };
-static const char32 __uni_decomp_data_0x24ca[] = { 0x55, 0, };
-static const char32 __uni_decomp_data_0x24cb[] = { 0x56, 0, };
-static const char32 __uni_decomp_data_0x24cc[] = { 0x57, 0, };
-static const char32 __uni_decomp_data_0x24cd[] = { 0x58, 0, };
-static const char32 __uni_decomp_data_0x24ce[] = { 0x59, 0, };
-static const char32 __uni_decomp_data_0x24cf[] = { 0x5a, 0, };
-static const char32 __uni_decomp_data_0x24d0[] = { 0x61, 0, };
-static const char32 __uni_decomp_data_0x24d1[] = { 0x62, 0, };
-static const char32 __uni_decomp_data_0x24d2[] = { 0x63, 0, };
-static const char32 __uni_decomp_data_0x24d3[] = { 0x64, 0, };
-static const char32 __uni_decomp_data_0x24d4[] = { 0x65, 0, };
-static const char32 __uni_decomp_data_0x24d5[] = { 0x66, 0, };
-static const char32 __uni_decomp_data_0x24d6[] = { 0x67, 0, };
-static const char32 __uni_decomp_data_0x24d7[] = { 0x68, 0, };
-static const char32 __uni_decomp_data_0x24d8[] = { 0x69, 0, };
-static const char32 __uni_decomp_data_0x24d9[] = { 0x6a, 0, };
-static const char32 __uni_decomp_data_0x24da[] = { 0x6b, 0, };
-static const char32 __uni_decomp_data_0x24db[] = { 0x6c, 0, };
-static const char32 __uni_decomp_data_0x24dc[] = { 0x6d, 0, };
-static const char32 __uni_decomp_data_0x24dd[] = { 0x6e, 0, };
-static const char32 __uni_decomp_data_0x24de[] = { 0x6f, 0, };
-static const char32 __uni_decomp_data_0x24df[] = { 0x70, 0, };
-static const char32 __uni_decomp_data_0x24e0[] = { 0x71, 0, };
-static const char32 __uni_decomp_data_0x24e1[] = { 0x72, 0, };
-static const char32 __uni_decomp_data_0x24e2[] = { 0x73, 0, };
-static const char32 __uni_decomp_data_0x24e3[] = { 0x74, 0, };
-static const char32 __uni_decomp_data_0x24e4[] = { 0x75, 0, };
-static const char32 __uni_decomp_data_0x24e5[] = { 0x76, 0, };
-static const char32 __uni_decomp_data_0x24e6[] = { 0x77, 0, };
-static const char32 __uni_decomp_data_0x24e7[] = { 0x78, 0, };
-static const char32 __uni_decomp_data_0x24e8[] = { 0x79, 0, };
-static const char32 __uni_decomp_data_0x24e9[] = { 0x7a, 0, };
-static const char32 __uni_decomp_data_0x24ea[] = { 0x30, 0, };
+static const char32 __uni_decomp_data_0x2480[] = { 4, 0x28, 0x31, 0x33, 0x29, };
+static const char32 __uni_decomp_data_0x2481[] = { 4, 0x28, 0x31, 0x34, 0x29, };
+static const char32 __uni_decomp_data_0x2482[] = { 4, 0x28, 0x31, 0x35, 0x29, };
+static const char32 __uni_decomp_data_0x2483[] = { 4, 0x28, 0x31, 0x36, 0x29, };
+static const char32 __uni_decomp_data_0x2484[] = { 4, 0x28, 0x31, 0x37, 0x29, };
+static const char32 __uni_decomp_data_0x2485[] = { 4, 0x28, 0x31, 0x38, 0x29, };
+static const char32 __uni_decomp_data_0x2486[] = { 4, 0x28, 0x31, 0x39, 0x29, };
+static const char32 __uni_decomp_data_0x2487[] = { 4, 0x28, 0x32, 0x30, 0x29, };
+static const char32 __uni_decomp_data_0x2488[] = { 2, 0x31, 0x2e, };
+static const char32 __uni_decomp_data_0x2489[] = { 2, 0x32, 0x2e, };
+static const char32 __uni_decomp_data_0x248a[] = { 2, 0x33, 0x2e, };
+static const char32 __uni_decomp_data_0x248b[] = { 2, 0x34, 0x2e, };
+static const char32 __uni_decomp_data_0x248c[] = { 2, 0x35, 0x2e, };
+static const char32 __uni_decomp_data_0x248d[] = { 2, 0x36, 0x2e, };
+static const char32 __uni_decomp_data_0x248e[] = { 2, 0x37, 0x2e, };
+static const char32 __uni_decomp_data_0x248f[] = { 2, 0x38, 0x2e, };
+static const char32 __uni_decomp_data_0x2490[] = { 2, 0x39, 0x2e, };
+static const char32 __uni_decomp_data_0x2491[] = { 3, 0x31, 0x30, 0x2e, };
+static const char32 __uni_decomp_data_0x2492[] = { 3, 0x31, 0x31, 0x2e, };
+static const char32 __uni_decomp_data_0x2493[] = { 3, 0x31, 0x32, 0x2e, };
+static const char32 __uni_decomp_data_0x2494[] = { 3, 0x31, 0x33, 0x2e, };
+static const char32 __uni_decomp_data_0x2495[] = { 3, 0x31, 0x34, 0x2e, };
+static const char32 __uni_decomp_data_0x2496[] = { 3, 0x31, 0x35, 0x2e, };
+static const char32 __uni_decomp_data_0x2497[] = { 3, 0x31, 0x36, 0x2e, };
+static const char32 __uni_decomp_data_0x2498[] = { 3, 0x31, 0x37, 0x2e, };
+static const char32 __uni_decomp_data_0x2499[] = { 3, 0x31, 0x38, 0x2e, };
+static const char32 __uni_decomp_data_0x249a[] = { 3, 0x31, 0x39, 0x2e, };
+static const char32 __uni_decomp_data_0x249b[] = { 3, 0x32, 0x30, 0x2e, };
+static const char32 __uni_decomp_data_0x249c[] = { 3, 0x28, 0x61, 0x29, };
+static const char32 __uni_decomp_data_0x249d[] = { 3, 0x28, 0x62, 0x29, };
+static const char32 __uni_decomp_data_0x249e[] = { 3, 0x28, 0x63, 0x29, };
+static const char32 __uni_decomp_data_0x249f[] = { 3, 0x28, 0x64, 0x29, };
+static const char32 __uni_decomp_data_0x24a0[] = { 3, 0x28, 0x65, 0x29, };
+static const char32 __uni_decomp_data_0x24a1[] = { 3, 0x28, 0x66, 0x29, };
+static const char32 __uni_decomp_data_0x24a2[] = { 3, 0x28, 0x67, 0x29, };
+static const char32 __uni_decomp_data_0x24a3[] = { 3, 0x28, 0x68, 0x29, };
+static const char32 __uni_decomp_data_0x24a4[] = { 3, 0x28, 0x69, 0x29, };
+static const char32 __uni_decomp_data_0x24a5[] = { 3, 0x28, 0x6a, 0x29, };
+static const char32 __uni_decomp_data_0x24a6[] = { 3, 0x28, 0x6b, 0x29, };
+static const char32 __uni_decomp_data_0x24a7[] = { 3, 0x28, 0x6c, 0x29, };
+static const char32 __uni_decomp_data_0x24a8[] = { 3, 0x28, 0x6d, 0x29, };
+static const char32 __uni_decomp_data_0x24a9[] = { 3, 0x28, 0x6e, 0x29, };
+static const char32 __uni_decomp_data_0x24aa[] = { 3, 0x28, 0x6f, 0x29, };
+static const char32 __uni_decomp_data_0x24ab[] = { 3, 0x28, 0x70, 0x29, };
+static const char32 __uni_decomp_data_0x24ac[] = { 3, 0x28, 0x71, 0x29, };
+static const char32 __uni_decomp_data_0x24ad[] = { 3, 0x28, 0x72, 0x29, };
+static const char32 __uni_decomp_data_0x24ae[] = { 3, 0x28, 0x73, 0x29, };
+static const char32 __uni_decomp_data_0x24af[] = { 3, 0x28, 0x74, 0x29, };
+static const char32 __uni_decomp_data_0x24b0[] = { 3, 0x28, 0x75, 0x29, };
+static const char32 __uni_decomp_data_0x24b1[] = { 3, 0x28, 0x76, 0x29, };
+static const char32 __uni_decomp_data_0x24b2[] = { 3, 0x28, 0x77, 0x29, };
+static const char32 __uni_decomp_data_0x24b3[] = { 3, 0x28, 0x78, 0x29, };
+static const char32 __uni_decomp_data_0x24b4[] = { 3, 0x28, 0x79, 0x29, };
+static const char32 __uni_decomp_data_0x24b5[] = { 3, 0x28, 0x7a, 0x29, };
+static const char32 __uni_decomp_data_0x24b6[] = { 1, 0x41, };
+static const char32 __uni_decomp_data_0x24b7[] = { 1, 0x42, };
+static const char32 __uni_decomp_data_0x24b8[] = { 1, 0x43, };
+static const char32 __uni_decomp_data_0x24b9[] = { 1, 0x44, };
+static const char32 __uni_decomp_data_0x24ba[] = { 1, 0x45, };
+static const char32 __uni_decomp_data_0x24bb[] = { 1, 0x46, };
+static const char32 __uni_decomp_data_0x24bc[] = { 1, 0x47, };
+static const char32 __uni_decomp_data_0x24bd[] = { 1, 0x48, };
+static const char32 __uni_decomp_data_0x24be[] = { 1, 0x49, };
+static const char32 __uni_decomp_data_0x24bf[] = { 1, 0x4a, };
+static const char32 __uni_decomp_data_0x24c0[] = { 1, 0x4b, };
+static const char32 __uni_decomp_data_0x24c1[] = { 1, 0x4c, };
+static const char32 __uni_decomp_data_0x24c2[] = { 1, 0x4d, };
+static const char32 __uni_decomp_data_0x24c3[] = { 1, 0x4e, };
+static const char32 __uni_decomp_data_0x24c4[] = { 1, 0x4f, };
+static const char32 __uni_decomp_data_0x24c5[] = { 1, 0x50, };
+static const char32 __uni_decomp_data_0x24c6[] = { 1, 0x51, };
+static const char32 __uni_decomp_data_0x24c7[] = { 1, 0x52, };
+static const char32 __uni_decomp_data_0x24c8[] = { 1, 0x53, };
+static const char32 __uni_decomp_data_0x24c9[] = { 1, 0x54, };
+static const char32 __uni_decomp_data_0x24ca[] = { 1, 0x55, };
+static const char32 __uni_decomp_data_0x24cb[] = { 1, 0x56, };
+static const char32 __uni_decomp_data_0x24cc[] = { 1, 0x57, };
+static const char32 __uni_decomp_data_0x24cd[] = { 1, 0x58, };
+static const char32 __uni_decomp_data_0x24ce[] = { 1, 0x59, };
+static const char32 __uni_decomp_data_0x24cf[] = { 1, 0x5a, };
+static const char32 __uni_decomp_data_0x24d0[] = { 1, 0x61, };
+static const char32 __uni_decomp_data_0x24d1[] = { 1, 0x62, };
+static const char32 __uni_decomp_data_0x24d2[] = { 1, 0x63, };
+static const char32 __uni_decomp_data_0x24d3[] = { 1, 0x64, };
+static const char32 __uni_decomp_data_0x24d4[] = { 1, 0x65, };
+static const char32 __uni_decomp_data_0x24d5[] = { 1, 0x66, };
+static const char32 __uni_decomp_data_0x24d6[] = { 1, 0x67, };
+static const char32 __uni_decomp_data_0x24d7[] = { 1, 0x68, };
+static const char32 __uni_decomp_data_0x24d8[] = { 1, 0x69, };
+static const char32 __uni_decomp_data_0x24d9[] = { 1, 0x6a, };
+static const char32 __uni_decomp_data_0x24da[] = { 1, 0x6b, };
+static const char32 __uni_decomp_data_0x24db[] = { 1, 0x6c, };
+static const char32 __uni_decomp_data_0x24dc[] = { 1, 0x6d, };
+static const char32 __uni_decomp_data_0x24dd[] = { 1, 0x6e, };
+static const char32 __uni_decomp_data_0x24de[] = { 1, 0x6f, };
+static const char32 __uni_decomp_data_0x24df[] = { 1, 0x70, };
+static const char32 __uni_decomp_data_0x24e0[] = { 1, 0x71, };
+static const char32 __uni_decomp_data_0x24e1[] = { 1, 0x72, };
+static const char32 __uni_decomp_data_0x24e2[] = { 1, 0x73, };
+static const char32 __uni_decomp_data_0x24e3[] = { 1, 0x74, };
+static const char32 __uni_decomp_data_0x24e4[] = { 1, 0x75, };
+static const char32 __uni_decomp_data_0x24e5[] = { 1, 0x76, };
+static const char32 __uni_decomp_data_0x24e6[] = { 1, 0x77, };
+static const char32 __uni_decomp_data_0x24e7[] = { 1, 0x78, };
+static const char32 __uni_decomp_data_0x24e8[] = { 1, 0x79, };
+static const char32 __uni_decomp_data_0x24e9[] = { 1, 0x7a, };
+static const char32 __uni_decomp_data_0x24ea[] = { 1, 0x30, };
 
 
 

Modified: sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_4.ipp
==============================================================================
--- sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_4.ipp	(original)
+++ sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_4.ipp	2009-08-06 03:26:39 EDT (Thu, 06 Aug 2009)
@@ -15078,10 +15078,10 @@
 };
 
 
-static const char32 __uni_decomp_data_0x2a0c[] = { 0x222b, 0x222b, 0x222b, 0x222b, 0, };
-static const char32 __uni_decomp_data_0x2a74[] = { 0x3a, 0x3a, 0x3d, 0, };
-static const char32 __uni_decomp_data_0x2a75[] = { 0x3d, 0x3d, 0, };
-static const char32 __uni_decomp_data_0x2a76[] = { 0x3d, 0x3d, 0x3d, 0, };
+static const char32 __uni_decomp_data_0x2a0c[] = { 4, 0x222b, 0x222b, 0x222b, 0x222b, };
+static const char32 __uni_decomp_data_0x2a74[] = { 3, 0x3a, 0x3a, 0x3d, };
+static const char32 __uni_decomp_data_0x2a75[] = { 2, 0x3d, 0x3d, };
+static const char32 __uni_decomp_data_0x2a76[] = { 3, 0x3d, 0x3d, 0x3d, };
 
 
 
@@ -16755,7 +16755,7 @@
 };
 
 
-static const char32 __uni_decomp_data_0x2adc[] = { 0x2add, 0x338, 0, };
+static const char32 __uni_decomp_data_0x2adc[] = { 2, 0x2add, 0x338, };
 
 
 
@@ -21775,8 +21775,8 @@
 };
 
 
-static const char32 __uni_decomp_data_0x2c7c[] = { 0x6a, 0, };
-static const char32 __uni_decomp_data_0x2c7d[] = { 0x56, 0, };
+static const char32 __uni_decomp_data_0x2c7c[] = { 1, 0x6a, };
+static const char32 __uni_decomp_data_0x2c7d[] = { 1, 0x56, };
 
 
 
@@ -25123,7 +25123,7 @@
 };
 
 
-static const char32 __uni_decomp_data_0x2d6f[] = { 0x2d61, 0, };
+static const char32 __uni_decomp_data_0x2d6f[] = { 1, 0x2d61, };
 
 
 
@@ -30143,8 +30143,8 @@
 };
 
 
-static const char32 __uni_decomp_data_0x2e9f[] = { 0x6bcd, 0, };
-static const char32 __uni_decomp_data_0x2ef3[] = { 0x9f9f, 0, };
+static const char32 __uni_decomp_data_0x2e9f[] = { 1, 0x6bcd, };
+static const char32 __uni_decomp_data_0x2ef3[] = { 1, 0x9f9f, };
 
 
 
@@ -31818,134 +31818,134 @@
 };
 
 
-static const char32 __uni_decomp_data_0x2f00[] = { 0x4e00, 0, };
-static const char32 __uni_decomp_data_0x2f01[] = { 0x4e28, 0, };
-static const char32 __uni_decomp_data_0x2f02[] = { 0x4e36, 0, };
-static const char32 __uni_decomp_data_0x2f03[] = { 0x4e3f, 0, };
-static const char32 __uni_decomp_data_0x2f04[] = { 0x4e59, 0, };
-static const char32 __uni_decomp_data_0x2f05[] = { 0x4e85, 0, };
-static const char32 __uni_decomp_data_0x2f06[] = { 0x4e8c, 0, };
-static const char32 __uni_decomp_data_0x2f07[] = { 0x4ea0, 0, };
-static const char32 __uni_decomp_data_0x2f08[] = { 0x4eba, 0, };
-static const char32 __uni_decomp_data_0x2f09[] = { 0x513f, 0, };
-static const char32 __uni_decomp_data_0x2f0a[] = { 0x5165, 0, };
-static const char32 __uni_decomp_data_0x2f0b[] = { 0x516b, 0, };
-static const char32 __uni_decomp_data_0x2f0c[] = { 0x5182, 0, };
-static const char32 __uni_decomp_data_0x2f0d[] = { 0x5196, 0, };
-static const char32 __uni_decomp_data_0x2f0e[] = { 0x51ab, 0, };
-static const char32 __uni_decomp_data_0x2f0f[] = { 0x51e0, 0, };
-static const char32 __uni_decomp_data_0x2f10[] = { 0x51f5, 0, };
-static const char32 __uni_decomp_data_0x2f11[] = { 0x5200, 0, };
-static const char32 __uni_decomp_data_0x2f12[] = { 0x529b, 0, };
-static const char32 __uni_decomp_data_0x2f13[] = { 0x52f9, 0, };
-static const char32 __uni_decomp_data_0x2f14[] = { 0x5315, 0, };
-static const char32 __uni_decomp_data_0x2f15[] = { 0x531a, 0, };
-static const char32 __uni_decomp_data_0x2f16[] = { 0x5338, 0, };
-static const char32 __uni_decomp_data_0x2f17[] = { 0x5341, 0, };
-static const char32 __uni_decomp_data_0x2f18[] = { 0x535c, 0, };
-static const char32 __uni_decomp_data_0x2f19[] = { 0x5369, 0, };
-static const char32 __uni_decomp_data_0x2f1a[] = { 0x5382, 0, };
-static const char32 __uni_decomp_data_0x2f1b[] = { 0x53b6, 0, };
-static const char32 __uni_decomp_data_0x2f1c[] = { 0x53c8, 0, };
-static const char32 __uni_decomp_data_0x2f1d[] = { 0x53e3, 0, };
-static const char32 __uni_decomp_data_0x2f1e[] = { 0x56d7, 0, };
-static const char32 __uni_decomp_data_0x2f1f[] = { 0x571f, 0, };
-static const char32 __uni_decomp_data_0x2f20[] = { 0x58eb, 0, };
-static const char32 __uni_decomp_data_0x2f21[] = { 0x5902, 0, };
-static const char32 __uni_decomp_data_0x2f22[] = { 0x590a, 0, };
-static const char32 __uni_decomp_data_0x2f23[] = { 0x5915, 0, };
-static const char32 __uni_decomp_data_0x2f24[] = { 0x5927, 0, };
-static const char32 __uni_decomp_data_0x2f25[] = { 0x5973, 0, };
-static const char32 __uni_decomp_data_0x2f26[] = { 0x5b50, 0, };
-static const char32 __uni_decomp_data_0x2f27[] = { 0x5b80, 0, };
-static const char32 __uni_decomp_data_0x2f28[] = { 0x5bf8, 0, };
-static const char32 __uni_decomp_data_0x2f29[] = { 0x5c0f, 0, };
-static const char32 __uni_decomp_data_0x2f2a[] = { 0x5c22, 0, };
-static const char32 __uni_decomp_data_0x2f2b[] = { 0x5c38, 0, };
-static const char32 __uni_decomp_data_0x2f2c[] = { 0x5c6e, 0, };
-static const char32 __uni_decomp_data_0x2f2d[] = { 0x5c71, 0, };
-static const char32 __uni_decomp_data_0x2f2e[] = { 0x5ddb, 0, };
-static const char32 __uni_decomp_data_0x2f2f[] = { 0x5de5, 0, };
-static const char32 __uni_decomp_data_0x2f30[] = { 0x5df1, 0, };
-static const char32 __uni_decomp_data_0x2f31[] = { 0x5dfe, 0, };
-static const char32 __uni_decomp_data_0x2f32[] = { 0x5e72, 0, };
-static const char32 __uni_decomp_data_0x2f33[] = { 0x5e7a, 0, };
-static const char32 __uni_decomp_data_0x2f34[] = { 0x5e7f, 0, };
-static const char32 __uni_decomp_data_0x2f35[] = { 0x5ef4, 0, };
-static const char32 __uni_decomp_data_0x2f36[] = { 0x5efe, 0, };
-static const char32 __uni_decomp_data_0x2f37[] = { 0x5f0b, 0, };
-static const char32 __uni_decomp_data_0x2f38[] = { 0x5f13, 0, };
-static const char32 __uni_decomp_data_0x2f39[] = { 0x5f50, 0, };
-static const char32 __uni_decomp_data_0x2f3a[] = { 0x5f61, 0, };
-static const char32 __uni_decomp_data_0x2f3b[] = { 0x5f73, 0, };
-static const char32 __uni_decomp_data_0x2f3c[] = { 0x5fc3, 0, };
-static const char32 __uni_decomp_data_0x2f3d[] = { 0x6208, 0, };
-static const char32 __uni_decomp_data_0x2f3e[] = { 0x6236, 0, };
-static const char32 __uni_decomp_data_0x2f3f[] = { 0x624b, 0, };
-static const char32 __uni_decomp_data_0x2f40[] = { 0x652f, 0, };
-static const char32 __uni_decomp_data_0x2f41[] = { 0x6534, 0, };
-static const char32 __uni_decomp_data_0x2f42[] = { 0x6587, 0, };
-static const char32 __uni_decomp_data_0x2f43[] = { 0x6597, 0, };
-static const char32 __uni_decomp_data_0x2f44[] = { 0x65a4, 0, };
-static const char32 __uni_decomp_data_0x2f45[] = { 0x65b9, 0, };
-static const char32 __uni_decomp_data_0x2f46[] = { 0x65e0, 0, };
-static const char32 __uni_decomp_data_0x2f47[] = { 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x2f48[] = { 0x66f0, 0, };
-static const char32 __uni_decomp_data_0x2f49[] = { 0x6708, 0, };
-static const char32 __uni_decomp_data_0x2f4a[] = { 0x6728, 0, };
-static const char32 __uni_decomp_data_0x2f4b[] = { 0x6b20, 0, };
-static const char32 __uni_decomp_data_0x2f4c[] = { 0x6b62, 0, };
-static const char32 __uni_decomp_data_0x2f4d[] = { 0x6b79, 0, };
-static const char32 __uni_decomp_data_0x2f4e[] = { 0x6bb3, 0, };
-static const char32 __uni_decomp_data_0x2f4f[] = { 0x6bcb, 0, };
-static const char32 __uni_decomp_data_0x2f50[] = { 0x6bd4, 0, };
-static const char32 __uni_decomp_data_0x2f51[] = { 0x6bdb, 0, };
-static const char32 __uni_decomp_data_0x2f52[] = { 0x6c0f, 0, };
-static const char32 __uni_decomp_data_0x2f53[] = { 0x6c14, 0, };
-static const char32 __uni_decomp_data_0x2f54[] = { 0x6c34, 0, };
-static const char32 __uni_decomp_data_0x2f55[] = { 0x706b, 0, };
-static const char32 __uni_decomp_data_0x2f56[] = { 0x722a, 0, };
-static const char32 __uni_decomp_data_0x2f57[] = { 0x7236, 0, };
-static const char32 __uni_decomp_data_0x2f58[] = { 0x723b, 0, };
-static const char32 __uni_decomp_data_0x2f59[] = { 0x723f, 0, };
-static const char32 __uni_decomp_data_0x2f5a[] = { 0x7247, 0, };
-static const char32 __uni_decomp_data_0x2f5b[] = { 0x7259, 0, };
-static const char32 __uni_decomp_data_0x2f5c[] = { 0x725b, 0, };
-static const char32 __uni_decomp_data_0x2f5d[] = { 0x72ac, 0, };
-static const char32 __uni_decomp_data_0x2f5e[] = { 0x7384, 0, };
-static const char32 __uni_decomp_data_0x2f5f[] = { 0x7389, 0, };
-static const char32 __uni_decomp_data_0x2f60[] = { 0x74dc, 0, };
-static const char32 __uni_decomp_data_0x2f61[] = { 0x74e6, 0, };
-static const char32 __uni_decomp_data_0x2f62[] = { 0x7518, 0, };
-static const char32 __uni_decomp_data_0x2f63[] = { 0x751f, 0, };
-static const char32 __uni_decomp_data_0x2f64[] = { 0x7528, 0, };
-static const char32 __uni_decomp_data_0x2f65[] = { 0x7530, 0, };
-static const char32 __uni_decomp_data_0x2f66[] = { 0x758b, 0, };
-static const char32 __uni_decomp_data_0x2f67[] = { 0x7592, 0, };
-static const char32 __uni_decomp_data_0x2f68[] = { 0x7676, 0, };
-static const char32 __uni_decomp_data_0x2f69[] = { 0x767d, 0, };
-static const char32 __uni_decomp_data_0x2f6a[] = { 0x76ae, 0, };
-static const char32 __uni_decomp_data_0x2f6b[] = { 0x76bf, 0, };
-static const char32 __uni_decomp_data_0x2f6c[] = { 0x76ee, 0, };
-static const char32 __uni_decomp_data_0x2f6d[] = { 0x77db, 0, };
-static const char32 __uni_decomp_data_0x2f6e[] = { 0x77e2, 0, };
-static const char32 __uni_decomp_data_0x2f6f[] = { 0x77f3, 0, };
-static const char32 __uni_decomp_data_0x2f70[] = { 0x793a, 0, };
-static const char32 __uni_decomp_data_0x2f71[] = { 0x79b8, 0, };
-static const char32 __uni_decomp_data_0x2f72[] = { 0x79be, 0, };
-static const char32 __uni_decomp_data_0x2f73[] = { 0x7a74, 0, };
-static const char32 __uni_decomp_data_0x2f74[] = { 0x7acb, 0, };
-static const char32 __uni_decomp_data_0x2f75[] = { 0x7af9, 0, };
-static const char32 __uni_decomp_data_0x2f76[] = { 0x7c73, 0, };
-static const char32 __uni_decomp_data_0x2f77[] = { 0x7cf8, 0, };
-static const char32 __uni_decomp_data_0x2f78[] = { 0x7f36, 0, };
-static const char32 __uni_decomp_data_0x2f79[] = { 0x7f51, 0, };
-static const char32 __uni_decomp_data_0x2f7a[] = { 0x7f8a, 0, };
-static const char32 __uni_decomp_data_0x2f7b[] = { 0x7fbd, 0, };
-static const char32 __uni_decomp_data_0x2f7c[] = { 0x8001, 0, };
-static const char32 __uni_decomp_data_0x2f7d[] = { 0x800c, 0, };
-static const char32 __uni_decomp_data_0x2f7e[] = { 0x8012, 0, };
-static const char32 __uni_decomp_data_0x2f7f[] = { 0x8033, 0, };
+static const char32 __uni_decomp_data_0x2f00[] = { 1, 0x4e00, };
+static const char32 __uni_decomp_data_0x2f01[] = { 1, 0x4e28, };
+static const char32 __uni_decomp_data_0x2f02[] = { 1, 0x4e36, };
+static const char32 __uni_decomp_data_0x2f03[] = { 1, 0x4e3f, };
+static const char32 __uni_decomp_data_0x2f04[] = { 1, 0x4e59, };
+static const char32 __uni_decomp_data_0x2f05[] = { 1, 0x4e85, };
+static const char32 __uni_decomp_data_0x2f06[] = { 1, 0x4e8c, };
+static const char32 __uni_decomp_data_0x2f07[] = { 1, 0x4ea0, };
+static const char32 __uni_decomp_data_0x2f08[] = { 1, 0x4eba, };
+static const char32 __uni_decomp_data_0x2f09[] = { 1, 0x513f, };
+static const char32 __uni_decomp_data_0x2f0a[] = { 1, 0x5165, };
+static const char32 __uni_decomp_data_0x2f0b[] = { 1, 0x516b, };
+static const char32 __uni_decomp_data_0x2f0c[] = { 1, 0x5182, };
+static const char32 __uni_decomp_data_0x2f0d[] = { 1, 0x5196, };
+static const char32 __uni_decomp_data_0x2f0e[] = { 1, 0x51ab, };
+static const char32 __uni_decomp_data_0x2f0f[] = { 1, 0x51e0, };
+static const char32 __uni_decomp_data_0x2f10[] = { 1, 0x51f5, };
+static const char32 __uni_decomp_data_0x2f11[] = { 1, 0x5200, };
+static const char32 __uni_decomp_data_0x2f12[] = { 1, 0x529b, };
+static const char32 __uni_decomp_data_0x2f13[] = { 1, 0x52f9, };
+static const char32 __uni_decomp_data_0x2f14[] = { 1, 0x5315, };
+static const char32 __uni_decomp_data_0x2f15[] = { 1, 0x531a, };
+static const char32 __uni_decomp_data_0x2f16[] = { 1, 0x5338, };
+static const char32 __uni_decomp_data_0x2f17[] = { 1, 0x5341, };
+static const char32 __uni_decomp_data_0x2f18[] = { 1, 0x535c, };
+static const char32 __uni_decomp_data_0x2f19[] = { 1, 0x5369, };
+static const char32 __uni_decomp_data_0x2f1a[] = { 1, 0x5382, };
+static const char32 __uni_decomp_data_0x2f1b[] = { 1, 0x53b6, };
+static const char32 __uni_decomp_data_0x2f1c[] = { 1, 0x53c8, };
+static const char32 __uni_decomp_data_0x2f1d[] = { 1, 0x53e3, };
+static const char32 __uni_decomp_data_0x2f1e[] = { 1, 0x56d7, };
+static const char32 __uni_decomp_data_0x2f1f[] = { 1, 0x571f, };
+static const char32 __uni_decomp_data_0x2f20[] = { 1, 0x58eb, };
+static const char32 __uni_decomp_data_0x2f21[] = { 1, 0x5902, };
+static const char32 __uni_decomp_data_0x2f22[] = { 1, 0x590a, };
+static const char32 __uni_decomp_data_0x2f23[] = { 1, 0x5915, };
+static const char32 __uni_decomp_data_0x2f24[] = { 1, 0x5927, };
+static const char32 __uni_decomp_data_0x2f25[] = { 1, 0x5973, };
+static const char32 __uni_decomp_data_0x2f26[] = { 1, 0x5b50, };
+static const char32 __uni_decomp_data_0x2f27[] = { 1, 0x5b80, };
+static const char32 __uni_decomp_data_0x2f28[] = { 1, 0x5bf8, };
+static const char32 __uni_decomp_data_0x2f29[] = { 1, 0x5c0f, };
+static const char32 __uni_decomp_data_0x2f2a[] = { 1, 0x5c22, };
+static const char32 __uni_decomp_data_0x2f2b[] = { 1, 0x5c38, };
+static const char32 __uni_decomp_data_0x2f2c[] = { 1, 0x5c6e, };
+static const char32 __uni_decomp_data_0x2f2d[] = { 1, 0x5c71, };
+static const char32 __uni_decomp_data_0x2f2e[] = { 1, 0x5ddb, };
+static const char32 __uni_decomp_data_0x2f2f[] = { 1, 0x5de5, };
+static const char32 __uni_decomp_data_0x2f30[] = { 1, 0x5df1, };
+static const char32 __uni_decomp_data_0x2f31[] = { 1, 0x5dfe, };
+static const char32 __uni_decomp_data_0x2f32[] = { 1, 0x5e72, };
+static const char32 __uni_decomp_data_0x2f33[] = { 1, 0x5e7a, };
+static const char32 __uni_decomp_data_0x2f34[] = { 1, 0x5e7f, };
+static const char32 __uni_decomp_data_0x2f35[] = { 1, 0x5ef4, };
+static const char32 __uni_decomp_data_0x2f36[] = { 1, 0x5efe, };
+static const char32 __uni_decomp_data_0x2f37[] = { 1, 0x5f0b, };
+static const char32 __uni_decomp_data_0x2f38[] = { 1, 0x5f13, };
+static const char32 __uni_decomp_data_0x2f39[] = { 1, 0x5f50, };
+static const char32 __uni_decomp_data_0x2f3a[] = { 1, 0x5f61, };
+static const char32 __uni_decomp_data_0x2f3b[] = { 1, 0x5f73, };
+static const char32 __uni_decomp_data_0x2f3c[] = { 1, 0x5fc3, };
+static const char32 __uni_decomp_data_0x2f3d[] = { 1, 0x6208, };
+static const char32 __uni_decomp_data_0x2f3e[] = { 1, 0x6236, };
+static const char32 __uni_decomp_data_0x2f3f[] = { 1, 0x624b, };
+static const char32 __uni_decomp_data_0x2f40[] = { 1, 0x652f, };
+static const char32 __uni_decomp_data_0x2f41[] = { 1, 0x6534, };
+static const char32 __uni_decomp_data_0x2f42[] = { 1, 0x6587, };
+static const char32 __uni_decomp_data_0x2f43[] = { 1, 0x6597, };
+static const char32 __uni_decomp_data_0x2f44[] = { 1, 0x65a4, };
+static const char32 __uni_decomp_data_0x2f45[] = { 1, 0x65b9, };
+static const char32 __uni_decomp_data_0x2f46[] = { 1, 0x65e0, };
+static const char32 __uni_decomp_data_0x2f47[] = { 1, 0x65e5, };
+static const char32 __uni_decomp_data_0x2f48[] = { 1, 0x66f0, };
+static const char32 __uni_decomp_data_0x2f49[] = { 1, 0x6708, };
+static const char32 __uni_decomp_data_0x2f4a[] = { 1, 0x6728, };
+static const char32 __uni_decomp_data_0x2f4b[] = { 1, 0x6b20, };
+static const char32 __uni_decomp_data_0x2f4c[] = { 1, 0x6b62, };
+static const char32 __uni_decomp_data_0x2f4d[] = { 1, 0x6b79, };
+static const char32 __uni_decomp_data_0x2f4e[] = { 1, 0x6bb3, };
+static const char32 __uni_decomp_data_0x2f4f[] = { 1, 0x6bcb, };
+static const char32 __uni_decomp_data_0x2f50[] = { 1, 0x6bd4, };
+static const char32 __uni_decomp_data_0x2f51[] = { 1, 0x6bdb, };
+static const char32 __uni_decomp_data_0x2f52[] = { 1, 0x6c0f, };
+static const char32 __uni_decomp_data_0x2f53[] = { 1, 0x6c14, };
+static const char32 __uni_decomp_data_0x2f54[] = { 1, 0x6c34, };
+static const char32 __uni_decomp_data_0x2f55[] = { 1, 0x706b, };
+static const char32 __uni_decomp_data_0x2f56[] = { 1, 0x722a, };
+static const char32 __uni_decomp_data_0x2f57[] = { 1, 0x7236, };
+static const char32 __uni_decomp_data_0x2f58[] = { 1, 0x723b, };
+static const char32 __uni_decomp_data_0x2f59[] = { 1, 0x723f, };
+static const char32 __uni_decomp_data_0x2f5a[] = { 1, 0x7247, };
+static const char32 __uni_decomp_data_0x2f5b[] = { 1, 0x7259, };
+static const char32 __uni_decomp_data_0x2f5c[] = { 1, 0x725b, };
+static const char32 __uni_decomp_data_0x2f5d[] = { 1, 0x72ac, };
+static const char32 __uni_decomp_data_0x2f5e[] = { 1, 0x7384, };
+static const char32 __uni_decomp_data_0x2f5f[] = { 1, 0x7389, };
+static const char32 __uni_decomp_data_0x2f60[] = { 1, 0x74dc, };
+static const char32 __uni_decomp_data_0x2f61[] = { 1, 0x74e6, };
+static const char32 __uni_decomp_data_0x2f62[] = { 1, 0x7518, };
+static const char32 __uni_decomp_data_0x2f63[] = { 1, 0x751f, };
+static const char32 __uni_decomp_data_0x2f64[] = { 1, 0x7528, };
+static const char32 __uni_decomp_data_0x2f65[] = { 1, 0x7530, };
+static const char32 __uni_decomp_data_0x2f66[] = { 1, 0x758b, };
+static const char32 __uni_decomp_data_0x2f67[] = { 1, 0x7592, };
+static const char32 __uni_decomp_data_0x2f68[] = { 1, 0x7676, };
+static const char32 __uni_decomp_data_0x2f69[] = { 1, 0x767d, };
+static const char32 __uni_decomp_data_0x2f6a[] = { 1, 0x76ae, };
+static const char32 __uni_decomp_data_0x2f6b[] = { 1, 0x76bf, };
+static const char32 __uni_decomp_data_0x2f6c[] = { 1, 0x76ee, };
+static const char32 __uni_decomp_data_0x2f6d[] = { 1, 0x77db, };
+static const char32 __uni_decomp_data_0x2f6e[] = { 1, 0x77e2, };
+static const char32 __uni_decomp_data_0x2f6f[] = { 1, 0x77f3, };
+static const char32 __uni_decomp_data_0x2f70[] = { 1, 0x793a, };
+static const char32 __uni_decomp_data_0x2f71[] = { 1, 0x79b8, };
+static const char32 __uni_decomp_data_0x2f72[] = { 1, 0x79be, };
+static const char32 __uni_decomp_data_0x2f73[] = { 1, 0x7a74, };
+static const char32 __uni_decomp_data_0x2f74[] = { 1, 0x7acb, };
+static const char32 __uni_decomp_data_0x2f75[] = { 1, 0x7af9, };
+static const char32 __uni_decomp_data_0x2f76[] = { 1, 0x7c73, };
+static const char32 __uni_decomp_data_0x2f77[] = { 1, 0x7cf8, };
+static const char32 __uni_decomp_data_0x2f78[] = { 1, 0x7f36, };
+static const char32 __uni_decomp_data_0x2f79[] = { 1, 0x7f51, };
+static const char32 __uni_decomp_data_0x2f7a[] = { 1, 0x7f8a, };
+static const char32 __uni_decomp_data_0x2f7b[] = { 1, 0x7fbd, };
+static const char32 __uni_decomp_data_0x2f7c[] = { 1, 0x8001, };
+static const char32 __uni_decomp_data_0x2f7d[] = { 1, 0x800c, };
+static const char32 __uni_decomp_data_0x2f7e[] = { 1, 0x8012, };
+static const char32 __uni_decomp_data_0x2f7f[] = { 1, 0x8033, };
 
 
 
@@ -33619,92 +33619,92 @@
 };
 
 
-static const char32 __uni_decomp_data_0x2f80[] = { 0x807f, 0, };
-static const char32 __uni_decomp_data_0x2f81[] = { 0x8089, 0, };
-static const char32 __uni_decomp_data_0x2f82[] = { 0x81e3, 0, };
-static const char32 __uni_decomp_data_0x2f83[] = { 0x81ea, 0, };
-static const char32 __uni_decomp_data_0x2f84[] = { 0x81f3, 0, };
-static const char32 __uni_decomp_data_0x2f85[] = { 0x81fc, 0, };
-static const char32 __uni_decomp_data_0x2f86[] = { 0x820c, 0, };
-static const char32 __uni_decomp_data_0x2f87[] = { 0x821b, 0, };
-static const char32 __uni_decomp_data_0x2f88[] = { 0x821f, 0, };
-static const char32 __uni_decomp_data_0x2f89[] = { 0x826e, 0, };
-static const char32 __uni_decomp_data_0x2f8a[] = { 0x8272, 0, };
-static const char32 __uni_decomp_data_0x2f8b[] = { 0x8278, 0, };
-static const char32 __uni_decomp_data_0x2f8c[] = { 0x864d, 0, };
-static const char32 __uni_decomp_data_0x2f8d[] = { 0x866b, 0, };
-static const char32 __uni_decomp_data_0x2f8e[] = { 0x8840, 0, };
-static const char32 __uni_decomp_data_0x2f8f[] = { 0x884c, 0, };
-static const char32 __uni_decomp_data_0x2f90[] = { 0x8863, 0, };
-static const char32 __uni_decomp_data_0x2f91[] = { 0x897e, 0, };
-static const char32 __uni_decomp_data_0x2f92[] = { 0x898b, 0, };
-static const char32 __uni_decomp_data_0x2f93[] = { 0x89d2, 0, };
-static const char32 __uni_decomp_data_0x2f94[] = { 0x8a00, 0, };
-static const char32 __uni_decomp_data_0x2f95[] = { 0x8c37, 0, };
-static const char32 __uni_decomp_data_0x2f96[] = { 0x8c46, 0, };
-static const char32 __uni_decomp_data_0x2f97[] = { 0x8c55, 0, };
-static const char32 __uni_decomp_data_0x2f98[] = { 0x8c78, 0, };
-static const char32 __uni_decomp_data_0x2f99[] = { 0x8c9d, 0, };
-static const char32 __uni_decomp_data_0x2f9a[] = { 0x8d64, 0, };
-static const char32 __uni_decomp_data_0x2f9b[] = { 0x8d70, 0, };
-static const char32 __uni_decomp_data_0x2f9c[] = { 0x8db3, 0, };
-static const char32 __uni_decomp_data_0x2f9d[] = { 0x8eab, 0, };
-static const char32 __uni_decomp_data_0x2f9e[] = { 0x8eca, 0, };
-static const char32 __uni_decomp_data_0x2f9f[] = { 0x8f9b, 0, };
-static const char32 __uni_decomp_data_0x2fa0[] = { 0x8fb0, 0, };
-static const char32 __uni_decomp_data_0x2fa1[] = { 0x8fb5, 0, };
-static const char32 __uni_decomp_data_0x2fa2[] = { 0x9091, 0, };
-static const char32 __uni_decomp_data_0x2fa3[] = { 0x9149, 0, };
-static const char32 __uni_decomp_data_0x2fa4[] = { 0x91c6, 0, };
-static const char32 __uni_decomp_data_0x2fa5[] = { 0x91cc, 0, };
-static const char32 __uni_decomp_data_0x2fa6[] = { 0x91d1, 0, };
-static const char32 __uni_decomp_data_0x2fa7[] = { 0x9577, 0, };
-static const char32 __uni_decomp_data_0x2fa8[] = { 0x9580, 0, };
-static const char32 __uni_decomp_data_0x2fa9[] = { 0x961c, 0, };
-static const char32 __uni_decomp_data_0x2faa[] = { 0x96b6, 0, };
-static const char32 __uni_decomp_data_0x2fab[] = { 0x96b9, 0, };
-static const char32 __uni_decomp_data_0x2fac[] = { 0x96e8, 0, };
-static const char32 __uni_decomp_data_0x2fad[] = { 0x9751, 0, };
-static const char32 __uni_decomp_data_0x2fae[] = { 0x975e, 0, };
-static const char32 __uni_decomp_data_0x2faf[] = { 0x9762, 0, };
-static const char32 __uni_decomp_data_0x2fb0[] = { 0x9769, 0, };
-static const char32 __uni_decomp_data_0x2fb1[] = { 0x97cb, 0, };
-static const char32 __uni_decomp_data_0x2fb2[] = { 0x97ed, 0, };
-static const char32 __uni_decomp_data_0x2fb3[] = { 0x97f3, 0, };
-static const char32 __uni_decomp_data_0x2fb4[] = { 0x9801, 0, };
-static const char32 __uni_decomp_data_0x2fb5[] = { 0x98a8, 0, };
-static const char32 __uni_decomp_data_0x2fb6[] = { 0x98db, 0, };
-static const char32 __uni_decomp_data_0x2fb7[] = { 0x98df, 0, };
-static const char32 __uni_decomp_data_0x2fb8[] = { 0x9996, 0, };
-static const char32 __uni_decomp_data_0x2fb9[] = { 0x9999, 0, };
-static const char32 __uni_decomp_data_0x2fba[] = { 0x99ac, 0, };
-static const char32 __uni_decomp_data_0x2fbb[] = { 0x9aa8, 0, };
-static const char32 __uni_decomp_data_0x2fbc[] = { 0x9ad8, 0, };
-static const char32 __uni_decomp_data_0x2fbd[] = { 0x9adf, 0, };
-static const char32 __uni_decomp_data_0x2fbe[] = { 0x9b25, 0, };
-static const char32 __uni_decomp_data_0x2fbf[] = { 0x9b2f, 0, };
-static const char32 __uni_decomp_data_0x2fc0[] = { 0x9b32, 0, };
-static const char32 __uni_decomp_data_0x2fc1[] = { 0x9b3c, 0, };
-static const char32 __uni_decomp_data_0x2fc2[] = { 0x9b5a, 0, };
-static const char32 __uni_decomp_data_0x2fc3[] = { 0x9ce5, 0, };
-static const char32 __uni_decomp_data_0x2fc4[] = { 0x9e75, 0, };
-static const char32 __uni_decomp_data_0x2fc5[] = { 0x9e7f, 0, };
-static const char32 __uni_decomp_data_0x2fc6[] = { 0x9ea5, 0, };
-static const char32 __uni_decomp_data_0x2fc7[] = { 0x9ebb, 0, };
-static const char32 __uni_decomp_data_0x2fc8[] = { 0x9ec3, 0, };
-static const char32 __uni_decomp_data_0x2fc9[] = { 0x9ecd, 0, };
-static const char32 __uni_decomp_data_0x2fca[] = { 0x9ed1, 0, };
-static const char32 __uni_decomp_data_0x2fcb[] = { 0x9ef9, 0, };
-static const char32 __uni_decomp_data_0x2fcc[] = { 0x9efd, 0, };
-static const char32 __uni_decomp_data_0x2fcd[] = { 0x9f0e, 0, };
-static const char32 __uni_decomp_data_0x2fce[] = { 0x9f13, 0, };
-static const char32 __uni_decomp_data_0x2fcf[] = { 0x9f20, 0, };
-static const char32 __uni_decomp_data_0x2fd0[] = { 0x9f3b, 0, };
-static const char32 __uni_decomp_data_0x2fd1[] = { 0x9f4a, 0, };
-static const char32 __uni_decomp_data_0x2fd2[] = { 0x9f52, 0, };
-static const char32 __uni_decomp_data_0x2fd3[] = { 0x9f8d, 0, };
-static const char32 __uni_decomp_data_0x2fd4[] = { 0x9f9c, 0, };
-static const char32 __uni_decomp_data_0x2fd5[] = { 0x9fa0, 0, };
+static const char32 __uni_decomp_data_0x2f80[] = { 1, 0x807f, };
+static const char32 __uni_decomp_data_0x2f81[] = { 1, 0x8089, };
+static const char32 __uni_decomp_data_0x2f82[] = { 1, 0x81e3, };
+static const char32 __uni_decomp_data_0x2f83[] = { 1, 0x81ea, };
+static const char32 __uni_decomp_data_0x2f84[] = { 1, 0x81f3, };
+static const char32 __uni_decomp_data_0x2f85[] = { 1, 0x81fc, };
+static const char32 __uni_decomp_data_0x2f86[] = { 1, 0x820c, };
+static const char32 __uni_decomp_data_0x2f87[] = { 1, 0x821b, };
+static const char32 __uni_decomp_data_0x2f88[] = { 1, 0x821f, };
+static const char32 __uni_decomp_data_0x2f89[] = { 1, 0x826e, };
+static const char32 __uni_decomp_data_0x2f8a[] = { 1, 0x8272, };
+static const char32 __uni_decomp_data_0x2f8b[] = { 1, 0x8278, };
+static const char32 __uni_decomp_data_0x2f8c[] = { 1, 0x864d, };
+static const char32 __uni_decomp_data_0x2f8d[] = { 1, 0x866b, };
+static const char32 __uni_decomp_data_0x2f8e[] = { 1, 0x8840, };
+static const char32 __uni_decomp_data_0x2f8f[] = { 1, 0x884c, };
+static const char32 __uni_decomp_data_0x2f90[] = { 1, 0x8863, };
+static const char32 __uni_decomp_data_0x2f91[] = { 1, 0x897e, };
+static const char32 __uni_decomp_data_0x2f92[] = { 1, 0x898b, };
+static const char32 __uni_decomp_data_0x2f93[] = { 1, 0x89d2, };
+static const char32 __uni_decomp_data_0x2f94[] = { 1, 0x8a00, };
+static const char32 __uni_decomp_data_0x2f95[] = { 1, 0x8c37, };
+static const char32 __uni_decomp_data_0x2f96[] = { 1, 0x8c46, };
+static const char32 __uni_decomp_data_0x2f97[] = { 1, 0x8c55, };
+static const char32 __uni_decomp_data_0x2f98[] = { 1, 0x8c78, };
+static const char32 __uni_decomp_data_0x2f99[] = { 1, 0x8c9d, };
+static const char32 __uni_decomp_data_0x2f9a[] = { 1, 0x8d64, };
+static const char32 __uni_decomp_data_0x2f9b[] = { 1, 0x8d70, };
+static const char32 __uni_decomp_data_0x2f9c[] = { 1, 0x8db3, };
+static const char32 __uni_decomp_data_0x2f9d[] = { 1, 0x8eab, };
+static const char32 __uni_decomp_data_0x2f9e[] = { 1, 0x8eca, };
+static const char32 __uni_decomp_data_0x2f9f[] = { 1, 0x8f9b, };
+static const char32 __uni_decomp_data_0x2fa0[] = { 1, 0x8fb0, };
+static const char32 __uni_decomp_data_0x2fa1[] = { 1, 0x8fb5, };
+static const char32 __uni_decomp_data_0x2fa2[] = { 1, 0x9091, };
+static const char32 __uni_decomp_data_0x2fa3[] = { 1, 0x9149, };
+static const char32 __uni_decomp_data_0x2fa4[] = { 1, 0x91c6, };
+static const char32 __uni_decomp_data_0x2fa5[] = { 1, 0x91cc, };
+static const char32 __uni_decomp_data_0x2fa6[] = { 1, 0x91d1, };
+static const char32 __uni_decomp_data_0x2fa7[] = { 1, 0x9577, };
+static const char32 __uni_decomp_data_0x2fa8[] = { 1, 0x9580, };
+static const char32 __uni_decomp_data_0x2fa9[] = { 1, 0x961c, };
+static const char32 __uni_decomp_data_0x2faa[] = { 1, 0x96b6, };
+static const char32 __uni_decomp_data_0x2fab[] = { 1, 0x96b9, };
+static const char32 __uni_decomp_data_0x2fac[] = { 1, 0x96e8, };
+static const char32 __uni_decomp_data_0x2fad[] = { 1, 0x9751, };
+static const char32 __uni_decomp_data_0x2fae[] = { 1, 0x975e, };
+static const char32 __uni_decomp_data_0x2faf[] = { 1, 0x9762, };
+static const char32 __uni_decomp_data_0x2fb0[] = { 1, 0x9769, };
+static const char32 __uni_decomp_data_0x2fb1[] = { 1, 0x97cb, };
+static const char32 __uni_decomp_data_0x2fb2[] = { 1, 0x97ed, };
+static const char32 __uni_decomp_data_0x2fb3[] = { 1, 0x97f3, };
+static const char32 __uni_decomp_data_0x2fb4[] = { 1, 0x9801, };
+static const char32 __uni_decomp_data_0x2fb5[] = { 1, 0x98a8, };
+static const char32 __uni_decomp_data_0x2fb6[] = { 1, 0x98db, };
+static const char32 __uni_decomp_data_0x2fb7[] = { 1, 0x98df, };
+static const char32 __uni_decomp_data_0x2fb8[] = { 1, 0x9996, };
+static const char32 __uni_decomp_data_0x2fb9[] = { 1, 0x9999, };
+static const char32 __uni_decomp_data_0x2fba[] = { 1, 0x99ac, };
+static const char32 __uni_decomp_data_0x2fbb[] = { 1, 0x9aa8, };
+static const char32 __uni_decomp_data_0x2fbc[] = { 1, 0x9ad8, };
+static const char32 __uni_decomp_data_0x2fbd[] = { 1, 0x9adf, };
+static const char32 __uni_decomp_data_0x2fbe[] = { 1, 0x9b25, };
+static const char32 __uni_decomp_data_0x2fbf[] = { 1, 0x9b2f, };
+static const char32 __uni_decomp_data_0x2fc0[] = { 1, 0x9b32, };
+static const char32 __uni_decomp_data_0x2fc1[] = { 1, 0x9b3c, };
+static const char32 __uni_decomp_data_0x2fc2[] = { 1, 0x9b5a, };
+static const char32 __uni_decomp_data_0x2fc3[] = { 1, 0x9ce5, };
+static const char32 __uni_decomp_data_0x2fc4[] = { 1, 0x9e75, };
+static const char32 __uni_decomp_data_0x2fc5[] = { 1, 0x9e7f, };
+static const char32 __uni_decomp_data_0x2fc6[] = { 1, 0x9ea5, };
+static const char32 __uni_decomp_data_0x2fc7[] = { 1, 0x9ebb, };
+static const char32 __uni_decomp_data_0x2fc8[] = { 1, 0x9ec3, };
+static const char32 __uni_decomp_data_0x2fc9[] = { 1, 0x9ecd, };
+static const char32 __uni_decomp_data_0x2fca[] = { 1, 0x9ed1, };
+static const char32 __uni_decomp_data_0x2fcb[] = { 1, 0x9ef9, };
+static const char32 __uni_decomp_data_0x2fcc[] = { 1, 0x9efd, };
+static const char32 __uni_decomp_data_0x2fcd[] = { 1, 0x9f0e, };
+static const char32 __uni_decomp_data_0x2fce[] = { 1, 0x9f13, };
+static const char32 __uni_decomp_data_0x2fcf[] = { 1, 0x9f20, };
+static const char32 __uni_decomp_data_0x2fd0[] = { 1, 0x9f3b, };
+static const char32 __uni_decomp_data_0x2fd1[] = { 1, 0x9f4a, };
+static const char32 __uni_decomp_data_0x2fd2[] = { 1, 0x9f52, };
+static const char32 __uni_decomp_data_0x2fd3[] = { 1, 0x9f8d, };
+static const char32 __uni_decomp_data_0x2fd4[] = { 1, 0x9f9c, };
+static const char32 __uni_decomp_data_0x2fd5[] = { 1, 0x9fa0, };
 
 
 
@@ -35378,36 +35378,36 @@
 };
 
 
-static const char32 __uni_decomp_data_0x3000[] = { 0x20, 0, };
-static const char32 __uni_decomp_data_0x3036[] = { 0x3012, 0, };
-static const char32 __uni_decomp_data_0x3038[] = { 0x5341, 0, };
-static const char32 __uni_decomp_data_0x3039[] = { 0x5344, 0, };
-static const char32 __uni_decomp_data_0x303a[] = { 0x5345, 0, };
-static const char32 __uni_decomp_data_0x304c[] = { 0x304b, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x304e[] = { 0x304d, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x3050[] = { 0x304f, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x3052[] = { 0x3051, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x3054[] = { 0x3053, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x3056[] = { 0x3055, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x3058[] = { 0x3057, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x305a[] = { 0x3059, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x305c[] = { 0x305b, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x305e[] = { 0x305d, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x3060[] = { 0x305f, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x3062[] = { 0x3061, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x3065[] = { 0x3064, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x3067[] = { 0x3066, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x3069[] = { 0x3068, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x3070[] = { 0x306f, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x3071[] = { 0x306f, 0x309a, 0, };
-static const char32 __uni_decomp_data_0x3073[] = { 0x3072, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x3074[] = { 0x3072, 0x309a, 0, };
-static const char32 __uni_decomp_data_0x3076[] = { 0x3075, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x3077[] = { 0x3075, 0x309a, 0, };
-static const char32 __uni_decomp_data_0x3079[] = { 0x3078, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x307a[] = { 0x3078, 0x309a, 0, };
-static const char32 __uni_decomp_data_0x307c[] = { 0x307b, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x307d[] = { 0x307b, 0x309a, 0, };
+static const char32 __uni_decomp_data_0x3000[] = { 1, 0x20, };
+static const char32 __uni_decomp_data_0x3036[] = { 1, 0x3012, };
+static const char32 __uni_decomp_data_0x3038[] = { 1, 0x5341, };
+static const char32 __uni_decomp_data_0x3039[] = { 1, 0x5344, };
+static const char32 __uni_decomp_data_0x303a[] = { 1, 0x5345, };
+static const char32 __uni_decomp_data_0x304c[] = { 2, 0x304b, 0x3099, };
+static const char32 __uni_decomp_data_0x304e[] = { 2, 0x304d, 0x3099, };
+static const char32 __uni_decomp_data_0x3050[] = { 2, 0x304f, 0x3099, };
+static const char32 __uni_decomp_data_0x3052[] = { 2, 0x3051, 0x3099, };
+static const char32 __uni_decomp_data_0x3054[] = { 2, 0x3053, 0x3099, };
+static const char32 __uni_decomp_data_0x3056[] = { 2, 0x3055, 0x3099, };
+static const char32 __uni_decomp_data_0x3058[] = { 2, 0x3057, 0x3099, };
+static const char32 __uni_decomp_data_0x305a[] = { 2, 0x3059, 0x3099, };
+static const char32 __uni_decomp_data_0x305c[] = { 2, 0x305b, 0x3099, };
+static const char32 __uni_decomp_data_0x305e[] = { 2, 0x305d, 0x3099, };
+static const char32 __uni_decomp_data_0x3060[] = { 2, 0x305f, 0x3099, };
+static const char32 __uni_decomp_data_0x3062[] = { 2, 0x3061, 0x3099, };
+static const char32 __uni_decomp_data_0x3065[] = { 2, 0x3064, 0x3099, };
+static const char32 __uni_decomp_data_0x3067[] = { 2, 0x3066, 0x3099, };
+static const char32 __uni_decomp_data_0x3069[] = { 2, 0x3068, 0x3099, };
+static const char32 __uni_decomp_data_0x3070[] = { 2, 0x306f, 0x3099, };
+static const char32 __uni_decomp_data_0x3071[] = { 2, 0x306f, 0x309a, };
+static const char32 __uni_decomp_data_0x3073[] = { 2, 0x3072, 0x3099, };
+static const char32 __uni_decomp_data_0x3074[] = { 2, 0x3072, 0x309a, };
+static const char32 __uni_decomp_data_0x3076[] = { 2, 0x3075, 0x3099, };
+static const char32 __uni_decomp_data_0x3077[] = { 2, 0x3075, 0x309a, };
+static const char32 __uni_decomp_data_0x3079[] = { 2, 0x3078, 0x3099, };
+static const char32 __uni_decomp_data_0x307a[] = { 2, 0x3078, 0x309a, };
+static const char32 __uni_decomp_data_0x307c[] = { 2, 0x307b, 0x3099, };
+static const char32 __uni_decomp_data_0x307d[] = { 2, 0x307b, 0x309a, };
 
 
 
@@ -37081,43 +37081,43 @@
 };
 
 
-static const char32 __uni_decomp_data_0x3094[] = { 0x3046, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x309b[] = { 0x20, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x309c[] = { 0x20, 0x309a, 0, };
-static const char32 __uni_decomp_data_0x309e[] = { 0x309d, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x309f[] = { 0x3088, 0x308a, 0, };
-static const char32 __uni_decomp_data_0x30ac[] = { 0x30ab, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x30ae[] = { 0x30ad, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x30b0[] = { 0x30af, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x30b2[] = { 0x30b1, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x30b4[] = { 0x30b3, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x30b6[] = { 0x30b5, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x30b8[] = { 0x30b7, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x30ba[] = { 0x30b9, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x30bc[] = { 0x30bb, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x30be[] = { 0x30bd, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x30c0[] = { 0x30bf, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x30c2[] = { 0x30c1, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x30c5[] = { 0x30c4, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x30c7[] = { 0x30c6, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x30c9[] = { 0x30c8, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x30d0[] = { 0x30cf, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x30d1[] = { 0x30cf, 0x309a, 0, };
-static const char32 __uni_decomp_data_0x30d3[] = { 0x30d2, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x30d4[] = { 0x30d2, 0x309a, 0, };
-static const char32 __uni_decomp_data_0x30d6[] = { 0x30d5, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x30d7[] = { 0x30d5, 0x309a, 0, };
-static const char32 __uni_decomp_data_0x30d9[] = { 0x30d8, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x30da[] = { 0x30d8, 0x309a, 0, };
-static const char32 __uni_decomp_data_0x30dc[] = { 0x30db, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x30dd[] = { 0x30db, 0x309a, 0, };
-static const char32 __uni_decomp_data_0x30f4[] = { 0x30a6, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x30f7[] = { 0x30ef, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x30f8[] = { 0x30f0, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x30f9[] = { 0x30f1, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x30fa[] = { 0x30f2, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x30fe[] = { 0x30fd, 0x3099, 0, };
-static const char32 __uni_decomp_data_0x30ff[] = { 0x30b3, 0x30c8, 0, };
+static const char32 __uni_decomp_data_0x3094[] = { 2, 0x3046, 0x3099, };
+static const char32 __uni_decomp_data_0x309b[] = { 2, 0x20, 0x3099, };
+static const char32 __uni_decomp_data_0x309c[] = { 2, 0x20, 0x309a, };
+static const char32 __uni_decomp_data_0x309e[] = { 2, 0x309d, 0x3099, };
+static const char32 __uni_decomp_data_0x309f[] = { 2, 0x3088, 0x308a, };
+static const char32 __uni_decomp_data_0x30ac[] = { 2, 0x30ab, 0x3099, };
+static const char32 __uni_decomp_data_0x30ae[] = { 2, 0x30ad, 0x3099, };
+static const char32 __uni_decomp_data_0x30b0[] = { 2, 0x30af, 0x3099, };
+static const char32 __uni_decomp_data_0x30b2[] = { 2, 0x30b1, 0x3099, };
+static const char32 __uni_decomp_data_0x30b4[] = { 2, 0x30b3, 0x3099, };
+static const char32 __uni_decomp_data_0x30b6[] = { 2, 0x30b5, 0x3099, };
+static const char32 __uni_decomp_data_0x30b8[] = { 2, 0x30b7, 0x3099, };
+static const char32 __uni_decomp_data_0x30ba[] = { 2, 0x30b9, 0x3099, };
+static const char32 __uni_decomp_data_0x30bc[] = { 2, 0x30bb, 0x3099, };
+static const char32 __uni_decomp_data_0x30be[] = { 2, 0x30bd, 0x3099, };
+static const char32 __uni_decomp_data_0x30c0[] = { 2, 0x30bf, 0x3099, };
+static const char32 __uni_decomp_data_0x30c2[] = { 2, 0x30c1, 0x3099, };
+static const char32 __uni_decomp_data_0x30c5[] = { 2, 0x30c4, 0x3099, };
+static const char32 __uni_decomp_data_0x30c7[] = { 2, 0x30c6, 0x3099, };
+static const char32 __uni_decomp_data_0x30c9[] = { 2, 0x30c8, 0x3099, };
+static const char32 __uni_decomp_data_0x30d0[] = { 2, 0x30cf, 0x3099, };
+static const char32 __uni_decomp_data_0x30d1[] = { 2, 0x30cf, 0x309a, };
+static const char32 __uni_decomp_data_0x30d3[] = { 2, 0x30d2, 0x3099, };
+static const char32 __uni_decomp_data_0x30d4[] = { 2, 0x30d2, 0x309a, };
+static const char32 __uni_decomp_data_0x30d6[] = { 2, 0x30d5, 0x3099, };
+static const char32 __uni_decomp_data_0x30d7[] = { 2, 0x30d5, 0x309a, };
+static const char32 __uni_decomp_data_0x30d9[] = { 2, 0x30d8, 0x3099, };
+static const char32 __uni_decomp_data_0x30da[] = { 2, 0x30d8, 0x309a, };
+static const char32 __uni_decomp_data_0x30dc[] = { 2, 0x30db, 0x3099, };
+static const char32 __uni_decomp_data_0x30dd[] = { 2, 0x30db, 0x309a, };
+static const char32 __uni_decomp_data_0x30f4[] = { 2, 0x30a6, 0x3099, };
+static const char32 __uni_decomp_data_0x30f7[] = { 2, 0x30ef, 0x3099, };
+static const char32 __uni_decomp_data_0x30f8[] = { 2, 0x30f0, 0x3099, };
+static const char32 __uni_decomp_data_0x30f9[] = { 2, 0x30f1, 0x3099, };
+static const char32 __uni_decomp_data_0x30fa[] = { 2, 0x30f2, 0x3099, };
+static const char32 __uni_decomp_data_0x30fe[] = { 2, 0x30fd, 0x3099, };
+static const char32 __uni_decomp_data_0x30ff[] = { 2, 0x30b3, 0x30c8, };
 
 
 
@@ -38791,85 +38791,85 @@
 };
 
 
-static const char32 __uni_decomp_data_0x3131[] = { 0x1100, 0, };
-static const char32 __uni_decomp_data_0x3132[] = { 0x1101, 0, };
-static const char32 __uni_decomp_data_0x3133[] = { 0x11aa, 0, };
-static const char32 __uni_decomp_data_0x3134[] = { 0x1102, 0, };
-static const char32 __uni_decomp_data_0x3135[] = { 0x11ac, 0, };
-static const char32 __uni_decomp_data_0x3136[] = { 0x11ad, 0, };
-static const char32 __uni_decomp_data_0x3137[] = { 0x1103, 0, };
-static const char32 __uni_decomp_data_0x3138[] = { 0x1104, 0, };
-static const char32 __uni_decomp_data_0x3139[] = { 0x1105, 0, };
-static const char32 __uni_decomp_data_0x313a[] = { 0x11b0, 0, };
-static const char32 __uni_decomp_data_0x313b[] = { 0x11b1, 0, };
-static const char32 __uni_decomp_data_0x313c[] = { 0x11b2, 0, };
-static const char32 __uni_decomp_data_0x313d[] = { 0x11b3, 0, };
-static const char32 __uni_decomp_data_0x313e[] = { 0x11b4, 0, };
-static const char32 __uni_decomp_data_0x313f[] = { 0x11b5, 0, };
-static const char32 __uni_decomp_data_0x3140[] = { 0x111a, 0, };
-static const char32 __uni_decomp_data_0x3141[] = { 0x1106, 0, };
-static const char32 __uni_decomp_data_0x3142[] = { 0x1107, 0, };
-static const char32 __uni_decomp_data_0x3143[] = { 0x1108, 0, };
-static const char32 __uni_decomp_data_0x3144[] = { 0x1121, 0, };
-static const char32 __uni_decomp_data_0x3145[] = { 0x1109, 0, };
-static const char32 __uni_decomp_data_0x3146[] = { 0x110a, 0, };
-static const char32 __uni_decomp_data_0x3147[] = { 0x110b, 0, };
-static const char32 __uni_decomp_data_0x3148[] = { 0x110c, 0, };
-static const char32 __uni_decomp_data_0x3149[] = { 0x110d, 0, };
-static const char32 __uni_decomp_data_0x314a[] = { 0x110e, 0, };
-static const char32 __uni_decomp_data_0x314b[] = { 0x110f, 0, };
-static const char32 __uni_decomp_data_0x314c[] = { 0x1110, 0, };
-static const char32 __uni_decomp_data_0x314d[] = { 0x1111, 0, };
-static const char32 __uni_decomp_data_0x314e[] = { 0x1112, 0, };
-static const char32 __uni_decomp_data_0x314f[] = { 0x1161, 0, };
-static const char32 __uni_decomp_data_0x3150[] = { 0x1162, 0, };
-static const char32 __uni_decomp_data_0x3151[] = { 0x1163, 0, };
-static const char32 __uni_decomp_data_0x3152[] = { 0x1164, 0, };
-static const char32 __uni_decomp_data_0x3153[] = { 0x1165, 0, };
-static const char32 __uni_decomp_data_0x3154[] = { 0x1166, 0, };
-static const char32 __uni_decomp_data_0x3155[] = { 0x1167, 0, };
-static const char32 __uni_decomp_data_0x3156[] = { 0x1168, 0, };
-static const char32 __uni_decomp_data_0x3157[] = { 0x1169, 0, };
-static const char32 __uni_decomp_data_0x3158[] = { 0x116a, 0, };
-static const char32 __uni_decomp_data_0x3159[] = { 0x116b, 0, };
-static const char32 __uni_decomp_data_0x315a[] = { 0x116c, 0, };
-static const char32 __uni_decomp_data_0x315b[] = { 0x116d, 0, };
-static const char32 __uni_decomp_data_0x315c[] = { 0x116e, 0, };
-static const char32 __uni_decomp_data_0x315d[] = { 0x116f, 0, };
-static const char32 __uni_decomp_data_0x315e[] = { 0x1170, 0, };
-static const char32 __uni_decomp_data_0x315f[] = { 0x1171, 0, };
-static const char32 __uni_decomp_data_0x3160[] = { 0x1172, 0, };
-static const char32 __uni_decomp_data_0x3161[] = { 0x1173, 0, };
-static const char32 __uni_decomp_data_0x3162[] = { 0x1174, 0, };
-static const char32 __uni_decomp_data_0x3163[] = { 0x1175, 0, };
-static const char32 __uni_decomp_data_0x3164[] = { 0x1160, 0, };
-static const char32 __uni_decomp_data_0x3165[] = { 0x1114, 0, };
-static const char32 __uni_decomp_data_0x3166[] = { 0x1115, 0, };
-static const char32 __uni_decomp_data_0x3167[] = { 0x11c7, 0, };
-static const char32 __uni_decomp_data_0x3168[] = { 0x11c8, 0, };
-static const char32 __uni_decomp_data_0x3169[] = { 0x11cc, 0, };
-static const char32 __uni_decomp_data_0x316a[] = { 0x11ce, 0, };
-static const char32 __uni_decomp_data_0x316b[] = { 0x11d3, 0, };
-static const char32 __uni_decomp_data_0x316c[] = { 0x11d7, 0, };
-static const char32 __uni_decomp_data_0x316d[] = { 0x11d9, 0, };
-static const char32 __uni_decomp_data_0x316e[] = { 0x111c, 0, };
-static const char32 __uni_decomp_data_0x316f[] = { 0x11dd, 0, };
-static const char32 __uni_decomp_data_0x3170[] = { 0x11df, 0, };
-static const char32 __uni_decomp_data_0x3171[] = { 0x111d, 0, };
-static const char32 __uni_decomp_data_0x3172[] = { 0x111e, 0, };
-static const char32 __uni_decomp_data_0x3173[] = { 0x1120, 0, };
-static const char32 __uni_decomp_data_0x3174[] = { 0x1122, 0, };
-static const char32 __uni_decomp_data_0x3175[] = { 0x1123, 0, };
-static const char32 __uni_decomp_data_0x3176[] = { 0x1127, 0, };
-static const char32 __uni_decomp_data_0x3177[] = { 0x1129, 0, };
-static const char32 __uni_decomp_data_0x3178[] = { 0x112b, 0, };
-static const char32 __uni_decomp_data_0x3179[] = { 0x112c, 0, };
-static const char32 __uni_decomp_data_0x317a[] = { 0x112d, 0, };
-static const char32 __uni_decomp_data_0x317b[] = { 0x112e, 0, };
-static const char32 __uni_decomp_data_0x317c[] = { 0x112f, 0, };
-static const char32 __uni_decomp_data_0x317d[] = { 0x1132, 0, };
-static const char32 __uni_decomp_data_0x317e[] = { 0x1136, 0, };
-static const char32 __uni_decomp_data_0x317f[] = { 0x1140, 0, };
+static const char32 __uni_decomp_data_0x3131[] = { 1, 0x1100, };
+static const char32 __uni_decomp_data_0x3132[] = { 1, 0x1101, };
+static const char32 __uni_decomp_data_0x3133[] = { 1, 0x11aa, };
+static const char32 __uni_decomp_data_0x3134[] = { 1, 0x1102, };
+static const char32 __uni_decomp_data_0x3135[] = { 1, 0x11ac, };
+static const char32 __uni_decomp_data_0x3136[] = { 1, 0x11ad, };
+static const char32 __uni_decomp_data_0x3137[] = { 1, 0x1103, };
+static const char32 __uni_decomp_data_0x3138[] = { 1, 0x1104, };
+static const char32 __uni_decomp_data_0x3139[] = { 1, 0x1105, };
+static const char32 __uni_decomp_data_0x313a[] = { 1, 0x11b0, };
+static const char32 __uni_decomp_data_0x313b[] = { 1, 0x11b1, };
+static const char32 __uni_decomp_data_0x313c[] = { 1, 0x11b2, };
+static const char32 __uni_decomp_data_0x313d[] = { 1, 0x11b3, };
+static const char32 __uni_decomp_data_0x313e[] = { 1, 0x11b4, };
+static const char32 __uni_decomp_data_0x313f[] = { 1, 0x11b5, };
+static const char32 __uni_decomp_data_0x3140[] = { 1, 0x111a, };
+static const char32 __uni_decomp_data_0x3141[] = { 1, 0x1106, };
+static const char32 __uni_decomp_data_0x3142[] = { 1, 0x1107, };
+static const char32 __uni_decomp_data_0x3143[] = { 1, 0x1108, };
+static const char32 __uni_decomp_data_0x3144[] = { 1, 0x1121, };
+static const char32 __uni_decomp_data_0x3145[] = { 1, 0x1109, };
+static const char32 __uni_decomp_data_0x3146[] = { 1, 0x110a, };
+static const char32 __uni_decomp_data_0x3147[] = { 1, 0x110b, };
+static const char32 __uni_decomp_data_0x3148[] = { 1, 0x110c, };
+static const char32 __uni_decomp_data_0x3149[] = { 1, 0x110d, };
+static const char32 __uni_decomp_data_0x314a[] = { 1, 0x110e, };
+static const char32 __uni_decomp_data_0x314b[] = { 1, 0x110f, };
+static const char32 __uni_decomp_data_0x314c[] = { 1, 0x1110, };
+static const char32 __uni_decomp_data_0x314d[] = { 1, 0x1111, };
+static const char32 __uni_decomp_data_0x314e[] = { 1, 0x1112, };
+static const char32 __uni_decomp_data_0x314f[] = { 1, 0x1161, };
+static const char32 __uni_decomp_data_0x3150[] = { 1, 0x1162, };
+static const char32 __uni_decomp_data_0x3151[] = { 1, 0x1163, };
+static const char32 __uni_decomp_data_0x3152[] = { 1, 0x1164, };
+static const char32 __uni_decomp_data_0x3153[] = { 1, 0x1165, };
+static const char32 __uni_decomp_data_0x3154[] = { 1, 0x1166, };
+static const char32 __uni_decomp_data_0x3155[] = { 1, 0x1167, };
+static const char32 __uni_decomp_data_0x3156[] = { 1, 0x1168, };
+static const char32 __uni_decomp_data_0x3157[] = { 1, 0x1169, };
+static const char32 __uni_decomp_data_0x3158[] = { 1, 0x116a, };
+static const char32 __uni_decomp_data_0x3159[] = { 1, 0x116b, };
+static const char32 __uni_decomp_data_0x315a[] = { 1, 0x116c, };
+static const char32 __uni_decomp_data_0x315b[] = { 1, 0x116d, };
+static const char32 __uni_decomp_data_0x315c[] = { 1, 0x116e, };
+static const char32 __uni_decomp_data_0x315d[] = { 1, 0x116f, };
+static const char32 __uni_decomp_data_0x315e[] = { 1, 0x1170, };
+static const char32 __uni_decomp_data_0x315f[] = { 1, 0x1171, };
+static const char32 __uni_decomp_data_0x3160[] = { 1, 0x1172, };
+static const char32 __uni_decomp_data_0x3161[] = { 1, 0x1173, };
+static const char32 __uni_decomp_data_0x3162[] = { 1, 0x1174, };
+static const char32 __uni_decomp_data_0x3163[] = { 1, 0x1175, };
+static const char32 __uni_decomp_data_0x3164[] = { 1, 0x1160, };
+static const char32 __uni_decomp_data_0x3165[] = { 1, 0x1114, };
+static const char32 __uni_decomp_data_0x3166[] = { 1, 0x1115, };
+static const char32 __uni_decomp_data_0x3167[] = { 1, 0x11c7, };
+static const char32 __uni_decomp_data_0x3168[] = { 1, 0x11c8, };
+static const char32 __uni_decomp_data_0x3169[] = { 1, 0x11cc, };
+static const char32 __uni_decomp_data_0x316a[] = { 1, 0x11ce, };
+static const char32 __uni_decomp_data_0x316b[] = { 1, 0x11d3, };
+static const char32 __uni_decomp_data_0x316c[] = { 1, 0x11d7, };
+static const char32 __uni_decomp_data_0x316d[] = { 1, 0x11d9, };
+static const char32 __uni_decomp_data_0x316e[] = { 1, 0x111c, };
+static const char32 __uni_decomp_data_0x316f[] = { 1, 0x11dd, };
+static const char32 __uni_decomp_data_0x3170[] = { 1, 0x11df, };
+static const char32 __uni_decomp_data_0x3171[] = { 1, 0x111d, };
+static const char32 __uni_decomp_data_0x3172[] = { 1, 0x111e, };
+static const char32 __uni_decomp_data_0x3173[] = { 1, 0x1120, };
+static const char32 __uni_decomp_data_0x3174[] = { 1, 0x1122, };
+static const char32 __uni_decomp_data_0x3175[] = { 1, 0x1123, };
+static const char32 __uni_decomp_data_0x3176[] = { 1, 0x1127, };
+static const char32 __uni_decomp_data_0x3177[] = { 1, 0x1129, };
+static const char32 __uni_decomp_data_0x3178[] = { 1, 0x112b, };
+static const char32 __uni_decomp_data_0x3179[] = { 1, 0x112c, };
+static const char32 __uni_decomp_data_0x317a[] = { 1, 0x112d, };
+static const char32 __uni_decomp_data_0x317b[] = { 1, 0x112e, };
+static const char32 __uni_decomp_data_0x317c[] = { 1, 0x112f, };
+static const char32 __uni_decomp_data_0x317d[] = { 1, 0x1132, };
+static const char32 __uni_decomp_data_0x317e[] = { 1, 0x1136, };
+static const char32 __uni_decomp_data_0x317f[] = { 1, 0x1140, };
 
 
 

Modified: sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_5.ipp
==============================================================================
--- sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_5.ipp	(original)
+++ sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_5.ipp	2009-08-06 03:26:39 EDT (Thu, 06 Aug 2009)
@@ -21,35 +21,35 @@
 
 
 namespace boost { namespace unicode { namespace ucd {
-static const char32 __uni_decomp_data_0x3180[] = { 0x1147, 0, };
-static const char32 __uni_decomp_data_0x3181[] = { 0x114c, 0, };
-static const char32 __uni_decomp_data_0x3182[] = { 0x11f1, 0, };
-static const char32 __uni_decomp_data_0x3183[] = { 0x11f2, 0, };
-static const char32 __uni_decomp_data_0x3184[] = { 0x1157, 0, };
-static const char32 __uni_decomp_data_0x3185[] = { 0x1158, 0, };
-static const char32 __uni_decomp_data_0x3186[] = { 0x1159, 0, };
-static const char32 __uni_decomp_data_0x3187[] = { 0x1184, 0, };
-static const char32 __uni_decomp_data_0x3188[] = { 0x1185, 0, };
-static const char32 __uni_decomp_data_0x3189[] = { 0x1188, 0, };
-static const char32 __uni_decomp_data_0x318a[] = { 0x1191, 0, };
-static const char32 __uni_decomp_data_0x318b[] = { 0x1192, 0, };
-static const char32 __uni_decomp_data_0x318c[] = { 0x1194, 0, };
-static const char32 __uni_decomp_data_0x318d[] = { 0x119e, 0, };
-static const char32 __uni_decomp_data_0x318e[] = { 0x11a1, 0, };
-static const char32 __uni_decomp_data_0x3192[] = { 0x4e00, 0, };
-static const char32 __uni_decomp_data_0x3193[] = { 0x4e8c, 0, };
-static const char32 __uni_decomp_data_0x3194[] = { 0x4e09, 0, };
-static const char32 __uni_decomp_data_0x3195[] = { 0x56db, 0, };
-static const char32 __uni_decomp_data_0x3196[] = { 0x4e0a, 0, };
-static const char32 __uni_decomp_data_0x3197[] = { 0x4e2d, 0, };
-static const char32 __uni_decomp_data_0x3198[] = { 0x4e0b, 0, };
-static const char32 __uni_decomp_data_0x3199[] = { 0x7532, 0, };
-static const char32 __uni_decomp_data_0x319a[] = { 0x4e59, 0, };
-static const char32 __uni_decomp_data_0x319b[] = { 0x4e19, 0, };
-static const char32 __uni_decomp_data_0x319c[] = { 0x4e01, 0, };
-static const char32 __uni_decomp_data_0x319d[] = { 0x5929, 0, };
-static const char32 __uni_decomp_data_0x319e[] = { 0x5730, 0, };
-static const char32 __uni_decomp_data_0x319f[] = { 0x4eba, 0, };
+static const char32 __uni_decomp_data_0x3180[] = { 1, 0x1147, };
+static const char32 __uni_decomp_data_0x3181[] = { 1, 0x114c, };
+static const char32 __uni_decomp_data_0x3182[] = { 1, 0x11f1, };
+static const char32 __uni_decomp_data_0x3183[] = { 1, 0x11f2, };
+static const char32 __uni_decomp_data_0x3184[] = { 1, 0x1157, };
+static const char32 __uni_decomp_data_0x3185[] = { 1, 0x1158, };
+static const char32 __uni_decomp_data_0x3186[] = { 1, 0x1159, };
+static const char32 __uni_decomp_data_0x3187[] = { 1, 0x1184, };
+static const char32 __uni_decomp_data_0x3188[] = { 1, 0x1185, };
+static const char32 __uni_decomp_data_0x3189[] = { 1, 0x1188, };
+static const char32 __uni_decomp_data_0x318a[] = { 1, 0x1191, };
+static const char32 __uni_decomp_data_0x318b[] = { 1, 0x1192, };
+static const char32 __uni_decomp_data_0x318c[] = { 1, 0x1194, };
+static const char32 __uni_decomp_data_0x318d[] = { 1, 0x119e, };
+static const char32 __uni_decomp_data_0x318e[] = { 1, 0x11a1, };
+static const char32 __uni_decomp_data_0x3192[] = { 1, 0x4e00, };
+static const char32 __uni_decomp_data_0x3193[] = { 1, 0x4e8c, };
+static const char32 __uni_decomp_data_0x3194[] = { 1, 0x4e09, };
+static const char32 __uni_decomp_data_0x3195[] = { 1, 0x56db, };
+static const char32 __uni_decomp_data_0x3196[] = { 1, 0x4e0a, };
+static const char32 __uni_decomp_data_0x3197[] = { 1, 0x4e2d, };
+static const char32 __uni_decomp_data_0x3198[] = { 1, 0x4e0b, };
+static const char32 __uni_decomp_data_0x3199[] = { 1, 0x7532, };
+static const char32 __uni_decomp_data_0x319a[] = { 1, 0x4e59, };
+static const char32 __uni_decomp_data_0x319b[] = { 1, 0x4e19, };
+static const char32 __uni_decomp_data_0x319c[] = { 1, 0x4e01, };
+static const char32 __uni_decomp_data_0x319d[] = { 1, 0x5929, };
+static const char32 __uni_decomp_data_0x319e[] = { 1, 0x5730, };
+static const char32 __uni_decomp_data_0x319f[] = { 1, 0x4eba, };
 
 
 
@@ -1723,120 +1723,120 @@
 };
 
 
-static const char32 __uni_decomp_data_0x3200[] = { 0x28, 0x1100, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3201[] = { 0x28, 0x1102, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3202[] = { 0x28, 0x1103, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3203[] = { 0x28, 0x1105, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3204[] = { 0x28, 0x1106, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3205[] = { 0x28, 0x1107, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3206[] = { 0x28, 0x1109, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3207[] = { 0x28, 0x110b, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3208[] = { 0x28, 0x110c, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3209[] = { 0x28, 0x110e, 0x29, 0, };
-static const char32 __uni_decomp_data_0x320a[] = { 0x28, 0x110f, 0x29, 0, };
-static const char32 __uni_decomp_data_0x320b[] = { 0x28, 0x1110, 0x29, 0, };
-static const char32 __uni_decomp_data_0x320c[] = { 0x28, 0x1111, 0x29, 0, };
-static const char32 __uni_decomp_data_0x320d[] = { 0x28, 0x1112, 0x29, 0, };
-static const char32 __uni_decomp_data_0x320e[] = { 0x28, 0x1100, 0x1161, 0x29, 0, };
-static const char32 __uni_decomp_data_0x320f[] = { 0x28, 0x1102, 0x1161, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3210[] = { 0x28, 0x1103, 0x1161, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3211[] = { 0x28, 0x1105, 0x1161, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3212[] = { 0x28, 0x1106, 0x1161, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3213[] = { 0x28, 0x1107, 0x1161, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3214[] = { 0x28, 0x1109, 0x1161, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3215[] = { 0x28, 0x110b, 0x1161, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3216[] = { 0x28, 0x110c, 0x1161, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3217[] = { 0x28, 0x110e, 0x1161, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3218[] = { 0x28, 0x110f, 0x1161, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3219[] = { 0x28, 0x1110, 0x1161, 0x29, 0, };
-static const char32 __uni_decomp_data_0x321a[] = { 0x28, 0x1111, 0x1161, 0x29, 0, };
-static const char32 __uni_decomp_data_0x321b[] = { 0x28, 0x1112, 0x1161, 0x29, 0, };
-static const char32 __uni_decomp_data_0x321c[] = { 0x28, 0x110c, 0x116e, 0x29, 0, };
-static const char32 __uni_decomp_data_0x321d[] = { 0x28, 0x110b, 0x1169, 0x110c, 0x1165, 0x11ab, 0x29, 0, };
-static const char32 __uni_decomp_data_0x321e[] = { 0x28, 0x110b, 0x1169, 0x1112, 0x116e, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3220[] = { 0x28, 0x4e00, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3221[] = { 0x28, 0x4e8c, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3222[] = { 0x28, 0x4e09, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3223[] = { 0x28, 0x56db, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3224[] = { 0x28, 0x4e94, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3225[] = { 0x28, 0x516d, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3226[] = { 0x28, 0x4e03, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3227[] = { 0x28, 0x516b, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3228[] = { 0x28, 0x4e5d, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3229[] = { 0x28, 0x5341, 0x29, 0, };
-static const char32 __uni_decomp_data_0x322a[] = { 0x28, 0x6708, 0x29, 0, };
-static const char32 __uni_decomp_data_0x322b[] = { 0x28, 0x706b, 0x29, 0, };
-static const char32 __uni_decomp_data_0x322c[] = { 0x28, 0x6c34, 0x29, 0, };
-static const char32 __uni_decomp_data_0x322d[] = { 0x28, 0x6728, 0x29, 0, };
-static const char32 __uni_decomp_data_0x322e[] = { 0x28, 0x91d1, 0x29, 0, };
-static const char32 __uni_decomp_data_0x322f[] = { 0x28, 0x571f, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3230[] = { 0x28, 0x65e5, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3231[] = { 0x28, 0x682a, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3232[] = { 0x28, 0x6709, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3233[] = { 0x28, 0x793e, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3234[] = { 0x28, 0x540d, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3235[] = { 0x28, 0x7279, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3236[] = { 0x28, 0x8ca1, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3237[] = { 0x28, 0x795d, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3238[] = { 0x28, 0x52b4, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3239[] = { 0x28, 0x4ee3, 0x29, 0, };
-static const char32 __uni_decomp_data_0x323a[] = { 0x28, 0x547c, 0x29, 0, };
-static const char32 __uni_decomp_data_0x323b[] = { 0x28, 0x5b66, 0x29, 0, };
-static const char32 __uni_decomp_data_0x323c[] = { 0x28, 0x76e3, 0x29, 0, };
-static const char32 __uni_decomp_data_0x323d[] = { 0x28, 0x4f01, 0x29, 0, };
-static const char32 __uni_decomp_data_0x323e[] = { 0x28, 0x8cc7, 0x29, 0, };
-static const char32 __uni_decomp_data_0x323f[] = { 0x28, 0x5354, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3240[] = { 0x28, 0x796d, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3241[] = { 0x28, 0x4f11, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3242[] = { 0x28, 0x81ea, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3243[] = { 0x28, 0x81f3, 0x29, 0, };
-static const char32 __uni_decomp_data_0x3250[] = { 0x50, 0x54, 0x45, 0, };
-static const char32 __uni_decomp_data_0x3251[] = { 0x32, 0x31, 0, };
-static const char32 __uni_decomp_data_0x3252[] = { 0x32, 0x32, 0, };
-static const char32 __uni_decomp_data_0x3253[] = { 0x32, 0x33, 0, };
-static const char32 __uni_decomp_data_0x3254[] = { 0x32, 0x34, 0, };
-static const char32 __uni_decomp_data_0x3255[] = { 0x32, 0x35, 0, };
-static const char32 __uni_decomp_data_0x3256[] = { 0x32, 0x36, 0, };
-static const char32 __uni_decomp_data_0x3257[] = { 0x32, 0x37, 0, };
-static const char32 __uni_decomp_data_0x3258[] = { 0x32, 0x38, 0, };
-static const char32 __uni_decomp_data_0x3259[] = { 0x32, 0x39, 0, };
-static const char32 __uni_decomp_data_0x325a[] = { 0x33, 0x30, 0, };
-static const char32 __uni_decomp_data_0x325b[] = { 0x33, 0x31, 0, };
-static const char32 __uni_decomp_data_0x325c[] = { 0x33, 0x32, 0, };
-static const char32 __uni_decomp_data_0x325d[] = { 0x33, 0x33, 0, };
-static const char32 __uni_decomp_data_0x325e[] = { 0x33, 0x34, 0, };
-static const char32 __uni_decomp_data_0x325f[] = { 0x33, 0x35, 0, };
-static const char32 __uni_decomp_data_0x3260[] = { 0x1100, 0, };
-static const char32 __uni_decomp_data_0x3261[] = { 0x1102, 0, };
-static const char32 __uni_decomp_data_0x3262[] = { 0x1103, 0, };
-static const char32 __uni_decomp_data_0x3263[] = { 0x1105, 0, };
-static const char32 __uni_decomp_data_0x3264[] = { 0x1106, 0, };
-static const char32 __uni_decomp_data_0x3265[] = { 0x1107, 0, };
-static const char32 __uni_decomp_data_0x3266[] = { 0x1109, 0, };
-static const char32 __uni_decomp_data_0x3267[] = { 0x110b, 0, };
-static const char32 __uni_decomp_data_0x3268[] = { 0x110c, 0, };
-static const char32 __uni_decomp_data_0x3269[] = { 0x110e, 0, };
-static const char32 __uni_decomp_data_0x326a[] = { 0x110f, 0, };
-static const char32 __uni_decomp_data_0x326b[] = { 0x1110, 0, };
-static const char32 __uni_decomp_data_0x326c[] = { 0x1111, 0, };
-static const char32 __uni_decomp_data_0x326d[] = { 0x1112, 0, };
-static const char32 __uni_decomp_data_0x326e[] = { 0x1100, 0x1161, 0, };
-static const char32 __uni_decomp_data_0x326f[] = { 0x1102, 0x1161, 0, };
-static const char32 __uni_decomp_data_0x3270[] = { 0x1103, 0x1161, 0, };
-static const char32 __uni_decomp_data_0x3271[] = { 0x1105, 0x1161, 0, };
-static const char32 __uni_decomp_data_0x3272[] = { 0x1106, 0x1161, 0, };
-static const char32 __uni_decomp_data_0x3273[] = { 0x1107, 0x1161, 0, };
-static const char32 __uni_decomp_data_0x3274[] = { 0x1109, 0x1161, 0, };
-static const char32 __uni_decomp_data_0x3275[] = { 0x110b, 0x1161, 0, };
-static const char32 __uni_decomp_data_0x3276[] = { 0x110c, 0x1161, 0, };
-static const char32 __uni_decomp_data_0x3277[] = { 0x110e, 0x1161, 0, };
-static const char32 __uni_decomp_data_0x3278[] = { 0x110f, 0x1161, 0, };
-static const char32 __uni_decomp_data_0x3279[] = { 0x1110, 0x1161, 0, };
-static const char32 __uni_decomp_data_0x327a[] = { 0x1111, 0x1161, 0, };
-static const char32 __uni_decomp_data_0x327b[] = { 0x1112, 0x1161, 0, };
-static const char32 __uni_decomp_data_0x327c[] = { 0x110e, 0x1161, 0x11b7, 0x1100, 0x1169, 0, };
-static const char32 __uni_decomp_data_0x327d[] = { 0x110c, 0x116e, 0x110b, 0x1174, 0, };
-static const char32 __uni_decomp_data_0x327e[] = { 0x110b, 0x116e, 0, };
+static const char32 __uni_decomp_data_0x3200[] = { 3, 0x28, 0x1100, 0x29, };
+static const char32 __uni_decomp_data_0x3201[] = { 3, 0x28, 0x1102, 0x29, };
+static const char32 __uni_decomp_data_0x3202[] = { 3, 0x28, 0x1103, 0x29, };
+static const char32 __uni_decomp_data_0x3203[] = { 3, 0x28, 0x1105, 0x29, };
+static const char32 __uni_decomp_data_0x3204[] = { 3, 0x28, 0x1106, 0x29, };
+static const char32 __uni_decomp_data_0x3205[] = { 3, 0x28, 0x1107, 0x29, };
+static const char32 __uni_decomp_data_0x3206[] = { 3, 0x28, 0x1109, 0x29, };
+static const char32 __uni_decomp_data_0x3207[] = { 3, 0x28, 0x110b, 0x29, };
+static const char32 __uni_decomp_data_0x3208[] = { 3, 0x28, 0x110c, 0x29, };
+static const char32 __uni_decomp_data_0x3209[] = { 3, 0x28, 0x110e, 0x29, };
+static const char32 __uni_decomp_data_0x320a[] = { 3, 0x28, 0x110f, 0x29, };
+static const char32 __uni_decomp_data_0x320b[] = { 3, 0x28, 0x1110, 0x29, };
+static const char32 __uni_decomp_data_0x320c[] = { 3, 0x28, 0x1111, 0x29, };
+static const char32 __uni_decomp_data_0x320d[] = { 3, 0x28, 0x1112, 0x29, };
+static const char32 __uni_decomp_data_0x320e[] = { 4, 0x28, 0x1100, 0x1161, 0x29, };
+static const char32 __uni_decomp_data_0x320f[] = { 4, 0x28, 0x1102, 0x1161, 0x29, };
+static const char32 __uni_decomp_data_0x3210[] = { 4, 0x28, 0x1103, 0x1161, 0x29, };
+static const char32 __uni_decomp_data_0x3211[] = { 4, 0x28, 0x1105, 0x1161, 0x29, };
+static const char32 __uni_decomp_data_0x3212[] = { 4, 0x28, 0x1106, 0x1161, 0x29, };
+static const char32 __uni_decomp_data_0x3213[] = { 4, 0x28, 0x1107, 0x1161, 0x29, };
+static const char32 __uni_decomp_data_0x3214[] = { 4, 0x28, 0x1109, 0x1161, 0x29, };
+static const char32 __uni_decomp_data_0x3215[] = { 4, 0x28, 0x110b, 0x1161, 0x29, };
+static const char32 __uni_decomp_data_0x3216[] = { 4, 0x28, 0x110c, 0x1161, 0x29, };
+static const char32 __uni_decomp_data_0x3217[] = { 4, 0x28, 0x110e, 0x1161, 0x29, };
+static const char32 __uni_decomp_data_0x3218[] = { 4, 0x28, 0x110f, 0x1161, 0x29, };
+static const char32 __uni_decomp_data_0x3219[] = { 4, 0x28, 0x1110, 0x1161, 0x29, };
+static const char32 __uni_decomp_data_0x321a[] = { 4, 0x28, 0x1111, 0x1161, 0x29, };
+static const char32 __uni_decomp_data_0x321b[] = { 4, 0x28, 0x1112, 0x1161, 0x29, };
+static const char32 __uni_decomp_data_0x321c[] = { 4, 0x28, 0x110c, 0x116e, 0x29, };
+static const char32 __uni_decomp_data_0x321d[] = { 7, 0x28, 0x110b, 0x1169, 0x110c, 0x1165, 0x11ab, 0x29, };
+static const char32 __uni_decomp_data_0x321e[] = { 6, 0x28, 0x110b, 0x1169, 0x1112, 0x116e, 0x29, };
+static const char32 __uni_decomp_data_0x3220[] = { 3, 0x28, 0x4e00, 0x29, };
+static const char32 __uni_decomp_data_0x3221[] = { 3, 0x28, 0x4e8c, 0x29, };
+static const char32 __uni_decomp_data_0x3222[] = { 3, 0x28, 0x4e09, 0x29, };
+static const char32 __uni_decomp_data_0x3223[] = { 3, 0x28, 0x56db, 0x29, };
+static const char32 __uni_decomp_data_0x3224[] = { 3, 0x28, 0x4e94, 0x29, };
+static const char32 __uni_decomp_data_0x3225[] = { 3, 0x28, 0x516d, 0x29, };
+static const char32 __uni_decomp_data_0x3226[] = { 3, 0x28, 0x4e03, 0x29, };
+static const char32 __uni_decomp_data_0x3227[] = { 3, 0x28, 0x516b, 0x29, };
+static const char32 __uni_decomp_data_0x3228[] = { 3, 0x28, 0x4e5d, 0x29, };
+static const char32 __uni_decomp_data_0x3229[] = { 3, 0x28, 0x5341, 0x29, };
+static const char32 __uni_decomp_data_0x322a[] = { 3, 0x28, 0x6708, 0x29, };
+static const char32 __uni_decomp_data_0x322b[] = { 3, 0x28, 0x706b, 0x29, };
+static const char32 __uni_decomp_data_0x322c[] = { 3, 0x28, 0x6c34, 0x29, };
+static const char32 __uni_decomp_data_0x322d[] = { 3, 0x28, 0x6728, 0x29, };
+static const char32 __uni_decomp_data_0x322e[] = { 3, 0x28, 0x91d1, 0x29, };
+static const char32 __uni_decomp_data_0x322f[] = { 3, 0x28, 0x571f, 0x29, };
+static const char32 __uni_decomp_data_0x3230[] = { 3, 0x28, 0x65e5, 0x29, };
+static const char32 __uni_decomp_data_0x3231[] = { 3, 0x28, 0x682a, 0x29, };
+static const char32 __uni_decomp_data_0x3232[] = { 3, 0x28, 0x6709, 0x29, };
+static const char32 __uni_decomp_data_0x3233[] = { 3, 0x28, 0x793e, 0x29, };
+static const char32 __uni_decomp_data_0x3234[] = { 3, 0x28, 0x540d, 0x29, };
+static const char32 __uni_decomp_data_0x3235[] = { 3, 0x28, 0x7279, 0x29, };
+static const char32 __uni_decomp_data_0x3236[] = { 3, 0x28, 0x8ca1, 0x29, };
+static const char32 __uni_decomp_data_0x3237[] = { 3, 0x28, 0x795d, 0x29, };
+static const char32 __uni_decomp_data_0x3238[] = { 3, 0x28, 0x52b4, 0x29, };
+static const char32 __uni_decomp_data_0x3239[] = { 3, 0x28, 0x4ee3, 0x29, };
+static const char32 __uni_decomp_data_0x323a[] = { 3, 0x28, 0x547c, 0x29, };
+static const char32 __uni_decomp_data_0x323b[] = { 3, 0x28, 0x5b66, 0x29, };
+static const char32 __uni_decomp_data_0x323c[] = { 3, 0x28, 0x76e3, 0x29, };
+static const char32 __uni_decomp_data_0x323d[] = { 3, 0x28, 0x4f01, 0x29, };
+static const char32 __uni_decomp_data_0x323e[] = { 3, 0x28, 0x8cc7, 0x29, };
+static const char32 __uni_decomp_data_0x323f[] = { 3, 0x28, 0x5354, 0x29, };
+static const char32 __uni_decomp_data_0x3240[] = { 3, 0x28, 0x796d, 0x29, };
+static const char32 __uni_decomp_data_0x3241[] = { 3, 0x28, 0x4f11, 0x29, };
+static const char32 __uni_decomp_data_0x3242[] = { 3, 0x28, 0x81ea, 0x29, };
+static const char32 __uni_decomp_data_0x3243[] = { 3, 0x28, 0x81f3, 0x29, };
+static const char32 __uni_decomp_data_0x3250[] = { 3, 0x50, 0x54, 0x45, };
+static const char32 __uni_decomp_data_0x3251[] = { 2, 0x32, 0x31, };
+static const char32 __uni_decomp_data_0x3252[] = { 2, 0x32, 0x32, };
+static const char32 __uni_decomp_data_0x3253[] = { 2, 0x32, 0x33, };
+static const char32 __uni_decomp_data_0x3254[] = { 2, 0x32, 0x34, };
+static const char32 __uni_decomp_data_0x3255[] = { 2, 0x32, 0x35, };
+static const char32 __uni_decomp_data_0x3256[] = { 2, 0x32, 0x36, };
+static const char32 __uni_decomp_data_0x3257[] = { 2, 0x32, 0x37, };
+static const char32 __uni_decomp_data_0x3258[] = { 2, 0x32, 0x38, };
+static const char32 __uni_decomp_data_0x3259[] = { 2, 0x32, 0x39, };
+static const char32 __uni_decomp_data_0x325a[] = { 2, 0x33, 0x30, };
+static const char32 __uni_decomp_data_0x325b[] = { 2, 0x33, 0x31, };
+static const char32 __uni_decomp_data_0x325c[] = { 2, 0x33, 0x32, };
+static const char32 __uni_decomp_data_0x325d[] = { 2, 0x33, 0x33, };
+static const char32 __uni_decomp_data_0x325e[] = { 2, 0x33, 0x34, };
+static const char32 __uni_decomp_data_0x325f[] = { 2, 0x33, 0x35, };
+static const char32 __uni_decomp_data_0x3260[] = { 1, 0x1100, };
+static const char32 __uni_decomp_data_0x3261[] = { 1, 0x1102, };
+static const char32 __uni_decomp_data_0x3262[] = { 1, 0x1103, };
+static const char32 __uni_decomp_data_0x3263[] = { 1, 0x1105, };
+static const char32 __uni_decomp_data_0x3264[] = { 1, 0x1106, };
+static const char32 __uni_decomp_data_0x3265[] = { 1, 0x1107, };
+static const char32 __uni_decomp_data_0x3266[] = { 1, 0x1109, };
+static const char32 __uni_decomp_data_0x3267[] = { 1, 0x110b, };
+static const char32 __uni_decomp_data_0x3268[] = { 1, 0x110c, };
+static const char32 __uni_decomp_data_0x3269[] = { 1, 0x110e, };
+static const char32 __uni_decomp_data_0x326a[] = { 1, 0x110f, };
+static const char32 __uni_decomp_data_0x326b[] = { 1, 0x1110, };
+static const char32 __uni_decomp_data_0x326c[] = { 1, 0x1111, };
+static const char32 __uni_decomp_data_0x326d[] = { 1, 0x1112, };
+static const char32 __uni_decomp_data_0x326e[] = { 2, 0x1100, 0x1161, };
+static const char32 __uni_decomp_data_0x326f[] = { 2, 0x1102, 0x1161, };
+static const char32 __uni_decomp_data_0x3270[] = { 2, 0x1103, 0x1161, };
+static const char32 __uni_decomp_data_0x3271[] = { 2, 0x1105, 0x1161, };
+static const char32 __uni_decomp_data_0x3272[] = { 2, 0x1106, 0x1161, };
+static const char32 __uni_decomp_data_0x3273[] = { 2, 0x1107, 0x1161, };
+static const char32 __uni_decomp_data_0x3274[] = { 2, 0x1109, 0x1161, };
+static const char32 __uni_decomp_data_0x3275[] = { 2, 0x110b, 0x1161, };
+static const char32 __uni_decomp_data_0x3276[] = { 2, 0x110c, 0x1161, };
+static const char32 __uni_decomp_data_0x3277[] = { 2, 0x110e, 0x1161, };
+static const char32 __uni_decomp_data_0x3278[] = { 2, 0x110f, 0x1161, };
+static const char32 __uni_decomp_data_0x3279[] = { 2, 0x1110, 0x1161, };
+static const char32 __uni_decomp_data_0x327a[] = { 2, 0x1111, 0x1161, };
+static const char32 __uni_decomp_data_0x327b[] = { 2, 0x1112, 0x1161, };
+static const char32 __uni_decomp_data_0x327c[] = { 5, 0x110e, 0x1161, 0x11b7, 0x1100, 0x1169, };
+static const char32 __uni_decomp_data_0x327d[] = { 4, 0x110c, 0x116e, 0x110b, 0x1174, };
+static const char32 __uni_decomp_data_0x327e[] = { 2, 0x110b, 0x116e, };
 
 
 
@@ -3510,133 +3510,133 @@
 };
 
 
-static const char32 __uni_decomp_data_0x3280[] = { 0x4e00, 0, };
-static const char32 __uni_decomp_data_0x3281[] = { 0x4e8c, 0, };
-static const char32 __uni_decomp_data_0x3282[] = { 0x4e09, 0, };
-static const char32 __uni_decomp_data_0x3283[] = { 0x56db, 0, };
-static const char32 __uni_decomp_data_0x3284[] = { 0x4e94, 0, };
-static const char32 __uni_decomp_data_0x3285[] = { 0x516d, 0, };
-static const char32 __uni_decomp_data_0x3286[] = { 0x4e03, 0, };
-static const char32 __uni_decomp_data_0x3287[] = { 0x516b, 0, };
-static const char32 __uni_decomp_data_0x3288[] = { 0x4e5d, 0, };
-static const char32 __uni_decomp_data_0x3289[] = { 0x5341, 0, };
-static const char32 __uni_decomp_data_0x328a[] = { 0x6708, 0, };
-static const char32 __uni_decomp_data_0x328b[] = { 0x706b, 0, };
-static const char32 __uni_decomp_data_0x328c[] = { 0x6c34, 0, };
-static const char32 __uni_decomp_data_0x328d[] = { 0x6728, 0, };
-static const char32 __uni_decomp_data_0x328e[] = { 0x91d1, 0, };
-static const char32 __uni_decomp_data_0x328f[] = { 0x571f, 0, };
-static const char32 __uni_decomp_data_0x3290[] = { 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x3291[] = { 0x682a, 0, };
-static const char32 __uni_decomp_data_0x3292[] = { 0x6709, 0, };
-static const char32 __uni_decomp_data_0x3293[] = { 0x793e, 0, };
-static const char32 __uni_decomp_data_0x3294[] = { 0x540d, 0, };
-static const char32 __uni_decomp_data_0x3295[] = { 0x7279, 0, };
-static const char32 __uni_decomp_data_0x3296[] = { 0x8ca1, 0, };
-static const char32 __uni_decomp_data_0x3297[] = { 0x795d, 0, };
-static const char32 __uni_decomp_data_0x3298[] = { 0x52b4, 0, };
-static const char32 __uni_decomp_data_0x3299[] = { 0x79d8, 0, };
-static const char32 __uni_decomp_data_0x329a[] = { 0x7537, 0, };
-static const char32 __uni_decomp_data_0x329b[] = { 0x5973, 0, };
-static const char32 __uni_decomp_data_0x329c[] = { 0x9069, 0, };
-static const char32 __uni_decomp_data_0x329d[] = { 0x512a, 0, };
-static const char32 __uni_decomp_data_0x329e[] = { 0x5370, 0, };
-static const char32 __uni_decomp_data_0x329f[] = { 0x6ce8, 0, };
-static const char32 __uni_decomp_data_0x32a0[] = { 0x9805, 0, };
-static const char32 __uni_decomp_data_0x32a1[] = { 0x4f11, 0, };
-static const char32 __uni_decomp_data_0x32a2[] = { 0x5199, 0, };
-static const char32 __uni_decomp_data_0x32a3[] = { 0x6b63, 0, };
-static const char32 __uni_decomp_data_0x32a4[] = { 0x4e0a, 0, };
-static const char32 __uni_decomp_data_0x32a5[] = { 0x4e2d, 0, };
-static const char32 __uni_decomp_data_0x32a6[] = { 0x4e0b, 0, };
-static const char32 __uni_decomp_data_0x32a7[] = { 0x5de6, 0, };
-static const char32 __uni_decomp_data_0x32a8[] = { 0x53f3, 0, };
-static const char32 __uni_decomp_data_0x32a9[] = { 0x533b, 0, };
-static const char32 __uni_decomp_data_0x32aa[] = { 0x5b97, 0, };
-static const char32 __uni_decomp_data_0x32ab[] = { 0x5b66, 0, };
-static const char32 __uni_decomp_data_0x32ac[] = { 0x76e3, 0, };
-static const char32 __uni_decomp_data_0x32ad[] = { 0x4f01, 0, };
-static const char32 __uni_decomp_data_0x32ae[] = { 0x8cc7, 0, };
-static const char32 __uni_decomp_data_0x32af[] = { 0x5354, 0, };
-static const char32 __uni_decomp_data_0x32b0[] = { 0x591c, 0, };
-static const char32 __uni_decomp_data_0x32b1[] = { 0x33, 0x36, 0, };
-static const char32 __uni_decomp_data_0x32b2[] = { 0x33, 0x37, 0, };
-static const char32 __uni_decomp_data_0x32b3[] = { 0x33, 0x38, 0, };
-static const char32 __uni_decomp_data_0x32b4[] = { 0x33, 0x39, 0, };
-static const char32 __uni_decomp_data_0x32b5[] = { 0x34, 0x30, 0, };
-static const char32 __uni_decomp_data_0x32b6[] = { 0x34, 0x31, 0, };
-static const char32 __uni_decomp_data_0x32b7[] = { 0x34, 0x32, 0, };
-static const char32 __uni_decomp_data_0x32b8[] = { 0x34, 0x33, 0, };
-static const char32 __uni_decomp_data_0x32b9[] = { 0x34, 0x34, 0, };
-static const char32 __uni_decomp_data_0x32ba[] = { 0x34, 0x35, 0, };
-static const char32 __uni_decomp_data_0x32bb[] = { 0x34, 0x36, 0, };
-static const char32 __uni_decomp_data_0x32bc[] = { 0x34, 0x37, 0, };
-static const char32 __uni_decomp_data_0x32bd[] = { 0x34, 0x38, 0, };
-static const char32 __uni_decomp_data_0x32be[] = { 0x34, 0x39, 0, };
-static const char32 __uni_decomp_data_0x32bf[] = { 0x35, 0x30, 0, };
-static const char32 __uni_decomp_data_0x32c0[] = { 0x31, 0x6708, 0, };
-static const char32 __uni_decomp_data_0x32c1[] = { 0x32, 0x6708, 0, };
-static const char32 __uni_decomp_data_0x32c2[] = { 0x33, 0x6708, 0, };
-static const char32 __uni_decomp_data_0x32c3[] = { 0x34, 0x6708, 0, };
-static const char32 __uni_decomp_data_0x32c4[] = { 0x35, 0x6708, 0, };
-static const char32 __uni_decomp_data_0x32c5[] = { 0x36, 0x6708, 0, };
-static const char32 __uni_decomp_data_0x32c6[] = { 0x37, 0x6708, 0, };
-static const char32 __uni_decomp_data_0x32c7[] = { 0x38, 0x6708, 0, };
-static const char32 __uni_decomp_data_0x32c8[] = { 0x39, 0x6708, 0, };
-static const char32 __uni_decomp_data_0x32c9[] = { 0x31, 0x30, 0x6708, 0, };
-static const char32 __uni_decomp_data_0x32ca[] = { 0x31, 0x31, 0x6708, 0, };
-static const char32 __uni_decomp_data_0x32cb[] = { 0x31, 0x32, 0x6708, 0, };
-static const char32 __uni_decomp_data_0x32cc[] = { 0x48, 0x67, 0, };
-static const char32 __uni_decomp_data_0x32cd[] = { 0x65, 0x72, 0x67, 0, };
-static const char32 __uni_decomp_data_0x32ce[] = { 0x65, 0x56, 0, };
-static const char32 __uni_decomp_data_0x32cf[] = { 0x4c, 0x54, 0x44, 0, };
-static const char32 __uni_decomp_data_0x32d0[] = { 0x30a2, 0, };
-static const char32 __uni_decomp_data_0x32d1[] = { 0x30a4, 0, };
-static const char32 __uni_decomp_data_0x32d2[] = { 0x30a6, 0, };
-static const char32 __uni_decomp_data_0x32d3[] = { 0x30a8, 0, };
-static const char32 __uni_decomp_data_0x32d4[] = { 0x30aa, 0, };
-static const char32 __uni_decomp_data_0x32d5[] = { 0x30ab, 0, };
-static const char32 __uni_decomp_data_0x32d6[] = { 0x30ad, 0, };
-static const char32 __uni_decomp_data_0x32d7[] = { 0x30af, 0, };
-static const char32 __uni_decomp_data_0x32d8[] = { 0x30b1, 0, };
-static const char32 __uni_decomp_data_0x32d9[] = { 0x30b3, 0, };
-static const char32 __uni_decomp_data_0x32da[] = { 0x30b5, 0, };
-static const char32 __uni_decomp_data_0x32db[] = { 0x30b7, 0, };
-static const char32 __uni_decomp_data_0x32dc[] = { 0x30b9, 0, };
-static const char32 __uni_decomp_data_0x32dd[] = { 0x30bb, 0, };
-static const char32 __uni_decomp_data_0x32de[] = { 0x30bd, 0, };
-static const char32 __uni_decomp_data_0x32df[] = { 0x30bf, 0, };
-static const char32 __uni_decomp_data_0x32e0[] = { 0x30c1, 0, };
-static const char32 __uni_decomp_data_0x32e1[] = { 0x30c4, 0, };
-static const char32 __uni_decomp_data_0x32e2[] = { 0x30c6, 0, };
-static const char32 __uni_decomp_data_0x32e3[] = { 0x30c8, 0, };
-static const char32 __uni_decomp_data_0x32e4[] = { 0x30ca, 0, };
-static const char32 __uni_decomp_data_0x32e5[] = { 0x30cb, 0, };
-static const char32 __uni_decomp_data_0x32e6[] = { 0x30cc, 0, };
-static const char32 __uni_decomp_data_0x32e7[] = { 0x30cd, 0, };
-static const char32 __uni_decomp_data_0x32e8[] = { 0x30ce, 0, };
-static const char32 __uni_decomp_data_0x32e9[] = { 0x30cf, 0, };
-static const char32 __uni_decomp_data_0x32ea[] = { 0x30d2, 0, };
-static const char32 __uni_decomp_data_0x32eb[] = { 0x30d5, 0, };
-static const char32 __uni_decomp_data_0x32ec[] = { 0x30d8, 0, };
-static const char32 __uni_decomp_data_0x32ed[] = { 0x30db, 0, };
-static const char32 __uni_decomp_data_0x32ee[] = { 0x30de, 0, };
-static const char32 __uni_decomp_data_0x32ef[] = { 0x30df, 0, };
-static const char32 __uni_decomp_data_0x32f0[] = { 0x30e0, 0, };
-static const char32 __uni_decomp_data_0x32f1[] = { 0x30e1, 0, };
-static const char32 __uni_decomp_data_0x32f2[] = { 0x30e2, 0, };
-static const char32 __uni_decomp_data_0x32f3[] = { 0x30e4, 0, };
-static const char32 __uni_decomp_data_0x32f4[] = { 0x30e6, 0, };
-static const char32 __uni_decomp_data_0x32f5[] = { 0x30e8, 0, };
-static const char32 __uni_decomp_data_0x32f6[] = { 0x30e9, 0, };
-static const char32 __uni_decomp_data_0x32f7[] = { 0x30ea, 0, };
-static const char32 __uni_decomp_data_0x32f8[] = { 0x30eb, 0, };
-static const char32 __uni_decomp_data_0x32f9[] = { 0x30ec, 0, };
-static const char32 __uni_decomp_data_0x32fa[] = { 0x30ed, 0, };
-static const char32 __uni_decomp_data_0x32fb[] = { 0x30ef, 0, };
-static const char32 __uni_decomp_data_0x32fc[] = { 0x30f0, 0, };
-static const char32 __uni_decomp_data_0x32fd[] = { 0x30f1, 0, };
-static const char32 __uni_decomp_data_0x32fe[] = { 0x30f2, 0, };
+static const char32 __uni_decomp_data_0x3280[] = { 1, 0x4e00, };
+static const char32 __uni_decomp_data_0x3281[] = { 1, 0x4e8c, };
+static const char32 __uni_decomp_data_0x3282[] = { 1, 0x4e09, };
+static const char32 __uni_decomp_data_0x3283[] = { 1, 0x56db, };
+static const char32 __uni_decomp_data_0x3284[] = { 1, 0x4e94, };
+static const char32 __uni_decomp_data_0x3285[] = { 1, 0x516d, };
+static const char32 __uni_decomp_data_0x3286[] = { 1, 0x4e03, };
+static const char32 __uni_decomp_data_0x3287[] = { 1, 0x516b, };
+static const char32 __uni_decomp_data_0x3288[] = { 1, 0x4e5d, };
+static const char32 __uni_decomp_data_0x3289[] = { 1, 0x5341, };
+static const char32 __uni_decomp_data_0x328a[] = { 1, 0x6708, };
+static const char32 __uni_decomp_data_0x328b[] = { 1, 0x706b, };
+static const char32 __uni_decomp_data_0x328c[] = { 1, 0x6c34, };
+static const char32 __uni_decomp_data_0x328d[] = { 1, 0x6728, };
+static const char32 __uni_decomp_data_0x328e[] = { 1, 0x91d1, };
+static const char32 __uni_decomp_data_0x328f[] = { 1, 0x571f, };
+static const char32 __uni_decomp_data_0x3290[] = { 1, 0x65e5, };
+static const char32 __uni_decomp_data_0x3291[] = { 1, 0x682a, };
+static const char32 __uni_decomp_data_0x3292[] = { 1, 0x6709, };
+static const char32 __uni_decomp_data_0x3293[] = { 1, 0x793e, };
+static const char32 __uni_decomp_data_0x3294[] = { 1, 0x540d, };
+static const char32 __uni_decomp_data_0x3295[] = { 1, 0x7279, };
+static const char32 __uni_decomp_data_0x3296[] = { 1, 0x8ca1, };
+static const char32 __uni_decomp_data_0x3297[] = { 1, 0x795d, };
+static const char32 __uni_decomp_data_0x3298[] = { 1, 0x52b4, };
+static const char32 __uni_decomp_data_0x3299[] = { 1, 0x79d8, };
+static const char32 __uni_decomp_data_0x329a[] = { 1, 0x7537, };
+static const char32 __uni_decomp_data_0x329b[] = { 1, 0x5973, };
+static const char32 __uni_decomp_data_0x329c[] = { 1, 0x9069, };
+static const char32 __uni_decomp_data_0x329d[] = { 1, 0x512a, };
+static const char32 __uni_decomp_data_0x329e[] = { 1, 0x5370, };
+static const char32 __uni_decomp_data_0x329f[] = { 1, 0x6ce8, };
+static const char32 __uni_decomp_data_0x32a0[] = { 1, 0x9805, };
+static const char32 __uni_decomp_data_0x32a1[] = { 1, 0x4f11, };
+static const char32 __uni_decomp_data_0x32a2[] = { 1, 0x5199, };
+static const char32 __uni_decomp_data_0x32a3[] = { 1, 0x6b63, };
+static const char32 __uni_decomp_data_0x32a4[] = { 1, 0x4e0a, };
+static const char32 __uni_decomp_data_0x32a5[] = { 1, 0x4e2d, };
+static const char32 __uni_decomp_data_0x32a6[] = { 1, 0x4e0b, };
+static const char32 __uni_decomp_data_0x32a7[] = { 1, 0x5de6, };
+static const char32 __uni_decomp_data_0x32a8[] = { 1, 0x53f3, };
+static const char32 __uni_decomp_data_0x32a9[] = { 1, 0x533b, };
+static const char32 __uni_decomp_data_0x32aa[] = { 1, 0x5b97, };
+static const char32 __uni_decomp_data_0x32ab[] = { 1, 0x5b66, };
+static const char32 __uni_decomp_data_0x32ac[] = { 1, 0x76e3, };
+static const char32 __uni_decomp_data_0x32ad[] = { 1, 0x4f01, };
+static const char32 __uni_decomp_data_0x32ae[] = { 1, 0x8cc7, };
+static const char32 __uni_decomp_data_0x32af[] = { 1, 0x5354, };
+static const char32 __uni_decomp_data_0x32b0[] = { 1, 0x591c, };
+static const char32 __uni_decomp_data_0x32b1[] = { 2, 0x33, 0x36, };
+static const char32 __uni_decomp_data_0x32b2[] = { 2, 0x33, 0x37, };
+static const char32 __uni_decomp_data_0x32b3[] = { 2, 0x33, 0x38, };
+static const char32 __uni_decomp_data_0x32b4[] = { 2, 0x33, 0x39, };
+static const char32 __uni_decomp_data_0x32b5[] = { 2, 0x34, 0x30, };
+static const char32 __uni_decomp_data_0x32b6[] = { 2, 0x34, 0x31, };
+static const char32 __uni_decomp_data_0x32b7[] = { 2, 0x34, 0x32, };
+static const char32 __uni_decomp_data_0x32b8[] = { 2, 0x34, 0x33, };
+static const char32 __uni_decomp_data_0x32b9[] = { 2, 0x34, 0x34, };
+static const char32 __uni_decomp_data_0x32ba[] = { 2, 0x34, 0x35, };
+static const char32 __uni_decomp_data_0x32bb[] = { 2, 0x34, 0x36, };
+static const char32 __uni_decomp_data_0x32bc[] = { 2, 0x34, 0x37, };
+static const char32 __uni_decomp_data_0x32bd[] = { 2, 0x34, 0x38, };
+static const char32 __uni_decomp_data_0x32be[] = { 2, 0x34, 0x39, };
+static const char32 __uni_decomp_data_0x32bf[] = { 2, 0x35, 0x30, };
+static const char32 __uni_decomp_data_0x32c0[] = { 2, 0x31, 0x6708, };
+static const char32 __uni_decomp_data_0x32c1[] = { 2, 0x32, 0x6708, };
+static const char32 __uni_decomp_data_0x32c2[] = { 2, 0x33, 0x6708, };
+static const char32 __uni_decomp_data_0x32c3[] = { 2, 0x34, 0x6708, };
+static const char32 __uni_decomp_data_0x32c4[] = { 2, 0x35, 0x6708, };
+static const char32 __uni_decomp_data_0x32c5[] = { 2, 0x36, 0x6708, };
+static const char32 __uni_decomp_data_0x32c6[] = { 2, 0x37, 0x6708, };
+static const char32 __uni_decomp_data_0x32c7[] = { 2, 0x38, 0x6708, };
+static const char32 __uni_decomp_data_0x32c8[] = { 2, 0x39, 0x6708, };
+static const char32 __uni_decomp_data_0x32c9[] = { 3, 0x31, 0x30, 0x6708, };
+static const char32 __uni_decomp_data_0x32ca[] = { 3, 0x31, 0x31, 0x6708, };
+static const char32 __uni_decomp_data_0x32cb[] = { 3, 0x31, 0x32, 0x6708, };
+static const char32 __uni_decomp_data_0x32cc[] = { 2, 0x48, 0x67, };
+static const char32 __uni_decomp_data_0x32cd[] = { 3, 0x65, 0x72, 0x67, };
+static const char32 __uni_decomp_data_0x32ce[] = { 2, 0x65, 0x56, };
+static const char32 __uni_decomp_data_0x32cf[] = { 3, 0x4c, 0x54, 0x44, };
+static const char32 __uni_decomp_data_0x32d0[] = { 1, 0x30a2, };
+static const char32 __uni_decomp_data_0x32d1[] = { 1, 0x30a4, };
+static const char32 __uni_decomp_data_0x32d2[] = { 1, 0x30a6, };
+static const char32 __uni_decomp_data_0x32d3[] = { 1, 0x30a8, };
+static const char32 __uni_decomp_data_0x32d4[] = { 1, 0x30aa, };
+static const char32 __uni_decomp_data_0x32d5[] = { 1, 0x30ab, };
+static const char32 __uni_decomp_data_0x32d6[] = { 1, 0x30ad, };
+static const char32 __uni_decomp_data_0x32d7[] = { 1, 0x30af, };
+static const char32 __uni_decomp_data_0x32d8[] = { 1, 0x30b1, };
+static const char32 __uni_decomp_data_0x32d9[] = { 1, 0x30b3, };
+static const char32 __uni_decomp_data_0x32da[] = { 1, 0x30b5, };
+static const char32 __uni_decomp_data_0x32db[] = { 1, 0x30b7, };
+static const char32 __uni_decomp_data_0x32dc[] = { 1, 0x30b9, };
+static const char32 __uni_decomp_data_0x32dd[] = { 1, 0x30bb, };
+static const char32 __uni_decomp_data_0x32de[] = { 1, 0x30bd, };
+static const char32 __uni_decomp_data_0x32df[] = { 1, 0x30bf, };
+static const char32 __uni_decomp_data_0x32e0[] = { 1, 0x30c1, };
+static const char32 __uni_decomp_data_0x32e1[] = { 1, 0x30c4, };
+static const char32 __uni_decomp_data_0x32e2[] = { 1, 0x30c6, };
+static const char32 __uni_decomp_data_0x32e3[] = { 1, 0x30c8, };
+static const char32 __uni_decomp_data_0x32e4[] = { 1, 0x30ca, };
+static const char32 __uni_decomp_data_0x32e5[] = { 1, 0x30cb, };
+static const char32 __uni_decomp_data_0x32e6[] = { 1, 0x30cc, };
+static const char32 __uni_decomp_data_0x32e7[] = { 1, 0x30cd, };
+static const char32 __uni_decomp_data_0x32e8[] = { 1, 0x30ce, };
+static const char32 __uni_decomp_data_0x32e9[] = { 1, 0x30cf, };
+static const char32 __uni_decomp_data_0x32ea[] = { 1, 0x30d2, };
+static const char32 __uni_decomp_data_0x32eb[] = { 1, 0x30d5, };
+static const char32 __uni_decomp_data_0x32ec[] = { 1, 0x30d8, };
+static const char32 __uni_decomp_data_0x32ed[] = { 1, 0x30db, };
+static const char32 __uni_decomp_data_0x32ee[] = { 1, 0x30de, };
+static const char32 __uni_decomp_data_0x32ef[] = { 1, 0x30df, };
+static const char32 __uni_decomp_data_0x32f0[] = { 1, 0x30e0, };
+static const char32 __uni_decomp_data_0x32f1[] = { 1, 0x30e1, };
+static const char32 __uni_decomp_data_0x32f2[] = { 1, 0x30e2, };
+static const char32 __uni_decomp_data_0x32f3[] = { 1, 0x30e4, };
+static const char32 __uni_decomp_data_0x32f4[] = { 1, 0x30e6, };
+static const char32 __uni_decomp_data_0x32f5[] = { 1, 0x30e8, };
+static const char32 __uni_decomp_data_0x32f6[] = { 1, 0x30e9, };
+static const char32 __uni_decomp_data_0x32f7[] = { 1, 0x30ea, };
+static const char32 __uni_decomp_data_0x32f8[] = { 1, 0x30eb, };
+static const char32 __uni_decomp_data_0x32f9[] = { 1, 0x30ec, };
+static const char32 __uni_decomp_data_0x32fa[] = { 1, 0x30ed, };
+static const char32 __uni_decomp_data_0x32fb[] = { 1, 0x30ef, };
+static const char32 __uni_decomp_data_0x32fc[] = { 1, 0x30f0, };
+static const char32 __uni_decomp_data_0x32fd[] = { 1, 0x30f1, };
+static const char32 __uni_decomp_data_0x32fe[] = { 1, 0x30f2, };
 
 
 
@@ -5310,134 +5310,134 @@
 };
 
 
-static const char32 __uni_decomp_data_0x3300[] = { 0x30a2, 0x30d1, 0x30fc, 0x30c8, 0, };
-static const char32 __uni_decomp_data_0x3301[] = { 0x30a2, 0x30eb, 0x30d5, 0x30a1, 0, };
-static const char32 __uni_decomp_data_0x3302[] = { 0x30a2, 0x30f3, 0x30da, 0x30a2, 0, };
-static const char32 __uni_decomp_data_0x3303[] = { 0x30a2, 0x30fc, 0x30eb, 0, };
-static const char32 __uni_decomp_data_0x3304[] = { 0x30a4, 0x30cb, 0x30f3, 0x30b0, 0, };
-static const char32 __uni_decomp_data_0x3305[] = { 0x30a4, 0x30f3, 0x30c1, 0, };
-static const char32 __uni_decomp_data_0x3306[] = { 0x30a6, 0x30a9, 0x30f3, 0, };
-static const char32 __uni_decomp_data_0x3307[] = { 0x30a8, 0x30b9, 0x30af, 0x30fc, 0x30c9, 0, };
-static const char32 __uni_decomp_data_0x3308[] = { 0x30a8, 0x30fc, 0x30ab, 0x30fc, 0, };
-static const char32 __uni_decomp_data_0x3309[] = { 0x30aa, 0x30f3, 0x30b9, 0, };
-static const char32 __uni_decomp_data_0x330a[] = { 0x30aa, 0x30fc, 0x30e0, 0, };
-static const char32 __uni_decomp_data_0x330b[] = { 0x30ab, 0x30a4, 0x30ea, 0, };
-static const char32 __uni_decomp_data_0x330c[] = { 0x30ab, 0x30e9, 0x30c3, 0x30c8, 0, };
-static const char32 __uni_decomp_data_0x330d[] = { 0x30ab, 0x30ed, 0x30ea, 0x30fc, 0, };
-static const char32 __uni_decomp_data_0x330e[] = { 0x30ac, 0x30ed, 0x30f3, 0, };
-static const char32 __uni_decomp_data_0x330f[] = { 0x30ac, 0x30f3, 0x30de, 0, };
-static const char32 __uni_decomp_data_0x3310[] = { 0x30ae, 0x30ac, 0, };
-static const char32 __uni_decomp_data_0x3311[] = { 0x30ae, 0x30cb, 0x30fc, 0, };
-static const char32 __uni_decomp_data_0x3312[] = { 0x30ad, 0x30e5, 0x30ea, 0x30fc, 0, };
-static const char32 __uni_decomp_data_0x3313[] = { 0x30ae, 0x30eb, 0x30c0, 0x30fc, 0, };
-static const char32 __uni_decomp_data_0x3314[] = { 0x30ad, 0x30ed, 0, };
-static const char32 __uni_decomp_data_0x3315[] = { 0x30ad, 0x30ed, 0x30b0, 0x30e9, 0x30e0, 0, };
-static const char32 __uni_decomp_data_0x3316[] = { 0x30ad, 0x30ed, 0x30e1, 0x30fc, 0x30c8, 0x30eb, 0, };
-static const char32 __uni_decomp_data_0x3317[] = { 0x30ad, 0x30ed, 0x30ef, 0x30c3, 0x30c8, 0, };
-static const char32 __uni_decomp_data_0x3318[] = { 0x30b0, 0x30e9, 0x30e0, 0, };
-static const char32 __uni_decomp_data_0x3319[] = { 0x30b0, 0x30e9, 0x30e0, 0x30c8, 0x30f3, 0, };
-static const char32 __uni_decomp_data_0x331a[] = { 0x30af, 0x30eb, 0x30bc, 0x30a4, 0x30ed, 0, };
-static const char32 __uni_decomp_data_0x331b[] = { 0x30af, 0x30ed, 0x30fc, 0x30cd, 0, };
-static const char32 __uni_decomp_data_0x331c[] = { 0x30b1, 0x30fc, 0x30b9, 0, };
-static const char32 __uni_decomp_data_0x331d[] = { 0x30b3, 0x30eb, 0x30ca, 0, };
-static const char32 __uni_decomp_data_0x331e[] = { 0x30b3, 0x30fc, 0x30dd, 0, };
-static const char32 __uni_decomp_data_0x331f[] = { 0x30b5, 0x30a4, 0x30af, 0x30eb, 0, };
-static const char32 __uni_decomp_data_0x3320[] = { 0x30b5, 0x30f3, 0x30c1, 0x30fc, 0x30e0, 0, };
-static const char32 __uni_decomp_data_0x3321[] = { 0x30b7, 0x30ea, 0x30f3, 0x30b0, 0, };
-static const char32 __uni_decomp_data_0x3322[] = { 0x30bb, 0x30f3, 0x30c1, 0, };
-static const char32 __uni_decomp_data_0x3323[] = { 0x30bb, 0x30f3, 0x30c8, 0, };
-static const char32 __uni_decomp_data_0x3324[] = { 0x30c0, 0x30fc, 0x30b9, 0, };
-static const char32 __uni_decomp_data_0x3325[] = { 0x30c7, 0x30b7, 0, };
-static const char32 __uni_decomp_data_0x3326[] = { 0x30c9, 0x30eb, 0, };
-static const char32 __uni_decomp_data_0x3327[] = { 0x30c8, 0x30f3, 0, };
-static const char32 __uni_decomp_data_0x3328[] = { 0x30ca, 0x30ce, 0, };
-static const char32 __uni_decomp_data_0x3329[] = { 0x30ce, 0x30c3, 0x30c8, 0, };
-static const char32 __uni_decomp_data_0x332a[] = { 0x30cf, 0x30a4, 0x30c4, 0, };
-static const char32 __uni_decomp_data_0x332b[] = { 0x30d1, 0x30fc, 0x30bb, 0x30f3, 0x30c8, 0, };
-static const char32 __uni_decomp_data_0x332c[] = { 0x30d1, 0x30fc, 0x30c4, 0, };
-static const char32 __uni_decomp_data_0x332d[] = { 0x30d0, 0x30fc, 0x30ec, 0x30eb, 0, };
-static const char32 __uni_decomp_data_0x332e[] = { 0x30d4, 0x30a2, 0x30b9, 0x30c8, 0x30eb, 0, };
-static const char32 __uni_decomp_data_0x332f[] = { 0x30d4, 0x30af, 0x30eb, 0, };
-static const char32 __uni_decomp_data_0x3330[] = { 0x30d4, 0x30b3, 0, };
-static const char32 __uni_decomp_data_0x3331[] = { 0x30d3, 0x30eb, 0, };
-static const char32 __uni_decomp_data_0x3332[] = { 0x30d5, 0x30a1, 0x30e9, 0x30c3, 0x30c9, 0, };
-static const char32 __uni_decomp_data_0x3333[] = { 0x30d5, 0x30a3, 0x30fc, 0x30c8, 0, };
-static const char32 __uni_decomp_data_0x3334[] = { 0x30d6, 0x30c3, 0x30b7, 0x30a7, 0x30eb, 0, };
-static const char32 __uni_decomp_data_0x3335[] = { 0x30d5, 0x30e9, 0x30f3, 0, };
-static const char32 __uni_decomp_data_0x3336[] = { 0x30d8, 0x30af, 0x30bf, 0x30fc, 0x30eb, 0, };
-static const char32 __uni_decomp_data_0x3337[] = { 0x30da, 0x30bd, 0, };
-static const char32 __uni_decomp_data_0x3338[] = { 0x30da, 0x30cb, 0x30d2, 0, };
-static const char32 __uni_decomp_data_0x3339[] = { 0x30d8, 0x30eb, 0x30c4, 0, };
-static const char32 __uni_decomp_data_0x333a[] = { 0x30da, 0x30f3, 0x30b9, 0, };
-static const char32 __uni_decomp_data_0x333b[] = { 0x30da, 0x30fc, 0x30b8, 0, };
-static const char32 __uni_decomp_data_0x333c[] = { 0x30d9, 0x30fc, 0x30bf, 0, };
-static const char32 __uni_decomp_data_0x333d[] = { 0x30dd, 0x30a4, 0x30f3, 0x30c8, 0, };
-static const char32 __uni_decomp_data_0x333e[] = { 0x30dc, 0x30eb, 0x30c8, 0, };
-static const char32 __uni_decomp_data_0x333f[] = { 0x30db, 0x30f3, 0, };
-static const char32 __uni_decomp_data_0x3340[] = { 0x30dd, 0x30f3, 0x30c9, 0, };
-static const char32 __uni_decomp_data_0x3341[] = { 0x30db, 0x30fc, 0x30eb, 0, };
-static const char32 __uni_decomp_data_0x3342[] = { 0x30db, 0x30fc, 0x30f3, 0, };
-static const char32 __uni_decomp_data_0x3343[] = { 0x30de, 0x30a4, 0x30af, 0x30ed, 0, };
-static const char32 __uni_decomp_data_0x3344[] = { 0x30de, 0x30a4, 0x30eb, 0, };
-static const char32 __uni_decomp_data_0x3345[] = { 0x30de, 0x30c3, 0x30cf, 0, };
-static const char32 __uni_decomp_data_0x3346[] = { 0x30de, 0x30eb, 0x30af, 0, };
-static const char32 __uni_decomp_data_0x3347[] = { 0x30de, 0x30f3, 0x30b7, 0x30e7, 0x30f3, 0, };
-static const char32 __uni_decomp_data_0x3348[] = { 0x30df, 0x30af, 0x30ed, 0x30f3, 0, };
-static const char32 __uni_decomp_data_0x3349[] = { 0x30df, 0x30ea, 0, };
-static const char32 __uni_decomp_data_0x334a[] = { 0x30df, 0x30ea, 0x30d0, 0x30fc, 0x30eb, 0, };
-static const char32 __uni_decomp_data_0x334b[] = { 0x30e1, 0x30ac, 0, };
-static const char32 __uni_decomp_data_0x334c[] = { 0x30e1, 0x30ac, 0x30c8, 0x30f3, 0, };
-static const char32 __uni_decomp_data_0x334d[] = { 0x30e1, 0x30fc, 0x30c8, 0x30eb, 0, };
-static const char32 __uni_decomp_data_0x334e[] = { 0x30e4, 0x30fc, 0x30c9, 0, };
-static const char32 __uni_decomp_data_0x334f[] = { 0x30e4, 0x30fc, 0x30eb, 0, };
-static const char32 __uni_decomp_data_0x3350[] = { 0x30e6, 0x30a2, 0x30f3, 0, };
-static const char32 __uni_decomp_data_0x3351[] = { 0x30ea, 0x30c3, 0x30c8, 0x30eb, 0, };
-static const char32 __uni_decomp_data_0x3352[] = { 0x30ea, 0x30e9, 0, };
-static const char32 __uni_decomp_data_0x3353[] = { 0x30eb, 0x30d4, 0x30fc, 0, };
-static const char32 __uni_decomp_data_0x3354[] = { 0x30eb, 0x30fc, 0x30d6, 0x30eb, 0, };
-static const char32 __uni_decomp_data_0x3355[] = { 0x30ec, 0x30e0, 0, };
-static const char32 __uni_decomp_data_0x3356[] = { 0x30ec, 0x30f3, 0x30c8, 0x30b2, 0x30f3, 0, };
-static const char32 __uni_decomp_data_0x3357[] = { 0x30ef, 0x30c3, 0x30c8, 0, };
-static const char32 __uni_decomp_data_0x3358[] = { 0x30, 0x70b9, 0, };
-static const char32 __uni_decomp_data_0x3359[] = { 0x31, 0x70b9, 0, };
-static const char32 __uni_decomp_data_0x335a[] = { 0x32, 0x70b9, 0, };
-static const char32 __uni_decomp_data_0x335b[] = { 0x33, 0x70b9, 0, };
-static const char32 __uni_decomp_data_0x335c[] = { 0x34, 0x70b9, 0, };
-static const char32 __uni_decomp_data_0x335d[] = { 0x35, 0x70b9, 0, };
-static const char32 __uni_decomp_data_0x335e[] = { 0x36, 0x70b9, 0, };
-static const char32 __uni_decomp_data_0x335f[] = { 0x37, 0x70b9, 0, };
-static const char32 __uni_decomp_data_0x3360[] = { 0x38, 0x70b9, 0, };
-static const char32 __uni_decomp_data_0x3361[] = { 0x39, 0x70b9, 0, };
-static const char32 __uni_decomp_data_0x3362[] = { 0x31, 0x30, 0x70b9, 0, };
-static const char32 __uni_decomp_data_0x3363[] = { 0x31, 0x31, 0x70b9, 0, };
-static const char32 __uni_decomp_data_0x3364[] = { 0x31, 0x32, 0x70b9, 0, };
-static const char32 __uni_decomp_data_0x3365[] = { 0x31, 0x33, 0x70b9, 0, };
-static const char32 __uni_decomp_data_0x3366[] = { 0x31, 0x34, 0x70b9, 0, };
-static const char32 __uni_decomp_data_0x3367[] = { 0x31, 0x35, 0x70b9, 0, };
-static const char32 __uni_decomp_data_0x3368[] = { 0x31, 0x36, 0x70b9, 0, };
-static const char32 __uni_decomp_data_0x3369[] = { 0x31, 0x37, 0x70b9, 0, };
-static const char32 __uni_decomp_data_0x336a[] = { 0x31, 0x38, 0x70b9, 0, };
-static const char32 __uni_decomp_data_0x336b[] = { 0x31, 0x39, 0x70b9, 0, };
-static const char32 __uni_decomp_data_0x336c[] = { 0x32, 0x30, 0x70b9, 0, };
-static const char32 __uni_decomp_data_0x336d[] = { 0x32, 0x31, 0x70b9, 0, };
-static const char32 __uni_decomp_data_0x336e[] = { 0x32, 0x32, 0x70b9, 0, };
-static const char32 __uni_decomp_data_0x336f[] = { 0x32, 0x33, 0x70b9, 0, };
-static const char32 __uni_decomp_data_0x3370[] = { 0x32, 0x34, 0x70b9, 0, };
-static const char32 __uni_decomp_data_0x3371[] = { 0x68, 0x50, 0x61, 0, };
-static const char32 __uni_decomp_data_0x3372[] = { 0x64, 0x61, 0, };
-static const char32 __uni_decomp_data_0x3373[] = { 0x41, 0x55, 0, };
-static const char32 __uni_decomp_data_0x3374[] = { 0x62, 0x61, 0x72, 0, };
-static const char32 __uni_decomp_data_0x3375[] = { 0x6f, 0x56, 0, };
-static const char32 __uni_decomp_data_0x3376[] = { 0x70, 0x63, 0, };
-static const char32 __uni_decomp_data_0x3377[] = { 0x64, 0x6d, 0, };
-static const char32 __uni_decomp_data_0x3378[] = { 0x64, 0x6d, 0xb2, 0, };
-static const char32 __uni_decomp_data_0x3379[] = { 0x64, 0x6d, 0xb3, 0, };
-static const char32 __uni_decomp_data_0x337a[] = { 0x49, 0x55, 0, };
-static const char32 __uni_decomp_data_0x337b[] = { 0x5e73, 0x6210, 0, };
-static const char32 __uni_decomp_data_0x337c[] = { 0x662d, 0x548c, 0, };
-static const char32 __uni_decomp_data_0x337d[] = { 0x5927, 0x6b63, 0, };
-static const char32 __uni_decomp_data_0x337e[] = { 0x660e, 0x6cbb, 0, };
-static const char32 __uni_decomp_data_0x337f[] = { 0x682a, 0x5f0f, 0x4f1a, 0x793e, 0, };
+static const char32 __uni_decomp_data_0x3300[] = { 4, 0x30a2, 0x30d1, 0x30fc, 0x30c8, };
+static const char32 __uni_decomp_data_0x3301[] = { 4, 0x30a2, 0x30eb, 0x30d5, 0x30a1, };
+static const char32 __uni_decomp_data_0x3302[] = { 4, 0x30a2, 0x30f3, 0x30da, 0x30a2, };
+static const char32 __uni_decomp_data_0x3303[] = { 3, 0x30a2, 0x30fc, 0x30eb, };
+static const char32 __uni_decomp_data_0x3304[] = { 4, 0x30a4, 0x30cb, 0x30f3, 0x30b0, };
+static const char32 __uni_decomp_data_0x3305[] = { 3, 0x30a4, 0x30f3, 0x30c1, };
+static const char32 __uni_decomp_data_0x3306[] = { 3, 0x30a6, 0x30a9, 0x30f3, };
+static const char32 __uni_decomp_data_0x3307[] = { 5, 0x30a8, 0x30b9, 0x30af, 0x30fc, 0x30c9, };
+static const char32 __uni_decomp_data_0x3308[] = { 4, 0x30a8, 0x30fc, 0x30ab, 0x30fc, };
+static const char32 __uni_decomp_data_0x3309[] = { 3, 0x30aa, 0x30f3, 0x30b9, };
+static const char32 __uni_decomp_data_0x330a[] = { 3, 0x30aa, 0x30fc, 0x30e0, };
+static const char32 __uni_decomp_data_0x330b[] = { 3, 0x30ab, 0x30a4, 0x30ea, };
+static const char32 __uni_decomp_data_0x330c[] = { 4, 0x30ab, 0x30e9, 0x30c3, 0x30c8, };
+static const char32 __uni_decomp_data_0x330d[] = { 4, 0x30ab, 0x30ed, 0x30ea, 0x30fc, };
+static const char32 __uni_decomp_data_0x330e[] = { 3, 0x30ac, 0x30ed, 0x30f3, };
+static const char32 __uni_decomp_data_0x330f[] = { 3, 0x30ac, 0x30f3, 0x30de, };
+static const char32 __uni_decomp_data_0x3310[] = { 2, 0x30ae, 0x30ac, };
+static const char32 __uni_decomp_data_0x3311[] = { 3, 0x30ae, 0x30cb, 0x30fc, };
+static const char32 __uni_decomp_data_0x3312[] = { 4, 0x30ad, 0x30e5, 0x30ea, 0x30fc, };
+static const char32 __uni_decomp_data_0x3313[] = { 4, 0x30ae, 0x30eb, 0x30c0, 0x30fc, };
+static const char32 __uni_decomp_data_0x3314[] = { 2, 0x30ad, 0x30ed, };
+static const char32 __uni_decomp_data_0x3315[] = { 5, 0x30ad, 0x30ed, 0x30b0, 0x30e9, 0x30e0, };
+static const char32 __uni_decomp_data_0x3316[] = { 6, 0x30ad, 0x30ed, 0x30e1, 0x30fc, 0x30c8, 0x30eb, };
+static const char32 __uni_decomp_data_0x3317[] = { 5, 0x30ad, 0x30ed, 0x30ef, 0x30c3, 0x30c8, };
+static const char32 __uni_decomp_data_0x3318[] = { 3, 0x30b0, 0x30e9, 0x30e0, };
+static const char32 __uni_decomp_data_0x3319[] = { 5, 0x30b0, 0x30e9, 0x30e0, 0x30c8, 0x30f3, };
+static const char32 __uni_decomp_data_0x331a[] = { 5, 0x30af, 0x30eb, 0x30bc, 0x30a4, 0x30ed, };
+static const char32 __uni_decomp_data_0x331b[] = { 4, 0x30af, 0x30ed, 0x30fc, 0x30cd, };
+static const char32 __uni_decomp_data_0x331c[] = { 3, 0x30b1, 0x30fc, 0x30b9, };
+static const char32 __uni_decomp_data_0x331d[] = { 3, 0x30b3, 0x30eb, 0x30ca, };
+static const char32 __uni_decomp_data_0x331e[] = { 3, 0x30b3, 0x30fc, 0x30dd, };
+static const char32 __uni_decomp_data_0x331f[] = { 4, 0x30b5, 0x30a4, 0x30af, 0x30eb, };
+static const char32 __uni_decomp_data_0x3320[] = { 5, 0x30b5, 0x30f3, 0x30c1, 0x30fc, 0x30e0, };
+static const char32 __uni_decomp_data_0x3321[] = { 4, 0x30b7, 0x30ea, 0x30f3, 0x30b0, };
+static const char32 __uni_decomp_data_0x3322[] = { 3, 0x30bb, 0x30f3, 0x30c1, };
+static const char32 __uni_decomp_data_0x3323[] = { 3, 0x30bb, 0x30f3, 0x30c8, };
+static const char32 __uni_decomp_data_0x3324[] = { 3, 0x30c0, 0x30fc, 0x30b9, };
+static const char32 __uni_decomp_data_0x3325[] = { 2, 0x30c7, 0x30b7, };
+static const char32 __uni_decomp_data_0x3326[] = { 2, 0x30c9, 0x30eb, };
+static const char32 __uni_decomp_data_0x3327[] = { 2, 0x30c8, 0x30f3, };
+static const char32 __uni_decomp_data_0x3328[] = { 2, 0x30ca, 0x30ce, };
+static const char32 __uni_decomp_data_0x3329[] = { 3, 0x30ce, 0x30c3, 0x30c8, };
+static const char32 __uni_decomp_data_0x332a[] = { 3, 0x30cf, 0x30a4, 0x30c4, };
+static const char32 __uni_decomp_data_0x332b[] = { 5, 0x30d1, 0x30fc, 0x30bb, 0x30f3, 0x30c8, };
+static const char32 __uni_decomp_data_0x332c[] = { 3, 0x30d1, 0x30fc, 0x30c4, };
+static const char32 __uni_decomp_data_0x332d[] = { 4, 0x30d0, 0x30fc, 0x30ec, 0x30eb, };
+static const char32 __uni_decomp_data_0x332e[] = { 5, 0x30d4, 0x30a2, 0x30b9, 0x30c8, 0x30eb, };
+static const char32 __uni_decomp_data_0x332f[] = { 3, 0x30d4, 0x30af, 0x30eb, };
+static const char32 __uni_decomp_data_0x3330[] = { 2, 0x30d4, 0x30b3, };
+static const char32 __uni_decomp_data_0x3331[] = { 2, 0x30d3, 0x30eb, };
+static const char32 __uni_decomp_data_0x3332[] = { 5, 0x30d5, 0x30a1, 0x30e9, 0x30c3, 0x30c9, };
+static const char32 __uni_decomp_data_0x3333[] = { 4, 0x30d5, 0x30a3, 0x30fc, 0x30c8, };
+static const char32 __uni_decomp_data_0x3334[] = { 5, 0x30d6, 0x30c3, 0x30b7, 0x30a7, 0x30eb, };
+static const char32 __uni_decomp_data_0x3335[] = { 3, 0x30d5, 0x30e9, 0x30f3, };
+static const char32 __uni_decomp_data_0x3336[] = { 5, 0x30d8, 0x30af, 0x30bf, 0x30fc, 0x30eb, };
+static const char32 __uni_decomp_data_0x3337[] = { 2, 0x30da, 0x30bd, };
+static const char32 __uni_decomp_data_0x3338[] = { 3, 0x30da, 0x30cb, 0x30d2, };
+static const char32 __uni_decomp_data_0x3339[] = { 3, 0x30d8, 0x30eb, 0x30c4, };
+static const char32 __uni_decomp_data_0x333a[] = { 3, 0x30da, 0x30f3, 0x30b9, };
+static const char32 __uni_decomp_data_0x333b[] = { 3, 0x30da, 0x30fc, 0x30b8, };
+static const char32 __uni_decomp_data_0x333c[] = { 3, 0x30d9, 0x30fc, 0x30bf, };
+static const char32 __uni_decomp_data_0x333d[] = { 4, 0x30dd, 0x30a4, 0x30f3, 0x30c8, };
+static const char32 __uni_decomp_data_0x333e[] = { 3, 0x30dc, 0x30eb, 0x30c8, };
+static const char32 __uni_decomp_data_0x333f[] = { 2, 0x30db, 0x30f3, };
+static const char32 __uni_decomp_data_0x3340[] = { 3, 0x30dd, 0x30f3, 0x30c9, };
+static const char32 __uni_decomp_data_0x3341[] = { 3, 0x30db, 0x30fc, 0x30eb, };
+static const char32 __uni_decomp_data_0x3342[] = { 3, 0x30db, 0x30fc, 0x30f3, };
+static const char32 __uni_decomp_data_0x3343[] = { 4, 0x30de, 0x30a4, 0x30af, 0x30ed, };
+static const char32 __uni_decomp_data_0x3344[] = { 3, 0x30de, 0x30a4, 0x30eb, };
+static const char32 __uni_decomp_data_0x3345[] = { 3, 0x30de, 0x30c3, 0x30cf, };
+static const char32 __uni_decomp_data_0x3346[] = { 3, 0x30de, 0x30eb, 0x30af, };
+static const char32 __uni_decomp_data_0x3347[] = { 5, 0x30de, 0x30f3, 0x30b7, 0x30e7, 0x30f3, };
+static const char32 __uni_decomp_data_0x3348[] = { 4, 0x30df, 0x30af, 0x30ed, 0x30f3, };
+static const char32 __uni_decomp_data_0x3349[] = { 2, 0x30df, 0x30ea, };
+static const char32 __uni_decomp_data_0x334a[] = { 5, 0x30df, 0x30ea, 0x30d0, 0x30fc, 0x30eb, };
+static const char32 __uni_decomp_data_0x334b[] = { 2, 0x30e1, 0x30ac, };
+static const char32 __uni_decomp_data_0x334c[] = { 4, 0x30e1, 0x30ac, 0x30c8, 0x30f3, };
+static const char32 __uni_decomp_data_0x334d[] = { 4, 0x30e1, 0x30fc, 0x30c8, 0x30eb, };
+static const char32 __uni_decomp_data_0x334e[] = { 3, 0x30e4, 0x30fc, 0x30c9, };
+static const char32 __uni_decomp_data_0x334f[] = { 3, 0x30e4, 0x30fc, 0x30eb, };
+static const char32 __uni_decomp_data_0x3350[] = { 3, 0x30e6, 0x30a2, 0x30f3, };
+static const char32 __uni_decomp_data_0x3351[] = { 4, 0x30ea, 0x30c3, 0x30c8, 0x30eb, };
+static const char32 __uni_decomp_data_0x3352[] = { 2, 0x30ea, 0x30e9, };
+static const char32 __uni_decomp_data_0x3353[] = { 3, 0x30eb, 0x30d4, 0x30fc, };
+static const char32 __uni_decomp_data_0x3354[] = { 4, 0x30eb, 0x30fc, 0x30d6, 0x30eb, };
+static const char32 __uni_decomp_data_0x3355[] = { 2, 0x30ec, 0x30e0, };
+static const char32 __uni_decomp_data_0x3356[] = { 5, 0x30ec, 0x30f3, 0x30c8, 0x30b2, 0x30f3, };
+static const char32 __uni_decomp_data_0x3357[] = { 3, 0x30ef, 0x30c3, 0x30c8, };
+static const char32 __uni_decomp_data_0x3358[] = { 2, 0x30, 0x70b9, };
+static const char32 __uni_decomp_data_0x3359[] = { 2, 0x31, 0x70b9, };
+static const char32 __uni_decomp_data_0x335a[] = { 2, 0x32, 0x70b9, };
+static const char32 __uni_decomp_data_0x335b[] = { 2, 0x33, 0x70b9, };
+static const char32 __uni_decomp_data_0x335c[] = { 2, 0x34, 0x70b9, };
+static const char32 __uni_decomp_data_0x335d[] = { 2, 0x35, 0x70b9, };
+static const char32 __uni_decomp_data_0x335e[] = { 2, 0x36, 0x70b9, };
+static const char32 __uni_decomp_data_0x335f[] = { 2, 0x37, 0x70b9, };
+static const char32 __uni_decomp_data_0x3360[] = { 2, 0x38, 0x70b9, };
+static const char32 __uni_decomp_data_0x3361[] = { 2, 0x39, 0x70b9, };
+static const char32 __uni_decomp_data_0x3362[] = { 3, 0x31, 0x30, 0x70b9, };
+static const char32 __uni_decomp_data_0x3363[] = { 3, 0x31, 0x31, 0x70b9, };
+static const char32 __uni_decomp_data_0x3364[] = { 3, 0x31, 0x32, 0x70b9, };
+static const char32 __uni_decomp_data_0x3365[] = { 3, 0x31, 0x33, 0x70b9, };
+static const char32 __uni_decomp_data_0x3366[] = { 3, 0x31, 0x34, 0x70b9, };
+static const char32 __uni_decomp_data_0x3367[] = { 3, 0x31, 0x35, 0x70b9, };
+static const char32 __uni_decomp_data_0x3368[] = { 3, 0x31, 0x36, 0x70b9, };
+static const char32 __uni_decomp_data_0x3369[] = { 3, 0x31, 0x37, 0x70b9, };
+static const char32 __uni_decomp_data_0x336a[] = { 3, 0x31, 0x38, 0x70b9, };
+static const char32 __uni_decomp_data_0x336b[] = { 3, 0x31, 0x39, 0x70b9, };
+static const char32 __uni_decomp_data_0x336c[] = { 3, 0x32, 0x30, 0x70b9, };
+static const char32 __uni_decomp_data_0x336d[] = { 3, 0x32, 0x31, 0x70b9, };
+static const char32 __uni_decomp_data_0x336e[] = { 3, 0x32, 0x32, 0x70b9, };
+static const char32 __uni_decomp_data_0x336f[] = { 3, 0x32, 0x33, 0x70b9, };
+static const char32 __uni_decomp_data_0x3370[] = { 3, 0x32, 0x34, 0x70b9, };
+static const char32 __uni_decomp_data_0x3371[] = { 3, 0x68, 0x50, 0x61, };
+static const char32 __uni_decomp_data_0x3372[] = { 2, 0x64, 0x61, };
+static const char32 __uni_decomp_data_0x3373[] = { 2, 0x41, 0x55, };
+static const char32 __uni_decomp_data_0x3374[] = { 3, 0x62, 0x61, 0x72, };
+static const char32 __uni_decomp_data_0x3375[] = { 2, 0x6f, 0x56, };
+static const char32 __uni_decomp_data_0x3376[] = { 2, 0x70, 0x63, };
+static const char32 __uni_decomp_data_0x3377[] = { 2, 0x64, 0x6d, };
+static const char32 __uni_decomp_data_0x3378[] = { 3, 0x64, 0x6d, 0xb2, };
+static const char32 __uni_decomp_data_0x3379[] = { 3, 0x64, 0x6d, 0xb3, };
+static const char32 __uni_decomp_data_0x337a[] = { 2, 0x49, 0x55, };
+static const char32 __uni_decomp_data_0x337b[] = { 2, 0x5e73, 0x6210, };
+static const char32 __uni_decomp_data_0x337c[] = { 2, 0x662d, 0x548c, };
+static const char32 __uni_decomp_data_0x337d[] = { 2, 0x5927, 0x6b63, };
+static const char32 __uni_decomp_data_0x337e[] = { 2, 0x660e, 0x6cbb, };
+static const char32 __uni_decomp_data_0x337f[] = { 4, 0x682a, 0x5f0f, 0x4f1a, 0x793e, };
 
 
 
@@ -7111,134 +7111,134 @@
 };
 
 
-static const char32 __uni_decomp_data_0x3380[] = { 0x70, 0x41, 0, };
-static const char32 __uni_decomp_data_0x3381[] = { 0x6e, 0x41, 0, };
-static const char32 __uni_decomp_data_0x3382[] = { 0x3bc, 0x41, 0, };
-static const char32 __uni_decomp_data_0x3383[] = { 0x6d, 0x41, 0, };
-static const char32 __uni_decomp_data_0x3384[] = { 0x6b, 0x41, 0, };
-static const char32 __uni_decomp_data_0x3385[] = { 0x4b, 0x42, 0, };
-static const char32 __uni_decomp_data_0x3386[] = { 0x4d, 0x42, 0, };
-static const char32 __uni_decomp_data_0x3387[] = { 0x47, 0x42, 0, };
-static const char32 __uni_decomp_data_0x3388[] = { 0x63, 0x61, 0x6c, 0, };
-static const char32 __uni_decomp_data_0x3389[] = { 0x6b, 0x63, 0x61, 0x6c, 0, };
-static const char32 __uni_decomp_data_0x338a[] = { 0x70, 0x46, 0, };
-static const char32 __uni_decomp_data_0x338b[] = { 0x6e, 0x46, 0, };
-static const char32 __uni_decomp_data_0x338c[] = { 0x3bc, 0x46, 0, };
-static const char32 __uni_decomp_data_0x338d[] = { 0x3bc, 0x67, 0, };
-static const char32 __uni_decomp_data_0x338e[] = { 0x6d, 0x67, 0, };
-static const char32 __uni_decomp_data_0x338f[] = { 0x6b, 0x67, 0, };
-static const char32 __uni_decomp_data_0x3390[] = { 0x48, 0x7a, 0, };
-static const char32 __uni_decomp_data_0x3391[] = { 0x6b, 0x48, 0x7a, 0, };
-static const char32 __uni_decomp_data_0x3392[] = { 0x4d, 0x48, 0x7a, 0, };
-static const char32 __uni_decomp_data_0x3393[] = { 0x47, 0x48, 0x7a, 0, };
-static const char32 __uni_decomp_data_0x3394[] = { 0x54, 0x48, 0x7a, 0, };
-static const char32 __uni_decomp_data_0x3395[] = { 0x3bc, 0x2113, 0, };
-static const char32 __uni_decomp_data_0x3396[] = { 0x6d, 0x2113, 0, };
-static const char32 __uni_decomp_data_0x3397[] = { 0x64, 0x2113, 0, };
-static const char32 __uni_decomp_data_0x3398[] = { 0x6b, 0x2113, 0, };
-static const char32 __uni_decomp_data_0x3399[] = { 0x66, 0x6d, 0, };
-static const char32 __uni_decomp_data_0x339a[] = { 0x6e, 0x6d, 0, };
-static const char32 __uni_decomp_data_0x339b[] = { 0x3bc, 0x6d, 0, };
-static const char32 __uni_decomp_data_0x339c[] = { 0x6d, 0x6d, 0, };
-static const char32 __uni_decomp_data_0x339d[] = { 0x63, 0x6d, 0, };
-static const char32 __uni_decomp_data_0x339e[] = { 0x6b, 0x6d, 0, };
-static const char32 __uni_decomp_data_0x339f[] = { 0x6d, 0x6d, 0xb2, 0, };
-static const char32 __uni_decomp_data_0x33a0[] = { 0x63, 0x6d, 0xb2, 0, };
-static const char32 __uni_decomp_data_0x33a1[] = { 0x6d, 0xb2, 0, };
-static const char32 __uni_decomp_data_0x33a2[] = { 0x6b, 0x6d, 0xb2, 0, };
-static const char32 __uni_decomp_data_0x33a3[] = { 0x6d, 0x6d, 0xb3, 0, };
-static const char32 __uni_decomp_data_0x33a4[] = { 0x63, 0x6d, 0xb3, 0, };
-static const char32 __uni_decomp_data_0x33a5[] = { 0x6d, 0xb3, 0, };
-static const char32 __uni_decomp_data_0x33a6[] = { 0x6b, 0x6d, 0xb3, 0, };
-static const char32 __uni_decomp_data_0x33a7[] = { 0x6d, 0x2215, 0x73, 0, };
-static const char32 __uni_decomp_data_0x33a8[] = { 0x6d, 0x2215, 0x73, 0xb2, 0, };
-static const char32 __uni_decomp_data_0x33a9[] = { 0x50, 0x61, 0, };
-static const char32 __uni_decomp_data_0x33aa[] = { 0x6b, 0x50, 0x61, 0, };
-static const char32 __uni_decomp_data_0x33ab[] = { 0x4d, 0x50, 0x61, 0, };
-static const char32 __uni_decomp_data_0x33ac[] = { 0x47, 0x50, 0x61, 0, };
-static const char32 __uni_decomp_data_0x33ad[] = { 0x72, 0x61, 0x64, 0, };
-static const char32 __uni_decomp_data_0x33ae[] = { 0x72, 0x61, 0x64, 0x2215, 0x73, 0, };
-static const char32 __uni_decomp_data_0x33af[] = { 0x72, 0x61, 0x64, 0x2215, 0x73, 0xb2, 0, };
-static const char32 __uni_decomp_data_0x33b0[] = { 0x70, 0x73, 0, };
-static const char32 __uni_decomp_data_0x33b1[] = { 0x6e, 0x73, 0, };
-static const char32 __uni_decomp_data_0x33b2[] = { 0x3bc, 0x73, 0, };
-static const char32 __uni_decomp_data_0x33b3[] = { 0x6d, 0x73, 0, };
-static const char32 __uni_decomp_data_0x33b4[] = { 0x70, 0x56, 0, };
-static const char32 __uni_decomp_data_0x33b5[] = { 0x6e, 0x56, 0, };
-static const char32 __uni_decomp_data_0x33b6[] = { 0x3bc, 0x56, 0, };
-static const char32 __uni_decomp_data_0x33b7[] = { 0x6d, 0x56, 0, };
-static const char32 __uni_decomp_data_0x33b8[] = { 0x6b, 0x56, 0, };
-static const char32 __uni_decomp_data_0x33b9[] = { 0x4d, 0x56, 0, };
-static const char32 __uni_decomp_data_0x33ba[] = { 0x70, 0x57, 0, };
-static const char32 __uni_decomp_data_0x33bb[] = { 0x6e, 0x57, 0, };
-static const char32 __uni_decomp_data_0x33bc[] = { 0x3bc, 0x57, 0, };
-static const char32 __uni_decomp_data_0x33bd[] = { 0x6d, 0x57, 0, };
-static const char32 __uni_decomp_data_0x33be[] = { 0x6b, 0x57, 0, };
-static const char32 __uni_decomp_data_0x33bf[] = { 0x4d, 0x57, 0, };
-static const char32 __uni_decomp_data_0x33c0[] = { 0x6b, 0x3a9, 0, };
-static const char32 __uni_decomp_data_0x33c1[] = { 0x4d, 0x3a9, 0, };
-static const char32 __uni_decomp_data_0x33c2[] = { 0x61, 0x2e, 0x6d, 0x2e, 0, };
-static const char32 __uni_decomp_data_0x33c3[] = { 0x42, 0x71, 0, };
-static const char32 __uni_decomp_data_0x33c4[] = { 0x63, 0x63, 0, };
-static const char32 __uni_decomp_data_0x33c5[] = { 0x63, 0x64, 0, };
-static const char32 __uni_decomp_data_0x33c6[] = { 0x43, 0x2215, 0x6b, 0x67, 0, };
-static const char32 __uni_decomp_data_0x33c7[] = { 0x43, 0x6f, 0x2e, 0, };
-static const char32 __uni_decomp_data_0x33c8[] = { 0x64, 0x42, 0, };
-static const char32 __uni_decomp_data_0x33c9[] = { 0x47, 0x79, 0, };
-static const char32 __uni_decomp_data_0x33ca[] = { 0x68, 0x61, 0, };
-static const char32 __uni_decomp_data_0x33cb[] = { 0x48, 0x50, 0, };
-static const char32 __uni_decomp_data_0x33cc[] = { 0x69, 0x6e, 0, };
-static const char32 __uni_decomp_data_0x33cd[] = { 0x4b, 0x4b, 0, };
-static const char32 __uni_decomp_data_0x33ce[] = { 0x4b, 0x4d, 0, };
-static const char32 __uni_decomp_data_0x33cf[] = { 0x6b, 0x74, 0, };
-static const char32 __uni_decomp_data_0x33d0[] = { 0x6c, 0x6d, 0, };
-static const char32 __uni_decomp_data_0x33d1[] = { 0x6c, 0x6e, 0, };
-static const char32 __uni_decomp_data_0x33d2[] = { 0x6c, 0x6f, 0x67, 0, };
-static const char32 __uni_decomp_data_0x33d3[] = { 0x6c, 0x78, 0, };
-static const char32 __uni_decomp_data_0x33d4[] = { 0x6d, 0x62, 0, };
-static const char32 __uni_decomp_data_0x33d5[] = { 0x6d, 0x69, 0x6c, 0, };
-static const char32 __uni_decomp_data_0x33d6[] = { 0x6d, 0x6f, 0x6c, 0, };
-static const char32 __uni_decomp_data_0x33d7[] = { 0x50, 0x48, 0, };
-static const char32 __uni_decomp_data_0x33d8[] = { 0x70, 0x2e, 0x6d, 0x2e, 0, };
-static const char32 __uni_decomp_data_0x33d9[] = { 0x50, 0x50, 0x4d, 0, };
-static const char32 __uni_decomp_data_0x33da[] = { 0x50, 0x52, 0, };
-static const char32 __uni_decomp_data_0x33db[] = { 0x73, 0x72, 0, };
-static const char32 __uni_decomp_data_0x33dc[] = { 0x53, 0x76, 0, };
-static const char32 __uni_decomp_data_0x33dd[] = { 0x57, 0x62, 0, };
-static const char32 __uni_decomp_data_0x33de[] = { 0x56, 0x2215, 0x6d, 0, };
-static const char32 __uni_decomp_data_0x33df[] = { 0x41, 0x2215, 0x6d, 0, };
-static const char32 __uni_decomp_data_0x33e0[] = { 0x31, 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x33e1[] = { 0x32, 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x33e2[] = { 0x33, 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x33e3[] = { 0x34, 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x33e4[] = { 0x35, 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x33e5[] = { 0x36, 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x33e6[] = { 0x37, 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x33e7[] = { 0x38, 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x33e8[] = { 0x39, 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x33e9[] = { 0x31, 0x30, 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x33ea[] = { 0x31, 0x31, 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x33eb[] = { 0x31, 0x32, 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x33ec[] = { 0x31, 0x33, 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x33ed[] = { 0x31, 0x34, 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x33ee[] = { 0x31, 0x35, 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x33ef[] = { 0x31, 0x36, 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x33f0[] = { 0x31, 0x37, 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x33f1[] = { 0x31, 0x38, 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x33f2[] = { 0x31, 0x39, 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x33f3[] = { 0x32, 0x30, 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x33f4[] = { 0x32, 0x31, 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x33f5[] = { 0x32, 0x32, 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x33f6[] = { 0x32, 0x33, 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x33f7[] = { 0x32, 0x34, 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x33f8[] = { 0x32, 0x35, 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x33f9[] = { 0x32, 0x36, 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x33fa[] = { 0x32, 0x37, 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x33fb[] = { 0x32, 0x38, 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x33fc[] = { 0x32, 0x39, 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x33fd[] = { 0x33, 0x30, 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x33fe[] = { 0x33, 0x31, 0x65e5, 0, };
-static const char32 __uni_decomp_data_0x33ff[] = { 0x67, 0x61, 0x6c, 0, };
+static const char32 __uni_decomp_data_0x3380[] = { 2, 0x70, 0x41, };
+static const char32 __uni_decomp_data_0x3381[] = { 2, 0x6e, 0x41, };
+static const char32 __uni_decomp_data_0x3382[] = { 2, 0x3bc, 0x41, };
+static const char32 __uni_decomp_data_0x3383[] = { 2, 0x6d, 0x41, };
+static const char32 __uni_decomp_data_0x3384[] = { 2, 0x6b, 0x41, };
+static const char32 __uni_decomp_data_0x3385[] = { 2, 0x4b, 0x42, };
+static const char32 __uni_decomp_data_0x3386[] = { 2, 0x4d, 0x42, };
+static const char32 __uni_decomp_data_0x3387[] = { 2, 0x47, 0x42, };
+static const char32 __uni_decomp_data_0x3388[] = { 3, 0x63, 0x61, 0x6c, };
+static const char32 __uni_decomp_data_0x3389[] = { 4, 0x6b, 0x63, 0x61, 0x6c, };
+static const char32 __uni_decomp_data_0x338a[] = { 2, 0x70, 0x46, };
+static const char32 __uni_decomp_data_0x338b[] = { 2, 0x6e, 0x46, };
+static const char32 __uni_decomp_data_0x338c[] = { 2, 0x3bc, 0x46, };
+static const char32 __uni_decomp_data_0x338d[] = { 2, 0x3bc, 0x67, };
+static const char32 __uni_decomp_data_0x338e[] = { 2, 0x6d, 0x67, };
+static const char32 __uni_decomp_data_0x338f[] = { 2, 0x6b, 0x67, };
+static const char32 __uni_decomp_data_0x3390[] = { 2, 0x48, 0x7a, };
+static const char32 __uni_decomp_data_0x3391[] = { 3, 0x6b, 0x48, 0x7a, };
+static const char32 __uni_decomp_data_0x3392[] = { 3, 0x4d, 0x48, 0x7a, };
+static const char32 __uni_decomp_data_0x3393[] = { 3, 0x47, 0x48, 0x7a, };
+static const char32 __uni_decomp_data_0x3394[] = { 3, 0x54, 0x48, 0x7a, };
+static const char32 __uni_decomp_data_0x3395[] = { 2, 0x3bc, 0x2113, };
+static const char32 __uni_decomp_data_0x3396[] = { 2, 0x6d, 0x2113, };
+static const char32 __uni_decomp_data_0x3397[] = { 2, 0x64, 0x2113, };
+static const char32 __uni_decomp_data_0x3398[] = { 2, 0x6b, 0x2113, };
+static const char32 __uni_decomp_data_0x3399[] = { 2, 0x66, 0x6d, };
+static const char32 __uni_decomp_data_0x339a[] = { 2, 0x6e, 0x6d, };
+static const char32 __uni_decomp_data_0x339b[] = { 2, 0x3bc, 0x6d, };
+static const char32 __uni_decomp_data_0x339c[] = { 2, 0x6d, 0x6d, };
+static const char32 __uni_decomp_data_0x339d[] = { 2, 0x63, 0x6d, };
+static const char32 __uni_decomp_data_0x339e[] = { 2, 0x6b, 0x6d, };
+static const char32 __uni_decomp_data_0x339f[] = { 3, 0x6d, 0x6d, 0xb2, };
+static const char32 __uni_decomp_data_0x33a0[] = { 3, 0x63, 0x6d, 0xb2, };
+static const char32 __uni_decomp_data_0x33a1[] = { 2, 0x6d, 0xb2, };
+static const char32 __uni_decomp_data_0x33a2[] = { 3, 0x6b, 0x6d, 0xb2, };
+static const char32 __uni_decomp_data_0x33a3[] = { 3, 0x6d, 0x6d, 0xb3, };
+static const char32 __uni_decomp_data_0x33a4[] = { 3, 0x63, 0x6d, 0xb3, };
+static const char32 __uni_decomp_data_0x33a5[] = { 2, 0x6d, 0xb3, };
+static const char32 __uni_decomp_data_0x33a6[] = { 3, 0x6b, 0x6d, 0xb3, };
+static const char32 __uni_decomp_data_0x33a7[] = { 3, 0x6d, 0x2215, 0x73, };
+static const char32 __uni_decomp_data_0x33a8[] = { 4, 0x6d, 0x2215, 0x73, 0xb2, };
+static const char32 __uni_decomp_data_0x33a9[] = { 2, 0x50, 0x61, };
+static const char32 __uni_decomp_data_0x33aa[] = { 3, 0x6b, 0x50, 0x61, };
+static const char32 __uni_decomp_data_0x33ab[] = { 3, 0x4d, 0x50, 0x61, };
+static const char32 __uni_decomp_data_0x33ac[] = { 3, 0x47, 0x50, 0x61, };
+static const char32 __uni_decomp_data_0x33ad[] = { 3, 0x72, 0x61, 0x64, };
+static const char32 __uni_decomp_data_0x33ae[] = { 5, 0x72, 0x61, 0x64, 0x2215, 0x73, };
+static const char32 __uni_decomp_data_0x33af[] = { 6, 0x72, 0x61, 0x64, 0x2215, 0x73, 0xb2, };
+static const char32 __uni_decomp_data_0x33b0[] = { 2, 0x70, 0x73, };
+static const char32 __uni_decomp_data_0x33b1[] = { 2, 0x6e, 0x73, };
+static const char32 __uni_decomp_data_0x33b2[] = { 2, 0x3bc, 0x73, };
+static const char32 __uni_decomp_data_0x33b3[] = { 2, 0x6d, 0x73, };
+static const char32 __uni_decomp_data_0x33b4[] = { 2, 0x70, 0x56, };
+static const char32 __uni_decomp_data_0x33b5[] = { 2, 0x6e, 0x56, };
+static const char32 __uni_decomp_data_0x33b6[] = { 2, 0x3bc, 0x56, };
+static const char32 __uni_decomp_data_0x33b7[] = { 2, 0x6d, 0x56, };
+static const char32 __uni_decomp_data_0x33b8[] = { 2, 0x6b, 0x56, };
+static const char32 __uni_decomp_data_0x33b9[] = { 2, 0x4d, 0x56, };
+static const char32 __uni_decomp_data_0x33ba[] = { 2, 0x70, 0x57, };
+static const char32 __uni_decomp_data_0x33bb[] = { 2, 0x6e, 0x57, };
+static const char32 __uni_decomp_data_0x33bc[] = { 2, 0x3bc, 0x57, };
+static const char32 __uni_decomp_data_0x33bd[] = { 2, 0x6d, 0x57, };
+static const char32 __uni_decomp_data_0x33be[] = { 2, 0x6b, 0x57, };
+static const char32 __uni_decomp_data_0x33bf[] = { 2, 0x4d, 0x57, };
+static const char32 __uni_decomp_data_0x33c0[] = { 2, 0x6b, 0x3a9, };
+static const char32 __uni_decomp_data_0x33c1[] = { 2, 0x4d, 0x3a9, };
+static const char32 __uni_decomp_data_0x33c2[] = { 4, 0x61, 0x2e, 0x6d, 0x2e, };
+static const char32 __uni_decomp_data_0x33c3[] = { 2, 0x42, 0x71, };
+static const char32 __uni_decomp_data_0x33c4[] = { 2, 0x63, 0x63, };
+static const char32 __uni_decomp_data_0x33c5[] = { 2, 0x63, 0x64, };
+static const char32 __uni_decomp_data_0x33c6[] = { 4, 0x43, 0x2215, 0x6b, 0x67, };
+static const char32 __uni_decomp_data_0x33c7[] = { 3, 0x43, 0x6f, 0x2e, };
+static const char32 __uni_decomp_data_0x33c8[] = { 2, 0x64, 0x42, };
+static const char32 __uni_decomp_data_0x33c9[] = { 2, 0x47, 0x79, };
+static const char32 __uni_decomp_data_0x33ca[] = { 2, 0x68, 0x61, };
+static const char32 __uni_decomp_data_0x33cb[] = { 2, 0x48, 0x50, };
+static const char32 __uni_decomp_data_0x33cc[] = { 2, 0x69, 0x6e, };
+static const char32 __uni_decomp_data_0x33cd[] = { 2, 0x4b, 0x4b, };
+static const char32 __uni_decomp_data_0x33ce[] = { 2, 0x4b, 0x4d, };
+static const char32 __uni_decomp_data_0x33cf[] = { 2, 0x6b, 0x74, };
+static const char32 __uni_decomp_data_0x33d0[] = { 2, 0x6c, 0x6d, };
+static const char32 __uni_decomp_data_0x33d1[] = { 2, 0x6c, 0x6e, };
+static const char32 __uni_decomp_data_0x33d2[] = { 3, 0x6c, 0x6f, 0x67, };
+static const char32 __uni_decomp_data_0x33d3[] = { 2, 0x6c, 0x78, };
+static const char32 __uni_decomp_data_0x33d4[] = { 2, 0x6d, 0x62, };
+static const char32 __uni_decomp_data_0x33d5[] = { 3, 0x6d, 0x69, 0x6c, };
+static const char32 __uni_decomp_data_0x33d6[] = { 3, 0x6d, 0x6f, 0x6c, };
+static const char32 __uni_decomp_data_0x33d7[] = { 2, 0x50, 0x48, };
+static const char32 __uni_decomp_data_0x33d8[] = { 4, 0x70, 0x2e, 0x6d, 0x2e, };
+static const char32 __uni_decomp_data_0x33d9[] = { 3, 0x50, 0x50, 0x4d, };
+static const char32 __uni_decomp_data_0x33da[] = { 2, 0x50, 0x52, };
+static const char32 __uni_decomp_data_0x33db[] = { 2, 0x73, 0x72, };
+static const char32 __uni_decomp_data_0x33dc[] = { 2, 0x53, 0x76, };
+static const char32 __uni_decomp_data_0x33dd[] = { 2, 0x57, 0x62, };
+static const char32 __uni_decomp_data_0x33de[] = { 3, 0x56, 0x2215, 0x6d, };
+static const char32 __uni_decomp_data_0x33df[] = { 3, 0x41, 0x2215, 0x6d, };
+static const char32 __uni_decomp_data_0x33e0[] = { 2, 0x31, 0x65e5, };
+static const char32 __uni_decomp_data_0x33e1[] = { 2, 0x32, 0x65e5, };
+static const char32 __uni_decomp_data_0x33e2[] = { 2, 0x33, 0x65e5, };
+static const char32 __uni_decomp_data_0x33e3[] = { 2, 0x34, 0x65e5, };
+static const char32 __uni_decomp_data_0x33e4[] = { 2, 0x35, 0x65e5, };
+static const char32 __uni_decomp_data_0x33e5[] = { 2, 0x36, 0x65e5, };
+static const char32 __uni_decomp_data_0x33e6[] = { 2, 0x37, 0x65e5, };
+static const char32 __uni_decomp_data_0x33e7[] = { 2, 0x38, 0x65e5, };
+static const char32 __uni_decomp_data_0x33e8[] = { 2, 0x39, 0x65e5, };
+static const char32 __uni_decomp_data_0x33e9[] = { 3, 0x31, 0x30, 0x65e5, };
+static const char32 __uni_decomp_data_0x33ea[] = { 3, 0x31, 0x31, 0x65e5, };
+static const char32 __uni_decomp_data_0x33eb[] = { 3, 0x31, 0x32, 0x65e5, };
+static const char32 __uni_decomp_data_0x33ec[] = { 3, 0x31, 0x33, 0x65e5, };
+static const char32 __uni_decomp_data_0x33ed[] = { 3, 0x31, 0x34, 0x65e5, };
+static const char32 __uni_decomp_data_0x33ee[] = { 3, 0x31, 0x35, 0x65e5, };
+static const char32 __uni_decomp_data_0x33ef[] = { 3, 0x31, 0x36, 0x65e5, };
+static const char32 __uni_decomp_data_0x33f0[] = { 3, 0x31, 0x37, 0x65e5, };
+static const char32 __uni_decomp_data_0x33f1[] = { 3, 0x31, 0x38, 0x65e5, };
+static const char32 __uni_decomp_data_0x33f2[] = { 3, 0x31, 0x39, 0x65e5, };
+static const char32 __uni_decomp_data_0x33f3[] = { 3, 0x32, 0x30, 0x65e5, };
+static const char32 __uni_decomp_data_0x33f4[] = { 3, 0x32, 0x31, 0x65e5, };
+static const char32 __uni_decomp_data_0x33f5[] = { 3, 0x32, 0x32, 0x65e5, };
+static const char32 __uni_decomp_data_0x33f6[] = { 3, 0x32, 0x33, 0x65e5, };
+static const char32 __uni_decomp_data_0x33f7[] = { 3, 0x32, 0x34, 0x65e5, };
+static const char32 __uni_decomp_data_0x33f8[] = { 3, 0x32, 0x35, 0x65e5, };
+static const char32 __uni_decomp_data_0x33f9[] = { 3, 0x32, 0x36, 0x65e5, };
+static const char32 __uni_decomp_data_0x33fa[] = { 3, 0x32, 0x37, 0x65e5, };
+static const char32 __uni_decomp_data_0x33fb[] = { 3, 0x32, 0x38, 0x65e5, };
+static const char32 __uni_decomp_data_0x33fc[] = { 3, 0x32, 0x39, 0x65e5, };
+static const char32 __uni_decomp_data_0x33fd[] = { 3, 0x33, 0x30, 0x65e5, };
+static const char32 __uni_decomp_data_0x33fe[] = { 3, 0x33, 0x31, 0x65e5, };
+static const char32 __uni_decomp_data_0x33ff[] = { 3, 0x67, 0x61, 0x6c, };
 
 
 
@@ -39026,7 +39026,7 @@
 };
 
 
-static const char32 __uni_decomp_data_0xa770[] = { 0xa76f, 0, };
+static const char32 __uni_decomp_data_0xa770[] = { 1, 0xa76f, };
 
 
 

Modified: sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_6.ipp
==============================================================================
--- sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_6.ipp	(original)
+++ sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_6.ipp	2009-08-06 03:26:39 EDT (Thu, 06 Aug 2009)
@@ -28462,134 +28462,134 @@
 };
 
 
-static const char32 __uni_decomp_data_0xf900[] = { 0x8c48, 0, };
-static const char32 __uni_decomp_data_0xf901[] = { 0x66f4, 0, };
-static const char32 __uni_decomp_data_0xf902[] = { 0x8eca, 0, };
-static const char32 __uni_decomp_data_0xf903[] = { 0x8cc8, 0, };
-static const char32 __uni_decomp_data_0xf904[] = { 0x6ed1, 0, };
-static const char32 __uni_decomp_data_0xf905[] = { 0x4e32, 0, };
-static const char32 __uni_decomp_data_0xf906[] = { 0x53e5, 0, };
-static const char32 __uni_decomp_data_0xf907[] = { 0x9f9c, 0, };
-static const char32 __uni_decomp_data_0xf908[] = { 0x9f9c, 0, };
-static const char32 __uni_decomp_data_0xf909[] = { 0x5951, 0, };
-static const char32 __uni_decomp_data_0xf90a[] = { 0x91d1, 0, };
-static const char32 __uni_decomp_data_0xf90b[] = { 0x5587, 0, };
-static const char32 __uni_decomp_data_0xf90c[] = { 0x5948, 0, };
-static const char32 __uni_decomp_data_0xf90d[] = { 0x61f6, 0, };
-static const char32 __uni_decomp_data_0xf90e[] = { 0x7669, 0, };
-static const char32 __uni_decomp_data_0xf90f[] = { 0x7f85, 0, };
-static const char32 __uni_decomp_data_0xf910[] = { 0x863f, 0, };
-static const char32 __uni_decomp_data_0xf911[] = { 0x87ba, 0, };
-static const char32 __uni_decomp_data_0xf912[] = { 0x88f8, 0, };
-static const char32 __uni_decomp_data_0xf913[] = { 0x908f, 0, };
-static const char32 __uni_decomp_data_0xf914[] = { 0x6a02, 0, };
-static const char32 __uni_decomp_data_0xf915[] = { 0x6d1b, 0, };
-static const char32 __uni_decomp_data_0xf916[] = { 0x70d9, 0, };
-static const char32 __uni_decomp_data_0xf917[] = { 0x73de, 0, };
-static const char32 __uni_decomp_data_0xf918[] = { 0x843d, 0, };
-static const char32 __uni_decomp_data_0xf919[] = { 0x916a, 0, };
-static const char32 __uni_decomp_data_0xf91a[] = { 0x99f1, 0, };
-static const char32 __uni_decomp_data_0xf91b[] = { 0x4e82, 0, };
-static const char32 __uni_decomp_data_0xf91c[] = { 0x5375, 0, };
-static const char32 __uni_decomp_data_0xf91d[] = { 0x6b04, 0, };
-static const char32 __uni_decomp_data_0xf91e[] = { 0x721b, 0, };
-static const char32 __uni_decomp_data_0xf91f[] = { 0x862d, 0, };
-static const char32 __uni_decomp_data_0xf920[] = { 0x9e1e, 0, };
-static const char32 __uni_decomp_data_0xf921[] = { 0x5d50, 0, };
-static const char32 __uni_decomp_data_0xf922[] = { 0x6feb, 0, };
-static const char32 __uni_decomp_data_0xf923[] = { 0x85cd, 0, };
-static const char32 __uni_decomp_data_0xf924[] = { 0x8964, 0, };
-static const char32 __uni_decomp_data_0xf925[] = { 0x62c9, 0, };
-static const char32 __uni_decomp_data_0xf926[] = { 0x81d8, 0, };
-static const char32 __uni_decomp_data_0xf927[] = { 0x881f, 0, };
-static const char32 __uni_decomp_data_0xf928[] = { 0x5eca, 0, };
-static const char32 __uni_decomp_data_0xf929[] = { 0x6717, 0, };
-static const char32 __uni_decomp_data_0xf92a[] = { 0x6d6a, 0, };
-static const char32 __uni_decomp_data_0xf92b[] = { 0x72fc, 0, };
-static const char32 __uni_decomp_data_0xf92c[] = { 0x90ce, 0, };
-static const char32 __uni_decomp_data_0xf92d[] = { 0x4f86, 0, };
-static const char32 __uni_decomp_data_0xf92e[] = { 0x51b7, 0, };
-static const char32 __uni_decomp_data_0xf92f[] = { 0x52de, 0, };
-static const char32 __uni_decomp_data_0xf930[] = { 0x64c4, 0, };
-static const char32 __uni_decomp_data_0xf931[] = { 0x6ad3, 0, };
-static const char32 __uni_decomp_data_0xf932[] = { 0x7210, 0, };
-static const char32 __uni_decomp_data_0xf933[] = { 0x76e7, 0, };
-static const char32 __uni_decomp_data_0xf934[] = { 0x8001, 0, };
-static const char32 __uni_decomp_data_0xf935[] = { 0x8606, 0, };
-static const char32 __uni_decomp_data_0xf936[] = { 0x865c, 0, };
-static const char32 __uni_decomp_data_0xf937[] = { 0x8def, 0, };
-static const char32 __uni_decomp_data_0xf938[] = { 0x9732, 0, };
-static const char32 __uni_decomp_data_0xf939[] = { 0x9b6f, 0, };
-static const char32 __uni_decomp_data_0xf93a[] = { 0x9dfa, 0, };
-static const char32 __uni_decomp_data_0xf93b[] = { 0x788c, 0, };
-static const char32 __uni_decomp_data_0xf93c[] = { 0x797f, 0, };
-static const char32 __uni_decomp_data_0xf93d[] = { 0x7da0, 0, };
-static const char32 __uni_decomp_data_0xf93e[] = { 0x83c9, 0, };
-static const char32 __uni_decomp_data_0xf93f[] = { 0x9304, 0, };
-static const char32 __uni_decomp_data_0xf940[] = { 0x9e7f, 0, };
-static const char32 __uni_decomp_data_0xf941[] = { 0x8ad6, 0, };
-static const char32 __uni_decomp_data_0xf942[] = { 0x58df, 0, };
-static const char32 __uni_decomp_data_0xf943[] = { 0x5f04, 0, };
-static const char32 __uni_decomp_data_0xf944[] = { 0x7c60, 0, };
-static const char32 __uni_decomp_data_0xf945[] = { 0x807e, 0, };
-static const char32 __uni_decomp_data_0xf946[] = { 0x7262, 0, };
-static const char32 __uni_decomp_data_0xf947[] = { 0x78ca, 0, };
-static const char32 __uni_decomp_data_0xf948[] = { 0x8cc2, 0, };
-static const char32 __uni_decomp_data_0xf949[] = { 0x96f7, 0, };
-static const char32 __uni_decomp_data_0xf94a[] = { 0x58d8, 0, };
-static const char32 __uni_decomp_data_0xf94b[] = { 0x5c62, 0, };
-static const char32 __uni_decomp_data_0xf94c[] = { 0x6a13, 0, };
-static const char32 __uni_decomp_data_0xf94d[] = { 0x6dda, 0, };
-static const char32 __uni_decomp_data_0xf94e[] = { 0x6f0f, 0, };
-static const char32 __uni_decomp_data_0xf94f[] = { 0x7d2f, 0, };
-static const char32 __uni_decomp_data_0xf950[] = { 0x7e37, 0, };
-static const char32 __uni_decomp_data_0xf951[] = { 0x964b, 0, };
-static const char32 __uni_decomp_data_0xf952[] = { 0x52d2, 0, };
-static const char32 __uni_decomp_data_0xf953[] = { 0x808b, 0, };
-static const char32 __uni_decomp_data_0xf954[] = { 0x51dc, 0, };
-static const char32 __uni_decomp_data_0xf955[] = { 0x51cc, 0, };
-static const char32 __uni_decomp_data_0xf956[] = { 0x7a1c, 0, };
-static const char32 __uni_decomp_data_0xf957[] = { 0x7dbe, 0, };
-static const char32 __uni_decomp_data_0xf958[] = { 0x83f1, 0, };
-static const char32 __uni_decomp_data_0xf959[] = { 0x9675, 0, };
-static const char32 __uni_decomp_data_0xf95a[] = { 0x8b80, 0, };
-static const char32 __uni_decomp_data_0xf95b[] = { 0x62cf, 0, };
-static const char32 __uni_decomp_data_0xf95c[] = { 0x6a02, 0, };
-static const char32 __uni_decomp_data_0xf95d[] = { 0x8afe, 0, };
-static const char32 __uni_decomp_data_0xf95e[] = { 0x4e39, 0, };
-static const char32 __uni_decomp_data_0xf95f[] = { 0x5be7, 0, };
-static const char32 __uni_decomp_data_0xf960[] = { 0x6012, 0, };
-static const char32 __uni_decomp_data_0xf961[] = { 0x7387, 0, };
-static const char32 __uni_decomp_data_0xf962[] = { 0x7570, 0, };
-static const char32 __uni_decomp_data_0xf963[] = { 0x5317, 0, };
-static const char32 __uni_decomp_data_0xf964[] = { 0x78fb, 0, };
-static const char32 __uni_decomp_data_0xf965[] = { 0x4fbf, 0, };
-static const char32 __uni_decomp_data_0xf966[] = { 0x5fa9, 0, };
-static const char32 __uni_decomp_data_0xf967[] = { 0x4e0d, 0, };
-static const char32 __uni_decomp_data_0xf968[] = { 0x6ccc, 0, };
-static const char32 __uni_decomp_data_0xf969[] = { 0x6578, 0, };
-static const char32 __uni_decomp_data_0xf96a[] = { 0x7d22, 0, };
-static const char32 __uni_decomp_data_0xf96b[] = { 0x53c3, 0, };
-static const char32 __uni_decomp_data_0xf96c[] = { 0x585e, 0, };
-static const char32 __uni_decomp_data_0xf96d[] = { 0x7701, 0, };
-static const char32 __uni_decomp_data_0xf96e[] = { 0x8449, 0, };
-static const char32 __uni_decomp_data_0xf96f[] = { 0x8aaa, 0, };
-static const char32 __uni_decomp_data_0xf970[] = { 0x6bba, 0, };
-static const char32 __uni_decomp_data_0xf971[] = { 0x8fb0, 0, };
-static const char32 __uni_decomp_data_0xf972[] = { 0x6c88, 0, };
-static const char32 __uni_decomp_data_0xf973[] = { 0x62fe, 0, };
-static const char32 __uni_decomp_data_0xf974[] = { 0x82e5, 0, };
-static const char32 __uni_decomp_data_0xf975[] = { 0x63a0, 0, };
-static const char32 __uni_decomp_data_0xf976[] = { 0x7565, 0, };
-static const char32 __uni_decomp_data_0xf977[] = { 0x4eae, 0, };
-static const char32 __uni_decomp_data_0xf978[] = { 0x5169, 0, };
-static const char32 __uni_decomp_data_0xf979[] = { 0x51c9, 0, };
-static const char32 __uni_decomp_data_0xf97a[] = { 0x6881, 0, };
-static const char32 __uni_decomp_data_0xf97b[] = { 0x7ce7, 0, };
-static const char32 __uni_decomp_data_0xf97c[] = { 0x826f, 0, };
-static const char32 __uni_decomp_data_0xf97d[] = { 0x8ad2, 0, };
-static const char32 __uni_decomp_data_0xf97e[] = { 0x91cf, 0, };
-static const char32 __uni_decomp_data_0xf97f[] = { 0x52f5, 0, };
+static const char32 __uni_decomp_data_0xf900[] = { 1, 0x8c48, };
+static const char32 __uni_decomp_data_0xf901[] = { 1, 0x66f4, };
+static const char32 __uni_decomp_data_0xf902[] = { 1, 0x8eca, };
+static const char32 __uni_decomp_data_0xf903[] = { 1, 0x8cc8, };
+static const char32 __uni_decomp_data_0xf904[] = { 1, 0x6ed1, };
+static const char32 __uni_decomp_data_0xf905[] = { 1, 0x4e32, };
+static const char32 __uni_decomp_data_0xf906[] = { 1, 0x53e5, };
+static const char32 __uni_decomp_data_0xf907[] = { 1, 0x9f9c, };
+static const char32 __uni_decomp_data_0xf908[] = { 1, 0x9f9c, };
+static const char32 __uni_decomp_data_0xf909[] = { 1, 0x5951, };
+static const char32 __uni_decomp_data_0xf90a[] = { 1, 0x91d1, };
+static const char32 __uni_decomp_data_0xf90b[] = { 1, 0x5587, };
+static const char32 __uni_decomp_data_0xf90c[] = { 1, 0x5948, };
+static const char32 __uni_decomp_data_0xf90d[] = { 1, 0x61f6, };
+static const char32 __uni_decomp_data_0xf90e[] = { 1, 0x7669, };
+static const char32 __uni_decomp_data_0xf90f[] = { 1, 0x7f85, };
+static const char32 __uni_decomp_data_0xf910[] = { 1, 0x863f, };
+static const char32 __uni_decomp_data_0xf911[] = { 1, 0x87ba, };
+static const char32 __uni_decomp_data_0xf912[] = { 1, 0x88f8, };
+static const char32 __uni_decomp_data_0xf913[] = { 1, 0x908f, };
+static const char32 __uni_decomp_data_0xf914[] = { 1, 0x6a02, };
+static const char32 __uni_decomp_data_0xf915[] = { 1, 0x6d1b, };
+static const char32 __uni_decomp_data_0xf916[] = { 1, 0x70d9, };
+static const char32 __uni_decomp_data_0xf917[] = { 1, 0x73de, };
+static const char32 __uni_decomp_data_0xf918[] = { 1, 0x843d, };
+static const char32 __uni_decomp_data_0xf919[] = { 1, 0x916a, };
+static const char32 __uni_decomp_data_0xf91a[] = { 1, 0x99f1, };
+static const char32 __uni_decomp_data_0xf91b[] = { 1, 0x4e82, };
+static const char32 __uni_decomp_data_0xf91c[] = { 1, 0x5375, };
+static const char32 __uni_decomp_data_0xf91d[] = { 1, 0x6b04, };
+static const char32 __uni_decomp_data_0xf91e[] = { 1, 0x721b, };
+static const char32 __uni_decomp_data_0xf91f[] = { 1, 0x862d, };
+static const char32 __uni_decomp_data_0xf920[] = { 1, 0x9e1e, };
+static const char32 __uni_decomp_data_0xf921[] = { 1, 0x5d50, };
+static const char32 __uni_decomp_data_0xf922[] = { 1, 0x6feb, };
+static const char32 __uni_decomp_data_0xf923[] = { 1, 0x85cd, };
+static const char32 __uni_decomp_data_0xf924[] = { 1, 0x8964, };
+static const char32 __uni_decomp_data_0xf925[] = { 1, 0x62c9, };
+static const char32 __uni_decomp_data_0xf926[] = { 1, 0x81d8, };
+static const char32 __uni_decomp_data_0xf927[] = { 1, 0x881f, };
+static const char32 __uni_decomp_data_0xf928[] = { 1, 0x5eca, };
+static const char32 __uni_decomp_data_0xf929[] = { 1, 0x6717, };
+static const char32 __uni_decomp_data_0xf92a[] = { 1, 0x6d6a, };
+static const char32 __uni_decomp_data_0xf92b[] = { 1, 0x72fc, };
+static const char32 __uni_decomp_data_0xf92c[] = { 1, 0x90ce, };
+static const char32 __uni_decomp_data_0xf92d[] = { 1, 0x4f86, };
+static const char32 __uni_decomp_data_0xf92e[] = { 1, 0x51b7, };
+static const char32 __uni_decomp_data_0xf92f[] = { 1, 0x52de, };
+static const char32 __uni_decomp_data_0xf930[] = { 1, 0x64c4, };
+static const char32 __uni_decomp_data_0xf931[] = { 1, 0x6ad3, };
+static const char32 __uni_decomp_data_0xf932[] = { 1, 0x7210, };
+static const char32 __uni_decomp_data_0xf933[] = { 1, 0x76e7, };
+static const char32 __uni_decomp_data_0xf934[] = { 1, 0x8001, };
+static const char32 __uni_decomp_data_0xf935[] = { 1, 0x8606, };
+static const char32 __uni_decomp_data_0xf936[] = { 1, 0x865c, };
+static const char32 __uni_decomp_data_0xf937[] = { 1, 0x8def, };
+static const char32 __uni_decomp_data_0xf938[] = { 1, 0x9732, };
+static const char32 __uni_decomp_data_0xf939[] = { 1, 0x9b6f, };
+static const char32 __uni_decomp_data_0xf93a[] = { 1, 0x9dfa, };
+static const char32 __uni_decomp_data_0xf93b[] = { 1, 0x788c, };
+static const char32 __uni_decomp_data_0xf93c[] = { 1, 0x797f, };
+static const char32 __uni_decomp_data_0xf93d[] = { 1, 0x7da0, };
+static const char32 __uni_decomp_data_0xf93e[] = { 1, 0x83c9, };
+static const char32 __uni_decomp_data_0xf93f[] = { 1, 0x9304, };
+static const char32 __uni_decomp_data_0xf940[] = { 1, 0x9e7f, };
+static const char32 __uni_decomp_data_0xf941[] = { 1, 0x8ad6, };
+static const char32 __uni_decomp_data_0xf942[] = { 1, 0x58df, };
+static const char32 __uni_decomp_data_0xf943[] = { 1, 0x5f04, };
+static const char32 __uni_decomp_data_0xf944[] = { 1, 0x7c60, };
+static const char32 __uni_decomp_data_0xf945[] = { 1, 0x807e, };
+static const char32 __uni_decomp_data_0xf946[] = { 1, 0x7262, };
+static const char32 __uni_decomp_data_0xf947[] = { 1, 0x78ca, };
+static const char32 __uni_decomp_data_0xf948[] = { 1, 0x8cc2, };
+static const char32 __uni_decomp_data_0xf949[] = { 1, 0x96f7, };
+static const char32 __uni_decomp_data_0xf94a[] = { 1, 0x58d8, };
+static const char32 __uni_decomp_data_0xf94b[] = { 1, 0x5c62, };
+static const char32 __uni_decomp_data_0xf94c[] = { 1, 0x6a13, };
+static const char32 __uni_decomp_data_0xf94d[] = { 1, 0x6dda, };
+static const char32 __uni_decomp_data_0xf94e[] = { 1, 0x6f0f, };
+static const char32 __uni_decomp_data_0xf94f[] = { 1, 0x7d2f, };
+static const char32 __uni_decomp_data_0xf950[] = { 1, 0x7e37, };
+static const char32 __uni_decomp_data_0xf951[] = { 1, 0x964b, };
+static const char32 __uni_decomp_data_0xf952[] = { 1, 0x52d2, };
+static const char32 __uni_decomp_data_0xf953[] = { 1, 0x808b, };
+static const char32 __uni_decomp_data_0xf954[] = { 1, 0x51dc, };
+static const char32 __uni_decomp_data_0xf955[] = { 1, 0x51cc, };
+static const char32 __uni_decomp_data_0xf956[] = { 1, 0x7a1c, };
+static const char32 __uni_decomp_data_0xf957[] = { 1, 0x7dbe, };
+static const char32 __uni_decomp_data_0xf958[] = { 1, 0x83f1, };
+static const char32 __uni_decomp_data_0xf959[] = { 1, 0x9675, };
+static const char32 __uni_decomp_data_0xf95a[] = { 1, 0x8b80, };
+static const char32 __uni_decomp_data_0xf95b[] = { 1, 0x62cf, };
+static const char32 __uni_decomp_data_0xf95c[] = { 1, 0x6a02, };
+static const char32 __uni_decomp_data_0xf95d[] = { 1, 0x8afe, };
+static const char32 __uni_decomp_data_0xf95e[] = { 1, 0x4e39, };
+static const char32 __uni_decomp_data_0xf95f[] = { 1, 0x5be7, };
+static const char32 __uni_decomp_data_0xf960[] = { 1, 0x6012, };
+static const char32 __uni_decomp_data_0xf961[] = { 1, 0x7387, };
+static const char32 __uni_decomp_data_0xf962[] = { 1, 0x7570, };
+static const char32 __uni_decomp_data_0xf963[] = { 1, 0x5317, };
+static const char32 __uni_decomp_data_0xf964[] = { 1, 0x78fb, };
+static const char32 __uni_decomp_data_0xf965[] = { 1, 0x4fbf, };
+static const char32 __uni_decomp_data_0xf966[] = { 1, 0x5fa9, };
+static const char32 __uni_decomp_data_0xf967[] = { 1, 0x4e0d, };
+static const char32 __uni_decomp_data_0xf968[] = { 1, 0x6ccc, };
+static const char32 __uni_decomp_data_0xf969[] = { 1, 0x6578, };
+static const char32 __uni_decomp_data_0xf96a[] = { 1, 0x7d22, };
+static const char32 __uni_decomp_data_0xf96b[] = { 1, 0x53c3, };
+static const char32 __uni_decomp_data_0xf96c[] = { 1, 0x585e, };
+static const char32 __uni_decomp_data_0xf96d[] = { 1, 0x7701, };
+static const char32 __uni_decomp_data_0xf96e[] = { 1, 0x8449, };
+static const char32 __uni_decomp_data_0xf96f[] = { 1, 0x8aaa, };
+static const char32 __uni_decomp_data_0xf970[] = { 1, 0x6bba, };
+static const char32 __uni_decomp_data_0xf971[] = { 1, 0x8fb0, };
+static const char32 __uni_decomp_data_0xf972[] = { 1, 0x6c88, };
+static const char32 __uni_decomp_data_0xf973[] = { 1, 0x62fe, };
+static const char32 __uni_decomp_data_0xf974[] = { 1, 0x82e5, };
+static const char32 __uni_decomp_data_0xf975[] = { 1, 0x63a0, };
+static const char32 __uni_decomp_data_0xf976[] = { 1, 0x7565, };
+static const char32 __uni_decomp_data_0xf977[] = { 1, 0x4eae, };
+static const char32 __uni_decomp_data_0xf978[] = { 1, 0x5169, };
+static const char32 __uni_decomp_data_0xf979[] = { 1, 0x51c9, };
+static const char32 __uni_decomp_data_0xf97a[] = { 1, 0x6881, };
+static const char32 __uni_decomp_data_0xf97b[] = { 1, 0x7ce7, };
+static const char32 __uni_decomp_data_0xf97c[] = { 1, 0x826f, };
+static const char32 __uni_decomp_data_0xf97d[] = { 1, 0x8ad2, };
+static const char32 __uni_decomp_data_0xf97e[] = { 1, 0x91cf, };
+static const char32 __uni_decomp_data_0xf97f[] = { 1, 0x52f5, };
 
 
 
@@ -30263,134 +30263,134 @@
 };
 
 
-static const char32 __uni_decomp_data_0xf980[] = { 0x5442, 0, };
-static const char32 __uni_decomp_data_0xf981[] = { 0x5973, 0, };
-static const char32 __uni_decomp_data_0xf982[] = { 0x5eec, 0, };
-static const char32 __uni_decomp_data_0xf983[] = { 0x65c5, 0, };
-static const char32 __uni_decomp_data_0xf984[] = { 0x6ffe, 0, };
-static const char32 __uni_decomp_data_0xf985[] = { 0x792a, 0, };
-static const char32 __uni_decomp_data_0xf986[] = { 0x95ad, 0, };
-static const char32 __uni_decomp_data_0xf987[] = { 0x9a6a, 0, };
-static const char32 __uni_decomp_data_0xf988[] = { 0x9e97, 0, };
-static const char32 __uni_decomp_data_0xf989[] = { 0x9ece, 0, };
-static const char32 __uni_decomp_data_0xf98a[] = { 0x529b, 0, };
-static const char32 __uni_decomp_data_0xf98b[] = { 0x66c6, 0, };
-static const char32 __uni_decomp_data_0xf98c[] = { 0x6b77, 0, };
-static const char32 __uni_decomp_data_0xf98d[] = { 0x8f62, 0, };
-static const char32 __uni_decomp_data_0xf98e[] = { 0x5e74, 0, };
-static const char32 __uni_decomp_data_0xf98f[] = { 0x6190, 0, };
-static const char32 __uni_decomp_data_0xf990[] = { 0x6200, 0, };
-static const char32 __uni_decomp_data_0xf991[] = { 0x649a, 0, };
-static const char32 __uni_decomp_data_0xf992[] = { 0x6f23, 0, };
-static const char32 __uni_decomp_data_0xf993[] = { 0x7149, 0, };
-static const char32 __uni_decomp_data_0xf994[] = { 0x7489, 0, };
-static const char32 __uni_decomp_data_0xf995[] = { 0x79ca, 0, };
-static const char32 __uni_decomp_data_0xf996[] = { 0x7df4, 0, };
-static const char32 __uni_decomp_data_0xf997[] = { 0x806f, 0, };
-static const char32 __uni_decomp_data_0xf998[] = { 0x8f26, 0, };
-static const char32 __uni_decomp_data_0xf999[] = { 0x84ee, 0, };
-static const char32 __uni_decomp_data_0xf99a[] = { 0x9023, 0, };
-static const char32 __uni_decomp_data_0xf99b[] = { 0x934a, 0, };
-static const char32 __uni_decomp_data_0xf99c[] = { 0x5217, 0, };
-static const char32 __uni_decomp_data_0xf99d[] = { 0x52a3, 0, };
-static const char32 __uni_decomp_data_0xf99e[] = { 0x54bd, 0, };
-static const char32 __uni_decomp_data_0xf99f[] = { 0x70c8, 0, };
-static const char32 __uni_decomp_data_0xf9a0[] = { 0x88c2, 0, };
-static const char32 __uni_decomp_data_0xf9a1[] = { 0x8aaa, 0, };
-static const char32 __uni_decomp_data_0xf9a2[] = { 0x5ec9, 0, };
-static const char32 __uni_decomp_data_0xf9a3[] = { 0x5ff5, 0, };
-static const char32 __uni_decomp_data_0xf9a4[] = { 0x637b, 0, };
-static const char32 __uni_decomp_data_0xf9a5[] = { 0x6bae, 0, };
-static const char32 __uni_decomp_data_0xf9a6[] = { 0x7c3e, 0, };
-static const char32 __uni_decomp_data_0xf9a7[] = { 0x7375, 0, };
-static const char32 __uni_decomp_data_0xf9a8[] = { 0x4ee4, 0, };
-static const char32 __uni_decomp_data_0xf9a9[] = { 0x56f9, 0, };
-static const char32 __uni_decomp_data_0xf9aa[] = { 0x5be7, 0, };
-static const char32 __uni_decomp_data_0xf9ab[] = { 0x5dba, 0, };
-static const char32 __uni_decomp_data_0xf9ac[] = { 0x601c, 0, };
-static const char32 __uni_decomp_data_0xf9ad[] = { 0x73b2, 0, };
-static const char32 __uni_decomp_data_0xf9ae[] = { 0x7469, 0, };
-static const char32 __uni_decomp_data_0xf9af[] = { 0x7f9a, 0, };
-static const char32 __uni_decomp_data_0xf9b0[] = { 0x8046, 0, };
-static const char32 __uni_decomp_data_0xf9b1[] = { 0x9234, 0, };
-static const char32 __uni_decomp_data_0xf9b2[] = { 0x96f6, 0, };
-static const char32 __uni_decomp_data_0xf9b3[] = { 0x9748, 0, };
-static const char32 __uni_decomp_data_0xf9b4[] = { 0x9818, 0, };
-static const char32 __uni_decomp_data_0xf9b5[] = { 0x4f8b, 0, };
-static const char32 __uni_decomp_data_0xf9b6[] = { 0x79ae, 0, };
-static const char32 __uni_decomp_data_0xf9b7[] = { 0x91b4, 0, };
-static const char32 __uni_decomp_data_0xf9b8[] = { 0x96b8, 0, };
-static const char32 __uni_decomp_data_0xf9b9[] = { 0x60e1, 0, };
-static const char32 __uni_decomp_data_0xf9ba[] = { 0x4e86, 0, };
-static const char32 __uni_decomp_data_0xf9bb[] = { 0x50da, 0, };
-static const char32 __uni_decomp_data_0xf9bc[] = { 0x5bee, 0, };
-static const char32 __uni_decomp_data_0xf9bd[] = { 0x5c3f, 0, };
-static const char32 __uni_decomp_data_0xf9be[] = { 0x6599, 0, };
-static const char32 __uni_decomp_data_0xf9bf[] = { 0x6a02, 0, };
-static const char32 __uni_decomp_data_0xf9c0[] = { 0x71ce, 0, };
-static const char32 __uni_decomp_data_0xf9c1[] = { 0x7642, 0, };
-static const char32 __uni_decomp_data_0xf9c2[] = { 0x84fc, 0, };
-static const char32 __uni_decomp_data_0xf9c3[] = { 0x907c, 0, };
-static const char32 __uni_decomp_data_0xf9c4[] = { 0x9f8d, 0, };
-static const char32 __uni_decomp_data_0xf9c5[] = { 0x6688, 0, };
-static const char32 __uni_decomp_data_0xf9c6[] = { 0x962e, 0, };
-static const char32 __uni_decomp_data_0xf9c7[] = { 0x5289, 0, };
-static const char32 __uni_decomp_data_0xf9c8[] = { 0x677b, 0, };
-static const char32 __uni_decomp_data_0xf9c9[] = { 0x67f3, 0, };
-static const char32 __uni_decomp_data_0xf9ca[] = { 0x6d41, 0, };
-static const char32 __uni_decomp_data_0xf9cb[] = { 0x6e9c, 0, };
-static const char32 __uni_decomp_data_0xf9cc[] = { 0x7409, 0, };
-static const char32 __uni_decomp_data_0xf9cd[] = { 0x7559, 0, };
-static const char32 __uni_decomp_data_0xf9ce[] = { 0x786b, 0, };
-static const char32 __uni_decomp_data_0xf9cf[] = { 0x7d10, 0, };
-static const char32 __uni_decomp_data_0xf9d0[] = { 0x985e, 0, };
-static const char32 __uni_decomp_data_0xf9d1[] = { 0x516d, 0, };
-static const char32 __uni_decomp_data_0xf9d2[] = { 0x622e, 0, };
-static const char32 __uni_decomp_data_0xf9d3[] = { 0x9678, 0, };
-static const char32 __uni_decomp_data_0xf9d4[] = { 0x502b, 0, };
-static const char32 __uni_decomp_data_0xf9d5[] = { 0x5d19, 0, };
-static const char32 __uni_decomp_data_0xf9d6[] = { 0x6dea, 0, };
-static const char32 __uni_decomp_data_0xf9d7[] = { 0x8f2a, 0, };
-static const char32 __uni_decomp_data_0xf9d8[] = { 0x5f8b, 0, };
-static const char32 __uni_decomp_data_0xf9d9[] = { 0x6144, 0, };
-static const char32 __uni_decomp_data_0xf9da[] = { 0x6817, 0, };
-static const char32 __uni_decomp_data_0xf9db[] = { 0x7387, 0, };
-static const char32 __uni_decomp_data_0xf9dc[] = { 0x9686, 0, };
-static const char32 __uni_decomp_data_0xf9dd[] = { 0x5229, 0, };
-static const char32 __uni_decomp_data_0xf9de[] = { 0x540f, 0, };
-static const char32 __uni_decomp_data_0xf9df[] = { 0x5c65, 0, };
-static const char32 __uni_decomp_data_0xf9e0[] = { 0x6613, 0, };
-static const char32 __uni_decomp_data_0xf9e1[] = { 0x674e, 0, };
-static const char32 __uni_decomp_data_0xf9e2[] = { 0x68a8, 0, };
-static const char32 __uni_decomp_data_0xf9e3[] = { 0x6ce5, 0, };
-static const char32 __uni_decomp_data_0xf9e4[] = { 0x7406, 0, };
-static const char32 __uni_decomp_data_0xf9e5[] = { 0x75e2, 0, };
-static const char32 __uni_decomp_data_0xf9e6[] = { 0x7f79, 0, };
-static const char32 __uni_decomp_data_0xf9e7[] = { 0x88cf, 0, };
-static const char32 __uni_decomp_data_0xf9e8[] = { 0x88e1, 0, };
-static const char32 __uni_decomp_data_0xf9e9[] = { 0x91cc, 0, };
-static const char32 __uni_decomp_data_0xf9ea[] = { 0x96e2, 0, };
-static const char32 __uni_decomp_data_0xf9eb[] = { 0x533f, 0, };
-static const char32 __uni_decomp_data_0xf9ec[] = { 0x6eba, 0, };
-static const char32 __uni_decomp_data_0xf9ed[] = { 0x541d, 0, };
-static const char32 __uni_decomp_data_0xf9ee[] = { 0x71d0, 0, };
-static const char32 __uni_decomp_data_0xf9ef[] = { 0x7498, 0, };
-static const char32 __uni_decomp_data_0xf9f0[] = { 0x85fa, 0, };
-static const char32 __uni_decomp_data_0xf9f1[] = { 0x96a3, 0, };
-static const char32 __uni_decomp_data_0xf9f2[] = { 0x9c57, 0, };
-static const char32 __uni_decomp_data_0xf9f3[] = { 0x9e9f, 0, };
-static const char32 __uni_decomp_data_0xf9f4[] = { 0x6797, 0, };
-static const char32 __uni_decomp_data_0xf9f5[] = { 0x6dcb, 0, };
-static const char32 __uni_decomp_data_0xf9f6[] = { 0x81e8, 0, };
-static const char32 __uni_decomp_data_0xf9f7[] = { 0x7acb, 0, };
-static const char32 __uni_decomp_data_0xf9f8[] = { 0x7b20, 0, };
-static const char32 __uni_decomp_data_0xf9f9[] = { 0x7c92, 0, };
-static const char32 __uni_decomp_data_0xf9fa[] = { 0x72c0, 0, };
-static const char32 __uni_decomp_data_0xf9fb[] = { 0x7099, 0, };
-static const char32 __uni_decomp_data_0xf9fc[] = { 0x8b58, 0, };
-static const char32 __uni_decomp_data_0xf9fd[] = { 0x4ec0, 0, };
-static const char32 __uni_decomp_data_0xf9fe[] = { 0x8336, 0, };
-static const char32 __uni_decomp_data_0xf9ff[] = { 0x523a, 0, };
+static const char32 __uni_decomp_data_0xf980[] = { 1, 0x5442, };
+static const char32 __uni_decomp_data_0xf981[] = { 1, 0x5973, };
+static const char32 __uni_decomp_data_0xf982[] = { 1, 0x5eec, };
+static const char32 __uni_decomp_data_0xf983[] = { 1, 0x65c5, };
+static const char32 __uni_decomp_data_0xf984[] = { 1, 0x6ffe, };
+static const char32 __uni_decomp_data_0xf985[] = { 1, 0x792a, };
+static const char32 __uni_decomp_data_0xf986[] = { 1, 0x95ad, };
+static const char32 __uni_decomp_data_0xf987[] = { 1, 0x9a6a, };
+static const char32 __uni_decomp_data_0xf988[] = { 1, 0x9e97, };
+static const char32 __uni_decomp_data_0xf989[] = { 1, 0x9ece, };
+static const char32 __uni_decomp_data_0xf98a[] = { 1, 0x529b, };
+static const char32 __uni_decomp_data_0xf98b[] = { 1, 0x66c6, };
+static const char32 __uni_decomp_data_0xf98c[] = { 1, 0x6b77, };
+static const char32 __uni_decomp_data_0xf98d[] = { 1, 0x8f62, };
+static const char32 __uni_decomp_data_0xf98e[] = { 1, 0x5e74, };
+static const char32 __uni_decomp_data_0xf98f[] = { 1, 0x6190, };
+static const char32 __uni_decomp_data_0xf990[] = { 1, 0x6200, };
+static const char32 __uni_decomp_data_0xf991[] = { 1, 0x649a, };
+static const char32 __uni_decomp_data_0xf992[] = { 1, 0x6f23, };
+static const char32 __uni_decomp_data_0xf993[] = { 1, 0x7149, };
+static const char32 __uni_decomp_data_0xf994[] = { 1, 0x7489, };
+static const char32 __uni_decomp_data_0xf995[] = { 1, 0x79ca, };
+static const char32 __uni_decomp_data_0xf996[] = { 1, 0x7df4, };
+static const char32 __uni_decomp_data_0xf997[] = { 1, 0x806f, };
+static const char32 __uni_decomp_data_0xf998[] = { 1, 0x8f26, };
+static const char32 __uni_decomp_data_0xf999[] = { 1, 0x84ee, };
+static const char32 __uni_decomp_data_0xf99a[] = { 1, 0x9023, };
+static const char32 __uni_decomp_data_0xf99b[] = { 1, 0x934a, };
+static const char32 __uni_decomp_data_0xf99c[] = { 1, 0x5217, };
+static const char32 __uni_decomp_data_0xf99d[] = { 1, 0x52a3, };
+static const char32 __uni_decomp_data_0xf99e[] = { 1, 0x54bd, };
+static const char32 __uni_decomp_data_0xf99f[] = { 1, 0x70c8, };
+static const char32 __uni_decomp_data_0xf9a0[] = { 1, 0x88c2, };
+static const char32 __uni_decomp_data_0xf9a1[] = { 1, 0x8aaa, };
+static const char32 __uni_decomp_data_0xf9a2[] = { 1, 0x5ec9, };
+static const char32 __uni_decomp_data_0xf9a3[] = { 1, 0x5ff5, };
+static const char32 __uni_decomp_data_0xf9a4[] = { 1, 0x637b, };
+static const char32 __uni_decomp_data_0xf9a5[] = { 1, 0x6bae, };
+static const char32 __uni_decomp_data_0xf9a6[] = { 1, 0x7c3e, };
+static const char32 __uni_decomp_data_0xf9a7[] = { 1, 0x7375, };
+static const char32 __uni_decomp_data_0xf9a8[] = { 1, 0x4ee4, };
+static const char32 __uni_decomp_data_0xf9a9[] = { 1, 0x56f9, };
+static const char32 __uni_decomp_data_0xf9aa[] = { 1, 0x5be7, };
+static const char32 __uni_decomp_data_0xf9ab[] = { 1, 0x5dba, };
+static const char32 __uni_decomp_data_0xf9ac[] = { 1, 0x601c, };
+static const char32 __uni_decomp_data_0xf9ad[] = { 1, 0x73b2, };
+static const char32 __uni_decomp_data_0xf9ae[] = { 1, 0x7469, };
+static const char32 __uni_decomp_data_0xf9af[] = { 1, 0x7f9a, };
+static const char32 __uni_decomp_data_0xf9b0[] = { 1, 0x8046, };
+static const char32 __uni_decomp_data_0xf9b1[] = { 1, 0x9234, };
+static const char32 __uni_decomp_data_0xf9b2[] = { 1, 0x96f6, };
+static const char32 __uni_decomp_data_0xf9b3[] = { 1, 0x9748, };
+static const char32 __uni_decomp_data_0xf9b4[] = { 1, 0x9818, };
+static const char32 __uni_decomp_data_0xf9b5[] = { 1, 0x4f8b, };
+static const char32 __uni_decomp_data_0xf9b6[] = { 1, 0x79ae, };
+static const char32 __uni_decomp_data_0xf9b7[] = { 1, 0x91b4, };
+static const char32 __uni_decomp_data_0xf9b8[] = { 1, 0x96b8, };
+static const char32 __uni_decomp_data_0xf9b9[] = { 1, 0x60e1, };
+static const char32 __uni_decomp_data_0xf9ba[] = { 1, 0x4e86, };
+static const char32 __uni_decomp_data_0xf9bb[] = { 1, 0x50da, };
+static const char32 __uni_decomp_data_0xf9bc[] = { 1, 0x5bee, };
+static const char32 __uni_decomp_data_0xf9bd[] = { 1, 0x5c3f, };
+static const char32 __uni_decomp_data_0xf9be[] = { 1, 0x6599, };
+static const char32 __uni_decomp_data_0xf9bf[] = { 1, 0x6a02, };
+static const char32 __uni_decomp_data_0xf9c0[] = { 1, 0x71ce, };
+static const char32 __uni_decomp_data_0xf9c1[] = { 1, 0x7642, };
+static const char32 __uni_decomp_data_0xf9c2[] = { 1, 0x84fc, };
+static const char32 __uni_decomp_data_0xf9c3[] = { 1, 0x907c, };
+static const char32 __uni_decomp_data_0xf9c4[] = { 1, 0x9f8d, };
+static const char32 __uni_decomp_data_0xf9c5[] = { 1, 0x6688, };
+static const char32 __uni_decomp_data_0xf9c6[] = { 1, 0x962e, };
+static const char32 __uni_decomp_data_0xf9c7[] = { 1, 0x5289, };
+static const char32 __uni_decomp_data_0xf9c8[] = { 1, 0x677b, };
+static const char32 __uni_decomp_data_0xf9c9[] = { 1, 0x67f3, };
+static const char32 __uni_decomp_data_0xf9ca[] = { 1, 0x6d41, };
+static const char32 __uni_decomp_data_0xf9cb[] = { 1, 0x6e9c, };
+static const char32 __uni_decomp_data_0xf9cc[] = { 1, 0x7409, };
+static const char32 __uni_decomp_data_0xf9cd[] = { 1, 0x7559, };
+static const char32 __uni_decomp_data_0xf9ce[] = { 1, 0x786b, };
+static const char32 __uni_decomp_data_0xf9cf[] = { 1, 0x7d10, };
+static const char32 __uni_decomp_data_0xf9d0[] = { 1, 0x985e, };
+static const char32 __uni_decomp_data_0xf9d1[] = { 1, 0x516d, };
+static const char32 __uni_decomp_data_0xf9d2[] = { 1, 0x622e, };
+static const char32 __uni_decomp_data_0xf9d3[] = { 1, 0x9678, };
+static const char32 __uni_decomp_data_0xf9d4[] = { 1, 0x502b, };
+static const char32 __uni_decomp_data_0xf9d5[] = { 1, 0x5d19, };
+static const char32 __uni_decomp_data_0xf9d6[] = { 1, 0x6dea, };
+static const char32 __uni_decomp_data_0xf9d7[] = { 1, 0x8f2a, };
+static const char32 __uni_decomp_data_0xf9d8[] = { 1, 0x5f8b, };
+static const char32 __uni_decomp_data_0xf9d9[] = { 1, 0x6144, };
+static const char32 __uni_decomp_data_0xf9da[] = { 1, 0x6817, };
+static const char32 __uni_decomp_data_0xf9db[] = { 1, 0x7387, };
+static const char32 __uni_decomp_data_0xf9dc[] = { 1, 0x9686, };
+static const char32 __uni_decomp_data_0xf9dd[] = { 1, 0x5229, };
+static const char32 __uni_decomp_data_0xf9de[] = { 1, 0x540f, };
+static const char32 __uni_decomp_data_0xf9df[] = { 1, 0x5c65, };
+static const char32 __uni_decomp_data_0xf9e0[] = { 1, 0x6613, };
+static const char32 __uni_decomp_data_0xf9e1[] = { 1, 0x674e, };
+static const char32 __uni_decomp_data_0xf9e2[] = { 1, 0x68a8, };
+static const char32 __uni_decomp_data_0xf9e3[] = { 1, 0x6ce5, };
+static const char32 __uni_decomp_data_0xf9e4[] = { 1, 0x7406, };
+static const char32 __uni_decomp_data_0xf9e5[] = { 1, 0x75e2, };
+static const char32 __uni_decomp_data_0xf9e6[] = { 1, 0x7f79, };
+static const char32 __uni_decomp_data_0xf9e7[] = { 1, 0x88cf, };
+static const char32 __uni_decomp_data_0xf9e8[] = { 1, 0x88e1, };
+static const char32 __uni_decomp_data_0xf9e9[] = { 1, 0x91cc, };
+static const char32 __uni_decomp_data_0xf9ea[] = { 1, 0x96e2, };
+static const char32 __uni_decomp_data_0xf9eb[] = { 1, 0x533f, };
+static const char32 __uni_decomp_data_0xf9ec[] = { 1, 0x6eba, };
+static const char32 __uni_decomp_data_0xf9ed[] = { 1, 0x541d, };
+static const char32 __uni_decomp_data_0xf9ee[] = { 1, 0x71d0, };
+static const char32 __uni_decomp_data_0xf9ef[] = { 1, 0x7498, };
+static const char32 __uni_decomp_data_0xf9f0[] = { 1, 0x85fa, };
+static const char32 __uni_decomp_data_0xf9f1[] = { 1, 0x96a3, };
+static const char32 __uni_decomp_data_0xf9f2[] = { 1, 0x9c57, };
+static const char32 __uni_decomp_data_0xf9f3[] = { 1, 0x9e9f, };
+static const char32 __uni_decomp_data_0xf9f4[] = { 1, 0x6797, };
+static const char32 __uni_decomp_data_0xf9f5[] = { 1, 0x6dcb, };
+static const char32 __uni_decomp_data_0xf9f6[] = { 1, 0x81e8, };
+static const char32 __uni_decomp_data_0xf9f7[] = { 1, 0x7acb, };
+static const char32 __uni_decomp_data_0xf9f8[] = { 1, 0x7b20, };
+static const char32 __uni_decomp_data_0xf9f9[] = { 1, 0x7c92, };
+static const char32 __uni_decomp_data_0xf9fa[] = { 1, 0x72c0, };
+static const char32 __uni_decomp_data_0xf9fb[] = { 1, 0x7099, };
+static const char32 __uni_decomp_data_0xf9fc[] = { 1, 0x8b58, };
+static const char32 __uni_decomp_data_0xf9fd[] = { 1, 0x4ec0, };
+static const char32 __uni_decomp_data_0xf9fe[] = { 1, 0x8336, };
+static const char32 __uni_decomp_data_0xf9ff[] = { 1, 0x523a, };
 
 
 
@@ -32064,115 +32064,115 @@
 };
 
 
-static const char32 __uni_decomp_data_0xfa00[] = { 0x5207, 0, };
-static const char32 __uni_decomp_data_0xfa01[] = { 0x5ea6, 0, };
-static const char32 __uni_decomp_data_0xfa02[] = { 0x62d3, 0, };
-static const char32 __uni_decomp_data_0xfa03[] = { 0x7cd6, 0, };
-static const char32 __uni_decomp_data_0xfa04[] = { 0x5b85, 0, };
-static const char32 __uni_decomp_data_0xfa05[] = { 0x6d1e, 0, };
-static const char32 __uni_decomp_data_0xfa06[] = { 0x66b4, 0, };
-static const char32 __uni_decomp_data_0xfa07[] = { 0x8f3b, 0, };
-static const char32 __uni_decomp_data_0xfa08[] = { 0x884c, 0, };
-static const char32 __uni_decomp_data_0xfa09[] = { 0x964d, 0, };
-static const char32 __uni_decomp_data_0xfa0a[] = { 0x898b, 0, };
-static const char32 __uni_decomp_data_0xfa0b[] = { 0x5ed3, 0, };
-static const char32 __uni_decomp_data_0xfa0c[] = { 0x5140, 0, };
-static const char32 __uni_decomp_data_0xfa0d[] = { 0x55c0, 0, };
-static const char32 __uni_decomp_data_0xfa10[] = { 0x585a, 0, };
-static const char32 __uni_decomp_data_0xfa12[] = { 0x6674, 0, };
-static const char32 __uni_decomp_data_0xfa15[] = { 0x51de, 0, };
-static const char32 __uni_decomp_data_0xfa16[] = { 0x732a, 0, };
-static const char32 __uni_decomp_data_0xfa17[] = { 0x76ca, 0, };
-static const char32 __uni_decomp_data_0xfa18[] = { 0x793c, 0, };
-static const char32 __uni_decomp_data_0xfa19[] = { 0x795e, 0, };
-static const char32 __uni_decomp_data_0xfa1a[] = { 0x7965, 0, };
-static const char32 __uni_decomp_data_0xfa1b[] = { 0x798f, 0, };
-static const char32 __uni_decomp_data_0xfa1c[] = { 0x9756, 0, };
-static const char32 __uni_decomp_data_0xfa1d[] = { 0x7cbe, 0, };
-static const char32 __uni_decomp_data_0xfa1e[] = { 0x7fbd, 0, };
-static const char32 __uni_decomp_data_0xfa20[] = { 0x8612, 0, };
-static const char32 __uni_decomp_data_0xfa22[] = { 0x8af8, 0, };
-static const char32 __uni_decomp_data_0xfa25[] = { 0x9038, 0, };
-static const char32 __uni_decomp_data_0xfa26[] = { 0x90fd, 0, };
-static const char32 __uni_decomp_data_0xfa2a[] = { 0x98ef, 0, };
-static const char32 __uni_decomp_data_0xfa2b[] = { 0x98fc, 0, };
-static const char32 __uni_decomp_data_0xfa2c[] = { 0x9928, 0, };
-static const char32 __uni_decomp_data_0xfa2d[] = { 0x9db4, 0, };
-static const char32 __uni_decomp_data_0xfa30[] = { 0x4fae, 0, };
-static const char32 __uni_decomp_data_0xfa31[] = { 0x50e7, 0, };
-static const char32 __uni_decomp_data_0xfa32[] = { 0x514d, 0, };
-static const char32 __uni_decomp_data_0xfa33[] = { 0x52c9, 0, };
-static const char32 __uni_decomp_data_0xfa34[] = { 0x52e4, 0, };
-static const char32 __uni_decomp_data_0xfa35[] = { 0x5351, 0, };
-static const char32 __uni_decomp_data_0xfa36[] = { 0x559d, 0, };
-static const char32 __uni_decomp_data_0xfa37[] = { 0x5606, 0, };
-static const char32 __uni_decomp_data_0xfa38[] = { 0x5668, 0, };
-static const char32 __uni_decomp_data_0xfa39[] = { 0x5840, 0, };
-static const char32 __uni_decomp_data_0xfa3a[] = { 0x58a8, 0, };
-static const char32 __uni_decomp_data_0xfa3b[] = { 0x5c64, 0, };
-static const char32 __uni_decomp_data_0xfa3c[] = { 0x5c6e, 0, };
-static const char32 __uni_decomp_data_0xfa3d[] = { 0x6094, 0, };
-static const char32 __uni_decomp_data_0xfa3e[] = { 0x6168, 0, };
-static const char32 __uni_decomp_data_0xfa3f[] = { 0x618e, 0, };
-static const char32 __uni_decomp_data_0xfa40[] = { 0x61f2, 0, };
-static const char32 __uni_decomp_data_0xfa41[] = { 0x654f, 0, };
-static const char32 __uni_decomp_data_0xfa42[] = { 0x65e2, 0, };
-static const char32 __uni_decomp_data_0xfa43[] = { 0x6691, 0, };
-static const char32 __uni_decomp_data_0xfa44[] = { 0x6885, 0, };
-static const char32 __uni_decomp_data_0xfa45[] = { 0x6d77, 0, };
-static const char32 __uni_decomp_data_0xfa46[] = { 0x6e1a, 0, };
-static const char32 __uni_decomp_data_0xfa47[] = { 0x6f22, 0, };
-static const char32 __uni_decomp_data_0xfa48[] = { 0x716e, 0, };
-static const char32 __uni_decomp_data_0xfa49[] = { 0x722b, 0, };
-static const char32 __uni_decomp_data_0xfa4a[] = { 0x7422, 0, };
-static const char32 __uni_decomp_data_0xfa4b[] = { 0x7891, 0, };
-static const char32 __uni_decomp_data_0xfa4c[] = { 0x793e, 0, };
-static const char32 __uni_decomp_data_0xfa4d[] = { 0x7949, 0, };
-static const char32 __uni_decomp_data_0xfa4e[] = { 0x7948, 0, };
-static const char32 __uni_decomp_data_0xfa4f[] = { 0x7950, 0, };
-static const char32 __uni_decomp_data_0xfa50[] = { 0x7956, 0, };
-static const char32 __uni_decomp_data_0xfa51[] = { 0x795d, 0, };
-static const char32 __uni_decomp_data_0xfa52[] = { 0x798d, 0, };
-static const char32 __uni_decomp_data_0xfa53[] = { 0x798e, 0, };
-static const char32 __uni_decomp_data_0xfa54[] = { 0x7a40, 0, };
-static const char32 __uni_decomp_data_0xfa55[] = { 0x7a81, 0, };
-static const char32 __uni_decomp_data_0xfa56[] = { 0x7bc0, 0, };
-static const char32 __uni_decomp_data_0xfa57[] = { 0x7df4, 0, };
-static const char32 __uni_decomp_data_0xfa58[] = { 0x7e09, 0, };
-static const char32 __uni_decomp_data_0xfa59[] = { 0x7e41, 0, };
-static const char32 __uni_decomp_data_0xfa5a[] = { 0x7f72, 0, };
-static const char32 __uni_decomp_data_0xfa5b[] = { 0x8005, 0, };
-static const char32 __uni_decomp_data_0xfa5c[] = { 0x81ed, 0, };
-static const char32 __uni_decomp_data_0xfa5d[] = { 0x8279, 0, };
-static const char32 __uni_decomp_data_0xfa5e[] = { 0x8279, 0, };
-static const char32 __uni_decomp_data_0xfa5f[] = { 0x8457, 0, };
-static const char32 __uni_decomp_data_0xfa60[] = { 0x8910, 0, };
-static const char32 __uni_decomp_data_0xfa61[] = { 0x8996, 0, };
-static const char32 __uni_decomp_data_0xfa62[] = { 0x8b01, 0, };
-static const char32 __uni_decomp_data_0xfa63[] = { 0x8b39, 0, };
-static const char32 __uni_decomp_data_0xfa64[] = { 0x8cd3, 0, };
-static const char32 __uni_decomp_data_0xfa65[] = { 0x8d08, 0, };
-static const char32 __uni_decomp_data_0xfa66[] = { 0x8fb6, 0, };
-static const char32 __uni_decomp_data_0xfa67[] = { 0x9038, 0, };
-static const char32 __uni_decomp_data_0xfa68[] = { 0x96e3, 0, };
-static const char32 __uni_decomp_data_0xfa69[] = { 0x97ff, 0, };
-static const char32 __uni_decomp_data_0xfa6a[] = { 0x983b, 0, };
-static const char32 __uni_decomp_data_0xfa70[] = { 0x4e26, 0, };
-static const char32 __uni_decomp_data_0xfa71[] = { 0x51b5, 0, };
-static const char32 __uni_decomp_data_0xfa72[] = { 0x5168, 0, };
-static const char32 __uni_decomp_data_0xfa73[] = { 0x4f80, 0, };
-static const char32 __uni_decomp_data_0xfa74[] = { 0x5145, 0, };
-static const char32 __uni_decomp_data_0xfa75[] = { 0x5180, 0, };
-static const char32 __uni_decomp_data_0xfa76[] = { 0x52c7, 0, };
-static const char32 __uni_decomp_data_0xfa77[] = { 0x52fa, 0, };
-static const char32 __uni_decomp_data_0xfa78[] = { 0x559d, 0, };
-static const char32 __uni_decomp_data_0xfa79[] = { 0x5555, 0, };
-static const char32 __uni_decomp_data_0xfa7a[] = { 0x5599, 0, };
-static const char32 __uni_decomp_data_0xfa7b[] = { 0x55e2, 0, };
-static const char32 __uni_decomp_data_0xfa7c[] = { 0x585a, 0, };
-static const char32 __uni_decomp_data_0xfa7d[] = { 0x58b3, 0, };
-static const char32 __uni_decomp_data_0xfa7e[] = { 0x5944, 0, };
-static const char32 __uni_decomp_data_0xfa7f[] = { 0x5954, 0, };
+static const char32 __uni_decomp_data_0xfa00[] = { 1, 0x5207, };
+static const char32 __uni_decomp_data_0xfa01[] = { 1, 0x5ea6, };
+static const char32 __uni_decomp_data_0xfa02[] = { 1, 0x62d3, };
+static const char32 __uni_decomp_data_0xfa03[] = { 1, 0x7cd6, };
+static const char32 __uni_decomp_data_0xfa04[] = { 1, 0x5b85, };
+static const char32 __uni_decomp_data_0xfa05[] = { 1, 0x6d1e, };
+static const char32 __uni_decomp_data_0xfa06[] = { 1, 0x66b4, };
+static const char32 __uni_decomp_data_0xfa07[] = { 1, 0x8f3b, };
+static const char32 __uni_decomp_data_0xfa08[] = { 1, 0x884c, };
+static const char32 __uni_decomp_data_0xfa09[] = { 1, 0x964d, };
+static const char32 __uni_decomp_data_0xfa0a[] = { 1, 0x898b, };
+static const char32 __uni_decomp_data_0xfa0b[] = { 1, 0x5ed3, };
+static const char32 __uni_decomp_data_0xfa0c[] = { 1, 0x5140, };
+static const char32 __uni_decomp_data_0xfa0d[] = { 1, 0x55c0, };
+static const char32 __uni_decomp_data_0xfa10[] = { 1, 0x585a, };
+static const char32 __uni_decomp_data_0xfa12[] = { 1, 0x6674, };
+static const char32 __uni_decomp_data_0xfa15[] = { 1, 0x51de, };
+static const char32 __uni_decomp_data_0xfa16[] = { 1, 0x732a, };
+static const char32 __uni_decomp_data_0xfa17[] = { 1, 0x76ca, };
+static const char32 __uni_decomp_data_0xfa18[] = { 1, 0x793c, };
+static const char32 __uni_decomp_data_0xfa19[] = { 1, 0x795e, };
+static const char32 __uni_decomp_data_0xfa1a[] = { 1, 0x7965, };
+static const char32 __uni_decomp_data_0xfa1b[] = { 1, 0x798f, };
+static const char32 __uni_decomp_data_0xfa1c[] = { 1, 0x9756, };
+static const char32 __uni_decomp_data_0xfa1d[] = { 1, 0x7cbe, };
+static const char32 __uni_decomp_data_0xfa1e[] = { 1, 0x7fbd, };
+static const char32 __uni_decomp_data_0xfa20[] = { 1, 0x8612, };
+static const char32 __uni_decomp_data_0xfa22[] = { 1, 0x8af8, };
+static const char32 __uni_decomp_data_0xfa25[] = { 1, 0x9038, };
+static const char32 __uni_decomp_data_0xfa26[] = { 1, 0x90fd, };
+static const char32 __uni_decomp_data_0xfa2a[] = { 1, 0x98ef, };
+static const char32 __uni_decomp_data_0xfa2b[] = { 1, 0x98fc, };
+static const char32 __uni_decomp_data_0xfa2c[] = { 1, 0x9928, };
+static const char32 __uni_decomp_data_0xfa2d[] = { 1, 0x9db4, };
+static const char32 __uni_decomp_data_0xfa30[] = { 1, 0x4fae, };
+static const char32 __uni_decomp_data_0xfa31[] = { 1, 0x50e7, };
+static const char32 __uni_decomp_data_0xfa32[] = { 1, 0x514d, };
+static const char32 __uni_decomp_data_0xfa33[] = { 1, 0x52c9, };
+static const char32 __uni_decomp_data_0xfa34[] = { 1, 0x52e4, };
+static const char32 __uni_decomp_data_0xfa35[] = { 1, 0x5351, };
+static const char32 __uni_decomp_data_0xfa36[] = { 1, 0x559d, };
+static const char32 __uni_decomp_data_0xfa37[] = { 1, 0x5606, };
+static const char32 __uni_decomp_data_0xfa38[] = { 1, 0x5668, };
+static const char32 __uni_decomp_data_0xfa39[] = { 1, 0x5840, };
+static const char32 __uni_decomp_data_0xfa3a[] = { 1, 0x58a8, };
+static const char32 __uni_decomp_data_0xfa3b[] = { 1, 0x5c64, };
+static const char32 __uni_decomp_data_0xfa3c[] = { 1, 0x5c6e, };
+static const char32 __uni_decomp_data_0xfa3d[] = { 1, 0x6094, };
+static const char32 __uni_decomp_data_0xfa3e[] = { 1, 0x6168, };
+static const char32 __uni_decomp_data_0xfa3f[] = { 1, 0x618e, };
+static const char32 __uni_decomp_data_0xfa40[] = { 1, 0x61f2, };
+static const char32 __uni_decomp_data_0xfa41[] = { 1, 0x654f, };
+static const char32 __uni_decomp_data_0xfa42[] = { 1, 0x65e2, };
+static const char32 __uni_decomp_data_0xfa43[] = { 1, 0x6691, };
+static const char32 __uni_decomp_data_0xfa44[] = { 1, 0x6885, };
+static const char32 __uni_decomp_data_0xfa45[] = { 1, 0x6d77, };
+static const char32 __uni_decomp_data_0xfa46[] = { 1, 0x6e1a, };
+static const char32 __uni_decomp_data_0xfa47[] = { 1, 0x6f22, };
+static const char32 __uni_decomp_data_0xfa48[] = { 1, 0x716e, };
+static const char32 __uni_decomp_data_0xfa49[] = { 1, 0x722b, };
+static const char32 __uni_decomp_data_0xfa4a[] = { 1, 0x7422, };
+static const char32 __uni_decomp_data_0xfa4b[] = { 1, 0x7891, };
+static const char32 __uni_decomp_data_0xfa4c[] = { 1, 0x793e, };
+static const char32 __uni_decomp_data_0xfa4d[] = { 1, 0x7949, };
+static const char32 __uni_decomp_data_0xfa4e[] = { 1, 0x7948, };
+static const char32 __uni_decomp_data_0xfa4f[] = { 1, 0x7950, };
+static const char32 __uni_decomp_data_0xfa50[] = { 1, 0x7956, };
+static const char32 __uni_decomp_data_0xfa51[] = { 1, 0x795d, };
+static const char32 __uni_decomp_data_0xfa52[] = { 1, 0x798d, };
+static const char32 __uni_decomp_data_0xfa53[] = { 1, 0x798e, };
+static const char32 __uni_decomp_data_0xfa54[] = { 1, 0x7a40, };
+static const char32 __uni_decomp_data_0xfa55[] = { 1, 0x7a81, };
+static const char32 __uni_decomp_data_0xfa56[] = { 1, 0x7bc0, };
+static const char32 __uni_decomp_data_0xfa57[] = { 1, 0x7df4, };
+static const char32 __uni_decomp_data_0xfa58[] = { 1, 0x7e09, };
+static const char32 __uni_decomp_data_0xfa59[] = { 1, 0x7e41, };
+static const char32 __uni_decomp_data_0xfa5a[] = { 1, 0x7f72, };
+static const char32 __uni_decomp_data_0xfa5b[] = { 1, 0x8005, };
+static const char32 __uni_decomp_data_0xfa5c[] = { 1, 0x81ed, };
+static const char32 __uni_decomp_data_0xfa5d[] = { 1, 0x8279, };
+static const char32 __uni_decomp_data_0xfa5e[] = { 1, 0x8279, };
+static const char32 __uni_decomp_data_0xfa5f[] = { 1, 0x8457, };
+static const char32 __uni_decomp_data_0xfa60[] = { 1, 0x8910, };
+static const char32 __uni_decomp_data_0xfa61[] = { 1, 0x8996, };
+static const char32 __uni_decomp_data_0xfa62[] = { 1, 0x8b01, };
+static const char32 __uni_decomp_data_0xfa63[] = { 1, 0x8b39, };
+static const char32 __uni_decomp_data_0xfa64[] = { 1, 0x8cd3, };
+static const char32 __uni_decomp_data_0xfa65[] = { 1, 0x8d08, };
+static const char32 __uni_decomp_data_0xfa66[] = { 1, 0x8fb6, };
+static const char32 __uni_decomp_data_0xfa67[] = { 1, 0x9038, };
+static const char32 __uni_decomp_data_0xfa68[] = { 1, 0x96e3, };
+static const char32 __uni_decomp_data_0xfa69[] = { 1, 0x97ff, };
+static const char32 __uni_decomp_data_0xfa6a[] = { 1, 0x983b, };
+static const char32 __uni_decomp_data_0xfa70[] = { 1, 0x4e26, };
+static const char32 __uni_decomp_data_0xfa71[] = { 1, 0x51b5, };
+static const char32 __uni_decomp_data_0xfa72[] = { 1, 0x5168, };
+static const char32 __uni_decomp_data_0xfa73[] = { 1, 0x4f80, };
+static const char32 __uni_decomp_data_0xfa74[] = { 1, 0x5145, };
+static const char32 __uni_decomp_data_0xfa75[] = { 1, 0x5180, };
+static const char32 __uni_decomp_data_0xfa76[] = { 1, 0x52c7, };
+static const char32 __uni_decomp_data_0xfa77[] = { 1, 0x52fa, };
+static const char32 __uni_decomp_data_0xfa78[] = { 1, 0x559d, };
+static const char32 __uni_decomp_data_0xfa79[] = { 1, 0x5555, };
+static const char32 __uni_decomp_data_0xfa7a[] = { 1, 0x5599, };
+static const char32 __uni_decomp_data_0xfa7b[] = { 1, 0x55e2, };
+static const char32 __uni_decomp_data_0xfa7c[] = { 1, 0x585a, };
+static const char32 __uni_decomp_data_0xfa7d[] = { 1, 0x58b3, };
+static const char32 __uni_decomp_data_0xfa7e[] = { 1, 0x5944, };
+static const char32 __uni_decomp_data_0xfa7f[] = { 1, 0x5954, };
 
 
 
@@ -33846,96 +33846,96 @@
 };
 
 
-static const char32 __uni_decomp_data_0xfa80[] = { 0x5a62, 0, };
-static const char32 __uni_decomp_data_0xfa81[] = { 0x5b28, 0, };
-static const char32 __uni_decomp_data_0xfa82[] = { 0x5ed2, 0, };
-static const char32 __uni_decomp_data_0xfa83[] = { 0x5ed9, 0, };
-static const char32 __uni_decomp_data_0xfa84[] = { 0x5f69, 0, };
-static const char32 __uni_decomp_data_0xfa85[] = { 0x5fad, 0, };
-static const char32 __uni_decomp_data_0xfa86[] = { 0x60d8, 0, };
-static const char32 __uni_decomp_data_0xfa87[] = { 0x614e, 0, };
-static const char32 __uni_decomp_data_0xfa88[] = { 0x6108, 0, };
-static const char32 __uni_decomp_data_0xfa89[] = { 0x618e, 0, };
-static const char32 __uni_decomp_data_0xfa8a[] = { 0x6160, 0, };
-static const char32 __uni_decomp_data_0xfa8b[] = { 0x61f2, 0, };
-static const char32 __uni_decomp_data_0xfa8c[] = { 0x6234, 0, };
-static const char32 __uni_decomp_data_0xfa8d[] = { 0x63c4, 0, };
-static const char32 __uni_decomp_data_0xfa8e[] = { 0x641c, 0, };
-static const char32 __uni_decomp_data_0xfa8f[] = { 0x6452, 0, };
-static const char32 __uni_decomp_data_0xfa90[] = { 0x6556, 0, };
-static const char32 __uni_decomp_data_0xfa91[] = { 0x6674, 0, };
-static const char32 __uni_decomp_data_0xfa92[] = { 0x6717, 0, };
-static const char32 __uni_decomp_data_0xfa93[] = { 0x671b, 0, };
-static const char32 __uni_decomp_data_0xfa94[] = { 0x6756, 0, };
-static const char32 __uni_decomp_data_0xfa95[] = { 0x6b79, 0, };
-static const char32 __uni_decomp_data_0xfa96[] = { 0x6bba, 0, };
-static const char32 __uni_decomp_data_0xfa97[] = { 0x6d41, 0, };
-static const char32 __uni_decomp_data_0xfa98[] = { 0x6edb, 0, };
-static const char32 __uni_decomp_data_0xfa99[] = { 0x6ecb, 0, };
-static const char32 __uni_decomp_data_0xfa9a[] = { 0x6f22, 0, };
-static const char32 __uni_decomp_data_0xfa9b[] = { 0x701e, 0, };
-static const char32 __uni_decomp_data_0xfa9c[] = { 0x716e, 0, };
-static const char32 __uni_decomp_data_0xfa9d[] = { 0x77a7, 0, };
-static const char32 __uni_decomp_data_0xfa9e[] = { 0x7235, 0, };
-static const char32 __uni_decomp_data_0xfa9f[] = { 0x72af, 0, };
-static const char32 __uni_decomp_data_0xfaa0[] = { 0x732a, 0, };
-static const char32 __uni_decomp_data_0xfaa1[] = { 0x7471, 0, };
-static const char32 __uni_decomp_data_0xfaa2[] = { 0x7506, 0, };
-static const char32 __uni_decomp_data_0xfaa3[] = { 0x753b, 0, };
-static const char32 __uni_decomp_data_0xfaa4[] = { 0x761d, 0, };
-static const char32 __uni_decomp_data_0xfaa5[] = { 0x761f, 0, };
-static const char32 __uni_decomp_data_0xfaa6[] = { 0x76ca, 0, };
-static const char32 __uni_decomp_data_0xfaa7[] = { 0x76db, 0, };
-static const char32 __uni_decomp_data_0xfaa8[] = { 0x76f4, 0, };
-static const char32 __uni_decomp_data_0xfaa9[] = { 0x774a, 0, };
-static const char32 __uni_decomp_data_0xfaaa[] = { 0x7740, 0, };
-static const char32 __uni_decomp_data_0xfaab[] = { 0x78cc, 0, };
-static const char32 __uni_decomp_data_0xfaac[] = { 0x7ab1, 0, };
-static const char32 __uni_decomp_data_0xfaad[] = { 0x7bc0, 0, };
-static const char32 __uni_decomp_data_0xfaae[] = { 0x7c7b, 0, };
-static const char32 __uni_decomp_data_0xfaaf[] = { 0x7d5b, 0, };
-static const char32 __uni_decomp_data_0xfab0[] = { 0x7df4, 0, };
-static const char32 __uni_decomp_data_0xfab1[] = { 0x7f3e, 0, };
-static const char32 __uni_decomp_data_0xfab2[] = { 0x8005, 0, };
-static const char32 __uni_decomp_data_0xfab3[] = { 0x8352, 0, };
-static const char32 __uni_decomp_data_0xfab4[] = { 0x83ef, 0, };
-static const char32 __uni_decomp_data_0xfab5[] = { 0x8779, 0, };
-static const char32 __uni_decomp_data_0xfab6[] = { 0x8941, 0, };
-static const char32 __uni_decomp_data_0xfab7[] = { 0x8986, 0, };
-static const char32 __uni_decomp_data_0xfab8[] = { 0x8996, 0, };
-static const char32 __uni_decomp_data_0xfab9[] = { 0x8abf, 0, };
-static const char32 __uni_decomp_data_0xfaba[] = { 0x8af8, 0, };
-static const char32 __uni_decomp_data_0xfabb[] = { 0x8acb, 0, };
-static const char32 __uni_decomp_data_0xfabc[] = { 0x8b01, 0, };
-static const char32 __uni_decomp_data_0xfabd[] = { 0x8afe, 0, };
-static const char32 __uni_decomp_data_0xfabe[] = { 0x8aed, 0, };
-static const char32 __uni_decomp_data_0xfabf[] = { 0x8b39, 0, };
-static const char32 __uni_decomp_data_0xfac0[] = { 0x8b8a, 0, };
-static const char32 __uni_decomp_data_0xfac1[] = { 0x8d08, 0, };
-static const char32 __uni_decomp_data_0xfac2[] = { 0x8f38, 0, };
-static const char32 __uni_decomp_data_0xfac3[] = { 0x9072, 0, };
-static const char32 __uni_decomp_data_0xfac4[] = { 0x9199, 0, };
-static const char32 __uni_decomp_data_0xfac5[] = { 0x9276, 0, };
-static const char32 __uni_decomp_data_0xfac6[] = { 0x967c, 0, };
-static const char32 __uni_decomp_data_0xfac7[] = { 0x96e3, 0, };
-static const char32 __uni_decomp_data_0xfac8[] = { 0x9756, 0, };
-static const char32 __uni_decomp_data_0xfac9[] = { 0x97db, 0, };
-static const char32 __uni_decomp_data_0xfaca[] = { 0x97ff, 0, };
-static const char32 __uni_decomp_data_0xfacb[] = { 0x980b, 0, };
-static const char32 __uni_decomp_data_0xfacc[] = { 0x983b, 0, };
-static const char32 __uni_decomp_data_0xfacd[] = { 0x9b12, 0, };
-static const char32 __uni_decomp_data_0xface[] = { 0x9f9c, 0, };
-static const char32 __uni_decomp_data_0xfacf[] = { 0x2284a, 0, };
-static const char32 __uni_decomp_data_0xfad0[] = { 0x22844, 0, };
-static const char32 __uni_decomp_data_0xfad1[] = { 0x233d5, 0, };
-static const char32 __uni_decomp_data_0xfad2[] = { 0x3b9d, 0, };
-static const char32 __uni_decomp_data_0xfad3[] = { 0x4018, 0, };
-static const char32 __uni_decomp_data_0xfad4[] = { 0x4039, 0, };
-static const char32 __uni_decomp_data_0xfad5[] = { 0x25249, 0, };
-static const char32 __uni_decomp_data_0xfad6[] = { 0x25cd0, 0, };
-static const char32 __uni_decomp_data_0xfad7[] = { 0x27ed3, 0, };
-static const char32 __uni_decomp_data_0xfad8[] = { 0x9f43, 0, };
-static const char32 __uni_decomp_data_0xfad9[] = { 0x9f8e, 0, };
+static const char32 __uni_decomp_data_0xfa80[] = { 1, 0x5a62, };
+static const char32 __uni_decomp_data_0xfa81[] = { 1, 0x5b28, };
+static const char32 __uni_decomp_data_0xfa82[] = { 1, 0x5ed2, };
+static const char32 __uni_decomp_data_0xfa83[] = { 1, 0x5ed9, };
+static const char32 __uni_decomp_data_0xfa84[] = { 1, 0x5f69, };
+static const char32 __uni_decomp_data_0xfa85[] = { 1, 0x5fad, };
+static const char32 __uni_decomp_data_0xfa86[] = { 1, 0x60d8, };
+static const char32 __uni_decomp_data_0xfa87[] = { 1, 0x614e, };
+static const char32 __uni_decomp_data_0xfa88[] = { 1, 0x6108, };
+static const char32 __uni_decomp_data_0xfa89[] = { 1, 0x618e, };
+static const char32 __uni_decomp_data_0xfa8a[] = { 1, 0x6160, };
+static const char32 __uni_decomp_data_0xfa8b[] = { 1, 0x61f2, };
+static const char32 __uni_decomp_data_0xfa8c[] = { 1, 0x6234, };
+static const char32 __uni_decomp_data_0xfa8d[] = { 1, 0x63c4, };
+static const char32 __uni_decomp_data_0xfa8e[] = { 1, 0x641c, };
+static const char32 __uni_decomp_data_0xfa8f[] = { 1, 0x6452, };
+static const char32 __uni_decomp_data_0xfa90[] = { 1, 0x6556, };
+static const char32 __uni_decomp_data_0xfa91[] = { 1, 0x6674, };
+static const char32 __uni_decomp_data_0xfa92[] = { 1, 0x6717, };
+static const char32 __uni_decomp_data_0xfa93[] = { 1, 0x671b, };
+static const char32 __uni_decomp_data_0xfa94[] = { 1, 0x6756, };
+static const char32 __uni_decomp_data_0xfa95[] = { 1, 0x6b79, };
+static const char32 __uni_decomp_data_0xfa96[] = { 1, 0x6bba, };
+static const char32 __uni_decomp_data_0xfa97[] = { 1, 0x6d41, };
+static const char32 __uni_decomp_data_0xfa98[] = { 1, 0x6edb, };
+static const char32 __uni_decomp_data_0xfa99[] = { 1, 0x6ecb, };
+static const char32 __uni_decomp_data_0xfa9a[] = { 1, 0x6f22, };
+static const char32 __uni_decomp_data_0xfa9b[] = { 1, 0x701e, };
+static const char32 __uni_decomp_data_0xfa9c[] = { 1, 0x716e, };
+static const char32 __uni_decomp_data_0xfa9d[] = { 1, 0x77a7, };
+static const char32 __uni_decomp_data_0xfa9e[] = { 1, 0x7235, };
+static const char32 __uni_decomp_data_0xfa9f[] = { 1, 0x72af, };
+static const char32 __uni_decomp_data_0xfaa0[] = { 1, 0x732a, };
+static const char32 __uni_decomp_data_0xfaa1[] = { 1, 0x7471, };
+static const char32 __uni_decomp_data_0xfaa2[] = { 1, 0x7506, };
+static const char32 __uni_decomp_data_0xfaa3[] = { 1, 0x753b, };
+static const char32 __uni_decomp_data_0xfaa4[] = { 1, 0x761d, };
+static const char32 __uni_decomp_data_0xfaa5[] = { 1, 0x761f, };
+static const char32 __uni_decomp_data_0xfaa6[] = { 1, 0x76ca, };
+static const char32 __uni_decomp_data_0xfaa7[] = { 1, 0x76db, };
+static const char32 __uni_decomp_data_0xfaa8[] = { 1, 0x76f4, };
+static const char32 __uni_decomp_data_0xfaa9[] = { 1, 0x774a, };
+static const char32 __uni_decomp_data_0xfaaa[] = { 1, 0x7740, };
+static const char32 __uni_decomp_data_0xfaab[] = { 1, 0x78cc, };
+static const char32 __uni_decomp_data_0xfaac[] = { 1, 0x7ab1, };
+static const char32 __uni_decomp_data_0xfaad[] = { 1, 0x7bc0, };
+static const char32 __uni_decomp_data_0xfaae[] = { 1, 0x7c7b, };
+static const char32 __uni_decomp_data_0xfaaf[] = { 1, 0x7d5b, };
+static const char32 __uni_decomp_data_0xfab0[] = { 1, 0x7df4, };
+static const char32 __uni_decomp_data_0xfab1[] = { 1, 0x7f3e, };
+static const char32 __uni_decomp_data_0xfab2[] = { 1, 0x8005, };
+static const char32 __uni_decomp_data_0xfab3[] = { 1, 0x8352, };
+static const char32 __uni_decomp_data_0xfab4[] = { 1, 0x83ef, };
+static const char32 __uni_decomp_data_0xfab5[] = { 1, 0x8779, };
+static const char32 __uni_decomp_data_0xfab6[] = { 1, 0x8941, };
+static const char32 __uni_decomp_data_0xfab7[] = { 1, 0x8986, };
+static const char32 __uni_decomp_data_0xfab8[] = { 1, 0x8996, };
+static const char32 __uni_decomp_data_0xfab9[] = { 1, 0x8abf, };
+static const char32 __uni_decomp_data_0xfaba[] = { 1, 0x8af8, };
+static const char32 __uni_decomp_data_0xfabb[] = { 1, 0x8acb, };
+static const char32 __uni_decomp_data_0xfabc[] = { 1, 0x8b01, };
+static const char32 __uni_decomp_data_0xfabd[] = { 1, 0x8afe, };
+static const char32 __uni_decomp_data_0xfabe[] = { 1, 0x8aed, };
+static const char32 __uni_decomp_data_0xfabf[] = { 1, 0x8b39, };
+static const char32 __uni_decomp_data_0xfac0[] = { 1, 0x8b8a, };
+static const char32 __uni_decomp_data_0xfac1[] = { 1, 0x8d08, };
+static const char32 __uni_decomp_data_0xfac2[] = { 1, 0x8f38, };
+static const char32 __uni_decomp_data_0xfac3[] = { 1, 0x9072, };
+static const char32 __uni_decomp_data_0xfac4[] = { 1, 0x9199, };
+static const char32 __uni_decomp_data_0xfac5[] = { 1, 0x9276, };
+static const char32 __uni_decomp_data_0xfac6[] = { 1, 0x967c, };
+static const char32 __uni_decomp_data_0xfac7[] = { 1, 0x96e3, };
+static const char32 __uni_decomp_data_0xfac8[] = { 1, 0x9756, };
+static const char32 __uni_decomp_data_0xfac9[] = { 1, 0x97db, };
+static const char32 __uni_decomp_data_0xfaca[] = { 1, 0x97ff, };
+static const char32 __uni_decomp_data_0xfacb[] = { 1, 0x980b, };
+static const char32 __uni_decomp_data_0xfacc[] = { 1, 0x983b, };
+static const char32 __uni_decomp_data_0xfacd[] = { 1, 0x9b12, };
+static const char32 __uni_decomp_data_0xface[] = { 1, 0x9f9c, };
+static const char32 __uni_decomp_data_0xfacf[] = { 1, 0x2284a, };
+static const char32 __uni_decomp_data_0xfad0[] = { 1, 0x22844, };
+static const char32 __uni_decomp_data_0xfad1[] = { 1, 0x233d5, };
+static const char32 __uni_decomp_data_0xfad2[] = { 1, 0x3b9d, };
+static const char32 __uni_decomp_data_0xfad3[] = { 1, 0x4018, };
+static const char32 __uni_decomp_data_0xfad4[] = { 1, 0x4039, };
+static const char32 __uni_decomp_data_0xfad5[] = { 1, 0x25249, };
+static const char32 __uni_decomp_data_0xfad6[] = { 1, 0x25cd0, };
+static const char32 __uni_decomp_data_0xfad7[] = { 1, 0x27ed3, };
+static const char32 __uni_decomp_data_0xfad8[] = { 1, 0x9f43, };
+static const char32 __uni_decomp_data_0xfad9[] = { 1, 0x9f8e, };
 
 
 
@@ -35609,111 +35609,111 @@
 };
 
 
-static const char32 __uni_decomp_data_0xfb00[] = { 0x66, 0x66, 0, };
-static const char32 __uni_decomp_data_0xfb01[] = { 0x66, 0x69, 0, };
-static const char32 __uni_decomp_data_0xfb02[] = { 0x66, 0x6c, 0, };
-static const char32 __uni_decomp_data_0xfb03[] = { 0x66, 0x66, 0x69, 0, };
-static const char32 __uni_decomp_data_0xfb04[] = { 0x66, 0x66, 0x6c, 0, };
-static const char32 __uni_decomp_data_0xfb05[] = { 0x17f, 0x74, 0, };
-static const char32 __uni_decomp_data_0xfb06[] = { 0x73, 0x74, 0, };
-static const char32 __uni_decomp_data_0xfb13[] = { 0x574, 0x576, 0, };
-static const char32 __uni_decomp_data_0xfb14[] = { 0x574, 0x565, 0, };
-static const char32 __uni_decomp_data_0xfb15[] = { 0x574, 0x56b, 0, };
-static const char32 __uni_decomp_data_0xfb16[] = { 0x57e, 0x576, 0, };
-static const char32 __uni_decomp_data_0xfb17[] = { 0x574, 0x56d, 0, };
-static const char32 __uni_decomp_data_0xfb1d[] = { 0x5d9, 0x5b4, 0, };
-static const char32 __uni_decomp_data_0xfb1f[] = { 0x5f2, 0x5b7, 0, };
-static const char32 __uni_decomp_data_0xfb20[] = { 0x5e2, 0, };
-static const char32 __uni_decomp_data_0xfb21[] = { 0x5d0, 0, };
-static const char32 __uni_decomp_data_0xfb22[] = { 0x5d3, 0, };
-static const char32 __uni_decomp_data_0xfb23[] = { 0x5d4, 0, };
-static const char32 __uni_decomp_data_0xfb24[] = { 0x5db, 0, };
-static const char32 __uni_decomp_data_0xfb25[] = { 0x5dc, 0, };
-static const char32 __uni_decomp_data_0xfb26[] = { 0x5dd, 0, };
-static const char32 __uni_decomp_data_0xfb27[] = { 0x5e8, 0, };
-static const char32 __uni_decomp_data_0xfb28[] = { 0x5ea, 0, };
-static const char32 __uni_decomp_data_0xfb29[] = { 0x2b, 0, };
-static const char32 __uni_decomp_data_0xfb2a[] = { 0x5e9, 0x5c1, 0, };
-static const char32 __uni_decomp_data_0xfb2b[] = { 0x5e9, 0x5c2, 0, };
-static const char32 __uni_decomp_data_0xfb2c[] = { 0xfb49, 0x5c1, 0, };
-static const char32 __uni_decomp_data_0xfb2d[] = { 0xfb49, 0x5c2, 0, };
-static const char32 __uni_decomp_data_0xfb2e[] = { 0x5d0, 0x5b7, 0, };
-static const char32 __uni_decomp_data_0xfb2f[] = { 0x5d0, 0x5b8, 0, };
-static const char32 __uni_decomp_data_0xfb30[] = { 0x5d0, 0x5bc, 0, };
-static const char32 __uni_decomp_data_0xfb31[] = { 0x5d1, 0x5bc, 0, };
-static const char32 __uni_decomp_data_0xfb32[] = { 0x5d2, 0x5bc, 0, };
-static const char32 __uni_decomp_data_0xfb33[] = { 0x5d3, 0x5bc, 0, };
-static const char32 __uni_decomp_data_0xfb34[] = { 0x5d4, 0x5bc, 0, };
-static const char32 __uni_decomp_data_0xfb35[] = { 0x5d5, 0x5bc, 0, };
-static const char32 __uni_decomp_data_0xfb36[] = { 0x5d6, 0x5bc, 0, };
-static const char32 __uni_decomp_data_0xfb38[] = { 0x5d8, 0x5bc, 0, };
-static const char32 __uni_decomp_data_0xfb39[] = { 0x5d9, 0x5bc, 0, };
-static const char32 __uni_decomp_data_0xfb3a[] = { 0x5da, 0x5bc, 0, };
-static const char32 __uni_decomp_data_0xfb3b[] = { 0x5db, 0x5bc, 0, };
-static const char32 __uni_decomp_data_0xfb3c[] = { 0x5dc, 0x5bc, 0, };
-static const char32 __uni_decomp_data_0xfb3e[] = { 0x5de, 0x5bc, 0, };
-static const char32 __uni_decomp_data_0xfb40[] = { 0x5e0, 0x5bc, 0, };
-static const char32 __uni_decomp_data_0xfb41[] = { 0x5e1, 0x5bc, 0, };
-static const char32 __uni_decomp_data_0xfb43[] = { 0x5e3, 0x5bc, 0, };
-static const char32 __uni_decomp_data_0xfb44[] = { 0x5e4, 0x5bc, 0, };
-static const char32 __uni_decomp_data_0xfb46[] = { 0x5e6, 0x5bc, 0, };
-static const char32 __uni_decomp_data_0xfb47[] = { 0x5e7, 0x5bc, 0, };
-static const char32 __uni_decomp_data_0xfb48[] = { 0x5e8, 0x5bc, 0, };
-static const char32 __uni_decomp_data_0xfb49[] = { 0x5e9, 0x5bc, 0, };
-static const char32 __uni_decomp_data_0xfb4a[] = { 0x5ea, 0x5bc, 0, };
-static const char32 __uni_decomp_data_0xfb4b[] = { 0x5d5, 0x5b9, 0, };
-static const char32 __uni_decomp_data_0xfb4c[] = { 0x5d1, 0x5bf, 0, };
-static const char32 __uni_decomp_data_0xfb4d[] = { 0x5db, 0x5bf, 0, };
-static const char32 __uni_decomp_data_0xfb4e[] = { 0x5e4, 0x5bf, 0, };
-static const char32 __uni_decomp_data_0xfb4f[] = { 0x5d0, 0x5dc, 0, };
-static const char32 __uni_decomp_data_0xfb50[] = { 0x671, 0, };
-static const char32 __uni_decomp_data_0xfb51[] = { 0x671, 0, };
-static const char32 __uni_decomp_data_0xfb52[] = { 0x67b, 0, };
-static const char32 __uni_decomp_data_0xfb53[] = { 0x67b, 0, };
-static const char32 __uni_decomp_data_0xfb54[] = { 0x67b, 0, };
-static const char32 __uni_decomp_data_0xfb55[] = { 0x67b, 0, };
-static const char32 __uni_decomp_data_0xfb56[] = { 0x67e, 0, };
-static const char32 __uni_decomp_data_0xfb57[] = { 0x67e, 0, };
-static const char32 __uni_decomp_data_0xfb58[] = { 0x67e, 0, };
-static const char32 __uni_decomp_data_0xfb59[] = { 0x67e, 0, };
-static const char32 __uni_decomp_data_0xfb5a[] = { 0x680, 0, };
-static const char32 __uni_decomp_data_0xfb5b[] = { 0x680, 0, };
-static const char32 __uni_decomp_data_0xfb5c[] = { 0x680, 0, };
-static const char32 __uni_decomp_data_0xfb5d[] = { 0x680, 0, };
-static const char32 __uni_decomp_data_0xfb5e[] = { 0x67a, 0, };
-static const char32 __uni_decomp_data_0xfb5f[] = { 0x67a, 0, };
-static const char32 __uni_decomp_data_0xfb60[] = { 0x67a, 0, };
-static const char32 __uni_decomp_data_0xfb61[] = { 0x67a, 0, };
-static const char32 __uni_decomp_data_0xfb62[] = { 0x67f, 0, };
-static const char32 __uni_decomp_data_0xfb63[] = { 0x67f, 0, };
-static const char32 __uni_decomp_data_0xfb64[] = { 0x67f, 0, };
-static const char32 __uni_decomp_data_0xfb65[] = { 0x67f, 0, };
-static const char32 __uni_decomp_data_0xfb66[] = { 0x679, 0, };
-static const char32 __uni_decomp_data_0xfb67[] = { 0x679, 0, };
-static const char32 __uni_decomp_data_0xfb68[] = { 0x679, 0, };
-static const char32 __uni_decomp_data_0xfb69[] = { 0x679, 0, };
-static const char32 __uni_decomp_data_0xfb6a[] = { 0x6a4, 0, };
-static const char32 __uni_decomp_data_0xfb6b[] = { 0x6a4, 0, };
-static const char32 __uni_decomp_data_0xfb6c[] = { 0x6a4, 0, };
-static const char32 __uni_decomp_data_0xfb6d[] = { 0x6a4, 0, };
-static const char32 __uni_decomp_data_0xfb6e[] = { 0x6a6, 0, };
-static const char32 __uni_decomp_data_0xfb6f[] = { 0x6a6, 0, };
-static const char32 __uni_decomp_data_0xfb70[] = { 0x6a6, 0, };
-static const char32 __uni_decomp_data_0xfb71[] = { 0x6a6, 0, };
-static const char32 __uni_decomp_data_0xfb72[] = { 0x684, 0, };
-static const char32 __uni_decomp_data_0xfb73[] = { 0x684, 0, };
-static const char32 __uni_decomp_data_0xfb74[] = { 0x684, 0, };
-static const char32 __uni_decomp_data_0xfb75[] = { 0x684, 0, };
-static const char32 __uni_decomp_data_0xfb76[] = { 0x683, 0, };
-static const char32 __uni_decomp_data_0xfb77[] = { 0x683, 0, };
-static const char32 __uni_decomp_data_0xfb78[] = { 0x683, 0, };
-static const char32 __uni_decomp_data_0xfb79[] = { 0x683, 0, };
-static const char32 __uni_decomp_data_0xfb7a[] = { 0x686, 0, };
-static const char32 __uni_decomp_data_0xfb7b[] = { 0x686, 0, };
-static const char32 __uni_decomp_data_0xfb7c[] = { 0x686, 0, };
-static const char32 __uni_decomp_data_0xfb7d[] = { 0x686, 0, };
-static const char32 __uni_decomp_data_0xfb7e[] = { 0x687, 0, };
-static const char32 __uni_decomp_data_0xfb7f[] = { 0x687, 0, };
+static const char32 __uni_decomp_data_0xfb00[] = { 2, 0x66, 0x66, };
+static const char32 __uni_decomp_data_0xfb01[] = { 2, 0x66, 0x69, };
+static const char32 __uni_decomp_data_0xfb02[] = { 2, 0x66, 0x6c, };
+static const char32 __uni_decomp_data_0xfb03[] = { 3, 0x66, 0x66, 0x69, };
+static const char32 __uni_decomp_data_0xfb04[] = { 3, 0x66, 0x66, 0x6c, };
+static const char32 __uni_decomp_data_0xfb05[] = { 2, 0x17f, 0x74, };
+static const char32 __uni_decomp_data_0xfb06[] = { 2, 0x73, 0x74, };
+static const char32 __uni_decomp_data_0xfb13[] = { 2, 0x574, 0x576, };
+static const char32 __uni_decomp_data_0xfb14[] = { 2, 0x574, 0x565, };
+static const char32 __uni_decomp_data_0xfb15[] = { 2, 0x574, 0x56b, };
+static const char32 __uni_decomp_data_0xfb16[] = { 2, 0x57e, 0x576, };
+static const char32 __uni_decomp_data_0xfb17[] = { 2, 0x574, 0x56d, };
+static const char32 __uni_decomp_data_0xfb1d[] = { 2, 0x5d9, 0x5b4, };
+static const char32 __uni_decomp_data_0xfb1f[] = { 2, 0x5f2, 0x5b7, };
+static const char32 __uni_decomp_data_0xfb20[] = { 1, 0x5e2, };
+static const char32 __uni_decomp_data_0xfb21[] = { 1, 0x5d0, };
+static const char32 __uni_decomp_data_0xfb22[] = { 1, 0x5d3, };
+static const char32 __uni_decomp_data_0xfb23[] = { 1, 0x5d4, };
+static const char32 __uni_decomp_data_0xfb24[] = { 1, 0x5db, };
+static const char32 __uni_decomp_data_0xfb25[] = { 1, 0x5dc, };
+static const char32 __uni_decomp_data_0xfb26[] = { 1, 0x5dd, };
+static const char32 __uni_decomp_data_0xfb27[] = { 1, 0x5e8, };
+static const char32 __uni_decomp_data_0xfb28[] = { 1, 0x5ea, };
+static const char32 __uni_decomp_data_0xfb29[] = { 1, 0x2b, };
+static const char32 __uni_decomp_data_0xfb2a[] = { 2, 0x5e9, 0x5c1, };
+static const char32 __uni_decomp_data_0xfb2b[] = { 2, 0x5e9, 0x5c2, };
+static const char32 __uni_decomp_data_0xfb2c[] = { 2, 0xfb49, 0x5c1, };
+static const char32 __uni_decomp_data_0xfb2d[] = { 2, 0xfb49, 0x5c2, };
+static const char32 __uni_decomp_data_0xfb2e[] = { 2, 0x5d0, 0x5b7, };
+static const char32 __uni_decomp_data_0xfb2f[] = { 2, 0x5d0, 0x5b8, };
+static const char32 __uni_decomp_data_0xfb30[] = { 2, 0x5d0, 0x5bc, };
+static const char32 __uni_decomp_data_0xfb31[] = { 2, 0x5d1, 0x5bc, };
+static const char32 __uni_decomp_data_0xfb32[] = { 2, 0x5d2, 0x5bc, };
+static const char32 __uni_decomp_data_0xfb33[] = { 2, 0x5d3, 0x5bc, };
+static const char32 __uni_decomp_data_0xfb34[] = { 2, 0x5d4, 0x5bc, };
+static const char32 __uni_decomp_data_0xfb35[] = { 2, 0x5d5, 0x5bc, };
+static const char32 __uni_decomp_data_0xfb36[] = { 2, 0x5d6, 0x5bc, };
+static const char32 __uni_decomp_data_0xfb38[] = { 2, 0x5d8, 0x5bc, };
+static const char32 __uni_decomp_data_0xfb39[] = { 2, 0x5d9, 0x5bc, };
+static const char32 __uni_decomp_data_0xfb3a[] = { 2, 0x5da, 0x5bc, };
+static const char32 __uni_decomp_data_0xfb3b[] = { 2, 0x5db, 0x5bc, };
+static const char32 __uni_decomp_data_0xfb3c[] = { 2, 0x5dc, 0x5bc, };
+static const char32 __uni_decomp_data_0xfb3e[] = { 2, 0x5de, 0x5bc, };
+static const char32 __uni_decomp_data_0xfb40[] = { 2, 0x5e0, 0x5bc, };
+static const char32 __uni_decomp_data_0xfb41[] = { 2, 0x5e1, 0x5bc, };
+static const char32 __uni_decomp_data_0xfb43[] = { 2, 0x5e3, 0x5bc, };
+static const char32 __uni_decomp_data_0xfb44[] = { 2, 0x5e4, 0x5bc, };
+static const char32 __uni_decomp_data_0xfb46[] = { 2, 0x5e6, 0x5bc, };
+static const char32 __uni_decomp_data_0xfb47[] = { 2, 0x5e7, 0x5bc, };
+static const char32 __uni_decomp_data_0xfb48[] = { 2, 0x5e8, 0x5bc, };
+static const char32 __uni_decomp_data_0xfb49[] = { 2, 0x5e9, 0x5bc, };
+static const char32 __uni_decomp_data_0xfb4a[] = { 2, 0x5ea, 0x5bc, };
+static const char32 __uni_decomp_data_0xfb4b[] = { 2, 0x5d5, 0x5b9, };
+static const char32 __uni_decomp_data_0xfb4c[] = { 2, 0x5d1, 0x5bf, };
+static const char32 __uni_decomp_data_0xfb4d[] = { 2, 0x5db, 0x5bf, };
+static const char32 __uni_decomp_data_0xfb4e[] = { 2, 0x5e4, 0x5bf, };
+static const char32 __uni_decomp_data_0xfb4f[] = { 2, 0x5d0, 0x5dc, };
+static const char32 __uni_decomp_data_0xfb50[] = { 1, 0x671, };
+static const char32 __uni_decomp_data_0xfb51[] = { 1, 0x671, };
+static const char32 __uni_decomp_data_0xfb52[] = { 1, 0x67b, };
+static const char32 __uni_decomp_data_0xfb53[] = { 1, 0x67b, };
+static const char32 __uni_decomp_data_0xfb54[] = { 1, 0x67b, };
+static const char32 __uni_decomp_data_0xfb55[] = { 1, 0x67b, };
+static const char32 __uni_decomp_data_0xfb56[] = { 1, 0x67e, };
+static const char32 __uni_decomp_data_0xfb57[] = { 1, 0x67e, };
+static const char32 __uni_decomp_data_0xfb58[] = { 1, 0x67e, };
+static const char32 __uni_decomp_data_0xfb59[] = { 1, 0x67e, };
+static const char32 __uni_decomp_data_0xfb5a[] = { 1, 0x680, };
+static const char32 __uni_decomp_data_0xfb5b[] = { 1, 0x680, };
+static const char32 __uni_decomp_data_0xfb5c[] = { 1, 0x680, };
+static const char32 __uni_decomp_data_0xfb5d[] = { 1, 0x680, };
+static const char32 __uni_decomp_data_0xfb5e[] = { 1, 0x67a, };
+static const char32 __uni_decomp_data_0xfb5f[] = { 1, 0x67a, };
+static const char32 __uni_decomp_data_0xfb60[] = { 1, 0x67a, };
+static const char32 __uni_decomp_data_0xfb61[] = { 1, 0x67a, };
+static const char32 __uni_decomp_data_0xfb62[] = { 1, 0x67f, };
+static const char32 __uni_decomp_data_0xfb63[] = { 1, 0x67f, };
+static const char32 __uni_decomp_data_0xfb64[] = { 1, 0x67f, };
+static const char32 __uni_decomp_data_0xfb65[] = { 1, 0x67f, };
+static const char32 __uni_decomp_data_0xfb66[] = { 1, 0x679, };
+static const char32 __uni_decomp_data_0xfb67[] = { 1, 0x679, };
+static const char32 __uni_decomp_data_0xfb68[] = { 1, 0x679, };
+static const char32 __uni_decomp_data_0xfb69[] = { 1, 0x679, };
+static const char32 __uni_decomp_data_0xfb6a[] = { 1, 0x6a4, };
+static const char32 __uni_decomp_data_0xfb6b[] = { 1, 0x6a4, };
+static const char32 __uni_decomp_data_0xfb6c[] = { 1, 0x6a4, };
+static const char32 __uni_decomp_data_0xfb6d[] = { 1, 0x6a4, };
+static const char32 __uni_decomp_data_0xfb6e[] = { 1, 0x6a6, };
+static const char32 __uni_decomp_data_0xfb6f[] = { 1, 0x6a6, };
+static const char32 __uni_decomp_data_0xfb70[] = { 1, 0x6a6, };
+static const char32 __uni_decomp_data_0xfb71[] = { 1, 0x6a6, };
+static const char32 __uni_decomp_data_0xfb72[] = { 1, 0x684, };
+static const char32 __uni_decomp_data_0xfb73[] = { 1, 0x684, };
+static const char32 __uni_decomp_data_0xfb74[] = { 1, 0x684, };
+static const char32 __uni_decomp_data_0xfb75[] = { 1, 0x684, };
+static const char32 __uni_decomp_data_0xfb76[] = { 1, 0x683, };
+static const char32 __uni_decomp_data_0xfb77[] = { 1, 0x683, };
+static const char32 __uni_decomp_data_0xfb78[] = { 1, 0x683, };
+static const char32 __uni_decomp_data_0xfb79[] = { 1, 0x683, };
+static const char32 __uni_decomp_data_0xfb7a[] = { 1, 0x686, };
+static const char32 __uni_decomp_data_0xfb7b[] = { 1, 0x686, };
+static const char32 __uni_decomp_data_0xfb7c[] = { 1, 0x686, };
+static const char32 __uni_decomp_data_0xfb7d[] = { 1, 0x686, };
+static const char32 __uni_decomp_data_0xfb7e[] = { 1, 0x687, };
+static const char32 __uni_decomp_data_0xfb7f[] = { 1, 0x687, };
 
 
 
@@ -37387,101 +37387,101 @@
 };
 
 
-static const char32 __uni_decomp_data_0xfb80[] = { 0x687, 0, };
-static const char32 __uni_decomp_data_0xfb81[] = { 0x687, 0, };
-static const char32 __uni_decomp_data_0xfb82[] = { 0x68d, 0, };
-static const char32 __uni_decomp_data_0xfb83[] = { 0x68d, 0, };
-static const char32 __uni_decomp_data_0xfb84[] = { 0x68c, 0, };
-static const char32 __uni_decomp_data_0xfb85[] = { 0x68c, 0, };
-static const char32 __uni_decomp_data_0xfb86[] = { 0x68e, 0, };
-static const char32 __uni_decomp_data_0xfb87[] = { 0x68e, 0, };
-static const char32 __uni_decomp_data_0xfb88[] = { 0x688, 0, };
-static const char32 __uni_decomp_data_0xfb89[] = { 0x688, 0, };
-static const char32 __uni_decomp_data_0xfb8a[] = { 0x698, 0, };
-static const char32 __uni_decomp_data_0xfb8b[] = { 0x698, 0, };
-static const char32 __uni_decomp_data_0xfb8c[] = { 0x691, 0, };
-static const char32 __uni_decomp_data_0xfb8d[] = { 0x691, 0, };
-static const char32 __uni_decomp_data_0xfb8e[] = { 0x6a9, 0, };
-static const char32 __uni_decomp_data_0xfb8f[] = { 0x6a9, 0, };
-static const char32 __uni_decomp_data_0xfb90[] = { 0x6a9, 0, };
-static const char32 __uni_decomp_data_0xfb91[] = { 0x6a9, 0, };
-static const char32 __uni_decomp_data_0xfb92[] = { 0x6af, 0, };
-static const char32 __uni_decomp_data_0xfb93[] = { 0x6af, 0, };
-static const char32 __uni_decomp_data_0xfb94[] = { 0x6af, 0, };
-static const char32 __uni_decomp_data_0xfb95[] = { 0x6af, 0, };
-static const char32 __uni_decomp_data_0xfb96[] = { 0x6b3, 0, };
-static const char32 __uni_decomp_data_0xfb97[] = { 0x6b3, 0, };
-static const char32 __uni_decomp_data_0xfb98[] = { 0x6b3, 0, };
-static const char32 __uni_decomp_data_0xfb99[] = { 0x6b3, 0, };
-static const char32 __uni_decomp_data_0xfb9a[] = { 0x6b1, 0, };
-static const char32 __uni_decomp_data_0xfb9b[] = { 0x6b1, 0, };
-static const char32 __uni_decomp_data_0xfb9c[] = { 0x6b1, 0, };
-static const char32 __uni_decomp_data_0xfb9d[] = { 0x6b1, 0, };
-static const char32 __uni_decomp_data_0xfb9e[] = { 0x6ba, 0, };
-static const char32 __uni_decomp_data_0xfb9f[] = { 0x6ba, 0, };
-static const char32 __uni_decomp_data_0xfba0[] = { 0x6bb, 0, };
-static const char32 __uni_decomp_data_0xfba1[] = { 0x6bb, 0, };
-static const char32 __uni_decomp_data_0xfba2[] = { 0x6bb, 0, };
-static const char32 __uni_decomp_data_0xfba3[] = { 0x6bb, 0, };
-static const char32 __uni_decomp_data_0xfba4[] = { 0x6c0, 0, };
-static const char32 __uni_decomp_data_0xfba5[] = { 0x6c0, 0, };
-static const char32 __uni_decomp_data_0xfba6[] = { 0x6c1, 0, };
-static const char32 __uni_decomp_data_0xfba7[] = { 0x6c1, 0, };
-static const char32 __uni_decomp_data_0xfba8[] = { 0x6c1, 0, };
-static const char32 __uni_decomp_data_0xfba9[] = { 0x6c1, 0, };
-static const char32 __uni_decomp_data_0xfbaa[] = { 0x6be, 0, };
-static const char32 __uni_decomp_data_0xfbab[] = { 0x6be, 0, };
-static const char32 __uni_decomp_data_0xfbac[] = { 0x6be, 0, };
-static const char32 __uni_decomp_data_0xfbad[] = { 0x6be, 0, };
-static const char32 __uni_decomp_data_0xfbae[] = { 0x6d2, 0, };
-static const char32 __uni_decomp_data_0xfbaf[] = { 0x6d2, 0, };
-static const char32 __uni_decomp_data_0xfbb0[] = { 0x6d3, 0, };
-static const char32 __uni_decomp_data_0xfbb1[] = { 0x6d3, 0, };
-static const char32 __uni_decomp_data_0xfbd3[] = { 0x6ad, 0, };
-static const char32 __uni_decomp_data_0xfbd4[] = { 0x6ad, 0, };
-static const char32 __uni_decomp_data_0xfbd5[] = { 0x6ad, 0, };
-static const char32 __uni_decomp_data_0xfbd6[] = { 0x6ad, 0, };
-static const char32 __uni_decomp_data_0xfbd7[] = { 0x6c7, 0, };
-static const char32 __uni_decomp_data_0xfbd8[] = { 0x6c7, 0, };
-static const char32 __uni_decomp_data_0xfbd9[] = { 0x6c6, 0, };
-static const char32 __uni_decomp_data_0xfbda[] = { 0x6c6, 0, };
-static const char32 __uni_decomp_data_0xfbdb[] = { 0x6c8, 0, };
-static const char32 __uni_decomp_data_0xfbdc[] = { 0x6c8, 0, };
-static const char32 __uni_decomp_data_0xfbdd[] = { 0x677, 0, };
-static const char32 __uni_decomp_data_0xfbde[] = { 0x6cb, 0, };
-static const char32 __uni_decomp_data_0xfbdf[] = { 0x6cb, 0, };
-static const char32 __uni_decomp_data_0xfbe0[] = { 0x6c5, 0, };
-static const char32 __uni_decomp_data_0xfbe1[] = { 0x6c5, 0, };
-static const char32 __uni_decomp_data_0xfbe2[] = { 0x6c9, 0, };
-static const char32 __uni_decomp_data_0xfbe3[] = { 0x6c9, 0, };
-static const char32 __uni_decomp_data_0xfbe4[] = { 0x6d0, 0, };
-static const char32 __uni_decomp_data_0xfbe5[] = { 0x6d0, 0, };
-static const char32 __uni_decomp_data_0xfbe6[] = { 0x6d0, 0, };
-static const char32 __uni_decomp_data_0xfbe7[] = { 0x6d0, 0, };
-static const char32 __uni_decomp_data_0xfbe8[] = { 0x649, 0, };
-static const char32 __uni_decomp_data_0xfbe9[] = { 0x649, 0, };
-static const char32 __uni_decomp_data_0xfbea[] = { 0x626, 0x627, 0, };
-static const char32 __uni_decomp_data_0xfbeb[] = { 0x626, 0x627, 0, };
-static const char32 __uni_decomp_data_0xfbec[] = { 0x626, 0x6d5, 0, };
-static const char32 __uni_decomp_data_0xfbed[] = { 0x626, 0x6d5, 0, };
-static const char32 __uni_decomp_data_0xfbee[] = { 0x626, 0x648, 0, };
-static const char32 __uni_decomp_data_0xfbef[] = { 0x626, 0x648, 0, };
-static const char32 __uni_decomp_data_0xfbf0[] = { 0x626, 0x6c7, 0, };
-static const char32 __uni_decomp_data_0xfbf1[] = { 0x626, 0x6c7, 0, };
-static const char32 __uni_decomp_data_0xfbf2[] = { 0x626, 0x6c6, 0, };
-static const char32 __uni_decomp_data_0xfbf3[] = { 0x626, 0x6c6, 0, };
-static const char32 __uni_decomp_data_0xfbf4[] = { 0x626, 0x6c8, 0, };
-static const char32 __uni_decomp_data_0xfbf5[] = { 0x626, 0x6c8, 0, };
-static const char32 __uni_decomp_data_0xfbf6[] = { 0x626, 0x6d0, 0, };
-static const char32 __uni_decomp_data_0xfbf7[] = { 0x626, 0x6d0, 0, };
-static const char32 __uni_decomp_data_0xfbf8[] = { 0x626, 0x6d0, 0, };
-static const char32 __uni_decomp_data_0xfbf9[] = { 0x626, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfbfa[] = { 0x626, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfbfb[] = { 0x626, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfbfc[] = { 0x6cc, 0, };
-static const char32 __uni_decomp_data_0xfbfd[] = { 0x6cc, 0, };
-static const char32 __uni_decomp_data_0xfbfe[] = { 0x6cc, 0, };
-static const char32 __uni_decomp_data_0xfbff[] = { 0x6cc, 0, };
+static const char32 __uni_decomp_data_0xfb80[] = { 1, 0x687, };
+static const char32 __uni_decomp_data_0xfb81[] = { 1, 0x687, };
+static const char32 __uni_decomp_data_0xfb82[] = { 1, 0x68d, };
+static const char32 __uni_decomp_data_0xfb83[] = { 1, 0x68d, };
+static const char32 __uni_decomp_data_0xfb84[] = { 1, 0x68c, };
+static const char32 __uni_decomp_data_0xfb85[] = { 1, 0x68c, };
+static const char32 __uni_decomp_data_0xfb86[] = { 1, 0x68e, };
+static const char32 __uni_decomp_data_0xfb87[] = { 1, 0x68e, };
+static const char32 __uni_decomp_data_0xfb88[] = { 1, 0x688, };
+static const char32 __uni_decomp_data_0xfb89[] = { 1, 0x688, };
+static const char32 __uni_decomp_data_0xfb8a[] = { 1, 0x698, };
+static const char32 __uni_decomp_data_0xfb8b[] = { 1, 0x698, };
+static const char32 __uni_decomp_data_0xfb8c[] = { 1, 0x691, };
+static const char32 __uni_decomp_data_0xfb8d[] = { 1, 0x691, };
+static const char32 __uni_decomp_data_0xfb8e[] = { 1, 0x6a9, };
+static const char32 __uni_decomp_data_0xfb8f[] = { 1, 0x6a9, };
+static const char32 __uni_decomp_data_0xfb90[] = { 1, 0x6a9, };
+static const char32 __uni_decomp_data_0xfb91[] = { 1, 0x6a9, };
+static const char32 __uni_decomp_data_0xfb92[] = { 1, 0x6af, };
+static const char32 __uni_decomp_data_0xfb93[] = { 1, 0x6af, };
+static const char32 __uni_decomp_data_0xfb94[] = { 1, 0x6af, };
+static const char32 __uni_decomp_data_0xfb95[] = { 1, 0x6af, };
+static const char32 __uni_decomp_data_0xfb96[] = { 1, 0x6b3, };
+static const char32 __uni_decomp_data_0xfb97[] = { 1, 0x6b3, };
+static const char32 __uni_decomp_data_0xfb98[] = { 1, 0x6b3, };
+static const char32 __uni_decomp_data_0xfb99[] = { 1, 0x6b3, };
+static const char32 __uni_decomp_data_0xfb9a[] = { 1, 0x6b1, };
+static const char32 __uni_decomp_data_0xfb9b[] = { 1, 0x6b1, };
+static const char32 __uni_decomp_data_0xfb9c[] = { 1, 0x6b1, };
+static const char32 __uni_decomp_data_0xfb9d[] = { 1, 0x6b1, };
+static const char32 __uni_decomp_data_0xfb9e[] = { 1, 0x6ba, };
+static const char32 __uni_decomp_data_0xfb9f[] = { 1, 0x6ba, };
+static const char32 __uni_decomp_data_0xfba0[] = { 1, 0x6bb, };
+static const char32 __uni_decomp_data_0xfba1[] = { 1, 0x6bb, };
+static const char32 __uni_decomp_data_0xfba2[] = { 1, 0x6bb, };
+static const char32 __uni_decomp_data_0xfba3[] = { 1, 0x6bb, };
+static const char32 __uni_decomp_data_0xfba4[] = { 1, 0x6c0, };
+static const char32 __uni_decomp_data_0xfba5[] = { 1, 0x6c0, };
+static const char32 __uni_decomp_data_0xfba6[] = { 1, 0x6c1, };
+static const char32 __uni_decomp_data_0xfba7[] = { 1, 0x6c1, };
+static const char32 __uni_decomp_data_0xfba8[] = { 1, 0x6c1, };
+static const char32 __uni_decomp_data_0xfba9[] = { 1, 0x6c1, };
+static const char32 __uni_decomp_data_0xfbaa[] = { 1, 0x6be, };
+static const char32 __uni_decomp_data_0xfbab[] = { 1, 0x6be, };
+static const char32 __uni_decomp_data_0xfbac[] = { 1, 0x6be, };
+static const char32 __uni_decomp_data_0xfbad[] = { 1, 0x6be, };
+static const char32 __uni_decomp_data_0xfbae[] = { 1, 0x6d2, };
+static const char32 __uni_decomp_data_0xfbaf[] = { 1, 0x6d2, };
+static const char32 __uni_decomp_data_0xfbb0[] = { 1, 0x6d3, };
+static const char32 __uni_decomp_data_0xfbb1[] = { 1, 0x6d3, };
+static const char32 __uni_decomp_data_0xfbd3[] = { 1, 0x6ad, };
+static const char32 __uni_decomp_data_0xfbd4[] = { 1, 0x6ad, };
+static const char32 __uni_decomp_data_0xfbd5[] = { 1, 0x6ad, };
+static const char32 __uni_decomp_data_0xfbd6[] = { 1, 0x6ad, };
+static const char32 __uni_decomp_data_0xfbd7[] = { 1, 0x6c7, };
+static const char32 __uni_decomp_data_0xfbd8[] = { 1, 0x6c7, };
+static const char32 __uni_decomp_data_0xfbd9[] = { 1, 0x6c6, };
+static const char32 __uni_decomp_data_0xfbda[] = { 1, 0x6c6, };
+static const char32 __uni_decomp_data_0xfbdb[] = { 1, 0x6c8, };
+static const char32 __uni_decomp_data_0xfbdc[] = { 1, 0x6c8, };
+static const char32 __uni_decomp_data_0xfbdd[] = { 1, 0x677, };
+static const char32 __uni_decomp_data_0xfbde[] = { 1, 0x6cb, };
+static const char32 __uni_decomp_data_0xfbdf[] = { 1, 0x6cb, };
+static const char32 __uni_decomp_data_0xfbe0[] = { 1, 0x6c5, };
+static const char32 __uni_decomp_data_0xfbe1[] = { 1, 0x6c5, };
+static const char32 __uni_decomp_data_0xfbe2[] = { 1, 0x6c9, };
+static const char32 __uni_decomp_data_0xfbe3[] = { 1, 0x6c9, };
+static const char32 __uni_decomp_data_0xfbe4[] = { 1, 0x6d0, };
+static const char32 __uni_decomp_data_0xfbe5[] = { 1, 0x6d0, };
+static const char32 __uni_decomp_data_0xfbe6[] = { 1, 0x6d0, };
+static const char32 __uni_decomp_data_0xfbe7[] = { 1, 0x6d0, };
+static const char32 __uni_decomp_data_0xfbe8[] = { 1, 0x649, };
+static const char32 __uni_decomp_data_0xfbe9[] = { 1, 0x649, };
+static const char32 __uni_decomp_data_0xfbea[] = { 2, 0x626, 0x627, };
+static const char32 __uni_decomp_data_0xfbeb[] = { 2, 0x626, 0x627, };
+static const char32 __uni_decomp_data_0xfbec[] = { 2, 0x626, 0x6d5, };
+static const char32 __uni_decomp_data_0xfbed[] = { 2, 0x626, 0x6d5, };
+static const char32 __uni_decomp_data_0xfbee[] = { 2, 0x626, 0x648, };
+static const char32 __uni_decomp_data_0xfbef[] = { 2, 0x626, 0x648, };
+static const char32 __uni_decomp_data_0xfbf0[] = { 2, 0x626, 0x6c7, };
+static const char32 __uni_decomp_data_0xfbf1[] = { 2, 0x626, 0x6c7, };
+static const char32 __uni_decomp_data_0xfbf2[] = { 2, 0x626, 0x6c6, };
+static const char32 __uni_decomp_data_0xfbf3[] = { 2, 0x626, 0x6c6, };
+static const char32 __uni_decomp_data_0xfbf4[] = { 2, 0x626, 0x6c8, };
+static const char32 __uni_decomp_data_0xfbf5[] = { 2, 0x626, 0x6c8, };
+static const char32 __uni_decomp_data_0xfbf6[] = { 2, 0x626, 0x6d0, };
+static const char32 __uni_decomp_data_0xfbf7[] = { 2, 0x626, 0x6d0, };
+static const char32 __uni_decomp_data_0xfbf8[] = { 2, 0x626, 0x6d0, };
+static const char32 __uni_decomp_data_0xfbf9[] = { 2, 0x626, 0x649, };
+static const char32 __uni_decomp_data_0xfbfa[] = { 2, 0x626, 0x649, };
+static const char32 __uni_decomp_data_0xfbfb[] = { 2, 0x626, 0x649, };
+static const char32 __uni_decomp_data_0xfbfc[] = { 1, 0x6cc, };
+static const char32 __uni_decomp_data_0xfbfd[] = { 1, 0x6cc, };
+static const char32 __uni_decomp_data_0xfbfe[] = { 1, 0x6cc, };
+static const char32 __uni_decomp_data_0xfbff[] = { 1, 0x6cc, };
 
 
 
@@ -39155,134 +39155,134 @@
 };
 
 
-static const char32 __uni_decomp_data_0xfc00[] = { 0x626, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfc01[] = { 0x626, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfc02[] = { 0x626, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc03[] = { 0x626, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfc04[] = { 0x626, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfc05[] = { 0x628, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfc06[] = { 0x628, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfc07[] = { 0x628, 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfc08[] = { 0x628, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc09[] = { 0x628, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfc0a[] = { 0x628, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfc0b[] = { 0x62a, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfc0c[] = { 0x62a, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfc0d[] = { 0x62a, 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfc0e[] = { 0x62a, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc0f[] = { 0x62a, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfc10[] = { 0x62a, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfc11[] = { 0x62b, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfc12[] = { 0x62b, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc13[] = { 0x62b, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfc14[] = { 0x62b, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfc15[] = { 0x62c, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfc16[] = { 0x62c, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc17[] = { 0x62d, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfc18[] = { 0x62d, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc19[] = { 0x62e, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfc1a[] = { 0x62e, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfc1b[] = { 0x62e, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc1c[] = { 0x633, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfc1d[] = { 0x633, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfc1e[] = { 0x633, 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfc1f[] = { 0x633, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc20[] = { 0x635, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfc21[] = { 0x635, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc22[] = { 0x636, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfc23[] = { 0x636, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfc24[] = { 0x636, 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfc25[] = { 0x636, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc26[] = { 0x637, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfc27[] = { 0x637, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc28[] = { 0x638, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc29[] = { 0x639, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfc2a[] = { 0x639, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc2b[] = { 0x63a, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfc2c[] = { 0x63a, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc2d[] = { 0x641, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfc2e[] = { 0x641, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfc2f[] = { 0x641, 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfc30[] = { 0x641, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc31[] = { 0x641, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfc32[] = { 0x641, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfc33[] = { 0x642, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfc34[] = { 0x642, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc35[] = { 0x642, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfc36[] = { 0x642, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfc37[] = { 0x643, 0x627, 0, };
-static const char32 __uni_decomp_data_0xfc38[] = { 0x643, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfc39[] = { 0x643, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfc3a[] = { 0x643, 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfc3b[] = { 0x643, 0x644, 0, };
-static const char32 __uni_decomp_data_0xfc3c[] = { 0x643, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc3d[] = { 0x643, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfc3e[] = { 0x643, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfc3f[] = { 0x644, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfc40[] = { 0x644, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfc41[] = { 0x644, 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfc42[] = { 0x644, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc43[] = { 0x644, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfc44[] = { 0x644, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfc45[] = { 0x645, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfc46[] = { 0x645, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfc47[] = { 0x645, 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfc48[] = { 0x645, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc49[] = { 0x645, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfc4a[] = { 0x645, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfc4b[] = { 0x646, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfc4c[] = { 0x646, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfc4d[] = { 0x646, 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfc4e[] = { 0x646, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc4f[] = { 0x646, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfc50[] = { 0x646, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfc51[] = { 0x647, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfc52[] = { 0x647, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc53[] = { 0x647, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfc54[] = { 0x647, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfc55[] = { 0x64a, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfc56[] = { 0x64a, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfc57[] = { 0x64a, 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfc58[] = { 0x64a, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc59[] = { 0x64a, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfc5a[] = { 0x64a, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfc5b[] = { 0x630, 0x670, 0, };
-static const char32 __uni_decomp_data_0xfc5c[] = { 0x631, 0x670, 0, };
-static const char32 __uni_decomp_data_0xfc5d[] = { 0x649, 0x670, 0, };
-static const char32 __uni_decomp_data_0xfc5e[] = { 0x20, 0x64c, 0x651, 0, };
-static const char32 __uni_decomp_data_0xfc5f[] = { 0x20, 0x64d, 0x651, 0, };
-static const char32 __uni_decomp_data_0xfc60[] = { 0x20, 0x64e, 0x651, 0, };
-static const char32 __uni_decomp_data_0xfc61[] = { 0x20, 0x64f, 0x651, 0, };
-static const char32 __uni_decomp_data_0xfc62[] = { 0x20, 0x650, 0x651, 0, };
-static const char32 __uni_decomp_data_0xfc63[] = { 0x20, 0x651, 0x670, 0, };
-static const char32 __uni_decomp_data_0xfc64[] = { 0x626, 0x631, 0, };
-static const char32 __uni_decomp_data_0xfc65[] = { 0x626, 0x632, 0, };
-static const char32 __uni_decomp_data_0xfc66[] = { 0x626, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc67[] = { 0x626, 0x646, 0, };
-static const char32 __uni_decomp_data_0xfc68[] = { 0x626, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfc69[] = { 0x626, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfc6a[] = { 0x628, 0x631, 0, };
-static const char32 __uni_decomp_data_0xfc6b[] = { 0x628, 0x632, 0, };
-static const char32 __uni_decomp_data_0xfc6c[] = { 0x628, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc6d[] = { 0x628, 0x646, 0, };
-static const char32 __uni_decomp_data_0xfc6e[] = { 0x628, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfc6f[] = { 0x628, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfc70[] = { 0x62a, 0x631, 0, };
-static const char32 __uni_decomp_data_0xfc71[] = { 0x62a, 0x632, 0, };
-static const char32 __uni_decomp_data_0xfc72[] = { 0x62a, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc73[] = { 0x62a, 0x646, 0, };
-static const char32 __uni_decomp_data_0xfc74[] = { 0x62a, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfc75[] = { 0x62a, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfc76[] = { 0x62b, 0x631, 0, };
-static const char32 __uni_decomp_data_0xfc77[] = { 0x62b, 0x632, 0, };
-static const char32 __uni_decomp_data_0xfc78[] = { 0x62b, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc79[] = { 0x62b, 0x646, 0, };
-static const char32 __uni_decomp_data_0xfc7a[] = { 0x62b, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfc7b[] = { 0x62b, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfc7c[] = { 0x641, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfc7d[] = { 0x641, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfc7e[] = { 0x642, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfc7f[] = { 0x642, 0x64a, 0, };
+static const char32 __uni_decomp_data_0xfc00[] = { 2, 0x626, 0x62c, };
+static const char32 __uni_decomp_data_0xfc01[] = { 2, 0x626, 0x62d, };
+static const char32 __uni_decomp_data_0xfc02[] = { 2, 0x626, 0x645, };
+static const char32 __uni_decomp_data_0xfc03[] = { 2, 0x626, 0x649, };
+static const char32 __uni_decomp_data_0xfc04[] = { 2, 0x626, 0x64a, };
+static const char32 __uni_decomp_data_0xfc05[] = { 2, 0x628, 0x62c, };
+static const char32 __uni_decomp_data_0xfc06[] = { 2, 0x628, 0x62d, };
+static const char32 __uni_decomp_data_0xfc07[] = { 2, 0x628, 0x62e, };
+static const char32 __uni_decomp_data_0xfc08[] = { 2, 0x628, 0x645, };
+static const char32 __uni_decomp_data_0xfc09[] = { 2, 0x628, 0x649, };
+static const char32 __uni_decomp_data_0xfc0a[] = { 2, 0x628, 0x64a, };
+static const char32 __uni_decomp_data_0xfc0b[] = { 2, 0x62a, 0x62c, };
+static const char32 __uni_decomp_data_0xfc0c[] = { 2, 0x62a, 0x62d, };
+static const char32 __uni_decomp_data_0xfc0d[] = { 2, 0x62a, 0x62e, };
+static const char32 __uni_decomp_data_0xfc0e[] = { 2, 0x62a, 0x645, };
+static const char32 __uni_decomp_data_0xfc0f[] = { 2, 0x62a, 0x649, };
+static const char32 __uni_decomp_data_0xfc10[] = { 2, 0x62a, 0x64a, };
+static const char32 __uni_decomp_data_0xfc11[] = { 2, 0x62b, 0x62c, };
+static const char32 __uni_decomp_data_0xfc12[] = { 2, 0x62b, 0x645, };
+static const char32 __uni_decomp_data_0xfc13[] = { 2, 0x62b, 0x649, };
+static const char32 __uni_decomp_data_0xfc14[] = { 2, 0x62b, 0x64a, };
+static const char32 __uni_decomp_data_0xfc15[] = { 2, 0x62c, 0x62d, };
+static const char32 __uni_decomp_data_0xfc16[] = { 2, 0x62c, 0x645, };
+static const char32 __uni_decomp_data_0xfc17[] = { 2, 0x62d, 0x62c, };
+static const char32 __uni_decomp_data_0xfc18[] = { 2, 0x62d, 0x645, };
+static const char32 __uni_decomp_data_0xfc19[] = { 2, 0x62e, 0x62c, };
+static const char32 __uni_decomp_data_0xfc1a[] = { 2, 0x62e, 0x62d, };
+static const char32 __uni_decomp_data_0xfc1b[] = { 2, 0x62e, 0x645, };
+static const char32 __uni_decomp_data_0xfc1c[] = { 2, 0x633, 0x62c, };
+static const char32 __uni_decomp_data_0xfc1d[] = { 2, 0x633, 0x62d, };
+static const char32 __uni_decomp_data_0xfc1e[] = { 2, 0x633, 0x62e, };
+static const char32 __uni_decomp_data_0xfc1f[] = { 2, 0x633, 0x645, };
+static const char32 __uni_decomp_data_0xfc20[] = { 2, 0x635, 0x62d, };
+static const char32 __uni_decomp_data_0xfc21[] = { 2, 0x635, 0x645, };
+static const char32 __uni_decomp_data_0xfc22[] = { 2, 0x636, 0x62c, };
+static const char32 __uni_decomp_data_0xfc23[] = { 2, 0x636, 0x62d, };
+static const char32 __uni_decomp_data_0xfc24[] = { 2, 0x636, 0x62e, };
+static const char32 __uni_decomp_data_0xfc25[] = { 2, 0x636, 0x645, };
+static const char32 __uni_decomp_data_0xfc26[] = { 2, 0x637, 0x62d, };
+static const char32 __uni_decomp_data_0xfc27[] = { 2, 0x637, 0x645, };
+static const char32 __uni_decomp_data_0xfc28[] = { 2, 0x638, 0x645, };
+static const char32 __uni_decomp_data_0xfc29[] = { 2, 0x639, 0x62c, };
+static const char32 __uni_decomp_data_0xfc2a[] = { 2, 0x639, 0x645, };
+static const char32 __uni_decomp_data_0xfc2b[] = { 2, 0x63a, 0x62c, };
+static const char32 __uni_decomp_data_0xfc2c[] = { 2, 0x63a, 0x645, };
+static const char32 __uni_decomp_data_0xfc2d[] = { 2, 0x641, 0x62c, };
+static const char32 __uni_decomp_data_0xfc2e[] = { 2, 0x641, 0x62d, };
+static const char32 __uni_decomp_data_0xfc2f[] = { 2, 0x641, 0x62e, };
+static const char32 __uni_decomp_data_0xfc30[] = { 2, 0x641, 0x645, };
+static const char32 __uni_decomp_data_0xfc31[] = { 2, 0x641, 0x649, };
+static const char32 __uni_decomp_data_0xfc32[] = { 2, 0x641, 0x64a, };
+static const char32 __uni_decomp_data_0xfc33[] = { 2, 0x642, 0x62d, };
+static const char32 __uni_decomp_data_0xfc34[] = { 2, 0x642, 0x645, };
+static const char32 __uni_decomp_data_0xfc35[] = { 2, 0x642, 0x649, };
+static const char32 __uni_decomp_data_0xfc36[] = { 2, 0x642, 0x64a, };
+static const char32 __uni_decomp_data_0xfc37[] = { 2, 0x643, 0x627, };
+static const char32 __uni_decomp_data_0xfc38[] = { 2, 0x643, 0x62c, };
+static const char32 __uni_decomp_data_0xfc39[] = { 2, 0x643, 0x62d, };
+static const char32 __uni_decomp_data_0xfc3a[] = { 2, 0x643, 0x62e, };
+static const char32 __uni_decomp_data_0xfc3b[] = { 2, 0x643, 0x644, };
+static const char32 __uni_decomp_data_0xfc3c[] = { 2, 0x643, 0x645, };
+static const char32 __uni_decomp_data_0xfc3d[] = { 2, 0x643, 0x649, };
+static const char32 __uni_decomp_data_0xfc3e[] = { 2, 0x643, 0x64a, };
+static const char32 __uni_decomp_data_0xfc3f[] = { 2, 0x644, 0x62c, };
+static const char32 __uni_decomp_data_0xfc40[] = { 2, 0x644, 0x62d, };
+static const char32 __uni_decomp_data_0xfc41[] = { 2, 0x644, 0x62e, };
+static const char32 __uni_decomp_data_0xfc42[] = { 2, 0x644, 0x645, };
+static const char32 __uni_decomp_data_0xfc43[] = { 2, 0x644, 0x649, };
+static const char32 __uni_decomp_data_0xfc44[] = { 2, 0x644, 0x64a, };
+static const char32 __uni_decomp_data_0xfc45[] = { 2, 0x645, 0x62c, };
+static const char32 __uni_decomp_data_0xfc46[] = { 2, 0x645, 0x62d, };
+static const char32 __uni_decomp_data_0xfc47[] = { 2, 0x645, 0x62e, };
+static const char32 __uni_decomp_data_0xfc48[] = { 2, 0x645, 0x645, };
+static const char32 __uni_decomp_data_0xfc49[] = { 2, 0x645, 0x649, };
+static const char32 __uni_decomp_data_0xfc4a[] = { 2, 0x645, 0x64a, };
+static const char32 __uni_decomp_data_0xfc4b[] = { 2, 0x646, 0x62c, };
+static const char32 __uni_decomp_data_0xfc4c[] = { 2, 0x646, 0x62d, };
+static const char32 __uni_decomp_data_0xfc4d[] = { 2, 0x646, 0x62e, };
+static const char32 __uni_decomp_data_0xfc4e[] = { 2, 0x646, 0x645, };
+static const char32 __uni_decomp_data_0xfc4f[] = { 2, 0x646, 0x649, };
+static const char32 __uni_decomp_data_0xfc50[] = { 2, 0x646, 0x64a, };
+static const char32 __uni_decomp_data_0xfc51[] = { 2, 0x647, 0x62c, };
+static const char32 __uni_decomp_data_0xfc52[] = { 2, 0x647, 0x645, };
+static const char32 __uni_decomp_data_0xfc53[] = { 2, 0x647, 0x649, };
+static const char32 __uni_decomp_data_0xfc54[] = { 2, 0x647, 0x64a, };
+static const char32 __uni_decomp_data_0xfc55[] = { 2, 0x64a, 0x62c, };
+static const char32 __uni_decomp_data_0xfc56[] = { 2, 0x64a, 0x62d, };
+static const char32 __uni_decomp_data_0xfc57[] = { 2, 0x64a, 0x62e, };
+static const char32 __uni_decomp_data_0xfc58[] = { 2, 0x64a, 0x645, };
+static const char32 __uni_decomp_data_0xfc59[] = { 2, 0x64a, 0x649, };
+static const char32 __uni_decomp_data_0xfc5a[] = { 2, 0x64a, 0x64a, };
+static const char32 __uni_decomp_data_0xfc5b[] = { 2, 0x630, 0x670, };
+static const char32 __uni_decomp_data_0xfc5c[] = { 2, 0x631, 0x670, };
+static const char32 __uni_decomp_data_0xfc5d[] = { 2, 0x649, 0x670, };
+static const char32 __uni_decomp_data_0xfc5e[] = { 3, 0x20, 0x64c, 0x651, };
+static const char32 __uni_decomp_data_0xfc5f[] = { 3, 0x20, 0x64d, 0x651, };
+static const char32 __uni_decomp_data_0xfc60[] = { 3, 0x20, 0x64e, 0x651, };
+static const char32 __uni_decomp_data_0xfc61[] = { 3, 0x20, 0x64f, 0x651, };
+static const char32 __uni_decomp_data_0xfc62[] = { 3, 0x20, 0x650, 0x651, };
+static const char32 __uni_decomp_data_0xfc63[] = { 3, 0x20, 0x651, 0x670, };
+static const char32 __uni_decomp_data_0xfc64[] = { 2, 0x626, 0x631, };
+static const char32 __uni_decomp_data_0xfc65[] = { 2, 0x626, 0x632, };
+static const char32 __uni_decomp_data_0xfc66[] = { 2, 0x626, 0x645, };
+static const char32 __uni_decomp_data_0xfc67[] = { 2, 0x626, 0x646, };
+static const char32 __uni_decomp_data_0xfc68[] = { 2, 0x626, 0x649, };
+static const char32 __uni_decomp_data_0xfc69[] = { 2, 0x626, 0x64a, };
+static const char32 __uni_decomp_data_0xfc6a[] = { 2, 0x628, 0x631, };
+static const char32 __uni_decomp_data_0xfc6b[] = { 2, 0x628, 0x632, };
+static const char32 __uni_decomp_data_0xfc6c[] = { 2, 0x628, 0x645, };
+static const char32 __uni_decomp_data_0xfc6d[] = { 2, 0x628, 0x646, };
+static const char32 __uni_decomp_data_0xfc6e[] = { 2, 0x628, 0x649, };
+static const char32 __uni_decomp_data_0xfc6f[] = { 2, 0x628, 0x64a, };
+static const char32 __uni_decomp_data_0xfc70[] = { 2, 0x62a, 0x631, };
+static const char32 __uni_decomp_data_0xfc71[] = { 2, 0x62a, 0x632, };
+static const char32 __uni_decomp_data_0xfc72[] = { 2, 0x62a, 0x645, };
+static const char32 __uni_decomp_data_0xfc73[] = { 2, 0x62a, 0x646, };
+static const char32 __uni_decomp_data_0xfc74[] = { 2, 0x62a, 0x649, };
+static const char32 __uni_decomp_data_0xfc75[] = { 2, 0x62a, 0x64a, };
+static const char32 __uni_decomp_data_0xfc76[] = { 2, 0x62b, 0x631, };
+static const char32 __uni_decomp_data_0xfc77[] = { 2, 0x62b, 0x632, };
+static const char32 __uni_decomp_data_0xfc78[] = { 2, 0x62b, 0x645, };
+static const char32 __uni_decomp_data_0xfc79[] = { 2, 0x62b, 0x646, };
+static const char32 __uni_decomp_data_0xfc7a[] = { 2, 0x62b, 0x649, };
+static const char32 __uni_decomp_data_0xfc7b[] = { 2, 0x62b, 0x64a, };
+static const char32 __uni_decomp_data_0xfc7c[] = { 2, 0x641, 0x649, };
+static const char32 __uni_decomp_data_0xfc7d[] = { 2, 0x641, 0x64a, };
+static const char32 __uni_decomp_data_0xfc7e[] = { 2, 0x642, 0x649, };
+static const char32 __uni_decomp_data_0xfc7f[] = { 2, 0x642, 0x64a, };
 
 
 

Modified: sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_7.ipp
==============================================================================
--- sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_7.ipp	(original)
+++ sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_7.ipp	2009-08-06 03:26:39 EDT (Thu, 06 Aug 2009)
@@ -21,134 +21,134 @@
 
 
 namespace boost { namespace unicode { namespace ucd {
-static const char32 __uni_decomp_data_0xfc80[] = { 0x643, 0x627, 0, };
-static const char32 __uni_decomp_data_0xfc81[] = { 0x643, 0x644, 0, };
-static const char32 __uni_decomp_data_0xfc82[] = { 0x643, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc83[] = { 0x643, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfc84[] = { 0x643, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfc85[] = { 0x644, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc86[] = { 0x644, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfc87[] = { 0x644, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfc88[] = { 0x645, 0x627, 0, };
-static const char32 __uni_decomp_data_0xfc89[] = { 0x645, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc8a[] = { 0x646, 0x631, 0, };
-static const char32 __uni_decomp_data_0xfc8b[] = { 0x646, 0x632, 0, };
-static const char32 __uni_decomp_data_0xfc8c[] = { 0x646, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc8d[] = { 0x646, 0x646, 0, };
-static const char32 __uni_decomp_data_0xfc8e[] = { 0x646, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfc8f[] = { 0x646, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfc90[] = { 0x649, 0x670, 0, };
-static const char32 __uni_decomp_data_0xfc91[] = { 0x64a, 0x631, 0, };
-static const char32 __uni_decomp_data_0xfc92[] = { 0x64a, 0x632, 0, };
-static const char32 __uni_decomp_data_0xfc93[] = { 0x64a, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc94[] = { 0x64a, 0x646, 0, };
-static const char32 __uni_decomp_data_0xfc95[] = { 0x64a, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfc96[] = { 0x64a, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfc97[] = { 0x626, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfc98[] = { 0x626, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfc99[] = { 0x626, 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfc9a[] = { 0x626, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfc9b[] = { 0x626, 0x647, 0, };
-static const char32 __uni_decomp_data_0xfc9c[] = { 0x628, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfc9d[] = { 0x628, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfc9e[] = { 0x628, 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfc9f[] = { 0x628, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfca0[] = { 0x628, 0x647, 0, };
-static const char32 __uni_decomp_data_0xfca1[] = { 0x62a, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfca2[] = { 0x62a, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfca3[] = { 0x62a, 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfca4[] = { 0x62a, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfca5[] = { 0x62a, 0x647, 0, };
-static const char32 __uni_decomp_data_0xfca6[] = { 0x62b, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfca7[] = { 0x62c, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfca8[] = { 0x62c, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfca9[] = { 0x62d, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfcaa[] = { 0x62d, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfcab[] = { 0x62e, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfcac[] = { 0x62e, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfcad[] = { 0x633, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfcae[] = { 0x633, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfcaf[] = { 0x633, 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfcb0[] = { 0x633, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfcb1[] = { 0x635, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfcb2[] = { 0x635, 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfcb3[] = { 0x635, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfcb4[] = { 0x636, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfcb5[] = { 0x636, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfcb6[] = { 0x636, 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfcb7[] = { 0x636, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfcb8[] = { 0x637, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfcb9[] = { 0x638, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfcba[] = { 0x639, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfcbb[] = { 0x639, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfcbc[] = { 0x63a, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfcbd[] = { 0x63a, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfcbe[] = { 0x641, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfcbf[] = { 0x641, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfcc0[] = { 0x641, 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfcc1[] = { 0x641, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfcc2[] = { 0x642, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfcc3[] = { 0x642, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfcc4[] = { 0x643, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfcc5[] = { 0x643, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfcc6[] = { 0x643, 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfcc7[] = { 0x643, 0x644, 0, };
-static const char32 __uni_decomp_data_0xfcc8[] = { 0x643, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfcc9[] = { 0x644, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfcca[] = { 0x644, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfccb[] = { 0x644, 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfccc[] = { 0x644, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfccd[] = { 0x644, 0x647, 0, };
-static const char32 __uni_decomp_data_0xfcce[] = { 0x645, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfccf[] = { 0x645, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfcd0[] = { 0x645, 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfcd1[] = { 0x645, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfcd2[] = { 0x646, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfcd3[] = { 0x646, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfcd4[] = { 0x646, 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfcd5[] = { 0x646, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfcd6[] = { 0x646, 0x647, 0, };
-static const char32 __uni_decomp_data_0xfcd7[] = { 0x647, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfcd8[] = { 0x647, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfcd9[] = { 0x647, 0x670, 0, };
-static const char32 __uni_decomp_data_0xfcda[] = { 0x64a, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfcdb[] = { 0x64a, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfcdc[] = { 0x64a, 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfcdd[] = { 0x64a, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfcde[] = { 0x64a, 0x647, 0, };
-static const char32 __uni_decomp_data_0xfcdf[] = { 0x626, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfce0[] = { 0x626, 0x647, 0, };
-static const char32 __uni_decomp_data_0xfce1[] = { 0x628, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfce2[] = { 0x628, 0x647, 0, };
-static const char32 __uni_decomp_data_0xfce3[] = { 0x62a, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfce4[] = { 0x62a, 0x647, 0, };
-static const char32 __uni_decomp_data_0xfce5[] = { 0x62b, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfce6[] = { 0x62b, 0x647, 0, };
-static const char32 __uni_decomp_data_0xfce7[] = { 0x633, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfce8[] = { 0x633, 0x647, 0, };
-static const char32 __uni_decomp_data_0xfce9[] = { 0x634, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfcea[] = { 0x634, 0x647, 0, };
-static const char32 __uni_decomp_data_0xfceb[] = { 0x643, 0x644, 0, };
-static const char32 __uni_decomp_data_0xfcec[] = { 0x643, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfced[] = { 0x644, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfcee[] = { 0x646, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfcef[] = { 0x646, 0x647, 0, };
-static const char32 __uni_decomp_data_0xfcf0[] = { 0x64a, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfcf1[] = { 0x64a, 0x647, 0, };
-static const char32 __uni_decomp_data_0xfcf2[] = { 0x640, 0x64e, 0x651, 0, };
-static const char32 __uni_decomp_data_0xfcf3[] = { 0x640, 0x64f, 0x651, 0, };
-static const char32 __uni_decomp_data_0xfcf4[] = { 0x640, 0x650, 0x651, 0, };
-static const char32 __uni_decomp_data_0xfcf5[] = { 0x637, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfcf6[] = { 0x637, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfcf7[] = { 0x639, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfcf8[] = { 0x639, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfcf9[] = { 0x63a, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfcfa[] = { 0x63a, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfcfb[] = { 0x633, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfcfc[] = { 0x633, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfcfd[] = { 0x634, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfcfe[] = { 0x634, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfcff[] = { 0x62d, 0x649, 0, };
+static const char32 __uni_decomp_data_0xfc80[] = { 2, 0x643, 0x627, };
+static const char32 __uni_decomp_data_0xfc81[] = { 2, 0x643, 0x644, };
+static const char32 __uni_decomp_data_0xfc82[] = { 2, 0x643, 0x645, };
+static const char32 __uni_decomp_data_0xfc83[] = { 2, 0x643, 0x649, };
+static const char32 __uni_decomp_data_0xfc84[] = { 2, 0x643, 0x64a, };
+static const char32 __uni_decomp_data_0xfc85[] = { 2, 0x644, 0x645, };
+static const char32 __uni_decomp_data_0xfc86[] = { 2, 0x644, 0x649, };
+static const char32 __uni_decomp_data_0xfc87[] = { 2, 0x644, 0x64a, };
+static const char32 __uni_decomp_data_0xfc88[] = { 2, 0x645, 0x627, };
+static const char32 __uni_decomp_data_0xfc89[] = { 2, 0x645, 0x645, };
+static const char32 __uni_decomp_data_0xfc8a[] = { 2, 0x646, 0x631, };
+static const char32 __uni_decomp_data_0xfc8b[] = { 2, 0x646, 0x632, };
+static const char32 __uni_decomp_data_0xfc8c[] = { 2, 0x646, 0x645, };
+static const char32 __uni_decomp_data_0xfc8d[] = { 2, 0x646, 0x646, };
+static const char32 __uni_decomp_data_0xfc8e[] = { 2, 0x646, 0x649, };
+static const char32 __uni_decomp_data_0xfc8f[] = { 2, 0x646, 0x64a, };
+static const char32 __uni_decomp_data_0xfc90[] = { 2, 0x649, 0x670, };
+static const char32 __uni_decomp_data_0xfc91[] = { 2, 0x64a, 0x631, };
+static const char32 __uni_decomp_data_0xfc92[] = { 2, 0x64a, 0x632, };
+static const char32 __uni_decomp_data_0xfc93[] = { 2, 0x64a, 0x645, };
+static const char32 __uni_decomp_data_0xfc94[] = { 2, 0x64a, 0x646, };
+static const char32 __uni_decomp_data_0xfc95[] = { 2, 0x64a, 0x649, };
+static const char32 __uni_decomp_data_0xfc96[] = { 2, 0x64a, 0x64a, };
+static const char32 __uni_decomp_data_0xfc97[] = { 2, 0x626, 0x62c, };
+static const char32 __uni_decomp_data_0xfc98[] = { 2, 0x626, 0x62d, };
+static const char32 __uni_decomp_data_0xfc99[] = { 2, 0x626, 0x62e, };
+static const char32 __uni_decomp_data_0xfc9a[] = { 2, 0x626, 0x645, };
+static const char32 __uni_decomp_data_0xfc9b[] = { 2, 0x626, 0x647, };
+static const char32 __uni_decomp_data_0xfc9c[] = { 2, 0x628, 0x62c, };
+static const char32 __uni_decomp_data_0xfc9d[] = { 2, 0x628, 0x62d, };
+static const char32 __uni_decomp_data_0xfc9e[] = { 2, 0x628, 0x62e, };
+static const char32 __uni_decomp_data_0xfc9f[] = { 2, 0x628, 0x645, };
+static const char32 __uni_decomp_data_0xfca0[] = { 2, 0x628, 0x647, };
+static const char32 __uni_decomp_data_0xfca1[] = { 2, 0x62a, 0x62c, };
+static const char32 __uni_decomp_data_0xfca2[] = { 2, 0x62a, 0x62d, };
+static const char32 __uni_decomp_data_0xfca3[] = { 2, 0x62a, 0x62e, };
+static const char32 __uni_decomp_data_0xfca4[] = { 2, 0x62a, 0x645, };
+static const char32 __uni_decomp_data_0xfca5[] = { 2, 0x62a, 0x647, };
+static const char32 __uni_decomp_data_0xfca6[] = { 2, 0x62b, 0x645, };
+static const char32 __uni_decomp_data_0xfca7[] = { 2, 0x62c, 0x62d, };
+static const char32 __uni_decomp_data_0xfca8[] = { 2, 0x62c, 0x645, };
+static const char32 __uni_decomp_data_0xfca9[] = { 2, 0x62d, 0x62c, };
+static const char32 __uni_decomp_data_0xfcaa[] = { 2, 0x62d, 0x645, };
+static const char32 __uni_decomp_data_0xfcab[] = { 2, 0x62e, 0x62c, };
+static const char32 __uni_decomp_data_0xfcac[] = { 2, 0x62e, 0x645, };
+static const char32 __uni_decomp_data_0xfcad[] = { 2, 0x633, 0x62c, };
+static const char32 __uni_decomp_data_0xfcae[] = { 2, 0x633, 0x62d, };
+static const char32 __uni_decomp_data_0xfcaf[] = { 2, 0x633, 0x62e, };
+static const char32 __uni_decomp_data_0xfcb0[] = { 2, 0x633, 0x645, };
+static const char32 __uni_decomp_data_0xfcb1[] = { 2, 0x635, 0x62d, };
+static const char32 __uni_decomp_data_0xfcb2[] = { 2, 0x635, 0x62e, };
+static const char32 __uni_decomp_data_0xfcb3[] = { 2, 0x635, 0x645, };
+static const char32 __uni_decomp_data_0xfcb4[] = { 2, 0x636, 0x62c, };
+static const char32 __uni_decomp_data_0xfcb5[] = { 2, 0x636, 0x62d, };
+static const char32 __uni_decomp_data_0xfcb6[] = { 2, 0x636, 0x62e, };
+static const char32 __uni_decomp_data_0xfcb7[] = { 2, 0x636, 0x645, };
+static const char32 __uni_decomp_data_0xfcb8[] = { 2, 0x637, 0x62d, };
+static const char32 __uni_decomp_data_0xfcb9[] = { 2, 0x638, 0x645, };
+static const char32 __uni_decomp_data_0xfcba[] = { 2, 0x639, 0x62c, };
+static const char32 __uni_decomp_data_0xfcbb[] = { 2, 0x639, 0x645, };
+static const char32 __uni_decomp_data_0xfcbc[] = { 2, 0x63a, 0x62c, };
+static const char32 __uni_decomp_data_0xfcbd[] = { 2, 0x63a, 0x645, };
+static const char32 __uni_decomp_data_0xfcbe[] = { 2, 0x641, 0x62c, };
+static const char32 __uni_decomp_data_0xfcbf[] = { 2, 0x641, 0x62d, };
+static const char32 __uni_decomp_data_0xfcc0[] = { 2, 0x641, 0x62e, };
+static const char32 __uni_decomp_data_0xfcc1[] = { 2, 0x641, 0x645, };
+static const char32 __uni_decomp_data_0xfcc2[] = { 2, 0x642, 0x62d, };
+static const char32 __uni_decomp_data_0xfcc3[] = { 2, 0x642, 0x645, };
+static const char32 __uni_decomp_data_0xfcc4[] = { 2, 0x643, 0x62c, };
+static const char32 __uni_decomp_data_0xfcc5[] = { 2, 0x643, 0x62d, };
+static const char32 __uni_decomp_data_0xfcc6[] = { 2, 0x643, 0x62e, };
+static const char32 __uni_decomp_data_0xfcc7[] = { 2, 0x643, 0x644, };
+static const char32 __uni_decomp_data_0xfcc8[] = { 2, 0x643, 0x645, };
+static const char32 __uni_decomp_data_0xfcc9[] = { 2, 0x644, 0x62c, };
+static const char32 __uni_decomp_data_0xfcca[] = { 2, 0x644, 0x62d, };
+static const char32 __uni_decomp_data_0xfccb[] = { 2, 0x644, 0x62e, };
+static const char32 __uni_decomp_data_0xfccc[] = { 2, 0x644, 0x645, };
+static const char32 __uni_decomp_data_0xfccd[] = { 2, 0x644, 0x647, };
+static const char32 __uni_decomp_data_0xfcce[] = { 2, 0x645, 0x62c, };
+static const char32 __uni_decomp_data_0xfccf[] = { 2, 0x645, 0x62d, };
+static const char32 __uni_decomp_data_0xfcd0[] = { 2, 0x645, 0x62e, };
+static const char32 __uni_decomp_data_0xfcd1[] = { 2, 0x645, 0x645, };
+static const char32 __uni_decomp_data_0xfcd2[] = { 2, 0x646, 0x62c, };
+static const char32 __uni_decomp_data_0xfcd3[] = { 2, 0x646, 0x62d, };
+static const char32 __uni_decomp_data_0xfcd4[] = { 2, 0x646, 0x62e, };
+static const char32 __uni_decomp_data_0xfcd5[] = { 2, 0x646, 0x645, };
+static const char32 __uni_decomp_data_0xfcd6[] = { 2, 0x646, 0x647, };
+static const char32 __uni_decomp_data_0xfcd7[] = { 2, 0x647, 0x62c, };
+static const char32 __uni_decomp_data_0xfcd8[] = { 2, 0x647, 0x645, };
+static const char32 __uni_decomp_data_0xfcd9[] = { 2, 0x647, 0x670, };
+static const char32 __uni_decomp_data_0xfcda[] = { 2, 0x64a, 0x62c, };
+static const char32 __uni_decomp_data_0xfcdb[] = { 2, 0x64a, 0x62d, };
+static const char32 __uni_decomp_data_0xfcdc[] = { 2, 0x64a, 0x62e, };
+static const char32 __uni_decomp_data_0xfcdd[] = { 2, 0x64a, 0x645, };
+static const char32 __uni_decomp_data_0xfcde[] = { 2, 0x64a, 0x647, };
+static const char32 __uni_decomp_data_0xfcdf[] = { 2, 0x626, 0x645, };
+static const char32 __uni_decomp_data_0xfce0[] = { 2, 0x626, 0x647, };
+static const char32 __uni_decomp_data_0xfce1[] = { 2, 0x628, 0x645, };
+static const char32 __uni_decomp_data_0xfce2[] = { 2, 0x628, 0x647, };
+static const char32 __uni_decomp_data_0xfce3[] = { 2, 0x62a, 0x645, };
+static const char32 __uni_decomp_data_0xfce4[] = { 2, 0x62a, 0x647, };
+static const char32 __uni_decomp_data_0xfce5[] = { 2, 0x62b, 0x645, };
+static const char32 __uni_decomp_data_0xfce6[] = { 2, 0x62b, 0x647, };
+static const char32 __uni_decomp_data_0xfce7[] = { 2, 0x633, 0x645, };
+static const char32 __uni_decomp_data_0xfce8[] = { 2, 0x633, 0x647, };
+static const char32 __uni_decomp_data_0xfce9[] = { 2, 0x634, 0x645, };
+static const char32 __uni_decomp_data_0xfcea[] = { 2, 0x634, 0x647, };
+static const char32 __uni_decomp_data_0xfceb[] = { 2, 0x643, 0x644, };
+static const char32 __uni_decomp_data_0xfcec[] = { 2, 0x643, 0x645, };
+static const char32 __uni_decomp_data_0xfced[] = { 2, 0x644, 0x645, };
+static const char32 __uni_decomp_data_0xfcee[] = { 2, 0x646, 0x645, };
+static const char32 __uni_decomp_data_0xfcef[] = { 2, 0x646, 0x647, };
+static const char32 __uni_decomp_data_0xfcf0[] = { 2, 0x64a, 0x645, };
+static const char32 __uni_decomp_data_0xfcf1[] = { 2, 0x64a, 0x647, };
+static const char32 __uni_decomp_data_0xfcf2[] = { 3, 0x640, 0x64e, 0x651, };
+static const char32 __uni_decomp_data_0xfcf3[] = { 3, 0x640, 0x64f, 0x651, };
+static const char32 __uni_decomp_data_0xfcf4[] = { 3, 0x640, 0x650, 0x651, };
+static const char32 __uni_decomp_data_0xfcf5[] = { 2, 0x637, 0x649, };
+static const char32 __uni_decomp_data_0xfcf6[] = { 2, 0x637, 0x64a, };
+static const char32 __uni_decomp_data_0xfcf7[] = { 2, 0x639, 0x649, };
+static const char32 __uni_decomp_data_0xfcf8[] = { 2, 0x639, 0x64a, };
+static const char32 __uni_decomp_data_0xfcf9[] = { 2, 0x63a, 0x649, };
+static const char32 __uni_decomp_data_0xfcfa[] = { 2, 0x63a, 0x64a, };
+static const char32 __uni_decomp_data_0xfcfb[] = { 2, 0x633, 0x649, };
+static const char32 __uni_decomp_data_0xfcfc[] = { 2, 0x633, 0x64a, };
+static const char32 __uni_decomp_data_0xfcfd[] = { 2, 0x634, 0x649, };
+static const char32 __uni_decomp_data_0xfcfe[] = { 2, 0x634, 0x64a, };
+static const char32 __uni_decomp_data_0xfcff[] = { 2, 0x62d, 0x649, };
 
 
 
@@ -1822,116 +1822,116 @@
 };
 
 
-static const char32 __uni_decomp_data_0xfd00[] = { 0x62d, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfd01[] = { 0x62c, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfd02[] = { 0x62c, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfd03[] = { 0x62e, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfd04[] = { 0x62e, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfd05[] = { 0x635, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfd06[] = { 0x635, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfd07[] = { 0x636, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfd08[] = { 0x636, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfd09[] = { 0x634, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfd0a[] = { 0x634, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfd0b[] = { 0x634, 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfd0c[] = { 0x634, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd0d[] = { 0x634, 0x631, 0, };
-static const char32 __uni_decomp_data_0xfd0e[] = { 0x633, 0x631, 0, };
-static const char32 __uni_decomp_data_0xfd0f[] = { 0x635, 0x631, 0, };
-static const char32 __uni_decomp_data_0xfd10[] = { 0x636, 0x631, 0, };
-static const char32 __uni_decomp_data_0xfd11[] = { 0x637, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfd12[] = { 0x637, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfd13[] = { 0x639, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfd14[] = { 0x639, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfd15[] = { 0x63a, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfd16[] = { 0x63a, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfd17[] = { 0x633, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfd18[] = { 0x633, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfd19[] = { 0x634, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfd1a[] = { 0x634, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfd1b[] = { 0x62d, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfd1c[] = { 0x62d, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfd1d[] = { 0x62c, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfd1e[] = { 0x62c, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfd1f[] = { 0x62e, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfd20[] = { 0x62e, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfd21[] = { 0x635, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfd22[] = { 0x635, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfd23[] = { 0x636, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfd24[] = { 0x636, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfd25[] = { 0x634, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfd26[] = { 0x634, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfd27[] = { 0x634, 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfd28[] = { 0x634, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd29[] = { 0x634, 0x631, 0, };
-static const char32 __uni_decomp_data_0xfd2a[] = { 0x633, 0x631, 0, };
-static const char32 __uni_decomp_data_0xfd2b[] = { 0x635, 0x631, 0, };
-static const char32 __uni_decomp_data_0xfd2c[] = { 0x636, 0x631, 0, };
-static const char32 __uni_decomp_data_0xfd2d[] = { 0x634, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfd2e[] = { 0x634, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfd2f[] = { 0x634, 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfd30[] = { 0x634, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd31[] = { 0x633, 0x647, 0, };
-static const char32 __uni_decomp_data_0xfd32[] = { 0x634, 0x647, 0, };
-static const char32 __uni_decomp_data_0xfd33[] = { 0x637, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd34[] = { 0x633, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfd35[] = { 0x633, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfd36[] = { 0x633, 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfd37[] = { 0x634, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfd38[] = { 0x634, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfd39[] = { 0x634, 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfd3a[] = { 0x637, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd3b[] = { 0x638, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd3c[] = { 0x627, 0x64b, 0, };
-static const char32 __uni_decomp_data_0xfd3d[] = { 0x627, 0x64b, 0, };
-static const char32 __uni_decomp_data_0xfd50[] = { 0x62a, 0x62c, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd51[] = { 0x62a, 0x62d, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfd52[] = { 0x62a, 0x62d, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfd53[] = { 0x62a, 0x62d, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd54[] = { 0x62a, 0x62e, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd55[] = { 0x62a, 0x645, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfd56[] = { 0x62a, 0x645, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfd57[] = { 0x62a, 0x645, 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfd58[] = { 0x62c, 0x645, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfd59[] = { 0x62c, 0x645, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfd5a[] = { 0x62d, 0x645, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfd5b[] = { 0x62d, 0x645, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfd5c[] = { 0x633, 0x62d, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfd5d[] = { 0x633, 0x62c, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfd5e[] = { 0x633, 0x62c, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfd5f[] = { 0x633, 0x645, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfd60[] = { 0x633, 0x645, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfd61[] = { 0x633, 0x645, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfd62[] = { 0x633, 0x645, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd63[] = { 0x633, 0x645, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd64[] = { 0x635, 0x62d, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfd65[] = { 0x635, 0x62d, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfd66[] = { 0x635, 0x645, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd67[] = { 0x634, 0x62d, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd68[] = { 0x634, 0x62d, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd69[] = { 0x634, 0x62c, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfd6a[] = { 0x634, 0x645, 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfd6b[] = { 0x634, 0x645, 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfd6c[] = { 0x634, 0x645, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd6d[] = { 0x634, 0x645, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd6e[] = { 0x636, 0x62d, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfd6f[] = { 0x636, 0x62e, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd70[] = { 0x636, 0x62e, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd71[] = { 0x637, 0x645, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfd72[] = { 0x637, 0x645, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfd73[] = { 0x637, 0x645, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd74[] = { 0x637, 0x645, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfd75[] = { 0x639, 0x62c, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd76[] = { 0x639, 0x645, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd77[] = { 0x639, 0x645, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd78[] = { 0x639, 0x645, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfd79[] = { 0x63a, 0x645, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd7a[] = { 0x63a, 0x645, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfd7b[] = { 0x63a, 0x645, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfd7c[] = { 0x641, 0x62e, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd7d[] = { 0x641, 0x62e, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd7e[] = { 0x642, 0x645, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfd7f[] = { 0x642, 0x645, 0x645, 0, };
+static const char32 __uni_decomp_data_0xfd00[] = { 2, 0x62d, 0x64a, };
+static const char32 __uni_decomp_data_0xfd01[] = { 2, 0x62c, 0x649, };
+static const char32 __uni_decomp_data_0xfd02[] = { 2, 0x62c, 0x64a, };
+static const char32 __uni_decomp_data_0xfd03[] = { 2, 0x62e, 0x649, };
+static const char32 __uni_decomp_data_0xfd04[] = { 2, 0x62e, 0x64a, };
+static const char32 __uni_decomp_data_0xfd05[] = { 2, 0x635, 0x649, };
+static const char32 __uni_decomp_data_0xfd06[] = { 2, 0x635, 0x64a, };
+static const char32 __uni_decomp_data_0xfd07[] = { 2, 0x636, 0x649, };
+static const char32 __uni_decomp_data_0xfd08[] = { 2, 0x636, 0x64a, };
+static const char32 __uni_decomp_data_0xfd09[] = { 2, 0x634, 0x62c, };
+static const char32 __uni_decomp_data_0xfd0a[] = { 2, 0x634, 0x62d, };
+static const char32 __uni_decomp_data_0xfd0b[] = { 2, 0x634, 0x62e, };
+static const char32 __uni_decomp_data_0xfd0c[] = { 2, 0x634, 0x645, };
+static const char32 __uni_decomp_data_0xfd0d[] = { 2, 0x634, 0x631, };
+static const char32 __uni_decomp_data_0xfd0e[] = { 2, 0x633, 0x631, };
+static const char32 __uni_decomp_data_0xfd0f[] = { 2, 0x635, 0x631, };
+static const char32 __uni_decomp_data_0xfd10[] = { 2, 0x636, 0x631, };
+static const char32 __uni_decomp_data_0xfd11[] = { 2, 0x637, 0x649, };
+static const char32 __uni_decomp_data_0xfd12[] = { 2, 0x637, 0x64a, };
+static const char32 __uni_decomp_data_0xfd13[] = { 2, 0x639, 0x649, };
+static const char32 __uni_decomp_data_0xfd14[] = { 2, 0x639, 0x64a, };
+static const char32 __uni_decomp_data_0xfd15[] = { 2, 0x63a, 0x649, };
+static const char32 __uni_decomp_data_0xfd16[] = { 2, 0x63a, 0x64a, };
+static const char32 __uni_decomp_data_0xfd17[] = { 2, 0x633, 0x649, };
+static const char32 __uni_decomp_data_0xfd18[] = { 2, 0x633, 0x64a, };
+static const char32 __uni_decomp_data_0xfd19[] = { 2, 0x634, 0x649, };
+static const char32 __uni_decomp_data_0xfd1a[] = { 2, 0x634, 0x64a, };
+static const char32 __uni_decomp_data_0xfd1b[] = { 2, 0x62d, 0x649, };
+static const char32 __uni_decomp_data_0xfd1c[] = { 2, 0x62d, 0x64a, };
+static const char32 __uni_decomp_data_0xfd1d[] = { 2, 0x62c, 0x649, };
+static const char32 __uni_decomp_data_0xfd1e[] = { 2, 0x62c, 0x64a, };
+static const char32 __uni_decomp_data_0xfd1f[] = { 2, 0x62e, 0x649, };
+static const char32 __uni_decomp_data_0xfd20[] = { 2, 0x62e, 0x64a, };
+static const char32 __uni_decomp_data_0xfd21[] = { 2, 0x635, 0x649, };
+static const char32 __uni_decomp_data_0xfd22[] = { 2, 0x635, 0x64a, };
+static const char32 __uni_decomp_data_0xfd23[] = { 2, 0x636, 0x649, };
+static const char32 __uni_decomp_data_0xfd24[] = { 2, 0x636, 0x64a, };
+static const char32 __uni_decomp_data_0xfd25[] = { 2, 0x634, 0x62c, };
+static const char32 __uni_decomp_data_0xfd26[] = { 2, 0x634, 0x62d, };
+static const char32 __uni_decomp_data_0xfd27[] = { 2, 0x634, 0x62e, };
+static const char32 __uni_decomp_data_0xfd28[] = { 2, 0x634, 0x645, };
+static const char32 __uni_decomp_data_0xfd29[] = { 2, 0x634, 0x631, };
+static const char32 __uni_decomp_data_0xfd2a[] = { 2, 0x633, 0x631, };
+static const char32 __uni_decomp_data_0xfd2b[] = { 2, 0x635, 0x631, };
+static const char32 __uni_decomp_data_0xfd2c[] = { 2, 0x636, 0x631, };
+static const char32 __uni_decomp_data_0xfd2d[] = { 2, 0x634, 0x62c, };
+static const char32 __uni_decomp_data_0xfd2e[] = { 2, 0x634, 0x62d, };
+static const char32 __uni_decomp_data_0xfd2f[] = { 2, 0x634, 0x62e, };
+static const char32 __uni_decomp_data_0xfd30[] = { 2, 0x634, 0x645, };
+static const char32 __uni_decomp_data_0xfd31[] = { 2, 0x633, 0x647, };
+static const char32 __uni_decomp_data_0xfd32[] = { 2, 0x634, 0x647, };
+static const char32 __uni_decomp_data_0xfd33[] = { 2, 0x637, 0x645, };
+static const char32 __uni_decomp_data_0xfd34[] = { 2, 0x633, 0x62c, };
+static const char32 __uni_decomp_data_0xfd35[] = { 2, 0x633, 0x62d, };
+static const char32 __uni_decomp_data_0xfd36[] = { 2, 0x633, 0x62e, };
+static const char32 __uni_decomp_data_0xfd37[] = { 2, 0x634, 0x62c, };
+static const char32 __uni_decomp_data_0xfd38[] = { 2, 0x634, 0x62d, };
+static const char32 __uni_decomp_data_0xfd39[] = { 2, 0x634, 0x62e, };
+static const char32 __uni_decomp_data_0xfd3a[] = { 2, 0x637, 0x645, };
+static const char32 __uni_decomp_data_0xfd3b[] = { 2, 0x638, 0x645, };
+static const char32 __uni_decomp_data_0xfd3c[] = { 2, 0x627, 0x64b, };
+static const char32 __uni_decomp_data_0xfd3d[] = { 2, 0x627, 0x64b, };
+static const char32 __uni_decomp_data_0xfd50[] = { 3, 0x62a, 0x62c, 0x645, };
+static const char32 __uni_decomp_data_0xfd51[] = { 3, 0x62a, 0x62d, 0x62c, };
+static const char32 __uni_decomp_data_0xfd52[] = { 3, 0x62a, 0x62d, 0x62c, };
+static const char32 __uni_decomp_data_0xfd53[] = { 3, 0x62a, 0x62d, 0x645, };
+static const char32 __uni_decomp_data_0xfd54[] = { 3, 0x62a, 0x62e, 0x645, };
+static const char32 __uni_decomp_data_0xfd55[] = { 3, 0x62a, 0x645, 0x62c, };
+static const char32 __uni_decomp_data_0xfd56[] = { 3, 0x62a, 0x645, 0x62d, };
+static const char32 __uni_decomp_data_0xfd57[] = { 3, 0x62a, 0x645, 0x62e, };
+static const char32 __uni_decomp_data_0xfd58[] = { 3, 0x62c, 0x645, 0x62d, };
+static const char32 __uni_decomp_data_0xfd59[] = { 3, 0x62c, 0x645, 0x62d, };
+static const char32 __uni_decomp_data_0xfd5a[] = { 3, 0x62d, 0x645, 0x64a, };
+static const char32 __uni_decomp_data_0xfd5b[] = { 3, 0x62d, 0x645, 0x649, };
+static const char32 __uni_decomp_data_0xfd5c[] = { 3, 0x633, 0x62d, 0x62c, };
+static const char32 __uni_decomp_data_0xfd5d[] = { 3, 0x633, 0x62c, 0x62d, };
+static const char32 __uni_decomp_data_0xfd5e[] = { 3, 0x633, 0x62c, 0x649, };
+static const char32 __uni_decomp_data_0xfd5f[] = { 3, 0x633, 0x645, 0x62d, };
+static const char32 __uni_decomp_data_0xfd60[] = { 3, 0x633, 0x645, 0x62d, };
+static const char32 __uni_decomp_data_0xfd61[] = { 3, 0x633, 0x645, 0x62c, };
+static const char32 __uni_decomp_data_0xfd62[] = { 3, 0x633, 0x645, 0x645, };
+static const char32 __uni_decomp_data_0xfd63[] = { 3, 0x633, 0x645, 0x645, };
+static const char32 __uni_decomp_data_0xfd64[] = { 3, 0x635, 0x62d, 0x62d, };
+static const char32 __uni_decomp_data_0xfd65[] = { 3, 0x635, 0x62d, 0x62d, };
+static const char32 __uni_decomp_data_0xfd66[] = { 3, 0x635, 0x645, 0x645, };
+static const char32 __uni_decomp_data_0xfd67[] = { 3, 0x634, 0x62d, 0x645, };
+static const char32 __uni_decomp_data_0xfd68[] = { 3, 0x634, 0x62d, 0x645, };
+static const char32 __uni_decomp_data_0xfd69[] = { 3, 0x634, 0x62c, 0x64a, };
+static const char32 __uni_decomp_data_0xfd6a[] = { 3, 0x634, 0x645, 0x62e, };
+static const char32 __uni_decomp_data_0xfd6b[] = { 3, 0x634, 0x645, 0x62e, };
+static const char32 __uni_decomp_data_0xfd6c[] = { 3, 0x634, 0x645, 0x645, };
+static const char32 __uni_decomp_data_0xfd6d[] = { 3, 0x634, 0x645, 0x645, };
+static const char32 __uni_decomp_data_0xfd6e[] = { 3, 0x636, 0x62d, 0x649, };
+static const char32 __uni_decomp_data_0xfd6f[] = { 3, 0x636, 0x62e, 0x645, };
+static const char32 __uni_decomp_data_0xfd70[] = { 3, 0x636, 0x62e, 0x645, };
+static const char32 __uni_decomp_data_0xfd71[] = { 3, 0x637, 0x645, 0x62d, };
+static const char32 __uni_decomp_data_0xfd72[] = { 3, 0x637, 0x645, 0x62d, };
+static const char32 __uni_decomp_data_0xfd73[] = { 3, 0x637, 0x645, 0x645, };
+static const char32 __uni_decomp_data_0xfd74[] = { 3, 0x637, 0x645, 0x64a, };
+static const char32 __uni_decomp_data_0xfd75[] = { 3, 0x639, 0x62c, 0x645, };
+static const char32 __uni_decomp_data_0xfd76[] = { 3, 0x639, 0x645, 0x645, };
+static const char32 __uni_decomp_data_0xfd77[] = { 3, 0x639, 0x645, 0x645, };
+static const char32 __uni_decomp_data_0xfd78[] = { 3, 0x639, 0x645, 0x649, };
+static const char32 __uni_decomp_data_0xfd79[] = { 3, 0x63a, 0x645, 0x645, };
+static const char32 __uni_decomp_data_0xfd7a[] = { 3, 0x63a, 0x645, 0x64a, };
+static const char32 __uni_decomp_data_0xfd7b[] = { 3, 0x63a, 0x645, 0x649, };
+static const char32 __uni_decomp_data_0xfd7c[] = { 3, 0x641, 0x62e, 0x645, };
+static const char32 __uni_decomp_data_0xfd7d[] = { 3, 0x641, 0x62e, 0x645, };
+static const char32 __uni_decomp_data_0xfd7e[] = { 3, 0x642, 0x645, 0x62d, };
+static const char32 __uni_decomp_data_0xfd7f[] = { 3, 0x642, 0x645, 0x645, };
 
 
 
@@ -3605,89 +3605,89 @@
 };
 
 
-static const char32 __uni_decomp_data_0xfd80[] = { 0x644, 0x62d, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd81[] = { 0x644, 0x62d, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfd82[] = { 0x644, 0x62d, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfd83[] = { 0x644, 0x62c, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfd84[] = { 0x644, 0x62c, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfd85[] = { 0x644, 0x62e, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd86[] = { 0x644, 0x62e, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd87[] = { 0x644, 0x645, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfd88[] = { 0x644, 0x645, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfd89[] = { 0x645, 0x62d, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfd8a[] = { 0x645, 0x62d, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd8b[] = { 0x645, 0x62d, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfd8c[] = { 0x645, 0x62c, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfd8d[] = { 0x645, 0x62c, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd8e[] = { 0x645, 0x62e, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfd8f[] = { 0x645, 0x62e, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd92[] = { 0x645, 0x62c, 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfd93[] = { 0x647, 0x645, 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfd94[] = { 0x647, 0x645, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd95[] = { 0x646, 0x62d, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd96[] = { 0x646, 0x62d, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfd97[] = { 0x646, 0x62c, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd98[] = { 0x646, 0x62c, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd99[] = { 0x646, 0x62c, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfd9a[] = { 0x646, 0x645, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfd9b[] = { 0x646, 0x645, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfd9c[] = { 0x64a, 0x645, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd9d[] = { 0x64a, 0x645, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfd9e[] = { 0x628, 0x62e, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfd9f[] = { 0x62a, 0x62c, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfda0[] = { 0x62a, 0x62c, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfda1[] = { 0x62a, 0x62e, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfda2[] = { 0x62a, 0x62e, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfda3[] = { 0x62a, 0x645, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfda4[] = { 0x62a, 0x645, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfda5[] = { 0x62c, 0x645, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfda6[] = { 0x62c, 0x62d, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfda7[] = { 0x62c, 0x645, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfda8[] = { 0x633, 0x62e, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfda9[] = { 0x635, 0x62d, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfdaa[] = { 0x634, 0x62d, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfdab[] = { 0x636, 0x62d, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfdac[] = { 0x644, 0x62c, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfdad[] = { 0x644, 0x645, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfdae[] = { 0x64a, 0x62d, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfdaf[] = { 0x64a, 0x62c, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfdb0[] = { 0x64a, 0x645, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfdb1[] = { 0x645, 0x645, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfdb2[] = { 0x642, 0x645, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfdb3[] = { 0x646, 0x62d, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfdb4[] = { 0x642, 0x645, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfdb5[] = { 0x644, 0x62d, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfdb6[] = { 0x639, 0x645, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfdb7[] = { 0x643, 0x645, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfdb8[] = { 0x646, 0x62c, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfdb9[] = { 0x645, 0x62e, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfdba[] = { 0x644, 0x62c, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfdbb[] = { 0x643, 0x645, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfdbc[] = { 0x644, 0x62c, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfdbd[] = { 0x646, 0x62c, 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfdbe[] = { 0x62c, 0x62d, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfdbf[] = { 0x62d, 0x62c, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfdc0[] = { 0x645, 0x62c, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfdc1[] = { 0x641, 0x645, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfdc2[] = { 0x628, 0x62d, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfdc3[] = { 0x643, 0x645, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfdc4[] = { 0x639, 0x62c, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfdc5[] = { 0x635, 0x645, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfdc6[] = { 0x633, 0x62e, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfdc7[] = { 0x646, 0x62c, 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfdf0[] = { 0x635, 0x644, 0x6d2, 0, };
-static const char32 __uni_decomp_data_0xfdf1[] = { 0x642, 0x644, 0x6d2, 0, };
-static const char32 __uni_decomp_data_0xfdf2[] = { 0x627, 0x644, 0x644, 0x647, 0, };
-static const char32 __uni_decomp_data_0xfdf3[] = { 0x627, 0x643, 0x628, 0x631, 0, };
-static const char32 __uni_decomp_data_0xfdf4[] = { 0x645, 0x62d, 0x645, 0x62f, 0, };
-static const char32 __uni_decomp_data_0xfdf5[] = { 0x635, 0x644, 0x639, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfdf6[] = { 0x631, 0x633, 0x648, 0x644, 0, };
-static const char32 __uni_decomp_data_0xfdf7[] = { 0x639, 0x644, 0x64a, 0x647, 0, };
-static const char32 __uni_decomp_data_0xfdf8[] = { 0x648, 0x633, 0x644, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfdf9[] = { 0x635, 0x644, 0x649, 0, };
-static const char32 __uni_decomp_data_0xfdfa[] = { 0x635, 0x644, 0x649, 0x20, 0x627, 0x644, 0x644, 0x647, 0x20, 0x639, 0x644, 0x64a, 0x647, 0x20, 0x648, 0x633, 0x644, 0x645, 0, };
-static const char32 __uni_decomp_data_0xfdfb[] = { 0x62c, 0x644, 0x20, 0x62c, 0x644, 0x627, 0x644, 0x647, 0, };
-static const char32 __uni_decomp_data_0xfdfc[] = { 0x631, 0x6cc, 0x627, 0x644, 0, };
+static const char32 __uni_decomp_data_0xfd80[] = { 3, 0x644, 0x62d, 0x645, };
+static const char32 __uni_decomp_data_0xfd81[] = { 3, 0x644, 0x62d, 0x64a, };
+static const char32 __uni_decomp_data_0xfd82[] = { 3, 0x644, 0x62d, 0x649, };
+static const char32 __uni_decomp_data_0xfd83[] = { 3, 0x644, 0x62c, 0x62c, };
+static const char32 __uni_decomp_data_0xfd84[] = { 3, 0x644, 0x62c, 0x62c, };
+static const char32 __uni_decomp_data_0xfd85[] = { 3, 0x644, 0x62e, 0x645, };
+static const char32 __uni_decomp_data_0xfd86[] = { 3, 0x644, 0x62e, 0x645, };
+static const char32 __uni_decomp_data_0xfd87[] = { 3, 0x644, 0x645, 0x62d, };
+static const char32 __uni_decomp_data_0xfd88[] = { 3, 0x644, 0x645, 0x62d, };
+static const char32 __uni_decomp_data_0xfd89[] = { 3, 0x645, 0x62d, 0x62c, };
+static const char32 __uni_decomp_data_0xfd8a[] = { 3, 0x645, 0x62d, 0x645, };
+static const char32 __uni_decomp_data_0xfd8b[] = { 3, 0x645, 0x62d, 0x64a, };
+static const char32 __uni_decomp_data_0xfd8c[] = { 3, 0x645, 0x62c, 0x62d, };
+static const char32 __uni_decomp_data_0xfd8d[] = { 3, 0x645, 0x62c, 0x645, };
+static const char32 __uni_decomp_data_0xfd8e[] = { 3, 0x645, 0x62e, 0x62c, };
+static const char32 __uni_decomp_data_0xfd8f[] = { 3, 0x645, 0x62e, 0x645, };
+static const char32 __uni_decomp_data_0xfd92[] = { 3, 0x645, 0x62c, 0x62e, };
+static const char32 __uni_decomp_data_0xfd93[] = { 3, 0x647, 0x645, 0x62c, };
+static const char32 __uni_decomp_data_0xfd94[] = { 3, 0x647, 0x645, 0x645, };
+static const char32 __uni_decomp_data_0xfd95[] = { 3, 0x646, 0x62d, 0x645, };
+static const char32 __uni_decomp_data_0xfd96[] = { 3, 0x646, 0x62d, 0x649, };
+static const char32 __uni_decomp_data_0xfd97[] = { 3, 0x646, 0x62c, 0x645, };
+static const char32 __uni_decomp_data_0xfd98[] = { 3, 0x646, 0x62c, 0x645, };
+static const char32 __uni_decomp_data_0xfd99[] = { 3, 0x646, 0x62c, 0x649, };
+static const char32 __uni_decomp_data_0xfd9a[] = { 3, 0x646, 0x645, 0x64a, };
+static const char32 __uni_decomp_data_0xfd9b[] = { 3, 0x646, 0x645, 0x649, };
+static const char32 __uni_decomp_data_0xfd9c[] = { 3, 0x64a, 0x645, 0x645, };
+static const char32 __uni_decomp_data_0xfd9d[] = { 3, 0x64a, 0x645, 0x645, };
+static const char32 __uni_decomp_data_0xfd9e[] = { 3, 0x628, 0x62e, 0x64a, };
+static const char32 __uni_decomp_data_0xfd9f[] = { 3, 0x62a, 0x62c, 0x64a, };
+static const char32 __uni_decomp_data_0xfda0[] = { 3, 0x62a, 0x62c, 0x649, };
+static const char32 __uni_decomp_data_0xfda1[] = { 3, 0x62a, 0x62e, 0x64a, };
+static const char32 __uni_decomp_data_0xfda2[] = { 3, 0x62a, 0x62e, 0x649, };
+static const char32 __uni_decomp_data_0xfda3[] = { 3, 0x62a, 0x645, 0x64a, };
+static const char32 __uni_decomp_data_0xfda4[] = { 3, 0x62a, 0x645, 0x649, };
+static const char32 __uni_decomp_data_0xfda5[] = { 3, 0x62c, 0x645, 0x64a, };
+static const char32 __uni_decomp_data_0xfda6[] = { 3, 0x62c, 0x62d, 0x649, };
+static const char32 __uni_decomp_data_0xfda7[] = { 3, 0x62c, 0x645, 0x649, };
+static const char32 __uni_decomp_data_0xfda8[] = { 3, 0x633, 0x62e, 0x649, };
+static const char32 __uni_decomp_data_0xfda9[] = { 3, 0x635, 0x62d, 0x64a, };
+static const char32 __uni_decomp_data_0xfdaa[] = { 3, 0x634, 0x62d, 0x64a, };
+static const char32 __uni_decomp_data_0xfdab[] = { 3, 0x636, 0x62d, 0x64a, };
+static const char32 __uni_decomp_data_0xfdac[] = { 3, 0x644, 0x62c, 0x64a, };
+static const char32 __uni_decomp_data_0xfdad[] = { 3, 0x644, 0x645, 0x64a, };
+static const char32 __uni_decomp_data_0xfdae[] = { 3, 0x64a, 0x62d, 0x64a, };
+static const char32 __uni_decomp_data_0xfdaf[] = { 3, 0x64a, 0x62c, 0x64a, };
+static const char32 __uni_decomp_data_0xfdb0[] = { 3, 0x64a, 0x645, 0x64a, };
+static const char32 __uni_decomp_data_0xfdb1[] = { 3, 0x645, 0x645, 0x64a, };
+static const char32 __uni_decomp_data_0xfdb2[] = { 3, 0x642, 0x645, 0x64a, };
+static const char32 __uni_decomp_data_0xfdb3[] = { 3, 0x646, 0x62d, 0x64a, };
+static const char32 __uni_decomp_data_0xfdb4[] = { 3, 0x642, 0x645, 0x62d, };
+static const char32 __uni_decomp_data_0xfdb5[] = { 3, 0x644, 0x62d, 0x645, };
+static const char32 __uni_decomp_data_0xfdb6[] = { 3, 0x639, 0x645, 0x64a, };
+static const char32 __uni_decomp_data_0xfdb7[] = { 3, 0x643, 0x645, 0x64a, };
+static const char32 __uni_decomp_data_0xfdb8[] = { 3, 0x646, 0x62c, 0x62d, };
+static const char32 __uni_decomp_data_0xfdb9[] = { 3, 0x645, 0x62e, 0x64a, };
+static const char32 __uni_decomp_data_0xfdba[] = { 3, 0x644, 0x62c, 0x645, };
+static const char32 __uni_decomp_data_0xfdbb[] = { 3, 0x643, 0x645, 0x645, };
+static const char32 __uni_decomp_data_0xfdbc[] = { 3, 0x644, 0x62c, 0x645, };
+static const char32 __uni_decomp_data_0xfdbd[] = { 3, 0x646, 0x62c, 0x62d, };
+static const char32 __uni_decomp_data_0xfdbe[] = { 3, 0x62c, 0x62d, 0x64a, };
+static const char32 __uni_decomp_data_0xfdbf[] = { 3, 0x62d, 0x62c, 0x64a, };
+static const char32 __uni_decomp_data_0xfdc0[] = { 3, 0x645, 0x62c, 0x64a, };
+static const char32 __uni_decomp_data_0xfdc1[] = { 3, 0x641, 0x645, 0x64a, };
+static const char32 __uni_decomp_data_0xfdc2[] = { 3, 0x628, 0x62d, 0x64a, };
+static const char32 __uni_decomp_data_0xfdc3[] = { 3, 0x643, 0x645, 0x645, };
+static const char32 __uni_decomp_data_0xfdc4[] = { 3, 0x639, 0x62c, 0x645, };
+static const char32 __uni_decomp_data_0xfdc5[] = { 3, 0x635, 0x645, 0x645, };
+static const char32 __uni_decomp_data_0xfdc6[] = { 3, 0x633, 0x62e, 0x64a, };
+static const char32 __uni_decomp_data_0xfdc7[] = { 3, 0x646, 0x62c, 0x64a, };
+static const char32 __uni_decomp_data_0xfdf0[] = { 3, 0x635, 0x644, 0x6d2, };
+static const char32 __uni_decomp_data_0xfdf1[] = { 3, 0x642, 0x644, 0x6d2, };
+static const char32 __uni_decomp_data_0xfdf2[] = { 4, 0x627, 0x644, 0x644, 0x647, };
+static const char32 __uni_decomp_data_0xfdf3[] = { 4, 0x627, 0x643, 0x628, 0x631, };
+static const char32 __uni_decomp_data_0xfdf4[] = { 4, 0x645, 0x62d, 0x645, 0x62f, };
+static const char32 __uni_decomp_data_0xfdf5[] = { 4, 0x635, 0x644, 0x639, 0x645, };
+static const char32 __uni_decomp_data_0xfdf6[] = { 4, 0x631, 0x633, 0x648, 0x644, };
+static const char32 __uni_decomp_data_0xfdf7[] = { 4, 0x639, 0x644, 0x64a, 0x647, };
+static const char32 __uni_decomp_data_0xfdf8[] = { 4, 0x648, 0x633, 0x644, 0x645, };
+static const char32 __uni_decomp_data_0xfdf9[] = { 3, 0x635, 0x644, 0x649, };
+static const char32 __uni_decomp_data_0xfdfa[] = { 12, 0x635, 0x644, 0x649, 0x20, 0x627, 0x644, 0x644, 0x647, 0x20, 0x639, 0x644, 0x64a, 0x647, 0x20, 0x648, 0x633, 0x644, 0x645, };
+static const char32 __uni_decomp_data_0xfdfb[] = { 8, 0x62c, 0x644, 0x20, 0x62c, 0x644, 0x627, 0x644, 0x647, };
+static const char32 __uni_decomp_data_0xfdfc[] = { 4, 0x631, 0x6cc, 0x627, 0x644, };
 
 
 
@@ -5361,86 +5361,86 @@
 };
 
 
-static const char32 __uni_decomp_data_0xfe10[] = { 0x2c, 0, };
-static const char32 __uni_decomp_data_0xfe11[] = { 0x3001, 0, };
-static const char32 __uni_decomp_data_0xfe12[] = { 0x3002, 0, };
-static const char32 __uni_decomp_data_0xfe13[] = { 0x3a, 0, };
-static const char32 __uni_decomp_data_0xfe14[] = { 0x3b, 0, };
-static const char32 __uni_decomp_data_0xfe15[] = { 0x21, 0, };
-static const char32 __uni_decomp_data_0xfe16[] = { 0x3f, 0, };
-static const char32 __uni_decomp_data_0xfe17[] = { 0x3016, 0, };
-static const char32 __uni_decomp_data_0xfe18[] = { 0x3017, 0, };
-static const char32 __uni_decomp_data_0xfe19[] = { 0x2026, 0, };
-static const char32 __uni_decomp_data_0xfe30[] = { 0x2025, 0, };
-static const char32 __uni_decomp_data_0xfe31[] = { 0x2014, 0, };
-static const char32 __uni_decomp_data_0xfe32[] = { 0x2013, 0, };
-static const char32 __uni_decomp_data_0xfe33[] = { 0x5f, 0, };
-static const char32 __uni_decomp_data_0xfe34[] = { 0x5f, 0, };
-static const char32 __uni_decomp_data_0xfe35[] = { 0x28, 0, };
-static const char32 __uni_decomp_data_0xfe36[] = { 0x29, 0, };
-static const char32 __uni_decomp_data_0xfe37[] = { 0x7b, 0, };
-static const char32 __uni_decomp_data_0xfe38[] = { 0x7d, 0, };
-static const char32 __uni_decomp_data_0xfe39[] = { 0x3014, 0, };
-static const char32 __uni_decomp_data_0xfe3a[] = { 0x3015, 0, };
-static const char32 __uni_decomp_data_0xfe3b[] = { 0x3010, 0, };
-static const char32 __uni_decomp_data_0xfe3c[] = { 0x3011, 0, };
-static const char32 __uni_decomp_data_0xfe3d[] = { 0x300a, 0, };
-static const char32 __uni_decomp_data_0xfe3e[] = { 0x300b, 0, };
-static const char32 __uni_decomp_data_0xfe3f[] = { 0x3008, 0, };
-static const char32 __uni_decomp_data_0xfe40[] = { 0x3009, 0, };
-static const char32 __uni_decomp_data_0xfe41[] = { 0x300c, 0, };
-static const char32 __uni_decomp_data_0xfe42[] = { 0x300d, 0, };
-static const char32 __uni_decomp_data_0xfe43[] = { 0x300e, 0, };
-static const char32 __uni_decomp_data_0xfe44[] = { 0x300f, 0, };
-static const char32 __uni_decomp_data_0xfe47[] = { 0x5b, 0, };
-static const char32 __uni_decomp_data_0xfe48[] = { 0x5d, 0, };
-static const char32 __uni_decomp_data_0xfe49[] = { 0x203e, 0, };
-static const char32 __uni_decomp_data_0xfe4a[] = { 0x203e, 0, };
-static const char32 __uni_decomp_data_0xfe4b[] = { 0x203e, 0, };
-static const char32 __uni_decomp_data_0xfe4c[] = { 0x203e, 0, };
-static const char32 __uni_decomp_data_0xfe4d[] = { 0x5f, 0, };
-static const char32 __uni_decomp_data_0xfe4e[] = { 0x5f, 0, };
-static const char32 __uni_decomp_data_0xfe4f[] = { 0x5f, 0, };
-static const char32 __uni_decomp_data_0xfe50[] = { 0x2c, 0, };
-static const char32 __uni_decomp_data_0xfe51[] = { 0x3001, 0, };
-static const char32 __uni_decomp_data_0xfe52[] = { 0x2e, 0, };
-static const char32 __uni_decomp_data_0xfe54[] = { 0x3b, 0, };
-static const char32 __uni_decomp_data_0xfe55[] = { 0x3a, 0, };
-static const char32 __uni_decomp_data_0xfe56[] = { 0x3f, 0, };
-static const char32 __uni_decomp_data_0xfe57[] = { 0x21, 0, };
-static const char32 __uni_decomp_data_0xfe58[] = { 0x2014, 0, };
-static const char32 __uni_decomp_data_0xfe59[] = { 0x28, 0, };
-static const char32 __uni_decomp_data_0xfe5a[] = { 0x29, 0, };
-static const char32 __uni_decomp_data_0xfe5b[] = { 0x7b, 0, };
-static const char32 __uni_decomp_data_0xfe5c[] = { 0x7d, 0, };
-static const char32 __uni_decomp_data_0xfe5d[] = { 0x3014, 0, };
-static const char32 __uni_decomp_data_0xfe5e[] = { 0x3015, 0, };
-static const char32 __uni_decomp_data_0xfe5f[] = { 0x23, 0, };
-static const char32 __uni_decomp_data_0xfe60[] = { 0x26, 0, };
-static const char32 __uni_decomp_data_0xfe61[] = { 0x2a, 0, };
-static const char32 __uni_decomp_data_0xfe62[] = { 0x2b, 0, };
-static const char32 __uni_decomp_data_0xfe63[] = { 0x2d, 0, };
-static const char32 __uni_decomp_data_0xfe64[] = { 0x3c, 0, };
-static const char32 __uni_decomp_data_0xfe65[] = { 0x3e, 0, };
-static const char32 __uni_decomp_data_0xfe66[] = { 0x3d, 0, };
-static const char32 __uni_decomp_data_0xfe68[] = { 0x5c, 0, };
-static const char32 __uni_decomp_data_0xfe69[] = { 0x24, 0, };
-static const char32 __uni_decomp_data_0xfe6a[] = { 0x25, 0, };
-static const char32 __uni_decomp_data_0xfe6b[] = { 0x40, 0, };
-static const char32 __uni_decomp_data_0xfe70[] = { 0x20, 0x64b, 0, };
-static const char32 __uni_decomp_data_0xfe71[] = { 0x640, 0x64b, 0, };
-static const char32 __uni_decomp_data_0xfe72[] = { 0x20, 0x64c, 0, };
-static const char32 __uni_decomp_data_0xfe74[] = { 0x20, 0x64d, 0, };
-static const char32 __uni_decomp_data_0xfe76[] = { 0x20, 0x64e, 0, };
-static const char32 __uni_decomp_data_0xfe77[] = { 0x640, 0x64e, 0, };
-static const char32 __uni_decomp_data_0xfe78[] = { 0x20, 0x64f, 0, };
-static const char32 __uni_decomp_data_0xfe79[] = { 0x640, 0x64f, 0, };
-static const char32 __uni_decomp_data_0xfe7a[] = { 0x20, 0x650, 0, };
-static const char32 __uni_decomp_data_0xfe7b[] = { 0x640, 0x650, 0, };
-static const char32 __uni_decomp_data_0xfe7c[] = { 0x20, 0x651, 0, };
-static const char32 __uni_decomp_data_0xfe7d[] = { 0x640, 0x651, 0, };
-static const char32 __uni_decomp_data_0xfe7e[] = { 0x20, 0x652, 0, };
-static const char32 __uni_decomp_data_0xfe7f[] = { 0x640, 0x652, 0, };
+static const char32 __uni_decomp_data_0xfe10[] = { 1, 0x2c, };
+static const char32 __uni_decomp_data_0xfe11[] = { 1, 0x3001, };
+static const char32 __uni_decomp_data_0xfe12[] = { 1, 0x3002, };
+static const char32 __uni_decomp_data_0xfe13[] = { 1, 0x3a, };
+static const char32 __uni_decomp_data_0xfe14[] = { 1, 0x3b, };
+static const char32 __uni_decomp_data_0xfe15[] = { 1, 0x21, };
+static const char32 __uni_decomp_data_0xfe16[] = { 1, 0x3f, };
+static const char32 __uni_decomp_data_0xfe17[] = { 1, 0x3016, };
+static const char32 __uni_decomp_data_0xfe18[] = { 1, 0x3017, };
+static const char32 __uni_decomp_data_0xfe19[] = { 1, 0x2026, };
+static const char32 __uni_decomp_data_0xfe30[] = { 1, 0x2025, };
+static const char32 __uni_decomp_data_0xfe31[] = { 1, 0x2014, };
+static const char32 __uni_decomp_data_0xfe32[] = { 1, 0x2013, };
+static const char32 __uni_decomp_data_0xfe33[] = { 1, 0x5f, };
+static const char32 __uni_decomp_data_0xfe34[] = { 1, 0x5f, };
+static const char32 __uni_decomp_data_0xfe35[] = { 1, 0x28, };
+static const char32 __uni_decomp_data_0xfe36[] = { 1, 0x29, };
+static const char32 __uni_decomp_data_0xfe37[] = { 1, 0x7b, };
+static const char32 __uni_decomp_data_0xfe38[] = { 1, 0x7d, };
+static const char32 __uni_decomp_data_0xfe39[] = { 1, 0x3014, };
+static const char32 __uni_decomp_data_0xfe3a[] = { 1, 0x3015, };
+static const char32 __uni_decomp_data_0xfe3b[] = { 1, 0x3010, };
+static const char32 __uni_decomp_data_0xfe3c[] = { 1, 0x3011, };
+static const char32 __uni_decomp_data_0xfe3d[] = { 1, 0x300a, };
+static const char32 __uni_decomp_data_0xfe3e[] = { 1, 0x300b, };
+static const char32 __uni_decomp_data_0xfe3f[] = { 1, 0x3008, };
+static const char32 __uni_decomp_data_0xfe40[] = { 1, 0x3009, };
+static const char32 __uni_decomp_data_0xfe41[] = { 1, 0x300c, };
+static const char32 __uni_decomp_data_0xfe42[] = { 1, 0x300d, };
+static const char32 __uni_decomp_data_0xfe43[] = { 1, 0x300e, };
+static const char32 __uni_decomp_data_0xfe44[] = { 1, 0x300f, };
+static const char32 __uni_decomp_data_0xfe47[] = { 1, 0x5b, };
+static const char32 __uni_decomp_data_0xfe48[] = { 1, 0x5d, };
+static const char32 __uni_decomp_data_0xfe49[] = { 1, 0x203e, };
+static const char32 __uni_decomp_data_0xfe4a[] = { 1, 0x203e, };
+static const char32 __uni_decomp_data_0xfe4b[] = { 1, 0x203e, };
+static const char32 __uni_decomp_data_0xfe4c[] = { 1, 0x203e, };
+static const char32 __uni_decomp_data_0xfe4d[] = { 1, 0x5f, };
+static const char32 __uni_decomp_data_0xfe4e[] = { 1, 0x5f, };
+static const char32 __uni_decomp_data_0xfe4f[] = { 1, 0x5f, };
+static const char32 __uni_decomp_data_0xfe50[] = { 1, 0x2c, };
+static const char32 __uni_decomp_data_0xfe51[] = { 1, 0x3001, };
+static const char32 __uni_decomp_data_0xfe52[] = { 1, 0x2e, };
+static const char32 __uni_decomp_data_0xfe54[] = { 1, 0x3b, };
+static const char32 __uni_decomp_data_0xfe55[] = { 1, 0x3a, };
+static const char32 __uni_decomp_data_0xfe56[] = { 1, 0x3f, };
+static const char32 __uni_decomp_data_0xfe57[] = { 1, 0x21, };
+static const char32 __uni_decomp_data_0xfe58[] = { 1, 0x2014, };
+static const char32 __uni_decomp_data_0xfe59[] = { 1, 0x28, };
+static const char32 __uni_decomp_data_0xfe5a[] = { 1, 0x29, };
+static const char32 __uni_decomp_data_0xfe5b[] = { 1, 0x7b, };
+static const char32 __uni_decomp_data_0xfe5c[] = { 1, 0x7d, };
+static const char32 __uni_decomp_data_0xfe5d[] = { 1, 0x3014, };
+static const char32 __uni_decomp_data_0xfe5e[] = { 1, 0x3015, };
+static const char32 __uni_decomp_data_0xfe5f[] = { 1, 0x23, };
+static const char32 __uni_decomp_data_0xfe60[] = { 1, 0x26, };
+static const char32 __uni_decomp_data_0xfe61[] = { 1, 0x2a, };
+static const char32 __uni_decomp_data_0xfe62[] = { 1, 0x2b, };
+static const char32 __uni_decomp_data_0xfe63[] = { 1, 0x2d, };
+static const char32 __uni_decomp_data_0xfe64[] = { 1, 0x3c, };
+static const char32 __uni_decomp_data_0xfe65[] = { 1, 0x3e, };
+static const char32 __uni_decomp_data_0xfe66[] = { 1, 0x3d, };
+static const char32 __uni_decomp_data_0xfe68[] = { 1, 0x5c, };
+static const char32 __uni_decomp_data_0xfe69[] = { 1, 0x24, };
+static const char32 __uni_decomp_data_0xfe6a[] = { 1, 0x25, };
+static const char32 __uni_decomp_data_0xfe6b[] = { 1, 0x40, };
+static const char32 __uni_decomp_data_0xfe70[] = { 2, 0x20, 0x64b, };
+static const char32 __uni_decomp_data_0xfe71[] = { 2, 0x640, 0x64b, };
+static const char32 __uni_decomp_data_0xfe72[] = { 2, 0x20, 0x64c, };
+static const char32 __uni_decomp_data_0xfe74[] = { 2, 0x20, 0x64d, };
+static const char32 __uni_decomp_data_0xfe76[] = { 2, 0x20, 0x64e, };
+static const char32 __uni_decomp_data_0xfe77[] = { 2, 0x640, 0x64e, };
+static const char32 __uni_decomp_data_0xfe78[] = { 2, 0x20, 0x64f, };
+static const char32 __uni_decomp_data_0xfe79[] = { 2, 0x640, 0x64f, };
+static const char32 __uni_decomp_data_0xfe7a[] = { 2, 0x20, 0x650, };
+static const char32 __uni_decomp_data_0xfe7b[] = { 2, 0x640, 0x650, };
+static const char32 __uni_decomp_data_0xfe7c[] = { 2, 0x20, 0x651, };
+static const char32 __uni_decomp_data_0xfe7d[] = { 2, 0x640, 0x651, };
+static const char32 __uni_decomp_data_0xfe7e[] = { 2, 0x20, 0x652, };
+static const char32 __uni_decomp_data_0xfe7f[] = { 2, 0x640, 0x652, };
 
 
 
@@ -7114,131 +7114,131 @@
 };
 
 
-static const char32 __uni_decomp_data_0xfe80[] = { 0x621, 0, };
-static const char32 __uni_decomp_data_0xfe81[] = { 0x622, 0, };
-static const char32 __uni_decomp_data_0xfe82[] = { 0x622, 0, };
-static const char32 __uni_decomp_data_0xfe83[] = { 0x623, 0, };
-static const char32 __uni_decomp_data_0xfe84[] = { 0x623, 0, };
-static const char32 __uni_decomp_data_0xfe85[] = { 0x624, 0, };
-static const char32 __uni_decomp_data_0xfe86[] = { 0x624, 0, };
-static const char32 __uni_decomp_data_0xfe87[] = { 0x625, 0, };
-static const char32 __uni_decomp_data_0xfe88[] = { 0x625, 0, };
-static const char32 __uni_decomp_data_0xfe89[] = { 0x626, 0, };
-static const char32 __uni_decomp_data_0xfe8a[] = { 0x626, 0, };
-static const char32 __uni_decomp_data_0xfe8b[] = { 0x626, 0, };
-static const char32 __uni_decomp_data_0xfe8c[] = { 0x626, 0, };
-static const char32 __uni_decomp_data_0xfe8d[] = { 0x627, 0, };
-static const char32 __uni_decomp_data_0xfe8e[] = { 0x627, 0, };
-static const char32 __uni_decomp_data_0xfe8f[] = { 0x628, 0, };
-static const char32 __uni_decomp_data_0xfe90[] = { 0x628, 0, };
-static const char32 __uni_decomp_data_0xfe91[] = { 0x628, 0, };
-static const char32 __uni_decomp_data_0xfe92[] = { 0x628, 0, };
-static const char32 __uni_decomp_data_0xfe93[] = { 0x629, 0, };
-static const char32 __uni_decomp_data_0xfe94[] = { 0x629, 0, };
-static const char32 __uni_decomp_data_0xfe95[] = { 0x62a, 0, };
-static const char32 __uni_decomp_data_0xfe96[] = { 0x62a, 0, };
-static const char32 __uni_decomp_data_0xfe97[] = { 0x62a, 0, };
-static const char32 __uni_decomp_data_0xfe98[] = { 0x62a, 0, };
-static const char32 __uni_decomp_data_0xfe99[] = { 0x62b, 0, };
-static const char32 __uni_decomp_data_0xfe9a[] = { 0x62b, 0, };
-static const char32 __uni_decomp_data_0xfe9b[] = { 0x62b, 0, };
-static const char32 __uni_decomp_data_0xfe9c[] = { 0x62b, 0, };
-static const char32 __uni_decomp_data_0xfe9d[] = { 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfe9e[] = { 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfe9f[] = { 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfea0[] = { 0x62c, 0, };
-static const char32 __uni_decomp_data_0xfea1[] = { 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfea2[] = { 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfea3[] = { 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfea4[] = { 0x62d, 0, };
-static const char32 __uni_decomp_data_0xfea5[] = { 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfea6[] = { 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfea7[] = { 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfea8[] = { 0x62e, 0, };
-static const char32 __uni_decomp_data_0xfea9[] = { 0x62f, 0, };
-static const char32 __uni_decomp_data_0xfeaa[] = { 0x62f, 0, };
-static const char32 __uni_decomp_data_0xfeab[] = { 0x630, 0, };
-static const char32 __uni_decomp_data_0xfeac[] = { 0x630, 0, };
-static const char32 __uni_decomp_data_0xfead[] = { 0x631, 0, };
-static const char32 __uni_decomp_data_0xfeae[] = { 0x631, 0, };
-static const char32 __uni_decomp_data_0xfeaf[] = { 0x632, 0, };
-static const char32 __uni_decomp_data_0xfeb0[] = { 0x632, 0, };
-static const char32 __uni_decomp_data_0xfeb1[] = { 0x633, 0, };
-static const char32 __uni_decomp_data_0xfeb2[] = { 0x633, 0, };
-static const char32 __uni_decomp_data_0xfeb3[] = { 0x633, 0, };
-static const char32 __uni_decomp_data_0xfeb4[] = { 0x633, 0, };
-static const char32 __uni_decomp_data_0xfeb5[] = { 0x634, 0, };
-static const char32 __uni_decomp_data_0xfeb6[] = { 0x634, 0, };
-static const char32 __uni_decomp_data_0xfeb7[] = { 0x634, 0, };
-static const char32 __uni_decomp_data_0xfeb8[] = { 0x634, 0, };
-static const char32 __uni_decomp_data_0xfeb9[] = { 0x635, 0, };
-static const char32 __uni_decomp_data_0xfeba[] = { 0x635, 0, };
-static const char32 __uni_decomp_data_0xfebb[] = { 0x635, 0, };
-static const char32 __uni_decomp_data_0xfebc[] = { 0x635, 0, };
-static const char32 __uni_decomp_data_0xfebd[] = { 0x636, 0, };
-static const char32 __uni_decomp_data_0xfebe[] = { 0x636, 0, };
-static const char32 __uni_decomp_data_0xfebf[] = { 0x636, 0, };
-static const char32 __uni_decomp_data_0xfec0[] = { 0x636, 0, };
-static const char32 __uni_decomp_data_0xfec1[] = { 0x637, 0, };
-static const char32 __uni_decomp_data_0xfec2[] = { 0x637, 0, };
-static const char32 __uni_decomp_data_0xfec3[] = { 0x637, 0, };
-static const char32 __uni_decomp_data_0xfec4[] = { 0x637, 0, };
-static const char32 __uni_decomp_data_0xfec5[] = { 0x638, 0, };
-static const char32 __uni_decomp_data_0xfec6[] = { 0x638, 0, };
-static const char32 __uni_decomp_data_0xfec7[] = { 0x638, 0, };
-static const char32 __uni_decomp_data_0xfec8[] = { 0x638, 0, };
-static const char32 __uni_decomp_data_0xfec9[] = { 0x639, 0, };
-static const char32 __uni_decomp_data_0xfeca[] = { 0x639, 0, };
-static const char32 __uni_decomp_data_0xfecb[] = { 0x639, 0, };
-static const char32 __uni_decomp_data_0xfecc[] = { 0x639, 0, };
-static const char32 __uni_decomp_data_0xfecd[] = { 0x63a, 0, };
-static const char32 __uni_decomp_data_0xfece[] = { 0x63a, 0, };
-static const char32 __uni_decomp_data_0xfecf[] = { 0x63a, 0, };
-static const char32 __uni_decomp_data_0xfed0[] = { 0x63a, 0, };
-static const char32 __uni_decomp_data_0xfed1[] = { 0x641, 0, };
-static const char32 __uni_decomp_data_0xfed2[] = { 0x641, 0, };
-static const char32 __uni_decomp_data_0xfed3[] = { 0x641, 0, };
-static const char32 __uni_decomp_data_0xfed4[] = { 0x641, 0, };
-static const char32 __uni_decomp_data_0xfed5[] = { 0x642, 0, };
-static const char32 __uni_decomp_data_0xfed6[] = { 0x642, 0, };
-static const char32 __uni_decomp_data_0xfed7[] = { 0x642, 0, };
-static const char32 __uni_decomp_data_0xfed8[] = { 0x642, 0, };
-static const char32 __uni_decomp_data_0xfed9[] = { 0x643, 0, };
-static const char32 __uni_decomp_data_0xfeda[] = { 0x643, 0, };
-static const char32 __uni_decomp_data_0xfedb[] = { 0x643, 0, };
-static const char32 __uni_decomp_data_0xfedc[] = { 0x643, 0, };
-static const char32 __uni_decomp_data_0xfedd[] = { 0x644, 0, };
-static const char32 __uni_decomp_data_0xfede[] = { 0x644, 0, };
-static const char32 __uni_decomp_data_0xfedf[] = { 0x644, 0, };
-static const char32 __uni_decomp_data_0xfee0[] = { 0x644, 0, };
-static const char32 __uni_decomp_data_0xfee1[] = { 0x645, 0, };
-static const char32 __uni_decomp_data_0xfee2[] = { 0x645, 0, };
-static const char32 __uni_decomp_data_0xfee3[] = { 0x645, 0, };
-static const char32 __uni_decomp_data_0xfee4[] = { 0x645, 0, };
-static const char32 __uni_decomp_data_0xfee5[] = { 0x646, 0, };
-static const char32 __uni_decomp_data_0xfee6[] = { 0x646, 0, };
-static const char32 __uni_decomp_data_0xfee7[] = { 0x646, 0, };
-static const char32 __uni_decomp_data_0xfee8[] = { 0x646, 0, };
-static const char32 __uni_decomp_data_0xfee9[] = { 0x647, 0, };
-static const char32 __uni_decomp_data_0xfeea[] = { 0x647, 0, };
-static const char32 __uni_decomp_data_0xfeeb[] = { 0x647, 0, };
-static const char32 __uni_decomp_data_0xfeec[] = { 0x647, 0, };
-static const char32 __uni_decomp_data_0xfeed[] = { 0x648, 0, };
-static const char32 __uni_decomp_data_0xfeee[] = { 0x648, 0, };
-static const char32 __uni_decomp_data_0xfeef[] = { 0x649, 0, };
-static const char32 __uni_decomp_data_0xfef0[] = { 0x649, 0, };
-static const char32 __uni_decomp_data_0xfef1[] = { 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfef2[] = { 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfef3[] = { 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfef4[] = { 0x64a, 0, };
-static const char32 __uni_decomp_data_0xfef5[] = { 0x644, 0x622, 0, };
-static const char32 __uni_decomp_data_0xfef6[] = { 0x644, 0x622, 0, };
-static const char32 __uni_decomp_data_0xfef7[] = { 0x644, 0x623, 0, };
-static const char32 __uni_decomp_data_0xfef8[] = { 0x644, 0x623, 0, };
-static const char32 __uni_decomp_data_0xfef9[] = { 0x644, 0x625, 0, };
-static const char32 __uni_decomp_data_0xfefa[] = { 0x644, 0x625, 0, };
-static const char32 __uni_decomp_data_0xfefb[] = { 0x644, 0x627, 0, };
-static const char32 __uni_decomp_data_0xfefc[] = { 0x644, 0x627, 0, };
+static const char32 __uni_decomp_data_0xfe80[] = { 1, 0x621, };
+static const char32 __uni_decomp_data_0xfe81[] = { 1, 0x622, };
+static const char32 __uni_decomp_data_0xfe82[] = { 1, 0x622, };
+static const char32 __uni_decomp_data_0xfe83[] = { 1, 0x623, };
+static const char32 __uni_decomp_data_0xfe84[] = { 1, 0x623, };
+static const char32 __uni_decomp_data_0xfe85[] = { 1, 0x624, };
+static const char32 __uni_decomp_data_0xfe86[] = { 1, 0x624, };
+static const char32 __uni_decomp_data_0xfe87[] = { 1, 0x625, };
+static const char32 __uni_decomp_data_0xfe88[] = { 1, 0x625, };
+static const char32 __uni_decomp_data_0xfe89[] = { 1, 0x626, };
+static const char32 __uni_decomp_data_0xfe8a[] = { 1, 0x626, };
+static const char32 __uni_decomp_data_0xfe8b[] = { 1, 0x626, };
+static const char32 __uni_decomp_data_0xfe8c[] = { 1, 0x626, };
+static const char32 __uni_decomp_data_0xfe8d[] = { 1, 0x627, };
+static const char32 __uni_decomp_data_0xfe8e[] = { 1, 0x627, };
+static const char32 __uni_decomp_data_0xfe8f[] = { 1, 0x628, };
+static const char32 __uni_decomp_data_0xfe90[] = { 1, 0x628, };
+static const char32 __uni_decomp_data_0xfe91[] = { 1, 0x628, };
+static const char32 __uni_decomp_data_0xfe92[] = { 1, 0x628, };
+static const char32 __uni_decomp_data_0xfe93[] = { 1, 0x629, };
+static const char32 __uni_decomp_data_0xfe94[] = { 1, 0x629, };
+static const char32 __uni_decomp_data_0xfe95[] = { 1, 0x62a, };
+static const char32 __uni_decomp_data_0xfe96[] = { 1, 0x62a, };
+static const char32 __uni_decomp_data_0xfe97[] = { 1, 0x62a, };
+static const char32 __uni_decomp_data_0xfe98[] = { 1, 0x62a, };
+static const char32 __uni_decomp_data_0xfe99[] = { 1, 0x62b, };
+static const char32 __uni_decomp_data_0xfe9a[] = { 1, 0x62b, };
+static const char32 __uni_decomp_data_0xfe9b[] = { 1, 0x62b, };
+static const char32 __uni_decomp_data_0xfe9c[] = { 1, 0x62b, };
+static const char32 __uni_decomp_data_0xfe9d[] = { 1, 0x62c, };
+static const char32 __uni_decomp_data_0xfe9e[] = { 1, 0x62c, };
+static const char32 __uni_decomp_data_0xfe9f[] = { 1, 0x62c, };
+static const char32 __uni_decomp_data_0xfea0[] = { 1, 0x62c, };
+static const char32 __uni_decomp_data_0xfea1[] = { 1, 0x62d, };
+static const char32 __uni_decomp_data_0xfea2[] = { 1, 0x62d, };
+static const char32 __uni_decomp_data_0xfea3[] = { 1, 0x62d, };
+static const char32 __uni_decomp_data_0xfea4[] = { 1, 0x62d, };
+static const char32 __uni_decomp_data_0xfea5[] = { 1, 0x62e, };
+static const char32 __uni_decomp_data_0xfea6[] = { 1, 0x62e, };
+static const char32 __uni_decomp_data_0xfea7[] = { 1, 0x62e, };
+static const char32 __uni_decomp_data_0xfea8[] = { 1, 0x62e, };
+static const char32 __uni_decomp_data_0xfea9[] = { 1, 0x62f, };
+static const char32 __uni_decomp_data_0xfeaa[] = { 1, 0x62f, };
+static const char32 __uni_decomp_data_0xfeab[] = { 1, 0x630, };
+static const char32 __uni_decomp_data_0xfeac[] = { 1, 0x630, };
+static const char32 __uni_decomp_data_0xfead[] = { 1, 0x631, };
+static const char32 __uni_decomp_data_0xfeae[] = { 1, 0x631, };
+static const char32 __uni_decomp_data_0xfeaf[] = { 1, 0x632, };
+static const char32 __uni_decomp_data_0xfeb0[] = { 1, 0x632, };
+static const char32 __uni_decomp_data_0xfeb1[] = { 1, 0x633, };
+static const char32 __uni_decomp_data_0xfeb2[] = { 1, 0x633, };
+static const char32 __uni_decomp_data_0xfeb3[] = { 1, 0x633, };
+static const char32 __uni_decomp_data_0xfeb4[] = { 1, 0x633, };
+static const char32 __uni_decomp_data_0xfeb5[] = { 1, 0x634, };
+static const char32 __uni_decomp_data_0xfeb6[] = { 1, 0x634, };
+static const char32 __uni_decomp_data_0xfeb7[] = { 1, 0x634, };
+static const char32 __uni_decomp_data_0xfeb8[] = { 1, 0x634, };
+static const char32 __uni_decomp_data_0xfeb9[] = { 1, 0x635, };
+static const char32 __uni_decomp_data_0xfeba[] = { 1, 0x635, };
+static const char32 __uni_decomp_data_0xfebb[] = { 1, 0x635, };
+static const char32 __uni_decomp_data_0xfebc[] = { 1, 0x635, };
+static const char32 __uni_decomp_data_0xfebd[] = { 1, 0x636, };
+static const char32 __uni_decomp_data_0xfebe[] = { 1, 0x636, };
+static const char32 __uni_decomp_data_0xfebf[] = { 1, 0x636, };
+static const char32 __uni_decomp_data_0xfec0[] = { 1, 0x636, };
+static const char32 __uni_decomp_data_0xfec1[] = { 1, 0x637, };
+static const char32 __uni_decomp_data_0xfec2[] = { 1, 0x637, };
+static const char32 __uni_decomp_data_0xfec3[] = { 1, 0x637, };
+static const char32 __uni_decomp_data_0xfec4[] = { 1, 0x637, };
+static const char32 __uni_decomp_data_0xfec5[] = { 1, 0x638, };
+static const char32 __uni_decomp_data_0xfec6[] = { 1, 0x638, };
+static const char32 __uni_decomp_data_0xfec7[] = { 1, 0x638, };
+static const char32 __uni_decomp_data_0xfec8[] = { 1, 0x638, };
+static const char32 __uni_decomp_data_0xfec9[] = { 1, 0x639, };
+static const char32 __uni_decomp_data_0xfeca[] = { 1, 0x639, };
+static const char32 __uni_decomp_data_0xfecb[] = { 1, 0x639, };
+static const char32 __uni_decomp_data_0xfecc[] = { 1, 0x639, };
+static const char32 __uni_decomp_data_0xfecd[] = { 1, 0x63a, };
+static const char32 __uni_decomp_data_0xfece[] = { 1, 0x63a, };
+static const char32 __uni_decomp_data_0xfecf[] = { 1, 0x63a, };
+static const char32 __uni_decomp_data_0xfed0[] = { 1, 0x63a, };
+static const char32 __uni_decomp_data_0xfed1[] = { 1, 0x641, };
+static const char32 __uni_decomp_data_0xfed2[] = { 1, 0x641, };
+static const char32 __uni_decomp_data_0xfed3[] = { 1, 0x641, };
+static const char32 __uni_decomp_data_0xfed4[] = { 1, 0x641, };
+static const char32 __uni_decomp_data_0xfed5[] = { 1, 0x642, };
+static const char32 __uni_decomp_data_0xfed6[] = { 1, 0x642, };
+static const char32 __uni_decomp_data_0xfed7[] = { 1, 0x642, };
+static const char32 __uni_decomp_data_0xfed8[] = { 1, 0x642, };
+static const char32 __uni_decomp_data_0xfed9[] = { 1, 0x643, };
+static const char32 __uni_decomp_data_0xfeda[] = { 1, 0x643, };
+static const char32 __uni_decomp_data_0xfedb[] = { 1, 0x643, };
+static const char32 __uni_decomp_data_0xfedc[] = { 1, 0x643, };
+static const char32 __uni_decomp_data_0xfedd[] = { 1, 0x644, };
+static const char32 __uni_decomp_data_0xfede[] = { 1, 0x644, };
+static const char32 __uni_decomp_data_0xfedf[] = { 1, 0x644, };
+static const char32 __uni_decomp_data_0xfee0[] = { 1, 0x644, };
+static const char32 __uni_decomp_data_0xfee1[] = { 1, 0x645, };
+static const char32 __uni_decomp_data_0xfee2[] = { 1, 0x645, };
+static const char32 __uni_decomp_data_0xfee3[] = { 1, 0x645, };
+static const char32 __uni_decomp_data_0xfee4[] = { 1, 0x645, };
+static const char32 __uni_decomp_data_0xfee5[] = { 1, 0x646, };
+static const char32 __uni_decomp_data_0xfee6[] = { 1, 0x646, };
+static const char32 __uni_decomp_data_0xfee7[] = { 1, 0x646, };
+static const char32 __uni_decomp_data_0xfee8[] = { 1, 0x646, };
+static const char32 __uni_decomp_data_0xfee9[] = { 1, 0x647, };
+static const char32 __uni_decomp_data_0xfeea[] = { 1, 0x647, };
+static const char32 __uni_decomp_data_0xfeeb[] = { 1, 0x647, };
+static const char32 __uni_decomp_data_0xfeec[] = { 1, 0x647, };
+static const char32 __uni_decomp_data_0xfeed[] = { 1, 0x648, };
+static const char32 __uni_decomp_data_0xfeee[] = { 1, 0x648, };
+static const char32 __uni_decomp_data_0xfeef[] = { 1, 0x649, };
+static const char32 __uni_decomp_data_0xfef0[] = { 1, 0x649, };
+static const char32 __uni_decomp_data_0xfef1[] = { 1, 0x64a, };
+static const char32 __uni_decomp_data_0xfef2[] = { 1, 0x64a, };
+static const char32 __uni_decomp_data_0xfef3[] = { 1, 0x64a, };
+static const char32 __uni_decomp_data_0xfef4[] = { 1, 0x64a, };
+static const char32 __uni_decomp_data_0xfef5[] = { 2, 0x644, 0x622, };
+static const char32 __uni_decomp_data_0xfef6[] = { 2, 0x644, 0x622, };
+static const char32 __uni_decomp_data_0xfef7[] = { 2, 0x644, 0x623, };
+static const char32 __uni_decomp_data_0xfef8[] = { 2, 0x644, 0x623, };
+static const char32 __uni_decomp_data_0xfef9[] = { 2, 0x644, 0x625, };
+static const char32 __uni_decomp_data_0xfefa[] = { 2, 0x644, 0x625, };
+static const char32 __uni_decomp_data_0xfefb[] = { 2, 0x644, 0x627, };
+static const char32 __uni_decomp_data_0xfefc[] = { 2, 0x644, 0x627, };
 
 
 
@@ -8912,133 +8912,133 @@
 };
 
 
-static const char32 __uni_decomp_data_0xff01[] = { 0x21, 0, };
-static const char32 __uni_decomp_data_0xff02[] = { 0x22, 0, };
-static const char32 __uni_decomp_data_0xff03[] = { 0x23, 0, };
-static const char32 __uni_decomp_data_0xff04[] = { 0x24, 0, };
-static const char32 __uni_decomp_data_0xff05[] = { 0x25, 0, };
-static const char32 __uni_decomp_data_0xff06[] = { 0x26, 0, };
-static const char32 __uni_decomp_data_0xff07[] = { 0x27, 0, };
-static const char32 __uni_decomp_data_0xff08[] = { 0x28, 0, };
-static const char32 __uni_decomp_data_0xff09[] = { 0x29, 0, };
-static const char32 __uni_decomp_data_0xff0a[] = { 0x2a, 0, };
-static const char32 __uni_decomp_data_0xff0b[] = { 0x2b, 0, };
-static const char32 __uni_decomp_data_0xff0c[] = { 0x2c, 0, };
-static const char32 __uni_decomp_data_0xff0d[] = { 0x2d, 0, };
-static const char32 __uni_decomp_data_0xff0e[] = { 0x2e, 0, };
-static const char32 __uni_decomp_data_0xff0f[] = { 0x2f, 0, };
-static const char32 __uni_decomp_data_0xff10[] = { 0x30, 0, };
-static const char32 __uni_decomp_data_0xff11[] = { 0x31, 0, };
-static const char32 __uni_decomp_data_0xff12[] = { 0x32, 0, };
-static const char32 __uni_decomp_data_0xff13[] = { 0x33, 0, };
-static const char32 __uni_decomp_data_0xff14[] = { 0x34, 0, };
-static const char32 __uni_decomp_data_0xff15[] = { 0x35, 0, };
-static const char32 __uni_decomp_data_0xff16[] = { 0x36, 0, };
-static const char32 __uni_decomp_data_0xff17[] = { 0x37, 0, };
-static const char32 __uni_decomp_data_0xff18[] = { 0x38, 0, };
-static const char32 __uni_decomp_data_0xff19[] = { 0x39, 0, };
-static const char32 __uni_decomp_data_0xff1a[] = { 0x3a, 0, };
-static const char32 __uni_decomp_data_0xff1b[] = { 0x3b, 0, };
-static const char32 __uni_decomp_data_0xff1c[] = { 0x3c, 0, };
-static const char32 __uni_decomp_data_0xff1d[] = { 0x3d, 0, };
-static const char32 __uni_decomp_data_0xff1e[] = { 0x3e, 0, };
-static const char32 __uni_decomp_data_0xff1f[] = { 0x3f, 0, };
-static const char32 __uni_decomp_data_0xff20[] = { 0x40, 0, };
-static const char32 __uni_decomp_data_0xff21[] = { 0x41, 0, };
-static const char32 __uni_decomp_data_0xff22[] = { 0x42, 0, };
-static const char32 __uni_decomp_data_0xff23[] = { 0x43, 0, };
-static const char32 __uni_decomp_data_0xff24[] = { 0x44, 0, };
-static const char32 __uni_decomp_data_0xff25[] = { 0x45, 0, };
-static const char32 __uni_decomp_data_0xff26[] = { 0x46, 0, };
-static const char32 __uni_decomp_data_0xff27[] = { 0x47, 0, };
-static const char32 __uni_decomp_data_0xff28[] = { 0x48, 0, };
-static const char32 __uni_decomp_data_0xff29[] = { 0x49, 0, };
-static const char32 __uni_decomp_data_0xff2a[] = { 0x4a, 0, };
-static const char32 __uni_decomp_data_0xff2b[] = { 0x4b, 0, };
-static const char32 __uni_decomp_data_0xff2c[] = { 0x4c, 0, };
-static const char32 __uni_decomp_data_0xff2d[] = { 0x4d, 0, };
-static const char32 __uni_decomp_data_0xff2e[] = { 0x4e, 0, };
-static const char32 __uni_decomp_data_0xff2f[] = { 0x4f, 0, };
-static const char32 __uni_decomp_data_0xff30[] = { 0x50, 0, };
-static const char32 __uni_decomp_data_0xff31[] = { 0x51, 0, };
-static const char32 __uni_decomp_data_0xff32[] = { 0x52, 0, };
-static const char32 __uni_decomp_data_0xff33[] = { 0x53, 0, };
-static const char32 __uni_decomp_data_0xff34[] = { 0x54, 0, };
-static const char32 __uni_decomp_data_0xff35[] = { 0x55, 0, };
-static const char32 __uni_decomp_data_0xff36[] = { 0x56, 0, };
-static const char32 __uni_decomp_data_0xff37[] = { 0x57, 0, };
-static const char32 __uni_decomp_data_0xff38[] = { 0x58, 0, };
-static const char32 __uni_decomp_data_0xff39[] = { 0x59, 0, };
-static const char32 __uni_decomp_data_0xff3a[] = { 0x5a, 0, };
-static const char32 __uni_decomp_data_0xff3b[] = { 0x5b, 0, };
-static const char32 __uni_decomp_data_0xff3c[] = { 0x5c, 0, };
-static const char32 __uni_decomp_data_0xff3d[] = { 0x5d, 0, };
-static const char32 __uni_decomp_data_0xff3e[] = { 0x5e, 0, };
-static const char32 __uni_decomp_data_0xff3f[] = { 0x5f, 0, };
-static const char32 __uni_decomp_data_0xff40[] = { 0x60, 0, };
-static const char32 __uni_decomp_data_0xff41[] = { 0x61, 0, };
-static const char32 __uni_decomp_data_0xff42[] = { 0x62, 0, };
-static const char32 __uni_decomp_data_0xff43[] = { 0x63, 0, };
-static const char32 __uni_decomp_data_0xff44[] = { 0x64, 0, };
-static const char32 __uni_decomp_data_0xff45[] = { 0x65, 0, };
-static const char32 __uni_decomp_data_0xff46[] = { 0x66, 0, };
-static const char32 __uni_decomp_data_0xff47[] = { 0x67, 0, };
-static const char32 __uni_decomp_data_0xff48[] = { 0x68, 0, };
-static const char32 __uni_decomp_data_0xff49[] = { 0x69, 0, };
-static const char32 __uni_decomp_data_0xff4a[] = { 0x6a, 0, };
-static const char32 __uni_decomp_data_0xff4b[] = { 0x6b, 0, };
-static const char32 __uni_decomp_data_0xff4c[] = { 0x6c, 0, };
-static const char32 __uni_decomp_data_0xff4d[] = { 0x6d, 0, };
-static const char32 __uni_decomp_data_0xff4e[] = { 0x6e, 0, };
-static const char32 __uni_decomp_data_0xff4f[] = { 0x6f, 0, };
-static const char32 __uni_decomp_data_0xff50[] = { 0x70, 0, };
-static const char32 __uni_decomp_data_0xff51[] = { 0x71, 0, };
-static const char32 __uni_decomp_data_0xff52[] = { 0x72, 0, };
-static const char32 __uni_decomp_data_0xff53[] = { 0x73, 0, };
-static const char32 __uni_decomp_data_0xff54[] = { 0x74, 0, };
-static const char32 __uni_decomp_data_0xff55[] = { 0x75, 0, };
-static const char32 __uni_decomp_data_0xff56[] = { 0x76, 0, };
-static const char32 __uni_decomp_data_0xff57[] = { 0x77, 0, };
-static const char32 __uni_decomp_data_0xff58[] = { 0x78, 0, };
-static const char32 __uni_decomp_data_0xff59[] = { 0x79, 0, };
-static const char32 __uni_decomp_data_0xff5a[] = { 0x7a, 0, };
-static const char32 __uni_decomp_data_0xff5b[] = { 0x7b, 0, };
-static const char32 __uni_decomp_data_0xff5c[] = { 0x7c, 0, };
-static const char32 __uni_decomp_data_0xff5d[] = { 0x7d, 0, };
-static const char32 __uni_decomp_data_0xff5e[] = { 0x7e, 0, };
-static const char32 __uni_decomp_data_0xff5f[] = { 0x2985, 0, };
-static const char32 __uni_decomp_data_0xff60[] = { 0x2986, 0, };
-static const char32 __uni_decomp_data_0xff61[] = { 0x3002, 0, };
-static const char32 __uni_decomp_data_0xff62[] = { 0x300c, 0, };
-static const char32 __uni_decomp_data_0xff63[] = { 0x300d, 0, };
-static const char32 __uni_decomp_data_0xff64[] = { 0x3001, 0, };
-static const char32 __uni_decomp_data_0xff65[] = { 0x30fb, 0, };
-static const char32 __uni_decomp_data_0xff66[] = { 0x30f2, 0, };
-static const char32 __uni_decomp_data_0xff67[] = { 0x30a1, 0, };
-static const char32 __uni_decomp_data_0xff68[] = { 0x30a3, 0, };
-static const char32 __uni_decomp_data_0xff69[] = { 0x30a5, 0, };
-static const char32 __uni_decomp_data_0xff6a[] = { 0x30a7, 0, };
-static const char32 __uni_decomp_data_0xff6b[] = { 0x30a9, 0, };
-static const char32 __uni_decomp_data_0xff6c[] = { 0x30e3, 0, };
-static const char32 __uni_decomp_data_0xff6d[] = { 0x30e5, 0, };
-static const char32 __uni_decomp_data_0xff6e[] = { 0x30e7, 0, };
-static const char32 __uni_decomp_data_0xff6f[] = { 0x30c3, 0, };
-static const char32 __uni_decomp_data_0xff70[] = { 0x30fc, 0, };
-static const char32 __uni_decomp_data_0xff71[] = { 0x30a2, 0, };
-static const char32 __uni_decomp_data_0xff72[] = { 0x30a4, 0, };
-static const char32 __uni_decomp_data_0xff73[] = { 0x30a6, 0, };
-static const char32 __uni_decomp_data_0xff74[] = { 0x30a8, 0, };
-static const char32 __uni_decomp_data_0xff75[] = { 0x30aa, 0, };
-static const char32 __uni_decomp_data_0xff76[] = { 0x30ab, 0, };
-static const char32 __uni_decomp_data_0xff77[] = { 0x30ad, 0, };
-static const char32 __uni_decomp_data_0xff78[] = { 0x30af, 0, };
-static const char32 __uni_decomp_data_0xff79[] = { 0x30b1, 0, };
-static const char32 __uni_decomp_data_0xff7a[] = { 0x30b3, 0, };
-static const char32 __uni_decomp_data_0xff7b[] = { 0x30b5, 0, };
-static const char32 __uni_decomp_data_0xff7c[] = { 0x30b7, 0, };
-static const char32 __uni_decomp_data_0xff7d[] = { 0x30b9, 0, };
-static const char32 __uni_decomp_data_0xff7e[] = { 0x30bb, 0, };
-static const char32 __uni_decomp_data_0xff7f[] = { 0x30bd, 0, };
+static const char32 __uni_decomp_data_0xff01[] = { 1, 0x21, };
+static const char32 __uni_decomp_data_0xff02[] = { 1, 0x22, };
+static const char32 __uni_decomp_data_0xff03[] = { 1, 0x23, };
+static const char32 __uni_decomp_data_0xff04[] = { 1, 0x24, };
+static const char32 __uni_decomp_data_0xff05[] = { 1, 0x25, };
+static const char32 __uni_decomp_data_0xff06[] = { 1, 0x26, };
+static const char32 __uni_decomp_data_0xff07[] = { 1, 0x27, };
+static const char32 __uni_decomp_data_0xff08[] = { 1, 0x28, };
+static const char32 __uni_decomp_data_0xff09[] = { 1, 0x29, };
+static const char32 __uni_decomp_data_0xff0a[] = { 1, 0x2a, };
+static const char32 __uni_decomp_data_0xff0b[] = { 1, 0x2b, };
+static const char32 __uni_decomp_data_0xff0c[] = { 1, 0x2c, };
+static const char32 __uni_decomp_data_0xff0d[] = { 1, 0x2d, };
+static const char32 __uni_decomp_data_0xff0e[] = { 1, 0x2e, };
+static const char32 __uni_decomp_data_0xff0f[] = { 1, 0x2f, };
+static const char32 __uni_decomp_data_0xff10[] = { 1, 0x30, };
+static const char32 __uni_decomp_data_0xff11[] = { 1, 0x31, };
+static const char32 __uni_decomp_data_0xff12[] = { 1, 0x32, };
+static const char32 __uni_decomp_data_0xff13[] = { 1, 0x33, };
+static const char32 __uni_decomp_data_0xff14[] = { 1, 0x34, };
+static const char32 __uni_decomp_data_0xff15[] = { 1, 0x35, };
+static const char32 __uni_decomp_data_0xff16[] = { 1, 0x36, };
+static const char32 __uni_decomp_data_0xff17[] = { 1, 0x37, };
+static const char32 __uni_decomp_data_0xff18[] = { 1, 0x38, };
+static const char32 __uni_decomp_data_0xff19[] = { 1, 0x39, };
+static const char32 __uni_decomp_data_0xff1a[] = { 1, 0x3a, };
+static const char32 __uni_decomp_data_0xff1b[] = { 1, 0x3b, };
+static const char32 __uni_decomp_data_0xff1c[] = { 1, 0x3c, };
+static const char32 __uni_decomp_data_0xff1d[] = { 1, 0x3d, };
+static const char32 __uni_decomp_data_0xff1e[] = { 1, 0x3e, };
+static const char32 __uni_decomp_data_0xff1f[] = { 1, 0x3f, };
+static const char32 __uni_decomp_data_0xff20[] = { 1, 0x40, };
+static const char32 __uni_decomp_data_0xff21[] = { 1, 0x41, };
+static const char32 __uni_decomp_data_0xff22[] = { 1, 0x42, };
+static const char32 __uni_decomp_data_0xff23[] = { 1, 0x43, };
+static const char32 __uni_decomp_data_0xff24[] = { 1, 0x44, };
+static const char32 __uni_decomp_data_0xff25[] = { 1, 0x45, };
+static const char32 __uni_decomp_data_0xff26[] = { 1, 0x46, };
+static const char32 __uni_decomp_data_0xff27[] = { 1, 0x47, };
+static const char32 __uni_decomp_data_0xff28[] = { 1, 0x48, };
+static const char32 __uni_decomp_data_0xff29[] = { 1, 0x49, };
+static const char32 __uni_decomp_data_0xff2a[] = { 1, 0x4a, };
+static const char32 __uni_decomp_data_0xff2b[] = { 1, 0x4b, };
+static const char32 __uni_decomp_data_0xff2c[] = { 1, 0x4c, };
+static const char32 __uni_decomp_data_0xff2d[] = { 1, 0x4d, };
+static const char32 __uni_decomp_data_0xff2e[] = { 1, 0x4e, };
+static const char32 __uni_decomp_data_0xff2f[] = { 1, 0x4f, };
+static const char32 __uni_decomp_data_0xff30[] = { 1, 0x50, };
+static const char32 __uni_decomp_data_0xff31[] = { 1, 0x51, };
+static const char32 __uni_decomp_data_0xff32[] = { 1, 0x52, };
+static const char32 __uni_decomp_data_0xff33[] = { 1, 0x53, };
+static const char32 __uni_decomp_data_0xff34[] = { 1, 0x54, };
+static const char32 __uni_decomp_data_0xff35[] = { 1, 0x55, };
+static const char32 __uni_decomp_data_0xff36[] = { 1, 0x56, };
+static const char32 __uni_decomp_data_0xff37[] = { 1, 0x57, };
+static const char32 __uni_decomp_data_0xff38[] = { 1, 0x58, };
+static const char32 __uni_decomp_data_0xff39[] = { 1, 0x59, };
+static const char32 __uni_decomp_data_0xff3a[] = { 1, 0x5a, };
+static const char32 __uni_decomp_data_0xff3b[] = { 1, 0x5b, };
+static const char32 __uni_decomp_data_0xff3c[] = { 1, 0x5c, };
+static const char32 __uni_decomp_data_0xff3d[] = { 1, 0x5d, };
+static const char32 __uni_decomp_data_0xff3e[] = { 1, 0x5e, };
+static const char32 __uni_decomp_data_0xff3f[] = { 1, 0x5f, };
+static const char32 __uni_decomp_data_0xff40[] = { 1, 0x60, };
+static const char32 __uni_decomp_data_0xff41[] = { 1, 0x61, };
+static const char32 __uni_decomp_data_0xff42[] = { 1, 0x62, };
+static const char32 __uni_decomp_data_0xff43[] = { 1, 0x63, };
+static const char32 __uni_decomp_data_0xff44[] = { 1, 0x64, };
+static const char32 __uni_decomp_data_0xff45[] = { 1, 0x65, };
+static const char32 __uni_decomp_data_0xff46[] = { 1, 0x66, };
+static const char32 __uni_decomp_data_0xff47[] = { 1, 0x67, };
+static const char32 __uni_decomp_data_0xff48[] = { 1, 0x68, };
+static const char32 __uni_decomp_data_0xff49[] = { 1, 0x69, };
+static const char32 __uni_decomp_data_0xff4a[] = { 1, 0x6a, };
+static const char32 __uni_decomp_data_0xff4b[] = { 1, 0x6b, };
+static const char32 __uni_decomp_data_0xff4c[] = { 1, 0x6c, };
+static const char32 __uni_decomp_data_0xff4d[] = { 1, 0x6d, };
+static const char32 __uni_decomp_data_0xff4e[] = { 1, 0x6e, };
+static const char32 __uni_decomp_data_0xff4f[] = { 1, 0x6f, };
+static const char32 __uni_decomp_data_0xff50[] = { 1, 0x70, };
+static const char32 __uni_decomp_data_0xff51[] = { 1, 0x71, };
+static const char32 __uni_decomp_data_0xff52[] = { 1, 0x72, };
+static const char32 __uni_decomp_data_0xff53[] = { 1, 0x73, };
+static const char32 __uni_decomp_data_0xff54[] = { 1, 0x74, };
+static const char32 __uni_decomp_data_0xff55[] = { 1, 0x75, };
+static const char32 __uni_decomp_data_0xff56[] = { 1, 0x76, };
+static const char32 __uni_decomp_data_0xff57[] = { 1, 0x77, };
+static const char32 __uni_decomp_data_0xff58[] = { 1, 0x78, };
+static const char32 __uni_decomp_data_0xff59[] = { 1, 0x79, };
+static const char32 __uni_decomp_data_0xff5a[] = { 1, 0x7a, };
+static const char32 __uni_decomp_data_0xff5b[] = { 1, 0x7b, };
+static const char32 __uni_decomp_data_0xff5c[] = { 1, 0x7c, };
+static const char32 __uni_decomp_data_0xff5d[] = { 1, 0x7d, };
+static const char32 __uni_decomp_data_0xff5e[] = { 1, 0x7e, };
+static const char32 __uni_decomp_data_0xff5f[] = { 1, 0x2985, };
+static const char32 __uni_decomp_data_0xff60[] = { 1, 0x2986, };
+static const char32 __uni_decomp_data_0xff61[] = { 1, 0x3002, };
+static const char32 __uni_decomp_data_0xff62[] = { 1, 0x300c, };
+static const char32 __uni_decomp_data_0xff63[] = { 1, 0x300d, };
+static const char32 __uni_decomp_data_0xff64[] = { 1, 0x3001, };
+static const char32 __uni_decomp_data_0xff65[] = { 1, 0x30fb, };
+static const char32 __uni_decomp_data_0xff66[] = { 1, 0x30f2, };
+static const char32 __uni_decomp_data_0xff67[] = { 1, 0x30a1, };
+static const char32 __uni_decomp_data_0xff68[] = { 1, 0x30a3, };
+static const char32 __uni_decomp_data_0xff69[] = { 1, 0x30a5, };
+static const char32 __uni_decomp_data_0xff6a[] = { 1, 0x30a7, };
+static const char32 __uni_decomp_data_0xff6b[] = { 1, 0x30a9, };
+static const char32 __uni_decomp_data_0xff6c[] = { 1, 0x30e3, };
+static const char32 __uni_decomp_data_0xff6d[] = { 1, 0x30e5, };
+static const char32 __uni_decomp_data_0xff6e[] = { 1, 0x30e7, };
+static const char32 __uni_decomp_data_0xff6f[] = { 1, 0x30c3, };
+static const char32 __uni_decomp_data_0xff70[] = { 1, 0x30fc, };
+static const char32 __uni_decomp_data_0xff71[] = { 1, 0x30a2, };
+static const char32 __uni_decomp_data_0xff72[] = { 1, 0x30a4, };
+static const char32 __uni_decomp_data_0xff73[] = { 1, 0x30a6, };
+static const char32 __uni_decomp_data_0xff74[] = { 1, 0x30a8, };
+static const char32 __uni_decomp_data_0xff75[] = { 1, 0x30aa, };
+static const char32 __uni_decomp_data_0xff76[] = { 1, 0x30ab, };
+static const char32 __uni_decomp_data_0xff77[] = { 1, 0x30ad, };
+static const char32 __uni_decomp_data_0xff78[] = { 1, 0x30af, };
+static const char32 __uni_decomp_data_0xff79[] = { 1, 0x30b1, };
+static const char32 __uni_decomp_data_0xff7a[] = { 1, 0x30b3, };
+static const char32 __uni_decomp_data_0xff7b[] = { 1, 0x30b5, };
+static const char32 __uni_decomp_data_0xff7c[] = { 1, 0x30b7, };
+static const char32 __uni_decomp_data_0xff7d[] = { 1, 0x30b9, };
+static const char32 __uni_decomp_data_0xff7e[] = { 1, 0x30bb, };
+static const char32 __uni_decomp_data_0xff7f[] = { 1, 0x30bd, };
 
 
 
@@ -10712,104 +10712,104 @@
 };
 
 
-static const char32 __uni_decomp_data_0xff80[] = { 0x30bf, 0, };
-static const char32 __uni_decomp_data_0xff81[] = { 0x30c1, 0, };
-static const char32 __uni_decomp_data_0xff82[] = { 0x30c4, 0, };
-static const char32 __uni_decomp_data_0xff83[] = { 0x30c6, 0, };
-static const char32 __uni_decomp_data_0xff84[] = { 0x30c8, 0, };
-static const char32 __uni_decomp_data_0xff85[] = { 0x30ca, 0, };
-static const char32 __uni_decomp_data_0xff86[] = { 0x30cb, 0, };
-static const char32 __uni_decomp_data_0xff87[] = { 0x30cc, 0, };
-static const char32 __uni_decomp_data_0xff88[] = { 0x30cd, 0, };
-static const char32 __uni_decomp_data_0xff89[] = { 0x30ce, 0, };
-static const char32 __uni_decomp_data_0xff8a[] = { 0x30cf, 0, };
-static const char32 __uni_decomp_data_0xff8b[] = { 0x30d2, 0, };
-static const char32 __uni_decomp_data_0xff8c[] = { 0x30d5, 0, };
-static const char32 __uni_decomp_data_0xff8d[] = { 0x30d8, 0, };
-static const char32 __uni_decomp_data_0xff8e[] = { 0x30db, 0, };
-static const char32 __uni_decomp_data_0xff8f[] = { 0x30de, 0, };
-static const char32 __uni_decomp_data_0xff90[] = { 0x30df, 0, };
-static const char32 __uni_decomp_data_0xff91[] = { 0x30e0, 0, };
-static const char32 __uni_decomp_data_0xff92[] = { 0x30e1, 0, };
-static const char32 __uni_decomp_data_0xff93[] = { 0x30e2, 0, };
-static const char32 __uni_decomp_data_0xff94[] = { 0x30e4, 0, };
-static const char32 __uni_decomp_data_0xff95[] = { 0x30e6, 0, };
-static const char32 __uni_decomp_data_0xff96[] = { 0x30e8, 0, };
-static const char32 __uni_decomp_data_0xff97[] = { 0x30e9, 0, };
-static const char32 __uni_decomp_data_0xff98[] = { 0x30ea, 0, };
-static const char32 __uni_decomp_data_0xff99[] = { 0x30eb, 0, };
-static const char32 __uni_decomp_data_0xff9a[] = { 0x30ec, 0, };
-static const char32 __uni_decomp_data_0xff9b[] = { 0x30ed, 0, };
-static const char32 __uni_decomp_data_0xff9c[] = { 0x30ef, 0, };
-static const char32 __uni_decomp_data_0xff9d[] = { 0x30f3, 0, };
-static const char32 __uni_decomp_data_0xff9e[] = { 0x3099, 0, };
-static const char32 __uni_decomp_data_0xff9f[] = { 0x309a, 0, };
-static const char32 __uni_decomp_data_0xffa0[] = { 0x3164, 0, };
-static const char32 __uni_decomp_data_0xffa1[] = { 0x3131, 0, };
-static const char32 __uni_decomp_data_0xffa2[] = { 0x3132, 0, };
-static const char32 __uni_decomp_data_0xffa3[] = { 0x3133, 0, };
-static const char32 __uni_decomp_data_0xffa4[] = { 0x3134, 0, };
-static const char32 __uni_decomp_data_0xffa5[] = { 0x3135, 0, };
-static const char32 __uni_decomp_data_0xffa6[] = { 0x3136, 0, };
-static const char32 __uni_decomp_data_0xffa7[] = { 0x3137, 0, };
-static const char32 __uni_decomp_data_0xffa8[] = { 0x3138, 0, };
-static const char32 __uni_decomp_data_0xffa9[] = { 0x3139, 0, };
-static const char32 __uni_decomp_data_0xffaa[] = { 0x313a, 0, };
-static const char32 __uni_decomp_data_0xffab[] = { 0x313b, 0, };
-static const char32 __uni_decomp_data_0xffac[] = { 0x313c, 0, };
-static const char32 __uni_decomp_data_0xffad[] = { 0x313d, 0, };
-static const char32 __uni_decomp_data_0xffae[] = { 0x313e, 0, };
-static const char32 __uni_decomp_data_0xffaf[] = { 0x313f, 0, };
-static const char32 __uni_decomp_data_0xffb0[] = { 0x3140, 0, };
-static const char32 __uni_decomp_data_0xffb1[] = { 0x3141, 0, };
-static const char32 __uni_decomp_data_0xffb2[] = { 0x3142, 0, };
-static const char32 __uni_decomp_data_0xffb3[] = { 0x3143, 0, };
-static const char32 __uni_decomp_data_0xffb4[] = { 0x3144, 0, };
-static const char32 __uni_decomp_data_0xffb5[] = { 0x3145, 0, };
-static const char32 __uni_decomp_data_0xffb6[] = { 0x3146, 0, };
-static const char32 __uni_decomp_data_0xffb7[] = { 0x3147, 0, };
-static const char32 __uni_decomp_data_0xffb8[] = { 0x3148, 0, };
-static const char32 __uni_decomp_data_0xffb9[] = { 0x3149, 0, };
-static const char32 __uni_decomp_data_0xffba[] = { 0x314a, 0, };
-static const char32 __uni_decomp_data_0xffbb[] = { 0x314b, 0, };
-static const char32 __uni_decomp_data_0xffbc[] = { 0x314c, 0, };
-static const char32 __uni_decomp_data_0xffbd[] = { 0x314d, 0, };
-static const char32 __uni_decomp_data_0xffbe[] = { 0x314e, 0, };
-static const char32 __uni_decomp_data_0xffc2[] = { 0x314f, 0, };
-static const char32 __uni_decomp_data_0xffc3[] = { 0x3150, 0, };
-static const char32 __uni_decomp_data_0xffc4[] = { 0x3151, 0, };
-static const char32 __uni_decomp_data_0xffc5[] = { 0x3152, 0, };
-static const char32 __uni_decomp_data_0xffc6[] = { 0x3153, 0, };
-static const char32 __uni_decomp_data_0xffc7[] = { 0x3154, 0, };
-static const char32 __uni_decomp_data_0xffca[] = { 0x3155, 0, };
-static const char32 __uni_decomp_data_0xffcb[] = { 0x3156, 0, };
-static const char32 __uni_decomp_data_0xffcc[] = { 0x3157, 0, };
-static const char32 __uni_decomp_data_0xffcd[] = { 0x3158, 0, };
-static const char32 __uni_decomp_data_0xffce[] = { 0x3159, 0, };
-static const char32 __uni_decomp_data_0xffcf[] = { 0x315a, 0, };
-static const char32 __uni_decomp_data_0xffd2[] = { 0x315b, 0, };
-static const char32 __uni_decomp_data_0xffd3[] = { 0x315c, 0, };
-static const char32 __uni_decomp_data_0xffd4[] = { 0x315d, 0, };
-static const char32 __uni_decomp_data_0xffd5[] = { 0x315e, 0, };
-static const char32 __uni_decomp_data_0xffd6[] = { 0x315f, 0, };
-static const char32 __uni_decomp_data_0xffd7[] = { 0x3160, 0, };
-static const char32 __uni_decomp_data_0xffda[] = { 0x3161, 0, };
-static const char32 __uni_decomp_data_0xffdb[] = { 0x3162, 0, };
-static const char32 __uni_decomp_data_0xffdc[] = { 0x3163, 0, };
-static const char32 __uni_decomp_data_0xffe0[] = { 0xa2, 0, };
-static const char32 __uni_decomp_data_0xffe1[] = { 0xa3, 0, };
-static const char32 __uni_decomp_data_0xffe2[] = { 0xac, 0, };
-static const char32 __uni_decomp_data_0xffe3[] = { 0xaf, 0, };
-static const char32 __uni_decomp_data_0xffe4[] = { 0xa6, 0, };
-static const char32 __uni_decomp_data_0xffe5[] = { 0xa5, 0, };
-static const char32 __uni_decomp_data_0xffe6[] = { 0x20a9, 0, };
-static const char32 __uni_decomp_data_0xffe8[] = { 0x2502, 0, };
-static const char32 __uni_decomp_data_0xffe9[] = { 0x2190, 0, };
-static const char32 __uni_decomp_data_0xffea[] = { 0x2191, 0, };
-static const char32 __uni_decomp_data_0xffeb[] = { 0x2192, 0, };
-static const char32 __uni_decomp_data_0xffec[] = { 0x2193, 0, };
-static const char32 __uni_decomp_data_0xffed[] = { 0x25a0, 0, };
-static const char32 __uni_decomp_data_0xffee[] = { 0x25cb, 0, };
+static const char32 __uni_decomp_data_0xff80[] = { 1, 0x30bf, };
+static const char32 __uni_decomp_data_0xff81[] = { 1, 0x30c1, };
+static const char32 __uni_decomp_data_0xff82[] = { 1, 0x30c4, };
+static const char32 __uni_decomp_data_0xff83[] = { 1, 0x30c6, };
+static const char32 __uni_decomp_data_0xff84[] = { 1, 0x30c8, };
+static const char32 __uni_decomp_data_0xff85[] = { 1, 0x30ca, };
+static const char32 __uni_decomp_data_0xff86[] = { 1, 0x30cb, };
+static const char32 __uni_decomp_data_0xff87[] = { 1, 0x30cc, };
+static const char32 __uni_decomp_data_0xff88[] = { 1, 0x30cd, };
+static const char32 __uni_decomp_data_0xff89[] = { 1, 0x30ce, };
+static const char32 __uni_decomp_data_0xff8a[] = { 1, 0x30cf, };
+static const char32 __uni_decomp_data_0xff8b[] = { 1, 0x30d2, };
+static const char32 __uni_decomp_data_0xff8c[] = { 1, 0x30d5, };
+static const char32 __uni_decomp_data_0xff8d[] = { 1, 0x30d8, };
+static const char32 __uni_decomp_data_0xff8e[] = { 1, 0x30db, };
+static const char32 __uni_decomp_data_0xff8f[] = { 1, 0x30de, };
+static const char32 __uni_decomp_data_0xff90[] = { 1, 0x30df, };
+static const char32 __uni_decomp_data_0xff91[] = { 1, 0x30e0, };
+static const char32 __uni_decomp_data_0xff92[] = { 1, 0x30e1, };
+static const char32 __uni_decomp_data_0xff93[] = { 1, 0x30e2, };
+static const char32 __uni_decomp_data_0xff94[] = { 1, 0x30e4, };
+static const char32 __uni_decomp_data_0xff95[] = { 1, 0x30e6, };
+static const char32 __uni_decomp_data_0xff96[] = { 1, 0x30e8, };
+static const char32 __uni_decomp_data_0xff97[] = { 1, 0x30e9, };
+static const char32 __uni_decomp_data_0xff98[] = { 1, 0x30ea, };
+static const char32 __uni_decomp_data_0xff99[] = { 1, 0x30eb, };
+static const char32 __uni_decomp_data_0xff9a[] = { 1, 0x30ec, };
+static const char32 __uni_decomp_data_0xff9b[] = { 1, 0x30ed, };
+static const char32 __uni_decomp_data_0xff9c[] = { 1, 0x30ef, };
+static const char32 __uni_decomp_data_0xff9d[] = { 1, 0x30f3, };
+static const char32 __uni_decomp_data_0xff9e[] = { 1, 0x3099, };
+static const char32 __uni_decomp_data_0xff9f[] = { 1, 0x309a, };
+static const char32 __uni_decomp_data_0xffa0[] = { 1, 0x3164, };
+static const char32 __uni_decomp_data_0xffa1[] = { 1, 0x3131, };
+static const char32 __uni_decomp_data_0xffa2[] = { 1, 0x3132, };
+static const char32 __uni_decomp_data_0xffa3[] = { 1, 0x3133, };
+static const char32 __uni_decomp_data_0xffa4[] = { 1, 0x3134, };
+static const char32 __uni_decomp_data_0xffa5[] = { 1, 0x3135, };
+static const char32 __uni_decomp_data_0xffa6[] = { 1, 0x3136, };
+static const char32 __uni_decomp_data_0xffa7[] = { 1, 0x3137, };
+static const char32 __uni_decomp_data_0xffa8[] = { 1, 0x3138, };
+static const char32 __uni_decomp_data_0xffa9[] = { 1, 0x3139, };
+static const char32 __uni_decomp_data_0xffaa[] = { 1, 0x313a, };
+static const char32 __uni_decomp_data_0xffab[] = { 1, 0x313b, };
+static const char32 __uni_decomp_data_0xffac[] = { 1, 0x313c, };
+static const char32 __uni_decomp_data_0xffad[] = { 1, 0x313d, };
+static const char32 __uni_decomp_data_0xffae[] = { 1, 0x313e, };
+static const char32 __uni_decomp_data_0xffaf[] = { 1, 0x313f, };
+static const char32 __uni_decomp_data_0xffb0[] = { 1, 0x3140, };
+static const char32 __uni_decomp_data_0xffb1[] = { 1, 0x3141, };
+static const char32 __uni_decomp_data_0xffb2[] = { 1, 0x3142, };
+static const char32 __uni_decomp_data_0xffb3[] = { 1, 0x3143, };
+static const char32 __uni_decomp_data_0xffb4[] = { 1, 0x3144, };
+static const char32 __uni_decomp_data_0xffb5[] = { 1, 0x3145, };
+static const char32 __uni_decomp_data_0xffb6[] = { 1, 0x3146, };
+static const char32 __uni_decomp_data_0xffb7[] = { 1, 0x3147, };
+static const char32 __uni_decomp_data_0xffb8[] = { 1, 0x3148, };
+static const char32 __uni_decomp_data_0xffb9[] = { 1, 0x3149, };
+static const char32 __uni_decomp_data_0xffba[] = { 1, 0x314a, };
+static const char32 __uni_decomp_data_0xffbb[] = { 1, 0x314b, };
+static const char32 __uni_decomp_data_0xffbc[] = { 1, 0x314c, };
+static const char32 __uni_decomp_data_0xffbd[] = { 1, 0x314d, };
+static const char32 __uni_decomp_data_0xffbe[] = { 1, 0x314e, };
+static const char32 __uni_decomp_data_0xffc2[] = { 1, 0x314f, };
+static const char32 __uni_decomp_data_0xffc3[] = { 1, 0x3150, };
+static const char32 __uni_decomp_data_0xffc4[] = { 1, 0x3151, };
+static const char32 __uni_decomp_data_0xffc5[] = { 1, 0x3152, };
+static const char32 __uni_decomp_data_0xffc6[] = { 1, 0x3153, };
+static const char32 __uni_decomp_data_0xffc7[] = { 1, 0x3154, };
+static const char32 __uni_decomp_data_0xffca[] = { 1, 0x3155, };
+static const char32 __uni_decomp_data_0xffcb[] = { 1, 0x3156, };
+static const char32 __uni_decomp_data_0xffcc[] = { 1, 0x3157, };
+static const char32 __uni_decomp_data_0xffcd[] = { 1, 0x3158, };
+static const char32 __uni_decomp_data_0xffce[] = { 1, 0x3159, };
+static const char32 __uni_decomp_data_0xffcf[] = { 1, 0x315a, };
+static const char32 __uni_decomp_data_0xffd2[] = { 1, 0x315b, };
+static const char32 __uni_decomp_data_0xffd3[] = { 1, 0x315c, };
+static const char32 __uni_decomp_data_0xffd4[] = { 1, 0x315d, };
+static const char32 __uni_decomp_data_0xffd5[] = { 1, 0x315e, };
+static const char32 __uni_decomp_data_0xffd6[] = { 1, 0x315f, };
+static const char32 __uni_decomp_data_0xffd7[] = { 1, 0x3160, };
+static const char32 __uni_decomp_data_0xffda[] = { 1, 0x3161, };
+static const char32 __uni_decomp_data_0xffdb[] = { 1, 0x3162, };
+static const char32 __uni_decomp_data_0xffdc[] = { 1, 0x3163, };
+static const char32 __uni_decomp_data_0xffe0[] = { 1, 0xa2, };
+static const char32 __uni_decomp_data_0xffe1[] = { 1, 0xa3, };
+static const char32 __uni_decomp_data_0xffe2[] = { 1, 0xac, };
+static const char32 __uni_decomp_data_0xffe3[] = { 1, 0xaf, };
+static const char32 __uni_decomp_data_0xffe4[] = { 1, 0xa6, };
+static const char32 __uni_decomp_data_0xffe5[] = { 1, 0xa5, };
+static const char32 __uni_decomp_data_0xffe6[] = { 1, 0x20a9, };
+static const char32 __uni_decomp_data_0xffe8[] = { 1, 0x2502, };
+static const char32 __uni_decomp_data_0xffe9[] = { 1, 0x2190, };
+static const char32 __uni_decomp_data_0xffea[] = { 1, 0x2191, };
+static const char32 __uni_decomp_data_0xffeb[] = { 1, 0x2192, };
+static const char32 __uni_decomp_data_0xffec[] = { 1, 0x2193, };
+static const char32 __uni_decomp_data_0xffed[] = { 1, 0x25a0, };
+static const char32 __uni_decomp_data_0xffee[] = { 1, 0x25cb, };
 
 
 

Modified: sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_8.ipp
==============================================================================
--- sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_8.ipp	(original)
+++ sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_8.ipp	2009-08-06 03:26:39 EDT (Thu, 06 Aug 2009)
@@ -8386,13 +8386,13 @@
 };
 
 
-static const char32 __uni_decomp_data_0x1d15e[] = { 0x1d157, 0x1d165, 0, };
-static const char32 __uni_decomp_data_0x1d15f[] = { 0x1d158, 0x1d165, 0, };
-static const char32 __uni_decomp_data_0x1d160[] = { 0x1d15f, 0x1d16e, 0, };
-static const char32 __uni_decomp_data_0x1d161[] = { 0x1d15f, 0x1d16f, 0, };
-static const char32 __uni_decomp_data_0x1d162[] = { 0x1d15f, 0x1d170, 0, };
-static const char32 __uni_decomp_data_0x1d163[] = { 0x1d15f, 0x1d171, 0, };
-static const char32 __uni_decomp_data_0x1d164[] = { 0x1d15f, 0x1d172, 0, };
+static const char32 __uni_decomp_data_0x1d15e[] = { 2, 0x1d157, 0x1d165, };
+static const char32 __uni_decomp_data_0x1d15f[] = { 2, 0x1d158, 0x1d165, };
+static const char32 __uni_decomp_data_0x1d160[] = { 2, 0x1d15f, 0x1d16e, };
+static const char32 __uni_decomp_data_0x1d161[] = { 2, 0x1d15f, 0x1d16f, };
+static const char32 __uni_decomp_data_0x1d162[] = { 2, 0x1d15f, 0x1d170, };
+static const char32 __uni_decomp_data_0x1d163[] = { 2, 0x1d15f, 0x1d171, };
+static const char32 __uni_decomp_data_0x1d164[] = { 2, 0x1d15f, 0x1d172, };
 
 
 
@@ -10066,12 +10066,12 @@
 };
 
 
-static const char32 __uni_decomp_data_0x1d1bb[] = { 0x1d1b9, 0x1d165, 0, };
-static const char32 __uni_decomp_data_0x1d1bc[] = { 0x1d1ba, 0x1d165, 0, };
-static const char32 __uni_decomp_data_0x1d1bd[] = { 0x1d1bb, 0x1d16e, 0, };
-static const char32 __uni_decomp_data_0x1d1be[] = { 0x1d1bc, 0x1d16e, 0, };
-static const char32 __uni_decomp_data_0x1d1bf[] = { 0x1d1bb, 0x1d16f, 0, };
-static const char32 __uni_decomp_data_0x1d1c0[] = { 0x1d1bc, 0x1d16f, 0, };
+static const char32 __uni_decomp_data_0x1d1bb[] = { 2, 0x1d1b9, 0x1d165, };
+static const char32 __uni_decomp_data_0x1d1bc[] = { 2, 0x1d1ba, 0x1d165, };
+static const char32 __uni_decomp_data_0x1d1bd[] = { 2, 0x1d1bb, 0x1d16e, };
+static const char32 __uni_decomp_data_0x1d1be[] = { 2, 0x1d1bc, 0x1d16e, };
+static const char32 __uni_decomp_data_0x1d1bf[] = { 2, 0x1d1bb, 0x1d16f, };
+static const char32 __uni_decomp_data_0x1d1c0[] = { 2, 0x1d1bc, 0x1d16f, };
 
 
 
@@ -15091,133 +15091,133 @@
 };
 
 
-static const char32 __uni_decomp_data_0x1d400[] = { 0x41, 0, };
-static const char32 __uni_decomp_data_0x1d401[] = { 0x42, 0, };
-static const char32 __uni_decomp_data_0x1d402[] = { 0x43, 0, };
-static const char32 __uni_decomp_data_0x1d403[] = { 0x44, 0, };
-static const char32 __uni_decomp_data_0x1d404[] = { 0x45, 0, };
-static const char32 __uni_decomp_data_0x1d405[] = { 0x46, 0, };
-static const char32 __uni_decomp_data_0x1d406[] = { 0x47, 0, };
-static const char32 __uni_decomp_data_0x1d407[] = { 0x48, 0, };
-static const char32 __uni_decomp_data_0x1d408[] = { 0x49, 0, };
-static const char32 __uni_decomp_data_0x1d409[] = { 0x4a, 0, };
-static const char32 __uni_decomp_data_0x1d40a[] = { 0x4b, 0, };
-static const char32 __uni_decomp_data_0x1d40b[] = { 0x4c, 0, };
-static const char32 __uni_decomp_data_0x1d40c[] = { 0x4d, 0, };
-static const char32 __uni_decomp_data_0x1d40d[] = { 0x4e, 0, };
-static const char32 __uni_decomp_data_0x1d40e[] = { 0x4f, 0, };
-static const char32 __uni_decomp_data_0x1d40f[] = { 0x50, 0, };
-static const char32 __uni_decomp_data_0x1d410[] = { 0x51, 0, };
-static const char32 __uni_decomp_data_0x1d411[] = { 0x52, 0, };
-static const char32 __uni_decomp_data_0x1d412[] = { 0x53, 0, };
-static const char32 __uni_decomp_data_0x1d413[] = { 0x54, 0, };
-static const char32 __uni_decomp_data_0x1d414[] = { 0x55, 0, };
-static const char32 __uni_decomp_data_0x1d415[] = { 0x56, 0, };
-static const char32 __uni_decomp_data_0x1d416[] = { 0x57, 0, };
-static const char32 __uni_decomp_data_0x1d417[] = { 0x58, 0, };
-static const char32 __uni_decomp_data_0x1d418[] = { 0x59, 0, };
-static const char32 __uni_decomp_data_0x1d419[] = { 0x5a, 0, };
-static const char32 __uni_decomp_data_0x1d41a[] = { 0x61, 0, };
-static const char32 __uni_decomp_data_0x1d41b[] = { 0x62, 0, };
-static const char32 __uni_decomp_data_0x1d41c[] = { 0x63, 0, };
-static const char32 __uni_decomp_data_0x1d41d[] = { 0x64, 0, };
-static const char32 __uni_decomp_data_0x1d41e[] = { 0x65, 0, };
-static const char32 __uni_decomp_data_0x1d41f[] = { 0x66, 0, };
-static const char32 __uni_decomp_data_0x1d420[] = { 0x67, 0, };
-static const char32 __uni_decomp_data_0x1d421[] = { 0x68, 0, };
-static const char32 __uni_decomp_data_0x1d422[] = { 0x69, 0, };
-static const char32 __uni_decomp_data_0x1d423[] = { 0x6a, 0, };
-static const char32 __uni_decomp_data_0x1d424[] = { 0x6b, 0, };
-static const char32 __uni_decomp_data_0x1d425[] = { 0x6c, 0, };
-static const char32 __uni_decomp_data_0x1d426[] = { 0x6d, 0, };
-static const char32 __uni_decomp_data_0x1d427[] = { 0x6e, 0, };
-static const char32 __uni_decomp_data_0x1d428[] = { 0x6f, 0, };
-static const char32 __uni_decomp_data_0x1d429[] = { 0x70, 0, };
-static const char32 __uni_decomp_data_0x1d42a[] = { 0x71, 0, };
-static const char32 __uni_decomp_data_0x1d42b[] = { 0x72, 0, };
-static const char32 __uni_decomp_data_0x1d42c[] = { 0x73, 0, };
-static const char32 __uni_decomp_data_0x1d42d[] = { 0x74, 0, };
-static const char32 __uni_decomp_data_0x1d42e[] = { 0x75, 0, };
-static const char32 __uni_decomp_data_0x1d42f[] = { 0x76, 0, };
-static const char32 __uni_decomp_data_0x1d430[] = { 0x77, 0, };
-static const char32 __uni_decomp_data_0x1d431[] = { 0x78, 0, };
-static const char32 __uni_decomp_data_0x1d432[] = { 0x79, 0, };
-static const char32 __uni_decomp_data_0x1d433[] = { 0x7a, 0, };
-static const char32 __uni_decomp_data_0x1d434[] = { 0x41, 0, };
-static const char32 __uni_decomp_data_0x1d435[] = { 0x42, 0, };
-static const char32 __uni_decomp_data_0x1d436[] = { 0x43, 0, };
-static const char32 __uni_decomp_data_0x1d437[] = { 0x44, 0, };
-static const char32 __uni_decomp_data_0x1d438[] = { 0x45, 0, };
-static const char32 __uni_decomp_data_0x1d439[] = { 0x46, 0, };
-static const char32 __uni_decomp_data_0x1d43a[] = { 0x47, 0, };
-static const char32 __uni_decomp_data_0x1d43b[] = { 0x48, 0, };
-static const char32 __uni_decomp_data_0x1d43c[] = { 0x49, 0, };
-static const char32 __uni_decomp_data_0x1d43d[] = { 0x4a, 0, };
-static const char32 __uni_decomp_data_0x1d43e[] = { 0x4b, 0, };
-static const char32 __uni_decomp_data_0x1d43f[] = { 0x4c, 0, };
-static const char32 __uni_decomp_data_0x1d440[] = { 0x4d, 0, };
-static const char32 __uni_decomp_data_0x1d441[] = { 0x4e, 0, };
-static const char32 __uni_decomp_data_0x1d442[] = { 0x4f, 0, };
-static const char32 __uni_decomp_data_0x1d443[] = { 0x50, 0, };
-static const char32 __uni_decomp_data_0x1d444[] = { 0x51, 0, };
-static const char32 __uni_decomp_data_0x1d445[] = { 0x52, 0, };
-static const char32 __uni_decomp_data_0x1d446[] = { 0x53, 0, };
-static const char32 __uni_decomp_data_0x1d447[] = { 0x54, 0, };
-static const char32 __uni_decomp_data_0x1d448[] = { 0x55, 0, };
-static const char32 __uni_decomp_data_0x1d449[] = { 0x56, 0, };
-static const char32 __uni_decomp_data_0x1d44a[] = { 0x57, 0, };
-static const char32 __uni_decomp_data_0x1d44b[] = { 0x58, 0, };
-static const char32 __uni_decomp_data_0x1d44c[] = { 0x59, 0, };
-static const char32 __uni_decomp_data_0x1d44d[] = { 0x5a, 0, };
-static const char32 __uni_decomp_data_0x1d44e[] = { 0x61, 0, };
-static const char32 __uni_decomp_data_0x1d44f[] = { 0x62, 0, };
-static const char32 __uni_decomp_data_0x1d450[] = { 0x63, 0, };
-static const char32 __uni_decomp_data_0x1d451[] = { 0x64, 0, };
-static const char32 __uni_decomp_data_0x1d452[] = { 0x65, 0, };
-static const char32 __uni_decomp_data_0x1d453[] = { 0x66, 0, };
-static const char32 __uni_decomp_data_0x1d454[] = { 0x67, 0, };
-static const char32 __uni_decomp_data_0x1d456[] = { 0x69, 0, };
-static const char32 __uni_decomp_data_0x1d457[] = { 0x6a, 0, };
-static const char32 __uni_decomp_data_0x1d458[] = { 0x6b, 0, };
-static const char32 __uni_decomp_data_0x1d459[] = { 0x6c, 0, };
-static const char32 __uni_decomp_data_0x1d45a[] = { 0x6d, 0, };
-static const char32 __uni_decomp_data_0x1d45b[] = { 0x6e, 0, };
-static const char32 __uni_decomp_data_0x1d45c[] = { 0x6f, 0, };
-static const char32 __uni_decomp_data_0x1d45d[] = { 0x70, 0, };
-static const char32 __uni_decomp_data_0x1d45e[] = { 0x71, 0, };
-static const char32 __uni_decomp_data_0x1d45f[] = { 0x72, 0, };
-static const char32 __uni_decomp_data_0x1d460[] = { 0x73, 0, };
-static const char32 __uni_decomp_data_0x1d461[] = { 0x74, 0, };
-static const char32 __uni_decomp_data_0x1d462[] = { 0x75, 0, };
-static const char32 __uni_decomp_data_0x1d463[] = { 0x76, 0, };
-static const char32 __uni_decomp_data_0x1d464[] = { 0x77, 0, };
-static const char32 __uni_decomp_data_0x1d465[] = { 0x78, 0, };
-static const char32 __uni_decomp_data_0x1d466[] = { 0x79, 0, };
-static const char32 __uni_decomp_data_0x1d467[] = { 0x7a, 0, };
-static const char32 __uni_decomp_data_0x1d468[] = { 0x41, 0, };
-static const char32 __uni_decomp_data_0x1d469[] = { 0x42, 0, };
-static const char32 __uni_decomp_data_0x1d46a[] = { 0x43, 0, };
-static const char32 __uni_decomp_data_0x1d46b[] = { 0x44, 0, };
-static const char32 __uni_decomp_data_0x1d46c[] = { 0x45, 0, };
-static const char32 __uni_decomp_data_0x1d46d[] = { 0x46, 0, };
-static const char32 __uni_decomp_data_0x1d46e[] = { 0x47, 0, };
-static const char32 __uni_decomp_data_0x1d46f[] = { 0x48, 0, };
-static const char32 __uni_decomp_data_0x1d470[] = { 0x49, 0, };
-static const char32 __uni_decomp_data_0x1d471[] = { 0x4a, 0, };
-static const char32 __uni_decomp_data_0x1d472[] = { 0x4b, 0, };
-static const char32 __uni_decomp_data_0x1d473[] = { 0x4c, 0, };
-static const char32 __uni_decomp_data_0x1d474[] = { 0x4d, 0, };
-static const char32 __uni_decomp_data_0x1d475[] = { 0x4e, 0, };
-static const char32 __uni_decomp_data_0x1d476[] = { 0x4f, 0, };
-static const char32 __uni_decomp_data_0x1d477[] = { 0x50, 0, };
-static const char32 __uni_decomp_data_0x1d478[] = { 0x51, 0, };
-static const char32 __uni_decomp_data_0x1d479[] = { 0x52, 0, };
-static const char32 __uni_decomp_data_0x1d47a[] = { 0x53, 0, };
-static const char32 __uni_decomp_data_0x1d47b[] = { 0x54, 0, };
-static const char32 __uni_decomp_data_0x1d47c[] = { 0x55, 0, };
-static const char32 __uni_decomp_data_0x1d47d[] = { 0x56, 0, };
-static const char32 __uni_decomp_data_0x1d47e[] = { 0x57, 0, };
-static const char32 __uni_decomp_data_0x1d47f[] = { 0x58, 0, };
+static const char32 __uni_decomp_data_0x1d400[] = { 1, 0x41, };
+static const char32 __uni_decomp_data_0x1d401[] = { 1, 0x42, };
+static const char32 __uni_decomp_data_0x1d402[] = { 1, 0x43, };
+static const char32 __uni_decomp_data_0x1d403[] = { 1, 0x44, };
+static const char32 __uni_decomp_data_0x1d404[] = { 1, 0x45, };
+static const char32 __uni_decomp_data_0x1d405[] = { 1, 0x46, };
+static const char32 __uni_decomp_data_0x1d406[] = { 1, 0x47, };
+static const char32 __uni_decomp_data_0x1d407[] = { 1, 0x48, };
+static const char32 __uni_decomp_data_0x1d408[] = { 1, 0x49, };
+static const char32 __uni_decomp_data_0x1d409[] = { 1, 0x4a, };
+static const char32 __uni_decomp_data_0x1d40a[] = { 1, 0x4b, };
+static const char32 __uni_decomp_data_0x1d40b[] = { 1, 0x4c, };
+static const char32 __uni_decomp_data_0x1d40c[] = { 1, 0x4d, };
+static const char32 __uni_decomp_data_0x1d40d[] = { 1, 0x4e, };
+static const char32 __uni_decomp_data_0x1d40e[] = { 1, 0x4f, };
+static const char32 __uni_decomp_data_0x1d40f[] = { 1, 0x50, };
+static const char32 __uni_decomp_data_0x1d410[] = { 1, 0x51, };
+static const char32 __uni_decomp_data_0x1d411[] = { 1, 0x52, };
+static const char32 __uni_decomp_data_0x1d412[] = { 1, 0x53, };
+static const char32 __uni_decomp_data_0x1d413[] = { 1, 0x54, };
+static const char32 __uni_decomp_data_0x1d414[] = { 1, 0x55, };
+static const char32 __uni_decomp_data_0x1d415[] = { 1, 0x56, };
+static const char32 __uni_decomp_data_0x1d416[] = { 1, 0x57, };
+static const char32 __uni_decomp_data_0x1d417[] = { 1, 0x58, };
+static const char32 __uni_decomp_data_0x1d418[] = { 1, 0x59, };
+static const char32 __uni_decomp_data_0x1d419[] = { 1, 0x5a, };
+static const char32 __uni_decomp_data_0x1d41a[] = { 1, 0x61, };
+static const char32 __uni_decomp_data_0x1d41b[] = { 1, 0x62, };
+static const char32 __uni_decomp_data_0x1d41c[] = { 1, 0x63, };
+static const char32 __uni_decomp_data_0x1d41d[] = { 1, 0x64, };
+static const char32 __uni_decomp_data_0x1d41e[] = { 1, 0x65, };
+static const char32 __uni_decomp_data_0x1d41f[] = { 1, 0x66, };
+static const char32 __uni_decomp_data_0x1d420[] = { 1, 0x67, };
+static const char32 __uni_decomp_data_0x1d421[] = { 1, 0x68, };
+static const char32 __uni_decomp_data_0x1d422[] = { 1, 0x69, };
+static const char32 __uni_decomp_data_0x1d423[] = { 1, 0x6a, };
+static const char32 __uni_decomp_data_0x1d424[] = { 1, 0x6b, };
+static const char32 __uni_decomp_data_0x1d425[] = { 1, 0x6c, };
+static const char32 __uni_decomp_data_0x1d426[] = { 1, 0x6d, };
+static const char32 __uni_decomp_data_0x1d427[] = { 1, 0x6e, };
+static const char32 __uni_decomp_data_0x1d428[] = { 1, 0x6f, };
+static const char32 __uni_decomp_data_0x1d429[] = { 1, 0x70, };
+static const char32 __uni_decomp_data_0x1d42a[] = { 1, 0x71, };
+static const char32 __uni_decomp_data_0x1d42b[] = { 1, 0x72, };
+static const char32 __uni_decomp_data_0x1d42c[] = { 1, 0x73, };
+static const char32 __uni_decomp_data_0x1d42d[] = { 1, 0x74, };
+static const char32 __uni_decomp_data_0x1d42e[] = { 1, 0x75, };
+static const char32 __uni_decomp_data_0x1d42f[] = { 1, 0x76, };
+static const char32 __uni_decomp_data_0x1d430[] = { 1, 0x77, };
+static const char32 __uni_decomp_data_0x1d431[] = { 1, 0x78, };
+static const char32 __uni_decomp_data_0x1d432[] = { 1, 0x79, };
+static const char32 __uni_decomp_data_0x1d433[] = { 1, 0x7a, };
+static const char32 __uni_decomp_data_0x1d434[] = { 1, 0x41, };
+static const char32 __uni_decomp_data_0x1d435[] = { 1, 0x42, };
+static const char32 __uni_decomp_data_0x1d436[] = { 1, 0x43, };
+static const char32 __uni_decomp_data_0x1d437[] = { 1, 0x44, };
+static const char32 __uni_decomp_data_0x1d438[] = { 1, 0x45, };
+static const char32 __uni_decomp_data_0x1d439[] = { 1, 0x46, };
+static const char32 __uni_decomp_data_0x1d43a[] = { 1, 0x47, };
+static const char32 __uni_decomp_data_0x1d43b[] = { 1, 0x48, };
+static const char32 __uni_decomp_data_0x1d43c[] = { 1, 0x49, };
+static const char32 __uni_decomp_data_0x1d43d[] = { 1, 0x4a, };
+static const char32 __uni_decomp_data_0x1d43e[] = { 1, 0x4b, };
+static const char32 __uni_decomp_data_0x1d43f[] = { 1, 0x4c, };
+static const char32 __uni_decomp_data_0x1d440[] = { 1, 0x4d, };
+static const char32 __uni_decomp_data_0x1d441[] = { 1, 0x4e, };
+static const char32 __uni_decomp_data_0x1d442[] = { 1, 0x4f, };
+static const char32 __uni_decomp_data_0x1d443[] = { 1, 0x50, };
+static const char32 __uni_decomp_data_0x1d444[] = { 1, 0x51, };
+static const char32 __uni_decomp_data_0x1d445[] = { 1, 0x52, };
+static const char32 __uni_decomp_data_0x1d446[] = { 1, 0x53, };
+static const char32 __uni_decomp_data_0x1d447[] = { 1, 0x54, };
+static const char32 __uni_decomp_data_0x1d448[] = { 1, 0x55, };
+static const char32 __uni_decomp_data_0x1d449[] = { 1, 0x56, };
+static const char32 __uni_decomp_data_0x1d44a[] = { 1, 0x57, };
+static const char32 __uni_decomp_data_0x1d44b[] = { 1, 0x58, };
+static const char32 __uni_decomp_data_0x1d44c[] = { 1, 0x59, };
+static const char32 __uni_decomp_data_0x1d44d[] = { 1, 0x5a, };
+static const char32 __uni_decomp_data_0x1d44e[] = { 1, 0x61, };
+static const char32 __uni_decomp_data_0x1d44f[] = { 1, 0x62, };
+static const char32 __uni_decomp_data_0x1d450[] = { 1, 0x63, };
+static const char32 __uni_decomp_data_0x1d451[] = { 1, 0x64, };
+static const char32 __uni_decomp_data_0x1d452[] = { 1, 0x65, };
+static const char32 __uni_decomp_data_0x1d453[] = { 1, 0x66, };
+static const char32 __uni_decomp_data_0x1d454[] = { 1, 0x67, };
+static const char32 __uni_decomp_data_0x1d456[] = { 1, 0x69, };
+static const char32 __uni_decomp_data_0x1d457[] = { 1, 0x6a, };
+static const char32 __uni_decomp_data_0x1d458[] = { 1, 0x6b, };
+static const char32 __uni_decomp_data_0x1d459[] = { 1, 0x6c, };
+static const char32 __uni_decomp_data_0x1d45a[] = { 1, 0x6d, };
+static const char32 __uni_decomp_data_0x1d45b[] = { 1, 0x6e, };
+static const char32 __uni_decomp_data_0x1d45c[] = { 1, 0x6f, };
+static const char32 __uni_decomp_data_0x1d45d[] = { 1, 0x70, };
+static const char32 __uni_decomp_data_0x1d45e[] = { 1, 0x71, };
+static const char32 __uni_decomp_data_0x1d45f[] = { 1, 0x72, };
+static const char32 __uni_decomp_data_0x1d460[] = { 1, 0x73, };
+static const char32 __uni_decomp_data_0x1d461[] = { 1, 0x74, };
+static const char32 __uni_decomp_data_0x1d462[] = { 1, 0x75, };
+static const char32 __uni_decomp_data_0x1d463[] = { 1, 0x76, };
+static const char32 __uni_decomp_data_0x1d464[] = { 1, 0x77, };
+static const char32 __uni_decomp_data_0x1d465[] = { 1, 0x78, };
+static const char32 __uni_decomp_data_0x1d466[] = { 1, 0x79, };
+static const char32 __uni_decomp_data_0x1d467[] = { 1, 0x7a, };
+static const char32 __uni_decomp_data_0x1d468[] = { 1, 0x41, };
+static const char32 __uni_decomp_data_0x1d469[] = { 1, 0x42, };
+static const char32 __uni_decomp_data_0x1d46a[] = { 1, 0x43, };
+static const char32 __uni_decomp_data_0x1d46b[] = { 1, 0x44, };
+static const char32 __uni_decomp_data_0x1d46c[] = { 1, 0x45, };
+static const char32 __uni_decomp_data_0x1d46d[] = { 1, 0x46, };
+static const char32 __uni_decomp_data_0x1d46e[] = { 1, 0x47, };
+static const char32 __uni_decomp_data_0x1d46f[] = { 1, 0x48, };
+static const char32 __uni_decomp_data_0x1d470[] = { 1, 0x49, };
+static const char32 __uni_decomp_data_0x1d471[] = { 1, 0x4a, };
+static const char32 __uni_decomp_data_0x1d472[] = { 1, 0x4b, };
+static const char32 __uni_decomp_data_0x1d473[] = { 1, 0x4c, };
+static const char32 __uni_decomp_data_0x1d474[] = { 1, 0x4d, };
+static const char32 __uni_decomp_data_0x1d475[] = { 1, 0x4e, };
+static const char32 __uni_decomp_data_0x1d476[] = { 1, 0x4f, };
+static const char32 __uni_decomp_data_0x1d477[] = { 1, 0x50, };
+static const char32 __uni_decomp_data_0x1d478[] = { 1, 0x51, };
+static const char32 __uni_decomp_data_0x1d479[] = { 1, 0x52, };
+static const char32 __uni_decomp_data_0x1d47a[] = { 1, 0x53, };
+static const char32 __uni_decomp_data_0x1d47b[] = { 1, 0x54, };
+static const char32 __uni_decomp_data_0x1d47c[] = { 1, 0x55, };
+static const char32 __uni_decomp_data_0x1d47d[] = { 1, 0x56, };
+static const char32 __uni_decomp_data_0x1d47e[] = { 1, 0x57, };
+static const char32 __uni_decomp_data_0x1d47f[] = { 1, 0x58, };
 
 
 
@@ -16891,123 +16891,123 @@
 };
 
 
-static const char32 __uni_decomp_data_0x1d480[] = { 0x59, 0, };
-static const char32 __uni_decomp_data_0x1d481[] = { 0x5a, 0, };
-static const char32 __uni_decomp_data_0x1d482[] = { 0x61, 0, };
-static const char32 __uni_decomp_data_0x1d483[] = { 0x62, 0, };
-static const char32 __uni_decomp_data_0x1d484[] = { 0x63, 0, };
-static const char32 __uni_decomp_data_0x1d485[] = { 0x64, 0, };
-static const char32 __uni_decomp_data_0x1d486[] = { 0x65, 0, };
-static const char32 __uni_decomp_data_0x1d487[] = { 0x66, 0, };
-static const char32 __uni_decomp_data_0x1d488[] = { 0x67, 0, };
-static const char32 __uni_decomp_data_0x1d489[] = { 0x68, 0, };
-static const char32 __uni_decomp_data_0x1d48a[] = { 0x69, 0, };
-static const char32 __uni_decomp_data_0x1d48b[] = { 0x6a, 0, };
-static const char32 __uni_decomp_data_0x1d48c[] = { 0x6b, 0, };
-static const char32 __uni_decomp_data_0x1d48d[] = { 0x6c, 0, };
-static const char32 __uni_decomp_data_0x1d48e[] = { 0x6d, 0, };
-static const char32 __uni_decomp_data_0x1d48f[] = { 0x6e, 0, };
-static const char32 __uni_decomp_data_0x1d490[] = { 0x6f, 0, };
-static const char32 __uni_decomp_data_0x1d491[] = { 0x70, 0, };
-static const char32 __uni_decomp_data_0x1d492[] = { 0x71, 0, };
-static const char32 __uni_decomp_data_0x1d493[] = { 0x72, 0, };
-static const char32 __uni_decomp_data_0x1d494[] = { 0x73, 0, };
-static const char32 __uni_decomp_data_0x1d495[] = { 0x74, 0, };
-static const char32 __uni_decomp_data_0x1d496[] = { 0x75, 0, };
-static const char32 __uni_decomp_data_0x1d497[] = { 0x76, 0, };
-static const char32 __uni_decomp_data_0x1d498[] = { 0x77, 0, };
-static const char32 __uni_decomp_data_0x1d499[] = { 0x78, 0, };
-static const char32 __uni_decomp_data_0x1d49a[] = { 0x79, 0, };
-static const char32 __uni_decomp_data_0x1d49b[] = { 0x7a, 0, };
-static const char32 __uni_decomp_data_0x1d49c[] = { 0x41, 0, };
-static const char32 __uni_decomp_data_0x1d49e[] = { 0x43, 0, };
-static const char32 __uni_decomp_data_0x1d49f[] = { 0x44, 0, };
-static const char32 __uni_decomp_data_0x1d4a2[] = { 0x47, 0, };
-static const char32 __uni_decomp_data_0x1d4a5[] = { 0x4a, 0, };
-static const char32 __uni_decomp_data_0x1d4a6[] = { 0x4b, 0, };
-static const char32 __uni_decomp_data_0x1d4a9[] = { 0x4e, 0, };
-static const char32 __uni_decomp_data_0x1d4aa[] = { 0x4f, 0, };
-static const char32 __uni_decomp_data_0x1d4ab[] = { 0x50, 0, };
-static const char32 __uni_decomp_data_0x1d4ac[] = { 0x51, 0, };
-static const char32 __uni_decomp_data_0x1d4ae[] = { 0x53, 0, };
-static const char32 __uni_decomp_data_0x1d4af[] = { 0x54, 0, };
-static const char32 __uni_decomp_data_0x1d4b0[] = { 0x55, 0, };
-static const char32 __uni_decomp_data_0x1d4b1[] = { 0x56, 0, };
-static const char32 __uni_decomp_data_0x1d4b2[] = { 0x57, 0, };
-static const char32 __uni_decomp_data_0x1d4b3[] = { 0x58, 0, };
-static const char32 __uni_decomp_data_0x1d4b4[] = { 0x59, 0, };
-static const char32 __uni_decomp_data_0x1d4b5[] = { 0x5a, 0, };
-static const char32 __uni_decomp_data_0x1d4b6[] = { 0x61, 0, };
-static const char32 __uni_decomp_data_0x1d4b7[] = { 0x62, 0, };
-static const char32 __uni_decomp_data_0x1d4b8[] = { 0x63, 0, };
-static const char32 __uni_decomp_data_0x1d4b9[] = { 0x64, 0, };
-static const char32 __uni_decomp_data_0x1d4bb[] = { 0x66, 0, };
-static const char32 __uni_decomp_data_0x1d4bd[] = { 0x68, 0, };
-static const char32 __uni_decomp_data_0x1d4be[] = { 0x69, 0, };
-static const char32 __uni_decomp_data_0x1d4bf[] = { 0x6a, 0, };
-static const char32 __uni_decomp_data_0x1d4c0[] = { 0x6b, 0, };
-static const char32 __uni_decomp_data_0x1d4c1[] = { 0x6c, 0, };
-static const char32 __uni_decomp_data_0x1d4c2[] = { 0x6d, 0, };
-static const char32 __uni_decomp_data_0x1d4c3[] = { 0x6e, 0, };
-static const char32 __uni_decomp_data_0x1d4c5[] = { 0x70, 0, };
-static const char32 __uni_decomp_data_0x1d4c6[] = { 0x71, 0, };
-static const char32 __uni_decomp_data_0x1d4c7[] = { 0x72, 0, };
-static const char32 __uni_decomp_data_0x1d4c8[] = { 0x73, 0, };
-static const char32 __uni_decomp_data_0x1d4c9[] = { 0x74, 0, };
-static const char32 __uni_decomp_data_0x1d4ca[] = { 0x75, 0, };
-static const char32 __uni_decomp_data_0x1d4cb[] = { 0x76, 0, };
-static const char32 __uni_decomp_data_0x1d4cc[] = { 0x77, 0, };
-static const char32 __uni_decomp_data_0x1d4cd[] = { 0x78, 0, };
-static const char32 __uni_decomp_data_0x1d4ce[] = { 0x79, 0, };
-static const char32 __uni_decomp_data_0x1d4cf[] = { 0x7a, 0, };
-static const char32 __uni_decomp_data_0x1d4d0[] = { 0x41, 0, };
-static const char32 __uni_decomp_data_0x1d4d1[] = { 0x42, 0, };
-static const char32 __uni_decomp_data_0x1d4d2[] = { 0x43, 0, };
-static const char32 __uni_decomp_data_0x1d4d3[] = { 0x44, 0, };
-static const char32 __uni_decomp_data_0x1d4d4[] = { 0x45, 0, };
-static const char32 __uni_decomp_data_0x1d4d5[] = { 0x46, 0, };
-static const char32 __uni_decomp_data_0x1d4d6[] = { 0x47, 0, };
-static const char32 __uni_decomp_data_0x1d4d7[] = { 0x48, 0, };
-static const char32 __uni_decomp_data_0x1d4d8[] = { 0x49, 0, };
-static const char32 __uni_decomp_data_0x1d4d9[] = { 0x4a, 0, };
-static const char32 __uni_decomp_data_0x1d4da[] = { 0x4b, 0, };
-static const char32 __uni_decomp_data_0x1d4db[] = { 0x4c, 0, };
-static const char32 __uni_decomp_data_0x1d4dc[] = { 0x4d, 0, };
-static const char32 __uni_decomp_data_0x1d4dd[] = { 0x4e, 0, };
-static const char32 __uni_decomp_data_0x1d4de[] = { 0x4f, 0, };
-static const char32 __uni_decomp_data_0x1d4df[] = { 0x50, 0, };
-static const char32 __uni_decomp_data_0x1d4e0[] = { 0x51, 0, };
-static const char32 __uni_decomp_data_0x1d4e1[] = { 0x52, 0, };
-static const char32 __uni_decomp_data_0x1d4e2[] = { 0x53, 0, };
-static const char32 __uni_decomp_data_0x1d4e3[] = { 0x54, 0, };
-static const char32 __uni_decomp_data_0x1d4e4[] = { 0x55, 0, };
-static const char32 __uni_decomp_data_0x1d4e5[] = { 0x56, 0, };
-static const char32 __uni_decomp_data_0x1d4e6[] = { 0x57, 0, };
-static const char32 __uni_decomp_data_0x1d4e7[] = { 0x58, 0, };
-static const char32 __uni_decomp_data_0x1d4e8[] = { 0x59, 0, };
-static const char32 __uni_decomp_data_0x1d4e9[] = { 0x5a, 0, };
-static const char32 __uni_decomp_data_0x1d4ea[] = { 0x61, 0, };
-static const char32 __uni_decomp_data_0x1d4eb[] = { 0x62, 0, };
-static const char32 __uni_decomp_data_0x1d4ec[] = { 0x63, 0, };
-static const char32 __uni_decomp_data_0x1d4ed[] = { 0x64, 0, };
-static const char32 __uni_decomp_data_0x1d4ee[] = { 0x65, 0, };
-static const char32 __uni_decomp_data_0x1d4ef[] = { 0x66, 0, };
-static const char32 __uni_decomp_data_0x1d4f0[] = { 0x67, 0, };
-static const char32 __uni_decomp_data_0x1d4f1[] = { 0x68, 0, };
-static const char32 __uni_decomp_data_0x1d4f2[] = { 0x69, 0, };
-static const char32 __uni_decomp_data_0x1d4f3[] = { 0x6a, 0, };
-static const char32 __uni_decomp_data_0x1d4f4[] = { 0x6b, 0, };
-static const char32 __uni_decomp_data_0x1d4f5[] = { 0x6c, 0, };
-static const char32 __uni_decomp_data_0x1d4f6[] = { 0x6d, 0, };
-static const char32 __uni_decomp_data_0x1d4f7[] = { 0x6e, 0, };
-static const char32 __uni_decomp_data_0x1d4f8[] = { 0x6f, 0, };
-static const char32 __uni_decomp_data_0x1d4f9[] = { 0x70, 0, };
-static const char32 __uni_decomp_data_0x1d4fa[] = { 0x71, 0, };
-static const char32 __uni_decomp_data_0x1d4fb[] = { 0x72, 0, };
-static const char32 __uni_decomp_data_0x1d4fc[] = { 0x73, 0, };
-static const char32 __uni_decomp_data_0x1d4fd[] = { 0x74, 0, };
-static const char32 __uni_decomp_data_0x1d4fe[] = { 0x75, 0, };
-static const char32 __uni_decomp_data_0x1d4ff[] = { 0x76, 0, };
+static const char32 __uni_decomp_data_0x1d480[] = { 1, 0x59, };
+static const char32 __uni_decomp_data_0x1d481[] = { 1, 0x5a, };
+static const char32 __uni_decomp_data_0x1d482[] = { 1, 0x61, };
+static const char32 __uni_decomp_data_0x1d483[] = { 1, 0x62, };
+static const char32 __uni_decomp_data_0x1d484[] = { 1, 0x63, };
+static const char32 __uni_decomp_data_0x1d485[] = { 1, 0x64, };
+static const char32 __uni_decomp_data_0x1d486[] = { 1, 0x65, };
+static const char32 __uni_decomp_data_0x1d487[] = { 1, 0x66, };
+static const char32 __uni_decomp_data_0x1d488[] = { 1, 0x67, };
+static const char32 __uni_decomp_data_0x1d489[] = { 1, 0x68, };
+static const char32 __uni_decomp_data_0x1d48a[] = { 1, 0x69, };
+static const char32 __uni_decomp_data_0x1d48b[] = { 1, 0x6a, };
+static const char32 __uni_decomp_data_0x1d48c[] = { 1, 0x6b, };
+static const char32 __uni_decomp_data_0x1d48d[] = { 1, 0x6c, };
+static const char32 __uni_decomp_data_0x1d48e[] = { 1, 0x6d, };
+static const char32 __uni_decomp_data_0x1d48f[] = { 1, 0x6e, };
+static const char32 __uni_decomp_data_0x1d490[] = { 1, 0x6f, };
+static const char32 __uni_decomp_data_0x1d491[] = { 1, 0x70, };
+static const char32 __uni_decomp_data_0x1d492[] = { 1, 0x71, };
+static const char32 __uni_decomp_data_0x1d493[] = { 1, 0x72, };
+static const char32 __uni_decomp_data_0x1d494[] = { 1, 0x73, };
+static const char32 __uni_decomp_data_0x1d495[] = { 1, 0x74, };
+static const char32 __uni_decomp_data_0x1d496[] = { 1, 0x75, };
+static const char32 __uni_decomp_data_0x1d497[] = { 1, 0x76, };
+static const char32 __uni_decomp_data_0x1d498[] = { 1, 0x77, };
+static const char32 __uni_decomp_data_0x1d499[] = { 1, 0x78, };
+static const char32 __uni_decomp_data_0x1d49a[] = { 1, 0x79, };
+static const char32 __uni_decomp_data_0x1d49b[] = { 1, 0x7a, };
+static const char32 __uni_decomp_data_0x1d49c[] = { 1, 0x41, };
+static const char32 __uni_decomp_data_0x1d49e[] = { 1, 0x43, };
+static const char32 __uni_decomp_data_0x1d49f[] = { 1, 0x44, };
+static const char32 __uni_decomp_data_0x1d4a2[] = { 1, 0x47, };
+static const char32 __uni_decomp_data_0x1d4a5[] = { 1, 0x4a, };
+static const char32 __uni_decomp_data_0x1d4a6[] = { 1, 0x4b, };
+static const char32 __uni_decomp_data_0x1d4a9[] = { 1, 0x4e, };
+static const char32 __uni_decomp_data_0x1d4aa[] = { 1, 0x4f, };
+static const char32 __uni_decomp_data_0x1d4ab[] = { 1, 0x50, };
+static const char32 __uni_decomp_data_0x1d4ac[] = { 1, 0x51, };
+static const char32 __uni_decomp_data_0x1d4ae[] = { 1, 0x53, };
+static const char32 __uni_decomp_data_0x1d4af[] = { 1, 0x54, };
+static const char32 __uni_decomp_data_0x1d4b0[] = { 1, 0x55, };
+static const char32 __uni_decomp_data_0x1d4b1[] = { 1, 0x56, };
+static const char32 __uni_decomp_data_0x1d4b2[] = { 1, 0x57, };
+static const char32 __uni_decomp_data_0x1d4b3[] = { 1, 0x58, };
+static const char32 __uni_decomp_data_0x1d4b4[] = { 1, 0x59, };
+static const char32 __uni_decomp_data_0x1d4b5[] = { 1, 0x5a, };
+static const char32 __uni_decomp_data_0x1d4b6[] = { 1, 0x61, };
+static const char32 __uni_decomp_data_0x1d4b7[] = { 1, 0x62, };
+static const char32 __uni_decomp_data_0x1d4b8[] = { 1, 0x63, };
+static const char32 __uni_decomp_data_0x1d4b9[] = { 1, 0x64, };
+static const char32 __uni_decomp_data_0x1d4bb[] = { 1, 0x66, };
+static const char32 __uni_decomp_data_0x1d4bd[] = { 1, 0x68, };
+static const char32 __uni_decomp_data_0x1d4be[] = { 1, 0x69, };
+static const char32 __uni_decomp_data_0x1d4bf[] = { 1, 0x6a, };
+static const char32 __uni_decomp_data_0x1d4c0[] = { 1, 0x6b, };
+static const char32 __uni_decomp_data_0x1d4c1[] = { 1, 0x6c, };
+static const char32 __uni_decomp_data_0x1d4c2[] = { 1, 0x6d, };
+static const char32 __uni_decomp_data_0x1d4c3[] = { 1, 0x6e, };
+static const char32 __uni_decomp_data_0x1d4c5[] = { 1, 0x70, };
+static const char32 __uni_decomp_data_0x1d4c6[] = { 1, 0x71, };
+static const char32 __uni_decomp_data_0x1d4c7[] = { 1, 0x72, };
+static const char32 __uni_decomp_data_0x1d4c8[] = { 1, 0x73, };
+static const char32 __uni_decomp_data_0x1d4c9[] = { 1, 0x74, };
+static const char32 __uni_decomp_data_0x1d4ca[] = { 1, 0x75, };
+static const char32 __uni_decomp_data_0x1d4cb[] = { 1, 0x76, };
+static const char32 __uni_decomp_data_0x1d4cc[] = { 1, 0x77, };
+static const char32 __uni_decomp_data_0x1d4cd[] = { 1, 0x78, };
+static const char32 __uni_decomp_data_0x1d4ce[] = { 1, 0x79, };
+static const char32 __uni_decomp_data_0x1d4cf[] = { 1, 0x7a, };
+static const char32 __uni_decomp_data_0x1d4d0[] = { 1, 0x41, };
+static const char32 __uni_decomp_data_0x1d4d1[] = { 1, 0x42, };
+static const char32 __uni_decomp_data_0x1d4d2[] = { 1, 0x43, };
+static const char32 __uni_decomp_data_0x1d4d3[] = { 1, 0x44, };
+static const char32 __uni_decomp_data_0x1d4d4[] = { 1, 0x45, };
+static const char32 __uni_decomp_data_0x1d4d5[] = { 1, 0x46, };
+static const char32 __uni_decomp_data_0x1d4d6[] = { 1, 0x47, };
+static const char32 __uni_decomp_data_0x1d4d7[] = { 1, 0x48, };
+static const char32 __uni_decomp_data_0x1d4d8[] = { 1, 0x49, };
+static const char32 __uni_decomp_data_0x1d4d9[] = { 1, 0x4a, };
+static const char32 __uni_decomp_data_0x1d4da[] = { 1, 0x4b, };
+static const char32 __uni_decomp_data_0x1d4db[] = { 1, 0x4c, };
+static const char32 __uni_decomp_data_0x1d4dc[] = { 1, 0x4d, };
+static const char32 __uni_decomp_data_0x1d4dd[] = { 1, 0x4e, };
+static const char32 __uni_decomp_data_0x1d4de[] = { 1, 0x4f, };
+static const char32 __uni_decomp_data_0x1d4df[] = { 1, 0x50, };
+static const char32 __uni_decomp_data_0x1d4e0[] = { 1, 0x51, };
+static const char32 __uni_decomp_data_0x1d4e1[] = { 1, 0x52, };
+static const char32 __uni_decomp_data_0x1d4e2[] = { 1, 0x53, };
+static const char32 __uni_decomp_data_0x1d4e3[] = { 1, 0x54, };
+static const char32 __uni_decomp_data_0x1d4e4[] = { 1, 0x55, };
+static const char32 __uni_decomp_data_0x1d4e5[] = { 1, 0x56, };
+static const char32 __uni_decomp_data_0x1d4e6[] = { 1, 0x57, };
+static const char32 __uni_decomp_data_0x1d4e7[] = { 1, 0x58, };
+static const char32 __uni_decomp_data_0x1d4e8[] = { 1, 0x59, };
+static const char32 __uni_decomp_data_0x1d4e9[] = { 1, 0x5a, };
+static const char32 __uni_decomp_data_0x1d4ea[] = { 1, 0x61, };
+static const char32 __uni_decomp_data_0x1d4eb[] = { 1, 0x62, };
+static const char32 __uni_decomp_data_0x1d4ec[] = { 1, 0x63, };
+static const char32 __uni_decomp_data_0x1d4ed[] = { 1, 0x64, };
+static const char32 __uni_decomp_data_0x1d4ee[] = { 1, 0x65, };
+static const char32 __uni_decomp_data_0x1d4ef[] = { 1, 0x66, };
+static const char32 __uni_decomp_data_0x1d4f0[] = { 1, 0x67, };
+static const char32 __uni_decomp_data_0x1d4f1[] = { 1, 0x68, };
+static const char32 __uni_decomp_data_0x1d4f2[] = { 1, 0x69, };
+static const char32 __uni_decomp_data_0x1d4f3[] = { 1, 0x6a, };
+static const char32 __uni_decomp_data_0x1d4f4[] = { 1, 0x6b, };
+static const char32 __uni_decomp_data_0x1d4f5[] = { 1, 0x6c, };
+static const char32 __uni_decomp_data_0x1d4f6[] = { 1, 0x6d, };
+static const char32 __uni_decomp_data_0x1d4f7[] = { 1, 0x6e, };
+static const char32 __uni_decomp_data_0x1d4f8[] = { 1, 0x6f, };
+static const char32 __uni_decomp_data_0x1d4f9[] = { 1, 0x70, };
+static const char32 __uni_decomp_data_0x1d4fa[] = { 1, 0x71, };
+static const char32 __uni_decomp_data_0x1d4fb[] = { 1, 0x72, };
+static const char32 __uni_decomp_data_0x1d4fc[] = { 1, 0x73, };
+static const char32 __uni_decomp_data_0x1d4fd[] = { 1, 0x74, };
+static const char32 __uni_decomp_data_0x1d4fe[] = { 1, 0x75, };
+static const char32 __uni_decomp_data_0x1d4ff[] = { 1, 0x76, };
 
 
 
@@ -18681,122 +18681,122 @@
 };
 
 
-static const char32 __uni_decomp_data_0x1d500[] = { 0x77, 0, };
-static const char32 __uni_decomp_data_0x1d501[] = { 0x78, 0, };
-static const char32 __uni_decomp_data_0x1d502[] = { 0x79, 0, };
-static const char32 __uni_decomp_data_0x1d503[] = { 0x7a, 0, };
-static const char32 __uni_decomp_data_0x1d504[] = { 0x41, 0, };
-static const char32 __uni_decomp_data_0x1d505[] = { 0x42, 0, };
-static const char32 __uni_decomp_data_0x1d507[] = { 0x44, 0, };
-static const char32 __uni_decomp_data_0x1d508[] = { 0x45, 0, };
-static const char32 __uni_decomp_data_0x1d509[] = { 0x46, 0, };
-static const char32 __uni_decomp_data_0x1d50a[] = { 0x47, 0, };
-static const char32 __uni_decomp_data_0x1d50d[] = { 0x4a, 0, };
-static const char32 __uni_decomp_data_0x1d50e[] = { 0x4b, 0, };
-static const char32 __uni_decomp_data_0x1d50f[] = { 0x4c, 0, };
-static const char32 __uni_decomp_data_0x1d510[] = { 0x4d, 0, };
-static const char32 __uni_decomp_data_0x1d511[] = { 0x4e, 0, };
-static const char32 __uni_decomp_data_0x1d512[] = { 0x4f, 0, };
-static const char32 __uni_decomp_data_0x1d513[] = { 0x50, 0, };
-static const char32 __uni_decomp_data_0x1d514[] = { 0x51, 0, };
-static const char32 __uni_decomp_data_0x1d516[] = { 0x53, 0, };
-static const char32 __uni_decomp_data_0x1d517[] = { 0x54, 0, };
-static const char32 __uni_decomp_data_0x1d518[] = { 0x55, 0, };
-static const char32 __uni_decomp_data_0x1d519[] = { 0x56, 0, };
-static const char32 __uni_decomp_data_0x1d51a[] = { 0x57, 0, };
-static const char32 __uni_decomp_data_0x1d51b[] = { 0x58, 0, };
-static const char32 __uni_decomp_data_0x1d51c[] = { 0x59, 0, };
-static const char32 __uni_decomp_data_0x1d51e[] = { 0x61, 0, };
-static const char32 __uni_decomp_data_0x1d51f[] = { 0x62, 0, };
-static const char32 __uni_decomp_data_0x1d520[] = { 0x63, 0, };
-static const char32 __uni_decomp_data_0x1d521[] = { 0x64, 0, };
-static const char32 __uni_decomp_data_0x1d522[] = { 0x65, 0, };
-static const char32 __uni_decomp_data_0x1d523[] = { 0x66, 0, };
-static const char32 __uni_decomp_data_0x1d524[] = { 0x67, 0, };
-static const char32 __uni_decomp_data_0x1d525[] = { 0x68, 0, };
-static const char32 __uni_decomp_data_0x1d526[] = { 0x69, 0, };
-static const char32 __uni_decomp_data_0x1d527[] = { 0x6a, 0, };
-static const char32 __uni_decomp_data_0x1d528[] = { 0x6b, 0, };
-static const char32 __uni_decomp_data_0x1d529[] = { 0x6c, 0, };
-static const char32 __uni_decomp_data_0x1d52a[] = { 0x6d, 0, };
-static const char32 __uni_decomp_data_0x1d52b[] = { 0x6e, 0, };
-static const char32 __uni_decomp_data_0x1d52c[] = { 0x6f, 0, };
-static const char32 __uni_decomp_data_0x1d52d[] = { 0x70, 0, };
-static const char32 __uni_decomp_data_0x1d52e[] = { 0x71, 0, };
-static const char32 __uni_decomp_data_0x1d52f[] = { 0x72, 0, };
-static const char32 __uni_decomp_data_0x1d530[] = { 0x73, 0, };
-static const char32 __uni_decomp_data_0x1d531[] = { 0x74, 0, };
-static const char32 __uni_decomp_data_0x1d532[] = { 0x75, 0, };
-static const char32 __uni_decomp_data_0x1d533[] = { 0x76, 0, };
-static const char32 __uni_decomp_data_0x1d534[] = { 0x77, 0, };
-static const char32 __uni_decomp_data_0x1d535[] = { 0x78, 0, };
-static const char32 __uni_decomp_data_0x1d536[] = { 0x79, 0, };
-static const char32 __uni_decomp_data_0x1d537[] = { 0x7a, 0, };
-static const char32 __uni_decomp_data_0x1d538[] = { 0x41, 0, };
-static const char32 __uni_decomp_data_0x1d539[] = { 0x42, 0, };
-static const char32 __uni_decomp_data_0x1d53b[] = { 0x44, 0, };
-static const char32 __uni_decomp_data_0x1d53c[] = { 0x45, 0, };
-static const char32 __uni_decomp_data_0x1d53d[] = { 0x46, 0, };
-static const char32 __uni_decomp_data_0x1d53e[] = { 0x47, 0, };
-static const char32 __uni_decomp_data_0x1d540[] = { 0x49, 0, };
-static const char32 __uni_decomp_data_0x1d541[] = { 0x4a, 0, };
-static const char32 __uni_decomp_data_0x1d542[] = { 0x4b, 0, };
-static const char32 __uni_decomp_data_0x1d543[] = { 0x4c, 0, };
-static const char32 __uni_decomp_data_0x1d544[] = { 0x4d, 0, };
-static const char32 __uni_decomp_data_0x1d546[] = { 0x4f, 0, };
-static const char32 __uni_decomp_data_0x1d54a[] = { 0x53, 0, };
-static const char32 __uni_decomp_data_0x1d54b[] = { 0x54, 0, };
-static const char32 __uni_decomp_data_0x1d54c[] = { 0x55, 0, };
-static const char32 __uni_decomp_data_0x1d54d[] = { 0x56, 0, };
-static const char32 __uni_decomp_data_0x1d54e[] = { 0x57, 0, };
-static const char32 __uni_decomp_data_0x1d54f[] = { 0x58, 0, };
-static const char32 __uni_decomp_data_0x1d550[] = { 0x59, 0, };
-static const char32 __uni_decomp_data_0x1d552[] = { 0x61, 0, };
-static const char32 __uni_decomp_data_0x1d553[] = { 0x62, 0, };
-static const char32 __uni_decomp_data_0x1d554[] = { 0x63, 0, };
-static const char32 __uni_decomp_data_0x1d555[] = { 0x64, 0, };
-static const char32 __uni_decomp_data_0x1d556[] = { 0x65, 0, };
-static const char32 __uni_decomp_data_0x1d557[] = { 0x66, 0, };
-static const char32 __uni_decomp_data_0x1d558[] = { 0x67, 0, };
-static const char32 __uni_decomp_data_0x1d559[] = { 0x68, 0, };
-static const char32 __uni_decomp_data_0x1d55a[] = { 0x69, 0, };
-static const char32 __uni_decomp_data_0x1d55b[] = { 0x6a, 0, };
-static const char32 __uni_decomp_data_0x1d55c[] = { 0x6b, 0, };
-static const char32 __uni_decomp_data_0x1d55d[] = { 0x6c, 0, };
-static const char32 __uni_decomp_data_0x1d55e[] = { 0x6d, 0, };
-static const char32 __uni_decomp_data_0x1d55f[] = { 0x6e, 0, };
-static const char32 __uni_decomp_data_0x1d560[] = { 0x6f, 0, };
-static const char32 __uni_decomp_data_0x1d561[] = { 0x70, 0, };
-static const char32 __uni_decomp_data_0x1d562[] = { 0x71, 0, };
-static const char32 __uni_decomp_data_0x1d563[] = { 0x72, 0, };
-static const char32 __uni_decomp_data_0x1d564[] = { 0x73, 0, };
-static const char32 __uni_decomp_data_0x1d565[] = { 0x74, 0, };
-static const char32 __uni_decomp_data_0x1d566[] = { 0x75, 0, };
-static const char32 __uni_decomp_data_0x1d567[] = { 0x76, 0, };
-static const char32 __uni_decomp_data_0x1d568[] = { 0x77, 0, };
-static const char32 __uni_decomp_data_0x1d569[] = { 0x78, 0, };
-static const char32 __uni_decomp_data_0x1d56a[] = { 0x79, 0, };
-static const char32 __uni_decomp_data_0x1d56b[] = { 0x7a, 0, };
-static const char32 __uni_decomp_data_0x1d56c[] = { 0x41, 0, };
-static const char32 __uni_decomp_data_0x1d56d[] = { 0x42, 0, };
-static const char32 __uni_decomp_data_0x1d56e[] = { 0x43, 0, };
-static const char32 __uni_decomp_data_0x1d56f[] = { 0x44, 0, };
-static const char32 __uni_decomp_data_0x1d570[] = { 0x45, 0, };
-static const char32 __uni_decomp_data_0x1d571[] = { 0x46, 0, };
-static const char32 __uni_decomp_data_0x1d572[] = { 0x47, 0, };
-static const char32 __uni_decomp_data_0x1d573[] = { 0x48, 0, };
-static const char32 __uni_decomp_data_0x1d574[] = { 0x49, 0, };
-static const char32 __uni_decomp_data_0x1d575[] = { 0x4a, 0, };
-static const char32 __uni_decomp_data_0x1d576[] = { 0x4b, 0, };
-static const char32 __uni_decomp_data_0x1d577[] = { 0x4c, 0, };
-static const char32 __uni_decomp_data_0x1d578[] = { 0x4d, 0, };
-static const char32 __uni_decomp_data_0x1d579[] = { 0x4e, 0, };
-static const char32 __uni_decomp_data_0x1d57a[] = { 0x4f, 0, };
-static const char32 __uni_decomp_data_0x1d57b[] = { 0x50, 0, };
-static const char32 __uni_decomp_data_0x1d57c[] = { 0x51, 0, };
-static const char32 __uni_decomp_data_0x1d57d[] = { 0x52, 0, };
-static const char32 __uni_decomp_data_0x1d57e[] = { 0x53, 0, };
-static const char32 __uni_decomp_data_0x1d57f[] = { 0x54, 0, };
+static const char32 __uni_decomp_data_0x1d500[] = { 1, 0x77, };
+static const char32 __uni_decomp_data_0x1d501[] = { 1, 0x78, };
+static const char32 __uni_decomp_data_0x1d502[] = { 1, 0x79, };
+static const char32 __uni_decomp_data_0x1d503[] = { 1, 0x7a, };
+static const char32 __uni_decomp_data_0x1d504[] = { 1, 0x41, };
+static const char32 __uni_decomp_data_0x1d505[] = { 1, 0x42, };
+static const char32 __uni_decomp_data_0x1d507[] = { 1, 0x44, };
+static const char32 __uni_decomp_data_0x1d508[] = { 1, 0x45, };
+static const char32 __uni_decomp_data_0x1d509[] = { 1, 0x46, };
+static const char32 __uni_decomp_data_0x1d50a[] = { 1, 0x47, };
+static const char32 __uni_decomp_data_0x1d50d[] = { 1, 0x4a, };
+static const char32 __uni_decomp_data_0x1d50e[] = { 1, 0x4b, };
+static const char32 __uni_decomp_data_0x1d50f[] = { 1, 0x4c, };
+static const char32 __uni_decomp_data_0x1d510[] = { 1, 0x4d, };
+static const char32 __uni_decomp_data_0x1d511[] = { 1, 0x4e, };
+static const char32 __uni_decomp_data_0x1d512[] = { 1, 0x4f, };
+static const char32 __uni_decomp_data_0x1d513[] = { 1, 0x50, };
+static const char32 __uni_decomp_data_0x1d514[] = { 1, 0x51, };
+static const char32 __uni_decomp_data_0x1d516[] = { 1, 0x53, };
+static const char32 __uni_decomp_data_0x1d517[] = { 1, 0x54, };
+static const char32 __uni_decomp_data_0x1d518[] = { 1, 0x55, };
+static const char32 __uni_decomp_data_0x1d519[] = { 1, 0x56, };
+static const char32 __uni_decomp_data_0x1d51a[] = { 1, 0x57, };
+static const char32 __uni_decomp_data_0x1d51b[] = { 1, 0x58, };
+static const char32 __uni_decomp_data_0x1d51c[] = { 1, 0x59, };
+static const char32 __uni_decomp_data_0x1d51e[] = { 1, 0x61, };
+static const char32 __uni_decomp_data_0x1d51f[] = { 1, 0x62, };
+static const char32 __uni_decomp_data_0x1d520[] = { 1, 0x63, };
+static const char32 __uni_decomp_data_0x1d521[] = { 1, 0x64, };
+static const char32 __uni_decomp_data_0x1d522[] = { 1, 0x65, };
+static const char32 __uni_decomp_data_0x1d523[] = { 1, 0x66, };
+static const char32 __uni_decomp_data_0x1d524[] = { 1, 0x67, };
+static const char32 __uni_decomp_data_0x1d525[] = { 1, 0x68, };
+static const char32 __uni_decomp_data_0x1d526[] = { 1, 0x69, };
+static const char32 __uni_decomp_data_0x1d527[] = { 1, 0x6a, };
+static const char32 __uni_decomp_data_0x1d528[] = { 1, 0x6b, };
+static const char32 __uni_decomp_data_0x1d529[] = { 1, 0x6c, };
+static const char32 __uni_decomp_data_0x1d52a[] = { 1, 0x6d, };
+static const char32 __uni_decomp_data_0x1d52b[] = { 1, 0x6e, };
+static const char32 __uni_decomp_data_0x1d52c[] = { 1, 0x6f, };
+static const char32 __uni_decomp_data_0x1d52d[] = { 1, 0x70, };
+static const char32 __uni_decomp_data_0x1d52e[] = { 1, 0x71, };
+static const char32 __uni_decomp_data_0x1d52f[] = { 1, 0x72, };
+static const char32 __uni_decomp_data_0x1d530[] = { 1, 0x73, };
+static const char32 __uni_decomp_data_0x1d531[] = { 1, 0x74, };
+static const char32 __uni_decomp_data_0x1d532[] = { 1, 0x75, };
+static const char32 __uni_decomp_data_0x1d533[] = { 1, 0x76, };
+static const char32 __uni_decomp_data_0x1d534[] = { 1, 0x77, };
+static const char32 __uni_decomp_data_0x1d535[] = { 1, 0x78, };
+static const char32 __uni_decomp_data_0x1d536[] = { 1, 0x79, };
+static const char32 __uni_decomp_data_0x1d537[] = { 1, 0x7a, };
+static const char32 __uni_decomp_data_0x1d538[] = { 1, 0x41, };
+static const char32 __uni_decomp_data_0x1d539[] = { 1, 0x42, };
+static const char32 __uni_decomp_data_0x1d53b[] = { 1, 0x44, };
+static const char32 __uni_decomp_data_0x1d53c[] = { 1, 0x45, };
+static const char32 __uni_decomp_data_0x1d53d[] = { 1, 0x46, };
+static const char32 __uni_decomp_data_0x1d53e[] = { 1, 0x47, };
+static const char32 __uni_decomp_data_0x1d540[] = { 1, 0x49, };
+static const char32 __uni_decomp_data_0x1d541[] = { 1, 0x4a, };
+static const char32 __uni_decomp_data_0x1d542[] = { 1, 0x4b, };
+static const char32 __uni_decomp_data_0x1d543[] = { 1, 0x4c, };
+static const char32 __uni_decomp_data_0x1d544[] = { 1, 0x4d, };
+static const char32 __uni_decomp_data_0x1d546[] = { 1, 0x4f, };
+static const char32 __uni_decomp_data_0x1d54a[] = { 1, 0x53, };
+static const char32 __uni_decomp_data_0x1d54b[] = { 1, 0x54, };
+static const char32 __uni_decomp_data_0x1d54c[] = { 1, 0x55, };
+static const char32 __uni_decomp_data_0x1d54d[] = { 1, 0x56, };
+static const char32 __uni_decomp_data_0x1d54e[] = { 1, 0x57, };
+static const char32 __uni_decomp_data_0x1d54f[] = { 1, 0x58, };
+static const char32 __uni_decomp_data_0x1d550[] = { 1, 0x59, };
+static const char32 __uni_decomp_data_0x1d552[] = { 1, 0x61, };
+static const char32 __uni_decomp_data_0x1d553[] = { 1, 0x62, };
+static const char32 __uni_decomp_data_0x1d554[] = { 1, 0x63, };
+static const char32 __uni_decomp_data_0x1d555[] = { 1, 0x64, };
+static const char32 __uni_decomp_data_0x1d556[] = { 1, 0x65, };
+static const char32 __uni_decomp_data_0x1d557[] = { 1, 0x66, };
+static const char32 __uni_decomp_data_0x1d558[] = { 1, 0x67, };
+static const char32 __uni_decomp_data_0x1d559[] = { 1, 0x68, };
+static const char32 __uni_decomp_data_0x1d55a[] = { 1, 0x69, };
+static const char32 __uni_decomp_data_0x1d55b[] = { 1, 0x6a, };
+static const char32 __uni_decomp_data_0x1d55c[] = { 1, 0x6b, };
+static const char32 __uni_decomp_data_0x1d55d[] = { 1, 0x6c, };
+static const char32 __uni_decomp_data_0x1d55e[] = { 1, 0x6d, };
+static const char32 __uni_decomp_data_0x1d55f[] = { 1, 0x6e, };
+static const char32 __uni_decomp_data_0x1d560[] = { 1, 0x6f, };
+static const char32 __uni_decomp_data_0x1d561[] = { 1, 0x70, };
+static const char32 __uni_decomp_data_0x1d562[] = { 1, 0x71, };
+static const char32 __uni_decomp_data_0x1d563[] = { 1, 0x72, };
+static const char32 __uni_decomp_data_0x1d564[] = { 1, 0x73, };
+static const char32 __uni_decomp_data_0x1d565[] = { 1, 0x74, };
+static const char32 __uni_decomp_data_0x1d566[] = { 1, 0x75, };
+static const char32 __uni_decomp_data_0x1d567[] = { 1, 0x76, };
+static const char32 __uni_decomp_data_0x1d568[] = { 1, 0x77, };
+static const char32 __uni_decomp_data_0x1d569[] = { 1, 0x78, };
+static const char32 __uni_decomp_data_0x1d56a[] = { 1, 0x79, };
+static const char32 __uni_decomp_data_0x1d56b[] = { 1, 0x7a, };
+static const char32 __uni_decomp_data_0x1d56c[] = { 1, 0x41, };
+static const char32 __uni_decomp_data_0x1d56d[] = { 1, 0x42, };
+static const char32 __uni_decomp_data_0x1d56e[] = { 1, 0x43, };
+static const char32 __uni_decomp_data_0x1d56f[] = { 1, 0x44, };
+static const char32 __uni_decomp_data_0x1d570[] = { 1, 0x45, };
+static const char32 __uni_decomp_data_0x1d571[] = { 1, 0x46, };
+static const char32 __uni_decomp_data_0x1d572[] = { 1, 0x47, };
+static const char32 __uni_decomp_data_0x1d573[] = { 1, 0x48, };
+static const char32 __uni_decomp_data_0x1d574[] = { 1, 0x49, };
+static const char32 __uni_decomp_data_0x1d575[] = { 1, 0x4a, };
+static const char32 __uni_decomp_data_0x1d576[] = { 1, 0x4b, };
+static const char32 __uni_decomp_data_0x1d577[] = { 1, 0x4c, };
+static const char32 __uni_decomp_data_0x1d578[] = { 1, 0x4d, };
+static const char32 __uni_decomp_data_0x1d579[] = { 1, 0x4e, };
+static const char32 __uni_decomp_data_0x1d57a[] = { 1, 0x4f, };
+static const char32 __uni_decomp_data_0x1d57b[] = { 1, 0x50, };
+static const char32 __uni_decomp_data_0x1d57c[] = { 1, 0x51, };
+static const char32 __uni_decomp_data_0x1d57d[] = { 1, 0x52, };
+static const char32 __uni_decomp_data_0x1d57e[] = { 1, 0x53, };
+static const char32 __uni_decomp_data_0x1d57f[] = { 1, 0x54, };
 
 
 
@@ -20470,134 +20470,134 @@
 };
 
 
-static const char32 __uni_decomp_data_0x1d580[] = { 0x55, 0, };
-static const char32 __uni_decomp_data_0x1d581[] = { 0x56, 0, };
-static const char32 __uni_decomp_data_0x1d582[] = { 0x57, 0, };
-static const char32 __uni_decomp_data_0x1d583[] = { 0x58, 0, };
-static const char32 __uni_decomp_data_0x1d584[] = { 0x59, 0, };
-static const char32 __uni_decomp_data_0x1d585[] = { 0x5a, 0, };
-static const char32 __uni_decomp_data_0x1d586[] = { 0x61, 0, };
-static const char32 __uni_decomp_data_0x1d587[] = { 0x62, 0, };
-static const char32 __uni_decomp_data_0x1d588[] = { 0x63, 0, };
-static const char32 __uni_decomp_data_0x1d589[] = { 0x64, 0, };
-static const char32 __uni_decomp_data_0x1d58a[] = { 0x65, 0, };
-static const char32 __uni_decomp_data_0x1d58b[] = { 0x66, 0, };
-static const char32 __uni_decomp_data_0x1d58c[] = { 0x67, 0, };
-static const char32 __uni_decomp_data_0x1d58d[] = { 0x68, 0, };
-static const char32 __uni_decomp_data_0x1d58e[] = { 0x69, 0, };
-static const char32 __uni_decomp_data_0x1d58f[] = { 0x6a, 0, };
-static const char32 __uni_decomp_data_0x1d590[] = { 0x6b, 0, };
-static const char32 __uni_decomp_data_0x1d591[] = { 0x6c, 0, };
-static const char32 __uni_decomp_data_0x1d592[] = { 0x6d, 0, };
-static const char32 __uni_decomp_data_0x1d593[] = { 0x6e, 0, };
-static const char32 __uni_decomp_data_0x1d594[] = { 0x6f, 0, };
-static const char32 __uni_decomp_data_0x1d595[] = { 0x70, 0, };
-static const char32 __uni_decomp_data_0x1d596[] = { 0x71, 0, };
-static const char32 __uni_decomp_data_0x1d597[] = { 0x72, 0, };
-static const char32 __uni_decomp_data_0x1d598[] = { 0x73, 0, };
-static const char32 __uni_decomp_data_0x1d599[] = { 0x74, 0, };
-static const char32 __uni_decomp_data_0x1d59a[] = { 0x75, 0, };
-static const char32 __uni_decomp_data_0x1d59b[] = { 0x76, 0, };
-static const char32 __uni_decomp_data_0x1d59c[] = { 0x77, 0, };
-static const char32 __uni_decomp_data_0x1d59d[] = { 0x78, 0, };
-static const char32 __uni_decomp_data_0x1d59e[] = { 0x79, 0, };
-static const char32 __uni_decomp_data_0x1d59f[] = { 0x7a, 0, };
-static const char32 __uni_decomp_data_0x1d5a0[] = { 0x41, 0, };
-static const char32 __uni_decomp_data_0x1d5a1[] = { 0x42, 0, };
-static const char32 __uni_decomp_data_0x1d5a2[] = { 0x43, 0, };
-static const char32 __uni_decomp_data_0x1d5a3[] = { 0x44, 0, };
-static const char32 __uni_decomp_data_0x1d5a4[] = { 0x45, 0, };
-static const char32 __uni_decomp_data_0x1d5a5[] = { 0x46, 0, };
-static const char32 __uni_decomp_data_0x1d5a6[] = { 0x47, 0, };
-static const char32 __uni_decomp_data_0x1d5a7[] = { 0x48, 0, };
-static const char32 __uni_decomp_data_0x1d5a8[] = { 0x49, 0, };
-static const char32 __uni_decomp_data_0x1d5a9[] = { 0x4a, 0, };
-static const char32 __uni_decomp_data_0x1d5aa[] = { 0x4b, 0, };
-static const char32 __uni_decomp_data_0x1d5ab[] = { 0x4c, 0, };
-static const char32 __uni_decomp_data_0x1d5ac[] = { 0x4d, 0, };
-static const char32 __uni_decomp_data_0x1d5ad[] = { 0x4e, 0, };
-static const char32 __uni_decomp_data_0x1d5ae[] = { 0x4f, 0, };
-static const char32 __uni_decomp_data_0x1d5af[] = { 0x50, 0, };
-static const char32 __uni_decomp_data_0x1d5b0[] = { 0x51, 0, };
-static const char32 __uni_decomp_data_0x1d5b1[] = { 0x52, 0, };
-static const char32 __uni_decomp_data_0x1d5b2[] = { 0x53, 0, };
-static const char32 __uni_decomp_data_0x1d5b3[] = { 0x54, 0, };
-static const char32 __uni_decomp_data_0x1d5b4[] = { 0x55, 0, };
-static const char32 __uni_decomp_data_0x1d5b5[] = { 0x56, 0, };
-static const char32 __uni_decomp_data_0x1d5b6[] = { 0x57, 0, };
-static const char32 __uni_decomp_data_0x1d5b7[] = { 0x58, 0, };
-static const char32 __uni_decomp_data_0x1d5b8[] = { 0x59, 0, };
-static const char32 __uni_decomp_data_0x1d5b9[] = { 0x5a, 0, };
-static const char32 __uni_decomp_data_0x1d5ba[] = { 0x61, 0, };
-static const char32 __uni_decomp_data_0x1d5bb[] = { 0x62, 0, };
-static const char32 __uni_decomp_data_0x1d5bc[] = { 0x63, 0, };
-static const char32 __uni_decomp_data_0x1d5bd[] = { 0x64, 0, };
-static const char32 __uni_decomp_data_0x1d5be[] = { 0x65, 0, };
-static const char32 __uni_decomp_data_0x1d5bf[] = { 0x66, 0, };
-static const char32 __uni_decomp_data_0x1d5c0[] = { 0x67, 0, };
-static const char32 __uni_decomp_data_0x1d5c1[] = { 0x68, 0, };
-static const char32 __uni_decomp_data_0x1d5c2[] = { 0x69, 0, };
-static const char32 __uni_decomp_data_0x1d5c3[] = { 0x6a, 0, };
-static const char32 __uni_decomp_data_0x1d5c4[] = { 0x6b, 0, };
-static const char32 __uni_decomp_data_0x1d5c5[] = { 0x6c, 0, };
-static const char32 __uni_decomp_data_0x1d5c6[] = { 0x6d, 0, };
-static const char32 __uni_decomp_data_0x1d5c7[] = { 0x6e, 0, };
-static const char32 __uni_decomp_data_0x1d5c8[] = { 0x6f, 0, };
-static const char32 __uni_decomp_data_0x1d5c9[] = { 0x70, 0, };
-static const char32 __uni_decomp_data_0x1d5ca[] = { 0x71, 0, };
-static const char32 __uni_decomp_data_0x1d5cb[] = { 0x72, 0, };
-static const char32 __uni_decomp_data_0x1d5cc[] = { 0x73, 0, };
-static const char32 __uni_decomp_data_0x1d5cd[] = { 0x74, 0, };
-static const char32 __uni_decomp_data_0x1d5ce[] = { 0x75, 0, };
-static const char32 __uni_decomp_data_0x1d5cf[] = { 0x76, 0, };
-static const char32 __uni_decomp_data_0x1d5d0[] = { 0x77, 0, };
-static const char32 __uni_decomp_data_0x1d5d1[] = { 0x78, 0, };
-static const char32 __uni_decomp_data_0x1d5d2[] = { 0x79, 0, };
-static const char32 __uni_decomp_data_0x1d5d3[] = { 0x7a, 0, };
-static const char32 __uni_decomp_data_0x1d5d4[] = { 0x41, 0, };
-static const char32 __uni_decomp_data_0x1d5d5[] = { 0x42, 0, };
-static const char32 __uni_decomp_data_0x1d5d6[] = { 0x43, 0, };
-static const char32 __uni_decomp_data_0x1d5d7[] = { 0x44, 0, };
-static const char32 __uni_decomp_data_0x1d5d8[] = { 0x45, 0, };
-static const char32 __uni_decomp_data_0x1d5d9[] = { 0x46, 0, };
-static const char32 __uni_decomp_data_0x1d5da[] = { 0x47, 0, };
-static const char32 __uni_decomp_data_0x1d5db[] = { 0x48, 0, };
-static const char32 __uni_decomp_data_0x1d5dc[] = { 0x49, 0, };
-static const char32 __uni_decomp_data_0x1d5dd[] = { 0x4a, 0, };
-static const char32 __uni_decomp_data_0x1d5de[] = { 0x4b, 0, };
-static const char32 __uni_decomp_data_0x1d5df[] = { 0x4c, 0, };
-static const char32 __uni_decomp_data_0x1d5e0[] = { 0x4d, 0, };
-static const char32 __uni_decomp_data_0x1d5e1[] = { 0x4e, 0, };
-static const char32 __uni_decomp_data_0x1d5e2[] = { 0x4f, 0, };
-static const char32 __uni_decomp_data_0x1d5e3[] = { 0x50, 0, };
-static const char32 __uni_decomp_data_0x1d5e4[] = { 0x51, 0, };
-static const char32 __uni_decomp_data_0x1d5e5[] = { 0x52, 0, };
-static const char32 __uni_decomp_data_0x1d5e6[] = { 0x53, 0, };
-static const char32 __uni_decomp_data_0x1d5e7[] = { 0x54, 0, };
-static const char32 __uni_decomp_data_0x1d5e8[] = { 0x55, 0, };
-static const char32 __uni_decomp_data_0x1d5e9[] = { 0x56, 0, };
-static const char32 __uni_decomp_data_0x1d5ea[] = { 0x57, 0, };
-static const char32 __uni_decomp_data_0x1d5eb[] = { 0x58, 0, };
-static const char32 __uni_decomp_data_0x1d5ec[] = { 0x59, 0, };
-static const char32 __uni_decomp_data_0x1d5ed[] = { 0x5a, 0, };
-static const char32 __uni_decomp_data_0x1d5ee[] = { 0x61, 0, };
-static const char32 __uni_decomp_data_0x1d5ef[] = { 0x62, 0, };
-static const char32 __uni_decomp_data_0x1d5f0[] = { 0x63, 0, };
-static const char32 __uni_decomp_data_0x1d5f1[] = { 0x64, 0, };
-static const char32 __uni_decomp_data_0x1d5f2[] = { 0x65, 0, };
-static const char32 __uni_decomp_data_0x1d5f3[] = { 0x66, 0, };
-static const char32 __uni_decomp_data_0x1d5f4[] = { 0x67, 0, };
-static const char32 __uni_decomp_data_0x1d5f5[] = { 0x68, 0, };
-static const char32 __uni_decomp_data_0x1d5f6[] = { 0x69, 0, };
-static const char32 __uni_decomp_data_0x1d5f7[] = { 0x6a, 0, };
-static const char32 __uni_decomp_data_0x1d5f8[] = { 0x6b, 0, };
-static const char32 __uni_decomp_data_0x1d5f9[] = { 0x6c, 0, };
-static const char32 __uni_decomp_data_0x1d5fa[] = { 0x6d, 0, };
-static const char32 __uni_decomp_data_0x1d5fb[] = { 0x6e, 0, };
-static const char32 __uni_decomp_data_0x1d5fc[] = { 0x6f, 0, };
-static const char32 __uni_decomp_data_0x1d5fd[] = { 0x70, 0, };
-static const char32 __uni_decomp_data_0x1d5fe[] = { 0x71, 0, };
-static const char32 __uni_decomp_data_0x1d5ff[] = { 0x72, 0, };
+static const char32 __uni_decomp_data_0x1d580[] = { 1, 0x55, };
+static const char32 __uni_decomp_data_0x1d581[] = { 1, 0x56, };
+static const char32 __uni_decomp_data_0x1d582[] = { 1, 0x57, };
+static const char32 __uni_decomp_data_0x1d583[] = { 1, 0x58, };
+static const char32 __uni_decomp_data_0x1d584[] = { 1, 0x59, };
+static const char32 __uni_decomp_data_0x1d585[] = { 1, 0x5a, };
+static const char32 __uni_decomp_data_0x1d586[] = { 1, 0x61, };
+static const char32 __uni_decomp_data_0x1d587[] = { 1, 0x62, };
+static const char32 __uni_decomp_data_0x1d588[] = { 1, 0x63, };
+static const char32 __uni_decomp_data_0x1d589[] = { 1, 0x64, };
+static const char32 __uni_decomp_data_0x1d58a[] = { 1, 0x65, };
+static const char32 __uni_decomp_data_0x1d58b[] = { 1, 0x66, };
+static const char32 __uni_decomp_data_0x1d58c[] = { 1, 0x67, };
+static const char32 __uni_decomp_data_0x1d58d[] = { 1, 0x68, };
+static const char32 __uni_decomp_data_0x1d58e[] = { 1, 0x69, };
+static const char32 __uni_decomp_data_0x1d58f[] = { 1, 0x6a, };
+static const char32 __uni_decomp_data_0x1d590[] = { 1, 0x6b, };
+static const char32 __uni_decomp_data_0x1d591[] = { 1, 0x6c, };
+static const char32 __uni_decomp_data_0x1d592[] = { 1, 0x6d, };
+static const char32 __uni_decomp_data_0x1d593[] = { 1, 0x6e, };
+static const char32 __uni_decomp_data_0x1d594[] = { 1, 0x6f, };
+static const char32 __uni_decomp_data_0x1d595[] = { 1, 0x70, };
+static const char32 __uni_decomp_data_0x1d596[] = { 1, 0x71, };
+static const char32 __uni_decomp_data_0x1d597[] = { 1, 0x72, };
+static const char32 __uni_decomp_data_0x1d598[] = { 1, 0x73, };
+static const char32 __uni_decomp_data_0x1d599[] = { 1, 0x74, };
+static const char32 __uni_decomp_data_0x1d59a[] = { 1, 0x75, };
+static const char32 __uni_decomp_data_0x1d59b[] = { 1, 0x76, };
+static const char32 __uni_decomp_data_0x1d59c[] = { 1, 0x77, };
+static const char32 __uni_decomp_data_0x1d59d[] = { 1, 0x78, };
+static const char32 __uni_decomp_data_0x1d59e[] = { 1, 0x79, };
+static const char32 __uni_decomp_data_0x1d59f[] = { 1, 0x7a, };
+static const char32 __uni_decomp_data_0x1d5a0[] = { 1, 0x41, };
+static const char32 __uni_decomp_data_0x1d5a1[] = { 1, 0x42, };
+static const char32 __uni_decomp_data_0x1d5a2[] = { 1, 0x43, };
+static const char32 __uni_decomp_data_0x1d5a3[] = { 1, 0x44, };
+static const char32 __uni_decomp_data_0x1d5a4[] = { 1, 0x45, };
+static const char32 __uni_decomp_data_0x1d5a5[] = { 1, 0x46, };
+static const char32 __uni_decomp_data_0x1d5a6[] = { 1, 0x47, };
+static const char32 __uni_decomp_data_0x1d5a7[] = { 1, 0x48, };
+static const char32 __uni_decomp_data_0x1d5a8[] = { 1, 0x49, };
+static const char32 __uni_decomp_data_0x1d5a9[] = { 1, 0x4a, };
+static const char32 __uni_decomp_data_0x1d5aa[] = { 1, 0x4b, };
+static const char32 __uni_decomp_data_0x1d5ab[] = { 1, 0x4c, };
+static const char32 __uni_decomp_data_0x1d5ac[] = { 1, 0x4d, };
+static const char32 __uni_decomp_data_0x1d5ad[] = { 1, 0x4e, };
+static const char32 __uni_decomp_data_0x1d5ae[] = { 1, 0x4f, };
+static const char32 __uni_decomp_data_0x1d5af[] = { 1, 0x50, };
+static const char32 __uni_decomp_data_0x1d5b0[] = { 1, 0x51, };
+static const char32 __uni_decomp_data_0x1d5b1[] = { 1, 0x52, };
+static const char32 __uni_decomp_data_0x1d5b2[] = { 1, 0x53, };
+static const char32 __uni_decomp_data_0x1d5b3[] = { 1, 0x54, };
+static const char32 __uni_decomp_data_0x1d5b4[] = { 1, 0x55, };
+static const char32 __uni_decomp_data_0x1d5b5[] = { 1, 0x56, };
+static const char32 __uni_decomp_data_0x1d5b6[] = { 1, 0x57, };
+static const char32 __uni_decomp_data_0x1d5b7[] = { 1, 0x58, };
+static const char32 __uni_decomp_data_0x1d5b8[] = { 1, 0x59, };
+static const char32 __uni_decomp_data_0x1d5b9[] = { 1, 0x5a, };
+static const char32 __uni_decomp_data_0x1d5ba[] = { 1, 0x61, };
+static const char32 __uni_decomp_data_0x1d5bb[] = { 1, 0x62, };
+static const char32 __uni_decomp_data_0x1d5bc[] = { 1, 0x63, };
+static const char32 __uni_decomp_data_0x1d5bd[] = { 1, 0x64, };
+static const char32 __uni_decomp_data_0x1d5be[] = { 1, 0x65, };
+static const char32 __uni_decomp_data_0x1d5bf[] = { 1, 0x66, };
+static const char32 __uni_decomp_data_0x1d5c0[] = { 1, 0x67, };
+static const char32 __uni_decomp_data_0x1d5c1[] = { 1, 0x68, };
+static const char32 __uni_decomp_data_0x1d5c2[] = { 1, 0x69, };
+static const char32 __uni_decomp_data_0x1d5c3[] = { 1, 0x6a, };
+static const char32 __uni_decomp_data_0x1d5c4[] = { 1, 0x6b, };
+static const char32 __uni_decomp_data_0x1d5c5[] = { 1, 0x6c, };
+static const char32 __uni_decomp_data_0x1d5c6[] = { 1, 0x6d, };
+static const char32 __uni_decomp_data_0x1d5c7[] = { 1, 0x6e, };
+static const char32 __uni_decomp_data_0x1d5c8[] = { 1, 0x6f, };
+static const char32 __uni_decomp_data_0x1d5c9[] = { 1, 0x70, };
+static const char32 __uni_decomp_data_0x1d5ca[] = { 1, 0x71, };
+static const char32 __uni_decomp_data_0x1d5cb[] = { 1, 0x72, };
+static const char32 __uni_decomp_data_0x1d5cc[] = { 1, 0x73, };
+static const char32 __uni_decomp_data_0x1d5cd[] = { 1, 0x74, };
+static const char32 __uni_decomp_data_0x1d5ce[] = { 1, 0x75, };
+static const char32 __uni_decomp_data_0x1d5cf[] = { 1, 0x76, };
+static const char32 __uni_decomp_data_0x1d5d0[] = { 1, 0x77, };
+static const char32 __uni_decomp_data_0x1d5d1[] = { 1, 0x78, };
+static const char32 __uni_decomp_data_0x1d5d2[] = { 1, 0x79, };
+static const char32 __uni_decomp_data_0x1d5d3[] = { 1, 0x7a, };
+static const char32 __uni_decomp_data_0x1d5d4[] = { 1, 0x41, };
+static const char32 __uni_decomp_data_0x1d5d5[] = { 1, 0x42, };
+static const char32 __uni_decomp_data_0x1d5d6[] = { 1, 0x43, };
+static const char32 __uni_decomp_data_0x1d5d7[] = { 1, 0x44, };
+static const char32 __uni_decomp_data_0x1d5d8[] = { 1, 0x45, };
+static const char32 __uni_decomp_data_0x1d5d9[] = { 1, 0x46, };
+static const char32 __uni_decomp_data_0x1d5da[] = { 1, 0x47, };
+static const char32 __uni_decomp_data_0x1d5db[] = { 1, 0x48, };
+static const char32 __uni_decomp_data_0x1d5dc[] = { 1, 0x49, };
+static const char32 __uni_decomp_data_0x1d5dd[] = { 1, 0x4a, };
+static const char32 __uni_decomp_data_0x1d5de[] = { 1, 0x4b, };
+static const char32 __uni_decomp_data_0x1d5df[] = { 1, 0x4c, };
+static const char32 __uni_decomp_data_0x1d5e0[] = { 1, 0x4d, };
+static const char32 __uni_decomp_data_0x1d5e1[] = { 1, 0x4e, };
+static const char32 __uni_decomp_data_0x1d5e2[] = { 1, 0x4f, };
+static const char32 __uni_decomp_data_0x1d5e3[] = { 1, 0x50, };
+static const char32 __uni_decomp_data_0x1d5e4[] = { 1, 0x51, };
+static const char32 __uni_decomp_data_0x1d5e5[] = { 1, 0x52, };
+static const char32 __uni_decomp_data_0x1d5e6[] = { 1, 0x53, };
+static const char32 __uni_decomp_data_0x1d5e7[] = { 1, 0x54, };
+static const char32 __uni_decomp_data_0x1d5e8[] = { 1, 0x55, };
+static const char32 __uni_decomp_data_0x1d5e9[] = { 1, 0x56, };
+static const char32 __uni_decomp_data_0x1d5ea[] = { 1, 0x57, };
+static const char32 __uni_decomp_data_0x1d5eb[] = { 1, 0x58, };
+static const char32 __uni_decomp_data_0x1d5ec[] = { 1, 0x59, };
+static const char32 __uni_decomp_data_0x1d5ed[] = { 1, 0x5a, };
+static const char32 __uni_decomp_data_0x1d5ee[] = { 1, 0x61, };
+static const char32 __uni_decomp_data_0x1d5ef[] = { 1, 0x62, };
+static const char32 __uni_decomp_data_0x1d5f0[] = { 1, 0x63, };
+static const char32 __uni_decomp_data_0x1d5f1[] = { 1, 0x64, };
+static const char32 __uni_decomp_data_0x1d5f2[] = { 1, 0x65, };
+static const char32 __uni_decomp_data_0x1d5f3[] = { 1, 0x66, };
+static const char32 __uni_decomp_data_0x1d5f4[] = { 1, 0x67, };
+static const char32 __uni_decomp_data_0x1d5f5[] = { 1, 0x68, };
+static const char32 __uni_decomp_data_0x1d5f6[] = { 1, 0x69, };
+static const char32 __uni_decomp_data_0x1d5f7[] = { 1, 0x6a, };
+static const char32 __uni_decomp_data_0x1d5f8[] = { 1, 0x6b, };
+static const char32 __uni_decomp_data_0x1d5f9[] = { 1, 0x6c, };
+static const char32 __uni_decomp_data_0x1d5fa[] = { 1, 0x6d, };
+static const char32 __uni_decomp_data_0x1d5fb[] = { 1, 0x6e, };
+static const char32 __uni_decomp_data_0x1d5fc[] = { 1, 0x6f, };
+static const char32 __uni_decomp_data_0x1d5fd[] = { 1, 0x70, };
+static const char32 __uni_decomp_data_0x1d5fe[] = { 1, 0x71, };
+static const char32 __uni_decomp_data_0x1d5ff[] = { 1, 0x72, };
 
 
 
@@ -22271,134 +22271,134 @@
 };
 
 
-static const char32 __uni_decomp_data_0x1d600[] = { 0x73, 0, };
-static const char32 __uni_decomp_data_0x1d601[] = { 0x74, 0, };
-static const char32 __uni_decomp_data_0x1d602[] = { 0x75, 0, };
-static const char32 __uni_decomp_data_0x1d603[] = { 0x76, 0, };
-static const char32 __uni_decomp_data_0x1d604[] = { 0x77, 0, };
-static const char32 __uni_decomp_data_0x1d605[] = { 0x78, 0, };
-static const char32 __uni_decomp_data_0x1d606[] = { 0x79, 0, };
-static const char32 __uni_decomp_data_0x1d607[] = { 0x7a, 0, };
-static const char32 __uni_decomp_data_0x1d608[] = { 0x41, 0, };
-static const char32 __uni_decomp_data_0x1d609[] = { 0x42, 0, };
-static const char32 __uni_decomp_data_0x1d60a[] = { 0x43, 0, };
-static const char32 __uni_decomp_data_0x1d60b[] = { 0x44, 0, };
-static const char32 __uni_decomp_data_0x1d60c[] = { 0x45, 0, };
-static const char32 __uni_decomp_data_0x1d60d[] = { 0x46, 0, };
-static const char32 __uni_decomp_data_0x1d60e[] = { 0x47, 0, };
-static const char32 __uni_decomp_data_0x1d60f[] = { 0x48, 0, };
-static const char32 __uni_decomp_data_0x1d610[] = { 0x49, 0, };
-static const char32 __uni_decomp_data_0x1d611[] = { 0x4a, 0, };
-static const char32 __uni_decomp_data_0x1d612[] = { 0x4b, 0, };
-static const char32 __uni_decomp_data_0x1d613[] = { 0x4c, 0, };
-static const char32 __uni_decomp_data_0x1d614[] = { 0x4d, 0, };
-static const char32 __uni_decomp_data_0x1d615[] = { 0x4e, 0, };
-static const char32 __uni_decomp_data_0x1d616[] = { 0x4f, 0, };
-static const char32 __uni_decomp_data_0x1d617[] = { 0x50, 0, };
-static const char32 __uni_decomp_data_0x1d618[] = { 0x51, 0, };
-static const char32 __uni_decomp_data_0x1d619[] = { 0x52, 0, };
-static const char32 __uni_decomp_data_0x1d61a[] = { 0x53, 0, };
-static const char32 __uni_decomp_data_0x1d61b[] = { 0x54, 0, };
-static const char32 __uni_decomp_data_0x1d61c[] = { 0x55, 0, };
-static const char32 __uni_decomp_data_0x1d61d[] = { 0x56, 0, };
-static const char32 __uni_decomp_data_0x1d61e[] = { 0x57, 0, };
-static const char32 __uni_decomp_data_0x1d61f[] = { 0x58, 0, };
-static const char32 __uni_decomp_data_0x1d620[] = { 0x59, 0, };
-static const char32 __uni_decomp_data_0x1d621[] = { 0x5a, 0, };
-static const char32 __uni_decomp_data_0x1d622[] = { 0x61, 0, };
-static const char32 __uni_decomp_data_0x1d623[] = { 0x62, 0, };
-static const char32 __uni_decomp_data_0x1d624[] = { 0x63, 0, };
-static const char32 __uni_decomp_data_0x1d625[] = { 0x64, 0, };
-static const char32 __uni_decomp_data_0x1d626[] = { 0x65, 0, };
-static const char32 __uni_decomp_data_0x1d627[] = { 0x66, 0, };
-static const char32 __uni_decomp_data_0x1d628[] = { 0x67, 0, };
-static const char32 __uni_decomp_data_0x1d629[] = { 0x68, 0, };
-static const char32 __uni_decomp_data_0x1d62a[] = { 0x69, 0, };
-static const char32 __uni_decomp_data_0x1d62b[] = { 0x6a, 0, };
-static const char32 __uni_decomp_data_0x1d62c[] = { 0x6b, 0, };
-static const char32 __uni_decomp_data_0x1d62d[] = { 0x6c, 0, };
-static const char32 __uni_decomp_data_0x1d62e[] = { 0x6d, 0, };
-static const char32 __uni_decomp_data_0x1d62f[] = { 0x6e, 0, };
-static const char32 __uni_decomp_data_0x1d630[] = { 0x6f, 0, };
-static const char32 __uni_decomp_data_0x1d631[] = { 0x70, 0, };
-static const char32 __uni_decomp_data_0x1d632[] = { 0x71, 0, };
-static const char32 __uni_decomp_data_0x1d633[] = { 0x72, 0, };
-static const char32 __uni_decomp_data_0x1d634[] = { 0x73, 0, };
-static const char32 __uni_decomp_data_0x1d635[] = { 0x74, 0, };
-static const char32 __uni_decomp_data_0x1d636[] = { 0x75, 0, };
-static const char32 __uni_decomp_data_0x1d637[] = { 0x76, 0, };
-static const char32 __uni_decomp_data_0x1d638[] = { 0x77, 0, };
-static const char32 __uni_decomp_data_0x1d639[] = { 0x78, 0, };
-static const char32 __uni_decomp_data_0x1d63a[] = { 0x79, 0, };
-static const char32 __uni_decomp_data_0x1d63b[] = { 0x7a, 0, };
-static const char32 __uni_decomp_data_0x1d63c[] = { 0x41, 0, };
-static const char32 __uni_decomp_data_0x1d63d[] = { 0x42, 0, };
-static const char32 __uni_decomp_data_0x1d63e[] = { 0x43, 0, };
-static const char32 __uni_decomp_data_0x1d63f[] = { 0x44, 0, };
-static const char32 __uni_decomp_data_0x1d640[] = { 0x45, 0, };
-static const char32 __uni_decomp_data_0x1d641[] = { 0x46, 0, };
-static const char32 __uni_decomp_data_0x1d642[] = { 0x47, 0, };
-static const char32 __uni_decomp_data_0x1d643[] = { 0x48, 0, };
-static const char32 __uni_decomp_data_0x1d644[] = { 0x49, 0, };
-static const char32 __uni_decomp_data_0x1d645[] = { 0x4a, 0, };
-static const char32 __uni_decomp_data_0x1d646[] = { 0x4b, 0, };
-static const char32 __uni_decomp_data_0x1d647[] = { 0x4c, 0, };
-static const char32 __uni_decomp_data_0x1d648[] = { 0x4d, 0, };
-static const char32 __uni_decomp_data_0x1d649[] = { 0x4e, 0, };
-static const char32 __uni_decomp_data_0x1d64a[] = { 0x4f, 0, };
-static const char32 __uni_decomp_data_0x1d64b[] = { 0x50, 0, };
-static const char32 __uni_decomp_data_0x1d64c[] = { 0x51, 0, };
-static const char32 __uni_decomp_data_0x1d64d[] = { 0x52, 0, };
-static const char32 __uni_decomp_data_0x1d64e[] = { 0x53, 0, };
-static const char32 __uni_decomp_data_0x1d64f[] = { 0x54, 0, };
-static const char32 __uni_decomp_data_0x1d650[] = { 0x55, 0, };
-static const char32 __uni_decomp_data_0x1d651[] = { 0x56, 0, };
-static const char32 __uni_decomp_data_0x1d652[] = { 0x57, 0, };
-static const char32 __uni_decomp_data_0x1d653[] = { 0x58, 0, };
-static const char32 __uni_decomp_data_0x1d654[] = { 0x59, 0, };
-static const char32 __uni_decomp_data_0x1d655[] = { 0x5a, 0, };
-static const char32 __uni_decomp_data_0x1d656[] = { 0x61, 0, };
-static const char32 __uni_decomp_data_0x1d657[] = { 0x62, 0, };
-static const char32 __uni_decomp_data_0x1d658[] = { 0x63, 0, };
-static const char32 __uni_decomp_data_0x1d659[] = { 0x64, 0, };
-static const char32 __uni_decomp_data_0x1d65a[] = { 0x65, 0, };
-static const char32 __uni_decomp_data_0x1d65b[] = { 0x66, 0, };
-static const char32 __uni_decomp_data_0x1d65c[] = { 0x67, 0, };
-static const char32 __uni_decomp_data_0x1d65d[] = { 0x68, 0, };
-static const char32 __uni_decomp_data_0x1d65e[] = { 0x69, 0, };
-static const char32 __uni_decomp_data_0x1d65f[] = { 0x6a, 0, };
-static const char32 __uni_decomp_data_0x1d660[] = { 0x6b, 0, };
-static const char32 __uni_decomp_data_0x1d661[] = { 0x6c, 0, };
-static const char32 __uni_decomp_data_0x1d662[] = { 0x6d, 0, };
-static const char32 __uni_decomp_data_0x1d663[] = { 0x6e, 0, };
-static const char32 __uni_decomp_data_0x1d664[] = { 0x6f, 0, };
-static const char32 __uni_decomp_data_0x1d665[] = { 0x70, 0, };
-static const char32 __uni_decomp_data_0x1d666[] = { 0x71, 0, };
-static const char32 __uni_decomp_data_0x1d667[] = { 0x72, 0, };
-static const char32 __uni_decomp_data_0x1d668[] = { 0x73, 0, };
-static const char32 __uni_decomp_data_0x1d669[] = { 0x74, 0, };
-static const char32 __uni_decomp_data_0x1d66a[] = { 0x75, 0, };
-static const char32 __uni_decomp_data_0x1d66b[] = { 0x76, 0, };
-static const char32 __uni_decomp_data_0x1d66c[] = { 0x77, 0, };
-static const char32 __uni_decomp_data_0x1d66d[] = { 0x78, 0, };
-static const char32 __uni_decomp_data_0x1d66e[] = { 0x79, 0, };
-static const char32 __uni_decomp_data_0x1d66f[] = { 0x7a, 0, };
-static const char32 __uni_decomp_data_0x1d670[] = { 0x41, 0, };
-static const char32 __uni_decomp_data_0x1d671[] = { 0x42, 0, };
-static const char32 __uni_decomp_data_0x1d672[] = { 0x43, 0, };
-static const char32 __uni_decomp_data_0x1d673[] = { 0x44, 0, };
-static const char32 __uni_decomp_data_0x1d674[] = { 0x45, 0, };
-static const char32 __uni_decomp_data_0x1d675[] = { 0x46, 0, };
-static const char32 __uni_decomp_data_0x1d676[] = { 0x47, 0, };
-static const char32 __uni_decomp_data_0x1d677[] = { 0x48, 0, };
-static const char32 __uni_decomp_data_0x1d678[] = { 0x49, 0, };
-static const char32 __uni_decomp_data_0x1d679[] = { 0x4a, 0, };
-static const char32 __uni_decomp_data_0x1d67a[] = { 0x4b, 0, };
-static const char32 __uni_decomp_data_0x1d67b[] = { 0x4c, 0, };
-static const char32 __uni_decomp_data_0x1d67c[] = { 0x4d, 0, };
-static const char32 __uni_decomp_data_0x1d67d[] = { 0x4e, 0, };
-static const char32 __uni_decomp_data_0x1d67e[] = { 0x4f, 0, };
-static const char32 __uni_decomp_data_0x1d67f[] = { 0x50, 0, };
+static const char32 __uni_decomp_data_0x1d600[] = { 1, 0x73, };
+static const char32 __uni_decomp_data_0x1d601[] = { 1, 0x74, };
+static const char32 __uni_decomp_data_0x1d602[] = { 1, 0x75, };
+static const char32 __uni_decomp_data_0x1d603[] = { 1, 0x76, };
+static const char32 __uni_decomp_data_0x1d604[] = { 1, 0x77, };
+static const char32 __uni_decomp_data_0x1d605[] = { 1, 0x78, };
+static const char32 __uni_decomp_data_0x1d606[] = { 1, 0x79, };
+static const char32 __uni_decomp_data_0x1d607[] = { 1, 0x7a, };
+static const char32 __uni_decomp_data_0x1d608[] = { 1, 0x41, };
+static const char32 __uni_decomp_data_0x1d609[] = { 1, 0x42, };
+static const char32 __uni_decomp_data_0x1d60a[] = { 1, 0x43, };
+static const char32 __uni_decomp_data_0x1d60b[] = { 1, 0x44, };
+static const char32 __uni_decomp_data_0x1d60c[] = { 1, 0x45, };
+static const char32 __uni_decomp_data_0x1d60d[] = { 1, 0x46, };
+static const char32 __uni_decomp_data_0x1d60e[] = { 1, 0x47, };
+static const char32 __uni_decomp_data_0x1d60f[] = { 1, 0x48, };
+static const char32 __uni_decomp_data_0x1d610[] = { 1, 0x49, };
+static const char32 __uni_decomp_data_0x1d611[] = { 1, 0x4a, };
+static const char32 __uni_decomp_data_0x1d612[] = { 1, 0x4b, };
+static const char32 __uni_decomp_data_0x1d613[] = { 1, 0x4c, };
+static const char32 __uni_decomp_data_0x1d614[] = { 1, 0x4d, };
+static const char32 __uni_decomp_data_0x1d615[] = { 1, 0x4e, };
+static const char32 __uni_decomp_data_0x1d616[] = { 1, 0x4f, };
+static const char32 __uni_decomp_data_0x1d617[] = { 1, 0x50, };
+static const char32 __uni_decomp_data_0x1d618[] = { 1, 0x51, };
+static const char32 __uni_decomp_data_0x1d619[] = { 1, 0x52, };
+static const char32 __uni_decomp_data_0x1d61a[] = { 1, 0x53, };
+static const char32 __uni_decomp_data_0x1d61b[] = { 1, 0x54, };
+static const char32 __uni_decomp_data_0x1d61c[] = { 1, 0x55, };
+static const char32 __uni_decomp_data_0x1d61d[] = { 1, 0x56, };
+static const char32 __uni_decomp_data_0x1d61e[] = { 1, 0x57, };
+static const char32 __uni_decomp_data_0x1d61f[] = { 1, 0x58, };
+static const char32 __uni_decomp_data_0x1d620[] = { 1, 0x59, };
+static const char32 __uni_decomp_data_0x1d621[] = { 1, 0x5a, };
+static const char32 __uni_decomp_data_0x1d622[] = { 1, 0x61, };
+static const char32 __uni_decomp_data_0x1d623[] = { 1, 0x62, };
+static const char32 __uni_decomp_data_0x1d624[] = { 1, 0x63, };
+static const char32 __uni_decomp_data_0x1d625[] = { 1, 0x64, };
+static const char32 __uni_decomp_data_0x1d626[] = { 1, 0x65, };
+static const char32 __uni_decomp_data_0x1d627[] = { 1, 0x66, };
+static const char32 __uni_decomp_data_0x1d628[] = { 1, 0x67, };
+static const char32 __uni_decomp_data_0x1d629[] = { 1, 0x68, };
+static const char32 __uni_decomp_data_0x1d62a[] = { 1, 0x69, };
+static const char32 __uni_decomp_data_0x1d62b[] = { 1, 0x6a, };
+static const char32 __uni_decomp_data_0x1d62c[] = { 1, 0x6b, };
+static const char32 __uni_decomp_data_0x1d62d[] = { 1, 0x6c, };
+static const char32 __uni_decomp_data_0x1d62e[] = { 1, 0x6d, };
+static const char32 __uni_decomp_data_0x1d62f[] = { 1, 0x6e, };
+static const char32 __uni_decomp_data_0x1d630[] = { 1, 0x6f, };
+static const char32 __uni_decomp_data_0x1d631[] = { 1, 0x70, };
+static const char32 __uni_decomp_data_0x1d632[] = { 1, 0x71, };
+static const char32 __uni_decomp_data_0x1d633[] = { 1, 0x72, };
+static const char32 __uni_decomp_data_0x1d634[] = { 1, 0x73, };
+static const char32 __uni_decomp_data_0x1d635[] = { 1, 0x74, };
+static const char32 __uni_decomp_data_0x1d636[] = { 1, 0x75, };
+static const char32 __uni_decomp_data_0x1d637[] = { 1, 0x76, };
+static const char32 __uni_decomp_data_0x1d638[] = { 1, 0x77, };
+static const char32 __uni_decomp_data_0x1d639[] = { 1, 0x78, };
+static const char32 __uni_decomp_data_0x1d63a[] = { 1, 0x79, };
+static const char32 __uni_decomp_data_0x1d63b[] = { 1, 0x7a, };
+static const char32 __uni_decomp_data_0x1d63c[] = { 1, 0x41, };
+static const char32 __uni_decomp_data_0x1d63d[] = { 1, 0x42, };
+static const char32 __uni_decomp_data_0x1d63e[] = { 1, 0x43, };
+static const char32 __uni_decomp_data_0x1d63f[] = { 1, 0x44, };
+static const char32 __uni_decomp_data_0x1d640[] = { 1, 0x45, };
+static const char32 __uni_decomp_data_0x1d641[] = { 1, 0x46, };
+static const char32 __uni_decomp_data_0x1d642[] = { 1, 0x47, };
+static const char32 __uni_decomp_data_0x1d643[] = { 1, 0x48, };
+static const char32 __uni_decomp_data_0x1d644[] = { 1, 0x49, };
+static const char32 __uni_decomp_data_0x1d645[] = { 1, 0x4a, };
+static const char32 __uni_decomp_data_0x1d646[] = { 1, 0x4b, };
+static const char32 __uni_decomp_data_0x1d647[] = { 1, 0x4c, };
+static const char32 __uni_decomp_data_0x1d648[] = { 1, 0x4d, };
+static const char32 __uni_decomp_data_0x1d649[] = { 1, 0x4e, };
+static const char32 __uni_decomp_data_0x1d64a[] = { 1, 0x4f, };
+static const char32 __uni_decomp_data_0x1d64b[] = { 1, 0x50, };
+static const char32 __uni_decomp_data_0x1d64c[] = { 1, 0x51, };
+static const char32 __uni_decomp_data_0x1d64d[] = { 1, 0x52, };
+static const char32 __uni_decomp_data_0x1d64e[] = { 1, 0x53, };
+static const char32 __uni_decomp_data_0x1d64f[] = { 1, 0x54, };
+static const char32 __uni_decomp_data_0x1d650[] = { 1, 0x55, };
+static const char32 __uni_decomp_data_0x1d651[] = { 1, 0x56, };
+static const char32 __uni_decomp_data_0x1d652[] = { 1, 0x57, };
+static const char32 __uni_decomp_data_0x1d653[] = { 1, 0x58, };
+static const char32 __uni_decomp_data_0x1d654[] = { 1, 0x59, };
+static const char32 __uni_decomp_data_0x1d655[] = { 1, 0x5a, };
+static const char32 __uni_decomp_data_0x1d656[] = { 1, 0x61, };
+static const char32 __uni_decomp_data_0x1d657[] = { 1, 0x62, };
+static const char32 __uni_decomp_data_0x1d658[] = { 1, 0x63, };
+static const char32 __uni_decomp_data_0x1d659[] = { 1, 0x64, };
+static const char32 __uni_decomp_data_0x1d65a[] = { 1, 0x65, };
+static const char32 __uni_decomp_data_0x1d65b[] = { 1, 0x66, };
+static const char32 __uni_decomp_data_0x1d65c[] = { 1, 0x67, };
+static const char32 __uni_decomp_data_0x1d65d[] = { 1, 0x68, };
+static const char32 __uni_decomp_data_0x1d65e[] = { 1, 0x69, };
+static const char32 __uni_decomp_data_0x1d65f[] = { 1, 0x6a, };
+static const char32 __uni_decomp_data_0x1d660[] = { 1, 0x6b, };
+static const char32 __uni_decomp_data_0x1d661[] = { 1, 0x6c, };
+static const char32 __uni_decomp_data_0x1d662[] = { 1, 0x6d, };
+static const char32 __uni_decomp_data_0x1d663[] = { 1, 0x6e, };
+static const char32 __uni_decomp_data_0x1d664[] = { 1, 0x6f, };
+static const char32 __uni_decomp_data_0x1d665[] = { 1, 0x70, };
+static const char32 __uni_decomp_data_0x1d666[] = { 1, 0x71, };
+static const char32 __uni_decomp_data_0x1d667[] = { 1, 0x72, };
+static const char32 __uni_decomp_data_0x1d668[] = { 1, 0x73, };
+static const char32 __uni_decomp_data_0x1d669[] = { 1, 0x74, };
+static const char32 __uni_decomp_data_0x1d66a[] = { 1, 0x75, };
+static const char32 __uni_decomp_data_0x1d66b[] = { 1, 0x76, };
+static const char32 __uni_decomp_data_0x1d66c[] = { 1, 0x77, };
+static const char32 __uni_decomp_data_0x1d66d[] = { 1, 0x78, };
+static const char32 __uni_decomp_data_0x1d66e[] = { 1, 0x79, };
+static const char32 __uni_decomp_data_0x1d66f[] = { 1, 0x7a, };
+static const char32 __uni_decomp_data_0x1d670[] = { 1, 0x41, };
+static const char32 __uni_decomp_data_0x1d671[] = { 1, 0x42, };
+static const char32 __uni_decomp_data_0x1d672[] = { 1, 0x43, };
+static const char32 __uni_decomp_data_0x1d673[] = { 1, 0x44, };
+static const char32 __uni_decomp_data_0x1d674[] = { 1, 0x45, };
+static const char32 __uni_decomp_data_0x1d675[] = { 1, 0x46, };
+static const char32 __uni_decomp_data_0x1d676[] = { 1, 0x47, };
+static const char32 __uni_decomp_data_0x1d677[] = { 1, 0x48, };
+static const char32 __uni_decomp_data_0x1d678[] = { 1, 0x49, };
+static const char32 __uni_decomp_data_0x1d679[] = { 1, 0x4a, };
+static const char32 __uni_decomp_data_0x1d67a[] = { 1, 0x4b, };
+static const char32 __uni_decomp_data_0x1d67b[] = { 1, 0x4c, };
+static const char32 __uni_decomp_data_0x1d67c[] = { 1, 0x4d, };
+static const char32 __uni_decomp_data_0x1d67d[] = { 1, 0x4e, };
+static const char32 __uni_decomp_data_0x1d67e[] = { 1, 0x4f, };
+static const char32 __uni_decomp_data_0x1d67f[] = { 1, 0x50, };
 
 
 
@@ -24072,132 +24072,132 @@
 };
 
 
-static const char32 __uni_decomp_data_0x1d680[] = { 0x51, 0, };
-static const char32 __uni_decomp_data_0x1d681[] = { 0x52, 0, };
-static const char32 __uni_decomp_data_0x1d682[] = { 0x53, 0, };
-static const char32 __uni_decomp_data_0x1d683[] = { 0x54, 0, };
-static const char32 __uni_decomp_data_0x1d684[] = { 0x55, 0, };
-static const char32 __uni_decomp_data_0x1d685[] = { 0x56, 0, };
-static const char32 __uni_decomp_data_0x1d686[] = { 0x57, 0, };
-static const char32 __uni_decomp_data_0x1d687[] = { 0x58, 0, };
-static const char32 __uni_decomp_data_0x1d688[] = { 0x59, 0, };
-static const char32 __uni_decomp_data_0x1d689[] = { 0x5a, 0, };
-static const char32 __uni_decomp_data_0x1d68a[] = { 0x61, 0, };
-static const char32 __uni_decomp_data_0x1d68b[] = { 0x62, 0, };
-static const char32 __uni_decomp_data_0x1d68c[] = { 0x63, 0, };
-static const char32 __uni_decomp_data_0x1d68d[] = { 0x64, 0, };
-static const char32 __uni_decomp_data_0x1d68e[] = { 0x65, 0, };
-static const char32 __uni_decomp_data_0x1d68f[] = { 0x66, 0, };
-static const char32 __uni_decomp_data_0x1d690[] = { 0x67, 0, };
-static const char32 __uni_decomp_data_0x1d691[] = { 0x68, 0, };
-static const char32 __uni_decomp_data_0x1d692[] = { 0x69, 0, };
-static const char32 __uni_decomp_data_0x1d693[] = { 0x6a, 0, };
-static const char32 __uni_decomp_data_0x1d694[] = { 0x6b, 0, };
-static const char32 __uni_decomp_data_0x1d695[] = { 0x6c, 0, };
-static const char32 __uni_decomp_data_0x1d696[] = { 0x6d, 0, };
-static const char32 __uni_decomp_data_0x1d697[] = { 0x6e, 0, };
-static const char32 __uni_decomp_data_0x1d698[] = { 0x6f, 0, };
-static const char32 __uni_decomp_data_0x1d699[] = { 0x70, 0, };
-static const char32 __uni_decomp_data_0x1d69a[] = { 0x71, 0, };
-static const char32 __uni_decomp_data_0x1d69b[] = { 0x72, 0, };
-static const char32 __uni_decomp_data_0x1d69c[] = { 0x73, 0, };
-static const char32 __uni_decomp_data_0x1d69d[] = { 0x74, 0, };
-static const char32 __uni_decomp_data_0x1d69e[] = { 0x75, 0, };
-static const char32 __uni_decomp_data_0x1d69f[] = { 0x76, 0, };
-static const char32 __uni_decomp_data_0x1d6a0[] = { 0x77, 0, };
-static const char32 __uni_decomp_data_0x1d6a1[] = { 0x78, 0, };
-static const char32 __uni_decomp_data_0x1d6a2[] = { 0x79, 0, };
-static const char32 __uni_decomp_data_0x1d6a3[] = { 0x7a, 0, };
-static const char32 __uni_decomp_data_0x1d6a4[] = { 0x131, 0, };
-static const char32 __uni_decomp_data_0x1d6a5[] = { 0x237, 0, };
-static const char32 __uni_decomp_data_0x1d6a8[] = { 0x391, 0, };
-static const char32 __uni_decomp_data_0x1d6a9[] = { 0x392, 0, };
-static const char32 __uni_decomp_data_0x1d6aa[] = { 0x393, 0, };
-static const char32 __uni_decomp_data_0x1d6ab[] = { 0x394, 0, };
-static const char32 __uni_decomp_data_0x1d6ac[] = { 0x395, 0, };
-static const char32 __uni_decomp_data_0x1d6ad[] = { 0x396, 0, };
-static const char32 __uni_decomp_data_0x1d6ae[] = { 0x397, 0, };
-static const char32 __uni_decomp_data_0x1d6af[] = { 0x398, 0, };
-static const char32 __uni_decomp_data_0x1d6b0[] = { 0x399, 0, };
-static const char32 __uni_decomp_data_0x1d6b1[] = { 0x39a, 0, };
-static const char32 __uni_decomp_data_0x1d6b2[] = { 0x39b, 0, };
-static const char32 __uni_decomp_data_0x1d6b3[] = { 0x39c, 0, };
-static const char32 __uni_decomp_data_0x1d6b4[] = { 0x39d, 0, };
-static const char32 __uni_decomp_data_0x1d6b5[] = { 0x39e, 0, };
-static const char32 __uni_decomp_data_0x1d6b6[] = { 0x39f, 0, };
-static const char32 __uni_decomp_data_0x1d6b7[] = { 0x3a0, 0, };
-static const char32 __uni_decomp_data_0x1d6b8[] = { 0x3a1, 0, };
-static const char32 __uni_decomp_data_0x1d6b9[] = { 0x3f4, 0, };
-static const char32 __uni_decomp_data_0x1d6ba[] = { 0x3a3, 0, };
-static const char32 __uni_decomp_data_0x1d6bb[] = { 0x3a4, 0, };
-static const char32 __uni_decomp_data_0x1d6bc[] = { 0x3a5, 0, };
-static const char32 __uni_decomp_data_0x1d6bd[] = { 0x3a6, 0, };
-static const char32 __uni_decomp_data_0x1d6be[] = { 0x3a7, 0, };
-static const char32 __uni_decomp_data_0x1d6bf[] = { 0x3a8, 0, };
-static const char32 __uni_decomp_data_0x1d6c0[] = { 0x3a9, 0, };
-static const char32 __uni_decomp_data_0x1d6c1[] = { 0x2207, 0, };
-static const char32 __uni_decomp_data_0x1d6c2[] = { 0x3b1, 0, };
-static const char32 __uni_decomp_data_0x1d6c3[] = { 0x3b2, 0, };
-static const char32 __uni_decomp_data_0x1d6c4[] = { 0x3b3, 0, };
-static const char32 __uni_decomp_data_0x1d6c5[] = { 0x3b4, 0, };
-static const char32 __uni_decomp_data_0x1d6c6[] = { 0x3b5, 0, };
-static const char32 __uni_decomp_data_0x1d6c7[] = { 0x3b6, 0, };
-static const char32 __uni_decomp_data_0x1d6c8[] = { 0x3b7, 0, };
-static const char32 __uni_decomp_data_0x1d6c9[] = { 0x3b8, 0, };
-static const char32 __uni_decomp_data_0x1d6ca[] = { 0x3b9, 0, };
-static const char32 __uni_decomp_data_0x1d6cb[] = { 0x3ba, 0, };
-static const char32 __uni_decomp_data_0x1d6cc[] = { 0x3bb, 0, };
-static const char32 __uni_decomp_data_0x1d6cd[] = { 0x3bc, 0, };
-static const char32 __uni_decomp_data_0x1d6ce[] = { 0x3bd, 0, };
-static const char32 __uni_decomp_data_0x1d6cf[] = { 0x3be, 0, };
-static const char32 __uni_decomp_data_0x1d6d0[] = { 0x3bf, 0, };
-static const char32 __uni_decomp_data_0x1d6d1[] = { 0x3c0, 0, };
-static const char32 __uni_decomp_data_0x1d6d2[] = { 0x3c1, 0, };
-static const char32 __uni_decomp_data_0x1d6d3[] = { 0x3c2, 0, };
-static const char32 __uni_decomp_data_0x1d6d4[] = { 0x3c3, 0, };
-static const char32 __uni_decomp_data_0x1d6d5[] = { 0x3c4, 0, };
-static const char32 __uni_decomp_data_0x1d6d6[] = { 0x3c5, 0, };
-static const char32 __uni_decomp_data_0x1d6d7[] = { 0x3c6, 0, };
-static const char32 __uni_decomp_data_0x1d6d8[] = { 0x3c7, 0, };
-static const char32 __uni_decomp_data_0x1d6d9[] = { 0x3c8, 0, };
-static const char32 __uni_decomp_data_0x1d6da[] = { 0x3c9, 0, };
-static const char32 __uni_decomp_data_0x1d6db[] = { 0x2202, 0, };
-static const char32 __uni_decomp_data_0x1d6dc[] = { 0x3f5, 0, };
-static const char32 __uni_decomp_data_0x1d6dd[] = { 0x3d1, 0, };
-static const char32 __uni_decomp_data_0x1d6de[] = { 0x3f0, 0, };
-static const char32 __uni_decomp_data_0x1d6df[] = { 0x3d5, 0, };
-static const char32 __uni_decomp_data_0x1d6e0[] = { 0x3f1, 0, };
-static const char32 __uni_decomp_data_0x1d6e1[] = { 0x3d6, 0, };
-static const char32 __uni_decomp_data_0x1d6e2[] = { 0x391, 0, };
-static const char32 __uni_decomp_data_0x1d6e3[] = { 0x392, 0, };
-static const char32 __uni_decomp_data_0x1d6e4[] = { 0x393, 0, };
-static const char32 __uni_decomp_data_0x1d6e5[] = { 0x394, 0, };
-static const char32 __uni_decomp_data_0x1d6e6[] = { 0x395, 0, };
-static const char32 __uni_decomp_data_0x1d6e7[] = { 0x396, 0, };
-static const char32 __uni_decomp_data_0x1d6e8[] = { 0x397, 0, };
-static const char32 __uni_decomp_data_0x1d6e9[] = { 0x398, 0, };
-static const char32 __uni_decomp_data_0x1d6ea[] = { 0x399, 0, };
-static const char32 __uni_decomp_data_0x1d6eb[] = { 0x39a, 0, };
-static const char32 __uni_decomp_data_0x1d6ec[] = { 0x39b, 0, };
-static const char32 __uni_decomp_data_0x1d6ed[] = { 0x39c, 0, };
-static const char32 __uni_decomp_data_0x1d6ee[] = { 0x39d, 0, };
-static const char32 __uni_decomp_data_0x1d6ef[] = { 0x39e, 0, };
-static const char32 __uni_decomp_data_0x1d6f0[] = { 0x39f, 0, };
-static const char32 __uni_decomp_data_0x1d6f1[] = { 0x3a0, 0, };
-static const char32 __uni_decomp_data_0x1d6f2[] = { 0x3a1, 0, };
-static const char32 __uni_decomp_data_0x1d6f3[] = { 0x3f4, 0, };
-static const char32 __uni_decomp_data_0x1d6f4[] = { 0x3a3, 0, };
-static const char32 __uni_decomp_data_0x1d6f5[] = { 0x3a4, 0, };
-static const char32 __uni_decomp_data_0x1d6f6[] = { 0x3a5, 0, };
-static const char32 __uni_decomp_data_0x1d6f7[] = { 0x3a6, 0, };
-static const char32 __uni_decomp_data_0x1d6f8[] = { 0x3a7, 0, };
-static const char32 __uni_decomp_data_0x1d6f9[] = { 0x3a8, 0, };
-static const char32 __uni_decomp_data_0x1d6fa[] = { 0x3a9, 0, };
-static const char32 __uni_decomp_data_0x1d6fb[] = { 0x2207, 0, };
-static const char32 __uni_decomp_data_0x1d6fc[] = { 0x3b1, 0, };
-static const char32 __uni_decomp_data_0x1d6fd[] = { 0x3b2, 0, };
-static const char32 __uni_decomp_data_0x1d6fe[] = { 0x3b3, 0, };
-static const char32 __uni_decomp_data_0x1d6ff[] = { 0x3b4, 0, };
+static const char32 __uni_decomp_data_0x1d680[] = { 1, 0x51, };
+static const char32 __uni_decomp_data_0x1d681[] = { 1, 0x52, };
+static const char32 __uni_decomp_data_0x1d682[] = { 1, 0x53, };
+static const char32 __uni_decomp_data_0x1d683[] = { 1, 0x54, };
+static const char32 __uni_decomp_data_0x1d684[] = { 1, 0x55, };
+static const char32 __uni_decomp_data_0x1d685[] = { 1, 0x56, };
+static const char32 __uni_decomp_data_0x1d686[] = { 1, 0x57, };
+static const char32 __uni_decomp_data_0x1d687[] = { 1, 0x58, };
+static const char32 __uni_decomp_data_0x1d688[] = { 1, 0x59, };
+static const char32 __uni_decomp_data_0x1d689[] = { 1, 0x5a, };
+static const char32 __uni_decomp_data_0x1d68a[] = { 1, 0x61, };
+static const char32 __uni_decomp_data_0x1d68b[] = { 1, 0x62, };
+static const char32 __uni_decomp_data_0x1d68c[] = { 1, 0x63, };
+static const char32 __uni_decomp_data_0x1d68d[] = { 1, 0x64, };
+static const char32 __uni_decomp_data_0x1d68e[] = { 1, 0x65, };
+static const char32 __uni_decomp_data_0x1d68f[] = { 1, 0x66, };
+static const char32 __uni_decomp_data_0x1d690[] = { 1, 0x67, };
+static const char32 __uni_decomp_data_0x1d691[] = { 1, 0x68, };
+static const char32 __uni_decomp_data_0x1d692[] = { 1, 0x69, };
+static const char32 __uni_decomp_data_0x1d693[] = { 1, 0x6a, };
+static const char32 __uni_decomp_data_0x1d694[] = { 1, 0x6b, };
+static const char32 __uni_decomp_data_0x1d695[] = { 1, 0x6c, };
+static const char32 __uni_decomp_data_0x1d696[] = { 1, 0x6d, };
+static const char32 __uni_decomp_data_0x1d697[] = { 1, 0x6e, };
+static const char32 __uni_decomp_data_0x1d698[] = { 1, 0x6f, };
+static const char32 __uni_decomp_data_0x1d699[] = { 1, 0x70, };
+static const char32 __uni_decomp_data_0x1d69a[] = { 1, 0x71, };
+static const char32 __uni_decomp_data_0x1d69b[] = { 1, 0x72, };
+static const char32 __uni_decomp_data_0x1d69c[] = { 1, 0x73, };
+static const char32 __uni_decomp_data_0x1d69d[] = { 1, 0x74, };
+static const char32 __uni_decomp_data_0x1d69e[] = { 1, 0x75, };
+static const char32 __uni_decomp_data_0x1d69f[] = { 1, 0x76, };
+static const char32 __uni_decomp_data_0x1d6a0[] = { 1, 0x77, };
+static const char32 __uni_decomp_data_0x1d6a1[] = { 1, 0x78, };
+static const char32 __uni_decomp_data_0x1d6a2[] = { 1, 0x79, };
+static const char32 __uni_decomp_data_0x1d6a3[] = { 1, 0x7a, };
+static const char32 __uni_decomp_data_0x1d6a4[] = { 1, 0x131, };
+static const char32 __uni_decomp_data_0x1d6a5[] = { 1, 0x237, };
+static const char32 __uni_decomp_data_0x1d6a8[] = { 1, 0x391, };
+static const char32 __uni_decomp_data_0x1d6a9[] = { 1, 0x392, };
+static const char32 __uni_decomp_data_0x1d6aa[] = { 1, 0x393, };
+static const char32 __uni_decomp_data_0x1d6ab[] = { 1, 0x394, };
+static const char32 __uni_decomp_data_0x1d6ac[] = { 1, 0x395, };
+static const char32 __uni_decomp_data_0x1d6ad[] = { 1, 0x396, };
+static const char32 __uni_decomp_data_0x1d6ae[] = { 1, 0x397, };
+static const char32 __uni_decomp_data_0x1d6af[] = { 1, 0x398, };
+static const char32 __uni_decomp_data_0x1d6b0[] = { 1, 0x399, };
+static const char32 __uni_decomp_data_0x1d6b1[] = { 1, 0x39a, };
+static const char32 __uni_decomp_data_0x1d6b2[] = { 1, 0x39b, };
+static const char32 __uni_decomp_data_0x1d6b3[] = { 1, 0x39c, };
+static const char32 __uni_decomp_data_0x1d6b4[] = { 1, 0x39d, };
+static const char32 __uni_decomp_data_0x1d6b5[] = { 1, 0x39e, };
+static const char32 __uni_decomp_data_0x1d6b6[] = { 1, 0x39f, };
+static const char32 __uni_decomp_data_0x1d6b7[] = { 1, 0x3a0, };
+static const char32 __uni_decomp_data_0x1d6b8[] = { 1, 0x3a1, };
+static const char32 __uni_decomp_data_0x1d6b9[] = { 1, 0x3f4, };
+static const char32 __uni_decomp_data_0x1d6ba[] = { 1, 0x3a3, };
+static const char32 __uni_decomp_data_0x1d6bb[] = { 1, 0x3a4, };
+static const char32 __uni_decomp_data_0x1d6bc[] = { 1, 0x3a5, };
+static const char32 __uni_decomp_data_0x1d6bd[] = { 1, 0x3a6, };
+static const char32 __uni_decomp_data_0x1d6be[] = { 1, 0x3a7, };
+static const char32 __uni_decomp_data_0x1d6bf[] = { 1, 0x3a8, };
+static const char32 __uni_decomp_data_0x1d6c0[] = { 1, 0x3a9, };
+static const char32 __uni_decomp_data_0x1d6c1[] = { 1, 0x2207, };
+static const char32 __uni_decomp_data_0x1d6c2[] = { 1, 0x3b1, };
+static const char32 __uni_decomp_data_0x1d6c3[] = { 1, 0x3b2, };
+static const char32 __uni_decomp_data_0x1d6c4[] = { 1, 0x3b3, };
+static const char32 __uni_decomp_data_0x1d6c5[] = { 1, 0x3b4, };
+static const char32 __uni_decomp_data_0x1d6c6[] = { 1, 0x3b5, };
+static const char32 __uni_decomp_data_0x1d6c7[] = { 1, 0x3b6, };
+static const char32 __uni_decomp_data_0x1d6c8[] = { 1, 0x3b7, };
+static const char32 __uni_decomp_data_0x1d6c9[] = { 1, 0x3b8, };
+static const char32 __uni_decomp_data_0x1d6ca[] = { 1, 0x3b9, };
+static const char32 __uni_decomp_data_0x1d6cb[] = { 1, 0x3ba, };
+static const char32 __uni_decomp_data_0x1d6cc[] = { 1, 0x3bb, };
+static const char32 __uni_decomp_data_0x1d6cd[] = { 1, 0x3bc, };
+static const char32 __uni_decomp_data_0x1d6ce[] = { 1, 0x3bd, };
+static const char32 __uni_decomp_data_0x1d6cf[] = { 1, 0x3be, };
+static const char32 __uni_decomp_data_0x1d6d0[] = { 1, 0x3bf, };
+static const char32 __uni_decomp_data_0x1d6d1[] = { 1, 0x3c0, };
+static const char32 __uni_decomp_data_0x1d6d2[] = { 1, 0x3c1, };
+static const char32 __uni_decomp_data_0x1d6d3[] = { 1, 0x3c2, };
+static const char32 __uni_decomp_data_0x1d6d4[] = { 1, 0x3c3, };
+static const char32 __uni_decomp_data_0x1d6d5[] = { 1, 0x3c4, };
+static const char32 __uni_decomp_data_0x1d6d6[] = { 1, 0x3c5, };
+static const char32 __uni_decomp_data_0x1d6d7[] = { 1, 0x3c6, };
+static const char32 __uni_decomp_data_0x1d6d8[] = { 1, 0x3c7, };
+static const char32 __uni_decomp_data_0x1d6d9[] = { 1, 0x3c8, };
+static const char32 __uni_decomp_data_0x1d6da[] = { 1, 0x3c9, };
+static const char32 __uni_decomp_data_0x1d6db[] = { 1, 0x2202, };
+static const char32 __uni_decomp_data_0x1d6dc[] = { 1, 0x3f5, };
+static const char32 __uni_decomp_data_0x1d6dd[] = { 1, 0x3d1, };
+static const char32 __uni_decomp_data_0x1d6de[] = { 1, 0x3f0, };
+static const char32 __uni_decomp_data_0x1d6df[] = { 1, 0x3d5, };
+static const char32 __uni_decomp_data_0x1d6e0[] = { 1, 0x3f1, };
+static const char32 __uni_decomp_data_0x1d6e1[] = { 1, 0x3d6, };
+static const char32 __uni_decomp_data_0x1d6e2[] = { 1, 0x391, };
+static const char32 __uni_decomp_data_0x1d6e3[] = { 1, 0x392, };
+static const char32 __uni_decomp_data_0x1d6e4[] = { 1, 0x393, };
+static const char32 __uni_decomp_data_0x1d6e5[] = { 1, 0x394, };
+static const char32 __uni_decomp_data_0x1d6e6[] = { 1, 0x395, };
+static const char32 __uni_decomp_data_0x1d6e7[] = { 1, 0x396, };
+static const char32 __uni_decomp_data_0x1d6e8[] = { 1, 0x397, };
+static const char32 __uni_decomp_data_0x1d6e9[] = { 1, 0x398, };
+static const char32 __uni_decomp_data_0x1d6ea[] = { 1, 0x399, };
+static const char32 __uni_decomp_data_0x1d6eb[] = { 1, 0x39a, };
+static const char32 __uni_decomp_data_0x1d6ec[] = { 1, 0x39b, };
+static const char32 __uni_decomp_data_0x1d6ed[] = { 1, 0x39c, };
+static const char32 __uni_decomp_data_0x1d6ee[] = { 1, 0x39d, };
+static const char32 __uni_decomp_data_0x1d6ef[] = { 1, 0x39e, };
+static const char32 __uni_decomp_data_0x1d6f0[] = { 1, 0x39f, };
+static const char32 __uni_decomp_data_0x1d6f1[] = { 1, 0x3a0, };
+static const char32 __uni_decomp_data_0x1d6f2[] = { 1, 0x3a1, };
+static const char32 __uni_decomp_data_0x1d6f3[] = { 1, 0x3f4, };
+static const char32 __uni_decomp_data_0x1d6f4[] = { 1, 0x3a3, };
+static const char32 __uni_decomp_data_0x1d6f5[] = { 1, 0x3a4, };
+static const char32 __uni_decomp_data_0x1d6f6[] = { 1, 0x3a5, };
+static const char32 __uni_decomp_data_0x1d6f7[] = { 1, 0x3a6, };
+static const char32 __uni_decomp_data_0x1d6f8[] = { 1, 0x3a7, };
+static const char32 __uni_decomp_data_0x1d6f9[] = { 1, 0x3a8, };
+static const char32 __uni_decomp_data_0x1d6fa[] = { 1, 0x3a9, };
+static const char32 __uni_decomp_data_0x1d6fb[] = { 1, 0x2207, };
+static const char32 __uni_decomp_data_0x1d6fc[] = { 1, 0x3b1, };
+static const char32 __uni_decomp_data_0x1d6fd[] = { 1, 0x3b2, };
+static const char32 __uni_decomp_data_0x1d6fe[] = { 1, 0x3b3, };
+static const char32 __uni_decomp_data_0x1d6ff[] = { 1, 0x3b4, };
 
 
 
@@ -25871,134 +25871,134 @@
 };
 
 
-static const char32 __uni_decomp_data_0x1d700[] = { 0x3b5, 0, };
-static const char32 __uni_decomp_data_0x1d701[] = { 0x3b6, 0, };
-static const char32 __uni_decomp_data_0x1d702[] = { 0x3b7, 0, };
-static const char32 __uni_decomp_data_0x1d703[] = { 0x3b8, 0, };
-static const char32 __uni_decomp_data_0x1d704[] = { 0x3b9, 0, };
-static const char32 __uni_decomp_data_0x1d705[] = { 0x3ba, 0, };
-static const char32 __uni_decomp_data_0x1d706[] = { 0x3bb, 0, };
-static const char32 __uni_decomp_data_0x1d707[] = { 0x3bc, 0, };
-static const char32 __uni_decomp_data_0x1d708[] = { 0x3bd, 0, };
-static const char32 __uni_decomp_data_0x1d709[] = { 0x3be, 0, };
-static const char32 __uni_decomp_data_0x1d70a[] = { 0x3bf, 0, };
-static const char32 __uni_decomp_data_0x1d70b[] = { 0x3c0, 0, };
-static const char32 __uni_decomp_data_0x1d70c[] = { 0x3c1, 0, };
-static const char32 __uni_decomp_data_0x1d70d[] = { 0x3c2, 0, };
-static const char32 __uni_decomp_data_0x1d70e[] = { 0x3c3, 0, };
-static const char32 __uni_decomp_data_0x1d70f[] = { 0x3c4, 0, };
-static const char32 __uni_decomp_data_0x1d710[] = { 0x3c5, 0, };
-static const char32 __uni_decomp_data_0x1d711[] = { 0x3c6, 0, };
-static const char32 __uni_decomp_data_0x1d712[] = { 0x3c7, 0, };
-static const char32 __uni_decomp_data_0x1d713[] = { 0x3c8, 0, };
-static const char32 __uni_decomp_data_0x1d714[] = { 0x3c9, 0, };
-static const char32 __uni_decomp_data_0x1d715[] = { 0x2202, 0, };
-static const char32 __uni_decomp_data_0x1d716[] = { 0x3f5, 0, };
-static const char32 __uni_decomp_data_0x1d717[] = { 0x3d1, 0, };
-static const char32 __uni_decomp_data_0x1d718[] = { 0x3f0, 0, };
-static const char32 __uni_decomp_data_0x1d719[] = { 0x3d5, 0, };
-static const char32 __uni_decomp_data_0x1d71a[] = { 0x3f1, 0, };
-static const char32 __uni_decomp_data_0x1d71b[] = { 0x3d6, 0, };
-static const char32 __uni_decomp_data_0x1d71c[] = { 0x391, 0, };
-static const char32 __uni_decomp_data_0x1d71d[] = { 0x392, 0, };
-static const char32 __uni_decomp_data_0x1d71e[] = { 0x393, 0, };
-static const char32 __uni_decomp_data_0x1d71f[] = { 0x394, 0, };
-static const char32 __uni_decomp_data_0x1d720[] = { 0x395, 0, };
-static const char32 __uni_decomp_data_0x1d721[] = { 0x396, 0, };
-static const char32 __uni_decomp_data_0x1d722[] = { 0x397, 0, };
-static const char32 __uni_decomp_data_0x1d723[] = { 0x398, 0, };
-static const char32 __uni_decomp_data_0x1d724[] = { 0x399, 0, };
-static const char32 __uni_decomp_data_0x1d725[] = { 0x39a, 0, };
-static const char32 __uni_decomp_data_0x1d726[] = { 0x39b, 0, };
-static const char32 __uni_decomp_data_0x1d727[] = { 0x39c, 0, };
-static const char32 __uni_decomp_data_0x1d728[] = { 0x39d, 0, };
-static const char32 __uni_decomp_data_0x1d729[] = { 0x39e, 0, };
-static const char32 __uni_decomp_data_0x1d72a[] = { 0x39f, 0, };
-static const char32 __uni_decomp_data_0x1d72b[] = { 0x3a0, 0, };
-static const char32 __uni_decomp_data_0x1d72c[] = { 0x3a1, 0, };
-static const char32 __uni_decomp_data_0x1d72d[] = { 0x3f4, 0, };
-static const char32 __uni_decomp_data_0x1d72e[] = { 0x3a3, 0, };
-static const char32 __uni_decomp_data_0x1d72f[] = { 0x3a4, 0, };
-static const char32 __uni_decomp_data_0x1d730[] = { 0x3a5, 0, };
-static const char32 __uni_decomp_data_0x1d731[] = { 0x3a6, 0, };
-static const char32 __uni_decomp_data_0x1d732[] = { 0x3a7, 0, };
-static const char32 __uni_decomp_data_0x1d733[] = { 0x3a8, 0, };
-static const char32 __uni_decomp_data_0x1d734[] = { 0x3a9, 0, };
-static const char32 __uni_decomp_data_0x1d735[] = { 0x2207, 0, };
-static const char32 __uni_decomp_data_0x1d736[] = { 0x3b1, 0, };
-static const char32 __uni_decomp_data_0x1d737[] = { 0x3b2, 0, };
-static const char32 __uni_decomp_data_0x1d738[] = { 0x3b3, 0, };
-static const char32 __uni_decomp_data_0x1d739[] = { 0x3b4, 0, };
-static const char32 __uni_decomp_data_0x1d73a[] = { 0x3b5, 0, };
-static const char32 __uni_decomp_data_0x1d73b[] = { 0x3b6, 0, };
-static const char32 __uni_decomp_data_0x1d73c[] = { 0x3b7, 0, };
-static const char32 __uni_decomp_data_0x1d73d[] = { 0x3b8, 0, };
-static const char32 __uni_decomp_data_0x1d73e[] = { 0x3b9, 0, };
-static const char32 __uni_decomp_data_0x1d73f[] = { 0x3ba, 0, };
-static const char32 __uni_decomp_data_0x1d740[] = { 0x3bb, 0, };
-static const char32 __uni_decomp_data_0x1d741[] = { 0x3bc, 0, };
-static const char32 __uni_decomp_data_0x1d742[] = { 0x3bd, 0, };
-static const char32 __uni_decomp_data_0x1d743[] = { 0x3be, 0, };
-static const char32 __uni_decomp_data_0x1d744[] = { 0x3bf, 0, };
-static const char32 __uni_decomp_data_0x1d745[] = { 0x3c0, 0, };
-static const char32 __uni_decomp_data_0x1d746[] = { 0x3c1, 0, };
-static const char32 __uni_decomp_data_0x1d747[] = { 0x3c2, 0, };
-static const char32 __uni_decomp_data_0x1d748[] = { 0x3c3, 0, };
-static const char32 __uni_decomp_data_0x1d749[] = { 0x3c4, 0, };
-static const char32 __uni_decomp_data_0x1d74a[] = { 0x3c5, 0, };
-static const char32 __uni_decomp_data_0x1d74b[] = { 0x3c6, 0, };
-static const char32 __uni_decomp_data_0x1d74c[] = { 0x3c7, 0, };
-static const char32 __uni_decomp_data_0x1d74d[] = { 0x3c8, 0, };
-static const char32 __uni_decomp_data_0x1d74e[] = { 0x3c9, 0, };
-static const char32 __uni_decomp_data_0x1d74f[] = { 0x2202, 0, };
-static const char32 __uni_decomp_data_0x1d750[] = { 0x3f5, 0, };
-static const char32 __uni_decomp_data_0x1d751[] = { 0x3d1, 0, };
-static const char32 __uni_decomp_data_0x1d752[] = { 0x3f0, 0, };
-static const char32 __uni_decomp_data_0x1d753[] = { 0x3d5, 0, };
-static const char32 __uni_decomp_data_0x1d754[] = { 0x3f1, 0, };
-static const char32 __uni_decomp_data_0x1d755[] = { 0x3d6, 0, };
-static const char32 __uni_decomp_data_0x1d756[] = { 0x391, 0, };
-static const char32 __uni_decomp_data_0x1d757[] = { 0x392, 0, };
-static const char32 __uni_decomp_data_0x1d758[] = { 0x393, 0, };
-static const char32 __uni_decomp_data_0x1d759[] = { 0x394, 0, };
-static const char32 __uni_decomp_data_0x1d75a[] = { 0x395, 0, };
-static const char32 __uni_decomp_data_0x1d75b[] = { 0x396, 0, };
-static const char32 __uni_decomp_data_0x1d75c[] = { 0x397, 0, };
-static const char32 __uni_decomp_data_0x1d75d[] = { 0x398, 0, };
-static const char32 __uni_decomp_data_0x1d75e[] = { 0x399, 0, };
-static const char32 __uni_decomp_data_0x1d75f[] = { 0x39a, 0, };
-static const char32 __uni_decomp_data_0x1d760[] = { 0x39b, 0, };
-static const char32 __uni_decomp_data_0x1d761[] = { 0x39c, 0, };
-static const char32 __uni_decomp_data_0x1d762[] = { 0x39d, 0, };
-static const char32 __uni_decomp_data_0x1d763[] = { 0x39e, 0, };
-static const char32 __uni_decomp_data_0x1d764[] = { 0x39f, 0, };
-static const char32 __uni_decomp_data_0x1d765[] = { 0x3a0, 0, };
-static const char32 __uni_decomp_data_0x1d766[] = { 0x3a1, 0, };
-static const char32 __uni_decomp_data_0x1d767[] = { 0x3f4, 0, };
-static const char32 __uni_decomp_data_0x1d768[] = { 0x3a3, 0, };
-static const char32 __uni_decomp_data_0x1d769[] = { 0x3a4, 0, };
-static const char32 __uni_decomp_data_0x1d76a[] = { 0x3a5, 0, };
-static const char32 __uni_decomp_data_0x1d76b[] = { 0x3a6, 0, };
-static const char32 __uni_decomp_data_0x1d76c[] = { 0x3a7, 0, };
-static const char32 __uni_decomp_data_0x1d76d[] = { 0x3a8, 0, };
-static const char32 __uni_decomp_data_0x1d76e[] = { 0x3a9, 0, };
-static const char32 __uni_decomp_data_0x1d76f[] = { 0x2207, 0, };
-static const char32 __uni_decomp_data_0x1d770[] = { 0x3b1, 0, };
-static const char32 __uni_decomp_data_0x1d771[] = { 0x3b2, 0, };
-static const char32 __uni_decomp_data_0x1d772[] = { 0x3b3, 0, };
-static const char32 __uni_decomp_data_0x1d773[] = { 0x3b4, 0, };
-static const char32 __uni_decomp_data_0x1d774[] = { 0x3b5, 0, };
-static const char32 __uni_decomp_data_0x1d775[] = { 0x3b6, 0, };
-static const char32 __uni_decomp_data_0x1d776[] = { 0x3b7, 0, };
-static const char32 __uni_decomp_data_0x1d777[] = { 0x3b8, 0, };
-static const char32 __uni_decomp_data_0x1d778[] = { 0x3b9, 0, };
-static const char32 __uni_decomp_data_0x1d779[] = { 0x3ba, 0, };
-static const char32 __uni_decomp_data_0x1d77a[] = { 0x3bb, 0, };
-static const char32 __uni_decomp_data_0x1d77b[] = { 0x3bc, 0, };
-static const char32 __uni_decomp_data_0x1d77c[] = { 0x3bd, 0, };
-static const char32 __uni_decomp_data_0x1d77d[] = { 0x3be, 0, };
-static const char32 __uni_decomp_data_0x1d77e[] = { 0x3bf, 0, };
-static const char32 __uni_decomp_data_0x1d77f[] = { 0x3c0, 0, };
+static const char32 __uni_decomp_data_0x1d700[] = { 1, 0x3b5, };
+static const char32 __uni_decomp_data_0x1d701[] = { 1, 0x3b6, };
+static const char32 __uni_decomp_data_0x1d702[] = { 1, 0x3b7, };
+static const char32 __uni_decomp_data_0x1d703[] = { 1, 0x3b8, };
+static const char32 __uni_decomp_data_0x1d704[] = { 1, 0x3b9, };
+static const char32 __uni_decomp_data_0x1d705[] = { 1, 0x3ba, };
+static const char32 __uni_decomp_data_0x1d706[] = { 1, 0x3bb, };
+static const char32 __uni_decomp_data_0x1d707[] = { 1, 0x3bc, };
+static const char32 __uni_decomp_data_0x1d708[] = { 1, 0x3bd, };
+static const char32 __uni_decomp_data_0x1d709[] = { 1, 0x3be, };
+static const char32 __uni_decomp_data_0x1d70a[] = { 1, 0x3bf, };
+static const char32 __uni_decomp_data_0x1d70b[] = { 1, 0x3c0, };
+static const char32 __uni_decomp_data_0x1d70c[] = { 1, 0x3c1, };
+static const char32 __uni_decomp_data_0x1d70d[] = { 1, 0x3c2, };
+static const char32 __uni_decomp_data_0x1d70e[] = { 1, 0x3c3, };
+static const char32 __uni_decomp_data_0x1d70f[] = { 1, 0x3c4, };
+static const char32 __uni_decomp_data_0x1d710[] = { 1, 0x3c5, };
+static const char32 __uni_decomp_data_0x1d711[] = { 1, 0x3c6, };
+static const char32 __uni_decomp_data_0x1d712[] = { 1, 0x3c7, };
+static const char32 __uni_decomp_data_0x1d713[] = { 1, 0x3c8, };
+static const char32 __uni_decomp_data_0x1d714[] = { 1, 0x3c9, };
+static const char32 __uni_decomp_data_0x1d715[] = { 1, 0x2202, };
+static const char32 __uni_decomp_data_0x1d716[] = { 1, 0x3f5, };
+static const char32 __uni_decomp_data_0x1d717[] = { 1, 0x3d1, };
+static const char32 __uni_decomp_data_0x1d718[] = { 1, 0x3f0, };
+static const char32 __uni_decomp_data_0x1d719[] = { 1, 0x3d5, };
+static const char32 __uni_decomp_data_0x1d71a[] = { 1, 0x3f1, };
+static const char32 __uni_decomp_data_0x1d71b[] = { 1, 0x3d6, };
+static const char32 __uni_decomp_data_0x1d71c[] = { 1, 0x391, };
+static const char32 __uni_decomp_data_0x1d71d[] = { 1, 0x392, };
+static const char32 __uni_decomp_data_0x1d71e[] = { 1, 0x393, };
+static const char32 __uni_decomp_data_0x1d71f[] = { 1, 0x394, };
+static const char32 __uni_decomp_data_0x1d720[] = { 1, 0x395, };
+static const char32 __uni_decomp_data_0x1d721[] = { 1, 0x396, };
+static const char32 __uni_decomp_data_0x1d722[] = { 1, 0x397, };
+static const char32 __uni_decomp_data_0x1d723[] = { 1, 0x398, };
+static const char32 __uni_decomp_data_0x1d724[] = { 1, 0x399, };
+static const char32 __uni_decomp_data_0x1d725[] = { 1, 0x39a, };
+static const char32 __uni_decomp_data_0x1d726[] = { 1, 0x39b, };
+static const char32 __uni_decomp_data_0x1d727[] = { 1, 0x39c, };
+static const char32 __uni_decomp_data_0x1d728[] = { 1, 0x39d, };
+static const char32 __uni_decomp_data_0x1d729[] = { 1, 0x39e, };
+static const char32 __uni_decomp_data_0x1d72a[] = { 1, 0x39f, };
+static const char32 __uni_decomp_data_0x1d72b[] = { 1, 0x3a0, };
+static const char32 __uni_decomp_data_0x1d72c[] = { 1, 0x3a1, };
+static const char32 __uni_decomp_data_0x1d72d[] = { 1, 0x3f4, };
+static const char32 __uni_decomp_data_0x1d72e[] = { 1, 0x3a3, };
+static const char32 __uni_decomp_data_0x1d72f[] = { 1, 0x3a4, };
+static const char32 __uni_decomp_data_0x1d730[] = { 1, 0x3a5, };
+static const char32 __uni_decomp_data_0x1d731[] = { 1, 0x3a6, };
+static const char32 __uni_decomp_data_0x1d732[] = { 1, 0x3a7, };
+static const char32 __uni_decomp_data_0x1d733[] = { 1, 0x3a8, };
+static const char32 __uni_decomp_data_0x1d734[] = { 1, 0x3a9, };
+static const char32 __uni_decomp_data_0x1d735[] = { 1, 0x2207, };
+static const char32 __uni_decomp_data_0x1d736[] = { 1, 0x3b1, };
+static const char32 __uni_decomp_data_0x1d737[] = { 1, 0x3b2, };
+static const char32 __uni_decomp_data_0x1d738[] = { 1, 0x3b3, };
+static const char32 __uni_decomp_data_0x1d739[] = { 1, 0x3b4, };
+static const char32 __uni_decomp_data_0x1d73a[] = { 1, 0x3b5, };
+static const char32 __uni_decomp_data_0x1d73b[] = { 1, 0x3b6, };
+static const char32 __uni_decomp_data_0x1d73c[] = { 1, 0x3b7, };
+static const char32 __uni_decomp_data_0x1d73d[] = { 1, 0x3b8, };
+static const char32 __uni_decomp_data_0x1d73e[] = { 1, 0x3b9, };
+static const char32 __uni_decomp_data_0x1d73f[] = { 1, 0x3ba, };
+static const char32 __uni_decomp_data_0x1d740[] = { 1, 0x3bb, };
+static const char32 __uni_decomp_data_0x1d741[] = { 1, 0x3bc, };
+static const char32 __uni_decomp_data_0x1d742[] = { 1, 0x3bd, };
+static const char32 __uni_decomp_data_0x1d743[] = { 1, 0x3be, };
+static const char32 __uni_decomp_data_0x1d744[] = { 1, 0x3bf, };
+static const char32 __uni_decomp_data_0x1d745[] = { 1, 0x3c0, };
+static const char32 __uni_decomp_data_0x1d746[] = { 1, 0x3c1, };
+static const char32 __uni_decomp_data_0x1d747[] = { 1, 0x3c2, };
+static const char32 __uni_decomp_data_0x1d748[] = { 1, 0x3c3, };
+static const char32 __uni_decomp_data_0x1d749[] = { 1, 0x3c4, };
+static const char32 __uni_decomp_data_0x1d74a[] = { 1, 0x3c5, };
+static const char32 __uni_decomp_data_0x1d74b[] = { 1, 0x3c6, };
+static const char32 __uni_decomp_data_0x1d74c[] = { 1, 0x3c7, };
+static const char32 __uni_decomp_data_0x1d74d[] = { 1, 0x3c8, };
+static const char32 __uni_decomp_data_0x1d74e[] = { 1, 0x3c9, };
+static const char32 __uni_decomp_data_0x1d74f[] = { 1, 0x2202, };
+static const char32 __uni_decomp_data_0x1d750[] = { 1, 0x3f5, };
+static const char32 __uni_decomp_data_0x1d751[] = { 1, 0x3d1, };
+static const char32 __uni_decomp_data_0x1d752[] = { 1, 0x3f0, };
+static const char32 __uni_decomp_data_0x1d753[] = { 1, 0x3d5, };
+static const char32 __uni_decomp_data_0x1d754[] = { 1, 0x3f1, };
+static const char32 __uni_decomp_data_0x1d755[] = { 1, 0x3d6, };
+static const char32 __uni_decomp_data_0x1d756[] = { 1, 0x391, };
+static const char32 __uni_decomp_data_0x1d757[] = { 1, 0x392, };
+static const char32 __uni_decomp_data_0x1d758[] = { 1, 0x393, };
+static const char32 __uni_decomp_data_0x1d759[] = { 1, 0x394, };
+static const char32 __uni_decomp_data_0x1d75a[] = { 1, 0x395, };
+static const char32 __uni_decomp_data_0x1d75b[] = { 1, 0x396, };
+static const char32 __uni_decomp_data_0x1d75c[] = { 1, 0x397, };
+static const char32 __uni_decomp_data_0x1d75d[] = { 1, 0x398, };
+static const char32 __uni_decomp_data_0x1d75e[] = { 1, 0x399, };
+static const char32 __uni_decomp_data_0x1d75f[] = { 1, 0x39a, };
+static const char32 __uni_decomp_data_0x1d760[] = { 1, 0x39b, };
+static const char32 __uni_decomp_data_0x1d761[] = { 1, 0x39c, };
+static const char32 __uni_decomp_data_0x1d762[] = { 1, 0x39d, };
+static const char32 __uni_decomp_data_0x1d763[] = { 1, 0x39e, };
+static const char32 __uni_decomp_data_0x1d764[] = { 1, 0x39f, };
+static const char32 __uni_decomp_data_0x1d765[] = { 1, 0x3a0, };
+static const char32 __uni_decomp_data_0x1d766[] = { 1, 0x3a1, };
+static const char32 __uni_decomp_data_0x1d767[] = { 1, 0x3f4, };
+static const char32 __uni_decomp_data_0x1d768[] = { 1, 0x3a3, };
+static const char32 __uni_decomp_data_0x1d769[] = { 1, 0x3a4, };
+static const char32 __uni_decomp_data_0x1d76a[] = { 1, 0x3a5, };
+static const char32 __uni_decomp_data_0x1d76b[] = { 1, 0x3a6, };
+static const char32 __uni_decomp_data_0x1d76c[] = { 1, 0x3a7, };
+static const char32 __uni_decomp_data_0x1d76d[] = { 1, 0x3a8, };
+static const char32 __uni_decomp_data_0x1d76e[] = { 1, 0x3a9, };
+static const char32 __uni_decomp_data_0x1d76f[] = { 1, 0x2207, };
+static const char32 __uni_decomp_data_0x1d770[] = { 1, 0x3b1, };
+static const char32 __uni_decomp_data_0x1d771[] = { 1, 0x3b2, };
+static const char32 __uni_decomp_data_0x1d772[] = { 1, 0x3b3, };
+static const char32 __uni_decomp_data_0x1d773[] = { 1, 0x3b4, };
+static const char32 __uni_decomp_data_0x1d774[] = { 1, 0x3b5, };
+static const char32 __uni_decomp_data_0x1d775[] = { 1, 0x3b6, };
+static const char32 __uni_decomp_data_0x1d776[] = { 1, 0x3b7, };
+static const char32 __uni_decomp_data_0x1d777[] = { 1, 0x3b8, };
+static const char32 __uni_decomp_data_0x1d778[] = { 1, 0x3b9, };
+static const char32 __uni_decomp_data_0x1d779[] = { 1, 0x3ba, };
+static const char32 __uni_decomp_data_0x1d77a[] = { 1, 0x3bb, };
+static const char32 __uni_decomp_data_0x1d77b[] = { 1, 0x3bc, };
+static const char32 __uni_decomp_data_0x1d77c[] = { 1, 0x3bd, };
+static const char32 __uni_decomp_data_0x1d77d[] = { 1, 0x3be, };
+static const char32 __uni_decomp_data_0x1d77e[] = { 1, 0x3bf, };
+static const char32 __uni_decomp_data_0x1d77f[] = { 1, 0x3c0, };
 
 
 
@@ -27672,132 +27672,132 @@
 };
 
 
-static const char32 __uni_decomp_data_0x1d780[] = { 0x3c1, 0, };
-static const char32 __uni_decomp_data_0x1d781[] = { 0x3c2, 0, };
-static const char32 __uni_decomp_data_0x1d782[] = { 0x3c3, 0, };
-static const char32 __uni_decomp_data_0x1d783[] = { 0x3c4, 0, };
-static const char32 __uni_decomp_data_0x1d784[] = { 0x3c5, 0, };
-static const char32 __uni_decomp_data_0x1d785[] = { 0x3c6, 0, };
-static const char32 __uni_decomp_data_0x1d786[] = { 0x3c7, 0, };
-static const char32 __uni_decomp_data_0x1d787[] = { 0x3c8, 0, };
-static const char32 __uni_decomp_data_0x1d788[] = { 0x3c9, 0, };
-static const char32 __uni_decomp_data_0x1d789[] = { 0x2202, 0, };
-static const char32 __uni_decomp_data_0x1d78a[] = { 0x3f5, 0, };
-static const char32 __uni_decomp_data_0x1d78b[] = { 0x3d1, 0, };
-static const char32 __uni_decomp_data_0x1d78c[] = { 0x3f0, 0, };
-static const char32 __uni_decomp_data_0x1d78d[] = { 0x3d5, 0, };
-static const char32 __uni_decomp_data_0x1d78e[] = { 0x3f1, 0, };
-static const char32 __uni_decomp_data_0x1d78f[] = { 0x3d6, 0, };
-static const char32 __uni_decomp_data_0x1d790[] = { 0x391, 0, };
-static const char32 __uni_decomp_data_0x1d791[] = { 0x392, 0, };
-static const char32 __uni_decomp_data_0x1d792[] = { 0x393, 0, };
-static const char32 __uni_decomp_data_0x1d793[] = { 0x394, 0, };
-static const char32 __uni_decomp_data_0x1d794[] = { 0x395, 0, };
-static const char32 __uni_decomp_data_0x1d795[] = { 0x396, 0, };
-static const char32 __uni_decomp_data_0x1d796[] = { 0x397, 0, };
-static const char32 __uni_decomp_data_0x1d797[] = { 0x398, 0, };
-static const char32 __uni_decomp_data_0x1d798[] = { 0x399, 0, };
-static const char32 __uni_decomp_data_0x1d799[] = { 0x39a, 0, };
-static const char32 __uni_decomp_data_0x1d79a[] = { 0x39b, 0, };
-static const char32 __uni_decomp_data_0x1d79b[] = { 0x39c, 0, };
-static const char32 __uni_decomp_data_0x1d79c[] = { 0x39d, 0, };
-static const char32 __uni_decomp_data_0x1d79d[] = { 0x39e, 0, };
-static const char32 __uni_decomp_data_0x1d79e[] = { 0x39f, 0, };
-static const char32 __uni_decomp_data_0x1d79f[] = { 0x3a0, 0, };
-static const char32 __uni_decomp_data_0x1d7a0[] = { 0x3a1, 0, };
-static const char32 __uni_decomp_data_0x1d7a1[] = { 0x3f4, 0, };
-static const char32 __uni_decomp_data_0x1d7a2[] = { 0x3a3, 0, };
-static const char32 __uni_decomp_data_0x1d7a3[] = { 0x3a4, 0, };
-static const char32 __uni_decomp_data_0x1d7a4[] = { 0x3a5, 0, };
-static const char32 __uni_decomp_data_0x1d7a5[] = { 0x3a6, 0, };
-static const char32 __uni_decomp_data_0x1d7a6[] = { 0x3a7, 0, };
-static const char32 __uni_decomp_data_0x1d7a7[] = { 0x3a8, 0, };
-static const char32 __uni_decomp_data_0x1d7a8[] = { 0x3a9, 0, };
-static const char32 __uni_decomp_data_0x1d7a9[] = { 0x2207, 0, };
-static const char32 __uni_decomp_data_0x1d7aa[] = { 0x3b1, 0, };
-static const char32 __uni_decomp_data_0x1d7ab[] = { 0x3b2, 0, };
-static const char32 __uni_decomp_data_0x1d7ac[] = { 0x3b3, 0, };
-static const char32 __uni_decomp_data_0x1d7ad[] = { 0x3b4, 0, };
-static const char32 __uni_decomp_data_0x1d7ae[] = { 0x3b5, 0, };
-static const char32 __uni_decomp_data_0x1d7af[] = { 0x3b6, 0, };
-static const char32 __uni_decomp_data_0x1d7b0[] = { 0x3b7, 0, };
-static const char32 __uni_decomp_data_0x1d7b1[] = { 0x3b8, 0, };
-static const char32 __uni_decomp_data_0x1d7b2[] = { 0x3b9, 0, };
-static const char32 __uni_decomp_data_0x1d7b3[] = { 0x3ba, 0, };
-static const char32 __uni_decomp_data_0x1d7b4[] = { 0x3bb, 0, };
-static const char32 __uni_decomp_data_0x1d7b5[] = { 0x3bc, 0, };
-static const char32 __uni_decomp_data_0x1d7b6[] = { 0x3bd, 0, };
-static const char32 __uni_decomp_data_0x1d7b7[] = { 0x3be, 0, };
-static const char32 __uni_decomp_data_0x1d7b8[] = { 0x3bf, 0, };
-static const char32 __uni_decomp_data_0x1d7b9[] = { 0x3c0, 0, };
-static const char32 __uni_decomp_data_0x1d7ba[] = { 0x3c1, 0, };
-static const char32 __uni_decomp_data_0x1d7bb[] = { 0x3c2, 0, };
-static const char32 __uni_decomp_data_0x1d7bc[] = { 0x3c3, 0, };
-static const char32 __uni_decomp_data_0x1d7bd[] = { 0x3c4, 0, };
-static const char32 __uni_decomp_data_0x1d7be[] = { 0x3c5, 0, };
-static const char32 __uni_decomp_data_0x1d7bf[] = { 0x3c6, 0, };
-static const char32 __uni_decomp_data_0x1d7c0[] = { 0x3c7, 0, };
-static const char32 __uni_decomp_data_0x1d7c1[] = { 0x3c8, 0, };
-static const char32 __uni_decomp_data_0x1d7c2[] = { 0x3c9, 0, };
-static const char32 __uni_decomp_data_0x1d7c3[] = { 0x2202, 0, };
-static const char32 __uni_decomp_data_0x1d7c4[] = { 0x3f5, 0, };
-static const char32 __uni_decomp_data_0x1d7c5[] = { 0x3d1, 0, };
-static const char32 __uni_decomp_data_0x1d7c6[] = { 0x3f0, 0, };
-static const char32 __uni_decomp_data_0x1d7c7[] = { 0x3d5, 0, };
-static const char32 __uni_decomp_data_0x1d7c8[] = { 0x3f1, 0, };
-static const char32 __uni_decomp_data_0x1d7c9[] = { 0x3d6, 0, };
-static const char32 __uni_decomp_data_0x1d7ca[] = { 0x3dc, 0, };
-static const char32 __uni_decomp_data_0x1d7cb[] = { 0x3dd, 0, };
-static const char32 __uni_decomp_data_0x1d7ce[] = { 0x30, 0, };
-static const char32 __uni_decomp_data_0x1d7cf[] = { 0x31, 0, };
-static const char32 __uni_decomp_data_0x1d7d0[] = { 0x32, 0, };
-static const char32 __uni_decomp_data_0x1d7d1[] = { 0x33, 0, };
-static const char32 __uni_decomp_data_0x1d7d2[] = { 0x34, 0, };
-static const char32 __uni_decomp_data_0x1d7d3[] = { 0x35, 0, };
-static const char32 __uni_decomp_data_0x1d7d4[] = { 0x36, 0, };
-static const char32 __uni_decomp_data_0x1d7d5[] = { 0x37, 0, };
-static const char32 __uni_decomp_data_0x1d7d6[] = { 0x38, 0, };
-static const char32 __uni_decomp_data_0x1d7d7[] = { 0x39, 0, };
-static const char32 __uni_decomp_data_0x1d7d8[] = { 0x30, 0, };
-static const char32 __uni_decomp_data_0x1d7d9[] = { 0x31, 0, };
-static const char32 __uni_decomp_data_0x1d7da[] = { 0x32, 0, };
-static const char32 __uni_decomp_data_0x1d7db[] = { 0x33, 0, };
-static const char32 __uni_decomp_data_0x1d7dc[] = { 0x34, 0, };
-static const char32 __uni_decomp_data_0x1d7dd[] = { 0x35, 0, };
-static const char32 __uni_decomp_data_0x1d7de[] = { 0x36, 0, };
-static const char32 __uni_decomp_data_0x1d7df[] = { 0x37, 0, };
-static const char32 __uni_decomp_data_0x1d7e0[] = { 0x38, 0, };
-static const char32 __uni_decomp_data_0x1d7e1[] = { 0x39, 0, };
-static const char32 __uni_decomp_data_0x1d7e2[] = { 0x30, 0, };
-static const char32 __uni_decomp_data_0x1d7e3[] = { 0x31, 0, };
-static const char32 __uni_decomp_data_0x1d7e4[] = { 0x32, 0, };
-static const char32 __uni_decomp_data_0x1d7e5[] = { 0x33, 0, };
-static const char32 __uni_decomp_data_0x1d7e6[] = { 0x34, 0, };
-static const char32 __uni_decomp_data_0x1d7e7[] = { 0x35, 0, };
-static const char32 __uni_decomp_data_0x1d7e8[] = { 0x36, 0, };
-static const char32 __uni_decomp_data_0x1d7e9[] = { 0x37, 0, };
-static const char32 __uni_decomp_data_0x1d7ea[] = { 0x38, 0, };
-static const char32 __uni_decomp_data_0x1d7eb[] = { 0x39, 0, };
-static const char32 __uni_decomp_data_0x1d7ec[] = { 0x30, 0, };
-static const char32 __uni_decomp_data_0x1d7ed[] = { 0x31, 0, };
-static const char32 __uni_decomp_data_0x1d7ee[] = { 0x32, 0, };
-static const char32 __uni_decomp_data_0x1d7ef[] = { 0x33, 0, };
-static const char32 __uni_decomp_data_0x1d7f0[] = { 0x34, 0, };
-static const char32 __uni_decomp_data_0x1d7f1[] = { 0x35, 0, };
-static const char32 __uni_decomp_data_0x1d7f2[] = { 0x36, 0, };
-static const char32 __uni_decomp_data_0x1d7f3[] = { 0x37, 0, };
-static const char32 __uni_decomp_data_0x1d7f4[] = { 0x38, 0, };
-static const char32 __uni_decomp_data_0x1d7f5[] = { 0x39, 0, };
-static const char32 __uni_decomp_data_0x1d7f6[] = { 0x30, 0, };
-static const char32 __uni_decomp_data_0x1d7f7[] = { 0x31, 0, };
-static const char32 __uni_decomp_data_0x1d7f8[] = { 0x32, 0, };
-static const char32 __uni_decomp_data_0x1d7f9[] = { 0x33, 0, };
-static const char32 __uni_decomp_data_0x1d7fa[] = { 0x34, 0, };
-static const char32 __uni_decomp_data_0x1d7fb[] = { 0x35, 0, };
-static const char32 __uni_decomp_data_0x1d7fc[] = { 0x36, 0, };
-static const char32 __uni_decomp_data_0x1d7fd[] = { 0x37, 0, };
-static const char32 __uni_decomp_data_0x1d7fe[] = { 0x38, 0, };
-static const char32 __uni_decomp_data_0x1d7ff[] = { 0x39, 0, };
+static const char32 __uni_decomp_data_0x1d780[] = { 1, 0x3c1, };
+static const char32 __uni_decomp_data_0x1d781[] = { 1, 0x3c2, };
+static const char32 __uni_decomp_data_0x1d782[] = { 1, 0x3c3, };
+static const char32 __uni_decomp_data_0x1d783[] = { 1, 0x3c4, };
+static const char32 __uni_decomp_data_0x1d784[] = { 1, 0x3c5, };
+static const char32 __uni_decomp_data_0x1d785[] = { 1, 0x3c6, };
+static const char32 __uni_decomp_data_0x1d786[] = { 1, 0x3c7, };
+static const char32 __uni_decomp_data_0x1d787[] = { 1, 0x3c8, };
+static const char32 __uni_decomp_data_0x1d788[] = { 1, 0x3c9, };
+static const char32 __uni_decomp_data_0x1d789[] = { 1, 0x2202, };
+static const char32 __uni_decomp_data_0x1d78a[] = { 1, 0x3f5, };
+static const char32 __uni_decomp_data_0x1d78b[] = { 1, 0x3d1, };
+static const char32 __uni_decomp_data_0x1d78c[] = { 1, 0x3f0, };
+static const char32 __uni_decomp_data_0x1d78d[] = { 1, 0x3d5, };
+static const char32 __uni_decomp_data_0x1d78e[] = { 1, 0x3f1, };
+static const char32 __uni_decomp_data_0x1d78f[] = { 1, 0x3d6, };
+static const char32 __uni_decomp_data_0x1d790[] = { 1, 0x391, };
+static const char32 __uni_decomp_data_0x1d791[] = { 1, 0x392, };
+static const char32 __uni_decomp_data_0x1d792[] = { 1, 0x393, };
+static const char32 __uni_decomp_data_0x1d793[] = { 1, 0x394, };
+static const char32 __uni_decomp_data_0x1d794[] = { 1, 0x395, };
+static const char32 __uni_decomp_data_0x1d795[] = { 1, 0x396, };
+static const char32 __uni_decomp_data_0x1d796[] = { 1, 0x397, };
+static const char32 __uni_decomp_data_0x1d797[] = { 1, 0x398, };
+static const char32 __uni_decomp_data_0x1d798[] = { 1, 0x399, };
+static const char32 __uni_decomp_data_0x1d799[] = { 1, 0x39a, };
+static const char32 __uni_decomp_data_0x1d79a[] = { 1, 0x39b, };
+static const char32 __uni_decomp_data_0x1d79b[] = { 1, 0x39c, };
+static const char32 __uni_decomp_data_0x1d79c[] = { 1, 0x39d, };
+static const char32 __uni_decomp_data_0x1d79d[] = { 1, 0x39e, };
+static const char32 __uni_decomp_data_0x1d79e[] = { 1, 0x39f, };
+static const char32 __uni_decomp_data_0x1d79f[] = { 1, 0x3a0, };
+static const char32 __uni_decomp_data_0x1d7a0[] = { 1, 0x3a1, };
+static const char32 __uni_decomp_data_0x1d7a1[] = { 1, 0x3f4, };
+static const char32 __uni_decomp_data_0x1d7a2[] = { 1, 0x3a3, };
+static const char32 __uni_decomp_data_0x1d7a3[] = { 1, 0x3a4, };
+static const char32 __uni_decomp_data_0x1d7a4[] = { 1, 0x3a5, };
+static const char32 __uni_decomp_data_0x1d7a5[] = { 1, 0x3a6, };
+static const char32 __uni_decomp_data_0x1d7a6[] = { 1, 0x3a7, };
+static const char32 __uni_decomp_data_0x1d7a7[] = { 1, 0x3a8, };
+static const char32 __uni_decomp_data_0x1d7a8[] = { 1, 0x3a9, };
+static const char32 __uni_decomp_data_0x1d7a9[] = { 1, 0x2207, };
+static const char32 __uni_decomp_data_0x1d7aa[] = { 1, 0x3b1, };
+static const char32 __uni_decomp_data_0x1d7ab[] = { 1, 0x3b2, };
+static const char32 __uni_decomp_data_0x1d7ac[] = { 1, 0x3b3, };
+static const char32 __uni_decomp_data_0x1d7ad[] = { 1, 0x3b4, };
+static const char32 __uni_decomp_data_0x1d7ae[] = { 1, 0x3b5, };
+static const char32 __uni_decomp_data_0x1d7af[] = { 1, 0x3b6, };
+static const char32 __uni_decomp_data_0x1d7b0[] = { 1, 0x3b7, };
+static const char32 __uni_decomp_data_0x1d7b1[] = { 1, 0x3b8, };
+static const char32 __uni_decomp_data_0x1d7b2[] = { 1, 0x3b9, };
+static const char32 __uni_decomp_data_0x1d7b3[] = { 1, 0x3ba, };
+static const char32 __uni_decomp_data_0x1d7b4[] = { 1, 0x3bb, };
+static const char32 __uni_decomp_data_0x1d7b5[] = { 1, 0x3bc, };
+static const char32 __uni_decomp_data_0x1d7b6[] = { 1, 0x3bd, };
+static const char32 __uni_decomp_data_0x1d7b7[] = { 1, 0x3be, };
+static const char32 __uni_decomp_data_0x1d7b8[] = { 1, 0x3bf, };
+static const char32 __uni_decomp_data_0x1d7b9[] = { 1, 0x3c0, };
+static const char32 __uni_decomp_data_0x1d7ba[] = { 1, 0x3c1, };
+static const char32 __uni_decomp_data_0x1d7bb[] = { 1, 0x3c2, };
+static const char32 __uni_decomp_data_0x1d7bc[] = { 1, 0x3c3, };
+static const char32 __uni_decomp_data_0x1d7bd[] = { 1, 0x3c4, };
+static const char32 __uni_decomp_data_0x1d7be[] = { 1, 0x3c5, };
+static const char32 __uni_decomp_data_0x1d7bf[] = { 1, 0x3c6, };
+static const char32 __uni_decomp_data_0x1d7c0[] = { 1, 0x3c7, };
+static const char32 __uni_decomp_data_0x1d7c1[] = { 1, 0x3c8, };
+static const char32 __uni_decomp_data_0x1d7c2[] = { 1, 0x3c9, };
+static const char32 __uni_decomp_data_0x1d7c3[] = { 1, 0x2202, };
+static const char32 __uni_decomp_data_0x1d7c4[] = { 1, 0x3f5, };
+static const char32 __uni_decomp_data_0x1d7c5[] = { 1, 0x3d1, };
+static const char32 __uni_decomp_data_0x1d7c6[] = { 1, 0x3f0, };
+static const char32 __uni_decomp_data_0x1d7c7[] = { 1, 0x3d5, };
+static const char32 __uni_decomp_data_0x1d7c8[] = { 1, 0x3f1, };
+static const char32 __uni_decomp_data_0x1d7c9[] = { 1, 0x3d6, };
+static const char32 __uni_decomp_data_0x1d7ca[] = { 1, 0x3dc, };
+static const char32 __uni_decomp_data_0x1d7cb[] = { 1, 0x3dd, };
+static const char32 __uni_decomp_data_0x1d7ce[] = { 1, 0x30, };
+static const char32 __uni_decomp_data_0x1d7cf[] = { 1, 0x31, };
+static const char32 __uni_decomp_data_0x1d7d0[] = { 1, 0x32, };
+static const char32 __uni_decomp_data_0x1d7d1[] = { 1, 0x33, };
+static const char32 __uni_decomp_data_0x1d7d2[] = { 1, 0x34, };
+static const char32 __uni_decomp_data_0x1d7d3[] = { 1, 0x35, };
+static const char32 __uni_decomp_data_0x1d7d4[] = { 1, 0x36, };
+static const char32 __uni_decomp_data_0x1d7d5[] = { 1, 0x37, };
+static const char32 __uni_decomp_data_0x1d7d6[] = { 1, 0x38, };
+static const char32 __uni_decomp_data_0x1d7d7[] = { 1, 0x39, };
+static const char32 __uni_decomp_data_0x1d7d8[] = { 1, 0x30, };
+static const char32 __uni_decomp_data_0x1d7d9[] = { 1, 0x31, };
+static const char32 __uni_decomp_data_0x1d7da[] = { 1, 0x32, };
+static const char32 __uni_decomp_data_0x1d7db[] = { 1, 0x33, };
+static const char32 __uni_decomp_data_0x1d7dc[] = { 1, 0x34, };
+static const char32 __uni_decomp_data_0x1d7dd[] = { 1, 0x35, };
+static const char32 __uni_decomp_data_0x1d7de[] = { 1, 0x36, };
+static const char32 __uni_decomp_data_0x1d7df[] = { 1, 0x37, };
+static const char32 __uni_decomp_data_0x1d7e0[] = { 1, 0x38, };
+static const char32 __uni_decomp_data_0x1d7e1[] = { 1, 0x39, };
+static const char32 __uni_decomp_data_0x1d7e2[] = { 1, 0x30, };
+static const char32 __uni_decomp_data_0x1d7e3[] = { 1, 0x31, };
+static const char32 __uni_decomp_data_0x1d7e4[] = { 1, 0x32, };
+static const char32 __uni_decomp_data_0x1d7e5[] = { 1, 0x33, };
+static const char32 __uni_decomp_data_0x1d7e6[] = { 1, 0x34, };
+static const char32 __uni_decomp_data_0x1d7e7[] = { 1, 0x35, };
+static const char32 __uni_decomp_data_0x1d7e8[] = { 1, 0x36, };
+static const char32 __uni_decomp_data_0x1d7e9[] = { 1, 0x37, };
+static const char32 __uni_decomp_data_0x1d7ea[] = { 1, 0x38, };
+static const char32 __uni_decomp_data_0x1d7eb[] = { 1, 0x39, };
+static const char32 __uni_decomp_data_0x1d7ec[] = { 1, 0x30, };
+static const char32 __uni_decomp_data_0x1d7ed[] = { 1, 0x31, };
+static const char32 __uni_decomp_data_0x1d7ee[] = { 1, 0x32, };
+static const char32 __uni_decomp_data_0x1d7ef[] = { 1, 0x33, };
+static const char32 __uni_decomp_data_0x1d7f0[] = { 1, 0x34, };
+static const char32 __uni_decomp_data_0x1d7f1[] = { 1, 0x35, };
+static const char32 __uni_decomp_data_0x1d7f2[] = { 1, 0x36, };
+static const char32 __uni_decomp_data_0x1d7f3[] = { 1, 0x37, };
+static const char32 __uni_decomp_data_0x1d7f4[] = { 1, 0x38, };
+static const char32 __uni_decomp_data_0x1d7f5[] = { 1, 0x39, };
+static const char32 __uni_decomp_data_0x1d7f6[] = { 1, 0x30, };
+static const char32 __uni_decomp_data_0x1d7f7[] = { 1, 0x31, };
+static const char32 __uni_decomp_data_0x1d7f8[] = { 1, 0x32, };
+static const char32 __uni_decomp_data_0x1d7f9[] = { 1, 0x33, };
+static const char32 __uni_decomp_data_0x1d7fa[] = { 1, 0x34, };
+static const char32 __uni_decomp_data_0x1d7fb[] = { 1, 0x35, };
+static const char32 __uni_decomp_data_0x1d7fc[] = { 1, 0x36, };
+static const char32 __uni_decomp_data_0x1d7fd[] = { 1, 0x37, };
+static const char32 __uni_decomp_data_0x1d7fe[] = { 1, 0x38, };
+static const char32 __uni_decomp_data_0x1d7ff[] = { 1, 0x39, };
 
 
 
@@ -36163,134 +36163,134 @@
 };
 
 
-static const char32 __uni_decomp_data_0x2f800[] = { 0x4e3d, 0, };
-static const char32 __uni_decomp_data_0x2f801[] = { 0x4e38, 0, };
-static const char32 __uni_decomp_data_0x2f802[] = { 0x4e41, 0, };
-static const char32 __uni_decomp_data_0x2f803[] = { 0x20122, 0, };
-static const char32 __uni_decomp_data_0x2f804[] = { 0x4f60, 0, };
-static const char32 __uni_decomp_data_0x2f805[] = { 0x4fae, 0, };
-static const char32 __uni_decomp_data_0x2f806[] = { 0x4fbb, 0, };
-static const char32 __uni_decomp_data_0x2f807[] = { 0x5002, 0, };
-static const char32 __uni_decomp_data_0x2f808[] = { 0x507a, 0, };
-static const char32 __uni_decomp_data_0x2f809[] = { 0x5099, 0, };
-static const char32 __uni_decomp_data_0x2f80a[] = { 0x50e7, 0, };
-static const char32 __uni_decomp_data_0x2f80b[] = { 0x50cf, 0, };
-static const char32 __uni_decomp_data_0x2f80c[] = { 0x349e, 0, };
-static const char32 __uni_decomp_data_0x2f80d[] = { 0x2063a, 0, };
-static const char32 __uni_decomp_data_0x2f80e[] = { 0x514d, 0, };
-static const char32 __uni_decomp_data_0x2f80f[] = { 0x5154, 0, };
-static const char32 __uni_decomp_data_0x2f810[] = { 0x5164, 0, };
-static const char32 __uni_decomp_data_0x2f811[] = { 0x5177, 0, };
-static const char32 __uni_decomp_data_0x2f812[] = { 0x2051c, 0, };
-static const char32 __uni_decomp_data_0x2f813[] = { 0x34b9, 0, };
-static const char32 __uni_decomp_data_0x2f814[] = { 0x5167, 0, };
-static const char32 __uni_decomp_data_0x2f815[] = { 0x518d, 0, };
-static const char32 __uni_decomp_data_0x2f816[] = { 0x2054b, 0, };
-static const char32 __uni_decomp_data_0x2f817[] = { 0x5197, 0, };
-static const char32 __uni_decomp_data_0x2f818[] = { 0x51a4, 0, };
-static const char32 __uni_decomp_data_0x2f819[] = { 0x4ecc, 0, };
-static const char32 __uni_decomp_data_0x2f81a[] = { 0x51ac, 0, };
-static const char32 __uni_decomp_data_0x2f81b[] = { 0x51b5, 0, };
-static const char32 __uni_decomp_data_0x2f81c[] = { 0x291df, 0, };
-static const char32 __uni_decomp_data_0x2f81d[] = { 0x51f5, 0, };
-static const char32 __uni_decomp_data_0x2f81e[] = { 0x5203, 0, };
-static const char32 __uni_decomp_data_0x2f81f[] = { 0x34df, 0, };
-static const char32 __uni_decomp_data_0x2f820[] = { 0x523b, 0, };
-static const char32 __uni_decomp_data_0x2f821[] = { 0x5246, 0, };
-static const char32 __uni_decomp_data_0x2f822[] = { 0x5272, 0, };
-static const char32 __uni_decomp_data_0x2f823[] = { 0x5277, 0, };
-static const char32 __uni_decomp_data_0x2f824[] = { 0x3515, 0, };
-static const char32 __uni_decomp_data_0x2f825[] = { 0x52c7, 0, };
-static const char32 __uni_decomp_data_0x2f826[] = { 0x52c9, 0, };
-static const char32 __uni_decomp_data_0x2f827[] = { 0x52e4, 0, };
-static const char32 __uni_decomp_data_0x2f828[] = { 0x52fa, 0, };
-static const char32 __uni_decomp_data_0x2f829[] = { 0x5305, 0, };
-static const char32 __uni_decomp_data_0x2f82a[] = { 0x5306, 0, };
-static const char32 __uni_decomp_data_0x2f82b[] = { 0x5317, 0, };
-static const char32 __uni_decomp_data_0x2f82c[] = { 0x5349, 0, };
-static const char32 __uni_decomp_data_0x2f82d[] = { 0x5351, 0, };
-static const char32 __uni_decomp_data_0x2f82e[] = { 0x535a, 0, };
-static const char32 __uni_decomp_data_0x2f82f[] = { 0x5373, 0, };
-static const char32 __uni_decomp_data_0x2f830[] = { 0x537d, 0, };
-static const char32 __uni_decomp_data_0x2f831[] = { 0x537f, 0, };
-static const char32 __uni_decomp_data_0x2f832[] = { 0x537f, 0, };
-static const char32 __uni_decomp_data_0x2f833[] = { 0x537f, 0, };
-static const char32 __uni_decomp_data_0x2f834[] = { 0x20a2c, 0, };
-static const char32 __uni_decomp_data_0x2f835[] = { 0x7070, 0, };
-static const char32 __uni_decomp_data_0x2f836[] = { 0x53ca, 0, };
-static const char32 __uni_decomp_data_0x2f837[] = { 0x53df, 0, };
-static const char32 __uni_decomp_data_0x2f838[] = { 0x20b63, 0, };
-static const char32 __uni_decomp_data_0x2f839[] = { 0x53eb, 0, };
-static const char32 __uni_decomp_data_0x2f83a[] = { 0x53f1, 0, };
-static const char32 __uni_decomp_data_0x2f83b[] = { 0x5406, 0, };
-static const char32 __uni_decomp_data_0x2f83c[] = { 0x549e, 0, };
-static const char32 __uni_decomp_data_0x2f83d[] = { 0x5438, 0, };
-static const char32 __uni_decomp_data_0x2f83e[] = { 0x5448, 0, };
-static const char32 __uni_decomp_data_0x2f83f[] = { 0x5468, 0, };
-static const char32 __uni_decomp_data_0x2f840[] = { 0x54a2, 0, };
-static const char32 __uni_decomp_data_0x2f841[] = { 0x54f6, 0, };
-static const char32 __uni_decomp_data_0x2f842[] = { 0x5510, 0, };
-static const char32 __uni_decomp_data_0x2f843[] = { 0x5553, 0, };
-static const char32 __uni_decomp_data_0x2f844[] = { 0x5563, 0, };
-static const char32 __uni_decomp_data_0x2f845[] = { 0x5584, 0, };
-static const char32 __uni_decomp_data_0x2f846[] = { 0x5584, 0, };
-static const char32 __uni_decomp_data_0x2f847[] = { 0x5599, 0, };
-static const char32 __uni_decomp_data_0x2f848[] = { 0x55ab, 0, };
-static const char32 __uni_decomp_data_0x2f849[] = { 0x55b3, 0, };
-static const char32 __uni_decomp_data_0x2f84a[] = { 0x55c2, 0, };
-static const char32 __uni_decomp_data_0x2f84b[] = { 0x5716, 0, };
-static const char32 __uni_decomp_data_0x2f84c[] = { 0x5606, 0, };
-static const char32 __uni_decomp_data_0x2f84d[] = { 0x5717, 0, };
-static const char32 __uni_decomp_data_0x2f84e[] = { 0x5651, 0, };
-static const char32 __uni_decomp_data_0x2f84f[] = { 0x5674, 0, };
-static const char32 __uni_decomp_data_0x2f850[] = { 0x5207, 0, };
-static const char32 __uni_decomp_data_0x2f851[] = { 0x58ee, 0, };
-static const char32 __uni_decomp_data_0x2f852[] = { 0x57ce, 0, };
-static const char32 __uni_decomp_data_0x2f853[] = { 0x57f4, 0, };
-static const char32 __uni_decomp_data_0x2f854[] = { 0x580d, 0, };
-static const char32 __uni_decomp_data_0x2f855[] = { 0x578b, 0, };
-static const char32 __uni_decomp_data_0x2f856[] = { 0x5832, 0, };
-static const char32 __uni_decomp_data_0x2f857[] = { 0x5831, 0, };
-static const char32 __uni_decomp_data_0x2f858[] = { 0x58ac, 0, };
-static const char32 __uni_decomp_data_0x2f859[] = { 0x214e4, 0, };
-static const char32 __uni_decomp_data_0x2f85a[] = { 0x58f2, 0, };
-static const char32 __uni_decomp_data_0x2f85b[] = { 0x58f7, 0, };
-static const char32 __uni_decomp_data_0x2f85c[] = { 0x5906, 0, };
-static const char32 __uni_decomp_data_0x2f85d[] = { 0x591a, 0, };
-static const char32 __uni_decomp_data_0x2f85e[] = { 0x5922, 0, };
-static const char32 __uni_decomp_data_0x2f85f[] = { 0x5962, 0, };
-static const char32 __uni_decomp_data_0x2f860[] = { 0x216a8, 0, };
-static const char32 __uni_decomp_data_0x2f861[] = { 0x216ea, 0, };
-static const char32 __uni_decomp_data_0x2f862[] = { 0x59ec, 0, };
-static const char32 __uni_decomp_data_0x2f863[] = { 0x5a1b, 0, };
-static const char32 __uni_decomp_data_0x2f864[] = { 0x5a27, 0, };
-static const char32 __uni_decomp_data_0x2f865[] = { 0x59d8, 0, };
-static const char32 __uni_decomp_data_0x2f866[] = { 0x5a66, 0, };
-static const char32 __uni_decomp_data_0x2f867[] = { 0x36ee, 0, };
-static const char32 __uni_decomp_data_0x2f868[] = { 0x36fc, 0, };
-static const char32 __uni_decomp_data_0x2f869[] = { 0x5b08, 0, };
-static const char32 __uni_decomp_data_0x2f86a[] = { 0x5b3e, 0, };
-static const char32 __uni_decomp_data_0x2f86b[] = { 0x5b3e, 0, };
-static const char32 __uni_decomp_data_0x2f86c[] = { 0x219c8, 0, };
-static const char32 __uni_decomp_data_0x2f86d[] = { 0x5bc3, 0, };
-static const char32 __uni_decomp_data_0x2f86e[] = { 0x5bd8, 0, };
-static const char32 __uni_decomp_data_0x2f86f[] = { 0x5be7, 0, };
-static const char32 __uni_decomp_data_0x2f870[] = { 0x5bf3, 0, };
-static const char32 __uni_decomp_data_0x2f871[] = { 0x21b18, 0, };
-static const char32 __uni_decomp_data_0x2f872[] = { 0x5bff, 0, };
-static const char32 __uni_decomp_data_0x2f873[] = { 0x5c06, 0, };
-static const char32 __uni_decomp_data_0x2f874[] = { 0x5f53, 0, };
-static const char32 __uni_decomp_data_0x2f875[] = { 0x5c22, 0, };
-static const char32 __uni_decomp_data_0x2f876[] = { 0x3781, 0, };
-static const char32 __uni_decomp_data_0x2f877[] = { 0x5c60, 0, };
-static const char32 __uni_decomp_data_0x2f878[] = { 0x5c6e, 0, };
-static const char32 __uni_decomp_data_0x2f879[] = { 0x5cc0, 0, };
-static const char32 __uni_decomp_data_0x2f87a[] = { 0x5c8d, 0, };
-static const char32 __uni_decomp_data_0x2f87b[] = { 0x21de4, 0, };
-static const char32 __uni_decomp_data_0x2f87c[] = { 0x5d43, 0, };
-static const char32 __uni_decomp_data_0x2f87d[] = { 0x21de6, 0, };
-static const char32 __uni_decomp_data_0x2f87e[] = { 0x5d6e, 0, };
-static const char32 __uni_decomp_data_0x2f87f[] = { 0x5d6b, 0, };
+static const char32 __uni_decomp_data_0x2f800[] = { 1, 0x4e3d, };
+static const char32 __uni_decomp_data_0x2f801[] = { 1, 0x4e38, };
+static const char32 __uni_decomp_data_0x2f802[] = { 1, 0x4e41, };
+static const char32 __uni_decomp_data_0x2f803[] = { 1, 0x20122, };
+static const char32 __uni_decomp_data_0x2f804[] = { 1, 0x4f60, };
+static const char32 __uni_decomp_data_0x2f805[] = { 1, 0x4fae, };
+static const char32 __uni_decomp_data_0x2f806[] = { 1, 0x4fbb, };
+static const char32 __uni_decomp_data_0x2f807[] = { 1, 0x5002, };
+static const char32 __uni_decomp_data_0x2f808[] = { 1, 0x507a, };
+static const char32 __uni_decomp_data_0x2f809[] = { 1, 0x5099, };
+static const char32 __uni_decomp_data_0x2f80a[] = { 1, 0x50e7, };
+static const char32 __uni_decomp_data_0x2f80b[] = { 1, 0x50cf, };
+static const char32 __uni_decomp_data_0x2f80c[] = { 1, 0x349e, };
+static const char32 __uni_decomp_data_0x2f80d[] = { 1, 0x2063a, };
+static const char32 __uni_decomp_data_0x2f80e[] = { 1, 0x514d, };
+static const char32 __uni_decomp_data_0x2f80f[] = { 1, 0x5154, };
+static const char32 __uni_decomp_data_0x2f810[] = { 1, 0x5164, };
+static const char32 __uni_decomp_data_0x2f811[] = { 1, 0x5177, };
+static const char32 __uni_decomp_data_0x2f812[] = { 1, 0x2051c, };
+static const char32 __uni_decomp_data_0x2f813[] = { 1, 0x34b9, };
+static const char32 __uni_decomp_data_0x2f814[] = { 1, 0x5167, };
+static const char32 __uni_decomp_data_0x2f815[] = { 1, 0x518d, };
+static const char32 __uni_decomp_data_0x2f816[] = { 1, 0x2054b, };
+static const char32 __uni_decomp_data_0x2f817[] = { 1, 0x5197, };
+static const char32 __uni_decomp_data_0x2f818[] = { 1, 0x51a4, };
+static const char32 __uni_decomp_data_0x2f819[] = { 1, 0x4ecc, };
+static const char32 __uni_decomp_data_0x2f81a[] = { 1, 0x51ac, };
+static const char32 __uni_decomp_data_0x2f81b[] = { 1, 0x51b5, };
+static const char32 __uni_decomp_data_0x2f81c[] = { 1, 0x291df, };
+static const char32 __uni_decomp_data_0x2f81d[] = { 1, 0x51f5, };
+static const char32 __uni_decomp_data_0x2f81e[] = { 1, 0x5203, };
+static const char32 __uni_decomp_data_0x2f81f[] = { 1, 0x34df, };
+static const char32 __uni_decomp_data_0x2f820[] = { 1, 0x523b, };
+static const char32 __uni_decomp_data_0x2f821[] = { 1, 0x5246, };
+static const char32 __uni_decomp_data_0x2f822[] = { 1, 0x5272, };
+static const char32 __uni_decomp_data_0x2f823[] = { 1, 0x5277, };
+static const char32 __uni_decomp_data_0x2f824[] = { 1, 0x3515, };
+static const char32 __uni_decomp_data_0x2f825[] = { 1, 0x52c7, };
+static const char32 __uni_decomp_data_0x2f826[] = { 1, 0x52c9, };
+static const char32 __uni_decomp_data_0x2f827[] = { 1, 0x52e4, };
+static const char32 __uni_decomp_data_0x2f828[] = { 1, 0x52fa, };
+static const char32 __uni_decomp_data_0x2f829[] = { 1, 0x5305, };
+static const char32 __uni_decomp_data_0x2f82a[] = { 1, 0x5306, };
+static const char32 __uni_decomp_data_0x2f82b[] = { 1, 0x5317, };
+static const char32 __uni_decomp_data_0x2f82c[] = { 1, 0x5349, };
+static const char32 __uni_decomp_data_0x2f82d[] = { 1, 0x5351, };
+static const char32 __uni_decomp_data_0x2f82e[] = { 1, 0x535a, };
+static const char32 __uni_decomp_data_0x2f82f[] = { 1, 0x5373, };
+static const char32 __uni_decomp_data_0x2f830[] = { 1, 0x537d, };
+static const char32 __uni_decomp_data_0x2f831[] = { 1, 0x537f, };
+static const char32 __uni_decomp_data_0x2f832[] = { 1, 0x537f, };
+static const char32 __uni_decomp_data_0x2f833[] = { 1, 0x537f, };
+static const char32 __uni_decomp_data_0x2f834[] = { 1, 0x20a2c, };
+static const char32 __uni_decomp_data_0x2f835[] = { 1, 0x7070, };
+static const char32 __uni_decomp_data_0x2f836[] = { 1, 0x53ca, };
+static const char32 __uni_decomp_data_0x2f837[] = { 1, 0x53df, };
+static const char32 __uni_decomp_data_0x2f838[] = { 1, 0x20b63, };
+static const char32 __uni_decomp_data_0x2f839[] = { 1, 0x53eb, };
+static const char32 __uni_decomp_data_0x2f83a[] = { 1, 0x53f1, };
+static const char32 __uni_decomp_data_0x2f83b[] = { 1, 0x5406, };
+static const char32 __uni_decomp_data_0x2f83c[] = { 1, 0x549e, };
+static const char32 __uni_decomp_data_0x2f83d[] = { 1, 0x5438, };
+static const char32 __uni_decomp_data_0x2f83e[] = { 1, 0x5448, };
+static const char32 __uni_decomp_data_0x2f83f[] = { 1, 0x5468, };
+static const char32 __uni_decomp_data_0x2f840[] = { 1, 0x54a2, };
+static const char32 __uni_decomp_data_0x2f841[] = { 1, 0x54f6, };
+static const char32 __uni_decomp_data_0x2f842[] = { 1, 0x5510, };
+static const char32 __uni_decomp_data_0x2f843[] = { 1, 0x5553, };
+static const char32 __uni_decomp_data_0x2f844[] = { 1, 0x5563, };
+static const char32 __uni_decomp_data_0x2f845[] = { 1, 0x5584, };
+static const char32 __uni_decomp_data_0x2f846[] = { 1, 0x5584, };
+static const char32 __uni_decomp_data_0x2f847[] = { 1, 0x5599, };
+static const char32 __uni_decomp_data_0x2f848[] = { 1, 0x55ab, };
+static const char32 __uni_decomp_data_0x2f849[] = { 1, 0x55b3, };
+static const char32 __uni_decomp_data_0x2f84a[] = { 1, 0x55c2, };
+static const char32 __uni_decomp_data_0x2f84b[] = { 1, 0x5716, };
+static const char32 __uni_decomp_data_0x2f84c[] = { 1, 0x5606, };
+static const char32 __uni_decomp_data_0x2f84d[] = { 1, 0x5717, };
+static const char32 __uni_decomp_data_0x2f84e[] = { 1, 0x5651, };
+static const char32 __uni_decomp_data_0x2f84f[] = { 1, 0x5674, };
+static const char32 __uni_decomp_data_0x2f850[] = { 1, 0x5207, };
+static const char32 __uni_decomp_data_0x2f851[] = { 1, 0x58ee, };
+static const char32 __uni_decomp_data_0x2f852[] = { 1, 0x57ce, };
+static const char32 __uni_decomp_data_0x2f853[] = { 1, 0x57f4, };
+static const char32 __uni_decomp_data_0x2f854[] = { 1, 0x580d, };
+static const char32 __uni_decomp_data_0x2f855[] = { 1, 0x578b, };
+static const char32 __uni_decomp_data_0x2f856[] = { 1, 0x5832, };
+static const char32 __uni_decomp_data_0x2f857[] = { 1, 0x5831, };
+static const char32 __uni_decomp_data_0x2f858[] = { 1, 0x58ac, };
+static const char32 __uni_decomp_data_0x2f859[] = { 1, 0x214e4, };
+static const char32 __uni_decomp_data_0x2f85a[] = { 1, 0x58f2, };
+static const char32 __uni_decomp_data_0x2f85b[] = { 1, 0x58f7, };
+static const char32 __uni_decomp_data_0x2f85c[] = { 1, 0x5906, };
+static const char32 __uni_decomp_data_0x2f85d[] = { 1, 0x591a, };
+static const char32 __uni_decomp_data_0x2f85e[] = { 1, 0x5922, };
+static const char32 __uni_decomp_data_0x2f85f[] = { 1, 0x5962, };
+static const char32 __uni_decomp_data_0x2f860[] = { 1, 0x216a8, };
+static const char32 __uni_decomp_data_0x2f861[] = { 1, 0x216ea, };
+static const char32 __uni_decomp_data_0x2f862[] = { 1, 0x59ec, };
+static const char32 __uni_decomp_data_0x2f863[] = { 1, 0x5a1b, };
+static const char32 __uni_decomp_data_0x2f864[] = { 1, 0x5a27, };
+static const char32 __uni_decomp_data_0x2f865[] = { 1, 0x59d8, };
+static const char32 __uni_decomp_data_0x2f866[] = { 1, 0x5a66, };
+static const char32 __uni_decomp_data_0x2f867[] = { 1, 0x36ee, };
+static const char32 __uni_decomp_data_0x2f868[] = { 1, 0x36fc, };
+static const char32 __uni_decomp_data_0x2f869[] = { 1, 0x5b08, };
+static const char32 __uni_decomp_data_0x2f86a[] = { 1, 0x5b3e, };
+static const char32 __uni_decomp_data_0x2f86b[] = { 1, 0x5b3e, };
+static const char32 __uni_decomp_data_0x2f86c[] = { 1, 0x219c8, };
+static const char32 __uni_decomp_data_0x2f86d[] = { 1, 0x5bc3, };
+static const char32 __uni_decomp_data_0x2f86e[] = { 1, 0x5bd8, };
+static const char32 __uni_decomp_data_0x2f86f[] = { 1, 0x5be7, };
+static const char32 __uni_decomp_data_0x2f870[] = { 1, 0x5bf3, };
+static const char32 __uni_decomp_data_0x2f871[] = { 1, 0x21b18, };
+static const char32 __uni_decomp_data_0x2f872[] = { 1, 0x5bff, };
+static const char32 __uni_decomp_data_0x2f873[] = { 1, 0x5c06, };
+static const char32 __uni_decomp_data_0x2f874[] = { 1, 0x5f53, };
+static const char32 __uni_decomp_data_0x2f875[] = { 1, 0x5c22, };
+static const char32 __uni_decomp_data_0x2f876[] = { 1, 0x3781, };
+static const char32 __uni_decomp_data_0x2f877[] = { 1, 0x5c60, };
+static const char32 __uni_decomp_data_0x2f878[] = { 1, 0x5c6e, };
+static const char32 __uni_decomp_data_0x2f879[] = { 1, 0x5cc0, };
+static const char32 __uni_decomp_data_0x2f87a[] = { 1, 0x5c8d, };
+static const char32 __uni_decomp_data_0x2f87b[] = { 1, 0x21de4, };
+static const char32 __uni_decomp_data_0x2f87c[] = { 1, 0x5d43, };
+static const char32 __uni_decomp_data_0x2f87d[] = { 1, 0x21de6, };
+static const char32 __uni_decomp_data_0x2f87e[] = { 1, 0x5d6e, };
+static const char32 __uni_decomp_data_0x2f87f[] = { 1, 0x5d6b, };
 
 
 
@@ -37964,134 +37964,134 @@
 };
 
 
-static const char32 __uni_decomp_data_0x2f880[] = { 0x5d7c, 0, };
-static const char32 __uni_decomp_data_0x2f881[] = { 0x5de1, 0, };
-static const char32 __uni_decomp_data_0x2f882[] = { 0x5de2, 0, };
-static const char32 __uni_decomp_data_0x2f883[] = { 0x382f, 0, };
-static const char32 __uni_decomp_data_0x2f884[] = { 0x5dfd, 0, };
-static const char32 __uni_decomp_data_0x2f885[] = { 0x5e28, 0, };
-static const char32 __uni_decomp_data_0x2f886[] = { 0x5e3d, 0, };
-static const char32 __uni_decomp_data_0x2f887[] = { 0x5e69, 0, };
-static const char32 __uni_decomp_data_0x2f888[] = { 0x3862, 0, };
-static const char32 __uni_decomp_data_0x2f889[] = { 0x22183, 0, };
-static const char32 __uni_decomp_data_0x2f88a[] = { 0x387c, 0, };
-static const char32 __uni_decomp_data_0x2f88b[] = { 0x5eb0, 0, };
-static const char32 __uni_decomp_data_0x2f88c[] = { 0x5eb3, 0, };
-static const char32 __uni_decomp_data_0x2f88d[] = { 0x5eb6, 0, };
-static const char32 __uni_decomp_data_0x2f88e[] = { 0x5eca, 0, };
-static const char32 __uni_decomp_data_0x2f88f[] = { 0x2a392, 0, };
-static const char32 __uni_decomp_data_0x2f890[] = { 0x5efe, 0, };
-static const char32 __uni_decomp_data_0x2f891[] = { 0x22331, 0, };
-static const char32 __uni_decomp_data_0x2f892[] = { 0x22331, 0, };
-static const char32 __uni_decomp_data_0x2f893[] = { 0x8201, 0, };
-static const char32 __uni_decomp_data_0x2f894[] = { 0x5f22, 0, };
-static const char32 __uni_decomp_data_0x2f895[] = { 0x5f22, 0, };
-static const char32 __uni_decomp_data_0x2f896[] = { 0x38c7, 0, };
-static const char32 __uni_decomp_data_0x2f897[] = { 0x232b8, 0, };
-static const char32 __uni_decomp_data_0x2f898[] = { 0x261da, 0, };
-static const char32 __uni_decomp_data_0x2f899[] = { 0x5f62, 0, };
-static const char32 __uni_decomp_data_0x2f89a[] = { 0x5f6b, 0, };
-static const char32 __uni_decomp_data_0x2f89b[] = { 0x38e3, 0, };
-static const char32 __uni_decomp_data_0x2f89c[] = { 0x5f9a, 0, };
-static const char32 __uni_decomp_data_0x2f89d[] = { 0x5fcd, 0, };
-static const char32 __uni_decomp_data_0x2f89e[] = { 0x5fd7, 0, };
-static const char32 __uni_decomp_data_0x2f89f[] = { 0x5ff9, 0, };
-static const char32 __uni_decomp_data_0x2f8a0[] = { 0x6081, 0, };
-static const char32 __uni_decomp_data_0x2f8a1[] = { 0x393a, 0, };
-static const char32 __uni_decomp_data_0x2f8a2[] = { 0x391c, 0, };
-static const char32 __uni_decomp_data_0x2f8a3[] = { 0x6094, 0, };
-static const char32 __uni_decomp_data_0x2f8a4[] = { 0x226d4, 0, };
-static const char32 __uni_decomp_data_0x2f8a5[] = { 0x60c7, 0, };
-static const char32 __uni_decomp_data_0x2f8a6[] = { 0x6148, 0, };
-static const char32 __uni_decomp_data_0x2f8a7[] = { 0x614c, 0, };
-static const char32 __uni_decomp_data_0x2f8a8[] = { 0x614e, 0, };
-static const char32 __uni_decomp_data_0x2f8a9[] = { 0x614c, 0, };
-static const char32 __uni_decomp_data_0x2f8aa[] = { 0x617a, 0, };
-static const char32 __uni_decomp_data_0x2f8ab[] = { 0x618e, 0, };
-static const char32 __uni_decomp_data_0x2f8ac[] = { 0x61b2, 0, };
-static const char32 __uni_decomp_data_0x2f8ad[] = { 0x61a4, 0, };
-static const char32 __uni_decomp_data_0x2f8ae[] = { 0x61af, 0, };
-static const char32 __uni_decomp_data_0x2f8af[] = { 0x61de, 0, };
-static const char32 __uni_decomp_data_0x2f8b0[] = { 0x61f2, 0, };
-static const char32 __uni_decomp_data_0x2f8b1[] = { 0x61f6, 0, };
-static const char32 __uni_decomp_data_0x2f8b2[] = { 0x6210, 0, };
-static const char32 __uni_decomp_data_0x2f8b3[] = { 0x621b, 0, };
-static const char32 __uni_decomp_data_0x2f8b4[] = { 0x625d, 0, };
-static const char32 __uni_decomp_data_0x2f8b5[] = { 0x62b1, 0, };
-static const char32 __uni_decomp_data_0x2f8b6[] = { 0x62d4, 0, };
-static const char32 __uni_decomp_data_0x2f8b7[] = { 0x6350, 0, };
-static const char32 __uni_decomp_data_0x2f8b8[] = { 0x22b0c, 0, };
-static const char32 __uni_decomp_data_0x2f8b9[] = { 0x633d, 0, };
-static const char32 __uni_decomp_data_0x2f8ba[] = { 0x62fc, 0, };
-static const char32 __uni_decomp_data_0x2f8bb[] = { 0x6368, 0, };
-static const char32 __uni_decomp_data_0x2f8bc[] = { 0x6383, 0, };
-static const char32 __uni_decomp_data_0x2f8bd[] = { 0x63e4, 0, };
-static const char32 __uni_decomp_data_0x2f8be[] = { 0x22bf1, 0, };
-static const char32 __uni_decomp_data_0x2f8bf[] = { 0x6422, 0, };
-static const char32 __uni_decomp_data_0x2f8c0[] = { 0x63c5, 0, };
-static const char32 __uni_decomp_data_0x2f8c1[] = { 0x63a9, 0, };
-static const char32 __uni_decomp_data_0x2f8c2[] = { 0x3a2e, 0, };
-static const char32 __uni_decomp_data_0x2f8c3[] = { 0x6469, 0, };
-static const char32 __uni_decomp_data_0x2f8c4[] = { 0x647e, 0, };
-static const char32 __uni_decomp_data_0x2f8c5[] = { 0x649d, 0, };
-static const char32 __uni_decomp_data_0x2f8c6[] = { 0x6477, 0, };
-static const char32 __uni_decomp_data_0x2f8c7[] = { 0x3a6c, 0, };
-static const char32 __uni_decomp_data_0x2f8c8[] = { 0x654f, 0, };
-static const char32 __uni_decomp_data_0x2f8c9[] = { 0x656c, 0, };
-static const char32 __uni_decomp_data_0x2f8ca[] = { 0x2300a, 0, };
-static const char32 __uni_decomp_data_0x2f8cb[] = { 0x65e3, 0, };
-static const char32 __uni_decomp_data_0x2f8cc[] = { 0x66f8, 0, };
-static const char32 __uni_decomp_data_0x2f8cd[] = { 0x6649, 0, };
-static const char32 __uni_decomp_data_0x2f8ce[] = { 0x3b19, 0, };
-static const char32 __uni_decomp_data_0x2f8cf[] = { 0x6691, 0, };
-static const char32 __uni_decomp_data_0x2f8d0[] = { 0x3b08, 0, };
-static const char32 __uni_decomp_data_0x2f8d1[] = { 0x3ae4, 0, };
-static const char32 __uni_decomp_data_0x2f8d2[] = { 0x5192, 0, };
-static const char32 __uni_decomp_data_0x2f8d3[] = { 0x5195, 0, };
-static const char32 __uni_decomp_data_0x2f8d4[] = { 0x6700, 0, };
-static const char32 __uni_decomp_data_0x2f8d5[] = { 0x669c, 0, };
-static const char32 __uni_decomp_data_0x2f8d6[] = { 0x80ad, 0, };
-static const char32 __uni_decomp_data_0x2f8d7[] = { 0x43d9, 0, };
-static const char32 __uni_decomp_data_0x2f8d8[] = { 0x6717, 0, };
-static const char32 __uni_decomp_data_0x2f8d9[] = { 0x671b, 0, };
-static const char32 __uni_decomp_data_0x2f8da[] = { 0x6721, 0, };
-static const char32 __uni_decomp_data_0x2f8db[] = { 0x675e, 0, };
-static const char32 __uni_decomp_data_0x2f8dc[] = { 0x6753, 0, };
-static const char32 __uni_decomp_data_0x2f8dd[] = { 0x233c3, 0, };
-static const char32 __uni_decomp_data_0x2f8de[] = { 0x3b49, 0, };
-static const char32 __uni_decomp_data_0x2f8df[] = { 0x67fa, 0, };
-static const char32 __uni_decomp_data_0x2f8e0[] = { 0x6785, 0, };
-static const char32 __uni_decomp_data_0x2f8e1[] = { 0x6852, 0, };
-static const char32 __uni_decomp_data_0x2f8e2[] = { 0x6885, 0, };
-static const char32 __uni_decomp_data_0x2f8e3[] = { 0x2346d, 0, };
-static const char32 __uni_decomp_data_0x2f8e4[] = { 0x688e, 0, };
-static const char32 __uni_decomp_data_0x2f8e5[] = { 0x681f, 0, };
-static const char32 __uni_decomp_data_0x2f8e6[] = { 0x6914, 0, };
-static const char32 __uni_decomp_data_0x2f8e7[] = { 0x3b9d, 0, };
-static const char32 __uni_decomp_data_0x2f8e8[] = { 0x6942, 0, };
-static const char32 __uni_decomp_data_0x2f8e9[] = { 0x69a3, 0, };
-static const char32 __uni_decomp_data_0x2f8ea[] = { 0x69ea, 0, };
-static const char32 __uni_decomp_data_0x2f8eb[] = { 0x6aa8, 0, };
-static const char32 __uni_decomp_data_0x2f8ec[] = { 0x236a3, 0, };
-static const char32 __uni_decomp_data_0x2f8ed[] = { 0x6adb, 0, };
-static const char32 __uni_decomp_data_0x2f8ee[] = { 0x3c18, 0, };
-static const char32 __uni_decomp_data_0x2f8ef[] = { 0x6b21, 0, };
-static const char32 __uni_decomp_data_0x2f8f0[] = { 0x238a7, 0, };
-static const char32 __uni_decomp_data_0x2f8f1[] = { 0x6b54, 0, };
-static const char32 __uni_decomp_data_0x2f8f2[] = { 0x3c4e, 0, };
-static const char32 __uni_decomp_data_0x2f8f3[] = { 0x6b72, 0, };
-static const char32 __uni_decomp_data_0x2f8f4[] = { 0x6b9f, 0, };
-static const char32 __uni_decomp_data_0x2f8f5[] = { 0x6bba, 0, };
-static const char32 __uni_decomp_data_0x2f8f6[] = { 0x6bbb, 0, };
-static const char32 __uni_decomp_data_0x2f8f7[] = { 0x23a8d, 0, };
-static const char32 __uni_decomp_data_0x2f8f8[] = { 0x21d0b, 0, };
-static const char32 __uni_decomp_data_0x2f8f9[] = { 0x23afa, 0, };
-static const char32 __uni_decomp_data_0x2f8fa[] = { 0x6c4e, 0, };
-static const char32 __uni_decomp_data_0x2f8fb[] = { 0x23cbc, 0, };
-static const char32 __uni_decomp_data_0x2f8fc[] = { 0x6cbf, 0, };
-static const char32 __uni_decomp_data_0x2f8fd[] = { 0x6ccd, 0, };
-static const char32 __uni_decomp_data_0x2f8fe[] = { 0x6c67, 0, };
-static const char32 __uni_decomp_data_0x2f8ff[] = { 0x6d16, 0, };
+static const char32 __uni_decomp_data_0x2f880[] = { 1, 0x5d7c, };
+static const char32 __uni_decomp_data_0x2f881[] = { 1, 0x5de1, };
+static const char32 __uni_decomp_data_0x2f882[] = { 1, 0x5de2, };
+static const char32 __uni_decomp_data_0x2f883[] = { 1, 0x382f, };
+static const char32 __uni_decomp_data_0x2f884[] = { 1, 0x5dfd, };
+static const char32 __uni_decomp_data_0x2f885[] = { 1, 0x5e28, };
+static const char32 __uni_decomp_data_0x2f886[] = { 1, 0x5e3d, };
+static const char32 __uni_decomp_data_0x2f887[] = { 1, 0x5e69, };
+static const char32 __uni_decomp_data_0x2f888[] = { 1, 0x3862, };
+static const char32 __uni_decomp_data_0x2f889[] = { 1, 0x22183, };
+static const char32 __uni_decomp_data_0x2f88a[] = { 1, 0x387c, };
+static const char32 __uni_decomp_data_0x2f88b[] = { 1, 0x5eb0, };
+static const char32 __uni_decomp_data_0x2f88c[] = { 1, 0x5eb3, };
+static const char32 __uni_decomp_data_0x2f88d[] = { 1, 0x5eb6, };
+static const char32 __uni_decomp_data_0x2f88e[] = { 1, 0x5eca, };
+static const char32 __uni_decomp_data_0x2f88f[] = { 1, 0x2a392, };
+static const char32 __uni_decomp_data_0x2f890[] = { 1, 0x5efe, };
+static const char32 __uni_decomp_data_0x2f891[] = { 1, 0x22331, };
+static const char32 __uni_decomp_data_0x2f892[] = { 1, 0x22331, };
+static const char32 __uni_decomp_data_0x2f893[] = { 1, 0x8201, };
+static const char32 __uni_decomp_data_0x2f894[] = { 1, 0x5f22, };
+static const char32 __uni_decomp_data_0x2f895[] = { 1, 0x5f22, };
+static const char32 __uni_decomp_data_0x2f896[] = { 1, 0x38c7, };
+static const char32 __uni_decomp_data_0x2f897[] = { 1, 0x232b8, };
+static const char32 __uni_decomp_data_0x2f898[] = { 1, 0x261da, };
+static const char32 __uni_decomp_data_0x2f899[] = { 1, 0x5f62, };
+static const char32 __uni_decomp_data_0x2f89a[] = { 1, 0x5f6b, };
+static const char32 __uni_decomp_data_0x2f89b[] = { 1, 0x38e3, };
+static const char32 __uni_decomp_data_0x2f89c[] = { 1, 0x5f9a, };
+static const char32 __uni_decomp_data_0x2f89d[] = { 1, 0x5fcd, };
+static const char32 __uni_decomp_data_0x2f89e[] = { 1, 0x5fd7, };
+static const char32 __uni_decomp_data_0x2f89f[] = { 1, 0x5ff9, };
+static const char32 __uni_decomp_data_0x2f8a0[] = { 1, 0x6081, };
+static const char32 __uni_decomp_data_0x2f8a1[] = { 1, 0x393a, };
+static const char32 __uni_decomp_data_0x2f8a2[] = { 1, 0x391c, };
+static const char32 __uni_decomp_data_0x2f8a3[] = { 1, 0x6094, };
+static const char32 __uni_decomp_data_0x2f8a4[] = { 1, 0x226d4, };
+static const char32 __uni_decomp_data_0x2f8a5[] = { 1, 0x60c7, };
+static const char32 __uni_decomp_data_0x2f8a6[] = { 1, 0x6148, };
+static const char32 __uni_decomp_data_0x2f8a7[] = { 1, 0x614c, };
+static const char32 __uni_decomp_data_0x2f8a8[] = { 1, 0x614e, };
+static const char32 __uni_decomp_data_0x2f8a9[] = { 1, 0x614c, };
+static const char32 __uni_decomp_data_0x2f8aa[] = { 1, 0x617a, };
+static const char32 __uni_decomp_data_0x2f8ab[] = { 1, 0x618e, };
+static const char32 __uni_decomp_data_0x2f8ac[] = { 1, 0x61b2, };
+static const char32 __uni_decomp_data_0x2f8ad[] = { 1, 0x61a4, };
+static const char32 __uni_decomp_data_0x2f8ae[] = { 1, 0x61af, };
+static const char32 __uni_decomp_data_0x2f8af[] = { 1, 0x61de, };
+static const char32 __uni_decomp_data_0x2f8b0[] = { 1, 0x61f2, };
+static const char32 __uni_decomp_data_0x2f8b1[] = { 1, 0x61f6, };
+static const char32 __uni_decomp_data_0x2f8b2[] = { 1, 0x6210, };
+static const char32 __uni_decomp_data_0x2f8b3[] = { 1, 0x621b, };
+static const char32 __uni_decomp_data_0x2f8b4[] = { 1, 0x625d, };
+static const char32 __uni_decomp_data_0x2f8b5[] = { 1, 0x62b1, };
+static const char32 __uni_decomp_data_0x2f8b6[] = { 1, 0x62d4, };
+static const char32 __uni_decomp_data_0x2f8b7[] = { 1, 0x6350, };
+static const char32 __uni_decomp_data_0x2f8b8[] = { 1, 0x22b0c, };
+static const char32 __uni_decomp_data_0x2f8b9[] = { 1, 0x633d, };
+static const char32 __uni_decomp_data_0x2f8ba[] = { 1, 0x62fc, };
+static const char32 __uni_decomp_data_0x2f8bb[] = { 1, 0x6368, };
+static const char32 __uni_decomp_data_0x2f8bc[] = { 1, 0x6383, };
+static const char32 __uni_decomp_data_0x2f8bd[] = { 1, 0x63e4, };
+static const char32 __uni_decomp_data_0x2f8be[] = { 1, 0x22bf1, };
+static const char32 __uni_decomp_data_0x2f8bf[] = { 1, 0x6422, };
+static const char32 __uni_decomp_data_0x2f8c0[] = { 1, 0x63c5, };
+static const char32 __uni_decomp_data_0x2f8c1[] = { 1, 0x63a9, };
+static const char32 __uni_decomp_data_0x2f8c2[] = { 1, 0x3a2e, };
+static const char32 __uni_decomp_data_0x2f8c3[] = { 1, 0x6469, };
+static const char32 __uni_decomp_data_0x2f8c4[] = { 1, 0x647e, };
+static const char32 __uni_decomp_data_0x2f8c5[] = { 1, 0x649d, };
+static const char32 __uni_decomp_data_0x2f8c6[] = { 1, 0x6477, };
+static const char32 __uni_decomp_data_0x2f8c7[] = { 1, 0x3a6c, };
+static const char32 __uni_decomp_data_0x2f8c8[] = { 1, 0x654f, };
+static const char32 __uni_decomp_data_0x2f8c9[] = { 1, 0x656c, };
+static const char32 __uni_decomp_data_0x2f8ca[] = { 1, 0x2300a, };
+static const char32 __uni_decomp_data_0x2f8cb[] = { 1, 0x65e3, };
+static const char32 __uni_decomp_data_0x2f8cc[] = { 1, 0x66f8, };
+static const char32 __uni_decomp_data_0x2f8cd[] = { 1, 0x6649, };
+static const char32 __uni_decomp_data_0x2f8ce[] = { 1, 0x3b19, };
+static const char32 __uni_decomp_data_0x2f8cf[] = { 1, 0x6691, };
+static const char32 __uni_decomp_data_0x2f8d0[] = { 1, 0x3b08, };
+static const char32 __uni_decomp_data_0x2f8d1[] = { 1, 0x3ae4, };
+static const char32 __uni_decomp_data_0x2f8d2[] = { 1, 0x5192, };
+static const char32 __uni_decomp_data_0x2f8d3[] = { 1, 0x5195, };
+static const char32 __uni_decomp_data_0x2f8d4[] = { 1, 0x6700, };
+static const char32 __uni_decomp_data_0x2f8d5[] = { 1, 0x669c, };
+static const char32 __uni_decomp_data_0x2f8d6[] = { 1, 0x80ad, };
+static const char32 __uni_decomp_data_0x2f8d7[] = { 1, 0x43d9, };
+static const char32 __uni_decomp_data_0x2f8d8[] = { 1, 0x6717, };
+static const char32 __uni_decomp_data_0x2f8d9[] = { 1, 0x671b, };
+static const char32 __uni_decomp_data_0x2f8da[] = { 1, 0x6721, };
+static const char32 __uni_decomp_data_0x2f8db[] = { 1, 0x675e, };
+static const char32 __uni_decomp_data_0x2f8dc[] = { 1, 0x6753, };
+static const char32 __uni_decomp_data_0x2f8dd[] = { 1, 0x233c3, };
+static const char32 __uni_decomp_data_0x2f8de[] = { 1, 0x3b49, };
+static const char32 __uni_decomp_data_0x2f8df[] = { 1, 0x67fa, };
+static const char32 __uni_decomp_data_0x2f8e0[] = { 1, 0x6785, };
+static const char32 __uni_decomp_data_0x2f8e1[] = { 1, 0x6852, };
+static const char32 __uni_decomp_data_0x2f8e2[] = { 1, 0x6885, };
+static const char32 __uni_decomp_data_0x2f8e3[] = { 1, 0x2346d, };
+static const char32 __uni_decomp_data_0x2f8e4[] = { 1, 0x688e, };
+static const char32 __uni_decomp_data_0x2f8e5[] = { 1, 0x681f, };
+static const char32 __uni_decomp_data_0x2f8e6[] = { 1, 0x6914, };
+static const char32 __uni_decomp_data_0x2f8e7[] = { 1, 0x3b9d, };
+static const char32 __uni_decomp_data_0x2f8e8[] = { 1, 0x6942, };
+static const char32 __uni_decomp_data_0x2f8e9[] = { 1, 0x69a3, };
+static const char32 __uni_decomp_data_0x2f8ea[] = { 1, 0x69ea, };
+static const char32 __uni_decomp_data_0x2f8eb[] = { 1, 0x6aa8, };
+static const char32 __uni_decomp_data_0x2f8ec[] = { 1, 0x236a3, };
+static const char32 __uni_decomp_data_0x2f8ed[] = { 1, 0x6adb, };
+static const char32 __uni_decomp_data_0x2f8ee[] = { 1, 0x3c18, };
+static const char32 __uni_decomp_data_0x2f8ef[] = { 1, 0x6b21, };
+static const char32 __uni_decomp_data_0x2f8f0[] = { 1, 0x238a7, };
+static const char32 __uni_decomp_data_0x2f8f1[] = { 1, 0x6b54, };
+static const char32 __uni_decomp_data_0x2f8f2[] = { 1, 0x3c4e, };
+static const char32 __uni_decomp_data_0x2f8f3[] = { 1, 0x6b72, };
+static const char32 __uni_decomp_data_0x2f8f4[] = { 1, 0x6b9f, };
+static const char32 __uni_decomp_data_0x2f8f5[] = { 1, 0x6bba, };
+static const char32 __uni_decomp_data_0x2f8f6[] = { 1, 0x6bbb, };
+static const char32 __uni_decomp_data_0x2f8f7[] = { 1, 0x23a8d, };
+static const char32 __uni_decomp_data_0x2f8f8[] = { 1, 0x21d0b, };
+static const char32 __uni_decomp_data_0x2f8f9[] = { 1, 0x23afa, };
+static const char32 __uni_decomp_data_0x2f8fa[] = { 1, 0x6c4e, };
+static const char32 __uni_decomp_data_0x2f8fb[] = { 1, 0x23cbc, };
+static const char32 __uni_decomp_data_0x2f8fc[] = { 1, 0x6cbf, };
+static const char32 __uni_decomp_data_0x2f8fd[] = { 1, 0x6ccd, };
+static const char32 __uni_decomp_data_0x2f8fe[] = { 1, 0x6c67, };
+static const char32 __uni_decomp_data_0x2f8ff[] = { 1, 0x6d16, };
 
 
 
@@ -39765,134 +39765,134 @@
 };
 
 
-static const char32 __uni_decomp_data_0x2f900[] = { 0x6d3e, 0, };
-static const char32 __uni_decomp_data_0x2f901[] = { 0x6d77, 0, };
-static const char32 __uni_decomp_data_0x2f902[] = { 0x6d41, 0, };
-static const char32 __uni_decomp_data_0x2f903[] = { 0x6d69, 0, };
-static const char32 __uni_decomp_data_0x2f904[] = { 0x6d78, 0, };
-static const char32 __uni_decomp_data_0x2f905[] = { 0x6d85, 0, };
-static const char32 __uni_decomp_data_0x2f906[] = { 0x23d1e, 0, };
-static const char32 __uni_decomp_data_0x2f907[] = { 0x6d34, 0, };
-static const char32 __uni_decomp_data_0x2f908[] = { 0x6e2f, 0, };
-static const char32 __uni_decomp_data_0x2f909[] = { 0x6e6e, 0, };
-static const char32 __uni_decomp_data_0x2f90a[] = { 0x3d33, 0, };
-static const char32 __uni_decomp_data_0x2f90b[] = { 0x6ecb, 0, };
-static const char32 __uni_decomp_data_0x2f90c[] = { 0x6ec7, 0, };
-static const char32 __uni_decomp_data_0x2f90d[] = { 0x23ed1, 0, };
-static const char32 __uni_decomp_data_0x2f90e[] = { 0x6df9, 0, };
-static const char32 __uni_decomp_data_0x2f90f[] = { 0x6f6e, 0, };
-static const char32 __uni_decomp_data_0x2f910[] = { 0x23f5e, 0, };
-static const char32 __uni_decomp_data_0x2f911[] = { 0x23f8e, 0, };
-static const char32 __uni_decomp_data_0x2f912[] = { 0x6fc6, 0, };
-static const char32 __uni_decomp_data_0x2f913[] = { 0x7039, 0, };
-static const char32 __uni_decomp_data_0x2f914[] = { 0x701e, 0, };
-static const char32 __uni_decomp_data_0x2f915[] = { 0x701b, 0, };
-static const char32 __uni_decomp_data_0x2f916[] = { 0x3d96, 0, };
-static const char32 __uni_decomp_data_0x2f917[] = { 0x704a, 0, };
-static const char32 __uni_decomp_data_0x2f918[] = { 0x707d, 0, };
-static const char32 __uni_decomp_data_0x2f919[] = { 0x7077, 0, };
-static const char32 __uni_decomp_data_0x2f91a[] = { 0x70ad, 0, };
-static const char32 __uni_decomp_data_0x2f91b[] = { 0x20525, 0, };
-static const char32 __uni_decomp_data_0x2f91c[] = { 0x7145, 0, };
-static const char32 __uni_decomp_data_0x2f91d[] = { 0x24263, 0, };
-static const char32 __uni_decomp_data_0x2f91e[] = { 0x719c, 0, };
-static const char32 __uni_decomp_data_0x2f91f[] = { 0x243ab, 0, };
-static const char32 __uni_decomp_data_0x2f920[] = { 0x7228, 0, };
-static const char32 __uni_decomp_data_0x2f921[] = { 0x7235, 0, };
-static const char32 __uni_decomp_data_0x2f922[] = { 0x7250, 0, };
-static const char32 __uni_decomp_data_0x2f923[] = { 0x24608, 0, };
-static const char32 __uni_decomp_data_0x2f924[] = { 0x7280, 0, };
-static const char32 __uni_decomp_data_0x2f925[] = { 0x7295, 0, };
-static const char32 __uni_decomp_data_0x2f926[] = { 0x24735, 0, };
-static const char32 __uni_decomp_data_0x2f927[] = { 0x24814, 0, };
-static const char32 __uni_decomp_data_0x2f928[] = { 0x737a, 0, };
-static const char32 __uni_decomp_data_0x2f929[] = { 0x738b, 0, };
-static const char32 __uni_decomp_data_0x2f92a[] = { 0x3eac, 0, };
-static const char32 __uni_decomp_data_0x2f92b[] = { 0x73a5, 0, };
-static const char32 __uni_decomp_data_0x2f92c[] = { 0x3eb8, 0, };
-static const char32 __uni_decomp_data_0x2f92d[] = { 0x3eb8, 0, };
-static const char32 __uni_decomp_data_0x2f92e[] = { 0x7447, 0, };
-static const char32 __uni_decomp_data_0x2f92f[] = { 0x745c, 0, };
-static const char32 __uni_decomp_data_0x2f930[] = { 0x7471, 0, };
-static const char32 __uni_decomp_data_0x2f931[] = { 0x7485, 0, };
-static const char32 __uni_decomp_data_0x2f932[] = { 0x74ca, 0, };
-static const char32 __uni_decomp_data_0x2f933[] = { 0x3f1b, 0, };
-static const char32 __uni_decomp_data_0x2f934[] = { 0x7524, 0, };
-static const char32 __uni_decomp_data_0x2f935[] = { 0x24c36, 0, };
-static const char32 __uni_decomp_data_0x2f936[] = { 0x753e, 0, };
-static const char32 __uni_decomp_data_0x2f937[] = { 0x24c92, 0, };
-static const char32 __uni_decomp_data_0x2f938[] = { 0x7570, 0, };
-static const char32 __uni_decomp_data_0x2f939[] = { 0x2219f, 0, };
-static const char32 __uni_decomp_data_0x2f93a[] = { 0x7610, 0, };
-static const char32 __uni_decomp_data_0x2f93b[] = { 0x24fa1, 0, };
-static const char32 __uni_decomp_data_0x2f93c[] = { 0x24fb8, 0, };
-static const char32 __uni_decomp_data_0x2f93d[] = { 0x25044, 0, };
-static const char32 __uni_decomp_data_0x2f93e[] = { 0x3ffc, 0, };
-static const char32 __uni_decomp_data_0x2f93f[] = { 0x4008, 0, };
-static const char32 __uni_decomp_data_0x2f940[] = { 0x76f4, 0, };
-static const char32 __uni_decomp_data_0x2f941[] = { 0x250f3, 0, };
-static const char32 __uni_decomp_data_0x2f942[] = { 0x250f2, 0, };
-static const char32 __uni_decomp_data_0x2f943[] = { 0x25119, 0, };
-static const char32 __uni_decomp_data_0x2f944[] = { 0x25133, 0, };
-static const char32 __uni_decomp_data_0x2f945[] = { 0x771e, 0, };
-static const char32 __uni_decomp_data_0x2f946[] = { 0x771f, 0, };
-static const char32 __uni_decomp_data_0x2f947[] = { 0x771f, 0, };
-static const char32 __uni_decomp_data_0x2f948[] = { 0x774a, 0, };
-static const char32 __uni_decomp_data_0x2f949[] = { 0x4039, 0, };
-static const char32 __uni_decomp_data_0x2f94a[] = { 0x778b, 0, };
-static const char32 __uni_decomp_data_0x2f94b[] = { 0x4046, 0, };
-static const char32 __uni_decomp_data_0x2f94c[] = { 0x4096, 0, };
-static const char32 __uni_decomp_data_0x2f94d[] = { 0x2541d, 0, };
-static const char32 __uni_decomp_data_0x2f94e[] = { 0x784e, 0, };
-static const char32 __uni_decomp_data_0x2f94f[] = { 0x788c, 0, };
-static const char32 __uni_decomp_data_0x2f950[] = { 0x78cc, 0, };
-static const char32 __uni_decomp_data_0x2f951[] = { 0x40e3, 0, };
-static const char32 __uni_decomp_data_0x2f952[] = { 0x25626, 0, };
-static const char32 __uni_decomp_data_0x2f953[] = { 0x7956, 0, };
-static const char32 __uni_decomp_data_0x2f954[] = { 0x2569a, 0, };
-static const char32 __uni_decomp_data_0x2f955[] = { 0x256c5, 0, };
-static const char32 __uni_decomp_data_0x2f956[] = { 0x798f, 0, };
-static const char32 __uni_decomp_data_0x2f957[] = { 0x79eb, 0, };
-static const char32 __uni_decomp_data_0x2f958[] = { 0x412f, 0, };
-static const char32 __uni_decomp_data_0x2f959[] = { 0x7a40, 0, };
-static const char32 __uni_decomp_data_0x2f95a[] = { 0x7a4a, 0, };
-static const char32 __uni_decomp_data_0x2f95b[] = { 0x7a4f, 0, };
-static const char32 __uni_decomp_data_0x2f95c[] = { 0x2597c, 0, };
-static const char32 __uni_decomp_data_0x2f95d[] = { 0x25aa7, 0, };
-static const char32 __uni_decomp_data_0x2f95e[] = { 0x25aa7, 0, };
-static const char32 __uni_decomp_data_0x2f95f[] = { 0x7aee, 0, };
-static const char32 __uni_decomp_data_0x2f960[] = { 0x4202, 0, };
-static const char32 __uni_decomp_data_0x2f961[] = { 0x25bab, 0, };
-static const char32 __uni_decomp_data_0x2f962[] = { 0x7bc6, 0, };
-static const char32 __uni_decomp_data_0x2f963[] = { 0x7bc9, 0, };
-static const char32 __uni_decomp_data_0x2f964[] = { 0x4227, 0, };
-static const char32 __uni_decomp_data_0x2f965[] = { 0x25c80, 0, };
-static const char32 __uni_decomp_data_0x2f966[] = { 0x7cd2, 0, };
-static const char32 __uni_decomp_data_0x2f967[] = { 0x42a0, 0, };
-static const char32 __uni_decomp_data_0x2f968[] = { 0x7ce8, 0, };
-static const char32 __uni_decomp_data_0x2f969[] = { 0x7ce3, 0, };
-static const char32 __uni_decomp_data_0x2f96a[] = { 0x7d00, 0, };
-static const char32 __uni_decomp_data_0x2f96b[] = { 0x25f86, 0, };
-static const char32 __uni_decomp_data_0x2f96c[] = { 0x7d63, 0, };
-static const char32 __uni_decomp_data_0x2f96d[] = { 0x4301, 0, };
-static const char32 __uni_decomp_data_0x2f96e[] = { 0x7dc7, 0, };
-static const char32 __uni_decomp_data_0x2f96f[] = { 0x7e02, 0, };
-static const char32 __uni_decomp_data_0x2f970[] = { 0x7e45, 0, };
-static const char32 __uni_decomp_data_0x2f971[] = { 0x4334, 0, };
-static const char32 __uni_decomp_data_0x2f972[] = { 0x26228, 0, };
-static const char32 __uni_decomp_data_0x2f973[] = { 0x26247, 0, };
-static const char32 __uni_decomp_data_0x2f974[] = { 0x4359, 0, };
-static const char32 __uni_decomp_data_0x2f975[] = { 0x262d9, 0, };
-static const char32 __uni_decomp_data_0x2f976[] = { 0x7f7a, 0, };
-static const char32 __uni_decomp_data_0x2f977[] = { 0x2633e, 0, };
-static const char32 __uni_decomp_data_0x2f978[] = { 0x7f95, 0, };
-static const char32 __uni_decomp_data_0x2f979[] = { 0x7ffa, 0, };
-static const char32 __uni_decomp_data_0x2f97a[] = { 0x8005, 0, };
-static const char32 __uni_decomp_data_0x2f97b[] = { 0x264da, 0, };
-static const char32 __uni_decomp_data_0x2f97c[] = { 0x26523, 0, };
-static const char32 __uni_decomp_data_0x2f97d[] = { 0x8060, 0, };
-static const char32 __uni_decomp_data_0x2f97e[] = { 0x265a8, 0, };
-static const char32 __uni_decomp_data_0x2f97f[] = { 0x8070, 0, };
+static const char32 __uni_decomp_data_0x2f900[] = { 1, 0x6d3e, };
+static const char32 __uni_decomp_data_0x2f901[] = { 1, 0x6d77, };
+static const char32 __uni_decomp_data_0x2f902[] = { 1, 0x6d41, };
+static const char32 __uni_decomp_data_0x2f903[] = { 1, 0x6d69, };
+static const char32 __uni_decomp_data_0x2f904[] = { 1, 0x6d78, };
+static const char32 __uni_decomp_data_0x2f905[] = { 1, 0x6d85, };
+static const char32 __uni_decomp_data_0x2f906[] = { 1, 0x23d1e, };
+static const char32 __uni_decomp_data_0x2f907[] = { 1, 0x6d34, };
+static const char32 __uni_decomp_data_0x2f908[] = { 1, 0x6e2f, };
+static const char32 __uni_decomp_data_0x2f909[] = { 1, 0x6e6e, };
+static const char32 __uni_decomp_data_0x2f90a[] = { 1, 0x3d33, };
+static const char32 __uni_decomp_data_0x2f90b[] = { 1, 0x6ecb, };
+static const char32 __uni_decomp_data_0x2f90c[] = { 1, 0x6ec7, };
+static const char32 __uni_decomp_data_0x2f90d[] = { 1, 0x23ed1, };
+static const char32 __uni_decomp_data_0x2f90e[] = { 1, 0x6df9, };
+static const char32 __uni_decomp_data_0x2f90f[] = { 1, 0x6f6e, };
+static const char32 __uni_decomp_data_0x2f910[] = { 1, 0x23f5e, };
+static const char32 __uni_decomp_data_0x2f911[] = { 1, 0x23f8e, };
+static const char32 __uni_decomp_data_0x2f912[] = { 1, 0x6fc6, };
+static const char32 __uni_decomp_data_0x2f913[] = { 1, 0x7039, };
+static const char32 __uni_decomp_data_0x2f914[] = { 1, 0x701e, };
+static const char32 __uni_decomp_data_0x2f915[] = { 1, 0x701b, };
+static const char32 __uni_decomp_data_0x2f916[] = { 1, 0x3d96, };
+static const char32 __uni_decomp_data_0x2f917[] = { 1, 0x704a, };
+static const char32 __uni_decomp_data_0x2f918[] = { 1, 0x707d, };
+static const char32 __uni_decomp_data_0x2f919[] = { 1, 0x7077, };
+static const char32 __uni_decomp_data_0x2f91a[] = { 1, 0x70ad, };
+static const char32 __uni_decomp_data_0x2f91b[] = { 1, 0x20525, };
+static const char32 __uni_decomp_data_0x2f91c[] = { 1, 0x7145, };
+static const char32 __uni_decomp_data_0x2f91d[] = { 1, 0x24263, };
+static const char32 __uni_decomp_data_0x2f91e[] = { 1, 0x719c, };
+static const char32 __uni_decomp_data_0x2f91f[] = { 1, 0x243ab, };
+static const char32 __uni_decomp_data_0x2f920[] = { 1, 0x7228, };
+static const char32 __uni_decomp_data_0x2f921[] = { 1, 0x7235, };
+static const char32 __uni_decomp_data_0x2f922[] = { 1, 0x7250, };
+static const char32 __uni_decomp_data_0x2f923[] = { 1, 0x24608, };
+static const char32 __uni_decomp_data_0x2f924[] = { 1, 0x7280, };
+static const char32 __uni_decomp_data_0x2f925[] = { 1, 0x7295, };
+static const char32 __uni_decomp_data_0x2f926[] = { 1, 0x24735, };
+static const char32 __uni_decomp_data_0x2f927[] = { 1, 0x24814, };
+static const char32 __uni_decomp_data_0x2f928[] = { 1, 0x737a, };
+static const char32 __uni_decomp_data_0x2f929[] = { 1, 0x738b, };
+static const char32 __uni_decomp_data_0x2f92a[] = { 1, 0x3eac, };
+static const char32 __uni_decomp_data_0x2f92b[] = { 1, 0x73a5, };
+static const char32 __uni_decomp_data_0x2f92c[] = { 1, 0x3eb8, };
+static const char32 __uni_decomp_data_0x2f92d[] = { 1, 0x3eb8, };
+static const char32 __uni_decomp_data_0x2f92e[] = { 1, 0x7447, };
+static const char32 __uni_decomp_data_0x2f92f[] = { 1, 0x745c, };
+static const char32 __uni_decomp_data_0x2f930[] = { 1, 0x7471, };
+static const char32 __uni_decomp_data_0x2f931[] = { 1, 0x7485, };
+static const char32 __uni_decomp_data_0x2f932[] = { 1, 0x74ca, };
+static const char32 __uni_decomp_data_0x2f933[] = { 1, 0x3f1b, };
+static const char32 __uni_decomp_data_0x2f934[] = { 1, 0x7524, };
+static const char32 __uni_decomp_data_0x2f935[] = { 1, 0x24c36, };
+static const char32 __uni_decomp_data_0x2f936[] = { 1, 0x753e, };
+static const char32 __uni_decomp_data_0x2f937[] = { 1, 0x24c92, };
+static const char32 __uni_decomp_data_0x2f938[] = { 1, 0x7570, };
+static const char32 __uni_decomp_data_0x2f939[] = { 1, 0x2219f, };
+static const char32 __uni_decomp_data_0x2f93a[] = { 1, 0x7610, };
+static const char32 __uni_decomp_data_0x2f93b[] = { 1, 0x24fa1, };
+static const char32 __uni_decomp_data_0x2f93c[] = { 1, 0x24fb8, };
+static const char32 __uni_decomp_data_0x2f93d[] = { 1, 0x25044, };
+static const char32 __uni_decomp_data_0x2f93e[] = { 1, 0x3ffc, };
+static const char32 __uni_decomp_data_0x2f93f[] = { 1, 0x4008, };
+static const char32 __uni_decomp_data_0x2f940[] = { 1, 0x76f4, };
+static const char32 __uni_decomp_data_0x2f941[] = { 1, 0x250f3, };
+static const char32 __uni_decomp_data_0x2f942[] = { 1, 0x250f2, };
+static const char32 __uni_decomp_data_0x2f943[] = { 1, 0x25119, };
+static const char32 __uni_decomp_data_0x2f944[] = { 1, 0x25133, };
+static const char32 __uni_decomp_data_0x2f945[] = { 1, 0x771e, };
+static const char32 __uni_decomp_data_0x2f946[] = { 1, 0x771f, };
+static const char32 __uni_decomp_data_0x2f947[] = { 1, 0x771f, };
+static const char32 __uni_decomp_data_0x2f948[] = { 1, 0x774a, };
+static const char32 __uni_decomp_data_0x2f949[] = { 1, 0x4039, };
+static const char32 __uni_decomp_data_0x2f94a[] = { 1, 0x778b, };
+static const char32 __uni_decomp_data_0x2f94b[] = { 1, 0x4046, };
+static const char32 __uni_decomp_data_0x2f94c[] = { 1, 0x4096, };
+static const char32 __uni_decomp_data_0x2f94d[] = { 1, 0x2541d, };
+static const char32 __uni_decomp_data_0x2f94e[] = { 1, 0x784e, };
+static const char32 __uni_decomp_data_0x2f94f[] = { 1, 0x788c, };
+static const char32 __uni_decomp_data_0x2f950[] = { 1, 0x78cc, };
+static const char32 __uni_decomp_data_0x2f951[] = { 1, 0x40e3, };
+static const char32 __uni_decomp_data_0x2f952[] = { 1, 0x25626, };
+static const char32 __uni_decomp_data_0x2f953[] = { 1, 0x7956, };
+static const char32 __uni_decomp_data_0x2f954[] = { 1, 0x2569a, };
+static const char32 __uni_decomp_data_0x2f955[] = { 1, 0x256c5, };
+static const char32 __uni_decomp_data_0x2f956[] = { 1, 0x798f, };
+static const char32 __uni_decomp_data_0x2f957[] = { 1, 0x79eb, };
+static const char32 __uni_decomp_data_0x2f958[] = { 1, 0x412f, };
+static const char32 __uni_decomp_data_0x2f959[] = { 1, 0x7a40, };
+static const char32 __uni_decomp_data_0x2f95a[] = { 1, 0x7a4a, };
+static const char32 __uni_decomp_data_0x2f95b[] = { 1, 0x7a4f, };
+static const char32 __uni_decomp_data_0x2f95c[] = { 1, 0x2597c, };
+static const char32 __uni_decomp_data_0x2f95d[] = { 1, 0x25aa7, };
+static const char32 __uni_decomp_data_0x2f95e[] = { 1, 0x25aa7, };
+static const char32 __uni_decomp_data_0x2f95f[] = { 1, 0x7aee, };
+static const char32 __uni_decomp_data_0x2f960[] = { 1, 0x4202, };
+static const char32 __uni_decomp_data_0x2f961[] = { 1, 0x25bab, };
+static const char32 __uni_decomp_data_0x2f962[] = { 1, 0x7bc6, };
+static const char32 __uni_decomp_data_0x2f963[] = { 1, 0x7bc9, };
+static const char32 __uni_decomp_data_0x2f964[] = { 1, 0x4227, };
+static const char32 __uni_decomp_data_0x2f965[] = { 1, 0x25c80, };
+static const char32 __uni_decomp_data_0x2f966[] = { 1, 0x7cd2, };
+static const char32 __uni_decomp_data_0x2f967[] = { 1, 0x42a0, };
+static const char32 __uni_decomp_data_0x2f968[] = { 1, 0x7ce8, };
+static const char32 __uni_decomp_data_0x2f969[] = { 1, 0x7ce3, };
+static const char32 __uni_decomp_data_0x2f96a[] = { 1, 0x7d00, };
+static const char32 __uni_decomp_data_0x2f96b[] = { 1, 0x25f86, };
+static const char32 __uni_decomp_data_0x2f96c[] = { 1, 0x7d63, };
+static const char32 __uni_decomp_data_0x2f96d[] = { 1, 0x4301, };
+static const char32 __uni_decomp_data_0x2f96e[] = { 1, 0x7dc7, };
+static const char32 __uni_decomp_data_0x2f96f[] = { 1, 0x7e02, };
+static const char32 __uni_decomp_data_0x2f970[] = { 1, 0x7e45, };
+static const char32 __uni_decomp_data_0x2f971[] = { 1, 0x4334, };
+static const char32 __uni_decomp_data_0x2f972[] = { 1, 0x26228, };
+static const char32 __uni_decomp_data_0x2f973[] = { 1, 0x26247, };
+static const char32 __uni_decomp_data_0x2f974[] = { 1, 0x4359, };
+static const char32 __uni_decomp_data_0x2f975[] = { 1, 0x262d9, };
+static const char32 __uni_decomp_data_0x2f976[] = { 1, 0x7f7a, };
+static const char32 __uni_decomp_data_0x2f977[] = { 1, 0x2633e, };
+static const char32 __uni_decomp_data_0x2f978[] = { 1, 0x7f95, };
+static const char32 __uni_decomp_data_0x2f979[] = { 1, 0x7ffa, };
+static const char32 __uni_decomp_data_0x2f97a[] = { 1, 0x8005, };
+static const char32 __uni_decomp_data_0x2f97b[] = { 1, 0x264da, };
+static const char32 __uni_decomp_data_0x2f97c[] = { 1, 0x26523, };
+static const char32 __uni_decomp_data_0x2f97d[] = { 1, 0x8060, };
+static const char32 __uni_decomp_data_0x2f97e[] = { 1, 0x265a8, };
+static const char32 __uni_decomp_data_0x2f97f[] = { 1, 0x8070, };
 
 
 

Modified: sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_9.ipp
==============================================================================
--- sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_9.ipp	(original)
+++ sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data_9.ipp	2009-08-06 03:26:39 EDT (Thu, 06 Aug 2009)
@@ -21,134 +21,134 @@
 
 
 namespace boost { namespace unicode { namespace ucd {
-static const char32 __uni_decomp_data_0x2f980[] = { 0x2335f, 0, };
-static const char32 __uni_decomp_data_0x2f981[] = { 0x43d5, 0, };
-static const char32 __uni_decomp_data_0x2f982[] = { 0x80b2, 0, };
-static const char32 __uni_decomp_data_0x2f983[] = { 0x8103, 0, };
-static const char32 __uni_decomp_data_0x2f984[] = { 0x440b, 0, };
-static const char32 __uni_decomp_data_0x2f985[] = { 0x813e, 0, };
-static const char32 __uni_decomp_data_0x2f986[] = { 0x5ab5, 0, };
-static const char32 __uni_decomp_data_0x2f987[] = { 0x267a7, 0, };
-static const char32 __uni_decomp_data_0x2f988[] = { 0x267b5, 0, };
-static const char32 __uni_decomp_data_0x2f989[] = { 0x23393, 0, };
-static const char32 __uni_decomp_data_0x2f98a[] = { 0x2339c, 0, };
-static const char32 __uni_decomp_data_0x2f98b[] = { 0x8201, 0, };
-static const char32 __uni_decomp_data_0x2f98c[] = { 0x8204, 0, };
-static const char32 __uni_decomp_data_0x2f98d[] = { 0x8f9e, 0, };
-static const char32 __uni_decomp_data_0x2f98e[] = { 0x446b, 0, };
-static const char32 __uni_decomp_data_0x2f98f[] = { 0x8291, 0, };
-static const char32 __uni_decomp_data_0x2f990[] = { 0x828b, 0, };
-static const char32 __uni_decomp_data_0x2f991[] = { 0x829d, 0, };
-static const char32 __uni_decomp_data_0x2f992[] = { 0x52b3, 0, };
-static const char32 __uni_decomp_data_0x2f993[] = { 0x82b1, 0, };
-static const char32 __uni_decomp_data_0x2f994[] = { 0x82b3, 0, };
-static const char32 __uni_decomp_data_0x2f995[] = { 0x82bd, 0, };
-static const char32 __uni_decomp_data_0x2f996[] = { 0x82e6, 0, };
-static const char32 __uni_decomp_data_0x2f997[] = { 0x26b3c, 0, };
-static const char32 __uni_decomp_data_0x2f998[] = { 0x82e5, 0, };
-static const char32 __uni_decomp_data_0x2f999[] = { 0x831d, 0, };
-static const char32 __uni_decomp_data_0x2f99a[] = { 0x8363, 0, };
-static const char32 __uni_decomp_data_0x2f99b[] = { 0x83ad, 0, };
-static const char32 __uni_decomp_data_0x2f99c[] = { 0x8323, 0, };
-static const char32 __uni_decomp_data_0x2f99d[] = { 0x83bd, 0, };
-static const char32 __uni_decomp_data_0x2f99e[] = { 0x83e7, 0, };
-static const char32 __uni_decomp_data_0x2f99f[] = { 0x8457, 0, };
-static const char32 __uni_decomp_data_0x2f9a0[] = { 0x8353, 0, };
-static const char32 __uni_decomp_data_0x2f9a1[] = { 0x83ca, 0, };
-static const char32 __uni_decomp_data_0x2f9a2[] = { 0x83cc, 0, };
-static const char32 __uni_decomp_data_0x2f9a3[] = { 0x83dc, 0, };
-static const char32 __uni_decomp_data_0x2f9a4[] = { 0x26c36, 0, };
-static const char32 __uni_decomp_data_0x2f9a5[] = { 0x26d6b, 0, };
-static const char32 __uni_decomp_data_0x2f9a6[] = { 0x26cd5, 0, };
-static const char32 __uni_decomp_data_0x2f9a7[] = { 0x452b, 0, };
-static const char32 __uni_decomp_data_0x2f9a8[] = { 0x84f1, 0, };
-static const char32 __uni_decomp_data_0x2f9a9[] = { 0x84f3, 0, };
-static const char32 __uni_decomp_data_0x2f9aa[] = { 0x8516, 0, };
-static const char32 __uni_decomp_data_0x2f9ab[] = { 0x273ca, 0, };
-static const char32 __uni_decomp_data_0x2f9ac[] = { 0x8564, 0, };
-static const char32 __uni_decomp_data_0x2f9ad[] = { 0x26f2c, 0, };
-static const char32 __uni_decomp_data_0x2f9ae[] = { 0x455d, 0, };
-static const char32 __uni_decomp_data_0x2f9af[] = { 0x4561, 0, };
-static const char32 __uni_decomp_data_0x2f9b0[] = { 0x26fb1, 0, };
-static const char32 __uni_decomp_data_0x2f9b1[] = { 0x270d2, 0, };
-static const char32 __uni_decomp_data_0x2f9b2[] = { 0x456b, 0, };
-static const char32 __uni_decomp_data_0x2f9b3[] = { 0x8650, 0, };
-static const char32 __uni_decomp_data_0x2f9b4[] = { 0x865c, 0, };
-static const char32 __uni_decomp_data_0x2f9b5[] = { 0x8667, 0, };
-static const char32 __uni_decomp_data_0x2f9b6[] = { 0x8669, 0, };
-static const char32 __uni_decomp_data_0x2f9b7[] = { 0x86a9, 0, };
-static const char32 __uni_decomp_data_0x2f9b8[] = { 0x8688, 0, };
-static const char32 __uni_decomp_data_0x2f9b9[] = { 0x870e, 0, };
-static const char32 __uni_decomp_data_0x2f9ba[] = { 0x86e2, 0, };
-static const char32 __uni_decomp_data_0x2f9bb[] = { 0x8779, 0, };
-static const char32 __uni_decomp_data_0x2f9bc[] = { 0x8728, 0, };
-static const char32 __uni_decomp_data_0x2f9bd[] = { 0x876b, 0, };
-static const char32 __uni_decomp_data_0x2f9be[] = { 0x8786, 0, };
-static const char32 __uni_decomp_data_0x2f9bf[] = { 0x45d7, 0, };
-static const char32 __uni_decomp_data_0x2f9c0[] = { 0x87e1, 0, };
-static const char32 __uni_decomp_data_0x2f9c1[] = { 0x8801, 0, };
-static const char32 __uni_decomp_data_0x2f9c2[] = { 0x45f9, 0, };
-static const char32 __uni_decomp_data_0x2f9c3[] = { 0x8860, 0, };
-static const char32 __uni_decomp_data_0x2f9c4[] = { 0x8863, 0, };
-static const char32 __uni_decomp_data_0x2f9c5[] = { 0x27667, 0, };
-static const char32 __uni_decomp_data_0x2f9c6[] = { 0x88d7, 0, };
-static const char32 __uni_decomp_data_0x2f9c7[] = { 0x88de, 0, };
-static const char32 __uni_decomp_data_0x2f9c8[] = { 0x4635, 0, };
-static const char32 __uni_decomp_data_0x2f9c9[] = { 0x88fa, 0, };
-static const char32 __uni_decomp_data_0x2f9ca[] = { 0x34bb, 0, };
-static const char32 __uni_decomp_data_0x2f9cb[] = { 0x278ae, 0, };
-static const char32 __uni_decomp_data_0x2f9cc[] = { 0x27966, 0, };
-static const char32 __uni_decomp_data_0x2f9cd[] = { 0x46be, 0, };
-static const char32 __uni_decomp_data_0x2f9ce[] = { 0x46c7, 0, };
-static const char32 __uni_decomp_data_0x2f9cf[] = { 0x8aa0, 0, };
-static const char32 __uni_decomp_data_0x2f9d0[] = { 0x8aed, 0, };
-static const char32 __uni_decomp_data_0x2f9d1[] = { 0x8b8a, 0, };
-static const char32 __uni_decomp_data_0x2f9d2[] = { 0x8c55, 0, };
-static const char32 __uni_decomp_data_0x2f9d3[] = { 0x27ca8, 0, };
-static const char32 __uni_decomp_data_0x2f9d4[] = { 0x8cab, 0, };
-static const char32 __uni_decomp_data_0x2f9d5[] = { 0x8cc1, 0, };
-static const char32 __uni_decomp_data_0x2f9d6[] = { 0x8d1b, 0, };
-static const char32 __uni_decomp_data_0x2f9d7[] = { 0x8d77, 0, };
-static const char32 __uni_decomp_data_0x2f9d8[] = { 0x27f2f, 0, };
-static const char32 __uni_decomp_data_0x2f9d9[] = { 0x20804, 0, };
-static const char32 __uni_decomp_data_0x2f9da[] = { 0x8dcb, 0, };
-static const char32 __uni_decomp_data_0x2f9db[] = { 0x8dbc, 0, };
-static const char32 __uni_decomp_data_0x2f9dc[] = { 0x8df0, 0, };
-static const char32 __uni_decomp_data_0x2f9dd[] = { 0x208de, 0, };
-static const char32 __uni_decomp_data_0x2f9de[] = { 0x8ed4, 0, };
-static const char32 __uni_decomp_data_0x2f9df[] = { 0x8f38, 0, };
-static const char32 __uni_decomp_data_0x2f9e0[] = { 0x285d2, 0, };
-static const char32 __uni_decomp_data_0x2f9e1[] = { 0x285ed, 0, };
-static const char32 __uni_decomp_data_0x2f9e2[] = { 0x9094, 0, };
-static const char32 __uni_decomp_data_0x2f9e3[] = { 0x90f1, 0, };
-static const char32 __uni_decomp_data_0x2f9e4[] = { 0x9111, 0, };
-static const char32 __uni_decomp_data_0x2f9e5[] = { 0x2872e, 0, };
-static const char32 __uni_decomp_data_0x2f9e6[] = { 0x911b, 0, };
-static const char32 __uni_decomp_data_0x2f9e7[] = { 0x9238, 0, };
-static const char32 __uni_decomp_data_0x2f9e8[] = { 0x92d7, 0, };
-static const char32 __uni_decomp_data_0x2f9e9[] = { 0x92d8, 0, };
-static const char32 __uni_decomp_data_0x2f9ea[] = { 0x927c, 0, };
-static const char32 __uni_decomp_data_0x2f9eb[] = { 0x93f9, 0, };
-static const char32 __uni_decomp_data_0x2f9ec[] = { 0x9415, 0, };
-static const char32 __uni_decomp_data_0x2f9ed[] = { 0x28bfa, 0, };
-static const char32 __uni_decomp_data_0x2f9ee[] = { 0x958b, 0, };
-static const char32 __uni_decomp_data_0x2f9ef[] = { 0x4995, 0, };
-static const char32 __uni_decomp_data_0x2f9f0[] = { 0x95b7, 0, };
-static const char32 __uni_decomp_data_0x2f9f1[] = { 0x28d77, 0, };
-static const char32 __uni_decomp_data_0x2f9f2[] = { 0x49e6, 0, };
-static const char32 __uni_decomp_data_0x2f9f3[] = { 0x96c3, 0, };
-static const char32 __uni_decomp_data_0x2f9f4[] = { 0x5db2, 0, };
-static const char32 __uni_decomp_data_0x2f9f5[] = { 0x9723, 0, };
-static const char32 __uni_decomp_data_0x2f9f6[] = { 0x29145, 0, };
-static const char32 __uni_decomp_data_0x2f9f7[] = { 0x2921a, 0, };
-static const char32 __uni_decomp_data_0x2f9f8[] = { 0x4a6e, 0, };
-static const char32 __uni_decomp_data_0x2f9f9[] = { 0x4a76, 0, };
-static const char32 __uni_decomp_data_0x2f9fa[] = { 0x97e0, 0, };
-static const char32 __uni_decomp_data_0x2f9fb[] = { 0x2940a, 0, };
-static const char32 __uni_decomp_data_0x2f9fc[] = { 0x4ab2, 0, };
-static const char32 __uni_decomp_data_0x2f9fd[] = { 0x29496, 0, };
-static const char32 __uni_decomp_data_0x2f9fe[] = { 0x980b, 0, };
-static const char32 __uni_decomp_data_0x2f9ff[] = { 0x980b, 0, };
+static const char32 __uni_decomp_data_0x2f980[] = { 1, 0x2335f, };
+static const char32 __uni_decomp_data_0x2f981[] = { 1, 0x43d5, };
+static const char32 __uni_decomp_data_0x2f982[] = { 1, 0x80b2, };
+static const char32 __uni_decomp_data_0x2f983[] = { 1, 0x8103, };
+static const char32 __uni_decomp_data_0x2f984[] = { 1, 0x440b, };
+static const char32 __uni_decomp_data_0x2f985[] = { 1, 0x813e, };
+static const char32 __uni_decomp_data_0x2f986[] = { 1, 0x5ab5, };
+static const char32 __uni_decomp_data_0x2f987[] = { 1, 0x267a7, };
+static const char32 __uni_decomp_data_0x2f988[] = { 1, 0x267b5, };
+static const char32 __uni_decomp_data_0x2f989[] = { 1, 0x23393, };
+static const char32 __uni_decomp_data_0x2f98a[] = { 1, 0x2339c, };
+static const char32 __uni_decomp_data_0x2f98b[] = { 1, 0x8201, };
+static const char32 __uni_decomp_data_0x2f98c[] = { 1, 0x8204, };
+static const char32 __uni_decomp_data_0x2f98d[] = { 1, 0x8f9e, };
+static const char32 __uni_decomp_data_0x2f98e[] = { 1, 0x446b, };
+static const char32 __uni_decomp_data_0x2f98f[] = { 1, 0x8291, };
+static const char32 __uni_decomp_data_0x2f990[] = { 1, 0x828b, };
+static const char32 __uni_decomp_data_0x2f991[] = { 1, 0x829d, };
+static const char32 __uni_decomp_data_0x2f992[] = { 1, 0x52b3, };
+static const char32 __uni_decomp_data_0x2f993[] = { 1, 0x82b1, };
+static const char32 __uni_decomp_data_0x2f994[] = { 1, 0x82b3, };
+static const char32 __uni_decomp_data_0x2f995[] = { 1, 0x82bd, };
+static const char32 __uni_decomp_data_0x2f996[] = { 1, 0x82e6, };
+static const char32 __uni_decomp_data_0x2f997[] = { 1, 0x26b3c, };
+static const char32 __uni_decomp_data_0x2f998[] = { 1, 0x82e5, };
+static const char32 __uni_decomp_data_0x2f999[] = { 1, 0x831d, };
+static const char32 __uni_decomp_data_0x2f99a[] = { 1, 0x8363, };
+static const char32 __uni_decomp_data_0x2f99b[] = { 1, 0x83ad, };
+static const char32 __uni_decomp_data_0x2f99c[] = { 1, 0x8323, };
+static const char32 __uni_decomp_data_0x2f99d[] = { 1, 0x83bd, };
+static const char32 __uni_decomp_data_0x2f99e[] = { 1, 0x83e7, };
+static const char32 __uni_decomp_data_0x2f99f[] = { 1, 0x8457, };
+static const char32 __uni_decomp_data_0x2f9a0[] = { 1, 0x8353, };
+static const char32 __uni_decomp_data_0x2f9a1[] = { 1, 0x83ca, };
+static const char32 __uni_decomp_data_0x2f9a2[] = { 1, 0x83cc, };
+static const char32 __uni_decomp_data_0x2f9a3[] = { 1, 0x83dc, };
+static const char32 __uni_decomp_data_0x2f9a4[] = { 1, 0x26c36, };
+static const char32 __uni_decomp_data_0x2f9a5[] = { 1, 0x26d6b, };
+static const char32 __uni_decomp_data_0x2f9a6[] = { 1, 0x26cd5, };
+static const char32 __uni_decomp_data_0x2f9a7[] = { 1, 0x452b, };
+static const char32 __uni_decomp_data_0x2f9a8[] = { 1, 0x84f1, };
+static const char32 __uni_decomp_data_0x2f9a9[] = { 1, 0x84f3, };
+static const char32 __uni_decomp_data_0x2f9aa[] = { 1, 0x8516, };
+static const char32 __uni_decomp_data_0x2f9ab[] = { 1, 0x273ca, };
+static const char32 __uni_decomp_data_0x2f9ac[] = { 1, 0x8564, };
+static const char32 __uni_decomp_data_0x2f9ad[] = { 1, 0x26f2c, };
+static const char32 __uni_decomp_data_0x2f9ae[] = { 1, 0x455d, };
+static const char32 __uni_decomp_data_0x2f9af[] = { 1, 0x4561, };
+static const char32 __uni_decomp_data_0x2f9b0[] = { 1, 0x26fb1, };
+static const char32 __uni_decomp_data_0x2f9b1[] = { 1, 0x270d2, };
+static const char32 __uni_decomp_data_0x2f9b2[] = { 1, 0x456b, };
+static const char32 __uni_decomp_data_0x2f9b3[] = { 1, 0x8650, };
+static const char32 __uni_decomp_data_0x2f9b4[] = { 1, 0x865c, };
+static const char32 __uni_decomp_data_0x2f9b5[] = { 1, 0x8667, };
+static const char32 __uni_decomp_data_0x2f9b6[] = { 1, 0x8669, };
+static const char32 __uni_decomp_data_0x2f9b7[] = { 1, 0x86a9, };
+static const char32 __uni_decomp_data_0x2f9b8[] = { 1, 0x8688, };
+static const char32 __uni_decomp_data_0x2f9b9[] = { 1, 0x870e, };
+static const char32 __uni_decomp_data_0x2f9ba[] = { 1, 0x86e2, };
+static const char32 __uni_decomp_data_0x2f9bb[] = { 1, 0x8779, };
+static const char32 __uni_decomp_data_0x2f9bc[] = { 1, 0x8728, };
+static const char32 __uni_decomp_data_0x2f9bd[] = { 1, 0x876b, };
+static const char32 __uni_decomp_data_0x2f9be[] = { 1, 0x8786, };
+static const char32 __uni_decomp_data_0x2f9bf[] = { 1, 0x45d7, };
+static const char32 __uni_decomp_data_0x2f9c0[] = { 1, 0x87e1, };
+static const char32 __uni_decomp_data_0x2f9c1[] = { 1, 0x8801, };
+static const char32 __uni_decomp_data_0x2f9c2[] = { 1, 0x45f9, };
+static const char32 __uni_decomp_data_0x2f9c3[] = { 1, 0x8860, };
+static const char32 __uni_decomp_data_0x2f9c4[] = { 1, 0x8863, };
+static const char32 __uni_decomp_data_0x2f9c5[] = { 1, 0x27667, };
+static const char32 __uni_decomp_data_0x2f9c6[] = { 1, 0x88d7, };
+static const char32 __uni_decomp_data_0x2f9c7[] = { 1, 0x88de, };
+static const char32 __uni_decomp_data_0x2f9c8[] = { 1, 0x4635, };
+static const char32 __uni_decomp_data_0x2f9c9[] = { 1, 0x88fa, };
+static const char32 __uni_decomp_data_0x2f9ca[] = { 1, 0x34bb, };
+static const char32 __uni_decomp_data_0x2f9cb[] = { 1, 0x278ae, };
+static const char32 __uni_decomp_data_0x2f9cc[] = { 1, 0x27966, };
+static const char32 __uni_decomp_data_0x2f9cd[] = { 1, 0x46be, };
+static const char32 __uni_decomp_data_0x2f9ce[] = { 1, 0x46c7, };
+static const char32 __uni_decomp_data_0x2f9cf[] = { 1, 0x8aa0, };
+static const char32 __uni_decomp_data_0x2f9d0[] = { 1, 0x8aed, };
+static const char32 __uni_decomp_data_0x2f9d1[] = { 1, 0x8b8a, };
+static const char32 __uni_decomp_data_0x2f9d2[] = { 1, 0x8c55, };
+static const char32 __uni_decomp_data_0x2f9d3[] = { 1, 0x27ca8, };
+static const char32 __uni_decomp_data_0x2f9d4[] = { 1, 0x8cab, };
+static const char32 __uni_decomp_data_0x2f9d5[] = { 1, 0x8cc1, };
+static const char32 __uni_decomp_data_0x2f9d6[] = { 1, 0x8d1b, };
+static const char32 __uni_decomp_data_0x2f9d7[] = { 1, 0x8d77, };
+static const char32 __uni_decomp_data_0x2f9d8[] = { 1, 0x27f2f, };
+static const char32 __uni_decomp_data_0x2f9d9[] = { 1, 0x20804, };
+static const char32 __uni_decomp_data_0x2f9da[] = { 1, 0x8dcb, };
+static const char32 __uni_decomp_data_0x2f9db[] = { 1, 0x8dbc, };
+static const char32 __uni_decomp_data_0x2f9dc[] = { 1, 0x8df0, };
+static const char32 __uni_decomp_data_0x2f9dd[] = { 1, 0x208de, };
+static const char32 __uni_decomp_data_0x2f9de[] = { 1, 0x8ed4, };
+static const char32 __uni_decomp_data_0x2f9df[] = { 1, 0x8f38, };
+static const char32 __uni_decomp_data_0x2f9e0[] = { 1, 0x285d2, };
+static const char32 __uni_decomp_data_0x2f9e1[] = { 1, 0x285ed, };
+static const char32 __uni_decomp_data_0x2f9e2[] = { 1, 0x9094, };
+static const char32 __uni_decomp_data_0x2f9e3[] = { 1, 0x90f1, };
+static const char32 __uni_decomp_data_0x2f9e4[] = { 1, 0x9111, };
+static const char32 __uni_decomp_data_0x2f9e5[] = { 1, 0x2872e, };
+static const char32 __uni_decomp_data_0x2f9e6[] = { 1, 0x911b, };
+static const char32 __uni_decomp_data_0x2f9e7[] = { 1, 0x9238, };
+static const char32 __uni_decomp_data_0x2f9e8[] = { 1, 0x92d7, };
+static const char32 __uni_decomp_data_0x2f9e9[] = { 1, 0x92d8, };
+static const char32 __uni_decomp_data_0x2f9ea[] = { 1, 0x927c, };
+static const char32 __uni_decomp_data_0x2f9eb[] = { 1, 0x93f9, };
+static const char32 __uni_decomp_data_0x2f9ec[] = { 1, 0x9415, };
+static const char32 __uni_decomp_data_0x2f9ed[] = { 1, 0x28bfa, };
+static const char32 __uni_decomp_data_0x2f9ee[] = { 1, 0x958b, };
+static const char32 __uni_decomp_data_0x2f9ef[] = { 1, 0x4995, };
+static const char32 __uni_decomp_data_0x2f9f0[] = { 1, 0x95b7, };
+static const char32 __uni_decomp_data_0x2f9f1[] = { 1, 0x28d77, };
+static const char32 __uni_decomp_data_0x2f9f2[] = { 1, 0x49e6, };
+static const char32 __uni_decomp_data_0x2f9f3[] = { 1, 0x96c3, };
+static const char32 __uni_decomp_data_0x2f9f4[] = { 1, 0x5db2, };
+static const char32 __uni_decomp_data_0x2f9f5[] = { 1, 0x9723, };
+static const char32 __uni_decomp_data_0x2f9f6[] = { 1, 0x29145, };
+static const char32 __uni_decomp_data_0x2f9f7[] = { 1, 0x2921a, };
+static const char32 __uni_decomp_data_0x2f9f8[] = { 1, 0x4a6e, };
+static const char32 __uni_decomp_data_0x2f9f9[] = { 1, 0x4a76, };
+static const char32 __uni_decomp_data_0x2f9fa[] = { 1, 0x97e0, };
+static const char32 __uni_decomp_data_0x2f9fb[] = { 1, 0x2940a, };
+static const char32 __uni_decomp_data_0x2f9fc[] = { 1, 0x4ab2, };
+static const char32 __uni_decomp_data_0x2f9fd[] = { 1, 0x29496, };
+static const char32 __uni_decomp_data_0x2f9fe[] = { 1, 0x980b, };
+static const char32 __uni_decomp_data_0x2f9ff[] = { 1, 0x980b, };
 
 
 
@@ -1822,36 +1822,36 @@
 };
 
 
-static const char32 __uni_decomp_data_0x2fa00[] = { 0x9829, 0, };
-static const char32 __uni_decomp_data_0x2fa01[] = { 0x295b6, 0, };
-static const char32 __uni_decomp_data_0x2fa02[] = { 0x98e2, 0, };
-static const char32 __uni_decomp_data_0x2fa03[] = { 0x4b33, 0, };
-static const char32 __uni_decomp_data_0x2fa04[] = { 0x9929, 0, };
-static const char32 __uni_decomp_data_0x2fa05[] = { 0x99a7, 0, };
-static const char32 __uni_decomp_data_0x2fa06[] = { 0x99c2, 0, };
-static const char32 __uni_decomp_data_0x2fa07[] = { 0x99fe, 0, };
-static const char32 __uni_decomp_data_0x2fa08[] = { 0x4bce, 0, };
-static const char32 __uni_decomp_data_0x2fa09[] = { 0x29b30, 0, };
-static const char32 __uni_decomp_data_0x2fa0a[] = { 0x9b12, 0, };
-static const char32 __uni_decomp_data_0x2fa0b[] = { 0x9c40, 0, };
-static const char32 __uni_decomp_data_0x2fa0c[] = { 0x9cfd, 0, };
-static const char32 __uni_decomp_data_0x2fa0d[] = { 0x4cce, 0, };
-static const char32 __uni_decomp_data_0x2fa0e[] = { 0x4ced, 0, };
-static const char32 __uni_decomp_data_0x2fa0f[] = { 0x9d67, 0, };
-static const char32 __uni_decomp_data_0x2fa10[] = { 0x2a0ce, 0, };
-static const char32 __uni_decomp_data_0x2fa11[] = { 0x4cf8, 0, };
-static const char32 __uni_decomp_data_0x2fa12[] = { 0x2a105, 0, };
-static const char32 __uni_decomp_data_0x2fa13[] = { 0x2a20e, 0, };
-static const char32 __uni_decomp_data_0x2fa14[] = { 0x2a291, 0, };
-static const char32 __uni_decomp_data_0x2fa15[] = { 0x9ebb, 0, };
-static const char32 __uni_decomp_data_0x2fa16[] = { 0x4d56, 0, };
-static const char32 __uni_decomp_data_0x2fa17[] = { 0x9ef9, 0, };
-static const char32 __uni_decomp_data_0x2fa18[] = { 0x9efe, 0, };
-static const char32 __uni_decomp_data_0x2fa19[] = { 0x9f05, 0, };
-static const char32 __uni_decomp_data_0x2fa1a[] = { 0x9f0f, 0, };
-static const char32 __uni_decomp_data_0x2fa1b[] = { 0x9f16, 0, };
-static const char32 __uni_decomp_data_0x2fa1c[] = { 0x9f3b, 0, };
-static const char32 __uni_decomp_data_0x2fa1d[] = { 0x2a600, 0, };
+static const char32 __uni_decomp_data_0x2fa00[] = { 1, 0x9829, };
+static const char32 __uni_decomp_data_0x2fa01[] = { 1, 0x295b6, };
+static const char32 __uni_decomp_data_0x2fa02[] = { 1, 0x98e2, };
+static const char32 __uni_decomp_data_0x2fa03[] = { 1, 0x4b33, };
+static const char32 __uni_decomp_data_0x2fa04[] = { 1, 0x9929, };
+static const char32 __uni_decomp_data_0x2fa05[] = { 1, 0x99a7, };
+static const char32 __uni_decomp_data_0x2fa06[] = { 1, 0x99c2, };
+static const char32 __uni_decomp_data_0x2fa07[] = { 1, 0x99fe, };
+static const char32 __uni_decomp_data_0x2fa08[] = { 1, 0x4bce, };
+static const char32 __uni_decomp_data_0x2fa09[] = { 1, 0x29b30, };
+static const char32 __uni_decomp_data_0x2fa0a[] = { 1, 0x9b12, };
+static const char32 __uni_decomp_data_0x2fa0b[] = { 1, 0x9c40, };
+static const char32 __uni_decomp_data_0x2fa0c[] = { 1, 0x9cfd, };
+static const char32 __uni_decomp_data_0x2fa0d[] = { 1, 0x4cce, };
+static const char32 __uni_decomp_data_0x2fa0e[] = { 1, 0x4ced, };
+static const char32 __uni_decomp_data_0x2fa0f[] = { 1, 0x9d67, };
+static const char32 __uni_decomp_data_0x2fa10[] = { 1, 0x2a0ce, };
+static const char32 __uni_decomp_data_0x2fa11[] = { 1, 0x4cf8, };
+static const char32 __uni_decomp_data_0x2fa12[] = { 1, 0x2a105, };
+static const char32 __uni_decomp_data_0x2fa13[] = { 1, 0x2a20e, };
+static const char32 __uni_decomp_data_0x2fa14[] = { 1, 0x2a291, };
+static const char32 __uni_decomp_data_0x2fa15[] = { 1, 0x9ebb, };
+static const char32 __uni_decomp_data_0x2fa16[] = { 1, 0x4d56, };
+static const char32 __uni_decomp_data_0x2fa17[] = { 1, 0x9ef9, };
+static const char32 __uni_decomp_data_0x2fa18[] = { 1, 0x9efe, };
+static const char32 __uni_decomp_data_0x2fa19[] = { 1, 0x9f05, };
+static const char32 __uni_decomp_data_0x2fa1a[] = { 1, 0x9f0f, };
+static const char32 __uni_decomp_data_0x2fa1b[] = { 1, 0x9f16, };
+static const char32 __uni_decomp_data_0x2fa1c[] = { 1, 0x9f3b, };
+static const char32 __uni_decomp_data_0x2fa1d[] = { 1, 0x2a600, };
 
 
 

Modified: sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_sort_data.ipp
==============================================================================
--- sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_sort_data.ipp	(original)
+++ sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_sort_data.ipp	2009-08-06 03:26:39 EDT (Thu, 06 Aug 2009)
@@ -19,7 +19,6 @@
 using namespace boost::unicode;
 
 
-
 namespace boost { namespace unicode { namespace ucd {
 }}}  // namespaces
 

Modified: sandbox/SOC/2009/unicode/libs/unicode/src/unicode_blocks.cpp
==============================================================================
--- sandbox/SOC/2009/unicode/libs/unicode/src/unicode_blocks.cpp	(original)
+++ sandbox/SOC/2009/unicode/libs/unicode/src/unicode_blocks.cpp	2009-08-06 03:26:39 EDT (Thu, 06 Aug 2009)
@@ -10,25 +10,25 @@
     struct block_find
     {
         typedef bool result_type;
-
-        bool operator()(const boost::unicode::ucd::unichar_blocks_internal& a, const boost::unicode::ucd::unichar_blocks_internal& b) const
+        
+        bool operator()(const unichar_blocks_internal& a, const unichar_blocks_internal& b) const
         {
             return a.first < b.first;
         }
         
-        bool operator()(const boost::unicode::ucd::unichar_blocks_internal& a, char32 b) const
+        bool operator()(const unichar_blocks_internal& a, char32 b) const
         {
             return a.first < b;
         }
         
-        bool operator()(char32 a, const boost::unicode::ucd::unichar_blocks_internal& b) const
+        bool operator()(char32 a, const unichar_blocks_internal& b) const
         {
             return a < b.first;
         }
     };
 }
 
-BOOST_UNICODE_DECL boost::unicode::ucd::block::type boost::unicode::ucd::get_block(char32 ch)
+BOOST_UNICODE_DECL block::type get_block(char32 ch)
 {
     const unichar_blocks_internal* end = __uni_block_data + __uni_block_data_size;
     
@@ -44,10 +44,10 @@
     if(ch > b->last)
         return block::none;
     
-    return (boost::unicode::ucd::block::type)b->first;
+    return (block::type)b->first;
 }
 
-BOOST_UNICODE_DECL const char* boost::unicode::ucd::as_string(boost::unicode::ucd::block::type type)
+BOOST_UNICODE_DECL const char* as_string(block::type type)
 {
     const unichar_blocks_internal* b = std::lower_bound(
         __uni_block_data, __uni_block_data + __uni_block_data_size,