chiark / gitweb /
merge from disorder.dev
authorrjk@greenend.org.uk <>
Fri, 23 Nov 2007 14:39:56 +0000 (14:39 +0000)
committerrjk@greenend.org.uk <>
Fri, 23 Nov 2007 14:39:56 +0000 (14:39 +0000)
45 files changed:
.bzrignore
disobedience/queue.c
doc/Makefile.am
doc/disorder-dbupgrade.8.in [new file with mode: 0644]
doc/disorder_config.5.in
doc/disorder_protocol.5.in
lib/Makefile.am
lib/charset.c
lib/charset.h
lib/configuration.c
lib/configuration.h
lib/split.c
lib/test.c
lib/trackname.c
lib/unicode.c [new file with mode: 0644]
lib/unicode.h [new file with mode: 0644]
lib/unidata.c
lib/unidata.h
lib/utf8.c
lib/utf8.h
lib/vector.h
lib/words.c [deleted file]
lib/words.h [deleted file]
python/disorder.py.in
scripts/Makefile.am
scripts/make-unidata
server/Makefile.am
server/README.dbversions [new file with mode: 0644]
server/cgi.c
server/dbupgrade.c [new file with mode: 0644]
server/dcgi.c
server/deadlock.c
server/dump.c
server/rescan.c
server/server.c
server/state.c
server/stats.c
server/trackdb-int.h
server/trackdb.c
server/trackdb.h
tests/Makefile.am
tests/dbversion.py [new file with mode: 0755]
tests/dtest.py
tests/files.py [new file with mode: 0755]
tests/search.py [new file with mode: 0755]

index 230d66a..1b45fb1 100644 (file)
@@ -117,4 +117,16 @@ server/disorder-stats
 *.deb
 *.dsc
 disobedience/disobedience.html
+lib/NormalizationTest.txt
+lib/CaseFolding.txt
+lib/UnicodeData.txt
+lib/GraphemeBreakProperty.txt
+lib/GraphemeBreakTest.txt
+lib/WordBreakProperty.txt
+lib/SentenceBreakProperty.txt
+lib/WordBreakTest.txt
+lib/DerivedNormalizationProps.txt
 tests/*.log
+server/disorder-dbupgrade
+doc/disorder-dbupgrade.8.html
+doc/disorder-dbupgrade.8
index fb1b73e..7565935 100644 (file)
@@ -55,6 +55,7 @@
  */
 
 #include "disobedience.h"
+#include "charset.h"
 
 /** @brief Horizontal padding for queue cells */
 #define HCELLPADDING 4
@@ -430,7 +431,8 @@ static GtkWidget *column_namepart(const struct queuelike
                                   const char *data) {
   D(("column_namepart"));
   NW(label);
-  return gtk_label_new(namepart(q->track, "display", data));
+  return gtk_label_new(truncate_for_display(namepart(q->track, "display", data),
+                                            config->short_display));
 }
 
 /** @brief Compute the length field */
index d7e9187..3e8078c 100644 (file)
@@ -21,7 +21,7 @@
 SEDFILES=disorder.1 disorderd.8 disorder_config.5 \
        disorder-dump.8 disorder_protocol.5 disorder-deadlock.8 \
        disorder-rescan.8 disobedience.1 disorderfm.1 disorder-playrtp.1 \
-       disorder-decode.8 disorder-stats.8
+       disorder-decode.8 disorder-stats.8 disorder-dbupgrade.8
 
 include ${top_srcdir}/scripts/sedfiles.make
 
@@ -29,7 +29,7 @@ man_MANS=disorderd.8 disorder.1 disorder.3 disorder_config.5 disorder-dump.8 \
        disorder_protocol.5 disorder-deadlock.8 \
        disorder-rescan.8 disobedience.1 disorderfm.1 disorder-speaker.8 \
        disorder-playrtp.1 disorder-normalize.8 disorder-decode.8 \
-       disorder-stats.8
+       disorder-stats.8 disorder-dbupgrade.8
 
 noinst_MANS=tkdisorder.1
 
@@ -48,6 +48,6 @@ EXTRA_DIST=disorderd.8.in disorder.1.in disorder_config.5.in \
           tkdisorder.1 disorder-deadlock.8.in disorder-rescan.8.in \
           disobedience.1.in disorderfm.1.in disorder-speaker.8 \
           disorder-playrtp.1.in disorder-decode.8.in disorder-normalize.8 \
-          disorder-stats.8.in
+          disorder-stats.8.in disorder-dbupgrade.8.in
 
 CLEANFILES=$(SEDFILES) $(HTMLMAN)
diff --git a/doc/disorder-dbupgrade.8.in b/doc/disorder-dbupgrade.8.in
new file mode 100644 (file)
index 0000000..3d8a3b0
--- /dev/null
@@ -0,0 +1,47 @@
+.\"
+.\" Copyright (C) 2007 Richard Kettlewell
+.\"
+.\" This program is free software; you can redistribute it and/or modify
+.\" it under the terms of the GNU General Public License as published by
+.\" the Free Software Foundation; either version 2 of the License, or
+.\" (at your option) any later version.
+.\"
+.\" This program is distributed in the hope that it will be useful, but
+.\" WITHOUT ANY WARRANTY; without even the implied warranty of
+.\" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+.\" General Public License for more details.
+.\"
+.\" You should have received a copy of the GNU General Public License
+.\" along with this program; if not, write to the Free Software
+.\" Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+.\" USA
+.\"
+.TH disorder-dbupgrade 8
+.SH NAME
+disorder-dbupgrade \- DisOrder Database Upgrader
+.SH SYNOPSIS
+.B disorder-dbupgrade
+.RI [ OPTIONS ]
+.RI [ PATH ...]
+.SH DESCRIPTION
+.B disorder-dbupgrade
+is DisOrder's database upgrader.  It is invoked by DisOrder when
+necessary and does not need to be invoked manually.
+.SH OPTIONS
+.TP
+.B --config \fIPATH\fR, \fB-c \fIPATH
+Set the configuration file.
+.TP
+.B --debug\fR, \fB-d
+Enable debugging.
+.TP
+.B --help\fR, \fB-h
+Display a usage message.
+.TP
+.B --version\fR, \fB-V
+Display version number.
+.SH "SEE ALSO"
+\fBdisorderd\fR(8), \fBdisorder_config\fR(5)
+.\" Local Variables:
+.\" mode:nroff
+.\" End:
index 0b1535f..badedeb 100644 (file)
@@ -126,6 +126,10 @@ interface.)
 Plugins are opened the first time they are required and never after,
 so after changing a plugin you must restart the server before it is
 guaranteed to take effect.
+.IP
+If
+.B plugins
+is used without arguments the plugin path is cleared.
 .SS "Server Configuration"
 .TP
 .B alias \fIPATTERN\fR
@@ -326,6 +330,10 @@ For the server to be able to calculate track lengths, there should be a
 command corresponding to each
 .B player
 command.
+.IP
+If
+.B player
+is used without arguments, the list of players is cleared.
 .TP
 .B prefsync \fISECONDS\fR
 The interval at which the preferences log file will be synchronised.  Defaults
@@ -440,14 +448,23 @@ Scratches are played using the same logic as other tracks.
 .IP
 At least for the time being, path names of scratches must be encoded using
 UTF-8 (which means that ASCII will do).
+.IP
+If \fBscratch\fR is used without arguments then the list of scratches is
+cleared.
 .TP
 .B stopword \fIWORD\fR ...
 Specifies one or more stopwords that should not take part in searches
 over track names.
+.IP
+If \fBstopword\fR is used without arguments then the list of stopwords is
+cleared.
 .TP
 .B tracklength \fIPATTERN\fR \fIMODULE\fR
 Specifies the module used to calculate the length of files matching
 \fIPATTERN\fR.  \fIMODULE\fR specifies which plugin module to use.
+.IP
+If \fBtracklength\fR is used without arguments then the list of modules is
+cleared.
 .SS "Client Configuration"
 .TP
 .B connect \fIHOST SERVICE\fR
@@ -468,6 +485,8 @@ interface.  If a template appears in more than one template directory
 then the one in the earliest directory specified is chosen.
 .IP
 See below for further details.
+.IP
+If \fBtemplates\fR is used without arguments then the template path is cleared.
 .TP
 .B transform \fITYPE\fR \fIREGEXP\fR \fISUBST\fR [\fICONTEXT\fR [\fIREFLAGS\fR]]
 Determines how names are sorted and displayed in track choice displays.
@@ -500,6 +519,10 @@ This must be the full URL, e.g. \fBhttp://myhost/cgi-bin/jukebox\fR and not
 .TP
 .B allow \fIUSERNAME\fR \fIPASSWORD\fR
 Specify a username/password pair.
+.IP
+If
+.B allow
+is used without arguments, the list of allowed users is cleared.
 .TP
 .B password \fIPASSWORD\fR
 Specify password.
@@ -507,6 +530,9 @@ Specify password.
 .B trust \fIUSERNAME\fR
 Allow \fIUSERNAME\fR to perform privileged operations such as shutting
 down or reconfiguring the daemon, or becoming another user.
+.IP
+If \fBtrust\fR is used without arguments then the list of trusted users is
+cleared.
 .TP
 .B user \fIUSER\fR
 Specifies the user to run as.  Only makes sense if invoked as root (or
@@ -558,6 +584,14 @@ If unset or \fByes\fR then play is enabled.  Otherwise it is disabled.  Use
 .B random-play
 If unset or \fByes\fR then random play is enabled.  Otherwise it is disabled.
 Use \fBdisable\fR rather than setting it directly.
+.PP
+Global preferences starting '_' are read-only (in the sense that you cannot
+modify them; the server may modify them as part of its normal operation).  They
+are:
+.TP
+.B _dbversion
+The database version string.  This is used by DisOrder to detect when it must
+modify the database after an upgrade.
 .SH "LIBAO DRIVER"
 .SS "Raw Protocol Players"
 Raw protocol players are expected to use the \fBdisorder\fR libao driver.
@@ -731,7 +765,7 @@ Expands to the filename of the current file or directory, inside the template
 argument to \fBchoose\fR.
 .TP
 .B @files{\fITEMPLATE\fB}
-Expands \fITEMPLATE\fB once for each file indicated by the \fBdirectory\fR CGI
+Expands \fITEMPLATE\fR once for each file indicated by the \fBdirectory\fR CGI
 arg if it is present, or otherwise for the list of files counted by \fBfiles\fR
 with names \fB0_file\fR, \fB1_file\fR etc.
 .TP
@@ -976,7 +1010,7 @@ URL-quote \fISTRING\fR.
 Expands to \fBdisorder.cgi\fR's version string.
 .TP
 .B @volume:\fISPEAKER\fB@
-The volume on the left or right speaker.  \fISPEAKER\fR must be \fBleft\fB or
+The volume on the left or right speaker.  \fISPEAKER\fR must be \fBleft\fR or
 \fBright\fR.
 .TP
 .B @when@
index d20edcf..bf293e9 100644 (file)
@@ -26,10 +26,12 @@ in this man page.
 The protocol is liable to change without notice.  You are recommended to check
 the implementation before believing this document.
 .SH "GENERAL SYNTAX"
-Everything is encoded using UTF-8.
+Everything is encoded using UTF-8.  See
+.B "CHARACTER ENCODING"
+below for more detail on character encoding issues.
 .PP
-Commands and responses consist of a line followed (depending on the
-command or response) by a message.
+Commands and responses consist of a line perhaps followed (depending on the
+command or response) by a body.
 .PP
 The line syntax is the same as described in \fBdisorder_config\fR(5) except
 that comments are prohibited.
@@ -455,6 +457,63 @@ The volume changed.
 is as defined in
 .B "TRACK INFORMATION"
 above.
+.SH "CHARACTER ENCODING"
+All data sent by both server and client is encoded using UTF-8.  Moreover it
+must be valid UTF-8, i.e. non-minimal sequences are not permitted, nor are
+surrogates, nor are code points outside the Unicode code space.
+.PP
+There are no particular normalization requirements on either side of the
+protocol.  The server currently converts internally to NFC, the client must
+normalize the responses returned if it needs some normalized form for further
+processing.
+.PP
+The various characters which divide up lines may not be followed by combining
+characters.  For instance all of the following are prohibited:
+.TP
+.B o
+LINE FEED followed by a combining character.  For example the sequence
+LINE FEED, COMBINING GRAVE ACCENT is never permitted.
+.TP
+.B o
+APOSTROPHE or QUOTATION MARK followed by a combining character when used to
+delimit fields.  For instance a line starting APOSTROPHE, COMBINING CEDILLA
+is prohibited.
+.IP
+Note that such sequences are not prohibited when the quote character cannot be
+interpreted as a field delimiter.  For instance APOSTROPHE, REVERSE SOLIDUS,
+APOSTROPHE, COMBINING CEDILLA, APOSTROPHE would be permitted.
+.TP
+.B o
+REVERSE SOLIDUS (BACKSLASH) followed by a combining character in a quoted
+string when it is the first character of an escape sequence.  For instance a
+line starting APOSTROPHE, REVERSE SOLIDUS, COMBINING TILDE is prohibited.
+.IP
+As above such sequences are not prohibited when the character is not being used
+to start an escape sequence.  For instance APOSTROPHE, REVERSE SOLIDUS,
+REVERSE SOLIDS, COMBINING TILDER, APOSTROPHE is permitted.
+.TP
+.B o
+Any of the field-splitting whitespace characters followed by a combining
+character when not part of a quoted field.  For instance a line starting COLON,
+SPACE, COMBINING CANDRABINDU is prohibited.
+.IP
+As above non-delimiter uses are fine.
+.TP
+.B o
+The FULL STOP characters used to quote or delimit a body.
+.PP
+Furthermore none of these characters are permitted to appear in the context of
+a canonical decomposition (i.e. they must still be present when converted to
+NFC).  In practice however this is not an issue in Unicode 5.0.
+.PP
+These rules are consistent with the observation that the split() function is
+essentially a naive ASCII parser.  The implication is not that these sequences
+never actually appear in the protocol, merely that the server is not required
+to honor them in any useful way nor be consistent between versions: in current
+versions the result will be lines and fields that start with combining
+characters and are not necessarily split where you expect, but future versions
+may remove them, reject them or ignore some or all of the delimiters that have
+following combining characters, and no notice will be given of any change.
 .SH "SEE ALSO"
 \fBdisorder\fR(1),
 \fBtime\fR(2),
index 524496e..b642c89 100644 (file)
@@ -63,12 +63,12 @@ libdisorder_a_SOURCES=charset.c charset.h           \
        timeval.h                                       \
        trackname.c trackname.h                         \
        user.h user.c                                   \
+       unicode.h unicode.c                             \
        unidata.h unidata.c                             \
        utf8.h utf8.c                                   \
        vacopy.h                                        \
        vector.c vector.h                               \
        wav.h wav.c                                     \
-       words.c words.h                                 \
        wstat.c wstat.h                                 \
        disorder.h
 
@@ -95,6 +95,9 @@ test_DEPENDENCIES=libdisorder.a
 check: test #test.i
        ./test
 
+rebuild-unicode:
+       cd ${srcdir} && ${top_srcdir}/scripts/make-unidata
+
 %.i: %.c
        $(CPP) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) -c $< > $@.new
        mv $@.new $@
index 3f0e8bc..fbcf275 100644 (file)
@@ -31,9 +31,8 @@
 #include "log.h"
 #include "charset.h"
 #include "configuration.h"
-#include "utf8.h"
 #include "vector.h"
-#include "unidata.h"
+#include "unicode.h"
 
 /** @brief Low-level converstion routine
  * @param from Source encoding
@@ -70,74 +69,6 @@ static void *convert(const char *from, const char *to,
   return buf;
 }
 
-/** @brief Convert UTF-8 to UCS-4
- * @param mb Pointer to 0-terminated UTF-8 string
- * @return Pointer to 0-terminated UCS-4 string
- *
- * Not everybody's iconv supports UCS-4, and it's inconvenient to have to know
- * our endianness, and it's easy to convert it ourselves, so we do.  See also
- * @ref ucs42utf8().
- */ 
-uint32_t *utf82ucs4(const char *mb) {
-  struct dynstr_ucs4 d;
-  uint32_t c;
-
-  dynstr_ucs4_init(&d);
-  while(*mb) {
-    PARSE_UTF8(mb, c,
-              error(0, "invalid UTF-8 sequence"); return 0;);
-    dynstr_ucs4_append(&d, c);
-  }
-  dynstr_ucs4_terminate(&d);
-  return d.vec;
-}
-
-/** @brief Convert one UCS-4 character to UTF-8
- * @param c Character to convert
- * @param d Dynamic string to append UTF-8 sequence to
- * @return 0 on success, -1 on error
- */
-int one_ucs42utf8(uint32_t c, struct dynstr *d) {
-  if(c < 0x80)
-    dynstr_append(d, c);
-  else if(c < 0x800) {
-    dynstr_append(d, 0xC0 | (c >> 6));
-    dynstr_append(d, 0x80 | (c & 0x3F));
-  } else if(c < 0x10000) {
-    dynstr_append(d, 0xE0 | (c >> 12));
-    dynstr_append(d, 0x80 | ((c >> 6) & 0x3F));
-    dynstr_append(d, 0x80 | (c & 0x3F));
-  } else if(c < 0x110000) {
-    dynstr_append(d, 0xF0 | (c >> 18));
-    dynstr_append(d, 0x80 | ((c >> 12) & 0x3F));
-    dynstr_append(d, 0x80 | ((c >> 6) & 0x3F));
-    dynstr_append(d, 0x80 | (c & 0x3F));
-  } else {
-    error(0, "invalid UCS-4 character %#"PRIx32, c);
-    return -1;
-  }
-  return 0;
-}
-
-/** @brief Convert UCS-4 to UTF-8
- * @param u Pointer to 0-terminated UCS-4 string
- * @return Pointer to 0-terminated UTF-8 string
- *
- * See @ref utf82ucs4().
- */
-char *ucs42utf8(const uint32_t *u) {
-  struct dynstr d;
-  uint32_t c;
-
-  dynstr_init(&d);
-  while((c = *u++)) {
-    if(one_ucs42utf8(c, &d))
-      return 0;
-  }
-  dynstr_terminate(&d);
-  return d.vec;
-}
-
 /** @brief Convert from the local multibyte encoding to UTF-8 */
 char *mb2utf8(const char *mb) {
   return convert(nl_langinfo(CODESET), "UTF-8", mb, strlen(mb) + 1);
@@ -167,80 +98,50 @@ char *any2any(const char *from,
   else return xstrdup(any);
 }
 
-/** @brief strlen workalike for UCS-4 strings
- *
- * We don't rely on the local @c wchar_t being UCS-4.
- */
-int ucs4cmp(const uint32_t *a, const uint32_t *b) {
-  while(*a && *b && *a == *b) ++a, ++b;
-  if(*a > *b) return 1;
-  else if(*a < *b) return -1;
-  else return 0;
-}
-
-/** @brief Return nonzero if @p c is a combining character */
-static int combining(int c) {
-  if(c < UNICODE_NCHARS) {
-    const struct unidata *const ud = &unidata[c / 256][c % 256];
-
-    return ud->gc == unicode_gc_Mn || ud->ccc != 0;
-  }
-  /* Assume unknown characters are noncombining */
-  return 0;
-}
-
 /** @brief Truncate a string for display purposes
  * @param s Pointer to UTF-8 string
  * @param max Maximum number of columns
  * @return @p or truncated string (never NULL)
  *
- * We don't correctly support bidi or double-width characters yet, nor
- * locate default grapheme cluster boundaries for saner truncation.
+ * Returns a string that is no longer than @p max graphemes long and is either
+ * (canonically) equal to @p s or is a truncated form of it with an ellipsis
+ * appended.
+ *
+ * We don't take display width into account (tricky for HTML!) and we don't
+ * attempt to implement the Bidi algorithm.  If you have track names for which
+ * either of these matter in practice then get in touch.
  */
 const char *truncate_for_display(const char *s, long max) {
-  const char *t = s, *r, *cut = 0;
-  char *truncated;
-  uint32_t c;
-  long n = 0;
+  uint32_t *s32;
+  size_t l32, cut;
+  utf32_iterator it;
 
-  /* We need to discover two things: firstly whether the string is
-   * longer than @p max glyphs and secondly if it is not, where to cut
-   * the string.
-   *
-   * Combining characters follow their base character (unicode
-   * standard 5.0 s2.11), so after each base character we must 
-   */
-  while(*t) {
-    PARSE_UTF8(t, c, return s);
-    if(combining(c))
-      /* This must be an initial combining character.  We just skip it. */
-      continue;
-    /* So c must be a base character.  It may be followed by any
-     * number of combining characters.  We advance past them. */
-    do {
-      r = t;
-      PARSE_UTF8(t, c, return s);
-    } while(combining(c));
-    /* Last character wasn't a combining character so back up */
-    t = r;
-    ++n;
-    /* So now there are N glyphs before position T.  We might
-     * therefore have reached the cut position. */
-    if(n == max - 3)
-      cut = t;
+  /* Convert to UTF-32 for processing */
+  if(!(s32 = utf8_to_utf32(s, strlen(s), &l32)))
+    return 0;
+  it = utf32_iterator_new(s32, l32);
+  cut = l32;
+  while(max && utf32_iterator_where(it) < l32) {
+    utf32_iterator_advance(it, 1);
+    if(utf32_iterator_grapheme_boundary(it))
+      --max;
+    if(max == 1)
+      cut = utf32_iterator_where(it);
+  }
+  if(max == 0) {                        /* we need to cut */
+    s32[cut] = 0x2026;                  /* HORIZONTAL ELLIPSIS */
+    l32 = cut + 1;
+    s = utf32_to_utf8(s32, l32, 0);
   }
-  /* If the string is short enough we return it unmodified */
-  if(n < max)
-    return s;
-  truncated = xmalloc_noptr(cut - s + 4);
-  memcpy(truncated, s, cut - s);
-  strcpy(truncated + (cut - s), "...");
-  return truncated;
+  xfree(s32);
+  return s;
 }
 
 /*
 Local Variables:
 c-basic-offset:2
 comment-column:40
+fill-column:79
+indent-tabs-mode:nil
 End:
 */
index 70b5b2f..f7860df 100644 (file)
@@ -24,10 +24,6 @@ struct dynstr;
 
 /* Character encoding conversion routines */
 
-int one_ucs42utf8(uint32_t c, struct dynstr *d);
-
-uint32_t *utf82ucs4(const char *mb);
-char *ucs42utf8(const uint32_t *u);
 char *mb2utf8(const char *mb);
 char *utf82mb(const char *utf8);
 /* various conversions, between multibyte strings (mb) in
@@ -63,9 +59,6 @@ static inline char *nullcheck(char *s) {
   return s;
 }
 
-int ucs4cmp(const uint32_t *a, const uint32_t *b);
-/* like strcmp */
-
 const char *truncate_for_display(const char *s, long max);
 
 #endif /* CHARSET_H */
index 35ed090..d758751 100644 (file)
@@ -226,6 +226,10 @@ static int set_stringlist_accum(const struct config_state *cs,
   struct stringlistlist *sll;
 
   sll = ADDRESS(cs->config, struct stringlistlist);
+  if(nvec == 0) {
+    sll->n = 0;
+    return 0;
+  }
   sll->n++;
   sll->s = xrealloc(sll->s, (sll->n * sizeof (struct stringlist)));
   s = &sll->s[sll->n - 1];
@@ -243,6 +247,10 @@ static int set_string_accum(const struct config_state *cs,
   struct stringlist *sl;
 
   sl = ADDRESS(cs->config, struct stringlist);
+  if(nvec == 0) {
+    sl->n = 0;
+    return 0;
+  }
   for(n = 0; n < nvec; ++n) {
     sl->n++;
     sl->s = xrealloc(sl->s, (sl->n * sizeof (char *)));
@@ -884,6 +892,7 @@ static const struct conf conf[] = {
   { C(checkpoint_min),   &type_integer,          validate_non_negative },
   { C(collection),       &type_collections,      validate_any },
   { C(connect),          &type_stringlist,       validate_addrport },
+  { C(dbversion),        &type_integer,          validate_positive },
   { C(device),           &type_string,           validate_any },
   { C(gap),              &type_integer,          validate_non_negative },
   { C(history),          &type_integer,          validate_positive },
@@ -1039,6 +1048,7 @@ static struct config *config_default(void) {
   c->short_display = 32;
   c->mixer = xstrdup("/dev/mixer");
   c->channel = xstrdup("pcm");
+  c->dbversion = 2;
   return c;
 }
 
index 4ef7862..a4ffa63 100644 (file)
@@ -246,6 +246,9 @@ struct config {
   /* derived values: */
   int nparts;                          /* number of distinct name parts */
   char **parts;                                /* name part list  */
+
+  /* undocumented, for testing only */
+  long dbversion;
 };
 
 extern struct config *config;
index 110e096..1bb19a5 100644 (file)
@@ -42,6 +42,9 @@ static void no_error_handler(const char attribute((unused)) *msg,
                             void attribute((unused)) *u) {
 }
 
+/* TODO: handle combining characters attached to delimiters in some
+ * sane way (might include reporting an error) */
+
 char **split(const char *p,
             int *np,
             unsigned flags,
@@ -110,6 +113,8 @@ char **split(const char *p,
   return v.vec;
 }
 
+/* TODO handle initial combining characters sanely */
+
 const char *quoteutf8(const char *s) {
   size_t len = 3 + strlen(s);
   const char *t;
index 2b40a44..f4043b9 100644 (file)
@@ -28,6 +28,8 @@
 #include <errno.h>
 #include <ctype.h>
 #include <assert.h>
+#include <sys/types.h>
+#include <sys/stat.h>
 
 #include "utf8.h"
 #include "mem.h"
 #include "charset.h"
 #include "mime.h"
 #include "hex.h"
-#include "words.h"
 #include "heap.h"
+#include "unicode.h"
+#include "inputline.h"
+#include "wstat.h"
 
 static int tests, errors;
+static int fail_first;
+
+static void count_error() {
+  ++errors;
+  if(fail_first)
+    abort();
+}
 
 /** @brief Checks that @p expr is nonzero */
 #define insist(expr) do {                              \
   if(!(expr)) {                                                \
-    ++errors;                                          \
+    count_error();                                             \
     fprintf(stderr, "%s:%d: error checking %s\n",      \
             __FILE__, __LINE__, #expr);                        \
   }                                                    \
@@ -69,6 +80,20 @@ static const char *format(const char *s) {
   return d.vec;
 }
 
+static const char *format_utf32(const uint32_t *s) {
+  struct dynstr d;
+  uint32_t c;
+  char buf[64];
+  
+  dynstr_init(&d);
+  while((c = *s++)) {
+    sprintf(buf, " %04lX", (long)c);
+    dynstr_append_string(&d, buf);
+  }
+  dynstr_terminate(&d);
+  return d.vec;
+}
+
 #define check_string(GOT, WANT) do {                           \
   const char *g = GOT;                                         \
   const char *w = WANT;                                                \
@@ -76,11 +101,11 @@ static const char *format(const char *s) {
   if(w == 0) {                                                 \
     fprintf(stderr, "%s:%d: %s returned 0\n",                  \
             __FILE__, __LINE__, #GOT);                         \
-    ++errors;                                                  \
+    count_error();                                                     \
   } else if(strcmp(w, g)) {                                    \
     fprintf(stderr, "%s:%d: %s returned:\n%s\nexpected:\n%s\n",        \
            __FILE__, __LINE__, #GOT, format(g), format(w));    \
-    ++errors;                                                  \
+    count_error();                                                     \
   }                                                            \
   ++tests;                                                     \
  } while(0)
@@ -109,15 +134,16 @@ static void test_utf8(void) {
   char *u8;                                    \
                                                \
   insist(validutf8(CHARS));                    \
-  ucs = utf82ucs4(CHARS);                      \
+  ucs = utf8_to_utf32(CHARS, strlen(CHARS), 0); \
   insist(ucs != 0);                            \
-  insist(!ucs4cmp(w, ucs));                    \
-  u8 = ucs42utf8(ucs);                         \
+  insist(!utf32_cmp(w, ucs));                  \
+  u8 = utf32_to_utf8(ucs, utf32_len(ucs), 0);   \
   insist(u8 != 0);                             \
   insist(!strcmp(u8, CHARS));                  \
 } while(0)
 
   fprintf(stderr, "test_utf8\n");
+#define validutf8(S) utf8_valid((S), strlen(S))
 
   /* empty string */
 
@@ -332,16 +358,18 @@ static void test_hex(void) {
 }
 
 static void test_casefold(void) {
-  uint32_t c, l, u[2];
-  const char *s, *ls;
+  uint32_t c, l;
+  const char *input, *canon_folded, *compat_folded, *canon_expected, *compat_expected;
 
   fprintf(stderr, "test_casefold\n");
 
+  /* This isn't a very exhaustive test.  Unlike for normalization, there don't
+   * seem to be any public test vectors for these algorithms. */
+  
   for(c = 1; c < 256; ++c) {
-    u[0] = c;
-    u[1] = 0;
-    s = ucs42utf8(u);
-    ls = casefold(s);
+    input = utf32_to_utf8(&c, 1, 0);
+    canon_folded = utf8_casefold_canon(input, strlen(input), 0);
+    compat_folded = utf8_casefold_compat(input, strlen(input), 0);
     switch(c) {
     default:
       if((c >= 'A' && c <= 'Z')
@@ -350,31 +378,102 @@ static void test_casefold(void) {
       else
        l = c;
       break;
-#if 0
-      /* unidata-based case folding doens't support special cases */
     case 0xB5:                         /* MICRO SIGN */
-      l = 0x39C;                       /* GREEK SMALL LETTER MU */
+      l = 0x3BC;                       /* GREEK SMALL LETTER MU */
       break;
     case 0xDF:                         /* LATIN SMALL LETTER SHARP S */
-      insist(!strcmp(ls, "ss"));
+      insist(!strcmp(canon_folded, "ss"));
+      insist(!strcmp(compat_folded, "ss"));
       l = 0;
       break;
-#endif
     }
     if(l) {
-      u[0] = l;
-      u[1] = 0;
-      s = ucs42utf8(u);
-      if(strcmp(s, ls)) {
-       fprintf(stderr, "%s:%d: casefolding %#lx got '%s', expected '%s'\n",
+      uint32_t *d;
+      /* Case-folded data is now normalized */
+      d = utf32_decompose_canon(&l, 1, 0);
+      canon_expected = utf32_to_utf8(d, utf32_len(d), 0);
+      if(strcmp(canon_folded, canon_expected)) {
+       fprintf(stderr, "%s:%d: canon-casefolding %#lx got '%s', expected '%s'\n",
                __FILE__, __LINE__, (unsigned long)c,
-               format(ls), format(s));
-       ++errors;
+               format(canon_folded), format(canon_expected));
+       count_error();
+      }
+      ++tests;
+      d = utf32_decompose_compat(&l, 1, 0);
+      compat_expected = utf32_to_utf8(d, utf32_len(d), 0);
+      if(strcmp(compat_folded, compat_expected)) {
+       fprintf(stderr, "%s:%d: compat-casefolding %#lx got '%s', expected '%s'\n",
+               __FILE__, __LINE__, (unsigned long)c,
+               format(compat_folded), format(compat_expected));
+       count_error();
       }
       ++tests;
     }
   }
-  check_string(casefold(""), "");
+  check_string(utf8_casefold_canon("", 0, 0), "");
+}
+
+struct {
+  const char *in;
+  const char *expect[10];
+} wtest[] = {
+  /* Empty string */
+  { "", { 0 } },
+  /* Only whitespace and punctuation */
+  { "    ", { 0 } },
+  { " '   ", { 0 } },
+  { " !  ", { 0 } },
+  { " \"\"  ", { 0 } },
+  { " @  ", { 0 } },
+  /* Basics */
+  { "wibble", { "wibble", 0 } },
+  { " wibble", { "wibble", 0 } },
+  { " wibble ", { "wibble", 0 } },
+  { "wibble ", { "wibble", 0 } },
+  { "wibble spong", { "wibble", "spong", 0 } },
+  { " wibble  spong", { "wibble", "spong", 0 } },
+  { " wibble  spong   ", { "wibble", "spong", 0 } },
+  { "wibble   spong  ", { "wibble", "spong", 0 } },
+  { "wibble   spong splat foo zot  ", { "wibble", "spong", "splat", "foo", "zot", 0 } },
+  /* Apostrophes */
+  { "wibble 'spong", { "wibble", "spong", 0 } },
+  { " wibble's", { "wibble's", 0 } },
+  { " wibblespong'   ", { "wibblespong", 0 } },
+  { "wibble   sp''ong  ", { "wibble", "sp", "ong", 0 } },
+};
+#define NWTEST (sizeof wtest / sizeof *wtest)
+
+static void test_words(void) {
+  size_t t, nexpect, ngot, i;
+  int right;
+  
+  fprintf(stderr, "test_words\n");
+  for(t = 0; t < NWTEST; ++t) {
+    char **got = utf8_word_split(wtest[t].in, strlen(wtest[t].in), &ngot, 0);
+
+    for(nexpect = 0; wtest[t].expect[nexpect]; ++nexpect)
+      ;
+    if(nexpect == ngot) {
+      for(i = 0; i < ngot; ++i)
+        if(strcmp(wtest[t].expect[i], got[i]))
+          break;
+      right = i == ngot;
+    } else
+      right = 0;
+    if(!right) {
+      fprintf(stderr, "word split %zu failed\n", t);
+      fprintf(stderr, "input: %s\n", wtest[t].in);
+      fprintf(stderr, "    | %-30s | %-30s\n",
+              "expected", "got");
+      for(i = 0; i < nexpect || i < ngot; ++i) {
+        const char *e = i < nexpect ? wtest[t].expect[i] : "<none>";
+        const char *g = i < ngot ? got[i] : "<none>";
+        fprintf(stderr, " %2zu | %-30s | %-30s\n", i, e, g);
+      }
+      count_error();
+    }
+    ++tests;
+  }
 }
 
 /** @brief Less-than comparison function for integer heap */
@@ -406,7 +505,176 @@ static void test_heap(void) {
   putchar('\n');
 }
 
+/** @brief Open a Unicode test file */
+static FILE *open_unicode_test(const char *path) {
+  const char *base;
+  FILE *fp;
+  char buffer[1024];
+  int w;
+
+  if((base = strrchr(path, '/')))
+    ++base;
+  else
+    base = path;
+  if(!(fp = fopen(base, "r"))) {
+    snprintf(buffer, sizeof buffer,
+             "wget http://www.unicode.org/Public/5.0.0/ucd/%s", path);
+    if((w = system(buffer)))
+      fatal(0, "%s: %s", buffer, wstat(w));
+    if(chmod(base, 0444) < 0)
+      fatal(errno, "chmod %s", base);
+    if(!(fp = fopen(base, "r")))
+      fatal(errno, "%s", base);
+  }
+  return fp;
+}
+
+/** @brief Run breaking tests for utf32_grapheme_boundary() etc */
+static void breaktest(const char *path,
+                      int (*breakfn)(const uint32_t *, size_t, size_t)) {
+  FILE *fp = open_unicode_test(path);
+  int lineno = 0;
+  char *l, *lp;
+  size_t bn, n;
+  char break_allowed[1024];
+  uint32_t buffer[1024];
+
+  while(!inputline(path, fp, &l, '\n')) {
+    ++lineno;
+    if(l[0] == '#') continue;
+    bn = 0;
+    lp = l;
+    while(*lp) {
+      if(*lp == ' ' || *lp == '\t') {
+        ++lp;
+        continue;
+      }
+      if(*lp == '#')
+        break;
+      if((unsigned char)*lp == 0xC3 && (unsigned char)lp[1] == 0xB7) {
+        /* 00F7 DIVISION SIGN */
+        break_allowed[bn] = 1;
+        lp += 2;
+        continue;
+      }
+      if((unsigned char)*lp == 0xC3 && (unsigned char)lp[1] == 0x97) {
+        /* 00D7 MULTIPLICATION SIGN */
+        break_allowed[bn] = 0;
+        lp += 2;
+        continue;
+      }
+      if(isxdigit((unsigned char)*lp)) {
+        buffer[bn++] = strtoul(lp, &lp, 16);
+        continue;
+      }
+      fatal(0, "%s:%d: evil line: %s", path, lineno, l);
+    }
+    for(n = 0; n <= bn; ++n) {
+      if(breakfn(buffer, bn, n) != break_allowed[n]) {
+        fprintf(stderr,
+                "%s:%d: offset %zu: mismatch\n"
+                "%s\n"
+                "\n",
+                path, lineno, n, l);
+        count_error();
+      }
+      ++tests;
+    }
+    xfree(l);
+  }
+  fclose(fp);
+}
+
+/** @brief Tests for @ref lib/unicode.h */
+static void test_unicode(void) {
+  FILE *fp;
+  int lineno = 0;
+  char *l, *lp;
+  uint32_t buffer[1024];
+  uint32_t *c[6], *NFD_c[6], *NFKD_c[6], *NFC_c[6], *NFKC_c[6]; /* 1-indexed */
+  int cn, bn;
+
+  fprintf(stderr, "test_unicode\n");
+  fp = open_unicode_test("NormalizationTest.txt");
+  while(!inputline("NormalizationTest.txt", fp, &l, '\n')) {
+    ++lineno;
+    if(*l == '#' || *l == '@')
+      continue;
+    bn = 0;
+    cn = 1;
+    lp = l;
+    c[cn++] = &buffer[bn];
+    while(*lp && *lp != '#') {
+      if(*lp == ' ') {
+       ++lp;
+       continue;
+      }
+      if(*lp == ';') {
+       buffer[bn++] = 0;
+       if(cn == 6)
+         break;
+       c[cn++] = &buffer[bn];
+       ++lp;
+       continue;
+      }
+      buffer[bn++] = strtoul(lp, &lp, 16);
+    }
+    buffer[bn] = 0;
+    assert(cn == 6);
+    for(cn = 1; cn <= 5; ++cn) {
+      NFD_c[cn] = utf32_decompose_canon(c[cn], utf32_len(c[cn]), 0);
+      NFKD_c[cn] = utf32_decompose_compat(c[cn], utf32_len(c[cn]), 0);
+      NFC_c[cn] = utf32_compose_canon(c[cn], utf32_len(c[cn]), 0);
+      NFKC_c[cn] = utf32_compose_compat(c[cn], utf32_len(c[cn]), 0);
+    }
+#define unt_check(T, A, B) do {                                        \
+    ++tests;                                                   \
+    if(utf32_cmp(c[A], T##_c[B])) {                            \
+      fprintf(stderr,                                           \
+              "NormalizationTest.txt:%d: c%d != "#T"(c%d)\n",   \
+              lineno, A, B);                                    \
+      fprintf(stderr, "      c%d:%s\n",                         \
+              A, format_utf32(c[A]));                          \
+      fprintf(stderr, "      c%d:%s\n",                         \
+              B, format_utf32(c[B]));                          \
+      fprintf(stderr, "%4s(c%d):%s\n",                         \
+              #T, B, format_utf32(T##_c[B]));                  \
+      count_error();                                           \
+    }                                                          \
+  } while(0)
+    unt_check(NFD, 3, 1);
+    unt_check(NFD, 3, 2);
+    unt_check(NFD, 3, 3);
+    unt_check(NFD, 5, 4);
+    unt_check(NFD, 5, 5);
+    unt_check(NFKD, 5, 1);
+    unt_check(NFKD, 5, 2);
+    unt_check(NFKD, 5, 3);
+    unt_check(NFKD, 5, 4);
+    unt_check(NFKD, 5, 5);
+    unt_check(NFC, 2, 1);
+    unt_check(NFC, 2, 2);
+    unt_check(NFC, 2, 3);
+    unt_check(NFC, 4, 4);
+    unt_check(NFC, 4, 5);
+    unt_check(NFKC, 4, 1);
+    unt_check(NFKC, 4, 2);
+    unt_check(NFKC, 4, 3);
+    unt_check(NFKC, 4, 4);
+    unt_check(NFKC, 4, 5);
+    for(cn = 1; cn <= 5; ++cn) {
+      xfree(NFD_c[cn]);
+      xfree(NFKD_c[cn]);
+    }
+    xfree(l);
+  }
+  fclose(fp);
+  breaktest("auxiliary/GraphemeBreakTest.txt", utf32_is_grapheme_boundary);
+  breaktest("auxiliary/WordBreakTest.txt", utf32_is_word_boundary);
+}
+
 int main(void) {
+  fail_first = !!getenv("FAIL_FIRST");
   insist('\n' == 0x0A);
   insist('\r' == 0x0D);
   insist(' ' == 0x20);
@@ -444,11 +712,14 @@ int main(void) {
   /* split.c */
   /* syscalls.c */
   /* table.c */
+  /* unicode.c */
+  test_unicode();
   /* utf8.c */
   test_utf8();
   /* vector.c */
   /* words.c */
   test_casefold();
+  test_words();
   /* XXX words() */
   /* wstat.c */
   fprintf(stderr,  "%d errors out of %d tests\n", errors, tests);
@@ -459,6 +730,7 @@ int main(void) {
 Local Variables:
 c-basic-offset:2
 comment-column:40
+fill-column:79
+indent-tabs-mode:nil
 End:
 */
-
index 53824d7..bb07e64 100644 (file)
@@ -31,7 +31,7 @@
 #include "regsub.h"
 #include "log.h"
 #include "filepart.h"
-#include "words.h"
+#include "unicode.h"
 
 const struct collection *find_track_collection(const char *track) {
   int n;
@@ -114,15 +114,20 @@ int compare_tracks(const char *sa, const char *sb,
                   const char *ta, const char *tb) {
   int c;
 
-  if((c = strcmp(casefold(sa), casefold(sb)))) return c;
+  if((c = strcmp(utf8_casefold_canon(sa, strlen(sa), 0),
+                utf8_casefold_canon(sb, strlen(sb), 0))))
+    return c;
   if((c = strcmp(sa, sb))) return c;
-  if((c = strcmp(casefold(da), casefold(db)))) return c;
+  if((c = strcmp(utf8_casefold_canon(da, strlen(da), 0),
+                utf8_casefold_canon(db, strlen(db), 0))))
+    return c;
   if((c = strcmp(da, db))) return c;
   return compare_path(ta, tb);
 }
 
 int compare_path_raw(const unsigned char *ap, size_t an,
                     const unsigned char *bp, size_t bn) {
+  /* Don't change this function!  The database sort order depends on it */
   while(an > 0 && bn > 0) {
     if(*ap == *bp) {
       ap++;
diff --git a/lib/unicode.c b/lib/unicode.c
new file mode 100644 (file)
index 0000000..5803926
--- /dev/null
@@ -0,0 +1,1569 @@
+/*
+ * This file is part of DisOrder
+ * Copyright (C) 2007 Richard Kettlewell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
+/** @file lib/unicode.c
+ * @brief Unicode support functions
+ *
+ * Here by UTF-8 and UTF-8 we mean the encoding forms of those names (not the
+ * encoding schemes).  The primary encoding form is UTF-32 but convenience
+ * wrappers using UTF-8 are provided for a number of functions.
+ *
+ * The idea is that all the strings that hit the database will be in a
+ * particular normalization form, and for the search and tags database
+ * in case-folded form, so they can be naively compared within the
+ * database code.
+ *
+ * As the code stands this guarantee is not well met!
+ *
+ * Subpages:
+ * - @ref utf32props
+ * - @ref utftransform
+ * - @ref utf32iterator
+ * - @ref utf32
+ * - @ref utf8
+ */
+
+#include <config.h>
+#include "types.h"
+
+#include <string.h>
+#include <stdio.h>             /* TODO */
+
+#include "mem.h"
+#include "vector.h"
+#include "unicode.h"
+#include "unidata.h"
+
+/** @defgroup utf32props Unicode Code Point Properties */
+/*@{*/
+
+static const struct unidata *utf32__unidata_hard(uint32_t c);
+
+/** @brief Find definition of code point @p c
+ * @param c Code point
+ * @return Pointer to @ref unidata structure for @p c
+ *
+ * @p c can be any 32-bit value, a sensible value will be returned regardless.
+ * The returned pointer is NOT guaranteed to be unique to @p c.
+ */
+static inline const struct unidata *utf32__unidata(uint32_t c) {
+  /* The bottom half of the table contains almost everything of interest
+   * and we can just return the right thing straight away */
+  if(c < UNICODE_BREAK_START)
+    return &unidata[c / UNICODE_MODULUS][c % UNICODE_MODULUS];
+  else
+    return utf32__unidata_hard(c);
+}
+
+/** @brief Find definition of code point @p c
+ * @param c Code point
+ * @return Pointer to @ref unidata structure for @p c
+ *
+ * @p c can be any 32-bit value, a sensible value will be returned regardless.
+ * The returned pointer is NOT guaranteed to be unique to @p c.
+ *
+ * Don't use this function (although it will work fine) - use utf32__unidata()
+ * instead.
+ */
+static const struct unidata *utf32__unidata_hard(uint32_t c) {
+  if(c < UNICODE_BREAK_START)
+    return &unidata[c / UNICODE_MODULUS][c % UNICODE_MODULUS];
+  /* Within the break everything is unassigned */
+  if(c < UNICODE_BREAK_END)
+    return utf32__unidata(0xFFFF);      /* guaranteed to be Cn */
+  /* Planes 15 and 16 are (mostly) private use */
+  if((c >= 0xF0000 && c <= 0xFFFFD)
+     || (c >= 0x100000 && c <= 0x10FFFD))
+    return utf32__unidata(0xE000);      /* first Co code point */
+  /* Everything else above the break top is unassigned */
+  if(c >= UNICODE_BREAK_TOP)
+    return utf32__unidata(0xFFFF);      /* guaranteed to be Cn */
+  /* Currently the rest is language tags and variation selectors */
+  c -= (UNICODE_BREAK_END - UNICODE_BREAK_START);
+  return &unidata[c / UNICODE_MODULUS][c % UNICODE_MODULUS];
+}
+
+/** @brief Return the combining class of @p c
+ * @param c Code point
+ * @return Combining class of @p c
+ *
+ * @p c can be any 32-bit value, a sensible value will be returned regardless.
+ */
+static inline int utf32__combining_class(uint32_t c) {
+  return utf32__unidata(c)->ccc;
+}
+
+/** @brief Return the combining class of @p c
+ * @param c Code point
+ * @return Combining class of @p c
+ *
+ * @p c can be any 32-bit value, a sensible value will be returned regardless.
+ */
+int utf32_combining_class(uint32_t c) {
+  return utf32__combining_class(c);
+}
+
+/** @brief Return the General_Category value for @p c
+ * @param c Code point
+ * @return General_Category property value
+ *
+ * @p c can be any 32-bit value, a sensible value will be returned regardless.
+ */
+static inline enum unicode_General_Category utf32__general_category(uint32_t c) {
+  return utf32__unidata(c)->general_category;
+}
+
+/** @brief Determine Grapheme_Break property
+ * @param c Code point
+ * @return Grapheme_Break property value of @p c
+ *
+ * @p c can be any 32-bit value, a sensible value will be returned regardless.
+ */
+static inline enum unicode_Grapheme_Break utf32__grapheme_break(uint32_t c) {
+  return utf32__unidata(c)->grapheme_break;
+}
+
+/** @brief Determine Word_Break property
+ * @param c Code point
+ * @return Word_Break property value of @p c
+ *
+ * @p c can be any 32-bit value, a sensible value will be returned regardless.
+ */
+static inline enum unicode_Word_Break utf32__word_break(uint32_t c) {
+  return utf32__unidata(c)->word_break;
+}
+
+/** @brief Determine Sentence_Break property
+ * @param c Code point
+ * @return Word_Break property value of @p c
+ *
+ * @p c can be any 32-bit value, a sensible value will be returned regardless.
+ */
+static inline enum unicode_Sentence_Break utf32__sentence_break(uint32_t c) {
+  return utf32__unidata(c)->sentence_break;
+}
+
+/** @brief Return true if @p c is ignorable for boundary specifications
+ * @param wb Word break property value
+ * @return non-0 if @p wb is unicode_Word_Break_Extend or unicode_Word_Break_Format
+ */
+static inline int utf32__boundary_ignorable(enum unicode_Word_Break wb) {
+  return (wb == unicode_Word_Break_Extend
+          || wb == unicode_Word_Break_Format);
+}
+
+/** @brief Return the canonical decomposition of @p c
+ * @param c Code point
+ * @return 0-terminated canonical decomposition, or 0
+ */
+static inline const uint32_t *utf32__decomposition_canon(uint32_t c) {
+  const struct unidata *const data = utf32__unidata(c);
+  const uint32_t *const decomp = data->decomp;
+
+  if(decomp && !(data->flags & unicode_compatibility_decomposition))
+    return decomp;
+  else
+    return 0;
+}
+
+/** @brief Return the compatibility decomposition of @p c
+ * @param c Code point
+ * @return 0-terminated decomposition, or 0
+ */
+static inline const uint32_t *utf32__decomposition_compat(uint32_t c) {
+  return utf32__unidata(c)->decomp;
+}
+
+/*@}*/
+/** @defgroup utftransform Functions that transform between different Unicode encoding forms */
+/*@{*/
+
+/** @brief Convert UTF-32 to UTF-8
+ * @param s Source string
+ * @param ns Length of source string in code points
+ * @param ndp Where to store length of destination string (or NULL)
+ * @return Newly allocated destination string or NULL on error
+ *
+ * If the UTF-32 is not valid then NULL is returned.  A UTF-32 code point is
+ * invalid if:
+ * - it codes for a UTF-16 surrogate
+ * - it codes for a value outside the unicode code space
+ *
+ * The return value is always 0-terminated.  The value returned via @p *ndp
+ * does not include the terminator.
+ */
+char *utf32_to_utf8(const uint32_t *s, size_t ns, size_t *ndp) {
+  struct dynstr d;
+  uint32_t c;
+
+  dynstr_init(&d);
+  while(ns > 0) {
+    c = *s++;
+    if(c < 0x80)
+      dynstr_append(&d, c);
+    else if(c < 0x0800) {
+      dynstr_append(&d, 0xC0 | (c >> 6));
+      dynstr_append(&d, 0x80 | (c & 0x3F));
+    } else if(c < 0x10000) {
+      if(c >= 0xD800 && c <= 0xDFFF)
+       goto error;
+      dynstr_append(&d, 0xE0 | (c >> 12));
+      dynstr_append(&d, 0x80 | ((c >> 6) & 0x3F));
+      dynstr_append(&d, 0x80 | (c & 0x3F));
+    } else if(c < 0x110000) {
+      dynstr_append(&d, 0xF0 | (c >> 18));
+      dynstr_append(&d, 0x80 | ((c >> 12) & 0x3F));
+      dynstr_append(&d, 0x80 | ((c >> 6) & 0x3F));
+      dynstr_append(&d, 0x80 | (c & 0x3F));
+    } else
+      goto error;
+    --ns;
+  }
+  dynstr_terminate(&d);
+  if(ndp)
+    *ndp = d.nvec;
+  return d.vec;
+error:
+  xfree(d.vec);
+  return 0;
+}
+
+/** @brief Convert UTF-8 to UTF-32
+ * @param s Source string
+ * @param ns Length of source string in code points
+ * @param ndp Where to store length of destination string (or NULL)
+ * @return Newly allocated destination string or NULL on error
+ *
+ * The return value is always 0-terminated.  The value returned via @p *ndp
+ * does not include the terminator.
+ *
+ * If the UTF-8 is not valid then NULL is returned.  A UTF-8 sequence
+ * for a code point is invalid if:
+ * - it is not the shortest possible sequence for the code point
+ * - it codes for a UTF-16 surrogate
+ * - it codes for a value outside the unicode code space
+ */
+uint32_t *utf8_to_utf32(const char *s, size_t ns, size_t *ndp) {
+  struct dynstr_ucs4 d;
+  uint32_t c32;
+  const uint8_t *ss = (const uint8_t *)s;
+  int n;
+
+  dynstr_ucs4_init(&d);
+  while(ns > 0) {
+    const struct unicode_utf8_row *const r = &unicode_utf8_valid[*ss];
+    if(r->count <= ns) {
+      switch(r->count) {
+      case 1:
+        c32 = *ss;
+        break;
+      case 2:
+        if(ss[1] < r->min2 || ss[1] > r->max2)
+          goto error;
+        c32 = *ss & 0x1F;
+        break;
+      case 3:
+        if(ss[1] < r->min2 || ss[1] > r->max2)
+          goto error;
+        c32 = *ss & 0x0F;
+        break;
+      case 4:
+        if(ss[1] < r->min2 || ss[1] > r->max2)
+          goto error;
+        c32 = *ss & 0x07;
+        break;
+      default:
+        goto error;
+      }
+    } else
+      goto error;
+    for(n = 1; n < r->count; ++n) {
+      if(ss[n] < 0x80 || ss[n] > 0xBF)
+        goto error;
+      c32 = (c32 << 6) | (ss[n] & 0x3F);
+    }
+    dynstr_ucs4_append(&d, c32);
+    ss += r->count;
+    ns -= r->count;
+  }
+  dynstr_ucs4_terminate(&d);
+  if(ndp)
+    *ndp = d.nvec;
+  return d.vec;
+error:
+  xfree(d.vec);
+  return 0;
+}
+
+/** @brief Test whether [s,s+ns) is valid UTF-8
+ * @param s Start of string
+ * @param ns Length of string
+ * @return non-0 if @p s is valid UTF-8, 0 if it is not valid
+ *
+ * This function is intended to be much faster than calling utf8_to_utf32() and
+ * throwing away the result.
+ */
+int utf8_valid(const char *s, size_t ns) {
+  const uint8_t *ss = (const uint8_t *)s;
+  while(ns > 0) {
+    const struct unicode_utf8_row *const r = &unicode_utf8_valid[*ss];
+    if(r->count <= ns) {
+      switch(r->count) {
+      case 1:
+        break;
+      case 2:
+        if(ss[1] < r->min2 || ss[1] > r->max2)
+          return 0;
+        break;
+      case 3:
+        if(ss[1] < r->min2 || ss[1] > r->max2)
+          return 0;
+        if(ss[2] < 0x80 || ss[2] > 0xBF)
+          return 0;
+        break;
+      case 4:
+        if(ss[1] < r->min2 || ss[1] > r->max2)
+          return 0;
+        if(ss[2] < 0x80 || ss[2] > 0xBF)
+          return 0;
+        if(ss[3] < 0x80 || ss[3] > 0xBF)
+          return 0;
+        break;
+      default:
+        return 0;
+      }
+    } else
+      return 0;
+    ss += r->count;
+    ns -= r->count;
+  }
+  return 1;
+}
+
+/*@}*/
+/** @defgroup utf32iterator UTF-32 string iterators */
+/*@{*/
+
+struct utf32_iterator_data {
+  /** @brief Start of string */
+  const uint32_t *s;
+
+  /** @brief Length of string */
+  size_t ns;
+
+  /** @brief Current position */
+  size_t n;
+
+  /** @brief Last two non-ignorable characters or (uint32_t)-1
+   *
+   * last[1] is the non-Extend/Format character just before position @p n;
+   * last[0] is the one just before that.
+   *
+   * Exception 1: if there is no such non-Extend/Format character then an
+   * Extend/Format character is accepted instead.
+   *
+   * Exception 2: if there is no such character even taking that into account
+   * the value is (uint32_t)-1.
+   */
+  uint32_t last[2];
+
+  /** @brief Tailoring for Word_Break */
+  unicode_property_tailor *word_break;
+};
+
+/** @brief Initialize an internal private iterator
+ * @param it Iterator
+ * @param s Start of string
+ * @param ns Length of string
+ * @param n Absolute position
+ */
+static void utf32__iterator_init(utf32_iterator it,
+                                 const uint32_t *s, size_t ns, size_t n) {
+  it->s = s;
+  it->ns = ns;
+  it->n = 0;
+  it->last[0] = it->last[1] = -1;
+  it->word_break = 0;
+  utf32_iterator_set(it, n);
+}
+
+/** @brief Create a new iterator pointing at the start of a string
+ * @param s Start of string
+ * @param ns Length of string
+ * @return New iterator
+ */
+utf32_iterator utf32_iterator_new(const uint32_t *s, size_t ns) {
+  utf32_iterator it = xmalloc(sizeof *it);
+  utf32__iterator_init(it, s, ns, 0);
+  return it;
+}
+
+/** @brief Tailor this iterator's interpretation of the Word_Break property.
+ * @param it Iterator
+ * @param pt Property tailor function or NULL
+ *
+ * After calling this the iterator will call @p pt to determine the Word_Break
+ * property of each code point.  If it returns -1 the default value will be
+ * used otherwise the returned value will be used.
+ *
+ * @p pt can be NULL to revert to the default value of the property.
+ *
+ * It is safe to call this function at any time; the iterator's internal state
+ * will be reset to suit the new tailoring.
+ */
+void utf32_iterator_tailor_word_break(utf32_iterator it,
+                                      unicode_property_tailor *pt) {
+  it->word_break = pt;
+  utf32_iterator_set(it, it->n);
+}
+
+static inline enum unicode_Word_Break utf32__iterator_word_break(utf32_iterator it,
+                                                                 uint32_t c) {
+  if(!it->word_break)
+    return utf32__word_break(c);
+  else {
+    const int t = it->word_break(c);
+
+    if(t < 0)
+      return utf32__word_break(c);
+    else
+      return t;
+  }
+}
+
+/** @brief Destroy an iterator
+ * @param it Iterator
+ */
+void utf32_iterator_destroy(utf32_iterator it) {
+  xfree(it);
+}
+
+/** @brief Find the current position of an interator
+ * @param it Iterator
+ */
+size_t utf32_iterator_where(utf32_iterator it) {
+  return it->n;
+}
+
+/** @brief Set an iterator's absolute position
+ * @param it Iterator
+ * @param n Absolute position
+ * @return 0 on success, non-0 on error
+ *
+ * It is an error to position the iterator outside the string (but acceptable
+ * to point it at the hypothetical post-final character).  If an invalid value
+ * of @p n is specified then the iterator is not changed.
+ *
+ * This function works by backing up and then advancing to reconstruct the
+ * iterator's internal state for position @p n.  The worst case will be O(n)
+ * time complexity (with a worse constant factor that utf32_iterator_advance())
+ * but the typical case is essentially constant-time.
+ */
+int utf32_iterator_set(utf32_iterator it, size_t n) {
+  /* We can't just jump to position @p n; the @p last[] values will be wrong.
+   * What we need is to jump a bit behind @p n and then advance forward,
+   * updating @p last[] along the way.  How far back?  We need to cross two
+   * non-ignorable code points as we advance forwards, so we'd better pass two
+   * such characters on the way back (if such are available).
+   */
+  size_t m;
+
+  if(n > it->ns)                        /* range check */
+    return -1;
+  /* Walk backwards skipping ignorable code points */
+  m = n;
+  while(m > 0
+        && (utf32__boundary_ignorable(utf32__iterator_word_break(it,
+                                                                 it->s[m-1]))))
+    --m;
+  /* Either m=0 or s[m-1] is not ignorable */
+  if(m > 0) {
+    --m;
+    /* s[m] is our first non-ignorable code; look for a second in the same
+       way **/
+    while(m > 0
+          && (utf32__boundary_ignorable(utf32__iterator_word_break(it,
+                                                                   it->s[m-1]))))
+      --m;
+    /* Either m=0 or s[m-1] is not ignorable */
+    if(m > 0)
+      --m;
+  }
+  it->last[0] = it->last[1] = -1;
+  it->n = m;
+  return utf32_iterator_advance(it, n - m);
+}
+
+/** @brief Advance an iterator
+ * @param it Iterator
+ * @param count Number of code points to advance by
+ * @return 0 on success, non-0 on error
+ *
+ * It is an error to advance an iterator beyond the hypothetical post-final
+ * character of the string.  If an invalid value of @p n is specified then the
+ * iterator is not changed.
+ *
+ * This function has O(n) time complexity: it works by advancing naively
+ * forwards through the string.
+ */
+int utf32_iterator_advance(utf32_iterator it, size_t count) {
+  if(count <= it->ns - it->n) {
+    while(count > 0) {
+      const uint32_t c = it->s[it->n];
+      const enum unicode_Word_Break wb = utf32__iterator_word_break(it, c);
+      if(it->last[1] == (uint32_t)-1
+         || !utf32__boundary_ignorable(wb)) {
+        it->last[0] = it->last[1];
+        it->last[1] = c;
+      }
+      ++it->n;
+      --count;
+    }
+    return 0;
+  } else
+    return -1;
+}
+
+/** @brief Find the current code point
+ * @param it Iterator
+ * @return Current code point or 0
+ *
+ * If the iterator points at the hypothetical post-final character of the
+ * string then 0 is returned.  NB that this doesn't mean that there aren't any
+ * 0 code points inside the string!
+ */
+uint32_t utf32_iterator_code(utf32_iterator it) {
+  if(it->n < it->ns)
+    return it->s[it->n];
+  else
+    return 0;
+}
+
+/** @brief Test for a grapheme boundary
+ * @param it Iterator
+ * @return Non-0 if pointing just after a grapheme boundary, otherwise 0
+ *
+ * This function identifies default grapheme cluster boundaries as described in
+ * UAX #29 s3.  It returns non-0 if @p it points at the code point just after a
+ * grapheme cluster boundary (including the hypothetical code point just after
+ * the end of the string).
+ */
+int utf32_iterator_grapheme_boundary(utf32_iterator it) {
+  uint32_t before, after;
+  enum unicode_Grapheme_Break gbbefore, gbafter;
+  /* GB1 and GB2 */
+  if(it->n == 0 || it->n == it->ns)
+    return 1;
+  /* Now we know that s[n-1] and s[n] are safe to inspect */
+  /* GB3 */
+  before = it->s[it->n-1];
+  after = it->s[it->n];
+  if(before == 0x000D && after == 0x000A)
+    return 0;
+  gbbefore = utf32__grapheme_break(before);
+  gbafter = utf32__grapheme_break(after);
+  /* GB4 */
+  if(gbbefore == unicode_Grapheme_Break_Control
+     || before == 0x000D
+     || before == 0x000A)
+    return 1;
+  /* GB5 */
+  if(gbafter == unicode_Grapheme_Break_Control
+     || after == 0x000D
+     || after == 0x000A)
+    return 1;
+  /* GB6 */
+  if(gbbefore == unicode_Grapheme_Break_L
+     && (gbafter == unicode_Grapheme_Break_L
+         || gbafter == unicode_Grapheme_Break_V
+         || gbafter == unicode_Grapheme_Break_LV
+         || gbafter == unicode_Grapheme_Break_LVT))
+    return 0;
+  /* GB7 */
+  if((gbbefore == unicode_Grapheme_Break_LV
+      || gbbefore == unicode_Grapheme_Break_V)
+     && (gbafter == unicode_Grapheme_Break_V
+         || gbafter == unicode_Grapheme_Break_T))
+    return 0;
+  /* GB8 */
+  if((gbbefore == unicode_Grapheme_Break_LVT
+      || gbbefore == unicode_Grapheme_Break_T)
+     && gbafter == unicode_Grapheme_Break_T)
+    return 0;
+  /* GB9 */
+  if(gbafter == unicode_Grapheme_Break_Extend)
+    return 0;
+  /* GB10 */
+  return 1;
+
+}
+
+/** @brief Test for a word boundary
+ * @param it Iterator
+ * @return Non-0 if pointing just after a word boundary, otherwise 0
+ *
+ * This function identifies default word boundaries as described in UAX #29 s4.
+ * It returns non-0 if @p it points at the code point just after a word
+ * boundary (including the hypothetical code point just after the end of the
+ * string) and 0 otherwise.
+ */
+int utf32_iterator_word_boundary(utf32_iterator it) {
+  enum unicode_Word_Break twobefore, before, after, twoafter;
+  size_t nn;
+
+  /* WB1 and WB2 */
+  if(it->n == 0 || it->n == it->ns)
+    return 1;
+  /* WB3 */
+  if(it->s[it->n-1] == 0x000D && it->s[it->n] == 0x000A)
+    return 0;
+  /* WB4 */
+  /* (!Sep) x (Extend|Format) as in UAX #29 s6.2 */
+  if(utf32__sentence_break(it->s[it->n-1]) != unicode_Sentence_Break_Sep
+     && utf32__boundary_ignorable(utf32__iterator_word_break(it, it->s[it->n])))
+    return 0;
+  /* Gather the property values we'll need for the rest of the test taking the
+   * s6.2 changes into account */
+  /* First we look at the code points after the proposed boundary */
+  nn = it->n;                           /* <it->ns */
+  after = utf32__iterator_word_break(it, it->s[nn++]);
+  if(!utf32__boundary_ignorable(after)) {
+    /* X (Extend|Format)* -> X */
+    while(nn < it->ns
+          && utf32__boundary_ignorable(utf32__iterator_word_break(it,
+                                                                  it->s[nn])))
+      ++nn;
+  }
+  /* It's possible now that nn=ns */
+  if(nn < it->ns)
+    twoafter = utf32__iterator_word_break(it, it->s[nn]);
+  else
+    twoafter = unicode_Word_Break_Other;
+
+  /* We've already recorded the non-ignorable code points before the proposed
+   * boundary */
+  before = utf32__iterator_word_break(it, it->last[1]);
+  twobefore = utf32__iterator_word_break(it, it->last[0]);
+
+  /* WB5 */
+  if(before == unicode_Word_Break_ALetter
+     && after == unicode_Word_Break_ALetter)
+    return 0;
+  /* WB6 */
+  if(before == unicode_Word_Break_ALetter
+     && after == unicode_Word_Break_MidLetter
+     && twoafter == unicode_Word_Break_ALetter)
+    return 0;
+  /* WB7 */
+  if(twobefore == unicode_Word_Break_ALetter
+     && before == unicode_Word_Break_MidLetter
+     && after == unicode_Word_Break_ALetter)
+    return 0;
+  /* WB8 */
+  if(before == unicode_Word_Break_Numeric
+     && after == unicode_Word_Break_Numeric)
+    return 0;
+  /* WB9 */
+  if(before == unicode_Word_Break_ALetter
+     && after == unicode_Word_Break_Numeric)
+    return 0;
+  /* WB10 */
+  if(before == unicode_Word_Break_Numeric
+     && after == unicode_Word_Break_ALetter)
+    return 0;
+   /* WB11 */
+  if(twobefore == unicode_Word_Break_Numeric
+     && before == unicode_Word_Break_MidNum
+     && after == unicode_Word_Break_Numeric)
+    return 0;
+  /* WB12 */
+  if(before == unicode_Word_Break_Numeric
+     && after == unicode_Word_Break_MidNum
+     && twoafter == unicode_Word_Break_Numeric)
+    return 0;
+  /* WB13 */
+  if(before == unicode_Word_Break_Katakana
+     && after == unicode_Word_Break_Katakana)
+    return 0;
+  /* WB13a */
+  if((before == unicode_Word_Break_ALetter
+      || before == unicode_Word_Break_Numeric
+      || before == unicode_Word_Break_Katakana
+      || before == unicode_Word_Break_ExtendNumLet)
+     && after == unicode_Word_Break_ExtendNumLet)
+    return 0;
+  /* WB13b */
+  if(before == unicode_Word_Break_ExtendNumLet
+     && (after == unicode_Word_Break_ALetter
+         || after == unicode_Word_Break_Numeric
+         || after == unicode_Word_Break_Katakana))
+    return 0;
+  /* WB14 */
+  return 1;
+}
+
+/*@}*/
+/** @defgroup utf32 Functions that operate on UTF-32 strings */
+/*@{*/
+
+/** @brief Return the length of a 0-terminated UTF-32 string
+ * @param s Pointer to 0-terminated string
+ * @return Length of string in code points (excluding terminator)
+ *
+ * Unlike the conversion functions no validity checking is done on the string.
+ */
+size_t utf32_len(const uint32_t *s) {
+  const uint32_t *t = s;
+
+  while(*t)
+    ++t;
+  return (size_t)(t - s);
+}
+
+/** @brief Stably sort [s,s+ns) into descending order of combining class
+ * @param s Start of array
+ * @param ns Number of elements, must be at least 1
+ * @param buffer Buffer of at least @p ns elements
+ */
+static void utf32__sort_ccc(uint32_t *s, size_t ns, uint32_t *buffer) {
+  uint32_t *a, *b, *bp;
+  size_t na, nb;
+
+  switch(ns) {
+  case 1:                      /* 1-element array is always sorted */
+    return;
+  case 2:                      /* 2-element arrays are trivial to sort */
+    if(utf32__combining_class(s[0]) > utf32__combining_class(s[1])) {
+      uint32_t tmp = s[0];
+      s[0] = s[1];
+      s[1] = tmp;
+    }
+    return;
+  default:
+    /* Partition the array */
+    na = ns / 2;
+    nb = ns - na;
+    a = s;
+    b = s + na;
+    /* Sort the two halves of the array */
+    utf32__sort_ccc(a, na, buffer);
+    utf32__sort_ccc(b, nb, buffer);
+    /* Merge them back into one, via the buffer */
+    bp = buffer;
+    while(na > 0 && nb > 0) {
+      /* We want ascending order of combining class (hence <)
+       * and we want stability within combining classes (hence <=)
+       */
+      if(utf32__combining_class(*a) <= utf32__combining_class(*b)) {
+       *bp++ = *a++;
+       --na;
+      } else {
+       *bp++ = *b++;
+       --nb;
+      }
+    }
+    while(na > 0) {
+      *bp++ = *a++;
+      --na;
+    }
+    while(nb > 0) {
+      *bp++ = *b++;
+      --nb;
+    }
+    memcpy(s, buffer,  ns * sizeof(uint32_t));
+    return;
+  }
+}
+
+/** @brief Put combining characters into canonical order
+ * @param s Pointer to UTF-32 string
+ * @param ns Length of @p s
+ * @return 0 on success, non-0 on error
+ *
+ * @p s is modified in-place.  See Unicode 5.0 s3.11 for details of the
+ * ordering.
+ *
+ * Currently we only support a maximum of 1024 combining characters after each
+ * base character.  If this limit is exceeded then a non-0 value is returned.
+ */
+static int utf32__canonical_ordering(uint32_t *s, size_t ns) {
+  size_t nc;
+  uint32_t buffer[1024];
+
+  /* The ordering amounts to a stable sort of each contiguous group of
+   * characters with non-0 combining class. */
+  while(ns > 0) {
+    /* Skip non-combining characters */
+    if(utf32__combining_class(*s) == 0) {
+      ++s;
+      --ns;
+      continue;
+    }
+    /* We must now have at least one combining character; see how many
+     * there are */
+    for(nc = 1; nc < ns && utf32__combining_class(s[nc]) != 0; ++nc)
+      ;
+    if(nc > 1024)
+      return -1;
+    /* Sort the array */
+    utf32__sort_ccc(s, nc, buffer);
+    s += nc;
+    ns -= nc;
+  }
+  return 0;
+}
+
+/* Magic numbers from UAX #15 s16 */
+#define SBase 0xAC00
+#define LBase 0x1100
+#define VBase 0x1161
+#define TBase 0x11A7
+#define LCount 19
+#define VCount 21
+#define TCount 28
+#define NCount (VCount * TCount)
+#define SCount (LCount * NCount)
+
+/** @brief Guts of the decomposition lookup functions */
+#define utf32__decompose_one_generic(WHICH) do {                        \
+  const uint32_t *dc = utf32__decomposition_##WHICH(c);                        \
+  if(dc) {                                                              \
+    /* Found a canonical decomposition in the table */                  \
+    while(*dc)                                                          \
+      utf32__decompose_one_##WHICH(d, *dc++);                           \
+  } else if(c >= SBase && c < SBase + SCount) {                         \
+    /* Mechanically decomposable Hangul syllable (UAX #15 s16) */       \
+    const uint32_t SIndex = c - SBase;                                  \
+    const uint32_t L = LBase + SIndex / NCount;                         \
+    const uint32_t V = VBase + (SIndex % NCount) / TCount;              \
+    const uint32_t T = TBase + SIndex % TCount;                         \
+    dynstr_ucs4_append(d, L);                                           \
+    dynstr_ucs4_append(d, V);                                           \
+    if(T != TBase)                                                      \
+      dynstr_ucs4_append(d, T);                                         \
+  } else                                                                \
+    /* Equal to own canonical decomposition */                          \
+    dynstr_ucs4_append(d, c);                                           \
+} while(0)
+
+/** @brief Recursively compute the canonical decomposition of @p c
+ * @param d Dynamic string to store decomposition in
+ * @param c Code point to decompose (must be a valid!)
+ * @return 0 on success, non-0 on error
+ */
+static void utf32__decompose_one_canon(struct dynstr_ucs4 *d, uint32_t c) {
+  utf32__decompose_one_generic(canon);
+}
+
+/** @brief Recursively compute the compatibility decomposition of @p c
+ * @param d Dynamic string to store decomposition in
+ * @param c Code point to decompose (must be a valid!)
+ * @return 0 on success, non-0 on error
+ */
+static void utf32__decompose_one_compat(struct dynstr_ucs4 *d, uint32_t c) {
+  utf32__decompose_one_generic(compat);
+}
+
+/** @brief Magic utf32__compositions() return value for Hangul Choseong */
+static const uint32_t utf32__hangul_L[1];
+
+/** @brief Return the list of compositions that @p c starts
+ * @param c Starter code point
+ * @return Composition list or NULL
+ *
+ * For Hangul leading (Choseong) jamo we return the special value
+ * utf32__hangul_L.  These code points are not listed as the targets of
+ * canonical decompositions (make-unidata checks) so there is no confusion with
+ * real decompositions here.
+ */
+static const uint32_t *utf32__compositions(uint32_t c) {
+  const uint32_t *compositions = utf32__unidata(c)->composed;
+
+  if(compositions)
+    return compositions;
+  /* Special-casing for Hangul */
+  switch(utf32__grapheme_break(c)) {
+  default:
+    return 0;
+  case unicode_Grapheme_Break_L:
+    return utf32__hangul_L;
+  }
+}
+
+/** @brief Composition step
+ * @param s Start of string
+ * @param ns Length of string
+ * @return New length of string
+ *
+ * This is called from utf32__decompose_generic() to compose the result string
+ * in place.
+ */
+static size_t utf32__compose(uint32_t *s, size_t ns) {
+  const uint32_t *compositions;
+  uint32_t *start = s, *t = s, *tt, cc;
+
+  while(ns > 0) {
+    uint32_t starter = *s++;
+    int block_starters = 0;
+    --ns;
+    /* We don't attempt to compose the following things:
+     * - final characters whatever kind they are
+     * - non-starter characters
+     * - starters that don't take part in a canonical decomposition mapping
+     */
+    if(ns == 0
+       || utf32__combining_class(starter)
+       || !(compositions = utf32__compositions(starter))) {
+      *t++ = starter;
+      continue;
+    }
+    if(compositions != utf32__hangul_L) {
+      /* Where we'll put the eventual starter */
+      tt = t++;
+      do {
+        /* See if we can find composition of starter+*s */
+        const uint32_t cchar = *s, *cp = compositions;
+        while((cc = *cp++)) {
+          const uint32_t *decomp = utf32__decomposition_canon(cc);
+          /* We know decomp[0] == starter */
+          if(decomp[1] == cchar)
+            break;
+        }
+        if(cc) {
+          /* Found a composition: cc decomposes to starter,*s */
+          starter = cc;
+          compositions = utf32__compositions(starter);
+          ++s;
+          --ns;
+        } else {
+          /* No composition found. */
+          const int class = utf32__combining_class(*s);
+          if(class) {
+            /* Transfer the uncomposable combining character to the output */
+            *t++ = *s++;
+            --ns;
+            /* All the combining characters of the same class of the
+             * uncomposable character are blocked by it, but there may be
+             * others of higher class later.  We eat the uncomposable and
+             * blocked characters and go back round the loop for that higher
+             * class. */
+            while(ns > 0 && utf32__combining_class(*s) == class) {
+              *t++ = *s++;
+              --ns;
+            }
+            /* Block any subsequent starters */
+            block_starters = 1;
+          } else {
+            /* The uncombinable character is itself a starter, so we don't
+             * transfer it to the output but instead go back round the main
+             * loop. */
+            break;
+          }
+        }
+        /* Keep going while there are still characters and the starter takes
+         * part in some composition */
+      } while(ns > 0 && compositions
+              && (!block_starters || utf32__combining_class(*s)));
+      /* Store any remaining combining characters */
+      while(ns > 0 && utf32__combining_class(*s)) {
+        *t++ = *s++;
+        --ns;
+      }
+      /* Store the resulting starter */
+      *tt = starter;
+    } else {
+      /* Special-casing for Hangul
+       *
+       * If there are combining characters between the L and the V then they
+       * will block the V and so no composition happens.  Similarly combining
+       * characters between V and T will block the T and so we only get as far
+       * as LV.
+       */
+      if(utf32__grapheme_break(*s) == unicode_Grapheme_Break_V) {
+        const uint32_t V = *s++;
+        const uint32_t LIndex = starter - LBase;
+        const uint32_t VIndex = V - VBase;
+        uint32_t TIndex;
+        --ns;
+        if(ns > 0
+           && utf32__grapheme_break(*s) == unicode_Grapheme_Break_T) {
+          /* We have an L V T sequence */
+          const uint32_t T = *s++;
+          TIndex = T - TBase;
+          --ns;
+        } else
+          /* It's just L V */
+          TIndex = 0;
+        /* Compose to LVT or LV as appropriate */
+        starter = (LIndex * VCount + VIndex) * TCount + TIndex + SBase;
+      } /* else we only have L or LV and no V or T */
+      *t++ = starter;
+      /* There could be some combining characters that belong to the V or T.
+       * These will be treated as non-starter characters at the top of the loop
+       * and thuss transferred to the output. */
+    }
+  }
+  return t - start;
+}
+
+/** @brief Guts of the composition and decomposition functions
+ * @param WHICH @c canon or @c compat to choose decomposition
+ * @param COMPOSE @c 0 or @c 1 to compose
+ */
+#define utf32__decompose_generic(WHICH, COMPOSE) do {   \
+  struct dynstr_ucs4 d;                                 \
+  uint32_t c;                                           \
+                                                        \
+  dynstr_ucs4_init(&d);                                 \
+  while(ns) {                                           \
+    c = *s++;                                           \
+    if((c >= 0xD800 && c <= 0xDFFF) || c > 0x10FFFF)    \
+      goto error;                                       \
+    utf32__decompose_one_##WHICH(&d, c);                \
+    --ns;                                               \
+  }                                                     \
+  if(utf32__canonical_ordering(d.vec, d.nvec))          \
+    goto error;                                         \
+  if(COMPOSE)                                           \
+    d.nvec = utf32__compose(d.vec, d.nvec);             \
+  dynstr_ucs4_terminate(&d);                            \
+  if(ndp)                                               \
+    *ndp = d.nvec;                                      \
+  return d.vec;                                         \
+error:                                                  \
+  xfree(d.vec);                                         \
+  return 0;                                             \
+} while(0)
+
+/** @brief Canonically decompose @p [s,s+ns)
+ * @param s Pointer to string
+ * @param ns Length of string
+ * @param ndp Where to store length of result
+ * @return Pointer to result string, or NULL on error
+ *
+ * Computes NFD (Normalization Form D) of the string at @p s.  This implies
+ * performing all canonical decompositions and then normalizing the order of
+ * combining characters.
+ *
+ * Returns NULL if the string is not valid for either of the following reasons:
+ * - it codes for a UTF-16 surrogate
+ * - it codes for a value outside the unicode code space
+ *
+ * See also:
+ * - utf32_decompose_compat()
+ * - utf32_compose_canon()
+ */
+uint32_t *utf32_decompose_canon(const uint32_t *s, size_t ns, size_t *ndp) {
+  utf32__decompose_generic(canon, 0);
+}
+
+/** @brief Compatibility decompose @p [s,s+ns)
+ * @param s Pointer to string
+ * @param ns Length of string
+ * @param ndp Where to store length of result
+ * @return Pointer to result string, or NULL on error
+ *
+ * Computes NFKD (Normalization Form KD) of the string at @p s.  This implies
+ * performing all canonical and compatibility decompositions and then
+ * normalizing the order of combining characters.
+ *
+ * Returns NULL if the string is not valid for either of the following reasons:
+ * - it codes for a UTF-16 surrogate
+ * - it codes for a value outside the unicode code space
+ *
+ * See also:
+ * - utf32_decompose_canon()
+ * - utf32_compose_compat()
+ */
+uint32_t *utf32_decompose_compat(const uint32_t *s, size_t ns, size_t *ndp) {
+  utf32__decompose_generic(compat, 0);
+}
+
+/** @brief Canonically compose @p [s,s+ns)
+ * @param s Pointer to string
+ * @param ns Length of string
+ * @param ndp Where to store length of result
+ * @return Pointer to result string, or NULL on error
+ *
+ * Computes NFC (Normalization Form C) of the string at @p s.  This implies
+ * performing all canonical decompositions, normalizing the order of combining
+ * characters and then composing all unblocked primary compositables.
+ *
+ * Returns NULL if the string is not valid for either of the following reasons:
+ * - it codes for a UTF-16 surrogate
+ * - it codes for a value outside the unicode code space
+ *
+ * See also:
+ * - utf32_compose_compat()
+ * - utf32_decompose_canon()
+ */
+uint32_t *utf32_compose_canon(const uint32_t *s, size_t ns, size_t *ndp) {
+  utf32__decompose_generic(canon, 1);
+}
+
+/** @brief Compatibility compose @p [s,s+ns)
+ * @param s Pointer to string
+ * @param ns Length of string
+ * @param ndp Where to store length of result
+ * @return Pointer to result string, or NULL on error
+ *
+ * Computes NFKC (Normalization Form KC) of the string at @p s.  This implies
+ * performing all canonical and compatibility decompositions, normalizing the
+ * order of combining characters and then composing all unblocked primary
+ * compositables.
+ *
+ * Returns NULL if the string is not valid for either of the following reasons:
+ * - it codes for a UTF-16 surrogate
+ * - it codes for a value outside the unicode code space
+ *
+ * See also:
+ * - utf32_compose_canon()
+ * - utf32_decompose_compat()
+ */
+uint32_t *utf32_compose_compat(const uint32_t *s, size_t ns, size_t *ndp) {
+  utf32__decompose_generic(compat, 1);
+}
+
+/** @brief Single-character case-fold and decompose operation */
+#define utf32__casefold_one(WHICH) do {                                 \
+  const uint32_t *cf = utf32__unidata(c)->casefold;                     \
+  if(cf) {                                                              \
+    /* Found a case-fold mapping in the table */                        \
+    while(*cf)                                                          \
+      utf32__decompose_one_##WHICH(&d, *cf++);                          \
+  } else                                                                \
+    utf32__decompose_one_##WHICH(&d, c);                                \
+} while(0)
+
+/** @brief Case-fold @p [s,s+ns)
+ * @param s Pointer to string
+ * @param ns Length of string
+ * @param ndp Where to store length of result
+ * @return Pointer to result string, or NULL on error
+ *
+ * Case-fold the string at @p s according to full default case-folding rules
+ * (s3.13) for caseless matching.  The result will be in NFD.
+ *
+ * Returns NULL if the string is not valid for either of the following reasons:
+ * - it codes for a UTF-16 surrogate
+ * - it codes for a value outside the unicode code space
+ */
+uint32_t *utf32_casefold_canon(const uint32_t *s, size_t ns, size_t *ndp) {
+  struct dynstr_ucs4 d;
+  uint32_t c;
+  size_t n;
+  uint32_t *ss = 0;
+
+  /* If the canonical decomposition of the string includes any combining
+   * character that case-folds to a non-combining character then we must
+   * normalize before we fold.  In Unicode 5.0.0 this means 0345 COMBINING
+   * GREEK YPOGEGRAMMENI in its decomposition and the various characters that
+   * canonically decompose to it. */
+  for(n = 0; n < ns; ++n)
+    if(utf32__unidata(s[n])->flags & unicode_normalize_before_casefold)
+      break;
+  if(n < ns) {
+    /* We need a preliminary decomposition */
+    if(!(ss = utf32_decompose_canon(s, ns, &ns)))
+      return 0;
+    s = ss;
+  }
+  dynstr_ucs4_init(&d);
+  while(ns) {
+    c = *s++;
+    if((c >= 0xD800 && c <= 0xDFFF) || c > 0x10FFFF)
+      goto error;
+    utf32__casefold_one(canon);
+    --ns;
+  }
+  if(utf32__canonical_ordering(d.vec, d.nvec))
+    goto error;
+  dynstr_ucs4_terminate(&d);
+  if(ndp)
+    *ndp = d.nvec;
+  return d.vec;
+error:
+  xfree(d.vec);
+  xfree(ss);
+  return 0;
+}
+
+/** @brief Compatibility case-fold @p [s,s+ns)
+ * @param s Pointer to string
+ * @param ns Length of string
+ * @param ndp Where to store length of result
+ * @return Pointer to result string, or NULL on error
+ *
+ * Case-fold the string at @p s according to full default case-folding rules
+ * (s3.13) for compatibility caseless matching.  The result will be in NFKD.
+ *
+ * Returns NULL if the string is not valid for either of the following reasons:
+ * - it codes for a UTF-16 surrogate
+ * - it codes for a value outside the unicode code space
+ */
+uint32_t *utf32_casefold_compat(const uint32_t *s, size_t ns, size_t *ndp) {
+  struct dynstr_ucs4 d;
+  uint32_t c;
+  size_t n;
+  uint32_t *ss = 0;
+
+  for(n = 0; n < ns; ++n)
+    if(utf32__unidata(s[n])->flags & unicode_normalize_before_casefold)
+      break;
+  if(n < ns) {
+    /* We need a preliminary _canonical_ decomposition */
+    if(!(ss = utf32_decompose_canon(s, ns, &ns)))
+      return 0;
+    s = ss;
+  }
+  /* This computes NFKD(toCaseFold(s)) */
+#define compat_casefold_middle() do {                   \
+  dynstr_ucs4_init(&d);                                 \
+  while(ns) {                                           \
+    c = *s++;                                           \
+    if((c >= 0xD800 && c <= 0xDFFF) || c > 0x10FFFF)    \
+      goto error;                                       \
+    utf32__casefold_one(compat);                        \
+    --ns;                                               \
+  }                                                     \
+  if(utf32__canonical_ordering(d.vec, d.nvec))          \
+    goto error;                                         \
+} while(0)
+  /* Do the inner (NFKD o toCaseFold) */
+  compat_casefold_middle();
+  /* We can do away with the NFD'd copy of the input now */
+  xfree(ss);
+  s = ss = d.vec;
+  ns = d.nvec;
+  /* Do the outer (NFKD o toCaseFold) */
+  compat_casefold_middle();
+  /* That's all */
+  dynstr_ucs4_terminate(&d);
+  if(ndp)
+    *ndp = d.nvec;
+  return d.vec;
+error:
+  xfree(d.vec);
+  xfree(ss);
+  return 0;
+}
+
+/** @brief Order a pair of UTF-32 strings
+ * @param a First 0-terminated string
+ * @param b Second 0-terminated string
+ * @return -1, 0 or 1 for a less than, equal to or greater than b
+ *
+ * "Comparable to strcmp() at its best."
+ */
+int utf32_cmp(const uint32_t *a, const uint32_t *b) {
+  while(*a && *b && *a == *b) {
+    ++a;
+    ++b;
+  }
+  return *a < *b ? -1 : (*a > *b ? 1 : 0);
+}
+
+/** @brief Identify a grapheme cluster boundary
+ * @param s Start of string (must be NFD)
+ * @param ns Length of string
+ * @param n Index within string (in [0,ns].)
+ * @return 1 at a grapheme cluster boundary, 0 otherwise
+ *
+ * This function identifies default grapheme cluster boundaries as described in
+ * UAX #29 s3.  It returns non-0 if @p n points at the code point just after a
+ * grapheme cluster boundary (including the hypothetical code point just after
+ * the end of the string).
+ *
+ * This function uses utf32_iterator_set() internally; see that function for
+ * remarks on performance.
+ */
+int utf32_is_grapheme_boundary(const uint32_t *s, size_t ns, size_t n) {
+  struct utf32_iterator_data it[1];
+
+  utf32__iterator_init(it, s, ns, n);
+  return utf32_iterator_grapheme_boundary(it);
+}
+
+/** @brief Identify a word boundary
+ * @param s Start of string (must be NFD)
+ * @param ns Length of string
+ * @param n Index within string (in [0,ns].)
+ * @return 1 at a word boundary, 0 otherwise
+ *
+ * This function identifies default word boundaries as described in UAX #29 s4.
+ * It returns non-0 if @p n points at the code point just after a word boundary
+ * (including the hypothetical code point just after the end of the string).
+ *
+ * This function uses utf32_iterator_set() internally; see that function for
+ * remarks on performance.
+ */
+int utf32_is_word_boundary(const uint32_t *s, size_t ns, size_t n) {
+  struct utf32_iterator_data it[1];
+
+  utf32__iterator_init(it, s, ns, n);
+  return utf32_iterator_word_boundary(it);
+}
+
+/** @brief Split [s,ns) into multiple words
+ * @param s Pointer to start of string
+ * @param ns Length of string
+ * @param nwp Where to store word count, or NULL
+ * @param wbreak Word_Break property tailor, or NULL
+ * @return Pointer to array of pointers to words
+ *
+ * The returned array is terminated by a NULL pointer and individual
+ * strings are 0-terminated.
+ */
+uint32_t **utf32_word_split(const uint32_t *s, size_t ns, size_t *nwp,
+                            unicode_property_tailor *wbreak) {
+  struct utf32_iterator_data it[1];
+  size_t b1 = 0, b2 = 0 ,i;
+  int isword;
+  struct vector32 v32[1];
+  uint32_t *w;
+
+  vector32_init(v32);
+  utf32__iterator_init(it, s, ns, 0);
+  it->word_break = wbreak;
+  /* Work our way through the string stopping at each word break. */
+  do {
+    if(utf32_iterator_word_boundary(it)) {
+      /* We've found a new boundary */
+      b1 = b2;
+      b2 = it->n;
+      /*fprintf(stderr, "[%zu, %zu) is a candidate word\n", b1, b2);*/
+      /* Inspect the characters between the boundary and form an opinion as to
+       * whether they are a word or not */
+      isword = 0;
+      for(i = b1; i < b2; ++i) {
+        switch(utf32__iterator_word_break(it, it->s[i])) {
+        case unicode_Word_Break_ALetter:
+        case unicode_Word_Break_Numeric:
+        case unicode_Word_Break_Katakana:
+          isword = 1;
+          break;
+        default:
+          break;
+        }
+      }
+      /* If it's a word add it to the list of results */
+      if(isword) {
+        w = xcalloc(b2 - b1 + 1, sizeof(uint32_t));
+        memcpy(w, it->s + b1, (b2 - b1) * sizeof (uint32_t));
+        vector32_append(v32, w);
+      }
+    }
+  } while(!utf32_iterator_advance(it, 1));
+  vector32_terminate(v32);
+  if(nwp)
+    *nwp = v32->nvec;
+  return v32->vec;
+}
+
+/*@}*/
+/** @defgroup utf8 Functions that operate on UTF-8 strings */
+/*@{*/
+
+/** @brief Wrapper to transform a UTF-8 string using the UTF-32 function */
+#define utf8__transform(FN) do {                                \
+  uint32_t *to32 = 0, *decomp32 = 0;                            \
+  size_t nto32, ndecomp32;                                      \
+  char *decomp8 = 0;                                            \
+                                                                \
+  if(!(to32 = utf8_to_utf32(s, ns, &nto32))) goto error;        \
+  if(!(decomp32 = FN(to32, nto32, &ndecomp32))) goto error;     \
+  decomp8 = utf32_to_utf8(decomp32, ndecomp32, ndp);            \
+error:                                                          \
+  xfree(to32);                                                  \
+  xfree(decomp32);                                              \
+  return decomp8;                                               \
+} while(0)
+
+/** @brief Canonically decompose @p [s,s+ns)
+ * @param s Pointer to string
+ * @param ns Length of string
+ * @param ndp Where to store length of result
+ * @return Pointer to result string, or NULL on error
+ *
+ * Computes NFD (Normalization Form D) of the string at @p s.  This implies
+ * performing all canonical decompositions and then normalizing the order of
+ * combining characters.
+ *
+ * Returns NULL if the string is not valid; see utf8_to_utf32() for reasons why
+ * this might be.
+ *
+ * See also:
+ * - utf32_decompose_canon().
+ * - utf8_decompose_compat()
+ * - utf8_compose_canon()
+ */
+char *utf8_decompose_canon(const char *s, size_t ns, size_t *ndp) {
+  utf8__transform(utf32_decompose_canon);
+}
+
+/** @brief Compatibility decompose @p [s,s+ns)
+ * @param s Pointer to string
+ * @param ns Length of string
+ * @param ndp Where to store length of result
+ * @return Pointer to result string, or NULL on error
+ *
+ * Computes NFKD (Normalization Form KD) of the string at @p s.  This implies
+ * performing all canonical and compatibility decompositions and then
+ * normalizing the order of combining characters.
+ *
+ * Returns NULL if the string is not valid; see utf8_to_utf32() for reasons why
+ * this might be.
+ *
+ * See also:
+ * - utf32_decompose_compat().
+ * - utf8_decompose_canon()
+ * - utf8_compose_compat()
+ */
+char *utf8_decompose_compat(const char *s, size_t ns, size_t *ndp) {
+  utf8__transform(utf32_decompose_compat);
+}
+
+/** @brief Canonically compose @p [s,s+ns)
+ * @param s Pointer to string
+ * @param ns Length of string
+ * @param ndp Where to store length of result
+ * @return Pointer to result string, or NULL on error
+ *
+ * Computes NFC (Normalization Form C) of the string at @p s.  This implies
+ * performing all canonical decompositions, normalizing the order of combining
+ * characters and then composing all unblocked primary compositables.
+ *
+ * Returns NULL if the string is not valid; see utf8_to_utf32() for reasons why
+ * this might be.
+ *
+ * See also:
+ * - utf32_compose_canon()
+ * - utf8_compose_compat()
+ * - utf8_decompose_canon()
+ */
+char *utf8_compose_canon(const char *s, size_t ns, size_t *ndp) {
+  utf8__transform(utf32_compose_canon);
+}
+
+/** @brief Compatibility compose @p [s,s+ns)
+ * @param s Pointer to string
+ * @param ns Length of string
+ * @param ndp Where to store length of result
+ * @return Pointer to result string, or NULL on error
+ *
+ * Computes NFKC (Normalization Form KC) of the string at @p s.  This implies
+ * performing all canonical and compatibility decompositions, normalizing the
+ * order of combining characters and then composing all unblocked primary
+ * compositables.
+ *
+ * Returns NULL if the string is not valid; see utf8_to_utf32() for reasons why
+ * this might be.
+ *
+ * See also:
+ * - utf32_compose_compat()
+ * - utf8_compose_canon()
+ * - utf8_decompose_compat()
+ */
+char *utf8_compose_compat(const char *s, size_t ns, size_t *ndp) {
+  utf8__transform(utf32_compose_compat);
+}
+
+/** @brief Case-fold @p [s,s+ns)
+ * @param s Pointer to string
+ * @param ns Length of string
+ * @param ndp Where to store length of result
+ * @return Pointer to result string, or NULL on error
+ *
+ * Case-fold the string at @p s according to full default case-folding rules
+ * (s3.13).  The result will be in NFD.
+ *
+ * Returns NULL if the string is not valid; see utf8_to_utf32() for reasons why
+ * this might be.
+ */
+char *utf8_casefold_canon(const char *s, size_t ns, size_t *ndp) {
+  utf8__transform(utf32_casefold_canon);
+}
+
+/** @brief Compatibility case-fold @p [s,s+ns)
+ * @param s Pointer to string
+ * @param ns Length of string
+ * @param ndp Where to store length of result
+ * @return Pointer to result string, or NULL on error
+ *
+ * Case-fold the string at @p s according to full default case-folding rules
+ * (s3.13).  The result will be in NFKD.
+ *
+ * Returns NULL if the string is not valid; see utf8_to_utf32() for reasons why
+ * this might be.
+ */
+char *utf8_casefold_compat(const char *s, size_t ns, size_t *ndp) {
+  utf8__transform(utf32_casefold_compat);
+}
+
+/** @brief Split [s,ns) into multiple words
+ * @param s Pointer to start of string
+ * @param ns Length of string
+ * @param nwp Where to store word count, or NULL
+ * @param wbreak Word_Break property tailor, or NULL
+ * @return Pointer to array of pointers to words
+ *
+ * The returned array is terminated by a NULL pointer and individual
+ * strings are 0-terminated.
+ */
+char **utf8_word_split(const char *s, size_t ns, size_t *nwp,
+                       unicode_property_tailor *wbreak) {
+  uint32_t *to32 = 0, **v32 = 0;
+  size_t nto32, nv, n;
+  char **v8 = 0, **ret = 0;
+
+  if(!(to32 = utf8_to_utf32(s, ns, &nto32))) goto error;
+  if(!(v32 = utf32_word_split(to32, nto32, &nv, wbreak))) goto error;
+  v8 = xcalloc(sizeof (char *), nv + 1);
+  for(n = 0; n < nv; ++n)
+    if(!(v8[n] = utf32_to_utf8(v32[n], utf32_len(v32[n]), 0)))
+      goto error;
+  ret = v8;
+  *nwp = nv;
+  v8 = 0;                               /* don't free */
+error:
+  if(v8) {
+    for(n = 0; n < nv; ++n)
+      xfree(v8[n]);
+    xfree(v8);
+  }
+  if(v32) {
+    for(n = 0; n < nv; ++n)
+      xfree(v32[n]);
+    xfree(v32);
+  }
+  xfree(to32);
+  return ret;
+}
+
+
+/*@}*/
+
+/*
+Local Variables:
+c-basic-offset:2
+comment-column:40
+fill-column:79
+indent-tabs-mode:nil
+End:
+*/
diff --git a/lib/unicode.h b/lib/unicode.h
new file mode 100644 (file)
index 0000000..982921b
--- /dev/null
@@ -0,0 +1,123 @@
+/*
+ * This file is part of DisOrde
+ * Copyright (C) 2007 Richard Kettlewell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
+/** @file lib/unicode.h
+ * @brief Unicode support functions
+ */
+
+#ifndef UNICODE_H
+#define UNICODE_H
+
+/** @brief Smart pointer into a string
+ *
+ * Iterators can be efficiently moved either forwards or back to the start of
+ * the string.  They cannot (currently) efficiently be moved backwards.  Their
+ * advantage is that they remember internal state to speed up boundary
+ * detection.
+ *
+ * Iterators can point to any code point of the string, or to a hypothetical
+ * post-final code point of value 0, but not outside the string.
+ */
+typedef struct utf32_iterator_data *utf32_iterator;
+
+/** @brief Property tailor function
+ * @param c Code point
+ * @return Tailored property or -1 to use standard value
+ *
+ * See also utf32_iterator_tailor_word_break().
+ */
+typedef int unicode_property_tailor(uint32_t c);
+
+char *utf32_to_utf8(const uint32_t *s, size_t ns, size_t *nd);
+uint32_t *utf8_to_utf32(const char *s, size_t ns, size_t *nd);
+int utf8_valid(const char *s, size_t ns);
+
+int utf32_combining_class(uint32_t c);
+
+size_t utf32_len(const uint32_t *s);
+int utf32_cmp(const uint32_t *a, const uint32_t *b);
+
+uint32_t *utf32_decompose_canon(const uint32_t *s, size_t ns, size_t *ndp);
+char *utf8_decompose_canon(const char *s, size_t ns, size_t *ndp);
+
+uint32_t *utf32_decompose_compat(const uint32_t *s, size_t ns, size_t *ndp);
+char *utf8_decompose_compat(const char *s, size_t ns, size_t *ndp);
+
+uint32_t *utf32_compose_canon(const uint32_t *s, size_t ns, size_t *ndp);
+char *utf8_compose_canon(const char *s, size_t ns, size_t *ndp);
+
+uint32_t *utf32_compose_compat(const uint32_t *s, size_t ns, size_t *ndp);
+char *utf8_compose_compat(const char *s, size_t ns, size_t *ndp);
+
+uint32_t *utf32_casefold_canon(const uint32_t *s, size_t ns, size_t *ndp);
+char *utf8_casefold_canon(const char *s, size_t ns, size_t *ndp);
+
+uint32_t *utf32_casefold_compat(const uint32_t *s, size_t ns, size_t *ndp);
+char *utf8_casefold_compat(const char *s, size_t ns, size_t *ndp);
+
+int utf32_is_grapheme_boundary(const uint32_t *s, size_t ns, size_t n);
+int utf32_is_word_boundary(const uint32_t *s, size_t ns, size_t n);
+
+utf32_iterator utf32_iterator_new(const uint32_t *s, size_t ns);
+void utf32_iterator_destroy(utf32_iterator it);
+
+size_t utf32_iterator_where(utf32_iterator it);
+int utf32_iterator_set(utf32_iterator it, size_t n);
+int utf32_iterator_advance(utf32_iterator it, size_t n);
+uint32_t utf32_iterator_code(utf32_iterator it);
+int utf32_iterator_grapheme_boundary(utf32_iterator it);
+int utf32_iterator_word_boundary(utf32_iterator it);
+void utf32_iterator_tailor_word_break(utf32_iterator it,
+                                      unicode_property_tailor *pt);
+
+uint32_t **utf32_word_split(const uint32_t *s, size_t ns, size_t *nwp,
+                            unicode_property_tailor *wbreak);
+char **utf8_word_split(const char *s, size_t ns, size_t *nwp,
+                            unicode_property_tailor *wbreak);
+
+/** @brief Convert 0-terminated UTF-32 to UTF-8
+ * @param s 0-terminated UTF-32 string
+ * @return 0-terminated UTF-8 string or 0 on error
+ *
+ * See utf32_to_utf8() for possible causes of errors.
+ */
+static inline char *utf32nt_to_utf8(const uint32_t *s) {
+  return utf32_to_utf8(s, utf32_len(s), 0);
+}
+
+/** @brief Convert 0-terminated UTF-8 to UTF-32
+ * @param s 0-terminated UTF-8 string
+ * @return 0-terminated UTF-32 string or 0 on error
+ *
+ * See utf8_to_utf32() for possible causes of errors.
+ */
+static inline uint32_t *utf8nt_to_utf32(const char *s) {
+  return utf8_to_utf32(s, strlen(s), 0);
+}
+
+#endif /* UNICODE_H */
+
+/*
+Local Variables:
+c-basic-offset:2
+comment-column:40
+fill-column:79
+indent-tabs-mode:nil
+End:
+*/
index ec4693d..d7bed16 100644 (file)
+/* Automatically generated file, see scripts/make-unidata */
+#include <config.h>
+#include "types.h"
 #include "unidata.h"
-static const struct unidata subtable0[] = {
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Zs, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Sc, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Ps, 0, 0, 0 },
-  { unicode_gc_Pe, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Sm, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Pd, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Sm, 0, 0, 0 },
-  { unicode_gc_Sm, 0, 0, 0 },
-  { unicode_gc_Sm, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Ps, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Pe, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Pc, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ps, 0, 0, 0 },
-  { unicode_gc_Sm, 0, 0, 0 },
-  { unicode_gc_Pe, 0, 0, 0 },
-  { unicode_gc_Sm, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Cc, 0, 0, 0 },
-  { unicode_gc_Zs, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Sc, 0, 0, 0 },
-  { unicode_gc_Sc, 0, 0, 0 },
-  { unicode_gc_Sc, 0, 0, 0 },
-  { unicode_gc_Sc, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Pi, 0, 0, 0 },
-  { unicode_gc_Sm, 0, 0, 0 },
-  { unicode_gc_Cf, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_Sm, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 743, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Pf, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Sm, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Sm, 0, 0, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, 121, 0 }
-};
-static const struct unidata subtable1[] = {
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, -199 },
-  { unicode_gc_Ll, 0, -232, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, -121 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Ll, 0, -300, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 210 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 206 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 205 },
-  { unicode_gc_Lu, 0, 0, 205 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 79 },
-  { unicode_gc_Lu, 0, 0, 202 },
-  { unicode_gc_Lu, 0, 0, 203 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 205 },
-  { unicode_gc_Lu, 0, 0, 207 },
-  { unicode_gc_Ll, 0, 97, 0 },
-  { unicode_gc_Lu, 0, 0, 211 },
-  { unicode_gc_Lu, 0, 0, 209 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 211 },
-  { unicode_gc_Lu, 0, 0, 213 },
-  { unicode_gc_Ll, 0, 130, 0 },
-  { unicode_gc_Lu, 0, 0, 214 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 218 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 218 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 218 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 217 },
-  { unicode_gc_Lu, 0, 0, 217 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 219 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 56, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 2 },
-  { unicode_gc_Lt, 0, -1, 1 },
-  { unicode_gc_Ll, 0, -2, 0 },
-  { unicode_gc_Lu, 0, 0, 2 },
-  { unicode_gc_Lt, 0, -1, 1 },
-  { unicode_gc_Ll, 0, -2, 0 },
-  { unicode_gc_Lu, 0, 0, 2 },
-  { unicode_gc_Lt, 0, -1, 1 },
-  { unicode_gc_Ll, 0, -2, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Ll, 0, -79, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 2 },
-  { unicode_gc_Lt, 0, -1, 1 },
-  { unicode_gc_Ll, 0, -2, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, -97 },
-  { unicode_gc_Lu, 0, 0, -56 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 }
-};
-static const struct unidata subtable2[] = {
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, -130 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, -210, 0 },
-  { unicode_gc_Ll, 0, -206, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, -205, 0 },
-  { unicode_gc_Ll, 0, -205, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, -202, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, -203, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, -205, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, -207, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, -209, 0 },
-  { unicode_gc_Ll, 0, -211, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, -211, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, -213, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, -214, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, -218, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, -218, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, -218, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, -217, 0 },
-  { unicode_gc_Ll, 0, -217, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, -219, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 }
-};
-static const struct unidata subtable3[] = {
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 232, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 232, 0, 0 },
-  { unicode_gc_Mn, 216, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 202, 0, 0 },
-  { unicode_gc_Mn, 202, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 202, 0, 0 },
-  { unicode_gc_Mn, 202, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 1, 0, 0 },
-  { unicode_gc_Mn, 1, 0, 0 },
-  { unicode_gc_Mn, 1, 0, 0 },
-  { unicode_gc_Mn, 1, 0, 0 },
-  { unicode_gc_Mn, 1, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 240, 84, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 234, 0, 0 },
-  { unicode_gc_Mn, 234, 0, 0 },
-  { unicode_gc_Mn, 233, 0, 0 },
-  { unicode_gc_Mn, 234, 0, 0 },
-  { unicode_gc_Mn, 234, 0, 0 },
-  { unicode_gc_Mn, 233, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 38 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 37 },
-  { unicode_gc_Lu, 0, 0, 37 },
-  { unicode_gc_Lu, 0, 0, 37 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 64 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 63 },
-  { unicode_gc_Lu, 0, 0, 63 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Ll, 0, -38, 0 },
-  { unicode_gc_Ll, 0, -37, 0 },
-  { unicode_gc_Ll, 0, -37, 0 },
-  { unicode_gc_Ll, 0, -37, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -31, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -64, 0 },
-  { unicode_gc_Ll, 0, -63, 0 },
-  { unicode_gc_Ll, 0, -63, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Ll, 0, -62, 0 },
-  { unicode_gc_Ll, 0, -57, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Ll, 0, -47, 0 },
-  { unicode_gc_Ll, 0, -54, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Ll, 0, -86, 0 },
-  { unicode_gc_Ll, 0, -80, 0 },
-  { unicode_gc_Ll, 0, 7, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, -60 },
-  { unicode_gc_Ll, 0, -96, 0 },
-  { unicode_gc_Sm, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, -7 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 }
-};
-static const struct unidata subtable4[] = {
-  { unicode_gc_Lu, 0, 0, 80 },
-  { unicode_gc_Lu, 0, 0, 80 },
-  { unicode_gc_Lu, 0, 0, 80 },
-  { unicode_gc_Lu, 0, 0, 80 },
-  { unicode_gc_Lu, 0, 0, 80 },
-  { unicode_gc_Lu, 0, 0, 80 },
-  { unicode_gc_Lu, 0, 0, 80 },
-  { unicode_gc_Lu, 0, 0, 80 },
-  { unicode_gc_Lu, 0, 0, 80 },
-  { unicode_gc_Lu, 0, 0, 80 },
-  { unicode_gc_Lu, 0, 0, 80 },
-  { unicode_gc_Lu, 0, 0, 80 },
-  { unicode_gc_Lu, 0, 0, 80 },
-  { unicode_gc_Lu, 0, 0, 80 },
-  { unicode_gc_Lu, 0, 0, 80 },
-  { unicode_gc_Lu, 0, 0, 80 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Lu, 0, 0, 32 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -32, 0 },
-  { unicode_gc_Ll, 0, -80, 0 },
-  { unicode_gc_Ll, 0, -80, 0 },
-  { unicode_gc_Ll, 0, -80, 0 },
-  { unicode_gc_Ll, 0, -80, 0 },
-  { unicode_gc_Ll, 0, -80, 0 },
-  { unicode_gc_Ll, 0, -80, 0 },
-  { unicode_gc_Ll, 0, -80, 0 },
-  { unicode_gc_Ll, 0, -80, 0 },
-  { unicode_gc_Ll, 0, -80, 0 },
-  { unicode_gc_Ll, 0, -80, 0 },
-  { unicode_gc_Ll, 0, -80, 0 },
-  { unicode_gc_Ll, 0, -80, 0 },
-  { unicode_gc_Ll, 0, -80, 0 },
-  { unicode_gc_Ll, 0, -80, 0 },
-  { unicode_gc_Ll, 0, -80, 0 },
-  { unicode_gc_Ll, 0, -80, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Me, 0, 0, 0 },
-  { unicode_gc_Me, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 }
-};
-static const struct unidata subtable5[] = {
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Lu, 0, 0, 48 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, -48, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Pd, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 222, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 222, 0, 0 },
-  { unicode_gc_Mn, 228, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 10, 0, 0 },
-  { unicode_gc_Mn, 11, 0, 0 },
-  { unicode_gc_Mn, 12, 0, 0 },
-  { unicode_gc_Mn, 13, 0, 0 },
-  { unicode_gc_Mn, 14, 0, 0 },
-  { unicode_gc_Mn, 15, 0, 0 },
-  { unicode_gc_Mn, 16, 0, 0 },
-  { unicode_gc_Mn, 17, 0, 0 },
-  { unicode_gc_Mn, 18, 0, 0 },
-  { unicode_gc_Mn, 19, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 20, 0, 0 },
-  { unicode_gc_Mn, 21, 0, 0 },
-  { unicode_gc_Mn, 22, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Mn, 23, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Mn, 24, 0, 0 },
-  { unicode_gc_Mn, 25, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 }
-};
-static const struct unidata subtable6[] = {
-  { unicode_gc_Cf, 0, 0, 0 },
-  { unicode_gc_Cf, 0, 0, 0 },
-  { unicode_gc_Cf, 0, 0, 0 },
-  { unicode_gc_Cf, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Mn, 27, 0, 0 },
-  { unicode_gc_Mn, 28, 0, 0 },
-  { unicode_gc_Mn, 29, 0, 0 },
-  { unicode_gc_Mn, 30, 0, 0 },
-  { unicode_gc_Mn, 31, 0, 0 },
-  { unicode_gc_Mn, 32, 0, 0 },
-  { unicode_gc_Mn, 33, 0, 0 },
-  { unicode_gc_Mn, 34, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Mn, 35, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Cf, 0, 0, 0 },
-  { unicode_gc_Me, 0, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 }
-};
-static const struct unidata subtable7[] = {
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cf, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Mn, 36, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 }
-};
-static const struct unidata subtable8[] = {
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 }
-};
-static const struct unidata subtable9[] = {
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 7, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mn, 9, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 7, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mn, 9, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Sc, 0, 0, 0 },
-  { unicode_gc_Sc, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 }
-};
-static const struct unidata subtable10[] = {
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 7, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 9, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 7, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mn, 9, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Sc, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 }
-};
-static const struct unidata subtable11[] = {
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 7, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mn, 9, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mn, 9, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_Sc, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 }
-};
-static const struct unidata subtable12[] = {
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 9, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 84, 0, 0 },
-  { unicode_gc_Mn, 91, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 7, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 9, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 }
-};
-static const struct unidata subtable13[] = {
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mn, 9, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 9, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 }
-};
-static const struct unidata subtable14[] = {
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 103, 0, 0 },
-  { unicode_gc_Mn, 103, 0, 0 },
-  { unicode_gc_Mn, 9, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Sc, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 107, 0, 0 },
-  { unicode_gc_Mn, 107, 0, 0 },
-  { unicode_gc_Mn, 107, 0, 0 },
-  { unicode_gc_Mn, 107, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 118, 0, 0 },
-  { unicode_gc_Mn, 118, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 122, 0, 0 },
-  { unicode_gc_Mn, 122, 0, 0 },
-  { unicode_gc_Mn, 122, 0, 0 },
-  { unicode_gc_Mn, 122, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 }
-};
-static const struct unidata subtable15[] = {
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_Mn, 216, 0, 0 },
-  { unicode_gc_Ps, 0, 0, 0 },
-  { unicode_gc_Pe, 0, 0, 0 },
-  { unicode_gc_Ps, 0, 0, 0 },
-  { unicode_gc_Pe, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 129, 0, 0 },
-  { unicode_gc_Mn, 130, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 132, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 130, 0, 0 },
-  { unicode_gc_Mn, 130, 0, 0 },
-  { unicode_gc_Mn, 130, 0, 0 },
-  { unicode_gc_Mn, 130, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mn, 130, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 9, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 }
-};
-static const struct unidata subtable16[] = {
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 7, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mn, 9, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 }
-};
-static const struct unidata subtable17[] = {
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 }
-};
-static const struct unidata subtable18[] = {
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 }
-};
-static const struct unidata subtable19[] = {
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 }
-};
-static const struct unidata subtable20[] = {
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 }
-};
-static const struct unidata subtable21[] = {
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 }
-};
-static const struct unidata subtable22[] = {
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Zs, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Ps, 0, 0, 0 },
-  { unicode_gc_Pe, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Nl, 0, 0, 0 },
-  { unicode_gc_Nl, 0, 0, 0 },
-  { unicode_gc_Nl, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 }
-};
-static const struct unidata subtable23[] = {
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 9, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 9, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cf, 0, 0, 0 },
-  { unicode_gc_Cf, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 9, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Sc, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_No, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 }
-};
-static const struct unidata subtable24[] = {
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Pd, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Zs, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Mn, 228, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 }
-};
-static const struct unidata subtable25[] = {
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mn, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mc, 0, 0, 0 },
-  { unicode_gc_Mn, 222, 0, 0 },
-  { unicode_gc_Mn, 230, 0, 0 },
-  { unicode_gc_Mn, 220, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Po, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Nd, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Lo, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 },
-  { unicode_gc_So, 0, 0, 0 }
-};
-static const struct unidata subtable26[] = {
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Lm, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 }
-};
-static const struct unidata subtable27[] = {
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, -59, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Lu, 0, 0, 1 },
-  { unicode_gc_Ll, 0, -1, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 }
-};
-static const struct unidata subtable28[] = {
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Ll, 0, 74, 0 },
-  { unicode_gc_Ll, 0, 74, 0 },
-  { unicode_gc_Ll, 0, 86, 0 },
-  { unicode_gc_Ll, 0, 86, 0 },
-  { unicode_gc_Ll, 0, 86, 0 },
-  { unicode_gc_Ll, 0, 86, 0 },
-  { unicode_gc_Ll, 0, 100, 0 },
-  { unicode_gc_Ll, 0, 100, 0 },
-  { unicode_gc_Ll, 0, 128, 0 },
-  { unicode_gc_Ll, 0, 128, 0 },
-  { unicode_gc_Ll, 0, 112, 0 },
-  { unicode_gc_Ll, 0, 112, 0 },
-  { unicode_gc_Ll, 0, 126, 0 },
-  { unicode_gc_Ll, 0, 126, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Lt, 0, 0, -8 },
-  { unicode_gc_Lt, 0, 0, -8 },
-  { unicode_gc_Lt, 0, 0, -8 },
-  { unicode_gc_Lt, 0, 0, -8 },
-  { unicode_gc_Lt, 0, 0, -8 },
-  { unicode_gc_Lt, 0, 0, -8 },
-  { unicode_gc_Lt, 0, 0, -8 },
-  { unicode_gc_Lt, 0, 0, -8 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Lt, 0, 0, -8 },
-  { unicode_gc_Lt, 0, 0, -8 },
-  { unicode_gc_Lt, 0, 0, -8 },
-  { unicode_gc_Lt, 0, 0, -8 },
-  { unicode_gc_Lt, 0, 0, -8 },
-  { unicode_gc_Lt, 0, 0, -8 },
-  { unicode_gc_Lt, 0, 0, -8 },
-  { unicode_gc_Lt, 0, 0, -8 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Lt, 0, 0, -8 },
-  { unicode_gc_Lt, 0, 0, -8 },
-  { unicode_gc_Lt, 0, 0, -8 },
-  { unicode_gc_Lt, 0, 0, -8 },
-  { unicode_gc_Lt, 0, 0, -8 },
-  { unicode_gc_Lt, 0, 0, -8 },
-  { unicode_gc_Lt, 0, 0, -8 },
-  { unicode_gc_Lt, 0, 0, -8 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 9, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -8 },
-  { unicode_gc_Lu, 0, 0, -74 },
-  { unicode_gc_Lu, 0, 0, -74 },
-  { unicode_gc_Lt, 0, 0, -9 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Ll, 0, -7205, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 9, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Lu, 0, 0, -86 },
-  { unicode_gc_Lu, 0, 0, -86 },
-  { unicode_gc_Lu, 0, 0, -86 },
-  { unicode_gc_Lu, 0, 0, -86 },
-  { unicode_gc_Lt, 0, 0, -9 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Sk, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 8, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Cn, 0, 0, 0 },
-  { unicode_gc_Ll, 0, 0, 0&nb