Use SASLprep to normalize passwords for SCRAM authentication.

An important step of SASLprep normalization, is to convert the string to
Unicode normalization form NFKC. Unicode normalization requires a fairly
large table of character decompositions, which is generated from data
published by the Unicode consortium. The script to generate the table is
put in src/common/unicode, as well test code for the normalization.
A pre-generated version of the tables is included in src/include/common,
so you don't need the code in src/common/unicode to build PostgreSQL, only
if you wish to modify the normalization tables.

The SASLprep implementation depends on the UTF-8 functions from
src/backend/utils/mb/wchar.c. So to use it, you must also compile and link
that. That doesn't change anything for the current users of these
functions, the backend and libpq, as they both already link with wchar.o.
It would be good to move those functions into a separate file in
src/commmon, but I'll leave that for another day.

No documentation changes included, because there is no details on the
SCRAM mechanism in the docs anyway. An overview on that in the protocol
specification would probably be good, even though SCRAM is documented in
detail in RFC5802. I'll write that as a separate patch. An important thing
to mention there is that we apply SASLprep even on invalid UTF-8 strings,
to support other encodings.

Patch by Michael Paquier and me.

Discussion: https://www.postgresql.org/message-id/CAB7nPqSByyEmAVLtEf1KxTRh=PWNKiWKEKQR=e1yGehz=wbymQ@mail.gmail.com

diff --git a/src/backend/libpq/auth-scram.c b/src/backend/libpq/auth-scram.c
index 14ddc8bd5425529a4585b457caf7628e0c05f54f..5077ff33b16acb0a65f2470f4d1854bd66c0b82c 100644 (file)
--- a/src/backend/libpq/auth-scram.c
+++ b/src/backend/libpq/auth-scram.c
@@ -11,13 +11,43 @@
  *
  * - Username from the authentication exchange is not used. The client
  *      should send an empty string as the username.
- * - Password is not processed with the SASLprep algorithm.
+ *
+ * - If the password isn't valid UTF-8, or contains characters prohibited
+ *      by the SASLprep profile, we skip the SASLprep pre-processing and use
+ *      the raw bytes in calculating the hash.
+ *
  * - Channel binding is not supported yet.
  *
+ *
  * The password stored in pg_authid consists of the salt, iteration count,
  * StoredKey and ServerKey.
  *
- * On error handling:
+ * SASLprep usage
+ * --------------
+ *
+ * One notable difference to the SCRAM specification is that while the
+ * specification dictates that the password is in UTF-8, and prohibits
+ * certain characters, we are more lenient.  If the password isn't a valid
+ * UTF-8 string, or contains prohibited characters, the raw bytes are used
+ * to calculate the hash instead, without SASLprep processing.  This is
+ * because PostgreSQL supports other encodings too, and the encoding being
+ * used during authentication is undefined (client_encoding isn't set until
+ * after authentication).  In effect, we try to interpret the password as
+ * UTF-8 and apply SASLprep processing, but if it looks invalid, we assume
+ * that it's in some other encoding.
+ *
+ * In the worst case, we misinterpret a password that's in a different
+ * encoding as being Unicode, because it happens to consists entirely of
+ * valid UTF-8 bytes, and we apply Unicode normalization to it.  As long
+ * as we do that consistently, that will not lead to failed logins.
+ * Fortunately, the UTF-8 byte sequences that are ignored by SASLprep
+ * don't correspond to any commonly used characters in any of the other
+ * supported encodings, so it should not lead to any significant loss in
+ * entropy, even if the normalization is incorrectly applied to a
+ * non-UTF-8 password.
+ *
+ * Error handling
+ * --------------
  *
  * Don't reveal user information to an unauthenticated client.  We don't
  * want an attacker to be able to probe whether a particular username is
@@ -37,6 +67,7 @@
  * to the encoding being used, whatever that is.  We cannot avoid that in
  * general, after logging in, but let's do what we can here.
  *
+ *
  * Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
@@ -52,6 +83,7 @@
 #include "catalog/pg_authid.h"
 #include "catalog/pg_control.h"
 #include "common/base64.h"
+#include "common/saslprep.h"
 #include "common/scram-common.h"
 #include "common/sha2.h"
 #include "libpq/auth.h"
@@ -344,6 +376,17 @@ scram_build_verifier(const char *username, const char *password,
        char            salt[SCRAM_SALT_LEN];
        char       *encoded_salt;
        int                     encoded_len;
+       char       *prep_password = NULL;
+       pg_saslprep_rc rc;
+
+       /*
+        * Normalize the password with SASLprep.  If that doesn't work, because
+        * the password isn't valid UTF-8 or contains prohibited characters, just
+        * proceed with the original password.  (See comments at top of file.)
+        */
+       rc = pg_saslprep(password, &prep_password);
+       if (rc == SASLPREP_SUCCESS)
+               password = (const char *) prep_password;
 
        if (iterations <= 0)
                iterations = SCRAM_ITERATIONS_DEFAULT;
@@ -373,6 +416,9 @@ scram_build_verifier(const char *username, const char *password,
        (void) hex_encode((const char *) keybuf, SCRAM_KEY_LEN, serverkey_hex);
        serverkey_hex[SCRAM_KEY_LEN * 2] = '\0';
 
+       if (prep_password)
+               pfree(prep_password);
+
        return psprintf("scram-sha-256:%s:%d:%s:%s", encoded_salt, iterations, storedkey_hex, serverkey_hex);
 }
 
@@ -392,13 +438,14 @@ scram_verify_plain_password(const char *username, const char *password,
        uint8           stored_key[SCRAM_KEY_LEN];
        uint8           server_key[SCRAM_KEY_LEN];
        uint8           computed_key[SCRAM_KEY_LEN];
+       char       *prep_password = NULL;
+       pg_saslprep_rc rc;
 
        if (!parse_scram_verifier(verifier, &encoded_salt, &iterations,
                                                          stored_key, server_key))
        {
                /*
-                * The password looked like a SCRAM verifier, but could not be
-                * parsed.
+                * The password looked like a SCRAM verifier, but could not be parsed.
                 */
                elog(LOG, "invalid SCRAM verifier for user \"%s\"", username);
                return false;
@@ -412,10 +459,18 @@ scram_verify_plain_password(const char *username, const char *password,
                return false;
        }
 
+       /* Normalize the password */
+       rc = pg_saslprep(password, &prep_password);
+       if (rc == SASLPREP_SUCCESS)
+               password = prep_password;
+
        /* Compute Server key based on the user-supplied plaintext password */
        scram_ClientOrServerKey(password, salt, saltlen, iterations,
                                                        SCRAM_SERVER_KEY_NAME, computed_key);
 
+       if (prep_password)
+               pfree(prep_password);
+
        /*
         * Compare the verifier's Server Key with the one computed from the
         * user-supplied password.

diff --git a/src/common/Makefile b/src/common/Makefile
index 971ddd5ea72da6788797a913d3a37bc744ea1a8b..80e78d72fe4799987ad0ef824eac101158dc0a0c 100644 (file)
--- a/src/common/Makefile
+++ b/src/common/Makefile
@@ -42,7 +42,8 @@ override CPPFLAGS += -DVAL_LIBS="\"$(LIBS)\""
 
 OBJS_COMMON = base64.o config_info.o controldata_utils.o exec.o ip.o \
        keywords.o md5.o pg_lzcompress.o pgfnames.o psprintf.o relpath.o \
-       rmtree.o scram-common.o string.o username.o wait_error.o
+       rmtree.o saslprep.o scram-common.o string.o unicode_norm.o \
+       username.o wait_error.o
 
 ifeq ($(with_openssl),yes)
 OBJS_COMMON += sha2_openssl.o

diff --git a/src/common/saslprep.c b/src/common/saslprep.c
new file mode 100644 (file)
index 0000000..7f5dc71
--- /dev/null
+++ b/src/common/saslprep.c
@@ -0,0 +1,1279 @@
+/*-------------------------------------------------------------------------
+ * saslprep.c
+ *             SASLprep normalization, for SCRAM authentication
+ *
+ * The SASLprep algorithm is used to process a user-supplied password into
+ * canonical form.  For more details, see:
+ *
+ * [RFC3454] Preparation of Internationalized Strings ("stringprep"),
+ *       http://www.ietf.org/rfc/rfc3454.txt
+ *
+ * [RFC4013] SASLprep: Stringprep Profile for User Names and Passwords
+ *       http://www.ietf.org/rfc/rfc4013.txt
+ *
+ *
+ * Portions Copyright (c) 2017, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *       src/common/saslprep.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef FRONTEND
+#include "postgres.h"
+#else
+#include "postgres_fe.h"
+#endif
+
+#include "common/saslprep.h"
+#include "common/unicode_norm.h"
+
+/*
+ * Note: The functions in this file depend on functions from
+ * src/backend/utils/mb/wchar.c, so in order to use this in frontend
+ * code, you will need to link that in, too.
+ */
+#include "mb/pg_wchar.h"
+
+/*
+ * Limit on how large password's we will try to process.  A password
+ * larger than this will be treated the same as out-of-memory.
+ */
+#define MAX_PASSWORD_LENGTH            1024
+
+/*
+ * In backend, we will use palloc/pfree.  In frontend, use malloc, and
+ * return SASLPREP_OOM on out-of-memory.
+ */
+#ifndef FRONTEND
+#define STRDUP(s) pstrdup(s)
+#define ALLOC(size) palloc(size)
+#define FREE(size) pfree(size)
+#else
+#define STRDUP(s) strdup(s)
+#define ALLOC(size) malloc(size)
+#define FREE(size) free(size)
+#endif
+
+/* Prototypes for local functions */
+static int     codepoint_range_cmp(const void *a, const void *b);
+static bool is_code_in_table(pg_wchar code, const pg_wchar *map, int mapsize);
+static int     pg_utf8_string_len(const char *source);
+static bool pg_is_ascii_string(const char *p);
+
+/*
+ * Stringprep Mapping Tables.
+ *
+ * The stringprep specification includes a number of tables of Unicode
+ * codepoints, used in different parts of the algorithm.  They are below,
+ * as arrays of codepoint ranges.  Each range is a pair of codepoints,
+ * for the first and last codepoint included the range (inclusive!).
+ */
+
+/*
+ * C.1.2 Non-ASCII space characters
+ *
+ * These are all mapped to the ASCII space character (U+00A0).
+ */
+static const pg_wchar non_ascii_space_ranges[] =
+{
+       0x00A0, 0x00A0,
+       0x1680, 0x1680,
+       0x2000, 0x200B,
+       0x202F, 0x202F,
+       0x205F, 0x205F,
+       0x3000, 0x3000
+};
+
+/*
+ * B.1 Commonly mapped to nothing
+ *
+ * If any of these appear in the input, they are removed.
+ */
+static const pg_wchar commonly_mapped_to_nothing_ranges[] =
+{
+       0x00AD, 0x00AD,
+       0x034F, 0x034F,
+       0x1806, 0x1806,
+       0x180B, 0x180D,
+       0x200B, 0x200D,
+       0x2060, 0x2060,
+       0xFE00, 0xFE0F,
+       0xFEFF, 0xFEFF
+};
+
+/*
+ * prohibited_output_ranges is a union of all the characters from
+ * the following tables:
+ *
+ * C.1.2 Non-ASCII space characters
+ * C.2.1 ASCII control characters
+ * C.2.2 Non-ASCII control characters
+ * C.3 Private Use characters
+ * C.4 Non-character code points
+ * C.5 Surrogate code points
+ * C.6 Inappropriate for plain text characters
+ * C.7 Inappropriate for canonical representation characters
+ * C.7 Change display properties or deprecated characters
+ * C.8 Tagging characters
+ *
+ * These are the tables that are listed as "prohibited output"
+ * characters in the SASLprep profile.
+ *
+ * The comment after each code range indicates which source table
+ * the code came from.  Note that there is some overlap in the source
+ * tables, so one code might originate from multiple source tables.
+ * Adjacent ranges have also been merged together, to save space.
+ */
+static const pg_wchar prohibited_output_ranges[] =
+{
+       0x0000, 0x001F,                         /* C.2.1 */
+       0x007F, 0x00A0,                         /* C.1.2, C.2.1, C.2.2 */
+       0x0340, 0x0341,                         /* C.8 */
+       0x06DD, 0x06DD,                         /* C.2.2 */
+       0x070F, 0x070F,                         /* C.2.2 */
+       0x1680, 0x1680,                         /* C.1.2 */
+       0x180E, 0x180E,                         /* C.2.2 */
+       0x2000, 0x200F,                         /* C.1.2, C.2.2, C.8 */
+       0x2028, 0x202F,                         /* C.1.2, C.2.2, C.8 */
+       0x205F, 0x2063,                         /* C.1.2, C.2.2 */
+       0x206A, 0x206F,                         /* C.2.2, C.8 */
+       0x2FF0, 0x2FFB,                         /* C.7 */
+       0x3000, 0x3000,                         /* C.1.2 */
+       0xD800, 0xF8FF,                         /* C.3, C.5 */
+       0xFDD0, 0xFDEF,                         /* C.4 */
+       0xFEFF, 0xFEFF,                         /* C.2.2 */
+       0xFFF9, 0xFFFF,                         /* C.2.2, C.4, C.6 */
+       0x1D173, 0x1D17A,                       /* C.2.2 */
+       0x1FFFE, 0x1FFFF,                       /* C.4 */
+       0x2FFFE, 0x2FFFF,                       /* C.4 */
+       0x3FFFE, 0x3FFFF,                       /* C.4 */
+       0x4FFFE, 0x4FFFF,                       /* C.4 */
+       0x5FFFE, 0x5FFFF,                       /* C.4 */
+       0x6FFFE, 0x6FFFF,                       /* C.4 */
+       0x7FFFE, 0x7FFFF,                       /* C.4 */
+       0x8FFFE, 0x8FFFF,                       /* C.4 */
+       0x9FFFE, 0x9FFFF,                       /* C.4 */
+       0xAFFFE, 0xAFFFF,                       /* C.4 */
+       0xBFFFE, 0xBFFFF,                       /* C.4 */
+       0xCFFFE, 0xCFFFF,                       /* C.4 */
+       0xDFFFE, 0xDFFFF,                       /* C.4 */
+       0xE0001, 0xE0001,                       /* C.9 */
+       0xE0020, 0xE007F,                       /* C.9 */
+       0xEFFFE, 0xEFFFF,                       /* C.4 */
+       0xF0000, 0xFFFFF,                       /* C.3, C.4 */
+       0x100000, 0x10FFFF                      /* C.3, C.4 */
+};
+
+/* A.1 Unassigned code points in Unicode 3.2 */
+static const pg_wchar unassigned_codepoint_ranges[] =
+{
+       0x0221, 0x0221,
+       0x0234, 0x024F,
+       0x02AE, 0x02AF,
+       0x02EF, 0x02FF,
+       0x0350, 0x035F,
+       0x0370, 0x0373,
+       0x0376, 0x0379,
+       0x037B, 0x037D,
+       0x037F, 0x0383,
+       0x038B, 0x038B,
+       0x038D, 0x038D,
+       0x03A2, 0x03A2,
+       0x03CF, 0x03CF,
+       0x03F7, 0x03FF,
+       0x0487, 0x0487,
+       0x04CF, 0x04CF,
+       0x04F6, 0x04F7,
+       0x04FA, 0x04FF,
+       0x0510, 0x0530,
+       0x0557, 0x0558,
+       0x0560, 0x0560,
+       0x0588, 0x0588,
+       0x058B, 0x0590,
+       0x05A2, 0x05A2,
+       0x05BA, 0x05BA,
+       0x05C5, 0x05CF,
+       0x05EB, 0x05EF,
+       0x05F5, 0x060B,
+       0x060D, 0x061A,
+       0x061C, 0x061E,
+       0x0620, 0x0620,
+       0x063B, 0x063F,
+       0x0656, 0x065F,
+       0x06EE, 0x06EF,
+       0x06FF, 0x06FF,
+       0x070E, 0x070E,
+       0x072D, 0x072F,
+       0x074B, 0x077F,
+       0x07B2, 0x0900,
+       0x0904, 0x0904,
+       0x093A, 0x093B,
+       0x094E, 0x094F,
+       0x0955, 0x0957,
+       0x0971, 0x0980,
+       0x0984, 0x0984,
+       0x098D, 0x098E,
+       0x0991, 0x0992,
+       0x09A9, 0x09A9,
+       0x09B1, 0x09B1,
+       0x09B3, 0x09B5,
+       0x09BA, 0x09BB,
+       0x09BD, 0x09BD,
+       0x09C5, 0x09C6,
+       0x09C9, 0x09CA,
+       0x09CE, 0x09D6,
+       0x09D8, 0x09DB,
+       0x09DE, 0x09DE,
+       0x09E4, 0x09E5,
+       0x09FB, 0x0A01,
+       0x0A03, 0x0A04,
+       0x0A0B, 0x0A0E,
+       0x0A11, 0x0A12,
+       0x0A29, 0x0A29,
+       0x0A31, 0x0A31,
+       0x0A34, 0x0A34,
+       0x0A37, 0x0A37,
+       0x0A3A, 0x0A3B,
+       0x0A3D, 0x0A3D,
+       0x0A43, 0x0A46,
+       0x0A49, 0x0A4A,
+       0x0A4E, 0x0A58,
+       0x0A5D, 0x0A5D,
+       0x0A5F, 0x0A65,
+       0x0A75, 0x0A80,
+       0x0A84, 0x0A84,
+       0x0A8C, 0x0A8C,
+       0x0A8E, 0x0A8E,
+       0x0A92, 0x0A92,
+       0x0AA9, 0x0AA9,
+       0x0AB1, 0x0AB1,
+       0x0AB4, 0x0AB4,
+       0x0ABA, 0x0ABB,
+       0x0AC6, 0x0AC6,
+       0x0ACA, 0x0ACA,
+       0x0ACE, 0x0ACF,
+       0x0AD1, 0x0ADF,
+       0x0AE1, 0x0AE5,
+       0x0AF0, 0x0B00,
+       0x0B04, 0x0B04,
+       0x0B0D, 0x0B0E,
+       0x0B11, 0x0B12,
+       0x0B29, 0x0B29,
+       0x0B31, 0x0B31,
+       0x0B34, 0x0B35,
+       0x0B3A, 0x0B3B,
+       0x0B44, 0x0B46,
+       0x0B49, 0x0B4A,
+       0x0B4E, 0x0B55,
+       0x0B58, 0x0B5B,
+       0x0B5E, 0x0B5E,
+       0x0B62, 0x0B65,
+       0x0B71, 0x0B81,
+       0x0B84, 0x0B84,
+       0x0B8B, 0x0B8D,
+       0x0B91, 0x0B91,
+       0x0B96, 0x0B98,
+       0x0B9B, 0x0B9B,
+       0x0B9D, 0x0B9D,
+       0x0BA0, 0x0BA2,
+       0x0BA5, 0x0BA7,
+       0x0BAB, 0x0BAD,
+       0x0BB6, 0x0BB6,
+       0x0BBA, 0x0BBD,
+       0x0BC3, 0x0BC5,
+       0x0BC9, 0x0BC9,
+       0x0BCE, 0x0BD6,
+       0x0BD8, 0x0BE6,
+       0x0BF3, 0x0C00,
+       0x0C04, 0x0C04,
+       0x0C0D, 0x0C0D,
+       0x0C11, 0x0C11,
+       0x0C29, 0x0C29,
+       0x0C34, 0x0C34,
+       0x0C3A, 0x0C3D,
+       0x0C45, 0x0C45,
+       0x0C49, 0x0C49,
+       0x0C4E, 0x0C54,
+       0x0C57, 0x0C5F,
+       0x0C62, 0x0C65,
+       0x0C70, 0x0C81,
+       0x0C84, 0x0C84,
+       0x0C8D, 0x0C8D,
+       0x0C91, 0x0C91,
+       0x0CA9, 0x0CA9,
+       0x0CB4, 0x0CB4,
+       0x0CBA, 0x0CBD,
+       0x0CC5, 0x0CC5,
+       0x0CC9, 0x0CC9,
+       0x0CCE, 0x0CD4,
+       0x0CD7, 0x0CDD,
+       0x0CDF, 0x0CDF,
+       0x0CE2, 0x0CE5,
+       0x0CF0, 0x0D01,
+       0x0D04, 0x0D04,
+       0x0D0D, 0x0D0D,
+       0x0D11, 0x0D11,
+       0x0D29, 0x0D29,
+       0x0D3A, 0x0D3D,
+       0x0D44, 0x0D45,
+       0x0D49, 0x0D49,
+       0x0D4E, 0x0D56,
+       0x0D58, 0x0D5F,
+       0x0D62, 0x0D65,
+       0x0D70, 0x0D81,
+       0x0D84, 0x0D84,
+       0x0D97, 0x0D99,
+       0x0DB2, 0x0DB2,
+       0x0DBC, 0x0DBC,
+       0x0DBE, 0x0DBF,
+       0x0DC7, 0x0DC9,
+       0x0DCB, 0x0DCE,
+       0x0DD5, 0x0DD5,
+       0x0DD7, 0x0DD7,
+       0x0DE0, 0x0DF1,
+       0x0DF5, 0x0E00,
+       0x0E3B, 0x0E3E,
+       0x0E5C, 0x0E80,
+       0x0E83, 0x0E83,
+       0x0E85, 0x0E86,
+       0x0E89, 0x0E89,
+       0x0E8B, 0x0E8C,
+       0x0E8E, 0x0E93,
+       0x0E98, 0x0E98,
+       0x0EA0, 0x0EA0,
+       0x0EA4, 0x0EA4,
+       0x0EA6, 0x0EA6,
+       0x0EA8, 0x0EA9,
+       0x0EAC, 0x0EAC,
+       0x0EBA, 0x0EBA,
+       0x0EBE, 0x0EBF,
+       0x0EC5, 0x0EC5,
+       0x0EC7, 0x0EC7,
+       0x0ECE, 0x0ECF,
+       0x0EDA, 0x0EDB,
+       0x0EDE, 0x0EFF,
+       0x0F48, 0x0F48,
+       0x0F6B, 0x0F70,
+       0x0F8C, 0x0F8F,
+       0x0F98, 0x0F98,
+       0x0FBD, 0x0FBD,
+       0x0FCD, 0x0FCE,
+       0x0FD0, 0x0FFF,
+       0x1022, 0x1022,
+       0x1028, 0x1028,
+       0x102B, 0x102B,
+       0x1033, 0x1035,
+       0x103A, 0x103F,
+       0x105A, 0x109F,
+       0x10C6, 0x10CF,
+       0x10F9, 0x10FA,
+       0x10FC, 0x10FF,
+       0x115A, 0x115E,
+       0x11A3, 0x11A7,
+       0x11FA, 0x11FF,
+       0x1207, 0x1207,
+       0x1247, 0x1247,
+       0x1249, 0x1249,
+       0x124E, 0x124F,
+       0x1257, 0x1257,
+       0x1259, 0x1259,
+       0x125E, 0x125F,
+       0x1287, 0x1287,
+       0x1289, 0x1289,
+       0x128E, 0x128F,
+       0x12AF, 0x12AF,
+       0x12B1, 0x12B1,
+       0x12B6, 0x12B7,
+       0x12BF, 0x12BF,
+       0x12C1, 0x12C1,
+       0x12C6, 0x12C7,
+       0x12CF, 0x12CF,
+       0x12D7, 0x12D7,
+       0x12EF, 0x12EF,
+       0x130F, 0x130F,
+       0x1311, 0x1311,
+       0x1316, 0x1317,
+       0x131F, 0x131F,
+       0x1347, 0x1347,
+       0x135B, 0x1360,
+       0x137D, 0x139F,
+       0x13F5, 0x1400,
+       0x1677, 0x167F,
+       0x169D, 0x169F,
+       0x16F1, 0x16FF,
+       0x170D, 0x170D,
+       0x1715, 0x171F,
+       0x1737, 0x173F,
+       0x1754, 0x175F,
+       0x176D, 0x176D,
+       0x1771, 0x1771,
+       0x1774, 0x177F,
+       0x17DD, 0x17DF,
+       0x17EA, 0x17FF,
+       0x180F, 0x180F,
+       0x181A, 0x181F,
+       0x1878, 0x187F,
+       0x18AA, 0x1DFF,
+       0x1E9C, 0x1E9F,
+       0x1EFA, 0x1EFF,
+       0x1F16, 0x1F17,
+       0x1F1E, 0x1F1F,
+       0x1F46, 0x1F47,
+       0x1F4E, 0x1F4F,
+       0x1F58, 0x1F58,
+       0x1F5A, 0x1F5A,
+       0x1F5C, 0x1F5C,
+       0x1F5E, 0x1F5E,
+       0x1F7E, 0x1F7F,
+       0x1FB5, 0x1FB5,
+       0x1FC5, 0x1FC5,
+       0x1FD4, 0x1FD5,
+       0x1FDC, 0x1FDC,
+       0x1FF0, 0x1FF1,
+       0x1FF5, 0x1FF5,
+       0x1FFF, 0x1FFF,
+       0x2053, 0x2056,
+       0x2058, 0x205E,
+       0x2064, 0x2069,
+       0x2072, 0x2073,
+       0x208F, 0x209F,
+       0x20B2, 0x20CF,
+       0x20EB, 0x20FF,
+       0x213B, 0x213C,
+       0x214C, 0x2152,
+       0x2184, 0x218F,
+       0x23CF, 0x23FF,
+       0x2427, 0x243F,
+       0x244B, 0x245F,
+       0x24FF, 0x24FF,
+       0x2614, 0x2615,
+       0x2618, 0x2618,
+       0x267E, 0x267F,
+       0x268A, 0x2700,
+       0x2705, 0x2705,
+       0x270A, 0x270B,
+       0x2728, 0x2728,
+       0x274C, 0x274C,
+       0x274E, 0x274E,
+       0x2753, 0x2755,
+       0x2757, 0x2757,
+       0x275F, 0x2760,
+       0x2795, 0x2797,
+       0x27B0, 0x27B0,
+       0x27BF, 0x27CF,
+       0x27EC, 0x27EF,
+       0x2B00, 0x2E7F,
+       0x2E9A, 0x2E9A,
+       0x2EF4, 0x2EFF,
+       0x2FD6, 0x2FEF,
+       0x2FFC, 0x2FFF,
+       0x3040, 0x3040,
+       0x3097, 0x3098,
+       0x3100, 0x3104,
+       0x312D, 0x3130,
+       0x318F, 0x318F,
+       0x31B8, 0x31EF,
+       0x321D, 0x321F,
+       0x3244, 0x3250,
+       0x327C, 0x327E,
+       0x32CC, 0x32CF,
+       0x32FF, 0x32FF,
+       0x3377, 0x337A,
+       0x33DE, 0x33DF,
+       0x33FF, 0x33FF,
+       0x4DB6, 0x4DFF,
+       0x9FA6, 0x9FFF,
+       0xA48D, 0xA48F,
+       0xA4C7, 0xABFF,
+       0xD7A4, 0xD7FF,
+       0xFA2E, 0xFA2F,
+       0xFA6B, 0xFAFF,
+       0xFB07, 0xFB12,
+       0xFB18, 0xFB1C,
+       0xFB37, 0xFB37,
+       0xFB3D, 0xFB3D,
+       0xFB3F, 0xFB3F,
+       0xFB42, 0xFB42,
+       0xFB45, 0xFB45,
+       0xFBB2, 0xFBD2,
+       0xFD40, 0xFD4F,
+       0xFD90, 0xFD91,
+       0xFDC8, 0xFDCF,
+       0xFDFD, 0xFDFF,
+       0xFE10, 0xFE1F,
+       0xFE24, 0xFE2F,
+       0xFE47, 0xFE48,
+       0xFE53, 0xFE53,
+       0xFE67, 0xFE67,
+       0xFE6C, 0xFE6F,
+       0xFE75, 0xFE75,
+       0xFEFD, 0xFEFE,
+       0xFF00, 0xFF00,
+       0xFFBF, 0xFFC1,
+       0xFFC8, 0xFFC9,
+       0xFFD0, 0xFFD1,
+       0xFFD8, 0xFFD9,
+       0xFFDD, 0xFFDF,
+       0xFFE7, 0xFFE7,
+       0xFFEF, 0xFFF8,
+       0x10000, 0x102FF,
+       0x1031F, 0x1031F,
+       0x10324, 0x1032F,
+       0x1034B, 0x103FF,
+       0x10426, 0x10427,
+       0x1044E, 0x1CFFF,
+       0x1D0F6, 0x1D0FF,
+       0x1D127, 0x1D129,
+       0x1D1DE, 0x1D3FF,
+       0x1D455, 0x1D455,
+       0x1D49D, 0x1D49D,
+       0x1D4A0, 0x1D4A1,
+       0x1D4A3, 0x1D4A4,
+       0x1D4A7, 0x1D4A8,
+       0x1D4AD, 0x1D4AD,
+       0x1D4BA, 0x1D4BA,
+       0x1D4BC, 0x1D4BC,
+       0x1D4C1, 0x1D4C1,
+       0x1D4C4, 0x1D4C4,
+       0x1D506, 0x1D506,
+       0x1D50B, 0x1D50C,
+       0x1D515, 0x1D515,
+       0x1D51D, 0x1D51D,
+       0x1D53A, 0x1D53A,
+       0x1D53F, 0x1D53F,
+       0x1D545, 0x1D545,
+       0x1D547, 0x1D549,
+       0x1D551, 0x1D551,
+       0x1D6A4, 0x1D6A7,
+       0x1D7CA, 0x1D7CD,
+       0x1D800, 0x1FFFD,
+       0x2A6D7, 0x2F7FF,
+       0x2FA1E, 0x2FFFD,
+       0x30000, 0x3FFFD,
+       0x40000, 0x4FFFD,
+       0x50000, 0x5FFFD,
+       0x60000, 0x6FFFD,
+       0x70000, 0x7FFFD,
+       0x80000, 0x8FFFD,
+       0x90000, 0x9FFFD,
+       0xA0000, 0xAFFFD,
+       0xB0000, 0xBFFFD,
+       0xC0000, 0xCFFFD,
+       0xD0000, 0xDFFFD,
+       0xE0000, 0xE0000,
+       0xE0002, 0xE001F,
+       0xE0080, 0xEFFFD
+};
+
+/* D.1 Characters with bidirectional property "R" or "AL" */
+static const pg_wchar RandALCat_codepoint_ranges[] =
+{
+       0x05BE, 0x05BE,
+       0x05C0, 0x05C0,
+       0x05C3, 0x05C3,
+       0x05D0, 0x05EA,
+       0x05F0, 0x05F4,
+       0x061B, 0x061B,
+       0x061F, 0x061F,
+       0x0621, 0x063A,
+       0x0640, 0x064A,
+       0x066D, 0x066F,
+       0x0671, 0x06D5,
+       0x06DD, 0x06DD,
+       0x06E5, 0x06E6,
+       0x06FA, 0x06FE,
+       0x0700, 0x070D,
+       0x0710, 0x0710,
+       0x0712, 0x072C,
+       0x0780, 0x07A5,
+       0x07B1, 0x07B1,
+       0x200F, 0x200F,
+       0xFB1D, 0xFB1D,
+       0xFB1F, 0xFB28,
+       0xFB2A, 0xFB36,
+       0xFB38, 0xFB3C,
+       0xFB3E, 0xFB3E,
+       0xFB40, 0xFB41,
+       0xFB43, 0xFB44,
+       0xFB46, 0xFBB1,
+       0xFBD3, 0xFD3D,
+       0xFD50, 0xFD8F,
+       0xFD92, 0xFDC7,
+       0xFDF0, 0xFDFC,
+       0xFE70, 0xFE74,
+       0xFE76, 0xFEFC
+};
+
+/* D.2 Characters with bidirectional property "L" */
+static const pg_wchar LCat_codepoint_ranges[] =
+{
+       0x0041, 0x005A,
+       0x0061, 0x007A,
+       0x00AA, 0x00AA,
+       0x00B5, 0x00B5,
+       0x00BA, 0x00BA,
+       0x00C0, 0x00D6,
+       0x00D8, 0x00F6,
+       0x00F8, 0x0220,
+       0x0222, 0x0233,
+       0x0250, 0x02AD,
+       0x02B0, 0x02B8,
+       0x02BB, 0x02C1,
+       0x02D0, 0x02D1,
+       0x02E0, 0x02E4,
+       0x02EE, 0x02EE,
+       0x037A, 0x037A,
+       0x0386, 0x0386,
+       0x0388, 0x038A,
+       0x038C, 0x038C,
+       0x038E, 0x03A1,
+       0x03A3, 0x03CE,
+       0x03D0, 0x03F5,
+       0x0400, 0x0482,
+       0x048A, 0x04CE,
+       0x04D0, 0x04F5,
+       0x04F8, 0x04F9,
+       0x0500, 0x050F,
+       0x0531, 0x0556,
+       0x0559, 0x055F,
+       0x0561, 0x0587,
+       0x0589, 0x0589,
+       0x0903, 0x0903,
+       0x0905, 0x0939,
+       0x093D, 0x0940,
+       0x0949, 0x094C,
+       0x0950, 0x0950,
+       0x0958, 0x0961,
+       0x0964, 0x0970,
+       0x0982, 0x0983,
+       0x0985, 0x098C,
+       0x098F, 0x0990,
+       0x0993, 0x09A8,
+       0x09AA, 0x09B0,
+       0x09B2, 0x09B2,
+       0x09B6, 0x09B9,
+       0x09BE, 0x09C0,
+       0x09C7, 0x09C8,
+       0x09CB, 0x09CC,
+       0x09D7, 0x09D7,
+       0x09DC, 0x09DD,
+       0x09DF, 0x09E1,
+       0x09E6, 0x09F1,
+       0x09F4, 0x09FA,
+       0x0A05, 0x0A0A,
+       0x0A0F, 0x0A10,
+       0x0A13, 0x0A28,
+       0x0A2A, 0x0A30,
+       0x0A32, 0x0A33,
+       0x0A35, 0x0A36,
+       0x0A38, 0x0A39,
+       0x0A3E, 0x0A40,
+       0x0A59, 0x0A5C,
+       0x0A5E, 0x0A5E,
+       0x0A66, 0x0A6F,
+       0x0A72, 0x0A74,
+       0x0A83, 0x0A83,
+       0x0A85, 0x0A8B,
+       0x0A8D, 0x0A8D,
+       0x0A8F, 0x0A91,
+       0x0A93, 0x0AA8,
+       0x0AAA, 0x0AB0,
+       0x0AB2, 0x0AB3,
+       0x0AB5, 0x0AB9,
+       0x0ABD, 0x0AC0,
+       0x0AC9, 0x0AC9,
+       0x0ACB, 0x0ACC,
+       0x0AD0, 0x0AD0,
+       0x0AE0, 0x0AE0,
+       0x0AE6, 0x0AEF,
+       0x0B02, 0x0B03,
+       0x0B05, 0x0B0C,
+       0x0B0F, 0x0B10,
+       0x0B13, 0x0B28,
+       0x0B2A, 0x0B30,
+       0x0B32, 0x0B33,
+       0x0B36, 0x0B39,
+       0x0B3D, 0x0B3E,
+       0x0B40, 0x0B40,
+       0x0B47, 0x0B48,
+       0x0B4B, 0x0B4C,
+       0x0B57, 0x0B57,
+       0x0B5C, 0x0B5D,
+       0x0B5F, 0x0B61,
+       0x0B66, 0x0B70,
+       0x0B83, 0x0B83,
+       0x0B85, 0x0B8A,
+       0x0B8E, 0x0B90,
+       0x0B92, 0x0B95,
+       0x0B99, 0x0B9A,
+       0x0B9C, 0x0B9C,
+       0x0B9E, 0x0B9F,
+       0x0BA3, 0x0BA4,
+       0x0BA8, 0x0BAA,
+       0x0BAE, 0x0BB5,
+       0x0BB7, 0x0BB9,
+       0x0BBE, 0x0BBF,
+       0x0BC1, 0x0BC2,
+       0x0BC6, 0x0BC8,
+       0x0BCA, 0x0BCC,
+       0x0BD7, 0x0BD7,
+       0x0BE7, 0x0BF2,
+       0x0C01, 0x0C03,
+       0x0C05, 0x0C0C,
+       0x0C0E, 0x0C10,
+       0x0C12, 0x0C28,
+       0x0C2A, 0x0C33,
+       0x0C35, 0x0C39,
+       0x0C41, 0x0C44,
+       0x0C60, 0x0C61,
+       0x0C66, 0x0C6F,
+       0x0C82, 0x0C83,
+       0x0C85, 0x0C8C,
+       0x0C8E, 0x0C90,
+       0x0C92, 0x0CA8,
+       0x0CAA, 0x0CB3,
+       0x0CB5, 0x0CB9,
+       0x0CBE, 0x0CBE,
+       0x0CC0, 0x0CC4,
+       0x0CC7, 0x0CC8,
+       0x0CCA, 0x0CCB,
+       0x0CD5, 0x0CD6,
+       0x0CDE, 0x0CDE,
+       0x0CE0, 0x0CE1,
+       0x0CE6, 0x0CEF,
+       0x0D02, 0x0D03,
+       0x0D05, 0x0D0C,
+       0x0D0E, 0x0D10,
+       0x0D12, 0x0D28,
+       0x0D2A, 0x0D39,
+       0x0D3E, 0x0D40,
+       0x0D46, 0x0D48,
+       0x0D4A, 0x0D4C,
+       0x0D57, 0x0D57,
+       0x0D60, 0x0D61,
+       0x0D66, 0x0D6F,
+       0x0D82, 0x0D83,
+       0x0D85, 0x0D96,
+       0x0D9A, 0x0DB1,
+       0x0DB3, 0x0DBB,
+       0x0DBD, 0x0DBD,
+       0x0DC0, 0x0DC6,
+       0x0DCF, 0x0DD1,
+       0x0DD8, 0x0DDF,
+       0x0DF2, 0x0DF4,
+       0x0E01, 0x0E30,
+       0x0E32, 0x0E33,
+       0x0E40, 0x0E46,
+       0x0E4F, 0x0E5B,
+       0x0E81, 0x0E82,
+       0x0E84, 0x0E84,
+       0x0E87, 0x0E88,
+       0x0E8A, 0x0E8A,
+       0x0E8D, 0x0E8D,
+       0x0E94, 0x0E97,
+       0x0E99, 0x0E9F,
+       0x0EA1, 0x0EA3,
+       0x0EA5, 0x0EA5,
+       0x0EA7, 0x0EA7,
+       0x0EAA, 0x0EAB,
+       0x0EAD, 0x0EB0,
+       0x0EB2, 0x0EB3,
+       0x0EBD, 0x0EBD,
+       0x0EC0, 0x0EC4,
+       0x0EC6, 0x0EC6,
+       0x0ED0, 0x0ED9,
+       0x0EDC, 0x0EDD,
+       0x0F00, 0x0F17,
+       0x0F1A, 0x0F34,
+       0x0F36, 0x0F36,
+       0x0F38, 0x0F38,
+       0x0F3E, 0x0F47,
+       0x0F49, 0x0F6A,
+       0x0F7F, 0x0F7F,
+       0x0F85, 0x0F85,
+       0x0F88, 0x0F8B,
+       0x0FBE, 0x0FC5,
+       0x0FC7, 0x0FCC,
+       0x0FCF, 0x0FCF,
+       0x1000, 0x1021,
+       0x1023, 0x1027,
+       0x1029, 0x102A,
+       0x102C, 0x102C,
+       0x1031, 0x1031,
+       0x1038, 0x1038,
+       0x1040, 0x1057,
+       0x10A0, 0x10C5,
+       0x10D0, 0x10F8,
+       0x10FB, 0x10FB,
+       0x1100, 0x1159,
+       0x115F, 0x11A2,
+       0x11A8, 0x11F9,
+       0x1200, 0x1206,
+       0x1208, 0x1246,
+       0x1248, 0x1248,
+       0x124A, 0x124D,
+       0x1250, 0x1256,
+       0x1258, 0x1258,
+       0x125A, 0x125D,
+       0x1260, 0x1286,
+       0x1288, 0x1288,
+       0x128A, 0x128D,
+       0x1290, 0x12AE,
+       0x12B0, 0x12B0,
+       0x12B2, 0x12B5,
+       0x12B8, 0x12BE,
+       0x12C0, 0x12C0,
+       0x12C2, 0x12C5,
+       0x12C8, 0x12CE,
+       0x12D0, 0x12D6,
+       0x12D8, 0x12EE,
+       0x12F0, 0x130E,
+       0x1310, 0x1310,
+       0x1312, 0x1315,
+       0x1318, 0x131E,
+       0x1320, 0x1346,
+       0x1348, 0x135A,
+       0x1361, 0x137C,
+       0x13A0, 0x13F4,
+       0x1401, 0x1676,
+       0x1681, 0x169A,
+       0x16A0, 0x16F0,
+       0x1700, 0x170C,
+       0x170E, 0x1711,
+       0x1720, 0x1731,
+       0x1735, 0x1736,
+       0x1740, 0x1751,
+       0x1760, 0x176C,
+       0x176E, 0x1770,
+       0x1780, 0x17B6,
+       0x17BE, 0x17C5,
+       0x17C7, 0x17C8,
+       0x17D4, 0x17DA,
+       0x17DC, 0x17DC,
+       0x17E0, 0x17E9,
+       0x1810, 0x1819,
+       0x1820, 0x1877,
+       0x1880, 0x18A8,
+       0x1E00, 0x1E9B,
+       0x1EA0, 0x1EF9,
+       0x1F00, 0x1F15,
+       0x1F18, 0x1F1D,
+       0x1F20, 0x1F45,
+       0x1F48, 0x1F4D,
+       0x1F50, 0x1F57,
+       0x1F59, 0x1F59,
+       0x1F5B, 0x1F5B,
+       0x1F5D, 0x1F5D,
+       0x1F5F, 0x1F7D,
+       0x1F80, 0x1FB4,
+       0x1FB6, 0x1FBC,
+       0x1FBE, 0x1FBE,
+       0x1FC2, 0x1FC4,
+       0x1FC6, 0x1FCC,
+       0x1FD0, 0x1FD3,
+       0x1FD6, 0x1FDB,
+       0x1FE0, 0x1FEC,
+       0x1FF2, 0x1FF4,
+       0x1FF6, 0x1FFC,
+       0x200E, 0x200E,
+       0x2071, 0x2071,
+       0x207F, 0x207F,
+       0x2102, 0x2102,
+       0x2107, 0x2107,
+       0x210A, 0x2113,
+       0x2115, 0x2115,
+       0x2119, 0x211D,
+       0x2124, 0x2124,
+       0x2126, 0x2126,
+       0x2128, 0x2128,
+       0x212A, 0x212D,
+       0x212F, 0x2131,
+       0x2133, 0x2139,
+       0x213D, 0x213F,
+       0x2145, 0x2149,
+       0x2160, 0x2183,
+       0x2336, 0x237A,
+       0x2395, 0x2395,
+       0x249C, 0x24E9,
+       0x3005, 0x3007,
+       0x3021, 0x3029,
+       0x3031, 0x3035,
+       0x3038, 0x303C,
+       0x3041, 0x3096,
+       0x309D, 0x309F,
+       0x30A1, 0x30FA,
+       0x30FC, 0x30FF,
+       0x3105, 0x312C,
+       0x3131, 0x318E,
+       0x3190, 0x31B7,
+       0x31F0, 0x321C,
+       0x3220, 0x3243,
+       0x3260, 0x327B,
+       0x327F, 0x32B0,
+       0x32C0, 0x32CB,
+       0x32D0, 0x32FE,
+       0x3300, 0x3376,
+       0x337B, 0x33DD,
+       0x33E0, 0x33FE,
+       0x3400, 0x4DB5,
+       0x4E00, 0x9FA5,
+       0xA000, 0xA48C,
+       0xAC00, 0xD7A3,
+       0xD800, 0xFA2D,
+       0xFA30, 0xFA6A,
+       0xFB00, 0xFB06,
+       0xFB13, 0xFB17,
+       0xFF21, 0xFF3A,
+       0xFF41, 0xFF5A,
+       0xFF66, 0xFFBE,
+       0xFFC2, 0xFFC7,
+       0xFFCA, 0xFFCF,
+       0xFFD2, 0xFFD7,
+       0xFFDA, 0xFFDC,
+       0x10300, 0x1031E,
+       0x10320, 0x10323,
+       0x10330, 0x1034A,
+       0x10400, 0x10425,
+       0x10428, 0x1044D,
+       0x1D000, 0x1D0F5,
+       0x1D100, 0x1D126,
+       0x1D12A, 0x1D166,
+       0x1D16A, 0x1D172,
+       0x1D183, 0x1D184,
+       0x1D18C, 0x1D1A9,
+       0x1D1AE, 0x1D1DD,
+       0x1D400, 0x1D454,
+       0x1D456, 0x1D49C,
+       0x1D49E, 0x1D49F,
+       0x1D4A2, 0x1D4A2,
+       0x1D4A5, 0x1D4A6,
+       0x1D4A9, 0x1D4AC,
+       0x1D4AE, 0x1D4B9,
+       0x1D4BB, 0x1D4BB,
+       0x1D4BD, 0x1D4C0,
+       0x1D4C2, 0x1D4C3,
+       0x1D4C5, 0x1D505,
+       0x1D507, 0x1D50A,
+       0x1D50D, 0x1D514,
+       0x1D516, 0x1D51C,
+       0x1D51E, 0x1D539,
+       0x1D53B, 0x1D53E,
+       0x1D540, 0x1D544,
+       0x1D546, 0x1D546,
+       0x1D54A, 0x1D550,
+       0x1D552, 0x1D6A3,
+       0x1D6A8, 0x1D7C9,
+       0x20000, 0x2A6D6,
+       0x2F800, 0x2FA1D,
+       0xF0000, 0xFFFFD,
+       0x100000, 0x10FFFD
+};
+
+/* End of stringprep tables */
+
+
+/* Is the given Unicode codepoint in the given table of ranges? */
+#define IS_CODE_IN_TABLE(code, map) is_code_in_table(code, map, lengthof(map))
+
+static int
+codepoint_range_cmp(const void *a, const void *b)
+{
+       const pg_wchar *key = (const pg_wchar *) a;
+       const pg_wchar *range = (const pg_wchar *) b;
+
+       if (*key < range[0])
+               return -1;                              /* less than lower bound */
+       if (*key > range[1])
+               return 1;                               /* greater than upper bound */
+
+       return 0;                                       /* within range */
+}
+
+static bool
+is_code_in_table(pg_wchar code, const pg_wchar *map, int mapsize)
+{
+       Assert(mapsize % 2 == 0);
+
+       if (code < map[0] || code > map[mapsize - 1])
+               return false;
+
+       if (bsearch(&code, map, mapsize / 2, sizeof(pg_wchar) * 2,
+                               codepoint_range_cmp))
+               return true;
+       else
+               return false;
+}
+
+/*
+ * Calculate the length in characters of a null-terminated UTF-8 string.
+ *
+ * Returns -1 if the input is not valid UTF-8.
+ */
+static int
+pg_utf8_string_len(const char *source)
+{
+       const unsigned char *p = (const unsigned char *) source;
+       int                     l;
+       int                     num_chars = 0;
+
+       while (*p)
+       {
+               l = pg_utf_mblen(p);
+
+               if (!pg_utf8_islegal(p, l))
+                       return -1;
+
+               p += l;
+               num_chars++;
+       }
+
+       return num_chars;
+}
+
+/*
+ * Returns true if the input string is pure ASCII.
+ */
+static bool
+pg_is_ascii_string(const char *p)
+{
+       while (*p)
+       {
+               if (IS_HIGHBIT_SET(*p))
+                       return false;
+               p++;
+       }
+       return true;
+}
+
+
+/*
+ * pg_saslprep - Normalize a password with SASLprep.
+ *
+ * SASLprep requires the input to be in UTF-8 encoding, but PostgreSQL
+ * supports many encodings, so we don't blindly assume that.  pg_saslprep
+ * will check if the input looks like valid UTF-8, and returns
+ * SASLPREP_INVALID_UTF8 if not.
+ *
+ * If the string contains prohibited characters (or more precisely, if the
+ * output string would contain prohibited characters after normalization),
+ * returns SASLPREP_PROHIBITED.
+ *
+ * On success, returns SASLPREP_SUCCESS, and the normalized string in
+ * *output.
+ *
+ * In frontend, the normalized string is malloc'd, and the caller is
+ * responsible for freeing it.  If an allocation fails, returns
+ * SASLPREP_OOM.  In backend, the normalized string is palloc'd instead,
+ * and a failed allocation leads to ereport(ERROR).
+ */
+pg_saslprep_rc
+pg_saslprep(const char *input, char **output)
+{
+       pg_wchar   *input_chars = NULL;
+       pg_wchar   *output_chars = NULL;
+       int                     input_size;
+       char       *result;
+       int                     result_size;
+       int                     count;
+       int                     i;
+       bool            contains_RandALCat;
+       unsigned char *p;
+       pg_wchar   *wp;
+
+       /* Check that the password isn't stupendously long */
+       if (strlen(input) > MAX_PASSWORD_LENGTH)
+       {
+#ifndef FRONTEND
+               ereport(ERROR,
+                               (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
+                                errmsg("password too long")));
+#else
+               return SASLPREP_OOM;
+#endif
+       }
+
+       /*
+        * Quick check if the input is pure ASCII.  An ASCII string requires
+        * no further processing.
+        */
+       if (pg_is_ascii_string(input))
+       {
+               *output = STRDUP(input);
+               if (!(*output))
+                       goto oom;
+               return SASLPREP_SUCCESS;
+       }
+
+       /*
+        * Convert the input from UTF-8 to an array of Unicode codepoints.
+        *
+        * This also checks that the input is a legal UTF-8 string.
+        */
+       input_size = pg_utf8_string_len(input);
+       if (input_size < 0)
+       {
+               *output = NULL;
+               return SASLPREP_INVALID_UTF8;
+       }
+
+       input_chars = ALLOC((input_size + 1) * sizeof(pg_wchar));
+       if (!input_chars)
+               goto oom;
+
+       p = (unsigned char *) input;
+       for (i = 0; i < input_size; i++)
+       {
+               input_chars[i] = utf8_to_unicode(p);
+               p += pg_utf_mblen(p);
+       }
+       input_chars[i] = (pg_wchar) '\0';
+
+       /*
+        * The steps below correspond to the steps listed in [RFC3454], Section
+        * "2. Preparation Overview"
+        */
+
+       /*
+        * 1) Map -- For each character in the input, check if it has a mapping
+        * and, if so, replace it with its mapping.
+        */
+       count = 0;
+       for (i = 0; i < input_size; i++)
+       {
+               pg_wchar        code = input_chars[i];
+
+               if (IS_CODE_IN_TABLE(code, non_ascii_space_ranges))
+                       input_chars[count++] = 0x0020;
+               else if (IS_CODE_IN_TABLE(code, commonly_mapped_to_nothing_ranges))
+               {
+                       /* map to nothing */
+               }
+               else
+                       input_chars[count++] = code;
+       }
+       input_chars[count] = (pg_wchar) '\0';
+       input_size = count;
+
+       if (input_size == 0)
+               goto prohibited;                /* don't allow empty password */
+
+       /*
+        * 2) Normalize -- Normalize the result of step 1 using Unicode
+        * normalization.
+        */
+       output_chars = unicode_normalize_kc(input_chars);
+       if (!output_chars)
+               goto oom;
+
+       /*
+        * 3) Prohibit -- Check for any characters that are not allowed in the
+        * output.  If any are found, return an error.
+        */
+       for (i = 0; i < input_size; i++)
+       {
+               pg_wchar        code = input_chars[i];
+
+               if (IS_CODE_IN_TABLE(code, prohibited_output_ranges))
+                       goto prohibited;
+               if (IS_CODE_IN_TABLE(code, unassigned_codepoint_ranges))
+                       goto prohibited;
+       }
+
+       /*
+        * 4) Check bidi -- Possibly check for right-to-left characters, and if
+        * any are found, make sure that the whole string satisfies the
+        * requirements for bidirectional strings.  If the string does not satisfy
+        * the requirements for bidirectional strings, return an error.
+        *
+        * [RFC3454], Section "6. Bidirectional Characters" explains in more
+        * detail what that means:
+        *
+        * "In any profile that specifies bidirectional character handling, all
+        * three of the following requirements MUST be met:
+        *
+        * 1) The characters in section 5.8 MUST be prohibited.
+        *
+        * 2) If a string contains any RandALCat character, the string MUST NOT
+        * contain any LCat character.
+        *
+        * 3) If a string contains any RandALCat character, a RandALCat character
+        * MUST be the first character of the string, and a RandALCat character
+        * MUST be the last character of the string."
+        */
+       contains_RandALCat = false;
+       for (i = 0; i < input_size; i++)
+       {
+               pg_wchar        code = input_chars[i];
+
+               if (IS_CODE_IN_TABLE(code, RandALCat_codepoint_ranges))
+               {
+                       contains_RandALCat = true;
+                       break;
+               }
+       }
+
+       if (contains_RandALCat)
+       {
+               pg_wchar        first = input_chars[0];
+               pg_wchar        last = input_chars[input_size - 1];
+
+               for (i = 0; i < input_size; i++)
+               {
+                       pg_wchar        code = input_chars[i];
+
+                       if (IS_CODE_IN_TABLE(code, LCat_codepoint_ranges))
+                               goto prohibited;
+               }
+
+               if (!IS_CODE_IN_TABLE(first, RandALCat_codepoint_ranges) ||
+                       !IS_CODE_IN_TABLE(last, RandALCat_codepoint_ranges))
+                       goto prohibited;
+       }
+
+       /*
+        * Finally, convert the result back to UTF-8.
+        */
+       result_size = 0;
+       for (wp = output_chars; *wp; wp++)
+       {
+               unsigned char buf[4];
+
+               unicode_to_utf8(*wp, buf);
+               result_size += pg_utf_mblen(buf);
+       }
+
+       result = ALLOC(result_size + 1);
+       if (!result)
+               goto oom;
+       p = (unsigned char *) result;
+       for (wp = output_chars; *wp; wp++)
+       {
+               unicode_to_utf8(*wp, p);
+               p += pg_utf_mblen(p);
+       }
+       Assert((char *) p == result + result_size);
+       *p = '\0';
+
+       FREE(input_chars);
+       FREE(output_chars);
+
+       *output = result;
+       return SASLPREP_SUCCESS;
+
+prohibited:
+       if (input_chars)
+               FREE(input_chars);
+       if (output_chars)
+               FREE(output_chars);
+
+       return SASLPREP_PROHIBITED;
+
+oom:
+       if (input_chars)
+               FREE(input_chars);
+       if (output_chars)
+               FREE(output_chars);
+
+       return SASLPREP_OOM;
+}

diff --git a/src/common/scram-common.c b/src/common/scram-common.c
index e44f38f6520eb5474a6de90b15f0bab0de60e18a..df9f0eaa90d1c6106613fbec6e995d5b963b6384 100644 (file)
--- a/src/common/scram-common.c
+++ b/src/common/scram-common.c
@@ -147,29 +147,10 @@ scram_H(const uint8 *input, int len, uint8 *result)
        pg_sha256_final(&ctx, result);
 }
 
-/*
- * Encrypt password for SCRAM authentication. This basically applies the
- * normalization of the password and a hash calculation using the salt
- * value given by caller.
- */
-static void
-scram_SaltedPassword(const char *password, const char *salt, int saltlen, int iterations,
-                                        uint8 *result)
-{
-       /*
-        * XXX: Here SASLprep should be applied on password. However, per RFC5802,
-        * it is required that the password is encoded in UTF-8, something that is
-        * not guaranteed in this protocol. We may want to revisit this
-        * normalization function once encoding functions are available as well in
-        * the frontend in order to be able to encode properly this string, and
-        * then apply SASLprep on it.
-        */
-
-       scram_Hi(password, salt, saltlen, iterations, result);
-}
-
 /*
  * Calculate ClientKey or ServerKey.
+ *
+ * The password should already be normalized by SASLprep.
  */
 void
 scram_ClientOrServerKey(const char *password,
@@ -179,7 +160,7 @@ scram_ClientOrServerKey(const char *password,
        uint8           keybuf[SCRAM_KEY_LEN];
        scram_HMAC_ctx ctx;
 
-       scram_SaltedPassword(password, salt, saltlen, iterations, keybuf);
+       scram_Hi(password, salt, saltlen, iterations, keybuf);
        scram_HMAC_init(&ctx, keybuf, SCRAM_KEY_LEN);
        scram_HMAC_update(&ctx, keystr, strlen(keystr));
        scram_HMAC_final(result, &ctx);

diff --git a/src/common/unicode/.gitignore b/src/common/unicode/.gitignore
new file mode 100644 (file)
index 0000000..5e583e2
--- /dev/null
+++ b/src/common/unicode/.gitignore
@@ -0,0 +1,7 @@
+/norm_test
+/norm_test_table.h
+
+# Files downloaded from the Unicode Character Database
+/CompositionExclusions.txt
+/NormalizationTest.txt
+/UnicodeData.txt

diff --git a/src/common/unicode/Makefile b/src/common/unicode/Makefile
new file mode 100644 (file)
index 0000000..e20ef77
--- /dev/null
+++ b/src/common/unicode/Makefile
@@ -0,0 +1,53 @@
+#-------------------------------------------------------------------------
+#
+# Makefile
+#    Makefile for src/common/unicode
+#
+# IDENTIFICATION
+#    src/common/unicode/Makefile
+#
+#-------------------------------------------------------------------------
+
+subdir = src/common/unicode
+top_builddir = ../../..
+include $(top_builddir)/src/Makefile.global
+
+override CPPFLAGS := -DFRONTEND $(CPPFLAGS)
+LIBS += $(PTHREAD_LIBS)
+
+# By default, do nothing.
+all:
+
+DOWNLOAD = wget -O $@ --no-use-server-timestamps
+
+# These files are part of the Unicode Character Database. Download
+# them on demand.
+UnicodeData.txt CompositionExclusions.txt NormalizationTest.txt:
+       $(DOWNLOAD) http://unicode.org/Public/UNIDATA/$(@F)
+
+# Generation of conversion tables used for string normalization with
+# UTF-8 strings.
+unicode_norm_table.h: generate-unicode_norm_table.pl UnicodeData.txt CompositionExclusions.txt
+       $(PERL) generate-unicode_norm_table.pl
+
+# Test suite
+normalization-check: norm_test
+       ./norm_test
+
+norm_test: norm_test.o ../unicode_norm.o
+
+norm_test.o: norm_test_table.h
+
+norm_test_table.h: generate-norm_test_table.pl NormalizationTest.txt
+       perl generate-norm_test_table.pl NormalizationTest.txt $@
+
+.PHONY: normalization-check
+
+
+clean:
+       rm -f $(OBJS) norm_test norm_test.o
+
+distclean: clean
+       rm -f UnicodeData.txt CompositionExclusions.txt NormalizationTest.txt norm_test_table.h unicode_norm_table.h
+
+maintainer-clean: distclean

diff --git a/src/common/unicode/README b/src/common/unicode/README
new file mode 100644 (file)
index 0000000..7c1c433
--- /dev/null
+++ b/src/common/unicode/README
@@ -0,0 +1,35 @@
+This directory contains tools to generate the tables in
+src/include/common/unicode_norm.h, used for Unicode normalization. The
+generated .h file is included in the source tree, so these are normally not
+needed to build PostgreSQL, only if you need to re-generate the .h file
+from the Unicode data files for some reason, e.g. to update to a new version
+of Unicode.
+
+Generating unicode_norm_table.h
+-------------------------------
+
+1. Download the Unicode data file, UnicodeData.txt, from the Unicode
+consortium and place it to the current directory. Run the perl script
+"norm_test_generate.pl", to process it, and to generate the
+"unicode_norm_table.h" file. The Makefile contains a rule to download the
+data files if they don't exist.
+
+    make unicode_norm_table.h
+
+2. Inspect the resulting header file. Once you're happy with it, copy it to
+the right location.
+
+    cp unicode_norm_table.h ../../../src/include/common/
+
+
+
+Tests
+-----
+
+The Unicode consortium publishes a comprehensive test suite for the
+normalization algorithm, in a file called NormalizationTest.txt. This
+directory also contains a perl script and some C code, to run our
+normalization code with all the test strings in NormalizationTest.txt.
+To download NormalizationTest.txt and run the tests:
+
+    make normalization-check

diff --git a/src/common/unicode/generate-norm_test_table.pl b/src/common/unicode/generate-norm_test_table.pl
new file mode 100644 (file)
index 0000000..836d3ab
--- /dev/null
+++ b/src/common/unicode/generate-norm_test_table.pl
@@ -0,0 +1,102 @@
+#!/usr/bin/perl
+#
+# Read Unicode consortium's normalization test suite, NormalizationTest.txt,
+# and generate a C array from it, for norm_test.c.
+#
+# NormalizationTest.txt is part of the Unicode Character Database.
+#
+# Copyright (c) 2000-2017, PostgreSQL Global Development Group
+
+use strict;
+use warnings;
+
+use File::Basename;
+
+die "Usage: $0 INPUT_FILE OUTPUT_FILE\n" if @ARGV != 2;
+my $input_file  = $ARGV[0];
+my $output_file = $ARGV[1];
+my $output_base = basename($output_file);
+
+# Open the input and output files
+open my $INPUT, $input_file
+  or die "Could not open input file $input_file: $!";
+open my $OUTPUT, "> $output_file"
+  or die "Could not open output file $output_file: $!\n";
+
+# Print header of output file.
+print $OUTPUT <<HEADER;
+/*-------------------------------------------------------------------------
+ *
+ * norm_test_table.h
+ *       Test strings for Unicode normalization.
+ *
+ * Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/common/unicode/norm_test_table.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+/*
+ * File auto-generated by src/common/unicode/generate-norm_test_table.pl, do
+ * not edit. There is deliberately not an #ifndef PG_NORM_TEST_TABLE_H
+ * here.
+ */
+
+typedef struct
+{
+       int                     linenum;
+       pg_wchar        input[50];
+       pg_wchar        output[50];
+} pg_unicode_test;
+
+/* test table */
+HEADER
+print $OUTPUT
+  "static const pg_unicode_test UnicodeNormalizationTests[] =\n{\n";
+
+# Helper routine to conver a space-separated list of Unicode characters to
+# hexadecimal list format, suitable for outputting in a C array.
+sub codepoint_string_to_hex
+{
+       my $codepoint_string = shift;
+
+       my $result;
+
+       foreach (split(' ', $codepoint_string))
+       {
+               my $cp   = $_;
+               my $utf8 = "0x$cp, ";
+               $result .= $utf8;
+       }
+       $result .= '0';    # null-terminated the array
+       return $result;
+}
+
+# Process the input file line by line
+my $linenum = 0;
+while (my $line = <$INPUT>)
+{
+       $linenum = $linenum + 1;
+       if ($line =~ /^\s*#/) { next; }    # ignore comments
+
+       if ($line =~ /^@/) { next; }       # ignore @Part0 like headers
+
+       # Split the line wanted and get the fields needed:
+       #
+       # source; NFC; NFD; NFKC; NFKD
+       my ($source, $nfc, $nfd, $nfkc, $nfkd) = split(';', $line);
+
+       my $source_utf8 = codepoint_string_to_hex($source);
+       my $nfkc_utf8   = codepoint_string_to_hex($nfkc);
+
+       print $OUTPUT "\t{ $linenum, { $source_utf8 }, { $nfkc_utf8 } },\n";
+}
+
+# Output terminator entry
+print $OUTPUT "\t{ 0, { 0 }, { 0 } }";
+print $OUTPUT "\n};\n";
+
+close $OUTPUT;
+close $INPUT;

diff --git a/src/common/unicode/generate-unicode_norm_table.pl b/src/common/unicode/generate-unicode_norm_table.pl
new file mode 100644 (file)
index 0000000..6d6e803
--- /dev/null
+++ b/src/common/unicode/generate-unicode_norm_table.pl
@@ -0,0 +1,226 @@
+#!/usr/bin/perl
+#
+# Generate a composition table, using Unicode data files as input
+#
+# Input: UnicodeData.txt and CompositionExclusions.txt
+# Output: unicode_norm_table.h
+#
+# Copyright (c) 2000-2017, PostgreSQL Global Development Group
+
+use strict;
+use warnings;
+
+my $output_file = "unicode_norm_table.h";
+
+my $FH;
+
+# Read list of codes that should be excluded from re-composition.
+my @composition_exclusion_codes = ();
+open($FH, "CompositionExclusions.txt")
+  or die "Could not open CompositionExclusions.txt: $!.";
+while (my $line = <$FH>)
+{
+       if ($line =~ /^([[:xdigit:]]+)/)
+       {
+               push @composition_exclusion_codes, $1;
+       }
+}
+close $FH;
+
+# Read entries from UnicodeData.txt into a list, and a hash table. We need
+# three fields from each row: the codepoint, canonical combining class,
+# and character decomposition mapping
+my @characters     = ();
+my %character_hash = ();
+open($FH, "UnicodeData.txt") or die "Could not open UnicodeData.txt: $!.";
+while (my $line = <$FH>)
+{
+       # Split the line wanted and get the fields needed:
+       # - Unicode code value
+       # - Canonical Combining Class
+       # - Character Decomposition Mapping
+       my @elts   = split(';', $line);
+       my $code   = $elts[0];
+       my $class  = $elts[3];
+       my $decomp = $elts[5];
+
+       # Skip codepoints above U+10FFFF. They cannot be represented in 4 bytes
+       # in UTF-8, and PostgreSQL doesn't support UTF-8 characters longer than
+       # 4 bytes. (This is just pro forma, as there aren't any such entries in
+       # the data file, currently.)
+       next if hex($code) > 0x10FFFF;
+
+       # Skip characters with no decompositions and a class of 0, to reduce the
+       # table size.
+       next if $class eq '0' && $decomp eq '';
+
+       my %char_entry = (code => $code, class => $class, decomp => $decomp);
+       push(@characters, \%char_entry);
+       $character_hash{$code} = \%char_entry;
+}
+close $FH;
+
+my $num_characters = scalar @characters;
+
+# Start writing out the output file
+open my $OUTPUT, "> $output_file"
+  or die "Could not open output file $output_file: $!\n";
+
+print $OUTPUT <<HEADER;
+/*-------------------------------------------------------------------------
+ *
+ * unicode_norm_table.h
+ *       Composition table used for Unicode normalization
+ *
+ * Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/common/unicode_norm_table.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+/*
+ * File auto-generated by src/common/unicode/generate-unicode_norm_table.pl,
+ * do not edit. There is deliberately not an #ifndef PG_UNICODE_NORM_TABLE_H
+ * here.
+ */
+typedef struct
+{
+       uint32          codepoint;              /* Unicode codepoint */
+       uint8           class;                  /* combining class of character */
+       uint8           dec_size_flags; /* size and flags of decomposition code list */
+       uint16          dec_index;              /* index into UnicodeDecomp_codepoints, or the
+                                                                * decomposition itself if DECOMP_INLINE */
+} pg_unicode_decomposition;
+
+#define DECOMP_NO_COMPOSE      0x80    /* don't use for re-composition */
+#define DECOMP_INLINE          0x40    /* decomposition is stored inline in dec_index */
+
+#define DECOMPOSITION_SIZE(x) ((x)->dec_size_flags & 0x3F)
+#define DECOMPOSITION_NO_COMPOSE(x) (((x)->dec_size_flags & DECOMP_NO_COMPOSE) != 0)
+#define DECOMPOSITION_IS_INLINE(x) (((x)->dec_size_flags & DECOMP_INLINE) != 0)
+
+/* Table of Unicode codepoints and their decompositions */
+static const pg_unicode_decomposition UnicodeDecompMain[$num_characters] =
+{
+HEADER
+
+my $decomp_index  = 0;
+my $decomp_string = "";
+
+my $last_code = $characters[-1]->{code};
+foreach my $char (@characters)
+{
+       my $code   = $char->{code};
+       my $class  = $char->{class};
+       my $decomp = $char->{decomp};
+
+       # The character decomposition mapping field in UnicodeData.txt is a list
+       # of unicode codepoints, separated by space. But it can be prefixed with
+       # so-called compatibility formatting tag, like "<compat>", or "<font>".
+       # The entries with compatibility formatting tags should not be used for
+       # re-composing characters during normalization, so flag them in the table.
+       # (The tag doesn't matter, only whether there is a tag or not)
+       my $compat = 0;
+       if ($decomp =~ /\<.*\>/)
+       {
+               $compat = 1;
+               $decomp =~ s/\<[^][]*\>//g;
+       }
+       my @decomp_elts = split(" ", $decomp);
+
+       # Decomposition size
+       # Print size of decomposition
+       my $decomp_size = scalar(@decomp_elts);
+
+       my $first_decomp = shift @decomp_elts;
+
+       my $flags   = "";
+       my $comment = "";
+
+       if ($decomp_size == 2)
+       {
+               # Should this be used for recomposition?
+               if ($compat)
+               {
+                       $flags .= " | DECOMP_NO_COMPOSE";
+                       $comment = "compatibility mapping";
+               }
+               elsif ($character_hash{$first_decomp}
+                       && $character_hash{$first_decomp}->{class} != 0)
+               {
+                       $flags .= " | DECOMP_NO_COMPOSE";
+                       $comment = "non-starter decomposition";
+               }
+               else
+               {
+                       foreach my $lcode (@composition_exclusion_codes)
+                       {
+                               if ($lcode eq $char->{code})
+                               {
+                                       $flags .= " | DECOMP_NO_COMPOSE";
+                                       $comment = "in exclusion list";
+                                       last;
+                               }
+                       }
+               }
+       }
+
+       if ($decomp_size == 0)
+       {
+               print $OUTPUT "\t{0x$code, $class, 0$flags, 0}";
+       }
+       elsif ($decomp_size == 1 && length($first_decomp) <= 4)
+       {
+               # The decomposition consists of a single codepoint, and it fits
+               # in a uint16, so we can store it "inline" in the main table.
+               $flags .= " | DECOMP_INLINE";
+               print $OUTPUT "\t{0x$code, $class, 1$flags, 0x$first_decomp}";
+       }
+       else
+       {
+               print $OUTPUT
+                 "\t{0x$code, $class, $decomp_size$flags, $decomp_index}";
+
+               # Now save the decompositions into a dedicated area that will
+               # be written afterwards.  First build the entry dedicated to
+               # a sub-table with the code and decomposition.
+               $decomp_string .= ",\n" if ($decomp_string ne "");
+
+               $decomp_string .= "\t /* $decomp_index */ 0x$first_decomp";
+               foreach (@decomp_elts)
+               {
+                       $decomp_string .= ", 0x$_";
+               }
+
+               $decomp_index = $decomp_index + $decomp_size;
+       }
+
+       # Print a comma after all items except the last one.
+       print $OUTPUT "," unless ($code eq $last_code);
+       if ($comment ne "")
+       {
+               # If the line is wide already, indent the comment with one tab,
+               # otherwise with two. This is to make the output match the way
+               # pgindent would mangle it. (This is quite hacky. To do this
+               # properly, we should actually track how long the line is so far,
+               # but this works for now.)
+               print $OUTPUT "\t" if ($decomp_index < 10);
+
+               print $OUTPUT "\t/* $comment */" if ($comment ne "");
+       }
+       print $OUTPUT "\n";
+}
+print $OUTPUT "\n};\n\n";
+
+# Print the array of decomposed codes.
+print $OUTPUT <<HEADER;
+/* codepoints array  */
+static const uint32 UnicodeDecomp_codepoints[$decomp_index] =
+{
+$decomp_string
+};
+HEADER
+
+close $OUTPUT;

diff --git a/src/common/unicode/norm_test.c b/src/common/unicode/norm_test.c
new file mode 100644 (file)
index 0000000..10a370c
--- /dev/null
+++ b/src/common/unicode/norm_test.c
@@ -0,0 +1,80 @@
+/*-------------------------------------------------------------------------
+ * norm_test.c
+ *             Program to test Unicode normalization functions.
+ *
+ * Portions Copyright (c) 2017, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *       src/common/unicode_norm.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres_fe.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "common/unicode_norm.h"
+
+#include "norm_test_table.h"
+
+static char *
+print_wchar_str(const pg_wchar *s)
+{
+#define BUF_DIGITS 50
+       static char buf[BUF_DIGITS * 2 + 1];
+       int                     i;
+
+       i = 0;
+       while (*s && i < BUF_DIGITS)
+       {
+               snprintf(&buf[i * 2], 3, "%04X", *s);
+               i++;
+               s++;
+       }
+       buf[i * 2] = '\0';
+       return buf;
+}
+
+static int
+pg_wcscmp(const pg_wchar *s1, const pg_wchar *s2)
+{
+       for (;;)
+       {
+               if (*s1 < *s2)
+                       return -1;
+               if (*s1 > *s2)
+                       return 1;
+               if (*s1 == 0)
+                       return 0;
+               s1++;
+               s2++;
+       }
+}
+
+int
+main(int argc, char **argv)
+{
+       const pg_unicode_test *test;
+
+       for (test = UnicodeNormalizationTests; test->input[0] != 0; test++)
+       {
+               pg_wchar   *result;
+
+               result = unicode_normalize_kc(test->input);
+
+               if (pg_wcscmp(test->output, result) != 0)
+               {
+                       printf("FAILURE (Normalizationdata.txt line %d):\n", test->linenum);
+                       printf("input:\t%s\n", print_wchar_str(test->input));
+                       printf("expected:\t%s\n", print_wchar_str(test->output));
+                       printf("got\t%s\n", print_wchar_str(result));
+                       printf("\n");
+                       exit(1);
+               }
+       }
+
+       printf("All tests successful!\n");
+       exit(0);
+}

diff --git a/src/common/unicode_norm.c b/src/common/unicode_norm.c
new file mode 100644 (file)
index 0000000..9eddade
--- /dev/null
+++ b/src/common/unicode_norm.c
@@ -0,0 +1,437 @@
+/*-------------------------------------------------------------------------
+ * unicode_norm.c
+ *             Normalize a Unicode string to NFKC form
+ *
+ * This implements Unicode normalization, per the documentation at
+ * http://www.unicode.org/reports/tr15/.
+ *
+ * Portions Copyright (c) 2017, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *       src/common/unicode_norm.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef FRONTEND
+#include "postgres.h"
+#else
+#include "postgres_fe.h"
+#endif
+
+#include "common/unicode_norm.h"
+#include "common/unicode_norm_table.h"
+
+#ifndef FRONTEND
+#define ALLOC(size) palloc(size)
+#define FREE(size) pfree(size)
+#else
+#define ALLOC(size) malloc(size)
+#define FREE(size) free(size)
+#endif
+
+/* Constants for calculations with Hangul characters */
+#define SBASE          0xAC00          /* U+AC00 */
+#define LBASE          0x1100          /* U+1100 */
+#define VBASE          0x1161          /* U+1161 */
+#define TBASE          0x11A7          /* U+11A7 */
+#define LCOUNT         19
+#define VCOUNT         21
+#define TCOUNT         28
+#define NCOUNT         VCOUNT * TCOUNT
+#define SCOUNT         LCOUNT * NCOUNT
+
+/* comparison routine for bsearch() of decomposition lookup table. */
+static int
+conv_compare(const void *p1, const void *p2)
+{
+       uint32          v1,
+                               v2;
+
+       v1 = *(const uint32 *) p1;
+       v2 = ((const pg_unicode_decomposition *) p2)->codepoint;
+       return (v1 > v2) ? 1 : ((v1 == v2) ? 0 : -1);
+}
+
+/*
+ * Get the entry corresponding to code in the decomposition lookup table.
+ */
+static pg_unicode_decomposition *
+get_code_entry(pg_wchar code)
+{
+       return bsearch(&(code),
+                                  (void *) UnicodeDecompMain,
+                                  lengthof(UnicodeDecompMain),
+                                  sizeof(pg_unicode_decomposition),
+                                  conv_compare);
+}
+
+/*
+ * Given a decomposition entry looked up earlier, get the decomposed
+ * characters.
+ *
+ * Note: the returned pointer can point to statically allocated buffer, and
+ * is only valid until next call to this function!
+ */
+static const pg_wchar *
+get_code_decomposition(pg_unicode_decomposition * entry, int *dec_size)
+{
+       static pg_wchar x;
+
+       if (DECOMPOSITION_IS_INLINE(entry))
+       {
+               Assert(DECOMPOSITION_SIZE(entry) == 1);
+               x = (pg_wchar) entry->dec_index;
+               *dec_size = 1;
+               return &x;
+       }
+       else
+       {
+               *dec_size = DECOMPOSITION_SIZE(entry);
+               return &UnicodeDecomp_codepoints[entry->dec_index];
+       }
+}
+
+/*
+ * Calculate how many characters a given character will decompose to.
+ *
+ * This needs to recurse, if the character decomposes into characters that
+ * are, in turn, decomposable.
+ */
+static int
+get_decomposed_size(pg_wchar code)
+{
+       pg_unicode_decomposition *entry;
+       int                     size = 0;
+       int                     i;
+       const uint32 *decomp;
+       int                     dec_size;
+
+       /*
+        * Fast path for Hangul characters not stored in tables to save memory as
+        * decomposition is algorithmic. See
+        * http://unicode.org/reports/tr15/tr15-18.html, annex 10 for details on
+        * the matter.
+        */
+       if (code >= SBASE && code < SBASE + SCOUNT)
+       {
+               uint32          tindex,
+                                       sindex;
+
+               sindex = code - SBASE;
+               tindex = sindex % TCOUNT;
+
+               if (tindex != 0)
+                       return 3;
+               return 2;
+       }
+
+       entry = get_code_entry(code);
+
+       /*
+        * Just count current code if no other decompositions.  A NULL entry is
+        * equivalent to a character with class 0 and no decompositions.
+        */
+       if (entry == NULL || DECOMPOSITION_SIZE(entry) == 0)
+               return 1;
+
+       /*
+        * If this entry has other decomposition codes look at them as well. First
+        * get its decomposition in the list of tables available.
+        */
+       decomp = get_code_decomposition(entry, &dec_size);
+       for (i = 0; i < dec_size; i++)
+       {
+               uint32          lcode = decomp[i];
+
+               size += get_decomposed_size(lcode);
+       }
+
+       return size;
+}
+
+/*
+ * Recompose a set of characters. For hangul characters, the calculation
+ * is algorithmic. For others, an inverse lookup at the decomposition
+ * table is necessary. Returns true if a recomposition can be done, and
+ * false otherwise.
+ */
+static bool
+recompose_code(uint32 start, uint32 code, uint32 *result)
+{
+       /*
+        * Handle Hangul characters algorithmically, per the Unicode spec.
+        *
+        * Check if two current characters are L and V.
+        */
+       if (start >= LBASE && start < LBASE + LCOUNT &&
+               code >= VBASE && code < VBASE + VCOUNT)
+       {
+               /* make syllable of form LV */
+               uint32          lindex = start - LBASE;
+               uint32          vindex = code - VBASE;
+
+               *result = SBASE + (lindex * VCOUNT + vindex) * TCOUNT;
+               return true;
+       }
+       /* Check if two current characters are LV and T */
+       else if (start >= SBASE && start < (SBASE + SCOUNT) &&
+                        ((start - SBASE) % TCOUNT) == 0 &&
+                        code >= TBASE && code < (TBASE + TCOUNT))
+       {
+               /* make syllable of from LVT */
+               uint32          tindex = code - TBASE;
+
+               *result = start + tindex;
+               return true;
+       }
+       else
+       {
+               int                     i;
+
+               /*
+                * Do an inverse lookup of the decomposition tables to see if anything
+                * matches. The comparison just needs to be a perfect match on the
+                * sub-table of size two, because the start character has already been
+                * recomposed partially.
+                */
+               for (i = 0; i < lengthof(UnicodeDecompMain); i++)
+               {
+                       const pg_unicode_decomposition *entry = &UnicodeDecompMain[i];
+
+                       if (DECOMPOSITION_SIZE(entry) != 2)
+                               continue;
+
+                       if (DECOMPOSITION_NO_COMPOSE(entry))
+                               continue;
+
+                       if (start == UnicodeDecomp_codepoints[entry->dec_index] &&
+                               code == UnicodeDecomp_codepoints[entry->dec_index + 1])
+                       {
+                               *result = entry->codepoint;
+                               return true;
+                       }
+               }
+       }
+
+       return false;
+}
+
+/*
+ * Decompose the given code into the array given by caller. The
+ * decomposition begins at the position given by caller, saving one
+ * lookup on the decomposition table. The current position needs to be
+ * updated here to let the caller know from where to continue filling
+ * in the array result.
+ */
+static void
+decompose_code(pg_wchar code, pg_wchar **result, int *current)
+{
+       pg_unicode_decomposition *entry;
+       int                     i;
+       const uint32 *decomp;
+       int                     dec_size;
+
+       /*
+        * Fast path for Hangul characters not stored in tables to save memory as
+        * decomposition is algorithmic. See
+        * http://unicode.org/reports/tr15/tr15-18.html, annex 10 for details on
+        * the matter.
+        */
+       if (code >= SBASE && code < SBASE + SCOUNT)
+       {
+               uint32          l,
+                                       v,
+                                       tindex,
+                                       sindex;
+               pg_wchar   *res = *result;
+
+               sindex = code - SBASE;
+               l = LBASE + sindex / (VCOUNT * TCOUNT);
+               v = VBASE + (sindex % (VCOUNT * TCOUNT)) / TCOUNT;
+               tindex = sindex % TCOUNT;
+
+               res[*current] = l;
+               (*current)++;
+               res[*current] = v;
+               (*current)++;
+
+               if (tindex != 0)
+               {
+                       res[*current] = TBASE + tindex;
+                       (*current)++;
+               }
+
+               return;
+       }
+
+       entry = get_code_entry(code);
+
+       /*
+        * Just fill in with the current decomposition if there are no
+        * decomposition codes to recurse to.  A NULL entry is equivalent to a
+        * character with class 0 and no decompositions, so just leave also in
+        * this case.
+        */
+       if (entry == NULL || DECOMPOSITION_SIZE(entry) == 0)
+       {
+               pg_wchar   *res = *result;
+
+               res[*current] = code;
+               (*current)++;
+               return;
+       }
+
+       /*
+        * If this entry has other decomposition codes look at them as well.
+        */
+       decomp = get_code_decomposition(entry, &dec_size);
+       for (i = 0; i < dec_size; i++)
+       {
+               pg_wchar        lcode = (pg_wchar) decomp[i];
+
+               /* Leave if no more decompositions */
+               decompose_code(lcode, result, current);
+       }
+}
+
+/*
+ * unicode_normalize_kc - Normalize a Unicode string to NFKC form.
+ *
+ * The input is a 0-terminated array of codepoints.
+ *
+ * In frontend, returns a 0-terminated array of codepoints, allocated with
+ * malloc. Or NULL if we run out of memory. In frontend, the returned
+ * string is palloc'd instead, and OOM is reported with ereport().
+ */
+pg_wchar *
+unicode_normalize_kc(const pg_wchar *input)
+{
+       pg_wchar   *decomp_chars;
+       pg_wchar   *recomp_chars;
+       int                     decomp_size,
+                               current_size;
+       int                     count;
+       const pg_wchar *p;
+
+       /* variables for recomposition */
+       int                     last_class;
+       int                     starter_pos;
+       int                     target_pos;
+       uint32          starter_ch;
+
+       /* First, do character decomposition */
+
+       /*
+        * Calculate how many characters long the decomposed version will be.
+        */
+       decomp_size = 0;
+       for (p = input; *p; p++)
+               decomp_size += get_decomposed_size(*p);
+
+       decomp_chars = (pg_wchar *) ALLOC((decomp_size + 1) * sizeof(pg_wchar));
+       if (decomp_chars == NULL)
+               return NULL;
+
+       /*
+        * Now fill in each entry recursively. This needs a second pass on the
+        * decomposition table.
+        */
+       current_size = 0;
+       for (p = input; *p; p++)
+               decompose_code(*p, &decomp_chars, &current_size);
+       decomp_chars[decomp_size] = '\0';
+       Assert(decomp_size == current_size);
+
+       /*
+        * Now apply canonical ordering.
+        */
+       for (count = 1; count < decomp_size; count++)
+       {
+               pg_wchar        prev = decomp_chars[count - 1];
+               pg_wchar        next = decomp_chars[count];
+               pg_wchar        tmp;
+               pg_unicode_decomposition *prevEntry = get_code_entry(prev);
+               pg_unicode_decomposition *nextEntry = get_code_entry(next);
+
+               /*
+                * If no entries are found, the character used is either an Hangul
+                * character or a character with a class of 0 and no decompositions,
+                * so move to next result.
+                */
+               if (prevEntry == NULL || nextEntry == NULL)
+                       continue;
+
+               /*
+                * Per Unicode (http://unicode.org/reports/tr15/tr15-18.html) annex 4,
+                * a sequence of two adjacent characters in a string is an
+                * exchangeable pair if the combining class (from the Unicode
+                * Character Database) for the first character is greater than the
+                * combining class for the second, and the second is not a starter.  A
+                * character is a starter if its combining class is 0.
+                */
+               if (nextEntry->class == 0x0 || prevEntry->class == 0x0)
+                       continue;
+
+               if (prevEntry->class <= nextEntry->class)
+                       continue;
+
+               /* exchange can happen */
+               tmp = decomp_chars[count - 1];
+               decomp_chars[count - 1] = decomp_chars[count];
+               decomp_chars[count] = tmp;
+
+               /* backtrack to check again */
+               if (count > 1)
+                       count -= 2;
+       }
+
+       /*
+        * The last phase of NFKC is the recomposition of the reordered Unicode
+        * string using combining classes. The recomposed string cannot be longer
+        * than the decomposed one, so make the allocation of the output string
+        * based on that assumption.
+        */
+       recomp_chars = (pg_wchar *) ALLOC((decomp_size + 1) * sizeof(pg_wchar));
+       if (!recomp_chars)
+       {
+               FREE(decomp_chars);
+               return NULL;
+       }
+
+       last_class = -1;                        /* this eliminates a special check */
+       starter_pos = 0;
+       target_pos = 1;
+       starter_ch = recomp_chars[0] = decomp_chars[0];
+
+       for (count = 1; count < decomp_size; count++)
+       {
+               pg_wchar        ch = decomp_chars[count];
+               pg_unicode_decomposition *ch_entry = get_code_entry(ch);
+               int                     ch_class = (ch_entry == NULL) ? 0 : ch_entry->class;
+               pg_wchar        composite;
+
+               if (last_class < ch_class &&
+                       recompose_code(starter_ch, ch, &composite))
+               {
+                       recomp_chars[starter_pos] = composite;
+                       starter_ch = composite;
+               }
+               else if (ch_class == 0)
+               {
+                       starter_pos = target_pos;
+                       starter_ch = ch;
+                       last_class = -1;
+                       recomp_chars[target_pos++] = ch;
+               }
+               else
+               {
+                       last_class = ch_class;
+                       recomp_chars[target_pos++] = ch;
+               }
+       }
+       recomp_chars[target_pos] = (pg_wchar) '\0';
+
+       FREE(decomp_chars);
+
+       return recomp_chars;
+}

diff --git a/src/include/common/saslprep.h b/src/include/common/saslprep.h
new file mode 100644 (file)
index 0000000..ec5c8ce
--- /dev/null
+++ b/src/include/common/saslprep.h
@@ -0,0 +1,30 @@
+/*-------------------------------------------------------------------------
+ *
+ * saslprep.h
+ *       SASLprep normalization, for SCRAM authentication
+ *
+ * These definitions are used by both frontend and backend code.
+ *
+ * Copyright (c) 2017, PostgreSQL Global Development Group
+ *
+ * src/include/common/saslprep.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef SASLPREP_H
+#define SASLPREP_H
+
+/*
+ * Return codes for pg_saslprep() function.
+ */
+typedef enum
+{
+       SASLPREP_SUCCESS = 0,
+       SASLPREP_OOM = -1,                      /* out of memory (only in frontend) */
+       SASLPREP_INVALID_UTF8 = -2, /* input is not a valid UTF-8 string */
+       SASLPREP_PROHIBITED = -3        /* output would contain prohibited characters */
+} pg_saslprep_rc;
+
+extern pg_saslprep_rc pg_saslprep(const char *input, char **output);
+
+#endif   /* SASLPREP_H */

diff --git a/src/include/common/unicode_norm.h b/src/include/common/unicode_norm.h
new file mode 100644 (file)
index 0000000..488f964
--- /dev/null
+++ b/src/include/common/unicode_norm.h
@@ -0,0 +1,21 @@
+/*-------------------------------------------------------------------------
+ *
+ * unicode_norm.h
+ *       Routines for normalizing Unicode strings
+ *
+ * These definitions are used by both frontend and backend code.
+ *
+ * Copyright (c) 2017, PostgreSQL Global Development Group
+ *
+ * src/include/common/unicode_norm.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef UNICODE_NORM_H
+#define UNICODE_NORM_H
+
+#include "mb/pg_wchar.h"
+
+extern pg_wchar *unicode_normalize_kc(const pg_wchar *input);
+
+#endif   /* UNICODE_NORM_H */

diff --git a/src/include/common/unicode_norm_table.h b/src/include/common/unicode_norm_table.h
new file mode 100644 (file)
index 0000000..a0181f1
--- /dev/null
+++ b/src/include/common/unicode_norm_table.h
@@ -0,0 +1,8859 @@
+/*-------------------------------------------------------------------------
+ *
+ * unicode_norm_table.h
+ *       Composition table used for Unicode normalization
+ *
+ * Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/common/unicode_norm_table.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+/*
+ * File auto-generated by src/common/unicode/generate-unicode_norm_table.pl,
+ * do not edit. There is deliberately not an #ifndef PG_UNICODE_NORM_TABLE_H
+ * here.
+ */
+typedef struct
+{
+       uint32          codepoint;              /* Unicode codepoint */
+       uint8           class;                  /* combining class of character */
+       uint8           dec_size_flags; /* size and flags of decomposition code list */
+       uint16          dec_index;              /* index into UnicodeDecomp_codepoints, or the
+                                                                * decomposition itself if DECOMP_INLINE */
+} pg_unicode_decomposition;
+
+#define DECOMP_NO_COMPOSE      0x80    /* don't use for re-composition */
+#define DECOMP_INLINE          0x40    /* decomposition is stored inline in dec_index */
+
+#define DECOMPOSITION_SIZE(x) ((x)->dec_size_flags & 0x3F)
+#define DECOMPOSITION_NO_COMPOSE(x) (((x)->dec_size_flags & DECOMP_NO_COMPOSE) != 0)
+#define DECOMPOSITION_IS_INLINE(x) (((x)->dec_size_flags & DECOMP_INLINE) != 0)
+
+/* Table of Unicode codepoints and their decompositions */
+static const pg_unicode_decomposition UnicodeDecompMain[6532] =
+{
+       {0x00A0, 0, 1 | DECOMP_INLINE, 0x0020},
+       {0x00A8, 0, 2 | DECOMP_NO_COMPOSE, 0},          /* compatibility mapping */
+       {0x00AA, 0, 1 | DECOMP_INLINE, 0x0061},
+       {0x00AF, 0, 2 | DECOMP_NO_COMPOSE, 2},          /* compatibility mapping */
+       {0x00B2, 0, 1 | DECOMP_INLINE, 0x0032},
+       {0x00B3, 0, 1 | DECOMP_INLINE, 0x0033},
+       {0x00B4, 0, 2 | DECOMP_NO_COMPOSE, 4},          /* compatibility mapping */
+       {0x00B5, 0, 1 | DECOMP_INLINE, 0x03BC},
+       {0x00B8, 0, 2 | DECOMP_NO_COMPOSE, 6},          /* compatibility mapping */
+       {0x00B9, 0, 1 | DECOMP_INLINE, 0x0031},
+       {0x00BA, 0, 1 | DECOMP_INLINE, 0x006F},
+       {0x00BC, 0, 3, 8},
+       {0x00BD, 0, 3, 11},
+       {0x00BE, 0, 3, 14},
+       {0x00C0, 0, 2, 17},
+       {0x00C1, 0, 2, 19},
+       {0x00C2, 0, 2, 21},
+       {0x00C3, 0, 2, 23},
+       {0x00C4, 0, 2, 25},
+       {0x00C5, 0, 2, 27},
+       {0x00C7, 0, 2, 29},
+       {0x00C8, 0, 2, 31},
+       {0x00C9, 0, 2, 33},
+       {0x00CA, 0, 2, 35},
+       {0x00CB, 0, 2, 37},
+       {0x00CC, 0, 2, 39},
+       {0x00CD, 0, 2, 41},
+       {0x00CE, 0, 2, 43},
+       {0x00CF, 0, 2, 45},
+       {0x00D1, 0, 2, 47},
+       {0x00D2, 0, 2, 49},
+       {0x00D3, 0, 2, 51},
+       {0x00D4, 0, 2, 53},
+       {0x00D5, 0, 2, 55},
+       {0x00D6, 0, 2, 57},
+       {0x00D9, 0, 2, 59},
+       {0x00DA, 0, 2, 61},
+       {0x00DB, 0, 2, 63},
+       {0x00DC, 0, 2, 65},
+       {0x00DD, 0, 2, 67},
+       {0x00E0, 0, 2, 69},
+       {0x00E1, 0, 2, 71},
+       {0x00E2, 0, 2, 73},
+       {0x00E3, 0, 2, 75},
+       {0x00E4, 0, 2, 77},
+       {0x00E5, 0, 2, 79},
+       {0x00E7, 0, 2, 81},
+       {0x00E8, 0, 2, 83},
+       {0x00E9, 0, 2, 85},
+       {0x00EA, 0, 2, 87},
+       {0x00EB, 0, 2, 89},
+       {0x00EC, 0, 2, 91},
+       {0x00ED, 0, 2, 93},
+       {0x00EE, 0, 2, 95},
+       {0x00EF, 0, 2, 97},
+       {0x00F1, 0, 2, 99},
+       {0x00F2, 0, 2, 101},
+       {0x00F3, 0, 2, 103},
+       {0x00F4, 0, 2, 105},
+       {0x00F5, 0, 2, 107},
+       {0x00F6, 0, 2, 109},
+       {0x00F9, 0, 2, 111},
+       {0x00FA, 0, 2, 113},
+       {0x00FB, 0, 2, 115},
+       {0x00FC, 0, 2, 117},
+       {0x00FD, 0, 2, 119},
+       {0x00FF, 0, 2, 121},
+       {0x0100, 0, 2, 123},
+       {0x0101, 0, 2, 125},
+       {0x0102, 0, 2, 127},
+       {0x0103, 0, 2, 129},
+       {0x0104, 0, 2, 131},
+       {0x0105, 0, 2, 133},
+       {0x0106, 0, 2, 135},
+       {0x0107, 0, 2, 137},
+       {0x0108, 0, 2, 139},
+       {0x0109, 0, 2, 141},
+       {0x010A, 0, 2, 143},
+       {0x010B, 0, 2, 145},
+       {0x010C, 0, 2, 147},
+       {0x010D, 0, 2, 149},
+       {0x010E, 0, 2, 151},
+       {0x010F, 0, 2, 153},
+       {0x0112, 0, 2, 155},
+       {0x0113, 0, 2, 157},
+       {0x0114, 0, 2, 159},
+       {0x0115, 0, 2, 161},
+       {0x0116, 0, 2, 163},
+       {0x0117, 0, 2, 165},
+       {0x0118, 0, 2, 167},
+       {0x0119, 0, 2, 169},
+       {0x011A, 0, 2, 171},
+       {0x011B, 0, 2, 173},
+       {0x011C, 0, 2, 175},
+       {0x011D, 0, 2, 177},
+       {0x011E, 0, 2, 179},
+       {0x011F, 0, 2, 181},
+       {0x0120, 0, 2, 183},
+       {0x0121, 0, 2, 185},
+       {0x0122, 0, 2, 187},
+       {0x0123, 0, 2, 189},
+       {0x0124, 0, 2, 191},
+       {0x0125, 0, 2, 193},
+       {0x0128, 0, 2, 195},
+       {0x0129, 0, 2, 197},
+       {0x012A, 0, 2, 199},
+       {0x012B, 0, 2, 201},
+       {0x012C, 0, 2, 203},
+       {0x012D, 0, 2, 205},
+       {0x012E, 0, 2, 207},
+       {0x012F, 0, 2, 209},
+       {0x0130, 0, 2, 211},
+       {0x0132, 0, 2 | DECOMP_NO_COMPOSE, 213},        /* compatibility mapping */
+       {0x0133, 0, 2 | DECOMP_NO_COMPOSE, 215},        /* compatibility mapping */
+       {0x0134, 0, 2, 217},
+       {0x0135, 0, 2, 219},
+       {0x0136, 0, 2, 221},
+       {0x0137, 0, 2, 223},
+       {0x0139, 0, 2, 225},
+       {0x013A, 0, 2, 227},
+       {0x013B, 0, 2, 229},
+       {0x013C, 0, 2, 231},
+       {0x013D, 0, 2, 233},
+       {0x013E, 0, 2, 235},
+       {0x013F, 0, 2 | DECOMP_NO_COMPOSE, 237},        /* compatibility mapping */
+       {0x0140, 0, 2 | DECOMP_NO_COMPOSE, 239},        /* compatibility mapping */
+       {0x0143, 0, 2, 241},
+       {0x0144, 0, 2, 243},
+       {0x0145, 0, 2, 245},
+       {0x0146, 0, 2, 247},
+       {0x0147, 0, 2, 249},
+       {0x0148, 0, 2, 251},
+       {0x0149, 0, 2 | DECOMP_NO_COMPOSE, 253},        /* compatibility mapping */
+       {0x014C, 0, 2, 255},
+       {0x014D, 0, 2, 257},
+       {0x014E, 0, 2, 259},
+       {0x014F, 0, 2, 261},
+       {0x0150, 0, 2, 263},
+       {0x0151, 0, 2, 265},
+       {0x0154, 0, 2, 267},
+       {0x0155, 0, 2, 269},
+       {0x0156, 0, 2, 271},
+       {0x0157, 0, 2, 273},
+       {0x0158, 0, 2, 275},
+       {0x0159, 0, 2, 277},
+       {0x015A, 0, 2, 279},
+       {0x015B, 0, 2, 281},
+       {0x015C, 0, 2, 283},
+       {0x015D, 0, 2, 285},
+       {0x015E, 0, 2, 287},
+       {0x015F, 0, 2, 289},
+       {0x0160, 0, 2, 291},
+       {0x0161, 0, 2, 293},
+       {0x0162, 0, 2, 295},
+       {0x0163, 0, 2, 297},
+       {0x0164, 0, 2, 299},
+       {0x0165, 0, 2, 301},
+       {0x0168, 0, 2, 303},
+       {0x0169, 0, 2, 305},
+       {0x016A, 0, 2, 307},
+       {0x016B, 0, 2, 309},
+       {0x016C, 0, 2, 311},
+       {0x016D, 0, 2, 313},
+       {0x016E, 0, 2, 315},
+       {0x016F, 0, 2, 317},
+       {0x0170, 0, 2, 319},
+       {0x0171, 0, 2, 321},
+       {0x0172, 0, 2, 323},
+       {0x0173, 0, 2, 325},
+       {0x0174, 0, 2, 327},
+       {0x0175, 0, 2, 329},
+       {0x0176, 0, 2, 331},
+       {0x0177, 0, 2, 333},
+       {0x0178, 0, 2, 335},
+       {0x0179, 0, 2, 337},
+       {0x017A, 0, 2, 339},
+       {0x017B, 0, 2, 341},
+       {0x017C, 0, 2, 343},
+       {0x017D, 0, 2, 345},
+       {0x017E, 0, 2, 347},
+       {0x017F, 0, 1 | DECOMP_INLINE, 0x0073},
+       {0x01A0, 0, 2, 349},
+       {0x01A1, 0, 2, 351},
+       {0x01AF, 0, 2, 353},
+       {0x01B0, 0, 2, 355},
+       {0x01C4, 0, 2 | DECOMP_NO_COMPOSE, 357},        /* compatibility mapping */
+       {0x01C5, 0, 2 | DECOMP_NO_COMPOSE, 359},        /* compatibility mapping */
+       {0x01C6, 0, 2 | DECOMP_NO_COMPOSE, 361},        /* compatibility mapping */
+       {0x01C7, 0, 2 | DECOMP_NO_COMPOSE, 363},        /* compatibility mapping */
+       {0x01C8, 0, 2 | DECOMP_NO_COMPOSE, 365},        /* compatibility mapping */
+       {0x01C9, 0, 2 | DECOMP_NO_COMPOSE, 367},        /* compatibility mapping */
+       {0x01CA, 0, 2 | DECOMP_NO_COMPOSE, 369},        /* compatibility mapping */
+       {0x01CB, 0, 2 | DECOMP_NO_COMPOSE, 371},        /* compatibility mapping */
+       {0x01CC, 0, 2 | DECOMP_NO_COMPOSE, 373},        /* compatibility mapping */
+       {0x01CD, 0, 2, 375},
+       {0x01CE, 0, 2, 377},
+       {0x01CF, 0, 2, 379},
+       {0x01D0, 0, 2, 381},
+       {0x01D1, 0, 2, 383},
+       {0x01D2, 0, 2, 385},
+       {0x01D3, 0, 2, 387},
+       {0x01D4, 0, 2, 389},
+       {0x01D5, 0, 2, 391},
+       {0x01D6, 0, 2, 393},
+       {0x01D7, 0, 2, 395},
+       {0x01D8, 0, 2, 397},
+       {0x01D9, 0, 2, 399},
+       {0x01DA, 0, 2, 401},
+       {0x01DB, 0, 2, 403},
+       {0x01DC, 0, 2, 405},
+       {0x01DE, 0, 2, 407},
+       {0x01DF, 0, 2, 409},
+       {0x01E0, 0, 2, 411},
+       {0x01E1, 0, 2, 413},
+       {0x01E2, 0, 2, 415},
+       {0x01E3, 0, 2, 417},
+       {0x01E6, 0, 2, 419},
+       {0x01E7, 0, 2, 421},
+       {0x01E8, 0, 2, 423},
+       {0x01E9, 0, 2, 425},
+       {0x01EA, 0, 2, 427},
+       {0x01EB, 0, 2, 429},
+       {0x01EC, 0, 2, 431},
+       {0x01ED, 0, 2, 433},
+       {0x01EE, 0, 2, 435},
+       {0x01EF, 0, 2, 437},
+       {0x01F0, 0, 2, 439},
+       {0x01F1, 0, 2 | DECOMP_NO_COMPOSE, 441},        /* compatibility mapping */
+       {0x01F2, 0, 2 | DECOMP_NO_COMPOSE, 443},        /* compatibility mapping */
+       {0x01F3, 0, 2 | DECOMP_NO_COMPOSE, 445},        /* compatibility mapping */
+       {0x01F4, 0, 2, 447},
+       {0x01F5, 0, 2, 449},
+       {0x01F8, 0, 2, 451},
+       {0x01F9, 0, 2, 453},
+       {0x01FA, 0, 2, 455},
+       {0x01FB, 0, 2, 457},
+       {0x01FC, 0, 2, 459},
+       {0x01FD, 0, 2, 461},
+       {0x01FE, 0, 2, 463},
+       {0x01FF, 0, 2, 465},
+       {0x0200, 0, 2, 467},
+       {0x0201, 0, 2, 469},
+       {0x0202, 0, 2, 471},
+       {0x0203, 0, 2, 473},
+       {0x0204, 0, 2, 475},
+       {0x0205, 0, 2, 477},
+       {0x0206, 0, 2, 479},
+       {0x0207, 0, 2, 481},
+       {0x0208, 0, 2, 483},
+       {0x0209, 0, 2, 485},
+       {0x020A, 0, 2, 487},
+       {0x020B, 0, 2, 489},
+       {0x020C, 0, 2, 491},
+       {0x020D, 0, 2, 493},
+       {0x020E, 0, 2, 495},
+       {0x020F, 0, 2, 497},
+       {0x0210, 0, 2, 499},
+       {0x0211, 0, 2, 501},
+       {0x0212, 0, 2, 503},
+       {0x0213, 0, 2, 505},
+       {0x0214, 0, 2, 507},
+       {0x0215, 0, 2, 509},
+       {0x0216, 0, 2, 511},
+       {0x0217, 0, 2, 513},
+       {0x0218, 0, 2, 515},
+       {0x0219, 0, 2, 517},
+       {0x021A, 0, 2, 519},
+       {0x021B, 0, 2, 521},
+       {0x021E, 0, 2, 523},
+       {0x021F, 0, 2, 525},
+       {0x0226, 0, 2, 527},
+       {0x0227, 0, 2, 529},
+       {0x0228, 0, 2, 531},
+       {0x0229, 0, 2, 533},
+       {0x022A, 0, 2, 535},
+       {0x022B, 0, 2, 537},
+       {0x022C, 0, 2, 539},
+       {0x022D, 0, 2, 541},
+       {0x022E, 0, 2, 543},
+       {0x022F, 0, 2, 545},
+       {0x0230, 0, 2, 547},
+       {0x0231, 0, 2, 549},
+       {0x0232, 0, 2, 551},
+       {0x0233, 0, 2, 553},
+       {0x02B0, 0, 1 | DECOMP_INLINE, 0x0068},
+       {0x02B1, 0, 1 | DECOMP_INLINE, 0x0266},
+       {0x02B2, 0, 1 | DECOMP_INLINE, 0x006A},
+       {0x02B3, 0, 1 | DECOMP_INLINE, 0x0072},
+       {0x02B4, 0, 1 | DECOMP_INLINE, 0x0279},
+       {0x02B5, 0, 1 | DECOMP_INLINE, 0x027B},
+       {0x02B6, 0, 1 | DECOMP_INLINE, 0x0281},
+       {0x02B7, 0, 1 | DECOMP_INLINE, 0x0077},
+       {0x02B8, 0, 1 | DECOMP_INLINE, 0x0079},
+       {0x02D8, 0, 2 | DECOMP_NO_COMPOSE, 555},        /* compatibility mapping */
+       {0x02D9, 0, 2 | DECOMP_NO_COMPOSE, 557},        /* compatibility mapping */
+       {0x02DA, 0, 2 | DECOMP_NO_COMPOSE, 559},        /* compatibility mapping */
+       {0x02DB, 0, 2 | DECOMP_NO_COMPOSE, 561},        /* compatibility mapping */
+       {0x02DC, 0, 2 | DECOMP_NO_COMPOSE, 563},        /* compatibility mapping */
+       {0x02DD, 0, 2 | DECOMP_NO_COMPOSE, 565},        /* compatibility mapping */
+       {0x02E0, 0, 1 | DECOMP_INLINE, 0x0263},
+       {0x02E1, 0, 1 | DECOMP_INLINE, 0x006C},
+       {0x02E2, 0, 1 | DECOMP_INLINE, 0x0073},
+       {0x02E3, 0, 1 | DECOMP_INLINE, 0x0078},
+       {0x02E4, 0, 1 | DECOMP_INLINE, 0x0295},
+       {0x0300, 230, 0, 0},
+       {0x0301, 230, 0, 0},
+       {0x0302, 230, 0, 0},
+       {0x0303, 230, 0, 0},
+       {0x0304, 230, 0, 0},
+       {0x0305, 230, 0, 0},
+       {0x0306, 230, 0, 0},
+       {0x0307, 230, 0, 0},
+       {0x0308, 230, 0, 0},
+       {0x0309, 230, 0, 0},
+       {0x030A, 230, 0, 0},
+       {0x030B, 230, 0, 0},
+       {0x030C, 230, 0, 0},
+       {0x030D, 230, 0, 0},
+       {0x030E, 230, 0, 0},
+       {0x030F, 230, 0, 0},
+       {0x0310, 230, 0, 0},
+       {0x0311, 230, 0, 0},
+       {0x0312, 230, 0, 0},
+       {0x0313, 230, 0, 0},
+       {0x0314, 230, 0, 0},
+       {0x0315, 232, 0, 0},
+       {0x0316, 220, 0, 0},
+       {0x0317, 220, 0, 0},
+       {0x0318, 220, 0, 0},
+       {0x0319, 220, 0, 0},
+       {0x031A, 232, 0, 0},
+       {0x031B, 216, 0, 0},
+       {0x031C, 220, 0, 0},
+       {0x031D, 220, 0, 0},
+       {0x031E, 220, 0, 0},
+       {0x031F, 220, 0, 0},
+       {0x0320, 220, 0, 0},
+       {0x0321, 202, 0, 0},
+       {0x0322, 202, 0, 0},
+       {0x0323, 220, 0, 0},
+       {0x0324, 220, 0, 0},
+       {0x0325, 220, 0, 0},
+       {0x0326, 220, 0, 0},
+       {0x0327, 202, 0, 0},
+       {0x0328, 202, 0, 0},
+       {0x0329, 220, 0, 0},
+       {0x032A, 220, 0, 0},
+       {0x032B, 220, 0, 0},
+       {0x032C, 220, 0, 0},
+       {0x032D, 220, 0, 0},
+       {0x032E, 220, 0, 0},
+       {0x032F, 220, 0, 0},
+       {0x0330, 220, 0, 0},
+       {0x0331, 220, 0, 0},
+       {0x0332, 220, 0, 0},
+       {0x0333, 220, 0, 0},
+       {0x0334, 1, 0, 0},
+       {0x0335, 1, 0, 0},
+       {0x0336, 1, 0, 0},
+       {0x0337, 1, 0, 0},
+       {0x0338, 1, 0, 0},
+       {0x0339, 220, 0, 0},
+       {0x033A, 220, 0, 0},
+       {0x033B, 220, 0, 0},
+       {0x033C, 220, 0, 0},
+       {0x033D, 230, 0, 0},
+       {0x033E, 230, 0, 0},
+       {0x033F, 230, 0, 0},
+       {0x0340, 230, 1 | DECOMP_INLINE, 0x0300},
+       {0x0341, 230, 1 | DECOMP_INLINE, 0x0301},
+       {0x0342, 230, 0, 0},
+       {0x0343, 230, 1 | DECOMP_INLINE, 0x0313},
+       {0x0344, 230, 2 | DECOMP_NO_COMPOSE, 567},      /* non-starter decomposition */
+       {0x0345, 240, 0, 0},
+       {0x0346, 230, 0, 0},
+       {0x0347, 220, 0, 0},
+       {0x0348, 220, 0, 0},
+       {0x0349, 220, 0, 0},
+       {0x034A, 230, 0, 0},
+       {0x034B, 230, 0, 0},
+       {0x034C, 230, 0, 0},
+       {0x034D, 220, 0, 0},
+       {0x034E, 220, 0, 0},
+       {0x0350, 230, 0, 0},
+       {0x0351, 230, 0, 0},
+       {0x0352, 230, 0, 0},
+       {0x0353, 220, 0, 0},
+       {0x0354, 220, 0, 0},
+       {0x0355, 220, 0, 0},
+       {0x0356, 220, 0, 0},
+       {0x0357, 230, 0, 0},
+       {0x0358, 232, 0, 0},
+       {0x0359, 220, 0, 0},
+       {0x035A, 220, 0, 0},
+       {0x035B, 230, 0, 0},
+       {0x035C, 233, 0, 0},
+       {0x035D, 234, 0, 0},
+       {0x035E, 234, 0, 0},
+       {0x035F, 233, 0, 0},
+       {0x0360, 234, 0, 0},
+       {0x0361, 234, 0, 0},
+       {0x0362, 233, 0, 0},
+       {0x0363, 230, 0, 0},
+       {0x0364, 230, 0, 0},
+       {0x0365, 230, 0, 0},
+       {0x0366, 230, 0, 0},
+       {0x0367, 230, 0, 0},
+       {0x0368, 230, 0, 0},
+       {0x0369, 230, 0, 0},
+       {0x036A, 230, 0, 0},
+       {0x036B, 230, 0, 0},
+       {0x036C, 230, 0, 0},
+       {0x036D, 230, 0, 0},
+       {0x036E, 230, 0, 0},
+       {0x036F, 230, 0, 0},
+       {0x0374, 0, 1 | DECOMP_INLINE, 0x02B9},
+       {0x037A, 0, 2 | DECOMP_NO_COMPOSE, 569},        /* compatibility mapping */
+       {0x037E, 0, 1 | DECOMP_INLINE, 0x003B},
+       {0x0384, 0, 2 | DECOMP_NO_COMPOSE, 571},        /* compatibility mapping */
+       {0x0385, 0, 2, 573},
+       {0x0386, 0, 2, 575},
+       {0x0387, 0, 1 | DECOMP_INLINE, 0x00B7},
+       {0x0388, 0, 2, 577},
+       {0x0389, 0, 2, 579},
+       {0x038A, 0, 2, 581},
+       {0x038C, 0, 2, 583},
+       {0x038E, 0, 2, 585},
+       {0x038F, 0, 2, 587},
+       {0x0390, 0, 2, 589},
+       {0x03AA, 0, 2, 591},
+       {0x03AB, 0, 2, 593},
+       {0x03AC, 0, 2, 595},
+       {0x03AD, 0, 2, 597},
+       {0x03AE, 0, 2, 599},
+       {0x03AF, 0, 2, 601},
+       {0x03B0, 0, 2, 603},
+       {0x03CA, 0, 2, 605},
+       {0x03CB, 0, 2, 607},
+       {0x03CC, 0, 2, 609},
+       {0x03CD, 0, 2, 611},
+       {0x03CE, 0, 2, 613},
+       {0x03D0, 0, 1 | DECOMP_INLINE, 0x03B2},
+       {0x03D1, 0, 1 | DECOMP_INLINE, 0x03B8},
+       {0x03D2, 0, 1 | DECOMP_INLINE, 0x03A5},
+       {0x03D3, 0, 2, 615},
+       {0x03D4, 0, 2, 617},
+       {0x03D5, 0, 1 | DECOMP_INLINE, 0x03C6},
+       {0x03D6, 0, 1 | DECOMP_INLINE, 0x03C0},
+       {0x03F0, 0, 1 | DECOMP_INLINE, 0x03BA},
+       {0x03F1, 0, 1 | DECOMP_INLINE, 0x03C1},
+       {0x03F2, 0, 1 | DECOMP_INLINE, 0x03C2},
+       {0x03F4, 0, 1 | DECOMP_INLINE, 0x0398},
+       {0x03F5, 0, 1 | DECOMP_INLINE, 0x03B5},
+       {0x03F9, 0, 1 | DECOMP_INLINE, 0x03A3},
+       {0x0400, 0, 2, 619},
+       {0x0401, 0, 2, 621},
+       {0x0403, 0, 2, 623},
+       {0x0407, 0, 2, 625},
+       {0x040C, 0, 2, 627},
+       {0x040D, 0, 2, 629},
+       {0x040E, 0, 2, 631},
+       {0x0419, 0, 2, 633},
+       {0x0439, 0, 2, 635},
+       {0x0450, 0, 2, 637},
+       {0x0451, 0, 2, 639},
+       {0x0453, 0, 2, 641},
+       {0x0457, 0, 2, 643},
+       {0x045C, 0, 2, 645},
+       {0x045D, 0, 2, 647},
+       {0x045E, 0, 2, 649},
+       {0x0476, 0, 2, 651},
+       {0x0477, 0, 2, 653},
+       {0x0483, 230, 0, 0},
+       {0x0484, 230, 0, 0},
+       {0x0485, 230, 0, 0},
+       {0x0486, 230, 0, 0},
+       {0x0487, 230, 0, 0},
+       {0x04C1, 0, 2, 655},
+       {0x04C2, 0, 2, 657},
+       {0x04D0, 0, 2, 659},
+       {0x04D1, 0, 2, 661},
+       {0x04D2, 0, 2, 663},
+       {0x04D3, 0, 2, 665},
+       {0x04D6, 0, 2, 667},
+       {0x04D7, 0, 2, 669},
+       {0x04DA, 0, 2, 671},
+       {0x04DB, 0, 2, 673},
+       {0x04DC, 0, 2, 675},
+       {0x04DD, 0, 2, 677},
+       {0x04DE, 0, 2, 679},
+       {0x04DF, 0, 2, 681},
+       {0x04E2, 0, 2, 683},
+       {0x04E3, 0, 2, 685},
+       {0x04E4, 0, 2, 687},
+       {0x04E5, 0, 2, 689},
+       {0x04E6, 0, 2, 691},
+       {0x04E7, 0, 2, 693},
+       {0x04EA, 0, 2, 695},
+       {0x04EB, 0, 2, 697},
+       {0x04EC, 0, 2, 699},
+       {0x04ED, 0, 2, 701},
+       {0x04EE, 0, 2, 703},
+       {0x04EF, 0, 2, 705},
+       {0x04F0, 0, 2, 707},
+       {0x04F1, 0, 2, 709},
+       {0x04F2, 0, 2, 711},
+       {0x04F3, 0, 2, 713},
+       {0x04F4, 0, 2, 715},
+       {0x04F5, 0, 2, 717},
+       {0x04F8, 0, 2, 719},
+       {0x04F9, 0, 2, 721},
+       {0x0587, 0, 2 | DECOMP_NO_COMPOSE, 723},        /* compatibility mapping */
+       {0x0591, 220, 0, 0},
+       {0x0592, 230, 0, 0},
+       {0x0593, 230, 0, 0},
+       {0x0594, 230, 0, 0},
+       {0x0595, 230, 0, 0},
+       {0x0596, 220, 0, 0},
+       {0x0597, 230, 0, 0},
+       {0x0598, 230, 0, 0},
+       {0x0599, 230, 0, 0},
+       {0x059A, 222, 0, 0},
+       {0x059B, 220, 0, 0},
+       {0x059C, 230, 0, 0},
+       {0x059D, 230, 0, 0},
+       {0x059E, 230, 0, 0},
+       {0x059F, 230, 0, 0},
+       {0x05A0, 230, 0, 0},
+       {0x05A1, 230, 0, 0},
+       {0x05A2, 220, 0, 0},
+       {0x05A3, 220, 0, 0},
+       {0x05A4, 220, 0, 0},
+       {0x05A5, 220, 0, 0},
+       {0x05A6, 220, 0, 0},
+       {0x05A7, 220, 0, 0},
+       {0x05A8, 230, 0, 0},
+       {0x05A9, 230, 0, 0},
+       {0x05AA, 220, 0, 0},
+       {0x05AB, 230, 0, 0},
+       {0x05AC, 230, 0, 0},
+       {0x05AD, 222, 0, 0},
+       {0x05AE, 228, 0, 0},
+       {0x05AF, 230, 0, 0},
+       {0x05B0, 10, 0, 0},
+       {0x05B1, 11, 0, 0},
+       {0x05B2, 12, 0, 0},
+       {0x05B3, 13, 0, 0},
+       {0x05B4, 14, 0, 0},
+       {0x05B5, 15, 0, 0},
+       {0x05B6, 16, 0, 0},
+       {0x05B7, 17, 0, 0},
+       {0x05B8, 18, 0, 0},
+       {0x05B9, 19, 0, 0},
+       {0x05BA, 19, 0, 0},
+       {0x05BB, 20, 0, 0},
+       {0x05BC, 21, 0, 0},
+       {0x05BD, 22, 0, 0},
+       {0x05BF, 23, 0, 0},
+       {0x05C1, 24, 0, 0},
+       {0x05C2, 25, 0, 0},
+       {0x05C4, 230, 0, 0},
+       {0x05C5, 220, 0, 0},
+       {0x05C7, 18, 0, 0},
+       {0x0610, 230, 0, 0},
+       {0x0611, 230, 0, 0},
+       {0x0612, 230, 0, 0},
+       {0x0613, 230, 0, 0},
+       {0x0614, 230, 0, 0},
+       {0x0615, 230, 0, 0},
+       {0x0616, 230, 0, 0},
+       {0x0617, 230, 0, 0},
+       {0x0618, 30, 0, 0},
+       {0x0619, 31, 0, 0},
+       {0x061A, 32, 0, 0},
+       {0x0622, 0, 2, 725},
+       {0x0623, 0, 2, 727},
+       {0x0624, 0, 2, 729},
+       {0x0625, 0, 2, 731},
+       {0x0626, 0, 2, 733},
+       {0x064B, 27, 0, 0},
+       {0x064C, 28, 0, 0},
+       {0x064D, 29, 0, 0},
+       {0x064E, 30, 0, 0},
+       {0x064F, 31, 0, 0},
+       {0x0650, 32, 0, 0},
+       {0x0651, 33, 0, 0},
+       {0x0652, 34, 0, 0},
+       {0x0653, 230, 0, 0},
+       {0x0654, 230, 0, 0},
+       {0x0655, 220, 0, 0},
+       {0x0656, 220, 0, 0},
+       {0x0657, 230, 0, 0},
+       {0x0658, 230, 0, 0},
+       {0x0659, 230, 0, 0},
+       {0x065A, 230, 0, 0},
+       {0x065B, 230, 0, 0},
+       {0x065C, 220, 0, 0},
+       {0x065D, 230, 0, 0},
+       {0x065E, 230, 0, 0},
+       {0x065F, 220, 0, 0},
+       {0x0670, 35, 0, 0},
+       {0x0675, 0, 2 | DECOMP_NO_COMPOSE, 735},        /* compatibility mapping */
+       {0x0676, 0, 2 | DECOMP_NO_COMPOSE, 737},        /* compatibility mapping */
+       {0x0677, 0, 2 | DECOMP_NO_COMPOSE, 739},        /* compatibility mapping */
+       {0x0678, 0, 2 | DECOMP_NO_COMPOSE, 741},        /* compatibility mapping */
+       {0x06C0, 0, 2, 743},
+       {0x06C2, 0, 2, 745},
+       {0x06D3, 0, 2, 747},
+       {0x06D6, 230, 0, 0},
+       {0x06D7, 230, 0, 0},
+       {0x06D8, 230, 0, 0},
+       {0x06D9, 230, 0, 0},
+       {0x06DA, 230, 0, 0},
+       {0x06DB, 230, 0, 0},
+       {0x06DC, 230, 0, 0},
+       {0x06DF, 230, 0, 0},
+       {0x06E0, 230, 0, 0},
+       {0x06E1, 230, 0, 0},
+       {0x06E2, 230, 0, 0},
+       {0x06E3, 220, 0, 0},
+       {0x06E4, 230, 0, 0},
+       {0x06E7, 230, 0, 0},
+       {0x06E8, 230, 0, 0},
+       {0x06EA, 220, 0, 0},
+       {0x06EB, 230, 0, 0},
+       {0x06EC, 230, 0, 0},
+       {0x06ED, 220, 0, 0},
+       {0x0711, 36, 0, 0},
+       {0x0730, 230, 0, 0},
+       {0x0731, 220, 0, 0},
+       {0x0732, 230, 0, 0},
+       {0x0733, 230, 0, 0},
+       {0x0734, 220, 0, 0},
+       {0x0735, 230, 0, 0},
+       {0x0736, 230, 0, 0},
+       {0x0737, 220, 0, 0},
+       {0x0738, 220, 0, 0},
+       {0x0739, 220, 0, 0},
+       {0x073A, 230, 0, 0},
+       {0x073B, 220, 0, 0},
+       {0x073C, 220, 0, 0},
+       {0x073D, 230, 0, 0},
+       {0x073E, 220, 0, 0},
+       {0x073F, 230, 0, 0},
+       {0x0740, 230, 0, 0},
+       {0x0741, 230, 0, 0},
+       {0x0742, 220, 0, 0},
+       {0x0743, 230, 0, 0},
+       {0x0744, 220, 0, 0},
+       {0x0745, 230, 0, 0},
+       {0x0746, 220, 0, 0},
+       {0x0747, 230, 0, 0},
+       {0x0748, 220, 0, 0},
+       {0x0749, 230, 0, 0},
+       {0x074A, 230, 0, 0},
+       {0x07EB, 230, 0, 0},
+       {0x07EC, 230, 0, 0},
+       {0x07ED, 230, 0, 0},
+       {0x07EE, 230, 0, 0},
+       {0x07EF, 230, 0, 0},
+       {0x07F0, 230, 0, 0},
+       {0x07F1, 230, 0, 0},
+       {0x07F2, 220, 0, 0},
+       {0x07F3, 230, 0, 0},
+       {0x0816, 230, 0, 0},
+       {0x0817, 230, 0, 0},
+       {0x0818, 230, 0, 0},
+       {0x0819, 230, 0, 0},
+       {0x081B, 230, 0, 0},
+       {0x081C, 230, 0, 0},
+       {0x081D, 230, 0, 0},
+       {0x081E, 230, 0, 0},
+       {0x081F, 230, 0, 0},
+       {0x0820, 230, 0, 0},
+       {0x0821, 230, 0, 0},
+       {0x0822, 230, 0, 0},
+       {0x0823, 230, 0, 0},
+       {0x0825, 230, 0, 0},
+       {0x0826, 230, 0, 0},
+       {0x0827, 230, 0, 0},
+       {0x0829, 230, 0, 0},
+       {0x082A, 230, 0, 0},
+       {0x082B, 230, 0, 0},
+       {0x082C, 230, 0, 0},
+       {0x082D, 230, 0, 0},
+       {0x0859, 220, 0, 0},
+       {0x085A, 220, 0, 0},
+       {0x085B, 220, 0, 0},
+       {0x08D4, 230, 0, 0},
+       {0x08D5, 230, 0, 0},
+       {0x08D6, 230, 0, 0},
+       {0x08D7, 230, 0, 0},
+       {0x08D8, 230, 0, 0},
+       {0x08D9, 230, 0, 0},
+       {0x08DA, 230, 0, 0},
+       {0x08DB, 230, 0, 0},
+       {0x08DC, 230, 0, 0},
+       {0x08DD, 230, 0, 0},
+       {0x08DE, 230, 0, 0},
+       {0x08DF, 230, 0, 0},
+       {0x08E0, 230, 0, 0},
+       {0x08E1, 230, 0, 0},
+       {0x08E3, 220, 0, 0},
+       {0x08E4, 230, 0, 0},
+       {0x08E5, 230, 0, 0},
+       {0x08E6, 220, 0, 0},
+       {0x08E7, 230, 0, 0},
+       {0x08E8, 230, 0, 0},
+       {0x08E9, 220, 0, 0},
+       {0x08EA, 230, 0, 0},
+       {0x08EB, 230, 0, 0},
+       {0x08EC, 230, 0, 0},
+       {0x08ED, 220, 0, 0},
+       {0x08EE, 220, 0, 0},
+       {0x08EF, 220, 0, 0},
+       {0x08F0, 27, 0, 0},
+       {0x08F1, 28, 0, 0},
+       {0x08F2, 29, 0, 0},
+       {0x08F3, 230, 0, 0},
+       {0x08F4, 230, 0, 0},
+       {0x08F5, 230, 0, 0},
+       {0x08F6, 220, 0, 0},
+       {0x08F7, 230, 0, 0},
+       {0x08F8, 230, 0, 0},
+       {0x08F9, 220, 0, 0},
+       {0x08FA, 220, 0, 0},
+       {0x08FB, 230, 0, 0},
+       {0x08FC, 230, 0, 0},
+       {0x08FD, 230, 0, 0},
+       {0x08FE, 230, 0, 0},
+       {0x08FF, 230, 0, 0},
+       {0x0929, 0, 2, 749},
+       {0x0931, 0, 2, 751},
+       {0x0934, 0, 2, 753},
+       {0x093C, 7, 0, 0},
+       {0x094D, 9, 0, 0},
+       {0x0951, 230, 0, 0},
+       {0x0952, 220, 0, 0},
+       {0x0953, 230, 0, 0},
+       {0x0954, 230, 0, 0},
+       {0x0958, 0, 2 | DECOMP_NO_COMPOSE, 755},        /* in exclusion list */
+       {0x0959, 0, 2 | DECOMP_NO_COMPOSE, 757},        /* in exclusion list */
+       {0x095A, 0, 2 | DECOMP_NO_COMPOSE, 759},        /* in exclusion list */
+       {0x095B, 0, 2 | DECOMP_NO_COMPOSE, 761},        /* in exclusion list */
+       {0x095C, 0, 2 | DECOMP_NO_COMPOSE, 763},        /* in exclusion list */
+       {0x095D, 0, 2 | DECOMP_NO_COMPOSE, 765},        /* in exclusion list */
+       {0x095E, 0, 2 | DECOMP_NO_COMPOSE, 767},        /* in exclusion list */
+       {0x095F, 0, 2 | DECOMP_NO_COMPOSE, 769},        /* in exclusion list */
+       {0x09BC, 7, 0, 0},
+       {0x09CB, 0, 2, 771},
+       {0x09CC, 0, 2, 773},
+       {0x09CD, 9, 0, 0},
+       {0x09DC, 0, 2 | DECOMP_NO_COMPOSE, 775},        /* in exclusion list */
+       {0x09DD, 0, 2 | DECOMP_NO_COMPOSE, 777},        /* in exclusion list */
+       {0x09DF, 0, 2 | DECOMP_NO_COMPOSE, 779},        /* in exclusion list */
+       {0x0A33, 0, 2 | DECOMP_NO_COMPOSE, 781},        /* in exclusion list */
+       {0x0A36, 0, 2 | DECOMP_NO_COMPOSE, 783},        /* in exclusion list */
+       {0x0A3C, 7, 0, 0},
+       {0x0A4D, 9, 0, 0},
+       {0x0A59, 0, 2 | DECOMP_NO_COMPOSE, 785},        /* in exclusion list */
+       {0x0A5A, 0, 2 | DECOMP_NO_COMPOSE, 787},        /* in exclusion list */
+       {0x0A5B, 0, 2 | DECOMP_NO_COMPOSE, 789},        /* in exclusion list */
+       {0x0A5E, 0, 2 | DECOMP_NO_COMPOSE, 791},        /* in exclusion list */
+       {0x0ABC, 7, 0, 0},
+       {0x0ACD, 9, 0, 0},
+       {0x0B3C, 7, 0, 0},
+       {0x0B48, 0, 2, 793},
+       {0x0B4B, 0, 2, 795},
+       {0x0B4C, 0, 2, 797},
+       {0x0B4D, 9, 0, 0},
+       {0x0B5C, 0, 2 | DECOMP_NO_COMPOSE, 799},        /* in exclusion list */
+       {0x0B5D, 0, 2 | DECOMP_NO_COMPOSE, 801},        /* in exclusion list */
+       {0x0B94, 0, 2, 803},
+       {0x0BCA, 0, 2, 805},
+       {0x0BCB, 0, 2, 807},
+       {0x0BCC, 0, 2, 809},
+       {0x0BCD, 9, 0, 0},
+       {0x0C48, 0, 2, 811},
+       {0x0C4D, 9, 0, 0},
+       {0x0C55, 84, 0, 0},
+       {0x0C56, 91, 0, 0},
+       {0x0CBC, 7, 0, 0},
+       {0x0CC0, 0, 2, 813},
+       {0x0CC7, 0, 2, 815},
+       {0x0CC8, 0, 2, 817},
+       {0x0CCA, 0, 2, 819},
+       {0x0CCB, 0, 2, 821},
+       {0x0CCD, 9, 0, 0},
+       {0x0D4A, 0, 2, 823},
+       {0x0D4B, 0, 2, 825},
+       {0x0D4C, 0, 2, 827},
+       {0x0D4D, 9, 0, 0},
+       {0x0DCA, 9, 0, 0},
+       {0x0DDA, 0, 2, 829},
+       {0x0DDC, 0, 2, 831},
+       {0x0DDD, 0, 2, 833},
+       {0x0DDE, 0, 2, 835},
+       {0x0E33, 0, 2 | DECOMP_NO_COMPOSE, 837},        /* compatibility mapping */
+       {0x0E38, 103, 0, 0},
+       {0x0E39, 103, 0, 0},
+       {0x0E3A, 9, 0, 0},
+       {0x0E48, 107, 0, 0},
+       {0x0E49, 107, 0, 0},
+       {0x0E4A, 107, 0, 0},
+       {0x0E4B, 107, 0, 0},
+       {0x0EB3, 0, 2 | DECOMP_NO_COMPOSE, 839},        /* compatibility mapping */
+       {0x0EB8, 118, 0, 0},
+       {0x0EB9, 118, 0, 0},
+       {0x0EC8, 122, 0, 0},
+       {0x0EC9, 122, 0, 0},
+       {0x0ECA, 122, 0, 0},
+       {0x0ECB, 122, 0, 0},
+       {0x0EDC, 0, 2 | DECOMP_NO_COMPOSE, 841},        /* compatibility mapping */
+       {0x0EDD, 0, 2 | DECOMP_NO_COMPOSE, 843},        /* compatibility mapping */
+       {0x0F0C, 0, 1 | DECOMP_INLINE, 0x0F0B},
+       {0x0F18, 220, 0, 0},
+       {0x0F19, 220, 0, 0},
+       {0x0F35, 220, 0, 0},
+       {0x0F37, 220, 0, 0},
+       {0x0F39, 216, 0, 0},
+       {0x0F43, 0, 2 | DECOMP_NO_COMPOSE, 845},        /* in exclusion list */
+       {0x0F4D, 0, 2 | DECOMP_NO_COMPOSE, 847},        /* in exclusion list */
+       {0x0F52, 0, 2 | DECOMP_NO_COMPOSE, 849},        /* in exclusion list */
+       {0x0F57, 0, 2 | DECOMP_NO_COMPOSE, 851},        /* in exclusion list */
+       {0x0F5C, 0, 2 | DECOMP_NO_COMPOSE, 853},        /* in exclusion list */
+       {0x0F69, 0, 2 | DECOMP_NO_COMPOSE, 855},        /* in exclusion list */
+       {0x0F71, 129, 0, 0},
+       {0x0F72, 130, 0, 0},
+       {0x0F73, 0, 2 | DECOMP_NO_COMPOSE, 857},        /* non-starter decomposition */
+       {0x0F74, 132, 0, 0},
+       {0x0F75, 0, 2 | DECOMP_NO_COMPOSE, 859},        /* non-starter decomposition */
+       {0x0F76, 0, 2 | DECOMP_NO_COMPOSE, 861},        /* in exclusion list */
+       {0x0F77, 0, 2 | DECOMP_NO_COMPOSE, 863},        /* compatibility mapping */
+       {0x0F78, 0, 2 | DECOMP_NO_COMPOSE, 865},        /* in exclusion list */
+       {0x0F79, 0, 2 | DECOMP_NO_COMPOSE, 867},        /* compatibility mapping */
+       {0x0F7A, 130, 0, 0},
+       {0x0F7B, 130, 0, 0},
+       {0x0F7C, 130, 0, 0},
+       {0x0F7D, 130, 0, 0},
+       {0x0F80, 130, 0, 0},
+       {0x0F81, 0, 2 | DECOMP_NO_COMPOSE, 869},        /* non-starter decomposition */
+       {0x0F82, 230, 0, 0},
+       {0x0F83, 230, 0, 0},
+       {0x0F84, 9, 0, 0},
+       {0x0F86, 230, 0, 0},
+       {0x0F87, 230, 0, 0},
+       {0x0F93, 0, 2 | DECOMP_NO_COMPOSE, 871},        /* in exclusion list */
+       {0x0F9D, 0, 2 | DECOMP_NO_COMPOSE, 873},        /* in exclusion list */
+       {0x0FA2, 0, 2 | DECOMP_NO_COMPOSE, 875},        /* in exclusion list */
+       {0x0FA7, 0, 2 | DECOMP_NO_COMPOSE, 877},        /* in exclusion list */
+       {0x0FAC, 0, 2 | DECOMP_NO_COMPOSE, 879},        /* in exclusion list */
+       {0x0FB9, 0, 2 | DECOMP_NO_COMPOSE, 881},        /* in exclusion list */
+       {0x0FC6, 220, 0, 0},
+       {0x1026, 0, 2, 883},
+       {0x1037, 7, 0, 0},
+       {0x1039, 9, 0, 0},
+       {0x103A, 9, 0, 0},
+       {0x108D, 220, 0, 0},
+       {0x10FC, 0, 1 | DECOMP_INLINE, 0x10DC},
+       {0x135D, 230, 0, 0},
+       {0x135E, 230, 0, 0},
+       {0x135F, 230, 0, 0},
+       {0x1714, 9, 0, 0},
+       {0x1734, 9, 0, 0},
+       {0x17D2, 9, 0, 0},
+       {0x17DD, 230, 0, 0},
+       {0x18A9, 228, 0, 0},
+       {0x1939, 222, 0, 0},
+       {0x193A, 230, 0, 0},
+       {0x193B, 220, 0, 0},
+       {0x1A17, 230, 0, 0},
+       {0x1A18, 220, 0, 0},
+       {0x1A60, 9, 0, 0},
+       {0x1A75, 230, 0, 0},
+       {0x1A76, 230, 0, 0},
+       {0x1A77, 230, 0, 0},
+       {0x1A78, 230, 0, 0},
+       {0x1A79, 230, 0, 0},
+       {0x1A7A, 230, 0, 0},
+       {0x1A7B, 230, 0, 0},
+       {0x1A7C, 230, 0, 0},
+       {0x1A7F, 220, 0, 0},
+       {0x1AB0, 230, 0, 0},
+       {0x1AB1, 230, 0, 0},
+       {0x1AB2, 230, 0, 0},
+       {0x1AB3, 230, 0, 0},
+       {0x1AB4, 230, 0, 0},
+       {0x1AB5, 220, 0, 0},
+       {0x1AB6, 220, 0, 0},
+       {0x1AB7, 220, 0, 0},
+       {0x1AB8, 220, 0, 0},
+       {0x1AB9, 220, 0, 0},
+       {0x1ABA, 220, 0, 0},
+       {0x1ABB, 230, 0, 0},
+       {0x1ABC, 230, 0, 0},
+       {0x1ABD, 220, 0, 0},
+       {0x1B06, 0, 2, 885},
+       {0x1B08, 0, 2, 887},
+       {0x1B0A, 0, 2, 889},
+       {0x1B0C, 0, 2, 891},
+       {0x1B0E, 0, 2, 893},
+       {0x1B12, 0, 2, 895},
+       {0x1B34, 7, 0, 0},
+       {0x1B3B, 0, 2, 897},
+       {0x1B3D, 0, 2, 899},
+       {0x1B40, 0, 2, 901},
+       {0x1B41, 0, 2, 903},
+       {0x1B43, 0, 2, 905},
+       {0x1B44, 9, 0, 0},
+       {0x1B6B, 230, 0, 0},
+       {0x1B6C, 220, 0, 0},
+       {0x1B6D, 230, 0, 0},
+       {0x1B6E, 230, 0, 0},
+       {0x1B6F, 230, 0, 0},
+       {0x1B70, 230, 0, 0},
+       {0x1B71, 230, 0, 0},
+       {0x1B72, 230, 0, 0},
+       {0x1B73, 230, 0, 0},
+       {0x1BAA, 9, 0, 0},
+       {0x1BAB, 9, 0, 0},
+       {0x1BE6, 7, 0, 0},
+       {0x1BF2, 9, 0, 0},
+       {0x1BF3, 9, 0, 0},
+       {0x1C37, 7, 0, 0},
+       {0x1CD0, 230, 0, 0},
+       {0x1CD1, 230, 0, 0},
+       {0x1CD2, 230, 0, 0},
+       {0x1CD4, 1, 0, 0},
+       {0x1CD5, 220, 0, 0},
+       {0x1CD6, 220, 0, 0},
+       {0x1CD7, 220, 0, 0},
+       {0x1CD8, 220, 0, 0},
+       {0x1CD9, 220, 0, 0},
+       {0x1CDA, 230, 0, 0},
+       {0x1CDB, 230, 0, 0},
+       {0x1CDC, 220, 0, 0},
+       {0x1CDD, 220, 0, 0},
+       {0x1CDE, 220, 0, 0},
+       {0x1CDF, 220, 0, 0},
+       {0x1CE0, 230, 0, 0},
+       {0x1CE2, 1, 0, 0},
+       {0x1CE3, 1, 0, 0},
+       {0x1CE4, 1, 0, 0},
+       {0x1CE5, 1, 0, 0},
+       {0x1CE6, 1, 0, 0},
+       {0x1CE7, 1, 0, 0},
+       {0x1CE8, 1, 0, 0},
+       {0x1CED, 220, 0, 0},
+       {0x1CF4, 230, 0, 0},
+       {0x1CF8, 230, 0, 0},
+       {0x1CF9, 230, 0, 0},
+       {0x1D2C, 0, 1 | DECOMP_INLINE, 0x0041},
+       {0x1D2D, 0, 1 | DECOMP_INLINE, 0x00C6},
+       {0x1D2E, 0, 1 | DECOMP_INLINE, 0x0042},
+       {0x1D30, 0, 1 | DECOMP_INLINE, 0x0044},
+       {0x1D31, 0, 1 | DECOMP_INLINE, 0x0045},
+       {0x1D32, 0, 1 | DECOMP_INLINE, 0x018E},
+       {0x1D33, 0, 1 | DECOMP_INLINE, 0x0047},
+       {0x1D34, 0, 1 | DECOMP_INLINE, 0x0048},
+       {0x1D35, 0, 1 | DECOMP_INLINE, 0x0049},
+       {0x1D36, 0, 1 | DECOMP_INLINE, 0x004A},
+       {0x1D37, 0, 1 | DECOMP_INLINE, 0x004B},
+       {0x1D38, 0, 1 | DECOMP_INLINE, 0x004C},
+       {0x1D39, 0, 1 | DECOMP_INLINE, 0x004D},
+       {0x1D3A, 0, 1 | DECOMP_INLINE, 0x004E},
+       {0x1D3C, 0, 1 | DECOMP_INLINE, 0x004F},
+       {0x1D3D, 0, 1 | DECOMP_INLINE, 0x0222},
+       {0x1D3E, 0, 1 | DECOMP_INLINE, 0x0050},
+       {0x1D3F, 0, 1 | DECOMP_INLINE, 0x0052},
+       {0x1D40, 0, 1 | DECOMP_INLINE, 0x0054},
+       {0x1D41, 0, 1 | DECOMP_INLINE, 0x0055},
+       {0x1D42, 0, 1 | DECOMP_INLINE, 0x0057},
+       {0x1D43, 0, 1 | DECOMP_INLINE, 0x0061},
+       {0x1D44, 0, 1 | DECOMP_INLINE, 0x0250},
+       {0x1D45, 0, 1 | DECOMP_INLINE, 0x0251},
+       {0x1D46, 0, 1 | DECOMP_INLINE, 0x1D02},
+       {0x1D47, 0, 1 | DECOMP_INLINE, 0x0062},
+       {0x1D48, 0, 1 | DECOMP_INLINE, 0x0064},
+       {0x1D49, 0, 1 | DECOMP_INLINE, 0x0065},
+       {0x1D4A, 0, 1 | DECOMP_INLINE, 0x0259},
+       {0x1D4B, 0, 1 | DECOMP_INLINE, 0x025B},
+       {0x1D4C, 0, 1 | DECOMP_INLINE, 0x025C},
+       {0x1D4D, 0, 1 | DECOMP_INLINE, 0x0067},
+       {0x1D4F, 0, 1 | DECOMP_INLINE, 0x006B},
+       {0x1D50, 0, 1 | DECOMP_INLINE, 0x006D},
+       {0x1D51, 0, 1 | DECOMP_INLINE, 0x014B},
+       {0x1D52, 0, 1 | DECOMP_INLINE, 0x006F},
+       {0x1D53, 0, 1 | DECOMP_INLINE, 0x0254},
+       {0x1D54, 0, 1 | DECOMP_INLINE, 0x1D16},
+       {0x1D55, 0, 1 | DECOMP_INLINE, 0x1D17},
+       {0x1D56, 0, 1 | DECOMP_INLINE, 0x0070},
+       {0x1D57, 0, 1 | DECOMP_INLINE, 0x0074},
+       {0x1D58, 0, 1 | DECOMP_INLINE, 0x0075},
+       {0x1D59, 0, 1 | DECOMP_INLINE, 0x1D1D},
+       {0x1D5A, 0, 1 | DECOMP_INLINE, 0x026F},
+       {0x1D5B, 0, 1 | DECOMP_INLINE, 0x0076},
+       {0x1D5C, 0, 1 | DECOMP_INLINE, 0x1D25},
+       {0x1D5D, 0, 1 | DECOMP_INLINE, 0x03B2},
+       {0x1D5E, 0, 1 | DECOMP_INLINE, 0x03B3},
+       {0x1D5F, 0, 1 | DECOMP_INLINE, 0x03B4},
+       {0x1D60, 0, 1 | DECOMP_INLINE, 0x03C6},
+       {0x1D61, 0, 1 | DECOMP_INLINE, 0x03C7},
+       {0x1D62, 0, 1 | DECOMP_INLINE, 0x0069},
+       {0x1D63, 0, 1 | DECOMP_INLINE, 0x0072},
+       {0x1D64, 0, 1 | DECOMP_INLINE, 0x0075},
+       {0x1D65, 0, 1 | DECOMP_INLINE, 0x0076},
+       {0x1D66, 0, 1 | DECOMP_INLINE, 0x03B2},
+       {0x1D67, 0, 1 | DECOMP_INLINE, 0x03B3},
+       {0x1D68, 0, 1 | DECOMP_INLINE, 0x03C1},
+       {0x1D69, 0, 1 | DECOMP_INLINE, 0x03C6},
+       {0x1D6A, 0, 1 | DECOMP_INLINE, 0x03C7},
+       {0x1D78, 0, 1 | DECOMP_INLINE, 0x043D},
+       {0x1D9B, 0, 1 | DECOMP_INLINE, 0x0252},
+       {0x1D9C, 0, 1 | DECOMP_INLINE, 0x0063},
+       {0x1D9D, 0, 1 | DECOMP_INLINE, 0x0255},
+       {0x1D9E, 0, 1 | DECOMP_INLINE, 0x00F0},
+       {0x1D9F, 0, 1 | DECOMP_INLINE, 0x025C},
+       {0x1DA0, 0, 1 | DECOMP_INLINE, 0x0066},
+       {0x1DA1, 0, 1 | DECOMP_INLINE, 0x025F},
+       {0x1DA2, 0, 1 | DECOMP_INLINE, 0x0261},
+       {0x1DA3, 0, 1 | DECOMP_INLINE, 0x0265},
+       {0x1DA4, 0, 1 | DECOMP_INLINE, 0x0268},
+       {0x1DA5, 0, 1 | DECOMP_INLINE, 0x0269},
+       {0x1DA6, 0, 1 | DECOMP_INLINE, 0x026A},
+       {0x1DA7, 0, 1 | DECOMP_INLINE, 0x1D7B},
+       {0x1DA8, 0, 1 | DECOMP_INLINE, 0x029D},
+       {0x1DA9, 0, 1 | DECOMP_INLINE, 0x026D},
+       {0x1DAA, 0, 1 | DECOMP_INLINE, 0x1D85},
+       {0x1DAB, 0, 1 | DECOMP_INLINE, 0x029F},
+       {0x1DAC, 0, 1 | DECOMP_INLINE, 0x0271},
+       {0x1DAD, 0, 1 | DECOMP_INLINE, 0x0270},
+       {0x1DAE, 0, 1 | DECOMP_INLINE, 0x0272},
+       {0x1DAF, 0, 1 | DECOMP_INLINE, 0x0273},
+       {0x1DB0, 0, 1 | DECOMP_INLINE, 0x0274},
+       {0x1DB1, 0, 1 | DECOMP_INLINE, 0x0275},
+       {0x1DB2, 0, 1 | DECOMP_INLINE, 0x0278},
+       {0x1DB3, 0, 1 | DECOMP_INLINE, 0x0282},
+       {0x1DB4, 0, 1 | DECOMP_INLINE, 0x0283},
+       {0x1DB5, 0, 1 | DECOMP_INLINE, 0x01AB},
+       {0x1DB6, 0, 1 | DECOMP_INLINE, 0x0289},
+       {0x1DB7, 0, 1 | DECOMP_INLINE, 0x028A},
+       {0x1DB8, 0, 1 | DECOMP_INLINE, 0x1D1C},
+       {0x1DB9, 0, 1 | DECOMP_INLINE, 0x028B},
+       {0x1DBA, 0, 1 | DECOMP_INLINE, 0x028C},
+       {0x1DBB, 0, 1 | DECOMP_INLINE, 0x007A},
+       {0x1DBC, 0, 1 | DECOMP_INLINE, 0x0290},
+       {0x1DBD, 0, 1 | DECOMP_INLINE, 0x0291},
+       {0x1DBE, 0, 1 | DECOMP_INLINE, 0x0292},
+       {0x1DBF, 0, 1 | DECOMP_INLINE, 0x03B8},
+       {0x1DC0, 230, 0, 0},
+       {0x1DC1, 230, 0, 0},
+       {0x1DC2, 220, 0, 0},
+       {0x1DC3, 230, 0, 0},
+       {0x1DC4, 230, 0, 0},
+       {0x1DC5, 230, 0, 0},
+       {0x1DC6, 230, 0, 0},
+       {0x1DC7, 230, 0, 0},
+       {0x1DC8, 230, 0, 0},
+       {0x1DC9, 230, 0, 0},
+       {0x1DCA, 220, 0, 0},
+       {0x1DCB, 230, 0, 0},
+       {0x1DCC, 230, 0, 0},
+       {0x1DCD, 234, 0, 0},
+       {0x1DCE, 214, 0, 0},
+       {0x1DCF, 220, 0, 0},
+       {0x1DD0, 202, 0, 0},
+       {0x1DD1, 230, 0, 0},
+       {0x1DD2, 230, 0, 0},
+       {0x1DD3, 230, 0, 0},
+       {0x1DD4, 230, 0, 0},
+       {0x1DD5, 230, 0, 0},
+       {0x1DD6, 230, 0, 0},
+       {0x1DD7, 230, 0, 0},
+       {0x1DD8, 230, 0, 0},
+       {0x1DD9, 230, 0, 0},
+       {0x1DDA, 230, 0, 0},
+       {0x1DDB, 230, 0, 0},
+       {0x1DDC, 230, 0, 0},
+       {0x1DDD, 230, 0, 0},
+       {0x1DDE, 230, 0, 0},
+       {0x1DDF, 230, 0, 0},
+       {0x1DE0, 230, 0, 0},
+       {0x1DE1, 230, 0, 0},
+       {0x1DE2, 230, 0, 0},
+       {0x1DE3, 230, 0, 0},
+       {0x1DE4, 230, 0, 0},
+       {0x1DE5, 230, 0, 0},
+       {0x1DE6, 230, 0, 0},
+       {0x1DE7, 230, 0, 0},
+       {0x1DE8, 230, 0, 0},
+       {0x1DE9, 230, 0, 0},
+       {0x1DEA, 230, 0, 0},
+       {0x1DEB, 230, 0, 0},
+       {0x1DEC, 230, 0, 0},
+       {0x1DED, 230, 0, 0},
+       {0x1DEE, 230, 0, 0},
+       {0x1DEF, 230, 0, 0},
+       {0x1DF0, 230, 0, 0},
+       {0x1DF1, 230, 0, 0},
+       {0x1DF2, 230, 0, 0},
+       {0x1DF3, 230, 0, 0},
+       {0x1DF4, 230, 0, 0},
+       {0x1DF5, 230, 0, 0},
+       {0x1DFB, 230, 0, 0},
+       {0x1DFC, 233, 0, 0},
+       {0x1DFD, 220, 0, 0},
+       {0x1DFE, 230, 0, 0},
+       {0x1DFF, 220, 0, 0},
+       {0x1E00, 0, 2, 907},
+       {0x1E01, 0, 2, 909},
+       {0x1E02, 0, 2, 911},
+       {0x1E03, 0, 2, 913},
+       {0x1E04, 0, 2, 915},
+       {0x1E05, 0, 2, 917},
+       {0x1E06, 0, 2, 919},
+       {0x1E07, 0, 2, 921},
+       {0x1E08, 0, 2, 923},
+       {0x1E09, 0, 2, 925},
+       {0x1E0A, 0, 2, 927},
+       {0x1E0B, 0, 2, 929},
+       {0x1E0C, 0, 2, 931},
+       {0x1E0D, 0, 2, 933},
+       {0x1E0E, 0, 2, 935},
+       {0x1E0F, 0, 2, 937},
+       {0x1E10, 0, 2, 939},
+       {0x1E11, 0, 2, 941},
+       {0x1E12, 0, 2, 943},
+       {0x1E13, 0, 2, 945},
+       {0x1E14, 0, 2, 947},
+       {0x1E15, 0, 2, 949},
+       {0x1E16, 0, 2, 951},
+       {0x1E17, 0, 2, 953},
+       {0x1E18, 0, 2, 955},
+       {0x1E19, 0, 2, 957},
+       {0x1E1A, 0, 2, 959},
+       {0x1E1B, 0, 2, 961},
+       {0x1E1C, 0, 2, 963},
+       {0x1E1D, 0, 2, 965},
+       {0x1E1E, 0, 2, 967},
+       {0x1E1F, 0, 2, 969},
+       {0x1E20, 0, 2, 971},
+       {0x1E21, 0, 2, 973},
+       {0x1E22, 0, 2, 975},
+       {0x1E23, 0, 2, 977},
+       {0x1E24, 0, 2, 979},
+       {0x1E25, 0, 2, 981},
+       {0x1E26, 0, 2, 983},
+       {0x1E27, 0, 2, 985},
+       {0x1E28, 0, 2, 987},
+       {0x1E29, 0, 2, 989},
+       {0x1E2A, 0, 2, 991},
+       {0x1E2B, 0, 2, 993},
+       {0x1E2C, 0, 2, 995},
+       {0x1E2D, 0, 2, 997},
+       {0x1E2E, 0, 2, 999},
+       {0x1E2F, 0, 2, 1001},
+       {0x1E30, 0, 2, 1003},
+       {0x1E31, 0, 2, 1005},
+       {0x1E32, 0, 2, 1007},
+       {0x1E33, 0, 2, 1009},
+       {0x1E34, 0, 2, 1011},
+       {0x1E35, 0, 2, 1013},
+       {0x1E36, 0, 2, 1015},
+       {0x1E37, 0, 2, 1017},
+       {0x1E38, 0, 2, 1019},
+       {0x1E39, 0, 2, 1021},
+       {0x1E3A, 0, 2, 1023},
+       {0x1E3B, 0, 2, 1025},
+       {0x1E3C, 0, 2, 1027},
+       {0x1E3D, 0, 2, 1029},
+       {0x1E3E, 0, 2, 1031},
+       {0x1E3F, 0, 2, 1033},
+       {0x1E40, 0, 2, 1035},
+       {0x1E41, 0, 2, 1037},
+       {0x1E42, 0, 2, 1039},
+       {0x1E43, 0, 2, 1041},
+       {0x1E44, 0, 2, 1043},
+       {0x1E45, 0, 2, 1045},
+       {0x1E46, 0, 2, 1047},
+       {0x1E47, 0, 2, 1049},
+       {0x1E48, 0, 2, 1051},
+       {0x1E49, 0, 2, 1053},
+       {0x1E4A, 0, 2, 1055},
+       {0x1E4B, 0, 2, 1057},
+       {0x1E4C, 0, 2, 1059},
+       {0x1E4D, 0, 2, 1061},
+       {0x1E4E, 0, 2, 1063},
+       {0x1E4F, 0, 2, 1065},
+       {0x1E50, 0, 2, 1067},
+       {0x1E51, 0, 2, 1069},
+       {0x1E52, 0, 2, 1071},
+       {0x1E53, 0, 2, 1073},
+       {0x1E54, 0, 2, 1075},
+       {0x1E55, 0, 2, 1077},
+       {0x1E56, 0, 2, 1079},
+       {0x1E57, 0, 2, 1081},
+       {0x1E58, 0, 2, 1083},
+       {0x1E59, 0, 2, 1085},
+       {0x1E5A, 0, 2, 1087},
+       {0x1E5B, 0, 2, 1089},
+       {0x1E5C, 0, 2, 1091},
+       {0x1E5D, 0, 2, 1093},
+       {0x1E5E, 0, 2, 1095},
+       {0x1E5F, 0, 2, 1097},
+       {0x1E60, 0, 2, 1099},
+       {0x1E61, 0, 2, 1101},
+       {0x1E62, 0, 2, 1103},
+       {0x1E63, 0, 2, 1105},
+       {0x1E64, 0, 2, 1107},
+       {0x1E65, 0, 2, 1109},
+       {0x1E66, 0, 2, 1111},
+       {0x1E67, 0, 2, 1113},
+       {0x1E68, 0, 2, 1115},
+       {0x1E69, 0, 2, 1117},
+       {0x1E6A, 0, 2, 1119},
+       {0x1E6B, 0, 2, 1121},
+       {0x1E6C, 0, 2, 1123},
+       {0x1E6D, 0, 2, 1125},
+       {0x1E6E, 0, 2, 1127},
+       {0x1E6F, 0, 2, 1129},
+       {0x1E70, 0, 2, 1131},
+       {0x1E71, 0, 2, 1133},
+       {0x1E72, 0, 2, 1135},
+       {0x1E73, 0, 2, 1137},
+       {0x1E74, 0, 2, 1139},
+       {0x1E75, 0, 2, 1141},
+       {0x1E76, 0, 2, 1143},
+       {0x1E77, 0, 2, 1145},
+       {0x1E78, 0, 2, 1147},
+       {0x1E79, 0, 2, 1149},
+       {0x1E7A, 0, 2, 1151},
+       {0x1E7B, 0, 2, 1153},
+       {0x1E7C, 0, 2, 1155},
+       {0x1E7D, 0, 2, 1157},
+       {0x1E7E, 0, 2, 1159},
+       {0x1E7F, 0, 2, 1161},
+       {0x1E80, 0, 2, 1163},
+       {0x1E81, 0, 2, 1165},
+       {0x1E82, 0, 2, 1167},
+       {0x1E83, 0, 2, 1169},
+       {0x1E84, 0, 2, 1171},
+       {0x1E85, 0, 2, 1173},
+       {0x1E86, 0, 2, 1175},
+       {0x1E87, 0, 2, 1177},
+       {0x1E88, 0, 2, 1179},
+       {0x1E89, 0, 2, 1181},
+       {0x1E8A, 0, 2, 1183},
+       {0x1E8B, 0, 2, 1185},
+       {0x1E8C, 0, 2, 1187},
+       {0x1E8D, 0, 2, 1189},
+       {0x1E8E, 0, 2, 1191},
+       {0x1E8F, 0, 2, 1193},
+       {0x1E90, 0, 2, 1195},
+       {0x1E91, 0, 2, 1197},
+       {0x1E92, 0, 2, 1199},
+       {0x1E93, 0, 2, 1201},
+       {0x1E94, 0, 2, 1203},
+       {0x1E95, 0, 2, 1205},
+       {0x1E96, 0, 2, 1207},
+       {0x1E97, 0, 2, 1209},
+       {0x1E98, 0, 2, 1211},
+       {0x1E99, 0, 2, 1213},
+       {0x1E9A, 0, 2 | DECOMP_NO_COMPOSE, 1215},       /* compatibility mapping */
+       {0x1E9B, 0, 2, 1217},
+       {0x1EA0, 0, 2, 1219},
+       {0x1EA1, 0, 2, 1221},
+       {0x1EA2, 0, 2, 1223},
+       {0x1EA3, 0, 2, 1225},
+       {0x1EA4, 0, 2, 1227},
+       {0x1EA5, 0, 2, 1229},
+       {0x1EA6, 0, 2, 1231},
+       {0x1EA7, 0, 2, 1233},
+       {0x1EA8, 0, 2, 1235},
+       {0x1EA9, 0, 2, 1237},
+       {0x1EAA, 0, 2, 1239},
+       {0x1EAB, 0, 2, 1241},
+       {0x1EAC, 0, 2, 1243},
+       {0x1EAD, 0, 2, 1245},
+       {0x1EAE, 0, 2, 1247},
+       {0x1EAF, 0, 2, 1249},
+       {0x1EB0, 0, 2, 1251},
+       {0x1EB1, 0, 2, 1253},
+       {0x1EB2, 0, 2, 1255},
+       {0x1EB3, 0, 2, 1257},
+       {0x1EB4, 0, 2, 1259},
+       {0x1EB5, 0, 2, 1261},
+       {0x1EB6, 0, 2, 1263},
+       {0x1EB7, 0, 2, 1265},
+       {0x1EB8, 0, 2, 1267},
+       {0x1EB9, 0, 2, 1269},
+       {0x1EBA, 0, 2, 1271},
+       {0x1EBB, 0, 2, 1273},
+       {0x1EBC, 0, 2, 1275},
+       {0x1EBD, 0, 2, 1277},
+       {0x1EBE, 0, 2, 1279},
+       {0x1EBF, 0, 2, 1281},
+       {0x1EC0, 0, 2, 1283},
+       {0x1EC1, 0, 2, 1285},
+       {0x1EC2, 0, 2, 1287},
+       {0x1EC3, 0, 2, 1289},
+       {0x1EC4, 0, 2, 1291},
+       {0x1EC5, 0, 2, 1293},
+       {0x1EC6, 0, 2, 1295},
+       {0x1EC7, 0, 2, 1297},
+       {0x1EC8, 0, 2, 1299},
+       {0x1EC9, 0, 2, 1301},
+       {0x1ECA, 0, 2, 1303},
+       {0x1ECB, 0, 2, 1305},
+       {0x1ECC, 0, 2, 1307},
+       {0x1ECD, 0, 2, 1309},
+       {0x1ECE, 0, 2, 1311},
+       {0x1ECF, 0, 2, 1313},
+       {0x1ED0, 0, 2, 1315},
+       {0x1ED1, 0, 2, 1317},
+       {0x1ED2, 0, 2, 1319},
+       {0x1ED3, 0, 2, 1321},
+       {0x1ED4, 0, 2, 1323},
+       {0x1ED5, 0, 2, 1325},
+       {0x1ED6, 0, 2, 1327},
+       {0x1ED7, 0, 2, 1329},
+       {0x1ED8, 0, 2, 1331},
+       {0x1ED9, 0, 2, 1333},
+       {0x1EDA, 0, 2, 1335},
+       {0x1EDB, 0, 2, 1337},
+       {0x1EDC, 0, 2, 1339},
+       {0x1EDD, 0, 2, 1341},
+       {0x1EDE, 0, 2, 1343},
+       {0x1EDF, 0, 2, 1345},
+       {0x1EE0, 0, 2, 1347},
+       {0x1EE1, 0, 2, 1349},
+       {0x1EE2, 0, 2, 1351},
+       {0x1EE3, 0, 2, 1353},
+       {0x1EE4, 0, 2, 1355},
+       {0x1EE5, 0, 2, 1357},
+       {0x1EE6, 0, 2, 1359},
+       {0x1EE7, 0, 2, 1361},
+       {0x1EE8, 0, 2, 1363},
+       {0x1EE9, 0, 2, 1365},
+       {0x1EEA, 0, 2, 1367},
+       {0x1EEB, 0, 2, 1369},
+       {0x1EEC, 0, 2, 1371},
+       {0x1EED, 0, 2, 1373},
+       {0x1EEE, 0, 2, 1375},
+       {0x1EEF, 0, 2, 1377},
+       {0x1EF0, 0, 2, 1379},
+       {0x1EF1, 0, 2, 1381},
+       {0x1EF2, 0, 2, 1383},
+       {0x1EF3, 0, 2, 1385},
+       {0x1EF4, 0, 2, 1387},
+       {0x1EF5, 0, 2, 1389},
+       {0x1EF6, 0, 2, 1391},
+       {0x1EF7, 0, 2, 1393},
+       {0x1EF8, 0, 2, 1395},
+       {0x1EF9, 0, 2, 1397},
+       {0x1F00, 0, 2, 1399},
+       {0x1F01, 0, 2, 1401},
+       {0x1F02, 0, 2, 1403},
+       {0x1F03, 0, 2, 1405},
+       {0x1F04, 0, 2, 1407},
+       {0x1F05, 0, 2, 1409},
+       {0x1F06, 0, 2, 1411},
+       {0x1F07, 0, 2, 1413},
+       {0x1F08, 0, 2, 1415},
+       {0x1F09, 0, 2, 1417},
+       {0x1F0A, 0, 2, 1419},
+       {0x1F0B, 0, 2, 1421},
+       {0x1F0C, 0, 2, 1423},
+       {0x1F0D, 0, 2, 1425},
+       {0x1F0E, 0, 2, 1427},
+       {0x1F0F, 0, 2, 1429},
+       {0x1F10, 0, 2, 1431},
+       {0x1F11, 0, 2, 1433},
+       {0x1F12, 0, 2, 1435},
+       {0x1F13, 0, 2, 1437},
+       {0x1F14, 0, 2, 1439},
+       {0x1F15, 0, 2, 1441},
+       {0x1F18, 0, 2, 1443},
+       {0x1F19, 0, 2, 1445},
+       {0x1F1A, 0, 2, 1447},
+       {0x1F1B, 0, 2, 1449},
+       {0x1F1C, 0, 2, 1451},
+       {0x1F1D, 0, 2, 1453},
+       {0x1F20, 0, 2, 1455},
+       {0x1F21, 0, 2, 1457},
+       {0x1F22, 0, 2, 1459},
+       {0x1F23, 0, 2, 1461},
+       {0x1F24, 0, 2, 1463},
+       {0x1F25, 0, 2, 1465},
+       {0x1F26, 0, 2, 1467},
+       {0x1F27, 0, 2, 1469},
+       {0x1F28, 0, 2, 1471},
+       {0x1F29, 0, 2, 1473},
+       {0x1F2A, 0, 2, 1475},
+       {0x1F2B, 0, 2, 1477},
+       {0x1F2C, 0, 2, 1479},
+       {0x1F2D, 0, 2, 1481},
+       {0x1F2E, 0, 2, 1483},
+       {0x1F2F, 0, 2, 1485},
+       {0x1F30, 0, 2, 1487},
+       {0x1F31, 0, 2, 1489},
+       {0x1F32, 0, 2, 1491},
+       {0x1F33, 0, 2, 1493},
+       {0x1F34, 0, 2, 1495},
+       {0x1F35, 0, 2, 1497},
+       {0x1F36, 0, 2, 1499},
+       {0x1F37, 0, 2, 1501},
+       {0x1F38, 0, 2, 1503},
+       {0x1F39, 0, 2, 1505},
+       {0x1F3A, 0, 2, 1507},
+       {0x1F3B, 0, 2, 1509},
+       {0x1F3C, 0, 2, 1511},
+       {0x1F3D, 0, 2, 1513},
+       {0x1F3E, 0, 2, 1515},
+       {0x1F3F, 0, 2, 1517},
+       {0x1F40, 0, 2, 1519},
+       {0x1F41, 0, 2, 1521},
+       {0x1F42, 0, 2, 1523},
+       {0x1F43, 0, 2, 1525},
+       {0x1F44, 0, 2, 1527},
+       {0x1F45, 0, 2, 1529},
+       {0x1F48, 0, 2, 1531},
+       {0x1F49, 0, 2, 1533},
+       {0x1F4A, 0, 2, 1535},
+       {0x1F4B, 0, 2, 1537},
+       {0x1F4C, 0, 2, 1539},
+       {0x1F4D, 0, 2, 1541},
+       {0x1F50, 0, 2, 1543},
+       {0x1F51, 0, 2, 1545},
+       {0x1F52, 0, 2, 1547},
+       {0x1F53, 0, 2, 1549},
+       {0x1F54, 0, 2, 1551},
+       {0x1F55, 0, 2, 1553},
+       {0x1F56, 0, 2, 1555},
+       {0x1F57, 0, 2, 1557},
+       {0x1F59, 0, 2, 1559},
+       {0x1F5B, 0, 2, 1561},
+       {0x1F5D, 0, 2, 1563},
+       {0x1F5F, 0, 2, 1565},
+       {0x1F60, 0, 2, 1567},
+       {0x1F61, 0, 2, 1569},
+       {0x1F62, 0, 2, 1571},
+       {0x1F63, 0, 2, 1573},
+       {0x1F64, 0, 2, 1575},
+       {0x1F65, 0, 2, 1577},
+       {0x1F66, 0, 2, 1579},
+       {0x1F67, 0, 2, 1581},
+       {0x1F68, 0, 2, 1583},
+       {0x1F69, 0, 2, 1585},
+       {0x1F6A, 0, 2, 1587},
+       {0x1F6B, 0, 2, 1589},
+       {0x1F6C, 0, 2, 1591},
+       {0x1F6D, 0, 2, 1593},
+       {0x1F6E, 0, 2, 1595},
+       {0x1F6F, 0, 2, 1597},
+       {0x1F70, 0, 2, 1599},
+       {0x1F71, 0, 1 | DECOMP_INLINE, 0x03AC},
+       {0x1F72, 0, 2, 1601},
+       {0x1F73, 0, 1 | DECOMP_INLINE, 0x03AD},
+       {0x1F74, 0, 2, 1603},
+       {0x1F75, 0, 1 | DECOMP_INLINE, 0x03AE},
+       {0x1F76, 0, 2, 1605},
+       {0x1F77, 0, 1 | DECOMP_INLINE, 0x03AF},
+       {0x1F78, 0, 2, 1607},
+       {0x1F79, 0, 1 | DECOMP_INLINE, 0x03CC},
+       {0x1F7A, 0, 2, 1609},
+       {0x1F7B, 0, 1 | DECOMP_INLINE, 0x03CD},
+       {0x1F7C, 0, 2, 1611},
+       {0x1F7D, 0, 1 | DECOMP_INLINE, 0x03CE},
+       {0x1F80, 0, 2, 1613},
+       {0x1F81, 0, 2, 1615},
+       {0x1F82, 0, 2, 1617},
+       {0x1F83, 0, 2, 1619},
+       {0x1F84, 0, 2, 1621},
+       {0x1F85, 0, 2, 1623},
+       {0x1F86, 0, 2, 1625},
+       {0x1F87, 0, 2, 1627},
+       {0x1F88, 0, 2, 1629},
+       {0x1F89, 0, 2, 1631},
+       {0x1F8A, 0, 2, 1633},
+       {0x1F8B, 0, 2, 1635},
+       {0x1F8C, 0, 2, 1637},
+       {0x1F8D, 0, 2, 1639},
+       {0x1F8E, 0, 2, 1641},
+       {0x1F8F, 0, 2, 1643},
+       {0x1F90, 0, 2, 1645},
+       {0x1F91, 0, 2, 1647},
+       {0x1F92, 0, 2, 1649},
+       {0x1F93, 0, 2, 1651},
+       {0x1F94, 0, 2, 1653},
+       {0x1F95, 0, 2, 1655},
+       {0x1F96, 0, 2, 1657},
+       {0x1F97, 0, 2, 1659},
+       {0x1F98, 0, 2, 1661},
+       {0x1F99, 0, 2, 1663},
+       {0x1F9A, 0, 2, 1665},
+       {0x1F9B, 0, 2, 1667},
+       {0x1F9C, 0, 2, 1669},
+       {0x1F9D, 0, 2, 1671},
+       {0x1F9E, 0, 2, 1673},
+       {0x1F9F, 0, 2, 1675},
+       {0x1FA0, 0, 2, 1677},
+       {0x1FA1, 0, 2, 1679},
+       {0x1FA2, 0, 2, 1681},
+       {0x1FA3, 0, 2, 1683},
+       {0x1FA4, 0, 2, 1685},
+       {0x1FA5, 0, 2, 1687},
+       {0x1FA6, 0, 2, 1689},
+       {0x1FA7, 0, 2, 1691},
+       {0x1FA8, 0, 2, 1693},
+       {0x1FA9, 0, 2, 1695},
+       {0x1FAA, 0, 2, 1697},
+       {0x1FAB, 0, 2, 1699},
+       {0x1FAC, 0, 2, 1701},
+       {0x1FAD, 0, 2, 1703},
+       {0x1FAE, 0, 2, 1705},
+       {0x1FAF, 0, 2, 1707},
+       {0x1FB0, 0, 2, 1709},
+       {0x1FB1, 0, 2, 1711},
+       {0x1FB2, 0, 2, 1713},
+       {0x1FB3, 0, 2, 1715},
+       {0x1FB4, 0, 2, 1717},
+       {0x1FB6, 0, 2, 1719},
+       {0x1FB7, 0, 2, 1721},
+       {0x1FB8, 0, 2, 1723},
+       {0x1FB9, 0, 2, 1725},
+       {0x1FBA, 0, 2, 1727},
+       {0x1FBB, 0, 1 | DECOMP_INLINE, 0x0386},
+       {0x1FBC, 0, 2, 1729},
+       {0x1FBD, 0, 2 | DECOMP_NO_COMPOSE, 1731},       /* compatibility mapping */
+       {0x1FBE, 0, 1 | DECOMP_INLINE, 0x03B9},
+       {0x1FBF, 0, 2 | DECOMP_NO_COMPOSE, 1733},       /* compatibility mapping */
+       {0x1FC0, 0, 2 | DECOMP_NO_COMPOSE, 1735},       /* compatibility mapping */
+       {0x1FC1, 0, 2, 1737},
+       {0x1FC2, 0, 2, 1739},
+       {0x1FC3, 0, 2, 1741},
+       {0x1FC4, 0, 2, 1743},
+       {0x1FC6, 0, 2, 1745},
+       {0x1FC7, 0, 2, 1747},
+       {0x1FC8, 0, 2, 1749},
+       {0x1FC9, 0, 1 | DECOMP_INLINE, 0x0388},
+       {0x1FCA, 0, 2, 1751},
+       {0x1FCB, 0, 1 | DECOMP_INLINE, 0x0389},
+       {0x1FCC, 0, 2, 1753},
+       {0x1FCD, 0, 2, 1755},
+       {0x1FCE, 0, 2, 1757},
+       {0x1FCF, 0, 2, 1759},
+       {0x1FD0, 0, 2, 1761},
+       {0x1FD1, 0, 2, 1763},
+       {0x1FD2, 0, 2, 1765},
+       {0x1FD3, 0, 1 | DECOMP_INLINE, 0x0390},
+       {0x1FD6, 0, 2, 1767},
+       {0x1FD7, 0, 2, 1769},
+       {0x1FD8, 0, 2, 1771},
+       {0x1FD9, 0, 2, 1773},
+       {0x1FDA, 0, 2, 1775},
+       {0x1FDB, 0, 1 | DECOMP_INLINE, 0x038A},
+       {0x1FDD, 0, 2, 1777},
+       {0x1FDE, 0, 2, 1779},
+       {0x1FDF, 0, 2, 1781},
+       {0x1FE0, 0, 2, 1783},
+       {0x1FE1, 0, 2, 1785},
+       {0x1FE2, 0, 2, 1787},
+       {0x1FE3, 0, 1 | DECOMP_INLINE, 0x03B0},
+       {0x1FE4, 0, 2, 1789},
+       {0x1FE5, 0, 2, 1791},
+       {0x1FE6, 0, 2, 1793},
+       {0x1FE7, 0, 2, 1795},
+       {0x1FE8, 0, 2, 1797},
+       {0x1FE9, 0, 2, 1799},
+       {0x1FEA, 0, 2, 1801},
+       {0x1FEB, 0, 1 | DECOMP_INLINE, 0x038E},
+       {0x1FEC, 0, 2, 1803},
+       {0x1FED, 0, 2, 1805},
+       {0x1FEE, 0, 1 | DECOMP_INLINE, 0x0385},
+       {0x1FEF, 0, 1 | DECOMP_INLINE, 0x0060},
+       {0x1FF2, 0, 2, 1807},
+       {0x1FF3, 0, 2, 1809},
+       {0x1FF4, 0, 2, 1811},
+       {0x1FF6, 0, 2, 1813},
+       {0x1FF7, 0, 2, 1815},
+       {0x1FF8, 0, 2, 1817},
+       {0x1FF9, 0, 1 | DECOMP_INLINE, 0x038C},
+       {0x1FFA, 0, 2, 1819},
+       {0x1FFB, 0, 1 | DECOMP_INLINE, 0x038F},
+       {0x1FFC, 0, 2, 1821},
+       {0x1FFD, 0, 1 | DECOMP_INLINE, 0x00B4},
+       {0x1FFE, 0, 2 | DECOMP_NO_COMPOSE, 1823},       /* compatibility mapping */
+       {0x2000, 0, 1 | DECOMP_INLINE, 0x2002},
+       {0x2001, 0, 1 | DECOMP_INLINE, 0x2003},
+       {0x2002, 0, 1 | DECOMP_INLINE, 0x0020},
+       {0x2003, 0, 1 | DECOMP_INLINE, 0x0020},
+       {0x2004, 0, 1 | DECOMP_INLINE, 0x0020},
+       {0x2005, 0, 1 | DECOMP_INLINE, 0x0020},
+       {0x2006, 0, 1 | DECOMP_INLINE, 0x0020},
+       {0x2007, 0, 1 | DECOMP_INLINE, 0x0020},
+       {0x2008, 0, 1 | DECOMP_INLINE, 0x0020},
+       {0x2009, 0, 1 | DECOMP_INLINE, 0x0020},
+       {0x200A, 0, 1 | DECOMP_INLINE, 0x0020},
+       {0x2011, 0, 1 | DECOMP_INLINE, 0x2010},
+       {0x2017, 0, 2 | DECOMP_NO_COMPOSE, 1825},       /* compatibility mapping */
+       {0x2024, 0, 1 | DECOMP_INLINE, 0x002E},
+       {0x2025, 0, 2 | DECOMP_NO_COMPOSE, 1827},       /* compatibility mapping */
+       {0x2026, 0, 3, 1829},
+       {0x202F, 0, 1 | DECOMP_INLINE, 0x0020},
+       {0x2033, 0, 2 | DECOMP_NO_COMPOSE, 1832},       /* compatibility mapping */
+       {0x2034, 0, 3, 1834},
+       {0x2036, 0, 2 | DECOMP_NO_COMPOSE, 1837},       /* compatibility mapping */
+       {0x2037, 0, 3, 1839},
+       {0x203C, 0, 2 | DECOMP_NO_COMPOSE, 1842},       /* compatibility mapping */
+       {0x203E, 0, 2 | DECOMP_NO_COMPOSE, 1844},       /* compatibility mapping */
+       {0x2047, 0, 2 | DECOMP_NO_COMPOSE, 1846},       /* compatibility mapping */
+       {0x2048, 0, 2 | DECOMP_NO_COMPOSE, 1848},       /* compatibility mapping */
+       {0x2049, 0, 2 | DECOMP_NO_COMPOSE, 1850},       /* compatibility mapping */
+       {0x2057, 0, 4, 1852},
+       {0x205F, 0, 1 | DECOMP_INLINE, 0x0020},
+       {0x2070, 0, 1 | DECOMP_INLINE, 0x0030},
+       {0x2071, 0, 1 | DECOMP_INLINE, 0x0069},
+       {0x2074, 0, 1 | DECOMP_INLINE, 0x0034},
+       {0x2075, 0, 1 | DECOMP_INLINE, 0x0035},
+       {0x2076, 0, 1 | DECOMP_INLINE, 0x0036},
+       {0x2077, 0, 1 | DECOMP_INLINE, 0x0037},
+       {0x2078, 0, 1 | DECOMP_INLINE, 0x0038},
+       {0x2079, 0, 1 | DECOMP_INLINE, 0x0039},
+       {0x207A, 0, 1 | DECOMP_INLINE, 0x002B},
+       {0x207B, 0, 1 | DECOMP_INLINE, 0x2212},
+       {0x207C, 0, 1 | DECOMP_INLINE, 0x003D},
+       {0x207D, 0, 1 | DECOMP_INLINE, 0x0028},
+       {0x207E, 0, 1 | DECOMP_INLINE, 0x0029},
+       {0x207F, 0, 1 | DECOMP_INLINE, 0x006E},
+       {0x2080, 0, 1 | DECOMP_INLINE, 0x0030},
+       {0x2081, 0, 1 | DECOMP_INLINE, 0x0031},
+       {0x2082, 0, 1 | DECOMP_INLINE, 0x0032},
+       {0x2083, 0, 1 | DECOMP_INLINE, 0x0033},
+       {0x2084, 0, 1 | DECOMP_INLINE, 0x0034},
+       {0x2085, 0, 1 | DECOMP_INLINE, 0x0035},
+       {0x2086, 0, 1 | DECOMP_INLINE, 0x0036},
+       {0x2087, 0, 1 | DECOMP_INLINE, 0x0037},
+       {0x2088, 0, 1 | DECOMP_INLINE, 0x0038},
+       {0x2089, 0, 1 | DECOMP_INLINE, 0x0039},
+       {0x208A, 0, 1 | DECOMP_INLINE, 0x002B},
+       {0x208B, 0, 1 | DECOMP_INLINE, 0x2212},
+       {0x208C, 0, 1 | DECOMP_INLINE, 0x003D},
+       {0x208D, 0, 1 | DECOMP_INLINE, 0x0028},
+       {0x208E, 0, 1 | DECOMP_INLINE, 0x0029},
+       {0x2090, 0, 1 | DECOMP_INLINE, 0x0061},
+       {0x2091, 0, 1 | DECOMP_INLINE, 0x0065},
+       {0x2092, 0, 1 | DECOMP_INLINE, 0x006F},
+       {0x2093, 0, 1 | DECOMP_INLINE, 0x0078},
+       {0x2094, 0, 1 | DECOMP_INLINE, 0x0259},
+       {0x2095, 0, 1 | DECOMP_INLINE, 0x0068},
+       {0x2096, 0, 1 | DECOMP_INLINE, 0x006B},
+       {0x2097, 0, 1 | DECOMP_INLINE, 0x006C},
+       {0x2098, 0, 1 | DECOMP_INLINE, 0x006D},
+       {0x2099, 0, 1 | DECOMP_INLINE, 0x006E},
+       {0x209A, 0, 1 | DECOMP_INLINE, 0x0070},
+       {0x209B, 0, 1 | DECOMP_INLINE, 0x0073},
+       {0x209C, 0, 1 | DECOMP_INLINE, 0x0074},
+       {0x20A8, 0, 2 | DECOMP_NO_COMPOSE, 1856},       /* compatibility mapping */
+       {0x20D0, 230, 0, 0},
+       {0x20D1, 230, 0, 0},
+       {0x20D2, 1, 0, 0},
+       {0x20D3, 1, 0, 0},
+       {0x20D4, 230, 0, 0},
+       {0x20D5, 230, 0, 0},
+       {0x20D6, 230, 0, 0},
+       {0x20D7, 230, 0, 0},
+       {0x20D8, 1, 0, 0},
+       {0x20D9, 1, 0, 0},
+       {0x20DA, 1, 0, 0},
+       {0x20DB, 230, 0, 0},
+       {0x20DC, 230, 0, 0},
+       {0x20E1, 230, 0, 0},
+       {0x20E5, 1, 0, 0},
+       {0x20E6, 1, 0, 0},
+       {0x20E7, 230, 0, 0},
+       {0x20E8, 220, 0, 0},
+       {0x20E9, 230, 0, 0},
+       {0x20EA, 1, 0, 0},
+       {0x20EB, 1, 0, 0},
+       {0x20EC, 220, 0, 0},
+       {0x20ED, 220, 0, 0},
+       {0x20EE, 220, 0, 0},
+       {0x20EF, 220, 0, 0},
+       {0x20F0, 230, 0, 0},
+       {0x2100, 0, 3, 1858},
+       {0x2101, 0, 3, 1861},
+       {0x2102, 0, 1 | DECOMP_INLINE, 0x0043},
+       {0x2103, 0, 2 | DECOMP_NO_COMPOSE, 1864},       /* compatibility mapping */
+       {0x2105, 0, 3, 1866},
+       {0x2106, 0, 3, 1869},
+       {0x2107, 0, 1 | DECOMP_INLINE, 0x0190},
+       {0x2109, 0, 2 | DECOMP_NO_COMPOSE, 1872},       /* compatibility mapping */
+       {0x210A, 0, 1 | DECOMP_INLINE, 0x0067},
+       {0x210B, 0, 1 | DECOMP_INLINE, 0x0048},
+       {0x210C, 0, 1 | DECOMP_INLINE, 0x0048},
+       {0x210D, 0, 1 | DECOMP_INLINE, 0x0048},
+       {0x210E, 0, 1 | DECOMP_INLINE, 0x0068},
+       {0x210F, 0, 1 | DECOMP_INLINE, 0x0127},
+       {0x2110, 0, 1 | DECOMP_INLINE, 0x0049},
+       {0x2111, 0, 1 | DECOMP_INLINE, 0x0049},
+       {0x2112, 0, 1 | DECOMP_INLINE, 0x004C},
+       {0x2113, 0, 1 | DECOMP_INLINE, 0x006C},
+       {0x2115, 0, 1 | DECOMP_INLINE, 0x004E},
+       {0x2116, 0, 2 | DECOMP_NO_COMPOSE, 1874},       /* compatibility mapping */
+       {0x2119, 0, 1 | DECOMP_INLINE, 0x0050},
+       {0x211A, 0, 1 | DECOMP_INLINE, 0x0051},
+       {0x211B, 0, 1 | DECOMP_INLINE, 0x0052},
+       {0x211C, 0, 1 | DECOMP_INLINE, 0x0052},
+       {0x211D, 0, 1 | DECOMP_INLINE, 0x0052},
+       {0x2120, 0, 2 | DECOMP_NO_COMPOSE, 1876},       /* compatibility mapping */
+       {0x2121, 0, 3, 1878},
+       {0x2122, 0, 2 | DECOMP_NO_COMPOSE, 1881},       /* compatibility mapping */
+       {0x2124, 0, 1 | DECOMP_INLINE, 0x005A},
+       {0x2126, 0, 1 | DECOMP_INLINE, 0x03A9},
+       {0x2128, 0, 1 | DECOMP_INLINE, 0x005A},
+       {0x212A, 0, 1 | DECOMP_INLINE, 0x004B},
+       {0x212B, 0, 1 | DECOMP_INLINE, 0x00C5},
+       {0x212C, 0, 1 | DECOMP_INLINE, 0x0042},
+       {0x212D, 0, 1 | DECOMP_INLINE, 0x0043},
+       {0x212F, 0, 1 | DECOMP_INLINE, 0x0065},
+       {0x2130, 0, 1 | DECOMP_INLINE, 0x0045},
+       {0x2131, 0, 1 | DECOMP_INLINE, 0x0046},
+       {0x2133, 0, 1 | DECOMP_INLINE, 0x004D},
+       {0x2134, 0, 1 | DECOMP_INLINE, 0x006F},
+       {0x2135, 0, 1 | DECOMP_INLINE, 0x05D0},
+       {0x2136, 0, 1 | DECOMP_INLINE, 0x05D1},
+       {0x2137, 0, 1 | DECOMP_INLINE, 0x05D2},
+       {0x2138, 0, 1 | DECOMP_INLINE, 0x05D3},
+       {0x2139, 0, 1 | DECOMP_INLINE, 0x0069},
+       {0x213B, 0, 3, 1883},
+       {0x213C, 0, 1 | DECOMP_INLINE, 0x03C0},
+       {0x213D, 0, 1 | DECOMP_INLINE, 0x03B3},
+       {0x213E, 0, 1 | DECOMP_INLINE, 0x0393},
+       {0x213F, 0, 1 | DECOMP_INLINE, 0x03A0},
+       {0x2140, 0, 1 | DECOMP_INLINE, 0x2211},
+       {0x2145, 0, 1 | DECOMP_INLINE, 0x0044},
+       {0x2146, 0, 1 | DECOMP_INLINE, 0x0064},
+       {0x2147, 0, 1 | DECOMP_INLINE, 0x0065},
+       {0x2148, 0, 1 | DECOMP_INLINE, 0x0069},
+       {0x2149, 0, 1 | DECOMP_INLINE, 0x006A},
+       {0x2150, 0, 3, 1886},
+       {0x2151, 0, 3, 1889},
+       {0x2152, 0, 4, 1892},
+       {0x2153, 0, 3, 1896},
+       {0x2154, 0, 3, 1899},
+       {0x2155, 0, 3, 1902},
+       {0x2156, 0, 3, 1905},
+       {0x2157, 0, 3, 1908},
+       {0x2158, 0, 3, 1911},
+       {0x2159, 0, 3, 1914},
+       {0x215A, 0, 3, 1917},
+       {0x215B, 0, 3, 1920},
+       {0x215C, 0, 3, 1923},
+       {0x215D, 0, 3, 1926},
+       {0x215E, 0, 3, 1929},
+       {0x215F, 0, 2 | DECOMP_NO_COMPOSE, 1932},       /* compatibility mapping */
+       {0x2160, 0, 1 | DECOMP_INLINE, 0x0049},
+       {0x2161, 0, 2 | DECOMP_NO_COMPOSE, 1934},       /* compatibility mapping */
+       {0x2162, 0, 3, 1936},
+       {0x2163, 0, 2 | DECOMP_NO_COMPOSE, 1939},       /* compatibility mapping */
+       {0x2164, 0, 1 | DECOMP_INLINE, 0x0056},
+       {0x2165, 0, 2 | DECOMP_NO_COMPOSE, 1941},       /* compatibility mapping */
+       {0x2166, 0, 3, 1943},
+       {0x2167, 0, 4, 1946},
+       {0x2168, 0, 2 | DECOMP_NO_COMPOSE, 1950},       /* compatibility mapping */
+       {0x2169, 0, 1 | DECOMP_INLINE, 0x0058},
+       {0x216A, 0, 2 | DECOMP_NO_COMPOSE, 1952},       /* compatibility mapping */
+       {0x216B, 0, 3, 1954},
+       {0x216C, 0, 1 | DECOMP_INLINE, 0x004C},
+       {0x216D, 0, 1 | DECOMP_INLINE, 0x0043},
+       {0x216E, 0, 1 | DECOMP_INLINE, 0x0044},
+       {0x216F, 0, 1 | DECOMP_INLINE, 0x004D},
+       {0x2170, 0, 1 | DECOMP_INLINE, 0x0069},
+       {0x2171, 0, 2 | DECOMP_NO_COMPOSE, 1957},       /* compatibility mapping */
+       {0x2172, 0, 3, 1959},
+       {0x2173, 0, 2 | DECOMP_NO_COMPOSE, 1962},       /* compatibility mapping */
+       {0x2174, 0, 1 | DECOMP_INLINE, 0x0076},
+       {0x2175, 0, 2 | DECOMP_NO_COMPOSE, 1964},       /* compatibility mapping */
+       {0x2176, 0, 3, 1966},
+       {0x2177, 0, 4, 1969},
+       {0x2178, 0, 2 | DECOMP_NO_COMPOSE, 1973},       /* compatibility mapping */
+       {0x2179, 0, 1 | DECOMP_INLINE, 0x0078},
+       {0x217A, 0, 2 | DECOMP_NO_COMPOSE, 1975},       /* compatibility mapping */
+       {0x217B, 0, 3, 1977},
+       {0x217C, 0, 1 | DECOMP_INLINE, 0x006C},
+       {0x217D, 0, 1 | DECOMP_INLINE, 0x0063},
+       {0x217E, 0, 1 | DECOMP_INLINE, 0x0064},
+       {0x217F, 0, 1 | DECOMP_INLINE, 0x006D},
+       {0x2189, 0, 3, 1980},
+       {0x219A, 0, 2, 1983},
+       {0x219B, 0, 2, 1985},
+       {0x21AE, 0, 2, 1987},
+       {0x21CD, 0, 2, 1989},
+       {0x21CE, 0, 2, 1991},
+       {0x21CF, 0, 2, 1993},
+       {0x2204, 0, 2, 1995},
+       {0x2209, 0, 2, 1997},
+       {0x220C, 0, 2, 1999},
+       {0x2224, 0, 2, 2001},
+       {0x2226, 0, 2, 2003},
+       {0x222C, 0, 2 | DECOMP_NO_COMPOSE, 2005},       /* compatibility mapping */
+       {0x222D, 0, 3, 2007},
+       {0x222F, 0, 2 | DECOMP_NO_COMPOSE, 2010},       /* compatibility mapping */
+       {0x2230, 0, 3, 2012},
+       {0x2241, 0, 2, 2015},
+       {0x2244, 0, 2, 2017},
+       {0x2247, 0, 2, 2019},
+       {0x2249, 0, 2, 2021},
+       {0x2260, 0, 2, 2023},
+       {0x2262, 0, 2, 2025},
+       {0x226D, 0, 2, 2027},
+       {0x226E, 0, 2, 2029},
+       {0x226F, 0, 2, 2031},
+       {0x2270, 0, 2, 2033},
+       {0x2271, 0, 2, 2035},
+       {0x2274, 0, 2, 2037},
+       {0x2275, 0, 2, 2039},
+       {0x2278, 0, 2, 2041},
+       {0x2279, 0, 2, 2043},
+       {0x2280, 0, 2, 2045},
+       {0x2281, 0, 2, 2047},
+       {0x2284, 0, 2, 2049},
+       {0x2285, 0, 2, 2051},
+       {0x2288, 0, 2, 2053},
+       {0x2289, 0, 2, 2055},
+       {0x22AC, 0, 2, 2057},
+       {0x22AD, 0, 2, 2059},
+       {0x22AE, 0, 2, 2061},
+       {0x22AF, 0, 2, 2063},
+       {0x22E0, 0, 2, 2065},
+       {0x22E1, 0, 2, 2067},
+       {0x22E2, 0, 2, 2069},
+       {0x22E3, 0, 2, 2071},
+       {0x22EA, 0, 2, 2073},
+       {0x22EB, 0, 2, 2075},
+       {0x22EC, 0, 2, 2077},
+       {0x22ED, 0, 2, 2079},
+       {0x2329, 0, 1 | DECOMP_INLINE, 0x3008},
+       {0x232A, 0, 1 | DECOMP_INLINE, 0x3009},
+       {0x2460, 0, 1 | DECOMP_INLINE, 0x0031},
+       {0x2461, 0, 1 | DECOMP_INLINE, 0x0032},
+       {0x2462, 0, 1 | DECOMP_INLINE, 0x0033},
+       {0x2463, 0, 1 | DECOMP_INLINE, 0x0034},
+       {0x2464, 0, 1 | DECOMP_INLINE, 0x0035},
+       {0x2465, 0, 1 | DECOMP_INLINE, 0x0036},
+       {0x2466, 0, 1 | DECOMP_INLINE, 0x0037},
+       {0x2467, 0, 1 | DECOMP_INLINE, 0x0038},
+       {0x2468, 0, 1 | DECOMP_INLINE, 0x0039},
+       {0x2469, 0, 2 | DECOMP_NO_COMPOSE, 2081},       /* compatibility mapping */
+       {0x246A, 0, 2 | DECOMP_NO_COMPOSE, 2083},       /* compatibility mapping */
+       {0x246B, 0, 2 | DECOMP_NO_COMPOSE, 2085},       /* compatibility mapping */
+       {0x246C, 0, 2 | DECOMP_NO_COMPOSE, 2087},       /* compatibility mapping */
+       {0x246D, 0, 2 | DECOMP_NO_COMPOSE, 2089},       /* compatibility mapping */
+       {0x246E, 0, 2 | DECOMP_NO_COMPOSE, 2091},       /* compatibility mapping */
+       {0x246F, 0, 2 | DECOMP_NO_COMPOSE, 2093},       /* compatibility mapping */
+       {0x2470, 0, 2 | DECOMP_NO_COMPOSE, 2095},       /* compatibility mapping */
+       {0x2471, 0, 2 | DECOMP_NO_COMPOSE, 2097},       /* compatibility mapping */
+       {0x2472, 0, 2 | DECOMP_NO_COMPOSE, 2099},       /* compatibility mapping */
+       {0x2473, 0, 2 | DECOMP_NO_COMPOSE, 2101},       /* compatibility mapping */
+       {0x2474, 0, 3, 2103},
+       {0x2475, 0, 3, 2106},
+       {0x2476, 0, 3, 2109},
+       {0x2477, 0, 3, 2112},
+       {0x2478, 0, 3, 2115},
+       {0x2479, 0, 3, 2118},
+       {0x247A, 0, 3, 2121},
+       {0x247B, 0, 3, 2124},
+       {0x247C, 0, 3, 2127},
+       {0x247D, 0, 4, 2130},
+       {0x247E, 0, 4, 2134},
+       {0x247F, 0, 4, 2138},
+       {0x2480, 0, 4, 2142},
+       {0x2481, 0, 4, 2146},
+       {0x2482, 0, 4, 2150},
+       {0x2483, 0, 4, 2154},
+       {0x2484, 0, 4, 2158},
+       {0x2485, 0, 4, 2162},
+       {0x2486, 0, 4, 2166},
+       {0x2487, 0, 4, 2170},
+       {0x2488, 0, 2 | DECOMP_NO_COMPOSE, 2174},       /* compatibility mapping */
+       {0x2489, 0, 2 | DECOMP_NO_COMPOSE, 2176},       /* compatibility mapping */
+       {0x248A, 0, 2 | DECOMP_NO_COMPOSE, 2178},       /* compatibility mapping */
+       {0x248B, 0, 2 | DECOMP_NO_COMPOSE, 2180},       /* compatibility mapping */
+       {0x248C, 0, 2 | DECOMP_NO_COMPOSE, 2182},       /* compatibility mapping */
+       {0x248D, 0, 2 | DECOMP_NO_COMPOSE, 2184},       /* compatibility mapping */
+       {0x248E, 0, 2 | DECOMP_NO_COMPOSE, 2186},       /* compatibility mapping */
+       {0x248F, 0, 2 | DECOMP_NO_COMPOSE, 2188},       /* compatibility mapping */
+       {0x2490, 0, 2 | DECOMP_NO_COMPOSE, 2190},       /* compatibility mapping */
+       {0x2491, 0, 3, 2192},
+       {0x2492, 0, 3, 2195},
+       {0x2493, 0, 3, 2198},
+       {0x2494, 0, 3, 2201},
+       {0x2495, 0, 3, 2204},
+       {0x2496, 0, 3, 2207},
+       {0x2497, 0, 3, 2210},
+       {0x2498, 0, 3, 2213},
+       {0x2499, 0, 3, 2216},
+       {0x249A, 0, 3, 2219},
+       {0x249B, 0, 3, 2222},
+       {0x249C, 0, 3, 2225},
+       {0x249D, 0, 3, 2228},
+       {0x249E, 0, 3, 2231},
+       {0x249F, 0, 3, 2234},
+       {0x24A0, 0, 3, 2237},
+       {0x24A1, 0, 3, 2240},
+       {0x24A2, 0, 3, 2243},
+       {0x24A3, 0, 3, 2246},
+       {0x24A4, 0, 3, 2249},
+       {0x24A5, 0, 3, 2252},
+       {0x24A6, 0, 3, 2255},
+       {0x24A7, 0, 3, 2258},
+       {0x24A8, 0, 3, 2261},
+       {0x24A9, 0, 3, 2264},
+       {0x24AA, 0, 3, 2267},
+       {0x24AB, 0, 3, 2270},
+       {0x24AC, 0, 3, 2273},
+       {0x24AD, 0, 3, 2276},
+       {0x24AE, 0, 3, 2279},
+       {0x24AF, 0, 3, 2282},
+       {0x24B0, 0, 3, 2285},
+       {0x24B1, 0, 3, 2288},
+       {0x24B2, 0, 3, 2291},
+       {0x24B3, 0, 3, 2294},
+       {0x24B4, 0, 3, 2297},
+       {0x24B5, 0, 3, 2300},
+       {0x24B6, 0, 1 | DECOMP_INLINE, 0x0041},
+       {0x24B7, 0, 1 | DECOMP_INLINE, 0x0042},
+       {0x24B8, 0, 1 | DECOMP_INLINE, 0x0043},
+       {0x24B9, 0, 1 | DECOMP_INLINE, 0x0044},
+       {0x24BA, 0, 1 | DECOMP_INLINE, 0x0045},
+       {0x24BB, 0, 1 | DECOMP_INLINE, 0x0046},
+       {0x24BC, 0, 1 | DECOMP_INLINE, 0x0047},
+       {0x24BD, 0, 1 | DECOMP_INLINE, 0x0048},
+       {0x24BE, 0, 1 | DECOMP_INLINE, 0x0049},
+       {0x24BF, 0, 1 | DECOMP_INLINE, 0x004A},
+       {0x24C0, 0, 1 | DECOMP_INLINE, 0x004B},
+       {0x24C1, 0, 1 | DECOMP_INLINE, 0x004C},
+       {0x24C2, 0, 1 | DECOMP_INLINE, 0x004D},
+       {0x24C3, 0, 1 | DECOMP_INLINE, 0x004E},
+       {0x24C4, 0, 1 | DECOMP_INLINE, 0x004F},
+       {0x24C5, 0, 1 | DECOMP_INLINE, 0x0050},
+       {0x24C6, 0, 1 | DECOMP_INLINE, 0x0051},
+       {0x24C7, 0, 1 | DECOMP_INLINE, 0x0052},
+       {0x24C8, 0, 1 | DECOMP_INLINE, 0x0053},
+       {0x24C9, 0, 1 | DECOMP_INLINE, 0x0054},
+       {0x24CA, 0, 1 | DECOMP_INLINE, 0x0055},
+       {0x24CB, 0, 1 | DECOMP_INLINE, 0x0056},
+       {0x24CC, 0, 1 | DECOMP_INLINE, 0x0057},
+       {0x24CD, 0, 1 | DECOMP_INLINE, 0x0058},
+       {0x24CE, 0, 1 | DECOMP_INLINE, 0x0059},
+       {0x24CF, 0, 1 | DECOMP_INLINE, 0x005A},
+       {0x24D0, 0, 1 | DECOMP_INLINE, 0x0061},
+       {0x24D1, 0, 1 | DECOMP_INLINE, 0x0062},
+       {0x24D2, 0, 1 | DECOMP_INLINE, 0x0063},
+       {0x24D3, 0, 1 | DECOMP_INLINE, 0x0064},
+       {0x24D4, 0, 1 | DECOMP_INLINE, 0x0065},
+       {0x24D5, 0, 1 | DECOMP_INLINE, 0x0066},
+       {0x24D6, 0, 1 | DECOMP_INLINE, 0x0067},
+       {0x24D7, 0, 1 | DECOMP_INLINE, 0x0068},
+       {0x24D8, 0, 1 | DECOMP_INLINE, 0x0069},
+       {0x24D9, 0, 1 | DECOMP_INLINE, 0x006A},
+       {0x24DA, 0, 1 | DECOMP_INLINE, 0x006B},
+       {0x24DB, 0, 1 | DECOMP_INLINE, 0x006C},
+       {0x24DC, 0, 1 | DECOMP_INLINE, 0x006D},
+       {0x24DD, 0, 1 | DECOMP_INLINE, 0x006E},
+       {0x24DE, 0, 1 | DECOMP_INLINE, 0x006F},
+       {0x24DF, 0, 1 | DECOMP_INLINE, 0x0070},
+       {0x24E0, 0, 1 | DECOMP_INLINE, 0x0071},
+       {0x24E1, 0, 1 | DECOMP_INLINE, 0x0072},
+       {0x24E2, 0, 1 | DECOMP_INLINE, 0x0073},
+       {0x24E3, 0, 1 | DECOMP_INLINE, 0x0074},
+       {0x24E4, 0, 1 | DECOMP_INLINE, 0x0075},
+       {0x24E5, 0, 1 | DECOMP_INLINE, 0x0076},
+       {0x24E6, 0, 1 | DECOMP_INLINE, 0x0077},
+       {0x24E7, 0, 1 | DECOMP_INLINE, 0x0078},
+       {0x24E8, 0, 1 | DECOMP_INLINE, 0x0079},
+       {0x24E9, 0, 1 | DECOMP_INLINE, 0x007A},
+       {0x24EA, 0, 1 | DECOMP_INLINE, 0x0030},
+       {0x2A0C, 0, 4, 2303},
+       {0x2A74, 0, 3, 2307},
+       {0x2A75, 0, 2 | DECOMP_NO_COMPOSE, 2310},       /* compatibility mapping */
+       {0x2A76, 0, 3, 2312},
+       {0x2ADC, 0, 2 | DECOMP_NO_COMPOSE, 2315},       /* in exclusion list */
+       {0x2C7C, 0, 1 | DECOMP_INLINE, 0x006A},
+       {0x2C7D, 0, 1 | DECOMP_INLINE, 0x0056},
+       {0x2CEF, 230, 0, 0},
+       {0x2CF0, 230, 0, 0},
+       {0x2CF1, 230, 0, 0},
+       {0x2D6F, 0, 1 | DECOMP_INLINE, 0x2D61},
+       {0x2D7F, 9, 0, 0},
+       {0x2DE0, 230, 0, 0},
+       {0x2DE1, 230, 0, 0},
+       {0x2DE2, 230, 0, 0},
+       {0x2DE3, 230, 0, 0},
+       {0x2DE4, 230, 0, 0},
+       {0x2DE5, 230, 0, 0},
+       {0x2DE6, 230, 0, 0},
+       {0x2DE7, 230, 0, 0},
+       {0x2DE8, 230, 0, 0},
+       {0x2DE9, 230, 0, 0},
+       {0x2DEA, 230, 0, 0},
+       {0x2DEB, 230, 0, 0},
+       {0x2DEC, 230, 0, 0},
+       {0x2DED, 230, 0, 0},
+       {0x2DEE, 230, 0, 0},
+       {0x2DEF, 230, 0, 0},
+       {0x2DF0, 230, 0, 0},
+       {0x2DF1, 230, 0, 0},
+       {0x2DF2, 230, 0, 0},
+       {0x2DF3, 230, 0, 0},
+       {0x2DF4, 230, 0, 0},
+       {0x2DF5, 230, 0, 0},
+       {0x2DF6, 230, 0, 0},
+       {0x2DF7, 230, 0, 0},
+       {0x2DF8, 230, 0, 0},
+       {0x2DF9, 230, 0, 0},
+       {0x2DFA, 230, 0, 0},
+       {0x2DFB, 230, 0, 0},
+       {0x2DFC, 230, 0, 0},
+       {0x2DFD, 230, 0, 0},
+       {0x2DFE, 230, 0, 0},
+       {0x2DFF, 230, 0, 0},
+       {0x2E9F, 0, 1 | DECOMP_INLINE, 0x6BCD},
+       {0x2EF3, 0, 1 | DECOMP_INLINE, 0x9F9F},
+       {0x2F00, 0, 1 | DECOMP_INLINE, 0x4E00},
+       {0x2F01, 0, 1 | DECOMP_INLINE, 0x4E28},
+       {0x2F02, 0, 1 | DECOMP_INLINE, 0x4E36},
+       {0x2F03, 0, 1 | DECOMP_INLINE, 0x4E3F},
+       {0x2F04, 0, 1 | DECOMP_INLINE, 0x4E59},
+       {0x2F05, 0, 1 | DECOMP_INLINE, 0x4E85},
+       {0x2F06, 0, 1 | DECOMP_INLINE, 0x4E8C},
+       {0x2F07, 0, 1 | DECOMP_INLINE, 0x4EA0},
+       {0x2F08, 0, 1 | DECOMP_INLINE, 0x4EBA},
+       {0x2F09, 0, 1 | DECOMP_INLINE, 0x513F},
+       {0x2F0A, 0, 1 | DECOMP_INLINE, 0x5165},
+       {0x2F0B, 0, 1 | DECOMP_INLINE, 0x516B},
+       {0x2F0C, 0, 1 | DECOMP_INLINE, 0x5182},
+       {0x2F0D, 0, 1 | DECOMP_INLINE, 0x5196},
+       {0x2F0E, 0, 1 | DECOMP_INLINE, 0x51AB},
+       {0x2F0F, 0, 1 | DECOMP_INLINE, 0x51E0},
+       {0x2F10, 0, 1 | DECOMP_INLINE, 0x51F5},
+       {0x2F11, 0, 1 | DECOMP_INLINE, 0x5200},
+       {0x2F12, 0, 1 | DECOMP_INLINE, 0x529B},
+       {0x2F13, 0, 1 | DECOMP_INLINE, 0x52F9},
+       {0x2F14, 0, 1 | DECOMP_INLINE, 0x5315},
+       {0x2F15, 0, 1 | DECOMP_INLINE, 0x531A},
+       {0x2F16, 0, 1 | DECOMP_INLINE, 0x5338},
+       {0x2F17, 0, 1 | DECOMP_INLINE, 0x5341},
+       {0x2F18, 0, 1 | DECOMP_INLINE, 0x535C},
+       {0x2F19, 0, 1 | DECOMP_INLINE, 0x5369},
+       {0x2F1A, 0, 1 | DECOMP_INLINE, 0x5382},
+       {0x2F1B, 0, 1 | DECOMP_INLINE, 0x53B6},
+       {0x2F1C, 0, 1 | DECOMP_INLINE, 0x53C8},
+       {0x2F1D, 0, 1 | DECOMP_INLINE, 0x53E3},
+       {0x2F1E, 0, 1 | DECOMP_INLINE, 0x56D7},
+       {0x2F1F, 0, 1 | DECOMP_INLINE, 0x571F},
+       {0x2F20, 0, 1 | DECOMP_INLINE, 0x58EB},
+       {0x2F21, 0, 1 | DECOMP_INLINE, 0x5902},
+       {0x2F22, 0, 1 | DECOMP_INLINE, 0x590A},
+       {0x2F23, 0, 1 | DECOMP_INLINE, 0x5915},
+       {0x2F24, 0, 1 | DECOMP_INLINE, 0x5927},
+       {0x2F25, 0, 1 | DECOMP_INLINE, 0x5973},
+       {0x2F26, 0, 1 | DECOMP_INLINE, 0x5B50},
+       {0x2F27, 0, 1 | DECOMP_INLINE, 0x5B80},
+       {0x2F28, 0, 1 | DECOMP_INLINE, 0x5BF8},
+       {0x2F29, 0, 1 | DECOMP_INLINE, 0x5C0F},
+       {0x2F2A, 0, 1 | DECOMP_INLINE, 0x5C22},
+       {0x2F2B, 0, 1 | DECOMP_INLINE, 0x5C38},
+       {0x2F2C, 0, 1 | DECOMP_INLINE, 0x5C6E},
+       {0x2F2D, 0, 1 | DECOMP_INLINE, 0x5C71},
+       {0x2F2E, 0, 1 | DECOMP_INLINE, 0x5DDB},
+       {0x2F2F, 0, 1 | DECOMP_INLINE, 0x5DE5},
+       {0x2F30, 0, 1 | DECOMP_INLINE, 0x5DF1},
+       {0x2F31, 0, 1 | DECOMP_INLINE, 0x5DFE},
+       {0x2F32, 0, 1 | DECOMP_INLINE, 0x5E72},
+       {0x2F33, 0, 1 | DECOMP_INLINE, 0x5E7A},
+       {0x2F34, 0, 1 | DECOMP_INLINE, 0x5E7F},
+       {0x2F35, 0, 1 | DECOMP_INLINE, 0x5EF4},
+       {0x2F36, 0, 1 | DECOMP_INLINE, 0x5EFE},
+       {0x2F37, 0, 1 | DECOMP_INLINE, 0x5F0B},
+       {0x2F38, 0, 1 | DECOMP_INLINE, 0x5F13},
+       {0x2F39, 0, 1 | DECOMP_INLINE, 0x5F50},
+       {0x2F3A, 0, 1 | DECOMP_INLINE, 0x5F61},
+       {0x2F3B, 0, 1 | DECOMP_INLINE, 0x5F73},
+       {0x2F3C, 0, 1 | DECOMP_INLINE, 0x5FC3},
+       {0x2F3D, 0, 1 | DECOMP_INLINE, 0x6208},
+       {0x2F3E, 0, 1 | DECOMP_INLINE, 0x6236},
+       {0x2F3F, 0, 1 | DECOMP_INLINE, 0x624B},
+       {0x2F40, 0, 1 | DECOMP_INLINE, 0x652F},
+       {0x2F41, 0, 1 | DECOMP_INLINE, 0x6534},
+       {0x2F42, 0, 1 | DECOMP_INLINE, 0x6587},
+       {0x2F43, 0, 1 | DECOMP_INLINE, 0x6597},
+       {0x2F44, 0, 1 | DECOMP_INLINE, 0x65A4},
+       {0x2F45, 0, 1 | DECOMP_INLINE, 0x65B9},
+       {0x2F46, 0, 1 | DECOMP_INLINE, 0x65E0},
+       {0x2F47, 0, 1 | DECOMP_INLINE, 0x65E5},
+       {0x2F48, 0, 1 | DECOMP_INLINE, 0x66F0},
+       {0x2F49, 0, 1 | DECOMP_INLINE, 0x6708},
+       {0x2F4A, 0, 1 | DECOMP_INLINE, 0x6728},
+       {0x2F4B, 0, 1 | DECOMP_INLINE, 0x6B20},
+       {0x2F4C, 0, 1 | DECOMP_INLINE, 0x6B62},
+       {0x2F4D, 0, 1 | DECOMP_INLINE, 0x6B79},
+       {0x2F4E, 0, 1 | DECOMP_INLINE, 0x6BB3},
+       {0x2F4F, 0, 1 | DECOMP_INLINE, 0x6BCB},
+       {0x2F50, 0, 1 | DECOMP_INLINE, 0x6BD4},
+       {0x2F51, 0, 1 | DECOMP_INLINE, 0x6BDB},
+       {0x2F52, 0, 1 | DECOMP_INLINE, 0x6C0F},
+       {0x2F53, 0, 1 | DECOMP_INLINE, 0x6C14},
+       {0x2F54, 0, 1 | DECOMP_INLINE, 0x6C34},
+       {0x2F55, 0, 1 | DECOMP_INLINE, 0x706B},
+       {0x2F56, 0, 1 | DECOMP_INLINE, 0x722A},
+       {0x2F57, 0, 1 | DECOMP_INLINE, 0x7236},
+       {0x2F58, 0, 1 | DECOMP_INLINE, 0x723B},
+       {0x2F59, 0, 1 | DECOMP_INLINE, 0x723F},
+       {0x2F5A, 0, 1 | DECOMP_INLINE, 0x7247},
+       {0x2F5B, 0, 1 | DECOMP_INLINE, 0x7259},
+       {0x2F5C, 0, 1 | DECOMP_INLINE, 0x725B},
+       {0x2F5D, 0, 1 | DECOMP_INLINE, 0x72AC},
+       {0x2F5E, 0, 1 | DECOMP_INLINE, 0x7384},
+       {0x2F5F, 0, 1 | DECOMP_INLINE, 0x7389},
+       {0x2F60, 0, 1 | DECOMP_INLINE, 0x74DC},
+       {0x2F61, 0, 1 | DECOMP_INLINE, 0x74E6},
+       {0x2F62, 0, 1 | DECOMP_INLINE, 0x7518},
+       {0x2F63, 0, 1 | DECOMP_INLINE, 0x751F},
+       {0x2F64, 0, 1 | DECOMP_INLINE, 0x7528},
+       {0x2F65, 0, 1 | DECOMP_INLINE, 0x7530},
+       {0x2F66, 0, 1 | DECOMP_INLINE, 0x758B},
+       {0x2F67, 0, 1 | DECOMP_INLINE, 0x7592},
+       {0x2F68, 0, 1 | DECOMP_INLINE, 0x7676},
+       {0x2F69, 0, 1 | DECOMP_INLINE, 0x767D},
+       {0x2F6A, 0, 1 | DECOMP_INLINE, 0x76AE},
+       {0x2F6B, 0, 1 | DECOMP_INLINE, 0x76BF},
+       {0x2F6C, 0, 1 | DECOMP_INLINE, 0x76EE},
+       {0x2F6D, 0, 1 | DECOMP_INLINE, 0x77DB},
+       {0x2F6E, 0, 1 | DECOMP_INLINE, 0x77E2},
+       {0x2F6F, 0, 1 | DECOMP_INLINE, 0x77F3},
+       {0x2F70, 0, 1 | DECOMP_INLINE, 0x793A},
+       {0x2F71, 0, 1 | DECOMP_INLINE, 0x79B8},
+       {0x2F72, 0, 1 | DECOMP_INLINE, 0x79BE},
+       {0x2F73, 0, 1 | DECOMP_INLINE, 0x7A74},
+       {0x2F74, 0, 1 | DECOMP_INLINE, 0x7ACB},
+       {0x2F75, 0, 1 | DECOMP_INLINE, 0x7AF9},
+       {0x2F76, 0, 1 | DECOMP_INLINE, 0x7C73},
+       {0x2F77, 0, 1 | DECOMP_INLINE, 0x7CF8},
+       {0x2F78, 0, 1 | DECOMP_INLINE, 0x7F36},
+       {0x2F79, 0, 1 | DECOMP_INLINE, 0x7F51},
+       {0x2F7A, 0, 1 | DECOMP_INLINE, 0x7F8A},
+       {0x2F7B, 0, 1 | DECOMP_INLINE, 0x7FBD},
+       {0x2F7C, 0, 1 | DECOMP_INLINE, 0x8001},
+       {0x2F7D, 0, 1 | DECOMP_INLINE, 0x800C},
+       {0x2F7E, 0, 1 | DECOMP_INLINE, 0x8012},
+       {0x2F7F, 0, 1 | DECOMP_INLINE, 0x8033},
+       {0x2F80, 0, 1 | DECOMP_INLINE, 0x807F},
+       {0x2F81, 0, 1 | DECOMP_INLINE, 0x8089},
+       {0x2F82, 0, 1 | DECOMP_INLINE, 0x81E3},
+       {0x2F83, 0, 1 | DECOMP_INLINE, 0x81EA},
+       {0x2F84, 0, 1 | DECOMP_INLINE, 0x81F3},
+       {0x2F85, 0, 1 | DECOMP_INLINE, 0x81FC},
+       {0x2F86, 0, 1 | DECOMP_INLINE, 0x820C},
+       {0x2F87, 0, 1 | DECOMP_INLINE, 0x821B},
+       {0x2F88, 0, 1 | DECOMP_INLINE, 0x821F},
+       {0x2F89, 0, 1 | DECOMP_INLINE, 0x826E},
+       {0x2F8A, 0, 1 | DECOMP_INLINE, 0x8272},
+       {0x2F8B, 0, 1 | DECOMP_INLINE, 0x8278},
+       {0x2F8C, 0, 1 | DECOMP_INLINE, 0x864D},
+       {0x2F8D, 0, 1 | DECOMP_INLINE, 0x866B},
+       {0x2F8E, 0, 1 | DECOMP_INLINE, 0x8840},
+       {0x2F8F, 0, 1 | DECOMP_INLINE, 0x884C},
+       {0x2F90, 0, 1 | DECOMP_INLINE, 0x8863},
+       {0x2F91, 0, 1 | DECOMP_INLINE, 0x897E},
+       {0x2F92, 0, 1 | DECOMP_INLINE, 0x898B},
+       {0x2F93, 0, 1 | DECOMP_INLINE, 0x89D2},
+       {0x2F94, 0, 1 | DECOMP_INLINE, 0x8A00},
+       {0x2F95, 0, 1 | DECOMP_INLINE, 0x8C37},
+       {0x2F96, 0, 1 | DECOMP_INLINE, 0x8C46},
+       {0x2F97, 0, 1 | DECOMP_INLINE, 0x8C55},
+       {0x2F98, 0, 1 | DECOMP_INLINE, 0x8C78},
+       {0x2F99, 0, 1 | DECOMP_INLINE, 0x8C9D},
+       {0x2F9A, 0, 1 | DECOMP_INLINE, 0x8D64},
+       {0x2F9B, 0, 1 | DECOMP_INLINE, 0x8D70},
+       {0x2F9C, 0, 1 | DECOMP_INLINE, 0x8DB3},
+       {0x2F9D, 0, 1 | DECOMP_INLINE, 0x8EAB},
+       {0x2F9E, 0, 1 | DECOMP_INLINE, 0x8ECA},
+       {0x2F9F, 0, 1 | DECOMP_INLINE, 0x8F9B},
+       {0x2FA0, 0, 1 | DECOMP_INLINE, 0x8FB0},
+       {0x2FA1, 0, 1 | DECOMP_INLINE, 0x8FB5},
+       {0x2FA2, 0, 1 | DECOMP_INLINE, 0x9091},
+       {0x2FA3, 0, 1 | DECOMP_INLINE, 0x9149},
+       {0x2FA4, 0, 1 | DECOMP_INLINE, 0x91C6},
+       {0x2FA5, 0, 1 | DECOMP_INLINE, 0x91CC},
+       {0x2FA6, 0, 1 | DECOMP_INLINE, 0x91D1},
+       {0x2FA7, 0, 1 | DECOMP_INLINE, 0x9577},
+       {0x2FA8, 0, 1 | DECOMP_INLINE, 0x9580},
+       {0x2FA9, 0, 1 | DECOMP_INLINE, 0x961C},
+       {0x2FAA, 0, 1 | DECOMP_INLINE, 0x96B6},
+       {0x2FAB, 0, 1 | DECOMP_INLINE, 0x96B9},
+       {0x2FAC, 0, 1 | DECOMP_INLINE, 0x96E8},
+       {0x2FAD, 0, 1 | DECOMP_INLINE, 0x9751},
+       {0x2FAE, 0, 1 | DECOMP_INLINE, 0x975E},
+       {0x2FAF, 0, 1 | DECOMP_INLINE, 0x9762},
+       {0x2FB0, 0, 1 | DECOMP_INLINE, 0x9769},
+       {0x2FB1, 0, 1 | DECOMP_INLINE, 0x97CB},
+       {0x2FB2, 0, 1 | DECOMP_INLINE, 0x97ED},
+       {0x2FB3, 0, 1 | DECOMP_INLINE, 0x97F3},
+       {0x2FB4, 0, 1 | DECOMP_INLINE, 0x9801},
+       {0x2FB5, 0, 1 | DECOMP_INLINE, 0x98A8},
+       {0x2FB6, 0, 1 | DECOMP_INLINE, 0x98DB},
+       {0x2FB7, 0, 1 | DECOMP_INLINE, 0x98DF},
+       {0x2FB8, 0, 1 | DECOMP_INLINE, 0x9996},
+       {0x2FB9, 0, 1 | DECOMP_INLINE, 0x9999},
+       {0x2FBA, 0, 1 | DECOMP_INLINE, 0x99AC},
+       {0x2FBB, 0, 1 | DECOMP_INLINE, 0x9AA8},
+       {0x2FBC, 0, 1 | DECOMP_INLINE, 0x9AD8},
+       {0x2FBD, 0, 1 | DECOMP_INLINE, 0x9ADF},
+       {0x2FBE, 0, 1 | DECOMP_INLINE, 0x9B25},
+       {0x2FBF, 0, 1 | DECOMP_INLINE, 0x9B2F},
+       {0x2FC0, 0, 1 | DECOMP_INLINE, 0x9B32},
+       {0x2FC1, 0, 1 | DECOMP_INLINE, 0x9B3C},
+       {0x2FC2, 0, 1 | DECOMP_INLINE, 0x9B5A},
+       {0x2FC3, 0, 1 | DECOMP_INLINE, 0x9CE5},
+       {0x2FC4, 0, 1 | DECOMP_INLINE, 0x9E75},
+       {0x2FC5, 0, 1 | DECOMP_INLINE, 0x9E7F},
+       {0x2FC6, 0, 1 | DECOMP_INLINE, 0x9EA5},
+       {0x2FC7, 0, 1 | DECOMP_INLINE, 0x9EBB},
+       {0x2FC8, 0, 1 | DECOMP_INLINE, 0x9EC3},
+       {0x2FC9, 0, 1 | DECOMP_INLINE, 0x9ECD},
+       {0x2FCA, 0, 1 | DECOMP_INLINE, 0x9ED1},
+       {0x2FCB, 0, 1 | DECOMP_INLINE, 0x9EF9},
+       {0x2FCC, 0, 1 | DECOMP_INLINE, 0x9EFD},
+       {0x2FCD, 0, 1 | DECOMP_INLINE, 0x9F0E},
+       {0x2FCE, 0, 1 | DECOMP_INLINE, 0x9F13},
+       {0x2FCF, 0, 1 | DECOMP_INLINE, 0x9F20},
+       {0x2FD0, 0, 1 | DECOMP_INLINE, 0x9F3B},
+       {0x2FD1, 0, 1 | DECOMP_INLINE, 0x9F4A},
+       {0x2FD2, 0, 1 | DECOMP_INLINE, 0x9F52},
+       {0x2FD3, 0, 1 | DECOMP_INLINE, 0x9F8D},
+       {0x2FD4, 0, 1 | DECOMP_INLINE, 0x9F9C},
+       {0x2FD5, 0, 1 | DECOMP_INLINE, 0x9FA0},
+       {0x3000, 0, 1 | DECOMP_INLINE, 0x0020},
+       {0x302A, 218, 0, 0},
+       {0x302B, 228, 0, 0},
+       {0x302C, 232, 0, 0},
+       {0x302D, 222, 0, 0},
+       {0x302E, 224, 0, 0},
+       {0x302F, 224, 0, 0},
+       {0x3036, 0, 1 | DECOMP_INLINE, 0x3012},
+       {0x3038, 0, 1 | DECOMP_INLINE, 0x5341},
+       {0x3039, 0, 1 | DECOMP_INLINE, 0x5344},
+       {0x303A, 0, 1 | DECOMP_INLINE, 0x5345},
+       {0x304C, 0, 2, 2317},
+       {0x304E, 0, 2, 2319},
+       {0x3050, 0, 2, 2321},
+       {0x3052, 0, 2, 2323},
+       {0x3054, 0, 2, 2325},
+       {0x3056, 0, 2, 2327},
+       {0x3058, 0, 2, 2329},
+       {0x305A, 0, 2, 2331},
+       {0x305C, 0, 2, 2333},
+       {0x305E, 0, 2, 2335},
+       {0x3060, 0, 2, 2337},
+       {0x3062, 0, 2, 2339},
+       {0x3065, 0, 2, 2341},
+       {0x3067, 0, 2, 2343},
+       {0x3069, 0, 2, 2345},
+       {0x3070, 0, 2, 2347},
+       {0x3071, 0, 2, 2349},
+       {0x3073, 0, 2, 2351},
+       {0x3074, 0, 2, 2353},
+       {0x3076, 0, 2, 2355},
+       {0x3077, 0, 2, 2357},
+       {0x3079, 0, 2, 2359},
+       {0x307A, 0, 2, 2361},
+       {0x307C, 0, 2, 2363},
+       {0x307D, 0, 2, 2365},
+       {0x3094, 0, 2, 2367},
+       {0x3099, 8, 0, 0},
+       {0x309A, 8, 0, 0},
+       {0x309B, 0, 2 | DECOMP_NO_COMPOSE, 2369},       /* compatibility mapping */
+       {0x309C, 0, 2 | DECOMP_NO_COMPOSE, 2371},       /* compatibility mapping */
+       {0x309E, 0, 2, 2373},
+       {0x309F, 0, 2 | DECOMP_NO_COMPOSE, 2375},       /* compatibility mapping */
+       {0x30AC, 0, 2, 2377},
+       {0x30AE, 0, 2, 2379},
+       {0x30B0, 0, 2, 2381},
+       {0x30B2, 0, 2, 2383},
+       {0x30B4, 0, 2, 2385},
+       {0x30B6, 0, 2, 2387},
+       {0x30B8, 0, 2, 2389},
+       {0x30BA, 0, 2, 2391},
+       {0x30BC, 0, 2, 2393},
+       {0x30BE, 0, 2, 2395},
+       {0x30C0, 0, 2, 2397},
+       {0x30C2, 0, 2, 2399},
+       {0x30C5, 0, 2, 2401},
+       {0x30C7, 0, 2, 2403},
+       {0x30C9, 0, 2, 2405},
+       {0x30D0, 0, 2, 2407},
+       {0x30D1, 0, 2, 2409},
+       {0x30D3, 0, 2, 2411},
+       {0x30D4, 0, 2, 2413},
+       {0x30D6, 0, 2, 2415},
+       {0x30D7, 0, 2, 2417},
+       {0x30D9, 0, 2, 2419},
+       {0x30DA, 0, 2, 2421},
+       {0x30DC, 0, 2, 2423},
+       {0x30DD, 0, 2, 2425},
+       {0x30F4, 0, 2, 2427},
+       {0x30F7, 0, 2, 2429},
+       {0x30F8, 0, 2, 2431},
+       {0x30F9, 0, 2, 2433},
+       {0x30FA, 0, 2, 2435},
+       {0x30FE, 0, 2, 2437},
+       {0x30FF, 0, 2 | DECOMP_NO_COMPOSE, 2439},       /* compatibility mapping */
+       {0x3131, 0, 1 | DECOMP_INLINE, 0x1100},
+       {0x3132, 0, 1 | DECOMP_INLINE, 0x1101},
+       {0x3133, 0, 1 | DECOMP_INLINE, 0x11AA},
+       {0x3134, 0, 1 | DECOMP_INLINE, 0x1102},
+       {0x3135, 0, 1 | DECOMP_INLINE, 0x11AC},
+       {0x3136, 0, 1 | DECOMP_INLINE, 0x11AD},
+       {0x3137, 0, 1 | DECOMP_INLINE, 0x1103},
+       {0x3138, 0, 1 | DECOMP_INLINE, 0x1104},
+       {0x3139, 0, 1 | DECOMP_INLINE, 0x1105},
+       {0x313A, 0, 1 | DECOMP_INLINE, 0x11B0},
+       {0x313B, 0, 1 | DECOMP_INLINE, 0x11B1},
+       {0x313C, 0, 1 | DECOMP_INLINE, 0x11B2},
+       {0x313D, 0, 1 | DECOMP_INLINE, 0x11B3},
+       {0x313E, 0, 1 | DECOMP_INLINE, 0x11B4},
+       {0x313F, 0, 1 | DECOMP_INLINE, 0x11B5},
+       {0x3140, 0, 1 | DECOMP_INLINE, 0x111A},
+       {0x3141, 0, 1 | DECOMP_INLINE, 0x1106},
+       {0x3142, 0, 1 | DECOMP_INLINE, 0x1107},
+       {0x3143, 0, 1 | DECOMP_INLINE, 0x1108},
+       {0x3144, 0, 1 | DECOMP_INLINE, 0x1121},
+       {0x3145, 0, 1 | DECOMP_INLINE, 0x1109},
+       {0x3146, 0, 1 | DECOMP_INLINE, 0x110A},
+       {0x3147, 0, 1 | DECOMP_INLINE, 0x110B},
+       {0x3148, 0, 1 | DECOMP_INLINE, 0x110C},
+       {0x3149, 0, 1 | DECOMP_INLINE, 0x110D},
+       {0x314A, 0, 1 | DECOMP_INLINE, 0x110E},
+       {0x314B, 0, 1 | DECOMP_INLINE, 0x110F},
+       {0x314C, 0, 1 | DECOMP_INLINE, 0x1110},
+       {0x314D, 0, 1 | DECOMP_INLINE, 0x1111},
+       {0x314E, 0, 1 | DECOMP_INLINE, 0x1112},
+       {0x314F, 0, 1 | DECOMP_INLINE, 0x1161},
+       {0x3150, 0, 1 | DECOMP_INLINE, 0x1162},
+       {0x3151, 0, 1 | DECOMP_INLINE, 0x1163},
+       {0x3152, 0, 1 | DECOMP_INLINE, 0x1164},
+       {0x3153, 0, 1 | DECOMP_INLINE, 0x1165},
+       {0x3154, 0, 1 | DECOMP_INLINE, 0x1166},
+       {0x3155, 0, 1 | DECOMP_INLINE, 0x1167},
+       {0x3156, 0, 1 | DECOMP_INLINE, 0x1168},
+       {0x3157, 0, 1 | DECOMP_INLINE, 0x1169},
+       {0x3158, 0, 1 | DECOMP_INLINE, 0x116A},
+       {0x3159, 0, 1 | DECOMP_INLINE, 0x116B},
+       {0x315A, 0, 1 | DECOMP_INLINE, 0x116C},
+       {0x315B, 0, 1 | DECOMP_INLINE, 0x116D},
+       {0x315C, 0, 1 | DECOMP_INLINE, 0x116E},
+       {0x315D, 0, 1 | DECOMP_INLINE, 0x116F},
+       {0x315E, 0, 1 | DECOMP_INLINE, 0x1170},
+       {0x315F, 0, 1 | DECOMP_INLINE, 0x1171},
+       {0x3160, 0, 1 | DECOMP_INLINE, 0x1172},
+       {0x3161, 0, 1 | DECOMP_INLINE, 0x1173},
+       {0x3162, 0, 1 | DECOMP_INLINE, 0x1174},
+       {0x3163, 0, 1 | DECOMP_INLINE, 0x1175},
+       {0x3164, 0, 1 | DECOMP_INLINE, 0x1160},
+       {0x3165, 0, 1 | DECOMP_INLINE, 0x1114},
+       {0x3166, 0, 1 | DECOMP_INLINE, 0x1115},
+       {0x3167, 0, 1 | DECOMP_INLINE, 0x11C7},
+       {0x3168, 0, 1 | DECOMP_INLINE, 0x11C8},
+       {0x3169, 0, 1 | DECOMP_INLINE, 0x11CC},
+       {0x316A, 0, 1 | DECOMP_INLINE, 0x11CE},
+       {0x316B, 0, 1 | DECOMP_INLINE, 0x11D3},
+       {0x316C, 0, 1 | DECOMP_INLINE, 0x11D7},
+       {0x316D, 0, 1 | DECOMP_INLINE, 0x11D9},
+       {0x316E, 0, 1 | DECOMP_INLINE, 0x111C},
+       {0x316F, 0, 1 | DECOMP_INLINE, 0x11DD},
+       {0x3170, 0, 1 | DECOMP_INLINE, 0x11DF},
+       {0x3171, 0, 1 | DECOMP_INLINE, 0x111D},
+       {0x3172, 0, 1 | DECOMP_INLINE, 0x111E},
+       {0x3173, 0, 1 | DECOMP_INLINE, 0x1120},
+       {0x3174, 0, 1 | DECOMP_INLINE, 0x1122},
+       {0x3175, 0, 1 | DECOMP_INLINE, 0x1123},
+       {0x3176, 0, 1 | DECOMP_INLINE, 0x1127},
+       {0x3177, 0, 1 | DECOMP_INLINE, 0x1129},
+       {0x3178, 0, 1 | DECOMP_INLINE, 0x112B},
+       {0x3179, 0, 1 | DECOMP_INLINE, 0x112C},
+       {0x317A, 0, 1 | DECOMP_INLINE, 0x112D},
+       {0x317B, 0, 1 | DECOMP_INLINE, 0x112E},
+       {0x317C, 0, 1 | DECOMP_INLINE, 0x112F},
+       {0x317D, 0, 1 | DECOMP_INLINE, 0x1132},
+       {0x317E, 0, 1 | DECOMP_INLINE, 0x1136},
+       {0x317F, 0, 1 | DECOMP_INLINE, 0x1140},
+       {0x3180, 0, 1 | DECOMP_INLINE, 0x1147},
+       {0x3181, 0, 1 | DECOMP_INLINE, 0x114C},
+       {0x3182, 0, 1 | DECOMP_INLINE, 0x11F1},
+       {0x3183, 0, 1 | DECOMP_INLINE, 0x11F2},
+       {0x3184, 0, 1 | DECOMP_INLINE, 0x1157},
+       {0x3185, 0, 1 | DECOMP_INLINE, 0x1158},
+       {0x3186, 0, 1 | DECOMP_INLINE, 0x1159},
+       {0x3187, 0, 1 | DECOMP_INLINE, 0x1184},
+       {0x3188, 0, 1 | DECOMP_INLINE, 0x1185},
+       {0x3189, 0, 1 | DECOMP_INLINE, 0x1188},
+       {0x318A, 0, 1 | DECOMP_INLINE, 0x1191},
+       {0x318B, 0, 1 | DECOMP_INLINE, 0x1192},
+       {0x318C, 0, 1 | DECOMP_INLINE, 0x1194},
+       {0x318D, 0, 1 | DECOMP_INLINE, 0x119E},
+       {0x318E, 0, 1 | DECOMP_INLINE, 0x11A1},
+       {0x3192, 0, 1 | DECOMP_INLINE, 0x4E00},
+       {0x3193, 0, 1 | DECOMP_INLINE, 0x4E8C},
+       {0x3194, 0, 1 | DECOMP_INLINE, 0x4E09},
+       {0x3195, 0, 1 | DECOMP_INLINE, 0x56DB},
+       {0x3196, 0, 1 | DECOMP_INLINE, 0x4E0A},
+       {0x3197, 0, 1 | DECOMP_INLINE, 0x4E2D},
+       {0x3198, 0, 1 | DECOMP_INLINE, 0x4E0B},
+       {0x3199, 0, 1 | DECOMP_INLINE, 0x7532},
+       {0x319A, 0, 1 | DECOMP_INLINE, 0x4E59},
+       {0x319B, 0, 1 | DECOMP_INLINE, 0x4E19},
+       {0x319C, 0, 1 | DECOMP_INLINE, 0x4E01},
+       {0x319D, 0, 1 | DECOMP_INLINE, 0x5929},
+       {0x319E, 0, 1 | DECOMP_INLINE, 0x5730},
+       {0x319F, 0, 1 | DECOMP_INLINE, 0x4EBA},
+       {0x3200, 0, 3, 2441},
+       {0x3201, 0, 3, 2444},
+       {0x3202, 0, 3, 2447},
+       {0x3203, 0, 3, 2450},
+       {0x3204, 0, 3, 2453},
+       {0x3205, 0, 3, 2456},
+       {0x3206, 0, 3, 2459},
+       {0x3207, 0, 3, 2462},
+       {0x3208, 0, 3, 2465},
+       {0x3209, 0, 3, 2468},
+       {0x320A, 0, 3, 2471},
+       {0x320B, 0, 3, 2474},
+       {0x320C, 0, 3, 2477},
+       {0x320D, 0, 3, 2480},
+       {0x320E, 0, 4, 2483},
+       {0x320F, 0, 4, 2487},
+       {0x3210, 0, 4, 2491},
+       {0x3211, 0, 4, 2495},
+       {0x3212, 0, 4, 2499},
+       {0x3213, 0, 4, 2503},
+       {0x3214, 0, 4, 2507},
+       {0x3215, 0, 4, 2511},
+       {0x3216, 0, 4, 2515},
+       {0x3217, 0, 4, 2519},
+       {0x3218, 0, 4, 2523},
+       {0x3219, 0, 4, 2527},
+       {0x321A, 0, 4, 2531},
+       {0x321B, 0, 4, 2535},
+       {0x321C, 0, 4, 2539},
+       {0x321D, 0, 7, 2543},
+       {0x321E, 0, 6, 2550},
+       {0x3220, 0, 3, 2556},
+       {0x3221, 0, 3, 2559},
+       {0x3222, 0, 3, 2562},
+       {0x3223, 0, 3, 2565},
+       {0x3224, 0, 3, 2568},
+       {0x3225, 0, 3, 2571},
+       {0x3226, 0, 3, 2574},
+       {0x3227, 0, 3, 2577},
+       {0x3228, 0, 3, 2580},
+       {0x3229, 0, 3, 2583},
+       {0x322A, 0, 3, 2586},
+       {0x322B, 0, 3, 2589},
+       {0x322C, 0, 3, 2592},
+       {0x322D, 0, 3, 2595},
+       {0x322E, 0, 3, 2598},
+       {0x322F, 0, 3, 2601},
+       {0x3230, 0, 3, 2604},
+       {0x3231, 0, 3, 2607},
+       {0x3232, 0, 3, 2610},
+       {0x3233, 0, 3, 2613},
+       {0x3234, 0, 3, 2616},
+       {0x3235, 0, 3, 2619},
+       {0x3236, 0, 3, 2622},
+       {0x3237, 0, 3, 2625},
+       {0x3238, 0, 3, 2628},
+       {0x3239, 0, 3, 2631},
+       {0x323A, 0, 3, 2634},
+       {0x323B, 0, 3, 2637},
+       {0x323C, 0, 3, 2640},
+       {0x323D, 0, 3, 2643},
+       {0x323E, 0, 3, 2646},
+       {0x323F, 0, 3, 2649},
+       {0x3240, 0, 3, 2652},
+       {0x3241, 0, 3, 2655},
+       {0x3242, 0, 3, 2658},
+       {0x3243, 0, 3, 2661},
+       {0x3244, 0, 1 | DECOMP_INLINE, 0x554F},
+       {0x3245, 0, 1 | DECOMP_INLINE, 0x5E7C},
+       {0x3246, 0, 1 | DECOMP_INLINE, 0x6587},
+       {0x3247, 0, 1 | DECOMP_INLINE, 0x7B8F},
+       {0x3250, 0, 3, 2664},
+       {0x3251, 0, 2 | DECOMP_NO_COMPOSE, 2667},       /* compatibility mapping */
+       {0x3252, 0, 2 | DECOMP_NO_COMPOSE, 2669},       /* compatibility mapping */
+       {0x3253, 0, 2 | DECOMP_NO_COMPOSE, 2671},       /* compatibility mapping */
+       {0x3254, 0, 2 | DECOMP_NO_COMPOSE, 2673},       /* compatibility mapping */
+       {0x3255, 0, 2 | DECOMP_NO_COMPOSE, 2675},       /* compatibility mapping */
+       {0x3256, 0, 2 | DECOMP_NO_COMPOSE, 2677},       /* compatibility mapping */
+       {0x3257, 0, 2 | DECOMP_NO_COMPOSE, 2679},       /* compatibility mapping */
+       {0x3258, 0, 2 | DECOMP_NO_COMPOSE, 2681},       /* compatibility mapping */
+       {0x3259, 0, 2 | DECOMP_NO_COMPOSE, 2683},       /* compatibility mapping */
+       {0x325A, 0, 2 | DECOMP_NO_COMPOSE, 2685},       /* compatibility mapping */
+       {0x325B, 0, 2 | DECOMP_NO_COMPOSE, 2687},       /* compatibility mapping */
+       {0x325C, 0, 2 | DECOMP_NO_COMPOSE, 2689},       /* compatibility mapping */
+       {0x325D, 0, 2 | DECOMP_NO_COMPOSE, 2691},       /* compatibility mapping */
+       {0x325E, 0, 2 | DECOMP_NO_COMPOSE, 2693},       /* compatibility mapping */
+       {0x325F, 0, 2 | DECOMP_NO_COMPOSE, 2695},       /* compatibility mapping */
+       {0x3260, 0, 1 | DECOMP_INLINE, 0x1100},
+       {0x3261, 0, 1 | DECOMP_INLINE, 0x1102},
+       {0x3262, 0, 1 | DECOMP_INLINE, 0x1103},
+       {0x3263, 0, 1 | DECOMP_INLINE, 0x1105},
+       {0x3264, 0, 1 | DECOMP_INLINE, 0x1106},
+       {0x3265, 0, 1 | DECOMP_INLINE, 0x1107},
+       {0x3266, 0, 1 | DECOMP_INLINE, 0x1109},
+       {0x3267, 0, 1 | DECOMP_INLINE, 0x110B},
+       {0x3268, 0, 1 | DECOMP_INLINE, 0x110C},
+       {0x3269, 0, 1 | DECOMP_INLINE, 0x110E},
+       {0x326A, 0, 1 | DECOMP_INLINE, 0x110F},
+       {0x326B, 0, 1 | DECOMP_INLINE, 0x1110},
+       {0x326C, 0, 1 | DECOMP_INLINE, 0x1111},
+       {0x326D, 0, 1 | DECOMP_INLINE, 0x1112},
+       {0x326E, 0, 2 | DECOMP_NO_COMPOSE, 2697},       /* compatibility mapping */
+       {0x326F, 0, 2 | DECOMP_NO_COMPOSE, 2699},       /* compatibility mapping */
+       {0x3270, 0, 2 | DECOMP_NO_COMPOSE, 2701},       /* compatibility mapping */
+       {0x3271, 0, 2 | DECOMP_NO_COMPOSE, 2703},       /* compatibility mapping */
+       {0x3272, 0, 2 | DECOMP_NO_COMPOSE, 2705},       /* compatibility mapping */
+       {0x3273, 0, 2 | DECOMP_NO_COMPOSE, 2707},       /* compatibility mapping */
+       {0x3274, 0, 2 | DECOMP_NO_COMPOSE, 2709},       /* compatibility mapping */
+       {0x3275, 0, 2 | DECOMP_NO_COMPOSE, 2711},       /* compatibility mapping */
+       {0x3276, 0, 2 | DECOMP_NO_COMPOSE, 2713},       /* compatibility mapping */
+       {0x3277, 0, 2 | DECOMP_NO_COMPOSE, 2715},       /* compatibility mapping */
+       {0x3278, 0, 2 | DECOMP_NO_COMPOSE, 2717},       /* compatibility mapping */
+       {0x3279, 0, 2 | DECOMP_NO_COMPOSE, 2719},       /* compatibility mapping */
+       {0x327A, 0, 2 | DECOMP_NO_COMPOSE, 2721},       /* compatibility mapping */
+       {0x327B, 0, 2 | DECOMP_NO_COMPOSE, 2723},       /* compatibility mapping */
+       {0x327C, 0, 5, 2725},
+       {0x327D, 0, 4, 2730},
+       {0x327E, 0, 2 | DECOMP_NO_COMPOSE, 2734},       /* compatibility mapping */
+       {0x3280, 0, 1 | DECOMP_INLINE, 0x4E00},
+       {0x3281, 0, 1 | DECOMP_INLINE, 0x4E8C},
+       {0x3282, 0, 1 | DECOMP_INLINE, 0x4E09},
+       {0x3283, 0, 1 | DECOMP_INLINE, 0x56DB},
+       {0x3284, 0, 1 | DECOMP_INLINE, 0x4E94},
+       {0x3285, 0, 1 | DECOMP_INLINE, 0x516D},
+       {0x3286, 0, 1 | DECOMP_INLINE, 0x4E03},
+       {0x3287, 0, 1 | DECOMP_INLINE, 0x516B},
+       {0x3288, 0, 1 | DECOMP_INLINE, 0x4E5D},
+       {0x3289, 0, 1 | DECOMP_INLINE, 0x5341},
+       {0x328A, 0, 1 | DECOMP_INLINE, 0x6708},
+       {0x328B, 0, 1 | DECOMP_INLINE, 0x706B},
+       {0x328C, 0, 1 | DECOMP_INLINE, 0x6C34},
+       {0x328D, 0, 1 | DECOMP_INLINE, 0x6728},
+       {0x328E, 0, 1 | DECOMP_INLINE, 0x91D1},
+       {0x328F, 0, 1 | DECOMP_INLINE, 0x571F},
+       {0x3290, 0, 1 | DECOMP_INLINE, 0x65E5},
+       {0x3291, 0, 1 | DECOMP_INLINE, 0x682A},
+       {0x3292, 0, 1 | DECOMP_INLINE, 0x6709},
+       {0x3293, 0, 1 | DECOMP_INLINE, 0x793E},
+       {0x3294, 0, 1 | DECOMP_INLINE, 0x540D},
+       {0x3295, 0, 1 | DECOMP_INLINE, 0x7279},
+       {0x3296, 0, 1 | DECOMP_INLINE, 0x8CA1},
+       {0x3297, 0, 1 | DECOMP_INLINE, 0x795D},
+       {0x3298, 0, 1 | DECOMP_INLINE, 0x52B4},
+       {0x3299, 0, 1 | DECOMP_INLINE, 0x79D8},
+       {0x329A, 0, 1 | DECOMP_INLINE, 0x7537},
+       {0x329B, 0, 1 | DECOMP_INLINE, 0x5973},
+       {0x329C, 0, 1 | DECOMP_INLINE, 0x9069},
+       {0x329D, 0, 1 | DECOMP_INLINE, 0x512A},
+       {0x329E, 0, 1 | DECOMP_INLINE, 0x5370},
+       {0x329F, 0, 1 | DECOMP_INLINE, 0x6CE8},
+       {0x32A0, 0, 1 | DECOMP_INLINE, 0x9805},
+       {0x32A1, 0, 1 | DECOMP_INLINE, 0x4F11},
+       {0x32A2, 0, 1 | DECOMP_INLINE, 0x5199},
+       {0x32A3, 0, 1 | DECOMP_INLINE, 0x6B63},
+       {0x32A4, 0, 1 | DECOMP_INLINE, 0x4E0A},
+       {0x32A5, 0, 1 | DECOMP_INLINE, 0x4E2D},
+       {0x32A6, 0, 1 | DECOMP_INLINE, 0x4E0B},
+       {0x32A7, 0, 1 | DECOMP_INLINE, 0x5DE6},
+       {0x32A8, 0, 1 | DECOMP_INLINE, 0x53F3},
+       {0x32A9, 0, 1 | DECOMP_INLINE, 0x533B},
+       {0x32AA, 0, 1 | DECOMP_INLINE, 0x5B97},
+       {0x32AB, 0, 1 | DECOMP_INLINE, 0x5B66},
+       {0x32AC, 0, 1 | DECOMP_INLINE, 0x76E3},
+       {0x32AD, 0, 1 | DECOMP_INLINE, 0x4F01},
+       {0x32AE, 0, 1 | DECOMP_INLINE, 0x8CC7},
+       {0x32AF, 0, 1 | DECOMP_INLINE, 0x5354},
+       {0x32B0, 0, 1 | DECOMP_INLINE, 0x591C},
+       {0x32B1, 0, 2 | DECOMP_NO_COMPOSE, 2736},       /* compatibility mapping */
+       {0x32B2, 0, 2 | DECOMP_NO_COMPOSE, 2738},       /* compatibility mapping */
+       {0x32B3, 0, 2 | DECOMP_NO_COMPOSE, 2740},       /* compatibility mapping */
+       {0x32B4, 0, 2 | DECOMP_NO_COMPOSE, 2742},       /* compatibility mapping */
+       {0x32B5, 0, 2 | DECOMP_NO_COMPOSE, 2744},       /* compatibility mapping */
+       {0x32B6, 0, 2 | DECOMP_NO_COMPOSE, 2746},       /* compatibility mapping */
+       {0x32B7, 0, 2 | DECOMP_NO_COMPOSE, 2748},       /* compatibility mapping */
+       {0x32B8, 0, 2 | DECOMP_NO_COMPOSE, 2750},       /* compatibility mapping */
+       {0x32B9, 0, 2 | DECOMP_NO_COMPOSE, 2752},       /* compatibility mapping */
+       {0x32BA, 0, 2 | DECOMP_NO_COMPOSE, 2754},       /* compatibility mapping */
+       {0x32BB, 0, 2 | DECOMP_NO_COMPOSE, 2756},       /* compatibility mapping */
+       {0x32BC, 0, 2 | DECOMP_NO_COMPOSE, 2758},       /* compatibility mapping */
+       {0x32BD, 0, 2 | DECOMP_NO_COMPOSE, 2760},       /* compatibility mapping */
+       {0x32BE, 0, 2 | DECOMP_NO_COMPOSE, 2762},       /* compatibility mapping */
+       {0x32BF, 0, 2 | DECOMP_NO_COMPOSE, 2764},       /* compatibility mapping */
+       {0x32C0, 0, 2 | DECOMP_NO_COMPOSE, 2766},       /* compatibility mapping */
+       {0x32C1, 0, 2 | DECOMP_NO_COMPOSE, 2768},       /* compatibility mapping */
+       {0x32C2, 0, 2 | DECOMP_NO_COMPOSE, 2770},       /* compatibility mapping */
+       {0x32C3, 0, 2 | DECOMP_NO_COMPOSE, 2772},       /* compatibility mapping */
+       {0x32C4, 0, 2 | DECOMP_NO_COMPOSE, 2774},       /* compatibility mapping */
+       {0x32C5, 0, 2 | DECOMP_NO_COMPOSE, 2776},       /* compatibility mapping */
+       {0x32C6, 0, 2 | DECOMP_NO_COMPOSE, 2778},       /* compatibility mapping */
+       {0x32C7, 0, 2 | DECOMP_NO_COMPOSE, 2780},       /* compatibility mapping */
+       {0x32C8, 0, 2 | DECOMP_NO_COMPOSE, 2782},       /* compatibility mapping */
+       {0x32C9, 0, 3, 2784},
+       {0x32CA, 0, 3, 2787},
+       {0x32CB, 0, 3, 2790},
+       {0x32CC, 0, 2 | DECOMP_NO_COMPOSE, 2793},       /* compatibility mapping */
+       {0x32CD, 0, 3, 2795},
+       {0x32CE, 0, 2 | DECOMP_NO_COMPOSE, 2798},       /* compatibility mapping */
+       {0x32CF, 0, 3, 2800},
+       {0x32D0, 0, 1 | DECOMP_INLINE, 0x30A2},
+       {0x32D1, 0, 1 | DECOMP_INLINE, 0x30A4},
+       {0x32D2, 0, 1 | DECOMP_INLINE, 0x30A6},
+       {0x32D3, 0, 1 | DECOMP_INLINE, 0x30A8},
+       {0x32D4, 0, 1 | DECOMP_INLINE, 0x30AA},
+       {0x32D5, 0, 1 | DECOMP_INLINE, 0x30AB},
+       {0x32D6, 0, 1 | DECOMP_INLINE, 0x30AD},
+       {0x32D7, 0, 1 | DECOMP_INLINE, 0x30AF},
+       {0x32D8, 0, 1 | DECOMP_INLINE, 0x30B1},
+       {0x32D9, 0, 1 | DECOMP_INLINE, 0x30B3},
+       {0x32DA, 0, 1 | DECOMP_INLINE, 0x30B5},
+       {0x32DB, 0, 1 | DECOMP_INLINE, 0x30B7},
+       {0x32DC, 0, 1 | DECOMP_INLINE, 0x30B9},
+       {0x32DD, 0, 1 | DECOMP_INLINE, 0x30BB},
+       {0x32DE, 0, 1 | DECOMP_INLINE, 0x30BD},
+       {0x32DF, 0, 1 | DECOMP_INLINE, 0x30BF},
+       {0x32E0, 0, 1 | DECOMP_INLINE, 0x30C1},
+       {0x32E1, 0, 1 | DECOMP_INLINE, 0x30C4},
+       {0x32E2, 0, 1 | DECOMP_INLINE, 0x30C6},
+       {0x32E3, 0, 1 | DECOMP_INLINE, 0x30C8},
+       {0x32E4, 0, 1 | DECOMP_INLINE, 0x30CA},
+       {0x32E5, 0, 1 | DECOMP_INLINE, 0x30CB},
+       {0x32E6, 0, 1 | DECOMP_INLINE, 0x30CC},
+       {0x32E7, 0, 1 | DECOMP_INLINE, 0x30CD},
+       {0x32E8, 0, 1 | DECOMP_INLINE, 0x30CE},
+       {0x32E9, 0, 1 | DECOMP_INLINE, 0x30CF},
+       {0x32EA, 0, 1 | DECOMP_INLINE, 0x30D2},
+       {0x32EB, 0, 1 | DECOMP_INLINE, 0x30D5},
+       {0x32EC, 0, 1 | DECOMP_INLINE, 0x30D8},
+       {0x32ED, 0, 1 | DECOMP_INLINE, 0x30DB},
+       {0x32EE, 0, 1 | DECOMP_INLINE, 0x30DE},
+       {0x32EF, 0, 1 | DECOMP_INLINE, 0x30DF},
+       {0x32F0, 0, 1 | DECOMP_INLINE, 0x30E0},
+       {0x32F1, 0, 1 | DECOMP_INLINE, 0x30E1},
+       {0x32F2, 0, 1 | DECOMP_INLINE, 0x30E2},
+       {0x32F3, 0, 1 | DECOMP_INLINE, 0x30E4},
+       {0x32F4, 0, 1 | DECOMP_INLINE, 0x30E6},
+       {0x32F5, 0, 1 | DECOMP_INLINE, 0x30E8},
+       {0x32F6, 0, 1 | DECOMP_INLINE, 0x30E9},
+       {0x32F7, 0, 1 | DECOMP_INLINE, 0x30EA},
+       {0x32F8, 0, 1 | DECOMP_INLINE, 0x30EB},
+       {0x32F9, 0, 1 | DECOMP_INLINE, 0x30EC},
+       {0x32FA, 0, 1 | DECOMP_INLINE, 0x30ED},
+       {0x32FB, 0, 1 | DECOMP_INLINE, 0x30EF},
+       {0x32FC, 0, 1 | DECOMP_INLINE, 0x30F0},
+       {0x32FD, 0, 1 | DECOMP_INLINE, 0x30F1},
+       {0x32FE, 0, 1 | DECOMP_INLINE, 0x30F2},
+       {0x3300, 0, 4, 2803},
+       {0x3301, 0, 4, 2807},
+       {0x3302, 0, 4, 2811},
+       {0x3303, 0, 3, 2815},
+       {0x3304, 0, 4, 2818},
+       {0x3305, 0, 3, 2822},
+       {0x3306, 0, 3, 2825},
+       {0x3307, 0, 5, 2828},
+       {0x3308, 0, 4, 2833},
+       {0x3309, 0, 3, 2837},
+       {0x330A, 0, 3, 2840},
+       {0x330B, 0, 3, 2843},
+       {0x330C, 0, 4, 2846},
+       {0x330D, 0, 4, 2850},
+       {0x330E, 0, 3, 2854},
+       {0x330F, 0, 3, 2857},
+       {0x3310, 0, 2 | DECOMP_NO_COMPOSE, 2860},       /* compatibility mapping */
+       {0x3311, 0, 3, 2862},
+       {0x3312, 0, 4, 2865},
+       {0x3313, 0, 4, 2869},
+       {0x3314, 0, 2 | DECOMP_NO_COMPOSE, 2873},       /* compatibility mapping */
+       {0x3315, 0, 5, 2875},
+       {0x3316, 0, 6, 2880},
+       {0x3317, 0, 5, 2886},
+       {0x3318, 0, 3, 2891},
+       {0x3319, 0, 5, 2894},
+       {0x331A, 0, 5, 2899},
+       {0x331B, 0, 4, 2904},
+       {0x331C, 0, 3, 2908},
+       {0x331D, 0, 3, 2911},
+       {0x331E, 0, 3, 2914},
+       {0x331F, 0, 4, 2917},
+       {0x3320, 0, 5, 2921},
+       {0x3321, 0, 4, 2926},
+       {0x3322, 0, 3, 2930},
+       {0x3323, 0, 3, 2933},
+       {0x3324, 0, 3, 2936},
+       {0x3325, 0, 2 | DECOMP_NO_COMPOSE, 2939},       /* compatibility mapping */
+       {0x3326, 0, 2 | DECOMP_NO_COMPOSE, 2941},       /* compatibility mapping */
+       {0x3327, 0, 2 | DECOMP_NO_COMPOSE, 2943},       /* compatibility mapping */
+       {0x3328, 0, 2 | DECOMP_NO_COMPOSE, 2945},       /* compatibility mapping */
+       {0x3329, 0, 3, 2947},
+       {0x332A, 0, 3, 2950},
+       {0x332B, 0, 5, 2953},
+       {0x332C, 0, 3, 2958},
+       {0x332D, 0, 4, 2961},
+       {0x332E, 0, 5, 2965},
+       {0x332F, 0, 3, 2970},
+       {0x3330, 0, 2 | DECOMP_NO_COMPOSE, 2973},       /* compatibility mapping */
+       {0x3331, 0, 2 | DECOMP_NO_COMPOSE, 2975},       /* compatibility mapping */
+       {0x3332, 0, 5, 2977},
+       {0x3333, 0, 4, 2982},
+       {0x3334, 0, 5, 2986},
+       {0x3335, 0, 3, 2991},
+       {0x3336, 0, 5, 2994},
+       {0x3337, 0, 2 | DECOMP_NO_COMPOSE, 2999},       /* compatibility mapping */
+       {0x3338, 0, 3, 3001},
+       {0x3339, 0, 3, 3004},
+       {0x333A, 0, 3, 3007},
+       {0x333B, 0, 3, 3010},
+       {0x333C, 0, 3, 3013},
+       {0x333D, 0, 4, 3016},
+       {0x333E, 0, 3, 3020},
+       {0x333F, 0, 2 | DECOMP_NO_COMPOSE, 3023},       /* compatibility mapping */
+       {0x3340, 0, 3, 3025},
+       {0x3341, 0, 3, 3028},
+       {0x3342, 0, 3, 3031},
+       {0x3343, 0, 4, 3034},
+       {0x3344, 0, 3, 3038},
+       {0x3345, 0, 3, 3041},
+       {0x3346, 0, 3, 3044},
+       {0x3347, 0, 5, 3047},
+       {0x3348, 0, 4, 3052},
+       {0x3349, 0, 2 | DECOMP_NO_COMPOSE, 3056},       /* compatibility mapping */
+       {0x334A, 0, 5, 3058},
+       {0x334B, 0, 2 | DECOMP_NO_COMPOSE, 3063},       /* compatibility mapping */
+       {0x334C, 0, 4, 3065},
+       {0x334D, 0, 4, 3069},
+       {0x334E, 0, 3, 3073},
+       {0x334F, 0, 3, 3076},
+       {0x3350, 0, 3, 3079},
+       {0x3351, 0, 4, 3082},
+       {0x3352, 0, 2 | DECOMP_NO_COMPOSE, 3086},       /* compatibility mapping */
+       {0x3353, 0, 3, 3088},
+       {0x3354, 0, 4, 3091},
+       {0x3355, 0, 2 | DECOMP_NO_COMPOSE, 3095},       /* compatibility mapping */
+       {0x3356, 0, 5, 3097},
+       {0x3357, 0, 3, 3102},
+       {0x3358, 0, 2 | DECOMP_NO_COMPOSE, 3105},       /* compatibility mapping */
+       {0x3359, 0, 2 | DECOMP_NO_COMPOSE, 3107},       /* compatibility mapping */
+       {0x335A, 0, 2 | DECOMP_NO_COMPOSE, 3109},       /* compatibility mapping */
+       {0x335B, 0, 2 | DECOMP_NO_COMPOSE, 3111},       /* compatibility mapping */
+       {0x335C, 0, 2 | DECOMP_NO_COMPOSE, 3113},       /* compatibility mapping */
+       {0x335D, 0, 2 | DECOMP_NO_COMPOSE, 3115},       /* compatibility mapping */
+       {0x335E, 0, 2 | DECOMP_NO_COMPOSE, 3117},       /* compatibility mapping */
+       {0x335F, 0, 2 | DECOMP_NO_COMPOSE, 3119},       /* compatibility mapping */
+       {0x3360, 0, 2 | DECOMP_NO_COMPOSE, 3121},       /* compatibility mapping */
+       {0x3361, 0, 2 | DECOMP_NO_COMPOSE, 3123},       /* compatibility mapping */
+       {0x3362, 0, 3, 3125},
+       {0x3363, 0, 3, 3128},
+       {0x3364, 0, 3, 3131},
+       {0x3365, 0, 3, 3134},
+       {0x3366, 0, 3, 3137},
+       {0x3367, 0, 3, 3140},
+       {0x3368, 0, 3, 3143},
+       {0x3369, 0, 3, 3146},
+       {0x336A, 0, 3, 3149},
+       {0x336B, 0, 3, 3152},
+       {0x336C, 0, 3, 3155},
+       {0x336D, 0, 3, 3158},
+       {0x336E, 0, 3, 3161},
+       {0x336F, 0, 3, 3164},
+       {0x3370, 0, 3, 3167},
+       {0x3371, 0, 3, 3170},
+       {0x3372, 0, 2 | DECOMP_NO_COMPOSE, 3173},       /* compatibility mapping */
+       {0x3373, 0, 2 | DECOMP_NO_COMPOSE, 3175},       /* compatibility mapping */
+       {0x3374, 0, 3, 3177},
+       {0x3375, 0, 2 | DECOMP_NO_COMPOSE, 3180},       /* compatibility mapping */
+       {0x3376, 0, 2 | DECOMP_NO_COMPOSE, 3182},       /* compatibility mapping */
+       {0x3377, 0, 2 | DECOMP_NO_COMPOSE, 3184},       /* compatibility mapping */
+       {0x3378, 0, 3, 3186},
+       {0x3379, 0, 3, 3189},
+       {0x337A, 0, 2 | DECOMP_NO_COMPOSE, 3192},       /* compatibility mapping */
+       {0x337B, 0, 2 | DECOMP_NO_COMPOSE, 3194},       /* compatibility mapping */
+       {0x337C, 0, 2 | DECOMP_NO_COMPOSE, 3196},       /* compatibility mapping */
+       {0x337D, 0, 2 | DECOMP_NO_COMPOSE, 3198},       /* compatibility mapping */
+       {0x337E, 0, 2 | DECOMP_NO_COMPOSE, 3200},       /* compatibility mapping */
+       {0x337F, 0, 4, 3202},
+       {0x3380, 0, 2 | DECOMP_NO_COMPOSE, 3206},       /* compatibility mapping */
+       {0x3381, 0, 2 | DECOMP_NO_COMPOSE, 3208},       /* compatibility mapping */
+       {0x3382, 0, 2 | DECOMP_NO_COMPOSE, 3210},       /* compatibility mapping */
+       {0x3383, 0, 2 | DECOMP_NO_COMPOSE, 3212},       /* compatibility mapping */
+       {0x3384, 0, 2 | DECOMP_NO_COMPOSE, 3214},       /* compatibility mapping */
+       {0x3385, 0, 2 | DECOMP_NO_COMPOSE, 3216},       /* compatibility mapping */
+       {0x3386, 0, 2 | DECOMP_NO_COMPOSE, 3218},       /* compatibility mapping */
+       {0x3387, 0, 2 | DECOMP_NO_COMPOSE, 3220},       /* compatibility mapping */
+       {0x3388, 0, 3, 3222},
+       {0x3389, 0, 4, 3225},
+       {0x338A, 0, 2 | DECOMP_NO_COMPOSE, 3229},       /* compatibility mapping */
+       {0x338B, 0, 2 | DECOMP_NO_COMPOSE, 3231},       /* compatibility mapping */
+       {0x338C, 0, 2 | DECOMP_NO_COMPOSE, 3233},       /* compatibility mapping */
+       {0x338D, 0, 2 | DECOMP_NO_COMPOSE, 3235},       /* compatibility mapping */
+       {0x338E, 0, 2 | DECOMP_NO_COMPOSE, 3237},       /* compatibility mapping */
+       {0x338F, 0, 2 | DECOMP_NO_COMPOSE, 3239},       /* compatibility mapping */
+       {0x3390, 0, 2 | DECOMP_NO_COMPOSE, 3241},       /* compatibility mapping */
+       {0x3391, 0, 3, 3243},
+       {0x3392, 0, 3, 3246},
+       {0x3393, 0, 3, 3249},
+       {0x3394, 0, 3, 3252},
+       {0x3395, 0, 2 | DECOMP_NO_COMPOSE, 3255},       /* compatibility mapping */
+       {0x3396, 0, 2 | DECOMP_NO_COMPOSE, 3257},       /* compatibility mapping */
+       {0x3397, 0, 2 | DECOMP_NO_COMPOSE, 3259},       /* compatibility mapping */
+       {0x3398, 0, 2 | DECOMP_NO_COMPOSE, 3261},       /* compatibility mapping */
+       {0x3399, 0, 2 | DECOMP_NO_COMPOSE, 3263},       /* compatibility mapping */
+       {0x339A, 0, 2 | DECOMP_NO_COMPOSE, 3265},       /* compatibility mapping */
+       {0x339B, 0, 2 | DECOMP_NO_COMPOSE, 3267},       /* compatibility mapping */
+       {0x339C, 0, 2 | DECOMP_NO_COMPOSE, 3269},       /* compatibility mapping */
+       {0x339D, 0, 2 | DECOMP_NO_COMPOSE, 3271},       /* compatibility mapping */
+       {0x339E, 0, 2 | DECOMP_NO_COMPOSE, 3273},       /* compatibility mapping */
+       {0x339F, 0, 3, 3275},
+       {0x33A0, 0, 3, 3278},
+       {0x33A1, 0, 2 | DECOMP_NO_COMPOSE, 3281},       /* compatibility mapping */
+       {0x33A2, 0, 3, 3283},
+       {0x33A3, 0, 3, 3286},
+       {0x33A4, 0, 3, 3289},
+       {0x33A5, 0, 2 | DECOMP_NO_COMPOSE, 3292},       /* compatibility mapping */
+       {0x33A6, 0, 3, 3294},
+       {0x33A7, 0, 3, 3297},
+       {0x33A8, 0, 4, 3300},
+       {0x33A9, 0, 2 | DECOMP_NO_COMPOSE, 3304},       /* compatibility mapping */
+       {0x33AA, 0, 3, 3306},
+       {0x33AB, 0, 3, 3309},
+       {0x33AC, 0, 3, 3312},
+       {0x33AD, 0, 3, 3315},
+       {0x33AE, 0, 5, 3318},
+       {0x33AF, 0, 6, 3323},
+       {0x33B0, 0, 2 | DECOMP_NO_COMPOSE, 3329},       /* compatibility mapping */
+       {0x33B1, 0, 2 | DECOMP_NO_COMPOSE, 3331},       /* compatibility mapping */
+       {0x33B2, 0, 2 | DECOMP_NO_COMPOSE, 3333},       /* compatibility mapping */
+       {0x33B3, 0, 2 | DECOMP_NO_COMPOSE, 3335},       /* compatibility mapping */
+       {0x33B4, 0, 2 | DECOMP_NO_COMPOSE, 3337},       /* compatibility mapping */
+       {0x33B5, 0, 2 | DECOMP_NO_COMPOSE, 3339},       /* compatibility mapping */
+       {0x33B6, 0, 2 | DECOMP_NO_COMPOSE, 3341},       /* compatibility mapping */
+       {0x33B7, 0, 2 | DECOMP_NO_COMPOSE, 3343},       /* compatibility mapping */
+       {0x33B8, 0, 2 | DECOMP_NO_COMPOSE, 3345},       /* compatibility mapping */
+       {0x33B9, 0, 2 | DECOMP_NO_COMPOSE, 3347},       /* compatibility mapping */
+       {0x33BA, 0, 2 | DECOMP_NO_COMPOSE, 3349},       /* compatibility mapping */
+       {0x33BB, 0, 2 | DECOMP_NO_COMPOSE, 3351},       /* compatibility mapping */
+       {0x33BC, 0, 2 | DECOMP_NO_COMPOSE, 3353},       /* compatibility mapping */
+       {0x33BD, 0, 2 | DECOMP_NO_COMPOSE, 3355},       /* compatibility mapping */
+       {0x33BE, 0, 2 | DECOMP_NO_COMPOSE, 3357},       /* compatibility mapping */
+       {0x33BF, 0, 2 | DECOMP_NO_COMPOSE, 3359},       /* compatibility mapping */
+       {0x33C0, 0, 2 | DECOMP_NO_COMPOSE, 3361},       /* compatibility mapping */
+       {0x33C1, 0, 2 | DECOMP_NO_COMPOSE, 3363},       /* compatibility mapping */
+       {0x33C2, 0, 4, 3365},
+       {0x33C3, 0, 2 | DECOMP_NO_COMPOSE, 3369},       /* compatibility mapping */
+       {0x33C4, 0, 2 | DECOMP_NO_COMPOSE, 3371},       /* compatibility mapping */
+       {0x33C5, 0, 2 | DECOMP_NO_COMPOSE, 3373},       /* compatibility mapping */
+       {0x33C6, 0, 4, 3375},
+       {0x33C7, 0, 3, 3379},
+       {0x33C8, 0, 2 | DECOMP_NO_COMPOSE, 3382},       /* compatibility mapping */
+       {0x33C9, 0, 2 | DECOMP_NO_COMPOSE, 3384},       /* compatibility mapping */
+       {0x33CA, 0, 2 | DECOMP_NO_COMPOSE, 3386},       /* compatibility mapping */
+       {0x33CB, 0, 2 | DECOMP_NO_COMPOSE, 3388},       /* compatibility mapping */
+       {0x33CC, 0, 2 | DECOMP_NO_COMPOSE, 3390},       /* compatibility mapping */
+       {0x33CD, 0, 2 | DECOMP_NO_COMPOSE, 3392},       /* compatibility mapping */
+       {0x33CE, 0, 2 | DECOMP_NO_COMPOSE, 3394},       /* compatibility mapping */
+       {0x33CF, 0, 2 | DECOMP_NO_COMPOSE, 3396},       /* compatibility mapping */
+       {0x33D0, 0, 2 | DECOMP_NO_COMPOSE, 3398},       /* compatibility mapping */
+       {0x33D1, 0, 2 | DECOMP_NO_COMPOSE, 3400},       /* compatibility mapping */
+       {0x33D2, 0, 3, 3402},
+       {0x33D3, 0, 2 | DECOMP_NO_COMPOSE, 3405},       /* compatibility mapping */
+       {0x33D4, 0, 2 | DECOMP_NO_COMPOSE, 3407},       /* compatibility mapping */
+       {0x33D5, 0, 3, 3409},
+       {0x33D6, 0, 3, 3412},
+       {0x33D7, 0, 2 | DECOMP_NO_COMPOSE, 3415},       /* compatibility mapping */
+       {0x33D8, 0, 4, 3417},
+       {0x33D9, 0, 3, 3421},
+       {0x33DA, 0, 2 | DECOMP_NO_COMPOSE, 3424},       /* compatibility mapping */
+       {0x33DB, 0, 2 | DECOMP_NO_COMPOSE, 3426},       /* compatibility mapping */
+       {0x33DC, 0, 2 | DECOMP_NO_COMPOSE, 3428},       /* compatibility mapping */
+       {0x33DD, 0, 2 | DECOMP_NO_COMPOSE, 3430},       /* compatibility mapping */
+       {0x33DE, 0, 3, 3432},
+       {0x33DF, 0, 3, 3435},
+       {0x33E0, 0, 2 | DECOMP_NO_COMPOSE, 3438},       /* compatibility mapping */
+       {0x33E1, 0, 2 | DECOMP_NO_COMPOSE, 3440},       /* compatibility mapping */
+       {0x33E2, 0, 2 | DECOMP_NO_COMPOSE, 3442},       /* compatibility mapping */
+       {0x33E3, 0, 2 | DECOMP_NO_COMPOSE, 3444},       /* compatibility mapping */
+       {0x33E4, 0, 2 | DECOMP_NO_COMPOSE, 3446},       /* compatibility mapping */
+       {0x33E5, 0, 2 | DECOMP_NO_COMPOSE, 3448},       /* compatibility mapping */
+       {0x33E6, 0, 2 | DECOMP_NO_COMPOSE, 3450},       /* compatibility mapping */
+       {0x33E7, 0, 2 | DECOMP_NO_COMPOSE, 3452},       /* compatibility mapping */
+       {0x33E8, 0, 2 | DECOMP_NO_COMPOSE, 3454},       /* compatibility mapping */
+       {0x33E9, 0, 3, 3456},
+       {0x33EA, 0, 3, 3459},
+       {0x33EB, 0, 3, 3462},
+       {0x33EC, 0, 3, 3465},
+       {0x33ED, 0, 3, 3468},
+       {0x33EE, 0, 3, 3471},
+       {0x33EF, 0, 3, 3474},
+       {0x33F0, 0, 3, 3477},
+       {0x33F1, 0, 3, 3480},
+       {0x33F2, 0, 3, 3483},
+       {0x33F3, 0, 3, 3486},
+       {0x33F4, 0, 3, 3489},
+       {0x33F5, 0, 3, 3492},
+       {0x33F6, 0, 3, 3495},
+       {0x33F7, 0, 3, 3498},
+       {0x33F8, 0, 3, 3501},
+       {0x33F9, 0, 3, 3504},
+       {0x33FA, 0, 3, 3507},
+       {0x33FB, 0, 3, 3510},
+       {0x33FC, 0, 3, 3513},
+       {0x33FD, 0, 3, 3516},
+       {0x33FE, 0, 3, 3519},
+       {0x33FF, 0, 3, 3522},
+       {0xA66F, 230, 0, 0},
+       {0xA674, 230, 0, 0},
+       {0xA675, 230, 0, 0},
+       {0xA676, 230, 0, 0},
+       {0xA677, 230, 0, 0},
+       {0xA678, 230, 0, 0},
+       {0xA679, 230, 0, 0},
+       {0xA67A, 230, 0, 0},
+       {0xA67B, 230, 0, 0},
+       {0xA67C, 230, 0, 0},
+       {0xA67D, 230, 0, 0},
+       {0xA69C, 0, 1 | DECOMP_INLINE, 0x044A},
+       {0xA69D, 0, 1 | DECOMP_INLINE, 0x044C},
+       {0xA69E, 230, 0, 0},
+       {0xA69F, 230, 0, 0},
+       {0xA6F0, 230, 0, 0},
+       {0xA6F1, 230, 0, 0},
+       {0xA770, 0, 1 | DECOMP_INLINE, 0xA76F},
+       {0xA7F8, 0, 1 | DECOMP_INLINE, 0x0126},
+       {0xA7F9, 0, 1 | DECOMP_INLINE, 0x0153},
+       {0xA806, 9, 0, 0},
+       {0xA8C4, 9, 0, 0},
+       {0xA8E0, 230, 0, 0},
+       {0xA8E1, 230, 0, 0},
+       {0xA8E2, 230, 0, 0},
+       {0xA8E3, 230, 0, 0},
+       {0xA8E4, 230, 0, 0},
+       {0xA8E5, 230, 0, 0},
+       {0xA8E6, 230, 0, 0},
+       {0xA8E7, 230, 0, 0},
+       {0xA8E8, 230, 0, 0},
+       {0xA8E9, 230, 0, 0},
+       {0xA8EA, 230, 0, 0},
+       {0xA8EB, 230, 0, 0},
+       {0xA8EC, 230, 0, 0},
+       {0xA8ED, 230, 0, 0},
+       {0xA8EE, 230, 0, 0},
+       {0xA8EF, 230, 0, 0},
+       {0xA8F0, 230, 0, 0},
+       {0xA8F1, 230, 0, 0},
+       {0xA92B, 220, 0, 0},
+       {0xA92C, 220, 0, 0},
+       {0xA92D, 220, 0, 0},
+       {0xA953, 9, 0, 0},
+       {0xA9B3, 7, 0, 0},
+       {0xA9C0, 9, 0, 0},
+       {0xAAB0, 230, 0, 0},
+       {0xAAB2, 230, 0, 0},
+       {0xAAB3, 230, 0, 0},
+       {0xAAB4, 220, 0, 0},
+       {0xAAB7, 230, 0, 0},
+       {0xAAB8, 230, 0, 0},
+       {0xAABE, 230, 0, 0},
+       {0xAABF, 230, 0, 0},
+       {0xAAC1, 230, 0, 0},
+       {0xAAF6, 9, 0, 0},
+       {0xAB5C, 0, 1 | DECOMP_INLINE, 0xA727},
+       {0xAB5D, 0, 1 | DECOMP_INLINE, 0xAB37},
+       {0xAB5E, 0, 1 | DECOMP_INLINE, 0x026B},
+       {0xAB5F, 0, 1 | DECOMP_INLINE, 0xAB52},
+       {0xABED, 9, 0, 0},
+       {0xF900, 0, 1 | DECOMP_INLINE, 0x8C48},
+       {0xF901, 0, 1 | DECOMP_INLINE, 0x66F4},
+       {0xF902, 0, 1 | DECOMP_INLINE, 0x8ECA},
+       {0xF903, 0, 1 | DECOMP_INLINE, 0x8CC8},
+       {0xF904, 0, 1 | DECOMP_INLINE, 0x6ED1},
+       {0xF905, 0, 1 | DECOMP_INLINE, 0x4E32},
+       {0xF906, 0, 1 | DECOMP_INLINE, 0x53E5},
+       {0xF907, 0, 1 | DECOMP_INLINE, 0x9F9C},
+       {0xF908, 0, 1 | DECOMP_INLINE, 0x9F9C},
+       {0xF909, 0, 1 | DECOMP_INLINE, 0x5951},
+       {0xF90A, 0, 1 | DECOMP_INLINE, 0x91D1},
+       {0xF90B, 0, 1 | DECOMP_INLINE, 0x5587},
+       {0xF90C, 0, 1 | DECOMP_INLINE, 0x5948},
+       {0xF90D, 0, 1 | DECOMP_INLINE, 0x61F6},
+       {0xF90E, 0, 1 | DECOMP_INLINE, 0x7669},
+       {0xF90F, 0, 1 | DECOMP_INLINE, 0x7F85},
+       {0xF910, 0, 1 | DECOMP_INLINE, 0x863F},
+       {0xF911, 0, 1 | DECOMP_INLINE, 0x87BA},
+       {0xF912, 0, 1 | DECOMP_INLINE, 0x88F8},
+       {0xF913, 0, 1 | DECOMP_INLINE, 0x908F},
+       {0xF914, 0, 1 | DECOMP_INLINE, 0x6A02},
+       {0xF915, 0, 1 | DECOMP_INLINE, 0x6D1B},
+       {0xF916, 0, 1 | DECOMP_INLINE, 0x70D9},
+       {0xF917, 0, 1 | DECOMP_INLINE, 0x73DE},
+       {0xF918, 0, 1 | DECOMP_INLINE, 0x843D},
+       {0xF919, 0, 1 | DECOMP_INLINE, 0x916A},
+       {0xF91A, 0, 1 | DECOMP_INLINE, 0x99F1},
+       {0xF91B, 0, 1 | DECOMP_INLINE, 0x4E82},
+       {0xF91C, 0, 1 | DECOMP_INLINE, 0x5375},
+       {0xF91D, 0, 1 | DECOMP_INLINE, 0x6B04},
+       {0xF91E, 0, 1 | DECOMP_INLINE, 0x721B},
+       {0xF91F, 0, 1 | DECOMP_INLINE, 0x862D},
+       {0xF920, 0, 1 | DECOMP_INLINE, 0x9E1E},
+       {0xF921, 0, 1 | DECOMP_INLINE, 0x5D50},
+       {0xF922, 0, 1 | DECOMP_INLINE, 0x6FEB},
+       {0xF923, 0, 1 | DECOMP_INLINE, 0x85CD},
+       {0xF924, 0, 1 | DECOMP_INLINE, 0x8964},
+       {0xF925, 0, 1 | DECOMP_INLINE, 0x62C9},
+       {0xF926, 0, 1 | DECOMP_INLINE, 0x81D8},
+       {0xF927, 0, 1 | DECOMP_INLINE, 0x881F},
+       {0xF928, 0, 1 | DECOMP_INLINE, 0x5ECA},
+       {0xF929, 0, 1 | DECOMP_INLINE, 0x6717},
+       {0xF92A, 0, 1 | DECOMP_INLINE, 0x6D6A},
+       {0xF92B, 0, 1 | DECOMP_INLINE, 0x72FC},
+       {0xF92C, 0, 1 | DECOMP_INLINE, 0x90CE},
+       {0xF92D, 0, 1 | DECOMP_INLINE, 0x4F86},
+       {0xF92E, 0, 1 | DECOMP_INLINE, 0x51B7},
+       {0xF92F, 0, 1 | DECOMP_INLINE, 0x52DE},
+       {0xF930, 0, 1 | DECOMP_INLINE, 0x64C4},
+       {0xF931, 0, 1 | DECOMP_INLINE, 0x6AD3},
+       {0xF932, 0, 1 | DECOMP_INLINE, 0x7210},
+       {0xF933, 0, 1 | DECOMP_INLINE, 0x76E7},
+       {0xF934, 0, 1 | DECOMP_INLINE, 0x8001},
+       {0xF935, 0, 1 | DECOMP_INLINE, 0x8606},
+       {0xF936, 0, 1 | DECOMP_INLINE, 0x865C},
+       {0xF937, 0, 1 | DECOMP_INLINE, 0x8DEF},
+       {0xF938, 0, 1 | DECOMP_INLINE, 0x9732},
+       {0xF939, 0, 1 | DECOMP_INLINE, 0x9B6F},
+       {0xF93A, 0, 1 | DECOMP_INLINE, 0x9DFA},
+       {0xF93B, 0, 1 | DECOMP_INLINE, 0x788C},
+       {0xF93C, 0, 1 | DECOMP_INLINE, 0x797F},
+       {0xF93D, 0, 1 | DECOMP_INLINE, 0x7DA0},
+       {0xF93E, 0, 1 | DECOMP_INLINE, 0x83C9},
+       {0xF93F, 0, 1 | DECOMP_INLINE, 0x9304},
+       {0xF940, 0, 1 | DECOMP_INLINE, 0x9E7F},
+       {0xF941, 0, 1 | DECOMP_INLINE, 0x8AD6},
+       {0xF942, 0, 1 | DECOMP_INLINE, 0x58DF},
+       {0xF943, 0, 1 | DECOMP_INLINE, 0x5F04},
+       {0xF944, 0, 1 | DECOMP_INLINE, 0x7C60},
+       {0xF945, 0, 1 | DECOMP_INLINE, 0x807E},
+       {0xF946, 0, 1 | DECOMP_INLINE, 0x7262},
+       {0xF947, 0, 1 | DECOMP_INLINE, 0x78CA},
+       {0xF948, 0, 1 | DECOMP_INLINE, 0x8CC2},
+       {0xF949, 0, 1 | DECOMP_INLINE, 0x96F7},
+       {0xF94A, 0, 1 | DECOMP_INLINE, 0x58D8},
+       {0xF94B, 0, 1 | DECOMP_INLINE, 0x5C62},
+       {0xF94C, 0, 1 | DECOMP_INLINE, 0x6A13},
+       {0xF94D, 0, 1 | DECOMP_INLINE, 0x6DDA},
+       {0xF94E, 0, 1 | DECOMP_INLINE, 0x6F0F},
+       {0xF94F, 0, 1 | DECOMP_INLINE, 0x7D2F},
+       {0xF950, 0, 1 | DECOMP_INLINE, 0x7E37},
+       {0xF951, 0, 1 | DECOMP_INLINE, 0x964B},
+       {0xF952, 0, 1 | DECOMP_INLINE, 0x52D2},
+       {0xF953, 0, 1 | DECOMP_INLINE, 0x808B},
+       {0xF954, 0, 1 | DECOMP_INLINE, 0x51DC},
+       {0xF955, 0, 1 | DECOMP_INLINE, 0x51CC},
+       {0xF956, 0, 1 | DECOMP_INLINE, 0x7A1C},
+       {0xF957, 0, 1 | DECOMP_INLINE, 0x7DBE},
+       {0xF958, 0, 1 | DECOMP_INLINE, 0x83F1},
+       {0xF959, 0, 1 | DECOMP_INLINE, 0x9675},
+       {0xF95A, 0, 1 | DECOMP_INLINE, 0x8B80},
+       {0xF95B, 0, 1 | DECOMP_INLINE, 0x62CF},
+       {0xF95C, 0, 1 | DECOMP_INLINE, 0x6A02},
+       {0xF95D, 0, 1 | DECOMP_INLINE, 0x8AFE},
+       {0xF95E, 0, 1 | DECOMP_INLINE, 0x4E39},
+       {0xF95F, 0, 1 | DECOMP_INLINE, 0x5BE7},
+       {0xF960, 0, 1 | DECOMP_INLINE, 0x6012},
+       {0xF961, 0, 1 | DECOMP_INLINE, 0x7387},
+       {0xF962, 0, 1 | DECOMP_INLINE, 0x7570},
+       {0xF963, 0, 1 | DECOMP_INLINE, 0x5317},
+       {0xF964, 0, 1 | DECOMP_INLINE, 0x78FB},
+       {0xF965, 0, 1 | DECOMP_INLINE, 0x4FBF},
+       {0xF966, 0, 1 | DECOMP_INLINE, 0x5FA9},
+       {0xF967, 0, 1 | DECOMP_INLINE, 0x4E0D},
+       {0xF968, 0, 1 | DECOMP_INLINE, 0x6CCC},
+       {0xF969, 0, 1 | DECOMP_INLINE, 0x6578},
+       {0xF96A, 0, 1 | DECOMP_INLINE, 0x7D22},
+       {0xF96B, 0, 1 | DECOMP_INLINE, 0x53C3},
+       {0xF96C, 0, 1 | DECOMP_INLINE, 0x585E},
+       {0xF96D, 0, 1 | DECOMP_INLINE, 0x7701},
+       {0xF96E, 0, 1 | DECOMP_INLINE, 0x8449},
+       {0xF96F, 0, 1 | DECOMP_INLINE, 0x8AAA},
+       {0xF970, 0, 1 | DECOMP_INLINE, 0x6BBA},
+       {0xF971, 0, 1 | DECOMP_INLINE, 0x8FB0},
+       {0xF972, 0, 1 | DECOMP_INLINE, 0x6C88},
+       {0xF973, 0, 1 | DECOMP_INLINE, 0x62FE},
+       {0xF974, 0, 1 | DECOMP_INLINE, 0x82E5},
+       {0xF975, 0, 1 | DECOMP_INLINE, 0x63A0},
+       {0xF976, 0, 1 | DECOMP_INLINE, 0x7565},
+       {0xF977, 0, 1 | DECOMP_INLINE, 0x4EAE},
+       {0xF978, 0, 1 | DECOMP_INLINE, 0x5169},
+       {0xF979, 0, 1 | DECOMP_INLINE, 0x51C9},
+       {0xF97A, 0, 1 | DECOMP_INLINE, 0x6881},
+       {0xF97B, 0, 1 | DECOMP_INLINE, 0x7CE7},
+       {0xF97C, 0, 1 | DECOMP_INLINE, 0x826F},
+       {0xF97D, 0, 1 | DECOMP_INLINE, 0x8AD2},
+       {0xF97E, 0, 1 | DECOMP_INLINE, 0x91CF},
+       {0xF97F, 0, 1 | DECOMP_INLINE, 0x52F5},
+       {0xF980, 0, 1 | DECOMP_INLINE, 0x5442},
+       {0xF981, 0, 1 | DECOMP_INLINE, 0x5973},
+       {0xF982, 0, 1 | DECOMP_INLINE, 0x5EEC},
+       {0xF983, 0, 1 | DECOMP_INLINE, 0x65C5},
+       {0xF984, 0, 1 | DECOMP_INLINE, 0x6FFE},
+       {0xF985, 0, 1 | DECOMP_INLINE, 0x792A},
+       {0xF986, 0, 1 | DECOMP_INLINE, 0x95AD},
+       {0xF987, 0, 1 | DECOMP_INLINE, 0x9A6A},
+       {0xF988, 0, 1 | DECOMP_INLINE, 0x9E97},
+       {0xF989, 0, 1 | DECOMP_INLINE, 0x9ECE},
+       {0xF98A, 0, 1 | DECOMP_INLINE, 0x529B},
+       {0xF98B, 0, 1 | DECOMP_INLINE, 0x66C6},
+       {0xF98C, 0, 1 | DECOMP_INLINE, 0x6B77},
+       {0xF98D, 0, 1 | DECOMP_INLINE, 0x8F62},
+       {0xF98E, 0, 1 | DECOMP_INLINE, 0x5E74},
+       {0xF98F, 0, 1 | DECOMP_INLINE, 0x6190},
+       {0xF990, 0, 1 | DECOMP_INLINE, 0x6200},
+       {0xF991, 0, 1 | DECOMP_INLINE, 0x649A},
+       {0xF992, 0, 1 | DECOMP_INLINE, 0x6F23},
+       {0xF993, 0, 1 | DECOMP_INLINE, 0x7149},
+       {0xF994, 0, 1 | DECOMP_INLINE, 0x7489},
+       {0xF995, 0, 1 | DECOMP_INLINE, 0x79CA},
+       {0xF996, 0, 1 | DECOMP_INLINE, 0x7DF4},
+       {0xF997, 0, 1 | DECOMP_INLINE, 0x806F},
+       {0xF998, 0, 1 | DECOMP_INLINE, 0x8F26},
+       {0xF999, 0, 1 | DECOMP_INLINE, 0x84EE},
+       {0xF99A, 0, 1 | DECOMP_INLINE, 0x9023},
+       {0xF99B, 0, 1 | DECOMP_INLINE, 0x934A},
+       {0xF99C, 0, 1 | DECOMP_INLINE, 0x5217},
+       {0xF99D, 0, 1 | DECOMP_INLINE, 0x52A3},
+       {0xF99E, 0, 1 | DECOMP_INLINE, 0x54BD},
+       {0xF99F, 0, 1 | DECOMP_INLINE, 0x70C8},
+       {0xF9A0, 0, 1 | DECOMP_INLINE, 0x88C2},
+       {0xF9A1, 0, 1 | DECOMP_INLINE, 0x8AAA},
+       {0xF9A2, 0, 1 | DECOMP_INLINE, 0x5EC9},
+       {0xF9A3, 0, 1 | DECOMP_INLINE, 0x5FF5},
+       {0xF9A4, 0, 1 | DECOMP_INLINE, 0x637B},
+       {0xF9A5, 0, 1 | DECOMP_INLINE, 0x6BAE},
+       {0xF9A6, 0, 1 | DECOMP_INLINE, 0x7C3E},
+       {0xF9A7, 0, 1 | DECOMP_INLINE, 0x7375},
+       {0xF9A8, 0, 1 | DECOMP_INLINE, 0x4EE4},
+       {0xF9A9, 0, 1 | DECOMP_INLINE, 0x56F9},
+       {0xF9AA, 0, 1 | DECOMP_INLINE, 0x5BE7},
+       {0xF9AB, 0, 1 | DECOMP_INLINE, 0x5DBA},
+       {0xF9AC, 0, 1 | DECOMP_INLINE, 0x601C},
+       {0xF9AD, 0, 1 | DECOMP_INLINE, 0x73B2},
+       {0xF9AE, 0, 1 | DECOMP_INLINE, 0x7469},
+       {0xF9AF, 0, 1 | DECOMP_INLINE, 0x7F9A},
+       {0xF9B0, 0, 1 | DECOMP_INLINE, 0x8046},
+       {0xF9B1, 0, 1 | DECOMP_INLINE, 0x9234},
+       {0xF9B2, 0, 1 | DECOMP_INLINE, 0x96F6},
+       {0xF9B3, 0, 1 | DECOMP_INLINE, 0x9748},
+       {0xF9B4, 0, 1 | DECOMP_INLINE, 0x9818},
+       {0xF9B5, 0, 1 | DECOMP_INLINE, 0x4F8B},
+       {0xF9B6, 0, 1 | DECOMP_INLINE, 0x79AE},
+       {0xF9B7, 0, 1 | DECOMP_INLINE, 0x91B4},
+       {0xF9B8, 0, 1 | DECOMP_INLINE, 0x96B8},
+       {0xF9B9, 0, 1 | DECOMP_INLINE, 0x60E1},
+       {0xF9BA, 0, 1 | DECOMP_INLINE, 0x4E86},
+       {0xF9BB, 0, 1 | DECOMP_INLINE, 0x50DA},
+       {0xF9BC, 0, 1 | DECOMP_INLINE, 0x5BEE},
+       {0xF9BD, 0, 1 | DECOMP_INLINE, 0x5C3F},
+       {0xF9BE, 0, 1 | DECOMP_INLINE, 0x6599},
+       {0xF9BF, 0, 1 | DECOMP_INLINE, 0x6A02},
+       {0xF9C0, 0, 1 | DECOMP_INLINE, 0x71CE},
+       {0xF9C1, 0, 1 | DECOMP_INLINE, 0x7642},
+       {0xF9C2, 0, 1 | DECOMP_INLINE, 0x84FC},
+       {0xF9C3, 0, 1 | DECOMP_INLINE, 0x907C},
+       {0xF9C4, 0, 1 | DECOMP_INLINE, 0x9F8D},
+       {0xF9C5, 0, 1 | DECOMP_INLINE, 0x6688},
+       {0xF9C6, 0, 1 | DECOMP_INLINE, 0x962E},
+       {0xF9C7, 0, 1 | DECOMP_INLINE, 0x5289},
+       {0xF9C8, 0, 1 | DECOMP_INLINE, 0x677B},
+       {0xF9C9, 0, 1 | DECOMP_INLINE, 0x67F3},
+       {0xF9CA, 0, 1 | DECOMP_INLINE, 0x6D41},
+       {0xF9CB, 0, 1 | DECOMP_INLINE, 0x6E9C},
+       {0xF9CC, 0, 1 | DECOMP_INLINE, 0x7409},
+       {0xF9CD, 0, 1 | DECOMP_INLINE, 0x7559},
+       {0xF9CE, 0, 1 | DECOMP_INLINE, 0x786B},
+       {0xF9CF, 0, 1 | DECOMP_INLINE, 0x7D10},
+       {0xF9D0, 0, 1 | DECOMP_INLINE, 0x985E},
+       {0xF9D1, 0, 1 | DECOMP_INLINE, 0x516D},
+       {0xF9D2, 0, 1 | DECOMP_INLINE, 0x622E},
+       {0xF9D3, 0, 1 | DECOMP_INLINE, 0x9678},
+       {0xF9D4, 0, 1 | DECOMP_INLINE, 0x502B},
+       {0xF9D5, 0, 1 | DECOMP_INLINE, 0x5D19},
+       {0xF9D6, 0, 1 | DECOMP_INLINE, 0x6DEA},
+       {0xF9D7, 0, 1 | DECOMP_INLINE, 0x8F2A},
+       {0xF9D8, 0, 1 | DECOMP_INLINE, 0x5F8B},
+       {0xF9D9, 0, 1 | DECOMP_INLINE, 0x6144},
+       {0xF9DA, 0, 1 | DECOMP_INLINE, 0x6817},
+       {0xF9DB, 0, 1 | DECOMP_INLINE, 0x7387},
+       {0xF9DC, 0, 1 | DECOMP_INLINE, 0x9686},
+       {0xF9DD, 0, 1 | DECOMP_INLINE, 0x5229},
+       {0xF9DE, 0, 1 | DECOMP_INLINE, 0x540F},
+       {0xF9DF, 0, 1 | DECOMP_INLINE, 0x5C65},
+       {0xF9E0, 0, 1 | DECOMP_INLINE, 0x6613},
+       {0xF9E1, 0, 1 | DECOMP_INLINE, 0x674E},
+       {0xF9E2, 0, 1 | DECOMP_INLINE, 0x68A8},
+       {0xF9E3, 0, 1 | DECOMP_INLINE, 0x6CE5},
+       {0xF9E4, 0, 1 | DECOMP_INLINE, 0x7406},
+       {0xF9E5, 0, 1 | DECOMP_INLINE, 0x75E2},
+       {0xF9E6, 0, 1 | DECOMP_INLINE, 0x7F79},
+       {0xF9E7, 0, 1 | DECOMP_INLINE, 0x88CF},
+       {0xF9E8, 0, 1 | DECOMP_INLINE, 0x88E1},
+       {0xF9E9, 0, 1 | DECOMP_INLINE, 0x91CC},
+       {0xF9EA, 0, 1 | DECOMP_INLINE, 0x96E2},
+       {0xF9EB, 0, 1 | DECOMP_INLINE, 0x533F},
+       {0xF9EC, 0, 1 | DECOMP_INLINE, 0x6EBA},
+       {0xF9ED, 0, 1 | DECOMP_INLINE, 0x541D},
+       {0xF9EE, 0, 1 | DECOMP_INLINE, 0x71D0},
+       {0xF9EF, 0, 1 | DECOMP_INLINE, 0x7498},
+       {0xF9F0, 0, 1 | DECOMP_INLINE, 0x85FA},
+       {0xF9F1, 0, 1 | DECOMP_INLINE, 0x96A3},
+       {0xF9F2, 0, 1 | DECOMP_INLINE, 0x9C57},
+       {0xF9F3, 0, 1 | DECOMP_INLINE, 0x9E9F},
+       {0xF9F4, 0, 1 | DECOMP_INLINE, 0x6797},
+       {0xF9F5, 0, 1 | DECOMP_INLINE, 0x6DCB},
+       {0xF9F6, 0, 1 | DECOMP_INLINE, 0x81E8},
+       {0xF9F7, 0, 1 | DECOMP_INLINE, 0x7ACB},
+       {0xF9F8, 0, 1 | DECOMP_INLINE, 0x7B20},
+       {0xF9F9, 0, 1 | DECOMP_INLINE, 0x7C92},
+       {0xF9FA, 0, 1 | DECOMP_INLINE, 0x72C0},
+       {0xF9FB, 0, 1 | DECOMP_INLINE, 0x7099},
+       {0xF9FC, 0, 1 | DECOMP_INLINE, 0x8B58},
+       {0xF9FD, 0, 1 | DECOMP_INLINE, 0x4EC0},
+       {0xF9FE, 0, 1 | DECOMP_INLINE, 0x8336},
+       {0xF9FF, 0, 1 | DECOMP_INLINE, 0x523A},
+       {0xFA00, 0, 1 | DECOMP_INLINE, 0x5207},
+       {0xFA01, 0, 1 | DECOMP_INLINE, 0x5EA6},
+       {0xFA02, 0, 1 | DECOMP_INLINE, 0x62D3},
+       {0xFA03, 0, 1 | DECOMP_INLINE, 0x7CD6},
+       {0xFA04, 0, 1 | DECOMP_INLINE, 0x5B85},
+       {0xFA05, 0, 1 | DECOMP_INLINE, 0x6D1E},
+       {0xFA06, 0, 1 | DECOMP_INLINE, 0x66B4},
+       {0xFA07, 0, 1 | DECOMP_INLINE, 0x8F3B},
+       {0xFA08, 0, 1 | DECOMP_INLINE, 0x884C},
+       {0xFA09, 0, 1 | DECOMP_INLINE, 0x964D},
+       {0xFA0A, 0, 1 | DECOMP_INLINE, 0x898B},
+       {0xFA0B, 0, 1 | DECOMP_INLINE, 0x5ED3},
+       {0xFA0C, 0, 1 | DECOMP_INLINE, 0x5140},
+       {0xFA0D, 0, 1 | DECOMP_INLINE, 0x55C0},
+       {0xFA10, 0, 1 | DECOMP_INLINE, 0x585A},
+       {0xFA12, 0, 1 | DECOMP_INLINE, 0x6674},
+       {0xFA15, 0, 1 | DECOMP_INLINE, 0x51DE},
+       {0xFA16, 0, 1 | DECOMP_INLINE, 0x732A},
+       {0xFA17, 0, 1 | DECOMP_INLINE, 0x76CA},
+       {0xFA18, 0, 1 | DECOMP_INLINE, 0x793C},
+       {0xFA19, 0, 1 | DECOMP_INLINE, 0x795E},
+       {0xFA1A, 0, 1 | DECOMP_INLINE, 0x7965},
+       {0xFA1B, 0, 1 | DECOMP_INLINE, 0x798F},
+       {0xFA1C, 0, 1 | DECOMP_INLINE, 0x9756},
+       {0xFA1D, 0, 1 | DECOMP_INLINE, 0x7CBE},
+       {0xFA1E, 0, 1 | DECOMP_INLINE, 0x7FBD},
+       {0xFA20, 0, 1 | DECOMP_INLINE, 0x8612},
+       {0xFA22, 0, 1 | DECOMP_INLINE, 0x8AF8},
+       {0xFA25, 0, 1 | DECOMP_INLINE, 0x9038},
+       {0xFA26, 0, 1 | DECOMP_INLINE, 0x90FD},
+       {0xFA2A, 0, 1 | DECOMP_INLINE, 0x98EF},
+       {0xFA2B, 0, 1 | DECOMP_INLINE, 0x98FC},
+       {0xFA2C, 0, 1 | DECOMP_INLINE, 0x9928},
+       {0xFA2D, 0, 1 | DECOMP_INLINE, 0x9DB4},
+       {0xFA2E, 0, 1 | DECOMP_INLINE, 0x90DE},
+       {0xFA2F, 0, 1 | DECOMP_INLINE, 0x96B7},
+       {0xFA30, 0, 1 | DECOMP_INLINE, 0x4FAE},
+       {0xFA31, 0, 1 | DECOMP_INLINE, 0x50E7},
+       {0xFA32, 0, 1 | DECOMP_INLINE, 0x514D},
+       {0xFA33, 0, 1 | DECOMP_INLINE, 0x52C9},
+       {0xFA34, 0, 1 | DECOMP_INLINE, 0x52E4},
+       {0xFA35, 0, 1 | DECOMP_INLINE, 0x5351},
+       {0xFA36, 0, 1 | DECOMP_INLINE, 0x559D},
+       {0xFA37, 0, 1 | DECOMP_INLINE, 0x5606},
+       {0xFA38, 0, 1 | DECOMP_INLINE, 0x5668},
+       {0xFA39, 0, 1 | DECOMP_INLINE, 0x5840},
+       {0xFA3A, 0, 1 | DECOMP_INLINE, 0x58A8},
+       {0xFA3B, 0, 1 | DECOMP_INLINE, 0x5C64},
+       {0xFA3C, 0, 1 | DECOMP_INLINE, 0x5C6E},
+       {0xFA3D, 0, 1 | DECOMP_INLINE, 0x6094},
+       {0xFA3E, 0, 1 | DECOMP_INLINE, 0x6168},
+       {0xFA3F, 0, 1 | DECOMP_INLINE, 0x618E},
+       {0xFA40, 0, 1 | DECOMP_INLINE, 0x61F2},
+       {0xFA41, 0, 1 | DECOMP_INLINE, 0x654F},
+       {0xFA42, 0, 1 | DECOMP_INLINE, 0x65E2},
+       {0xFA43, 0, 1 | DECOMP_INLINE, 0x6691},
+       {0xFA44, 0, 1 | DECOMP_INLINE, 0x6885},
+       {0xFA45, 0, 1 | DECOMP_INLINE, 0x6D77},
+       {0xFA46, 0, 1 | DECOMP_INLINE, 0x6E1A},
+       {0xFA47, 0, 1 | DECOMP_INLINE, 0x6F22},
+       {0xFA48, 0, 1 | DECOMP_INLINE, 0x716E},
+       {0xFA49, 0, 1 | DECOMP_INLINE, 0x722B},
+       {0xFA4A, 0, 1 | DECOMP_INLINE, 0x7422},
+       {0xFA4B, 0, 1 | DECOMP_INLINE, 0x7891},
+       {0xFA4C, 0, 1 | DECOMP_INLINE, 0x793E},
+       {0xFA4D, 0, 1 | DECOMP_INLINE, 0x7949},
+       {0xFA4E, 0, 1 | DECOMP_INLINE, 0x7948},
+       {0xFA4F, 0, 1 | DECOMP_INLINE, 0x7950},
+       {0xFA50, 0, 1 | DECOMP_INLINE, 0x7956},
+       {0xFA51, 0, 1 | DECOMP_INLINE, 0x795D},
+       {0xFA52, 0, 1 | DECOMP_INLINE, 0x798D},
+       {0xFA53, 0, 1 | DECOMP_INLINE, 0x798E},
+       {0xFA54, 0, 1 | DECOMP_INLINE, 0x7A40},
+       {0xFA55, 0, 1 | DECOMP_INLINE, 0x7A81},
+       {0xFA56, 0, 1 | DECOMP_INLINE, 0x7BC0},
+       {0xFA57, 0, 1 | DECOMP_INLINE, 0x7DF4},
+       {0xFA58, 0, 1 | DECOMP_INLINE, 0x7E09},
+       {0xFA59, 0, 1 | DECOMP_INLINE, 0x7E41},
+       {0xFA5A, 0, 1 | DECOMP_INLINE, 0x7F72},
+       {0xFA5B, 0, 1 | DECOMP_INLINE, 0x8005},
+       {0xFA5C, 0, 1 | DECOMP_INLINE, 0x81ED},
+       {0xFA5D, 0, 1 | DECOMP_INLINE, 0x8279},
+       {0xFA5E, 0, 1 | DECOMP_INLINE, 0x8279},
+       {0xFA5F, 0, 1 | DECOMP_INLINE, 0x8457},
+       {0xFA60, 0, 1 | DECOMP_INLINE, 0x8910},
+       {0xFA61, 0, 1 | DECOMP_INLINE, 0x8996},
+       {0xFA62, 0, 1 | DECOMP_INLINE, 0x8B01},
+       {0xFA63, 0, 1 | DECOMP_INLINE, 0x8B39},
+       {0xFA64, 0, 1 | DECOMP_INLINE, 0x8CD3},
+       {0xFA65, 0, 1 | DECOMP_INLINE, 0x8D08},
+       {0xFA66, 0, 1 | DECOMP_INLINE, 0x8FB6},
+       {0xFA67, 0, 1 | DECOMP_INLINE, 0x9038},
+       {0xFA68, 0, 1 | DECOMP_INLINE, 0x96E3},
+       {0xFA69, 0, 1 | DECOMP_INLINE, 0x97FF},
+       {0xFA6A, 0, 1 | DECOMP_INLINE, 0x983B},
+       {0xFA6B, 0, 1 | DECOMP_INLINE, 0x6075},
+       {0xFA6C, 0, 1, 3525},
+       {0xFA6D, 0, 1 | DECOMP_INLINE, 0x8218},
+       {0xFA70, 0, 1 | DECOMP_INLINE, 0x4E26},
+       {0xFA71, 0, 1 | DECOMP_INLINE, 0x51B5},
+       {0xFA72, 0, 1 | DECOMP_INLINE, 0x5168},
+       {0xFA73, 0, 1 | DECOMP_INLINE, 0x4F80},
+       {0xFA74, 0, 1 | DECOMP_INLINE, 0x5145},
+       {0xFA75, 0, 1 | DECOMP_INLINE, 0x5180},
+       {0xFA76, 0, 1 | DECOMP_INLINE, 0x52C7},
+       {0xFA77, 0, 1 | DECOMP_INLINE, 0x52FA},
+       {0xFA78, 0, 1 | DECOMP_INLINE, 0x559D},
+       {0xFA79, 0, 1 | DECOMP_INLINE, 0x5555},
+       {0xFA7A, 0, 1 | DECOMP_INLINE, 0x5599},
+       {0xFA7B, 0, 1 | DECOMP_INLINE, 0x55E2},
+       {0xFA7C, 0, 1 | DECOMP_INLINE, 0x585A},
+       {0xFA7D, 0, 1 | DECOMP_INLINE, 0x58B3},
+       {0xFA7E, 0, 1 | DECOMP_INLINE, 0x5944},
+       {0xFA7F, 0, 1 | DECOMP_INLINE, 0x5954},
+       {0xFA80, 0, 1 | DECOMP_INLINE, 0x5A62},
+       {0xFA81, 0, 1 | DECOMP_INLINE, 0x5B28},
+       {0xFA82, 0, 1 | DECOMP_INLINE, 0x5ED2},
+       {0xFA83, 0, 1 | DECOMP_INLINE, 0x5ED9},
+       {0xFA84, 0, 1 | DECOMP_INLINE, 0x5F69},
+       {0xFA85, 0, 1 | DECOMP_INLINE, 0x5FAD},
+       {0xFA86, 0, 1 | DECOMP_INLINE, 0x60D8},
+       {0xFA87, 0, 1 | DECOMP_INLINE, 0x614E},
+       {0xFA88, 0, 1 | DECOMP_INLINE, 0x6108},
+       {0xFA89, 0, 1 | DECOMP_INLINE, 0x618E},
+       {0xFA8A, 0, 1 | DECOMP_INLINE, 0x6160},
+       {0xFA8B, 0, 1 | DECOMP_INLINE, 0x61F2},
+       {0xFA8C, 0, 1 | DECOMP_INLINE, 0x6234},
+       {0xFA8D, 0, 1 | DECOMP_INLINE, 0x63C4},
+       {0xFA8E, 0, 1 | DECOMP_INLINE, 0x641C},
+       {0xFA8F, 0, 1 | DECOMP_INLINE, 0x6452},
+       {0xFA90, 0, 1 | DECOMP_INLINE, 0x6556},
+       {0xFA91, 0, 1 | DECOMP_INLINE, 0x6674},
+       {0xFA92, 0, 1 | DECOMP_INLINE, 0x6717},
+       {0xFA93, 0, 1 | DECOMP_INLINE, 0x671B},
+       {0xFA94, 0, 1 | DECOMP_INLINE, 0x6756},
+       {0xFA95, 0, 1 | DECOMP_INLINE, 0x6B79},
+       {0xFA96, 0, 1 | DECOMP_INLINE, 0x6BBA},
+       {0xFA97, 0, 1 | DECOMP_INLINE, 0x6D41},
+       {0xFA98, 0, 1 | DECOMP_INLINE, 0x6EDB},
+       {0xFA99, 0, 1 | DECOMP_INLINE, 0x6ECB},
+       {0xFA9A, 0, 1 | DECOMP_INLINE, 0x6F22},
+       {0xFA9B, 0, 1 | DECOMP_INLINE, 0x701E},
+       {0xFA9C, 0, 1 | DECOMP_INLINE, 0x716E},
+       {0xFA9D, 0, 1 | DECOMP_INLINE, 0x77A7},
+       {0xFA9E, 0, 1 | DECOMP_INLINE, 0x7235},
+       {0xFA9F, 0, 1 | DECOMP_INLINE, 0x72AF},
+       {0xFAA0, 0, 1 | DECOMP_INLINE, 0x732A},
+       {0xFAA1, 0, 1 | DECOMP_INLINE, 0x7471},
+       {0xFAA2, 0, 1 | DECOMP_INLINE, 0x7506},
+       {0xFAA3, 0, 1 | DECOMP_INLINE, 0x753B},
+       {0xFAA4, 0, 1 | DECOMP_INLINE, 0x761D},
+       {0xFAA5, 0, 1 | DECOMP_INLINE, 0x761F},
+       {0xFAA6, 0, 1 | DECOMP_INLINE, 0x76CA},
+       {0xFAA7, 0, 1 | DECOMP_INLINE, 0x76DB},
+       {0xFAA8, 0, 1 | DECOMP_INLINE, 0x76F4},
+       {0xFAA9, 0, 1 | DECOMP_INLINE, 0x774A},
+       {0xFAAA, 0, 1 | DECOMP_INLINE, 0x7740},
+       {0xFAAB, 0, 1 | DECOMP_INLINE, 0x78CC},
+       {0xFAAC, 0, 1 | DECOMP_INLINE, 0x7AB1},
+       {0xFAAD, 0, 1 | DECOMP_INLINE, 0x7BC0},
+       {0xFAAE, 0, 1 | DECOMP_INLINE, 0x7C7B},
+       {0xFAAF, 0, 1 | DECOMP_INLINE, 0x7D5B},
+       {0xFAB0, 0, 1 | DECOMP_INLINE, 0x7DF4},
+       {0xFAB1, 0, 1 | DECOMP_INLINE, 0x7F3E},
+       {0xFAB2, 0, 1 | DECOMP_INLINE, 0x8005},
+       {0xFAB3, 0, 1 | DECOMP_INLINE, 0x8352},
+       {0xFAB4, 0, 1 | DECOMP_INLINE, 0x83EF},
+       {0xFAB5, 0, 1 | DECOMP_INLINE, 0x8779},
+       {0xFAB6, 0, 1 | DECOMP_INLINE, 0x8941},
+       {0xFAB7, 0, 1 | DECOMP_INLINE, 0x8986},
+       {0xFAB8, 0, 1 | DECOMP_INLINE, 0x8996},
+       {0xFAB9, 0, 1 | DECOMP_INLINE, 0x8ABF},
+       {0xFABA, 0, 1 | DECOMP_INLINE, 0x8AF8},
+       {0xFABB, 0, 1 | DECOMP_INLINE, 0x8ACB},
+       {0xFABC, 0, 1 | DECOMP_INLINE, 0x8B01},
+       {0xFABD, 0, 1 | DECOMP_INLINE, 0x8AFE},
+       {0xFABE, 0, 1 | DECOMP_INLINE, 0x8AED},
+       {0xFABF, 0, 1 | DECOMP_INLINE, 0x8B39},
+       {0xFAC0, 0, 1 | DECOMP_INLINE, 0x8B8A},
+       {0xFAC1, 0, 1 | DECOMP_INLINE, 0x8D08},
+       {0xFAC2, 0, 1 | DECOMP_INLINE, 0x8F38},
+       {0xFAC3, 0, 1 | DECOMP_INLINE, 0x9072},
+       {0xFAC4, 0, 1 | DECOMP_INLINE, 0x9199},
+       {0xFAC5, 0, 1 | DECOMP_INLINE, 0x9276},
+       {0xFAC6, 0, 1 | DECOMP_INLINE, 0x967C},
+       {0xFAC7, 0, 1 | DECOMP_INLINE, 0x96E3},
+       {0xFAC8, 0, 1 | DECOMP_INLINE, 0x9756},
+       {0xFAC9, 0, 1 | DECOMP_INLINE, 0x97DB},
+       {0xFACA, 0, 1 | DECOMP_INLINE, 0x97FF},
+       {0xFACB, 0, 1 | DECOMP_INLINE, 0x980B},
+       {0xFACC, 0, 1 | DECOMP_INLINE, 0x983B},
+       {0xFACD, 0, 1 | DECOMP_INLINE, 0x9B12},
+       {0xFACE, 0, 1 | DECOMP_INLINE, 0x9F9C},
+       {0xFACF, 0, 1, 3526},
+       {0xFAD0, 0, 1, 3527},
+       {0xFAD1, 0, 1, 3528},
+       {0xFAD2, 0, 1 | DECOMP_INLINE, 0x3B9D},
+       {0xFAD3, 0, 1 | DECOMP_INLINE, 0x4018},
+       {0xFAD4, 0, 1 | DECOMP_INLINE, 0x4039},
+       {0xFAD5, 0, 1, 3529},
+       {0xFAD6, 0, 1, 3530},
+       {0xFAD7, 0, 1, 3531},
+       {0xFAD8, 0, 1 | DECOMP_INLINE, 0x9F43},
+       {0xFAD9, 0, 1 | DECOMP_INLINE, 0x9F8E},
+       {0xFB00, 0, 2 | DECOMP_NO_COMPOSE, 3532},       /* compatibility mapping */
+       {0xFB01, 0, 2 | DECOMP_NO_COMPOSE, 3534},       /* compatibility mapping */
+       {0xFB02, 0, 2 | DECOMP_NO_COMPOSE, 3536},       /* compatibility mapping */
+       {0xFB03, 0, 3, 3538},
+       {0xFB04, 0, 3, 3541},
+       {0xFB05, 0, 2 | DECOMP_NO_COMPOSE, 3544},       /* compatibility mapping */
+       {0xFB06, 0, 2 | DECOMP_NO_COMPOSE, 3546},       /* compatibility mapping */
+       {0xFB13, 0, 2 | DECOMP_NO_COMPOSE, 3548},       /* compatibility mapping */
+       {0xFB14, 0, 2 | DECOMP_NO_COMPOSE, 3550},       /* compatibility mapping */
+       {0xFB15, 0, 2 | DECOMP_NO_COMPOSE, 3552},       /* compatibility mapping */
+       {0xFB16, 0, 2 | DECOMP_NO_COMPOSE, 3554},       /* compatibility mapping */
+       {0xFB17, 0, 2 | DECOMP_NO_COMPOSE, 3556},       /* compatibility mapping */
+       {0xFB1D, 0, 2 | DECOMP_NO_COMPOSE, 3558},       /* in exclusion list */
+       {0xFB1E, 26, 0, 0},
+       {0xFB1F, 0, 2 | DECOMP_NO_COMPOSE, 3560},       /* in exclusion list */
+       {0xFB20, 0, 1 | DECOMP_INLINE, 0x05E2},
+       {0xFB21, 0, 1 | DECOMP_INLINE, 0x05D0},
+       {0xFB22, 0, 1 | DECOMP_INLINE, 0x05D3},
+       {0xFB23, 0, 1 | DECOMP_INLINE, 0x05D4},
+       {0xFB24, 0, 1 | DECOMP_INLINE, 0x05DB},
+       {0xFB25, 0, 1 | DECOMP_INLINE, 0x05DC},
+       {0xFB26, 0, 1 | DECOMP_INLINE, 0x05DD},
+       {0xFB27, 0, 1 | DECOMP_INLINE, 0x05E8},
+       {0xFB28, 0, 1 | DECOMP_INLINE, 0x05EA},
+       {0xFB29, 0, 1 | DECOMP_INLINE, 0x002B},
+       {0xFB2A, 0, 2 | DECOMP_NO_COMPOSE, 3562},       /* in exclusion list */
+       {0xFB2B, 0, 2 | DECOMP_NO_COMPOSE, 3564},       /* in exclusion list */
+       {0xFB2C, 0, 2 | DECOMP_NO_COMPOSE, 3566},       /* in exclusion list */
+       {0xFB2D, 0, 2 | DECOMP_NO_COMPOSE, 3568},       /* in exclusion list */
+       {0xFB2E, 0, 2 | DECOMP_NO_COMPOSE, 3570},       /* in exclusion list */
+       {0xFB2F, 0, 2 | DECOMP_NO_COMPOSE, 3572},       /* in exclusion list */
+       {0xFB30, 0, 2 | DECOMP_NO_COMPOSE, 3574},       /* in exclusion list */
+       {0xFB31, 0, 2 | DECOMP_NO_COMPOSE, 3576},       /* in exclusion list */
+       {0xFB32, 0, 2 | DECOMP_NO_COMPOSE, 3578},       /* in exclusion list */
+       {0xFB33, 0, 2 | DECOMP_NO_COMPOSE, 3580},       /* in exclusion list */
+       {0xFB34, 0, 2 | DECOMP_NO_COMPOSE, 3582},       /* in exclusion list */
+       {0xFB35, 0, 2 | DECOMP_NO_COMPOSE, 3584},       /* in exclusion list */
+       {0xFB36, 0, 2 | DECOMP_NO_COMPOSE, 3586},       /* in exclusion list */
+       {0xFB38, 0, 2 | DECOMP_NO_COMPOSE, 3588},       /* in exclusion list */
+       {0xFB39, 0, 2 | DECOMP_NO_COMPOSE, 3590},       /* in exclusion list */
+       {0xFB3A, 0, 2 | DECOMP_NO_COMPOSE, 3592},       /* in exclusion list */
+       {0xFB3B, 0, 2 | DECOMP_NO_COMPOSE, 3594},       /* in exclusion list */
+       {0xFB3C, 0, 2 | DECOMP_NO_COMPOSE, 3596},       /* in exclusion list */
+       {0xFB3E, 0, 2 | DECOMP_NO_COMPOSE, 3598},       /* in exclusion list */
+       {0xFB40, 0, 2 | DECOMP_NO_COMPOSE, 3600},       /* in exclusion list */
+       {0xFB41, 0, 2 | DECOMP_NO_COMPOSE, 3602},       /* in exclusion list */
+       {0xFB43, 0, 2 | DECOMP_NO_COMPOSE, 3604},       /* in exclusion list */
+       {0xFB44, 0, 2 | DECOMP_NO_COMPOSE, 3606},       /* in exclusion list */
+       {0xFB46, 0, 2 | DECOMP_NO_COMPOSE, 3608},       /* in exclusion list */
+       {0xFB47, 0, 2 | DECOMP_NO_COMPOSE, 3610},       /* in exclusion list */
+       {0xFB48, 0, 2 | DECOMP_NO_COMPOSE, 3612},       /* in exclusion list */
+       {0xFB49, 0, 2 | DECOMP_NO_COMPOSE, 3614},       /* in exclusion list */
+       {0xFB4A, 0, 2 | DECOMP_NO_COMPOSE, 3616},       /* in exclusion list */
+       {0xFB4B, 0, 2 | DECOMP_NO_COMPOSE, 3618},       /* in exclusion list */
+       {0xFB4C, 0, 2 | DECOMP_NO_COMPOSE, 3620},       /* in exclusion list */
+       {0xFB4D, 0, 2 | DECOMP_NO_COMPOSE, 3622},       /* in exclusion list */
+       {0xFB4E, 0, 2 | DECOMP_NO_COMPOSE, 3624},       /* in exclusion list */
+       {0xFB4F, 0, 2 | DECOMP_NO_COMPOSE, 3626},       /* compatibility mapping */
+       {0xFB50, 0, 1 | DECOMP_INLINE, 0x0671},
+       {0xFB51, 0, 1 | DECOMP_INLINE, 0x0671},
+       {0xFB52, 0, 1 | DECOMP_INLINE, 0x067B},
+       {0xFB53, 0, 1 | DECOMP_INLINE, 0x067B},
+       {0xFB54, 0, 1 | DECOMP_INLINE, 0x067B},
+       {0xFB55, 0, 1 | DECOMP_INLINE, 0x067B},
+       {0xFB56, 0, 1 | DECOMP_INLINE, 0x067E},
+       {0xFB57, 0, 1 | DECOMP_INLINE, 0x067E},
+       {0xFB58, 0, 1 | DECOMP_INLINE, 0x067E},
+       {0xFB59, 0, 1 | DECOMP_INLINE, 0x067E},
+       {0xFB5A, 0, 1 | DECOMP_INLINE, 0x0680},
+       {0xFB5B, 0, 1 | DECOMP_INLINE, 0x0680},
+       {0xFB5C, 0, 1 | DECOMP_INLINE, 0x0680},
+       {0xFB5D, 0, 1 | DECOMP_INLINE, 0x0680},
+       {0xFB5E, 0, 1 | DECOMP_INLINE, 0x067A},
+       {0xFB5F, 0, 1 | DECOMP_INLINE, 0x067A},
+       {0xFB60, 0, 1 | DECOMP_INLINE, 0x067A},
+       {0xFB61, 0, 1 | DECOMP_INLINE, 0x067A},
+       {0xFB62, 0, 1 | DECOMP_INLINE, 0x067F},
+       {0xFB63, 0, 1 | DECOMP_INLINE, 0x067F},
+       {0xFB64, 0, 1 | DECOMP_INLINE, 0x067F},
+       {0xFB65, 0, 1 | DECOMP_INLINE, 0x067F},
+       {0xFB66, 0, 1 | DECOMP_INLINE, 0x0679},
+       {0xFB67, 0, 1 | DECOMP_INLINE, 0x0679},
+       {0xFB68, 0, 1 | DECOMP_INLINE, 0x0679},
+       {0xFB69, 0, 1 | DECOMP_INLINE, 0x0679},
+       {0xFB6A, 0, 1 | DECOMP_INLINE, 0x06A4},
+       {0xFB6B, 0, 1 | DECOMP_INLINE, 0x06A4},
+       {0xFB6C, 0, 1 | DECOMP_INLINE, 0x06A4},
+       {0xFB6D, 0, 1 | DECOMP_INLINE, 0x06A4},
+       {0xFB6E, 0, 1 | DECOMP_INLINE, 0x06A6},
+       {0xFB6F, 0, 1 | DECOMP_INLINE, 0x06A6},
+       {0xFB70, 0, 1 | DECOMP_INLINE, 0x06A6},
+       {0xFB71, 0, 1 | DECOMP_INLINE, 0x06A6},
+       {0xFB72, 0, 1 | DECOMP_INLINE, 0x0684},
+       {0xFB73, 0, 1 | DECOMP_INLINE, 0x0684},
+       {0xFB74, 0, 1 | DECOMP_INLINE, 0x0684},
+       {0xFB75, 0, 1 | DECOMP_INLINE, 0x0684},
+       {0xFB76, 0, 1 | DECOMP_INLINE, 0x0683},
+       {0xFB77, 0, 1 | DECOMP_INLINE, 0x0683},
+       {0xFB78, 0, 1 | DECOMP_INLINE, 0x0683},
+       {0xFB79, 0, 1 | DECOMP_INLINE, 0x0683},
+       {0xFB7A, 0, 1 | DECOMP_INLINE, 0x0686},
+       {0xFB7B, 0, 1 | DECOMP_INLINE, 0x0686},
+       {0xFB7C, 0, 1 | DECOMP_INLINE, 0x0686},
+       {0xFB7D, 0, 1 | DECOMP_INLINE, 0x0686},
+       {0xFB7E, 0, 1 | DECOMP_INLINE, 0x0687},
+       {0xFB7F, 0, 1 | DECOMP_INLINE, 0x0687},
+       {0xFB80, 0, 1 | DECOMP_INLINE, 0x0687},
+       {0xFB81, 0, 1 | DECOMP_INLINE, 0x0687},
+       {0xFB82, 0, 1 | DECOMP_INLINE, 0x068D},
+       {0xFB83, 0, 1 | DECOMP_INLINE, 0x068D},
+       {0xFB84, 0, 1 | DECOMP_INLINE, 0x068C},
+       {0xFB85, 0, 1 | DECOMP_INLINE, 0x068C},
+       {0xFB86, 0, 1 | DECOMP_INLINE, 0x068E},
+       {0xFB87, 0, 1 | DECOMP_INLINE, 0x068E},
+       {0xFB88, 0, 1 | DECOMP_INLINE, 0x0688},
+       {0xFB89, 0, 1 | DECOMP_INLINE, 0x0688},
+       {0xFB8A, 0, 1 | DECOMP_INLINE, 0x0698},
+       {0xFB8B, 0, 1 | DECOMP_INLINE, 0x0698},
+       {0xFB8C, 0, 1 | DECOMP_INLINE, 0x0691},
+       {0xFB8D, 0, 1 | DECOMP_INLINE, 0x0691},
+       {0xFB8E, 0, 1 | DECOMP_INLINE, 0x06A9},
+       {0xFB8F, 0, 1 | DECOMP_INLINE, 0x06A9},
+       {0xFB90, 0, 1 | DECOMP_INLINE, 0x06A9},
+       {0xFB91, 0, 1 | DECOMP_INLINE, 0x06A9},
+       {0xFB92, 0, 1 | DECOMP_INLINE, 0x06AF},
+       {0xFB93, 0, 1 | DECOMP_INLINE, 0x06AF},
+       {0xFB94, 0, 1 | DECOMP_INLINE, 0x06AF},
+       {0xFB95, 0, 1 | DECOMP_INLINE, 0x06AF},
+       {0xFB96, 0, 1 | DECOMP_INLINE, 0x06B3},
+       {0xFB97, 0, 1 | DECOMP_INLINE, 0x06B3},
+       {0xFB98, 0, 1 | DECOMP_INLINE, 0x06B3},
+       {0xFB99, 0, 1 | DECOMP_INLINE, 0x06B3},
+       {0xFB9A, 0, 1 | DECOMP_INLINE, 0x06B1},
+       {0xFB9B, 0, 1 | DECOMP_INLINE, 0x06B1},
+       {0xFB9C, 0, 1 | DECOMP_INLINE, 0x06B1},
+       {0xFB9D, 0, 1 | DECOMP_INLINE, 0x06B1},
+       {0xFB9E, 0, 1 | DECOMP_INLINE, 0x06BA},
+       {0xFB9F, 0, 1 | DECOMP_INLINE, 0x06BA},
+       {0xFBA0, 0, 1 | DECOMP_INLINE, 0x06BB},
+       {0xFBA1, 0, 1 | DECOMP_INLINE, 0x06BB},
+       {0xFBA2, 0, 1 | DECOMP_INLINE, 0x06BB},
+       {0xFBA3, 0, 1 | DECOMP_INLINE, 0x06BB},
+       {0xFBA4, 0, 1 | DECOMP_INLINE, 0x06C0},
+       {0xFBA5, 0, 1 | DECOMP_INLINE, 0x06C0},
+       {0xFBA6, 0, 1 | DECOMP_INLINE, 0x06C1},
+       {0xFBA7, 0, 1 | DECOMP_INLINE, 0x06C1},
+       {0xFBA8, 0, 1 | DECOMP_INLINE, 0x06C1},
+       {0xFBA9, 0, 1 | DECOMP_INLINE, 0x06C1},
+       {0xFBAA, 0, 1 | DECOMP_INLINE, 0x06BE},
+       {0xFBAB, 0, 1 | DECOMP_INLINE, 0x06BE},
+       {0xFBAC, 0, 1 | DECOMP_INLINE, 0x06BE},
+       {0xFBAD, 0, 1 | DECOMP_INLINE, 0x06BE},
+       {0xFBAE, 0, 1 | DECOMP_INLINE, 0x06D2},
+       {0xFBAF, 0, 1 | DECOMP_INLINE, 0x06D2},
+       {0xFBB0, 0, 1 | DECOMP_INLINE, 0x06D3},
+       {0xFBB1, 0, 1 | DECOMP_INLINE, 0x06D3},
+       {0xFBD3, 0, 1 | DECOMP_INLINE, 0x06AD},
+       {0xFBD4, 0, 1 | DECOMP_INLINE, 0x06AD},
+       {0xFBD5, 0, 1 | DECOMP_INLINE, 0x06AD},
+       {0xFBD6, 0, 1 | DECOMP_INLINE, 0x06AD},
+       {0xFBD7, 0, 1 | DECOMP_INLINE, 0x06C7},
+       {0xFBD8, 0, 1 | DECOMP_INLINE, 0x06C7},
+       {0xFBD9, 0, 1 | DECOMP_INLINE, 0x06C6},
+       {0xFBDA, 0, 1 | DECOMP_INLINE, 0x06C6},
+       {0xFBDB, 0, 1 | DECOMP_INLINE, 0x06C8},
+       {0xFBDC, 0, 1 | DECOMP_INLINE, 0x06C8},
+       {0xFBDD, 0, 1 | DECOMP_INLINE, 0x0677},
+       {0xFBDE, 0, 1 | DECOMP_INLINE, 0x06CB},
+       {0xFBDF, 0, 1 | DECOMP_INLINE, 0x06CB},
+       {0xFBE0, 0, 1 | DECOMP_INLINE, 0x06C5},
+       {0xFBE1, 0, 1 | DECOMP_INLINE, 0x06C5},
+       {0xFBE2, 0, 1 | DECOMP_INLINE, 0x06C9},
+       {0xFBE3, 0, 1 | DECOMP_INLINE, 0x06C9},
+       {0xFBE4, 0, 1 | DECOMP_INLINE, 0x06D0},
+       {0xFBE5, 0, 1 | DECOMP_INLINE, 0x06D0},
+       {0xFBE6, 0, 1 | DECOMP_INLINE, 0x06D0},
+       {0xFBE7, 0, 1 | DECOMP_INLINE, 0x06D0},
+       {0xFBE8, 0, 1 | DECOMP_INLINE, 0x0649},
+       {0xFBE9, 0, 1 | DECOMP_INLINE, 0x0649},
+       {0xFBEA, 0, 2 | DECOMP_NO_COMPOSE, 3628},       /* compatibility mapping */
+       {0xFBEB, 0, 2 | DECOMP_NO_COMPOSE, 3630},       /* compatibility mapping */
+       {0xFBEC, 0, 2 | DECOMP_NO_COMPOSE, 3632},       /* compatibility mapping */
+       {0xFBED, 0, 2 | DECOMP_NO_COMPOSE, 3634},       /* compatibility mapping */
+       {0xFBEE, 0, 2 | DECOMP_NO_COMPOSE, 3636},       /* compatibility mapping */
+       {0xFBEF, 0, 2 | DECOMP_NO_COMPOSE, 3638},       /* compatibility mapping */
+       {0xFBF0, 0, 2 | DECOMP_NO_COMPOSE, 3640},       /* compatibility mapping */
+       {0xFBF1, 0, 2 | DECOMP_NO_COMPOSE, 3642},       /* compatibility mapping */
+       {0xFBF2, 0, 2 | DECOMP_NO_COMPOSE, 3644},       /* compatibility mapping */
+       {0xFBF3, 0, 2 | DECOMP_NO_COMPOSE, 3646},       /* compatibility mapping */
+       {0xFBF4, 0, 2 | DECOMP_NO_COMPOSE, 3648},       /* compatibility mapping */
+       {0xFBF5, 0, 2 | DECOMP_NO_COMPOSE, 3650},       /* compatibility mapping */
+       {0xFBF6, 0, 2 | DECOMP_NO_COMPOSE, 3652},       /* compatibility mapping */
+       {0xFBF7, 0, 2 | DECOMP_NO_COMPOSE, 3654},       /* compatibility mapping */
+       {0xFBF8, 0, 2 | DECOMP_NO_COMPOSE, 3656},       /* compatibility mapping */
+       {0xFBF9, 0, 2 | DECOMP_NO_COMPOSE, 3658},       /* compatibility mapping */
+       {0xFBFA, 0, 2 | DECOMP_NO_COMPOSE, 3660},       /* compatibility mapping */
+       {0xFBFB, 0, 2 | DECOMP_NO_COMPOSE, 3662},       /* compatibility mapping */
+       {0xFBFC, 0, 1 | DECOMP_INLINE, 0x06CC},
+       {0xFBFD, 0, 1 | DECOMP_INLINE, 0x06CC},
+       {0xFBFE, 0, 1 | DECOMP_INLINE, 0x06CC},
+       {0xFBFF, 0, 1 | DECOMP_INLINE, 0x06CC},
+       {0xFC00, 0, 2 | DECOMP_NO_COMPOSE, 3664},       /* compatibility mapping */
+       {0xFC01, 0, 2 | DECOMP_NO_COMPOSE, 3666},       /* compatibility mapping */
+       {0xFC02, 0, 2 | DECOMP_NO_COMPOSE, 3668},       /* compatibility mapping */
+       {0xFC03, 0, 2 | DECOMP_NO_COMPOSE, 3670},       /* compatibility mapping */
+       {0xFC04, 0, 2 | DECOMP_NO_COMPOSE, 3672},       /* compatibility mapping */
+       {0xFC05, 0, 2 | DECOMP_NO_COMPOSE, 3674},       /* compatibility mapping */
+       {0xFC06, 0, 2 | DECOMP_NO_COMPOSE, 3676},       /* compatibility mapping */
+       {0xFC07, 0, 2 | DECOMP_NO_COMPOSE, 3678},       /* compatibility mapping */
+       {0xFC08, 0, 2 | DECOMP_NO_COMPOSE, 3680},       /* compatibility mapping */
+       {0xFC09, 0, 2 | DECOMP_NO_COMPOSE, 3682},       /* compatibility mapping */
+       {0xFC0A, 0, 2 | DECOMP_NO_COMPOSE, 3684},       /* compatibility mapping */
+       {0xFC0B, 0, 2 | DECOMP_NO_COMPOSE, 3686},       /* compatibility mapping */
+       {0xFC0C, 0, 2 | DECOMP_NO_COMPOSE, 3688},       /* compatibility mapping */
+       {0xFC0D, 0, 2 | DECOMP_NO_COMPOSE, 3690},       /* compatibility mapping */
+       {0xFC0E, 0, 2 | DECOMP_NO_COMPOSE, 3692},       /* compatibility mapping */
+       {0xFC0F, 0, 2 | DECOMP_NO_COMPOSE, 3694},       /* compatibility mapping */
+       {0xFC10, 0, 2 | DECOMP_NO_COMPOSE, 3696},       /* compatibility mapping */
+       {0xFC11, 0, 2 | DECOMP_NO_COMPOSE, 3698},       /* compatibility mapping */
+       {0xFC12, 0, 2 | DECOMP_NO_COMPOSE, 3700},       /* compatibility mapping */
+       {0xFC13, 0, 2 | DECOMP_NO_COMPOSE, 3702},       /* compatibility mapping */
+       {0xFC14, 0, 2 | DECOMP_NO_COMPOSE, 3704},       /* compatibility mapping */
+       {0xFC15, 0, 2 | DECOMP_NO_COMPOSE, 3706},       /* compatibility mapping */
+       {0xFC16, 0, 2 | DECOMP_NO_COMPOSE, 3708},       /* compatibility mapping */
+       {0xFC17, 0, 2 | DECOMP_NO_COMPOSE, 3710},       /* compatibility mapping */
+       {0xFC18, 0, 2 | DECOMP_NO_COMPOSE, 3712},       /* compatibility mapping */
+       {0xFC19, 0, 2 | DECOMP_NO_COMPOSE, 3714},       /* compatibility mapping */
+       {0xFC1A, 0, 2 | DECOMP_NO_COMPOSE, 3716},       /* compatibility mapping */
+       {0xFC1B, 0, 2 | DECOMP_NO_COMPOSE, 3718},       /* compatibility mapping */
+       {0xFC1C, 0, 2 | DECOMP_NO_COMPOSE, 3720},       /* compatibility mapping */
+       {0xFC1D, 0, 2 | DECOMP_NO_COMPOSE, 3722},       /* compatibility mapping */
+       {0xFC1E, 0, 2 | DECOMP_NO_COMPOSE, 3724},       /* compatibility mapping */
+       {0xFC1F, 0, 2 | DECOMP_NO_COMPOSE, 3726},       /* compatibility mapping */
+       {0xFC20, 0, 2 | DECOMP_NO_COMPOSE, 3728},       /* compatibility mapping */
+       {0xFC21, 0, 2 | DECOMP_NO_COMPOSE, 3730},       /* compatibility mapping */
+       {0xFC22, 0, 2 | DECOMP_NO_COMPOSE, 3732},       /* compatibility mapping */
+       {0xFC23, 0, 2 | DECOMP_NO_COMPOSE, 3734},       /* compatibility mapping */
+       {0xFC24, 0, 2 | DECOMP_NO_COMPOSE, 3736},       /* compatibility mapping */
+       {0xFC25, 0, 2 | DECOMP_NO_COMPOSE, 3738},       /* compatibility mapping */
+       {0xFC26, 0, 2 | DECOMP_NO_COMPOSE, 3740},       /* compatibility mapping */
+       {0xFC27, 0, 2 | DECOMP_NO_COMPOSE, 3742},       /* compatibility mapping */
+       {0xFC28, 0, 2 | DECOMP_NO_COMPOSE, 3744},       /* compatibility mapping */
+       {0xFC29, 0, 2 | DECOMP_NO_COMPOSE, 3746},       /* compatibility mapping */
+       {0xFC2A, 0, 2 | DECOMP_NO_COMPOSE, 3748},       /* compatibility mapping */
+       {0xFC2B, 0, 2 | DECOMP_NO_COMPOSE, 3750},       /* compatibility mapping */
+       {0xFC2C, 0, 2 | DECOMP_NO_COMPOSE, 3752},       /* compatibility mapping */
+       {0xFC2D, 0, 2 | DECOMP_NO_COMPOSE, 3754},       /* compatibility mapping */
+       {0xFC2E, 0, 2 | DECOMP_NO_COMPOSE, 3756},       /* compatibility mapping */
+       {0xFC2F, 0, 2 | DECOMP_NO_COMPOSE, 3758},       /* compatibility mapping */
+       {0xFC30, 0, 2 | DECOMP_NO_COMPOSE, 3760},       /* compatibility mapping */
+       {0xFC31, 0, 2 | DECOMP_NO_COMPOSE, 3762},       /* compatibility mapping */
+       {0xFC32, 0, 2 | DECOMP_NO_COMPOSE, 3764},       /* compatibility mapping */
+       {0xFC33, 0, 2 | DECOMP_NO_COMPOSE, 3766},       /* compatibility mapping */
+       {0xFC34, 0, 2 | DECOMP_NO_COMPOSE, 3768},       /* compatibility mapping */
+       {0xFC35, 0, 2 | DECOMP_NO_COMPOSE, 3770},       /* compatibility mapping */
+       {0xFC36, 0, 2 | DECOMP_NO_COMPOSE, 3772},       /* compatibility mapping */
+       {0xFC37, 0, 2 | DECOMP_NO_COMPOSE, 3774},       /* compatibility mapping */
+       {0xFC38, 0, 2 | DECOMP_NO_COMPOSE, 3776},       /* compatibility mapping */
+       {0xFC39, 0, 2 | DECOMP_NO_COMPOSE, 3778},       /* compatibility mapping */
+       {0xFC3A, 0, 2 | DECOMP_NO_COMPOSE, 3780},       /* compatibility mapping */
+       {0xFC3B, 0, 2 | DECOMP_NO_COMPOSE, 3782},       /* compatibility mapping */
+       {0xFC3C, 0, 2 | DECOMP_NO_COMPOSE, 3784},       /* compatibility mapping */
+       {0xFC3D, 0, 2 | DECOMP_NO_COMPOSE, 3786},       /* compatibility mapping */
+       {0xFC3E, 0, 2 | DECOMP_NO_COMPOSE, 3788},       /* compatibility mapping */
+       {0xFC3F, 0, 2 | DECOMP_NO_COMPOSE, 3790},       /* compatibility mapping */
+       {0xFC40, 0, 2 | DECOMP_NO_COMPOSE, 3792},       /* compatibility mapping */
+       {0xFC41, 0, 2 | DECOMP_NO_COMPOSE, 3794},       /* compatibility mapping */
+       {0xFC42, 0, 2 | DECOMP_NO_COMPOSE, 3796},       /* compatibility mapping */
+       {0xFC43, 0, 2 | DECOMP_NO_COMPOSE, 3798},       /* compatibility mapping */
+       {0xFC44, 0, 2 | DECOMP_NO_COMPOSE, 3800},       /* compatibility mapping */
+       {0xFC45, 0, 2 | DECOMP_NO_COMPOSE, 3802},       /* compatibility mapping */
+       {0xFC46, 0, 2 | DECOMP_NO_COMPOSE, 3804},       /* compatibility mapping */
+       {0xFC47, 0, 2 | DECOMP_NO_COMPOSE, 3806},       /* compatibility mapping */
+       {0xFC48, 0, 2 | DECOMP_NO_COMPOSE, 3808},       /* compatibility mapping */
+       {0xFC49, 0, 2 | DECOMP_NO_COMPOSE, 3810},       /* compatibility mapping */
+       {0xFC4A, 0, 2 | DECOMP_NO_COMPOSE, 3812},       /* compatibility mapping */
+       {0xFC4B, 0, 2 | DECOMP_NO_COMPOSE, 3814},       /* compatibility mapping */
+       {0xFC4C, 0, 2 | DECOMP_NO_COMPOSE, 3816},       /* compatibility mapping */
+       {0xFC4D, 0, 2 | DECOMP_NO_COMPOSE, 3818},       /* compatibility mapping */
+       {0xFC4E, 0, 2 | DECOMP_NO_COMPOSE, 3820},       /* compatibility mapping */
+       {0xFC4F, 0, 2 | DECOMP_NO_COMPOSE, 3822},       /* compatibility mapping */
+       {0xFC50, 0, 2 | DECOMP_NO_COMPOSE, 3824},       /* compatibility mapping */
+       {0xFC51, 0, 2 | DECOMP_NO_COMPOSE, 3826},       /* compatibility mapping */
+       {0xFC52, 0, 2 | DECOMP_NO_COMPOSE, 3828},       /* compatibility mapping */
+       {0xFC53, 0, 2 | DECOMP_NO_COMPOSE, 3830},       /* compatibility mapping */
+       {0xFC54, 0, 2 | DECOMP_NO_COMPOSE, 3832},       /* compatibility mapping */
+       {0xFC55, 0, 2 | DECOMP_NO_COMPOSE, 3834},       /* compatibility mapping */
+       {0xFC56, 0, 2 | DECOMP_NO_COMPOSE, 3836},       /* compatibility mapping */
+       {0xFC57, 0, 2 | DECOMP_NO_COMPOSE, 3838},       /* compatibility mapping */
+       {0xFC58, 0, 2 | DECOMP_NO_COMPOSE, 3840},       /* compatibility mapping */
+       {0xFC59, 0, 2 | DECOMP_NO_COMPOSE, 3842},       /* compatibility mapping */
+       {0xFC5A, 0, 2 | DECOMP_NO_COMPOSE, 3844},       /* compatibility mapping */
+       {0xFC5B, 0, 2 | DECOMP_NO_COMPOSE, 3846},       /* compatibility mapping */
+       {0xFC5C, 0, 2 | DECOMP_NO_COMPOSE, 3848},       /* compatibility mapping */
+       {0xFC5D, 0, 2 | DECOMP_NO_COMPOSE, 3850},       /* compatibility mapping */
+       {0xFC5E, 0, 3, 3852},
+       {0xFC5F, 0, 3, 3855},
+       {0xFC60, 0, 3, 3858},
+       {0xFC61, 0, 3, 3861},
+       {0xFC62, 0, 3, 3864},
+       {0xFC63, 0, 3, 3867},
+       {0xFC64, 0, 2 | DECOMP_NO_COMPOSE, 3870},       /* compatibility mapping */
+       {0xFC65, 0, 2 | DECOMP_NO_COMPOSE, 3872},       /* compatibility mapping */
+       {0xFC66, 0, 2 | DECOMP_NO_COMPOSE, 3874},       /* compatibility mapping */
+       {0xFC67, 0, 2 | DECOMP_NO_COMPOSE, 3876},       /* compatibility mapping */
+       {0xFC68, 0, 2 | DECOMP_NO_COMPOSE, 3878},       /* compatibility mapping */
+       {0xFC69, 0, 2 | DECOMP_NO_COMPOSE, 3880},       /* compatibility mapping */
+       {0xFC6A, 0, 2 | DECOMP_NO_COMPOSE, 3882},       /* compatibility mapping */
+       {0xFC6B, 0, 2 | DECOMP_NO_COMPOSE, 3884},       /* compatibility mapping */
+       {0xFC6C, 0, 2 | DECOMP_NO_COMPOSE, 3886},       /* compatibility mapping */
+       {0xFC6D, 0, 2 | DECOMP_NO_COMPOSE, 3888},       /* compatibility mapping */
+       {0xFC6E, 0, 2 | DECOMP_NO_COMPOSE, 3890},       /* compatibility mapping */
+       {0xFC6F, 0, 2 | DECOMP_NO_COMPOSE, 3892},       /* compatibility mapping */
+       {0xFC70, 0, 2 | DECOMP_NO_COMPOSE, 3894},       /* compatibility mapping */
+       {0xFC71, 0, 2 | DECOMP_NO_COMPOSE, 3896},       /* compatibility mapping */
+       {0xFC72, 0, 2 | DECOMP_NO_COMPOSE, 3898},       /* compatibility mapping */
+       {0xFC73, 0, 2 | DECOMP_NO_COMPOSE, 3900},       /* compatibility mapping */
+       {0xFC74, 0, 2 | DECOMP_NO_COMPOSE, 3902},       /* compatibility mapping */
+       {0xFC75, 0, 2 | DECOMP_NO_COMPOSE, 3904},       /* compatibility mapping */
+       {0xFC76, 0, 2 | DECOMP_NO_COMPOSE, 3906},       /* compatibility mapping */
+       {0xFC77, 0, 2 | DECOMP_NO_COMPOSE, 3908},       /* compatibility mapping */
+       {0xFC78, 0, 2 | DECOMP_NO_COMPOSE, 3910},       /* compatibility mapping */
+       {0xFC79, 0, 2 | DECOMP_NO_COMPOSE, 3912},       /* compatibility mapping */
+       {0xFC7A, 0, 2 | DECOMP_NO_COMPOSE, 3914},       /* compatibility mapping */
+       {0xFC7B, 0, 2 | DECOMP_NO_COMPOSE, 3916},       /* compatibility mapping */
+       {0xFC7C, 0, 2 | DECOMP_NO_COMPOSE, 3918},       /* compatibility mapping */
+       {0xFC7D, 0, 2 | DECOMP_NO_COMPOSE, 3920},       /* compatibility mapping */
+       {0xFC7E, 0, 2 | DECOMP_NO_COMPOSE, 3922},       /* compatibility mapping */
+       {0xFC7F, 0, 2 | DECOMP_NO_COMPOSE, 3924},       /* compatibility mapping */
+       {0xFC80, 0, 2 | DECOMP_NO_COMPOSE, 3926},       /* compatibility mapping */
+       {0xFC81, 0, 2 | DECOMP_NO_COMPOSE, 3928},       /* compatibility mapping */
+       {0xFC82, 0, 2 | DECOMP_NO_COMPOSE, 3930},       /* compatibility mapping */
+       {0xFC83, 0, 2 | DECOMP_NO_COMPOSE, 3932},       /* compatibility mapping */
+       {0xFC84, 0, 2 | DECOMP_NO_COMPOSE, 3934},       /* compatibility mapping */
+       {0xFC85, 0, 2 | DECOMP_NO_COMPOSE, 3936},       /* compatibility mapping */
+       {0xFC86, 0, 2 | DECOMP_NO_COMPOSE, 3938},       /* compatibility mapping */
+       {0xFC87, 0, 2 | DECOMP_NO_COMPOSE, 3940},       /* compatibility mapping */
+       {0xFC88, 0, 2 | DECOMP_NO_COMPOSE, 3942},       /* compatibility mapping */
+       {0xFC89, 0, 2 | DECOMP_NO_COMPOSE, 3944},       /* compatibility mapping */
+       {0xFC8A, 0, 2 | DECOMP_NO_COMPOSE, 3946},       /* compatibility mapping */
+       {0xFC8B, 0, 2 | DECOMP_NO_COMPOSE, 3948},       /* compatibility mapping */
+       {0xFC8C, 0, 2 | DECOMP_NO_COMPOSE, 3950},       /* compatibility mapping */
+       {0xFC8D, 0, 2 | DECOMP_NO_COMPOSE, 3952},       /* compatibility mapping */
+       {0xFC8E, 0, 2 | DECOMP_NO_COMPOSE, 3954},       /* compatibility mapping */
+       {0xFC8F, 0, 2 | DECOMP_NO_COMPOSE, 3956},       /* compatibility mapping */
+       {0xFC90, 0, 2 | DECOMP_NO_COMPOSE, 3958},       /* compatibility mapping */
+       {0xFC91, 0, 2 | DECOMP_NO_COMPOSE, 3960},       /* compatibility mapping */
+       {0xFC92, 0, 2 | DECOMP_NO_COMPOSE, 3962},       /* compatibility mapping */
+       {0xFC93, 0, 2 | DECOMP_NO_COMPOSE, 3964},       /* compatibility mapping */
+       {0xFC94, 0, 2 | DECOMP_NO_COMPOSE, 3966},       /* compatibility mapping */
+       {0xFC95, 0, 2 | DECOMP_NO_COMPOSE, 3968},       /* compatibility mapping */
+       {0xFC96, 0, 2 | DECOMP_NO_COMPOSE, 3970},       /* compatibility mapping */
+       {0xFC97, 0, 2 | DECOMP_NO_COMPOSE, 3972},       /* compatibility mapping */
+       {0xFC98, 0, 2 | DECOMP_NO_COMPOSE, 3974},       /* compatibility mapping */
+       {0xFC99, 0, 2 | DECOMP_NO_COMPOSE, 3976},       /* compatibility mapping */
+       {0xFC9A, 0, 2 | DECOMP_NO_COMPOSE, 3978},       /* compatibility mapping */
+       {0xFC9B, 0, 2 | DECOMP_NO_COMPOSE, 3980},       /* compatibility mapping */
+       {0xFC9C, 0, 2 | DECOMP_NO_COMPOSE, 3982},       /* compatibility mapping */
+       {0xFC9D, 0, 2 | DECOMP_NO_COMPOSE, 3984},       /* compatibility mapping */
+       {0xFC9E, 0, 2 | DECOMP_NO_COMPOSE, 3986},       /* compatibility mapping */
+       {0xFC9F, 0, 2 | DECOMP_NO_COMPOSE, 3988},       /* compatibility mapping */
+       {0xFCA0, 0, 2 | DECOMP_NO_COMPOSE, 3990},       /* compatibility mapping */
+       {0xFCA1, 0, 2 | DECOMP_NO_COMPOSE, 3992},       /* compatibility mapping */
+       {0xFCA2, 0, 2 | DECOMP_NO_COMPOSE, 3994},       /* compatibility mapping */
+       {0xFCA3, 0, 2 | DECOMP_NO_COMPOSE, 3996},       /* compatibility mapping */
+       {0xFCA4, 0, 2 | DECOMP_NO_COMPOSE, 3998},       /* compatibility mapping */
+       {0xFCA5, 0, 2 | DECOMP_NO_COMPOSE, 4000},       /* compatibility mapping */
+       {0xFCA6, 0, 2 | DECOMP_NO_COMPOSE, 4002},       /* compatibility mapping */
+       {0xFCA7, 0, 2 | DECOMP_NO_COMPOSE, 4004},       /* compatibility mapping */
+       {0xFCA8, 0, 2 | DECOMP_NO_COMPOSE, 4006},       /* compatibility mapping */
+       {0xFCA9, 0, 2 | DECOMP_NO_COMPOSE, 4008},       /* compatibility mapping */
+       {0xFCAA, 0, 2 | DECOMP_NO_COMPOSE, 4010},       /* compatibility mapping */
+       {0xFCAB, 0, 2 | DECOMP_NO_COMPOSE, 4012},       /* compatibility mapping */
+       {0xFCAC, 0, 2 | DECOMP_NO_COMPOSE, 4014},       /* compatibility mapping */
+       {0xFCAD, 0, 2 | DECOMP_NO_COMPOSE, 4016},       /* compatibility mapping */
+       {0xFCAE, 0, 2 | DECOMP_NO_COMPOSE, 4018},       /* compatibility mapping */
+       {0xFCAF, 0, 2 | DECOMP_NO_COMPOSE, 4020},       /* compatibility mapping */
+       {0xFCB0, 0, 2 | DECOMP_NO_COMPOSE, 4022},       /* compatibility mapping */
+       {0xFCB1, 0, 2 | DECOMP_NO_COMPOSE, 4024},       /* compatibility mapping */
+       {0xFCB2, 0, 2 | DECOMP_NO_COMPOSE, 4026},       /* compatibility mapping */
+       {0xFCB3, 0, 2 | DECOMP_NO_COMPOSE, 4028},       /* compatibility mapping */
+       {0xFCB4, 0, 2 | DECOMP_NO_COMPOSE, 4030},       /* compatibility mapping */
+       {0xFCB5, 0, 2 | DECOMP_NO_COMPOSE, 4032},       /* compatibility mapping */
+       {0xFCB6, 0, 2 | DECOMP_NO_COMPOSE, 4034},       /* compatibility mapping */
+       {0xFCB7, 0, 2 | DECOMP_NO_COMPOSE, 4036},       /* compatibility mapping */
+       {0xFCB8, 0, 2 | DECOMP_NO_COMPOSE, 4038},       /* compatibility mapping */
+       {0xFCB9, 0, 2 | DECOMP_NO_COMPOSE, 4040},       /* compatibility mapping */
+       {0xFCBA, 0, 2 | DECOMP_NO_COMPOSE, 4042},       /* compatibility mapping */
+       {0xFCBB, 0, 2 | DECOMP_NO_COMPOSE, 4044},       /* compatibility mapping */
+       {0xFCBC, 0, 2 | DECOMP_NO_COMPOSE, 4046},       /* compatibility mapping */
+       {0xFCBD, 0, 2 | DECOMP_NO_COMPOSE, 4048},       /* compatibility mapping */
+       {0xFCBE, 0, 2 | DECOMP_NO_COMPOSE, 4050},       /* compatibility mapping */
+       {0xFCBF, 0, 2 | DECOMP_NO_COMPOSE, 4052},       /* compatibility mapping */
+       {0xFCC0, 0, 2 | DECOMP_NO_COMPOSE, 4054},       /* compatibility mapping */
+       {0xFCC1, 0, 2 | DECOMP_NO_COMPOSE, 4056},       /* compatibility mapping */
+       {0xFCC2, 0, 2 | DECOMP_NO_COMPOSE, 4058},       /* compatibility mapping */
+       {0xFCC3, 0, 2 | DECOMP_NO_COMPOSE, 4060},       /* compatibility mapping */
+       {0xFCC4, 0, 2 | DECOMP_NO_COMPOSE, 4062},       /* compatibility mapping */
+       {0xFCC5, 0, 2 | DECOMP_NO_COMPOSE, 4064},       /* compatibility mapping */
+       {0xFCC6, 0, 2 | DECOMP_NO_COMPOSE, 4066},       /* compatibility mapping */
+       {0xFCC7, 0, 2 | DECOMP_NO_COMPOSE, 4068},       /* compatibility mapping */
+       {0xFCC8, 0, 2 | DECOMP_NO_COMPOSE, 4070},       /* compatibility mapping */
+       {0xFCC9, 0, 2 | DECOMP_NO_COMPOSE, 4072},       /* compatibility mapping */
+       {0xFCCA, 0, 2 | DECOMP_NO_COMPOSE, 4074},       /* compatibility mapping */
+       {0xFCCB, 0, 2 | DECOMP_NO_COMPOSE, 4076},       /* compatibility mapping */
+       {0xFCCC, 0, 2 | DECOMP_NO_COMPOSE, 4078},       /* compatibility mapping */
+       {0xFCCD, 0, 2 | DECOMP_NO_COMPOSE, 4080},       /* compatibility mapping */
+       {0xFCCE, 0, 2 | DECOMP_NO_COMPOSE, 4082},       /* compatibility mapping */
+       {0xFCCF, 0, 2 | DECOMP_NO_COMPOSE, 4084},       /* compatibility mapping */
+       {0xFCD0, 0, 2 | DECOMP_NO_COMPOSE, 4086},       /* compatibility mapping */
+       {0xFCD1, 0, 2 | DECOMP_NO_COMPOSE, 4088},       /* compatibility mapping */
+       {0xFCD2, 0, 2 | DECOMP_NO_COMPOSE, 4090},       /* compatibility mapping */
+       {0xFCD3, 0, 2 | DECOMP_NO_COMPOSE, 4092},       /* compatibility mapping */
+       {0xFCD4, 0, 2 | DECOMP_NO_COMPOSE, 4094},       /* compatibility mapping */
+       {0xFCD5, 0, 2 | DECOMP_NO_COMPOSE, 4096},       /* compatibility mapping */
+       {0xFCD6, 0, 2 | DECOMP_NO_COMPOSE, 4098},       /* compatibility mapping */
+       {0xFCD7, 0, 2 | DECOMP_NO_COMPOSE, 4100},       /* compatibility mapping */
+       {0xFCD8, 0, 2 | DECOMP_NO_COMPOSE, 4102},       /* compatibility mapping */
+       {0xFCD9, 0, 2 | DECOMP_NO_COMPOSE, 4104},       /* compatibility mapping */
+       {0xFCDA, 0, 2 | DECOMP_NO_COMPOSE, 4106},       /* compatibility mapping */
+       {0xFCDB, 0, 2 | DECOMP_NO_COMPOSE, 4108},       /* compatibility mapping */
+       {0xFCDC, 0, 2 | DECOMP_NO_COMPOSE, 4110},       /* compatibility mapping */
+       {0xFCDD, 0, 2 | DECOMP_NO_COMPOSE, 4112},       /* compatibility mapping */
+       {0xFCDE, 0, 2 | DECOMP_NO_COMPOSE, 4114},       /* compatibility mapping */
+       {0xFCDF, 0, 2 | DECOMP_NO_COMPOSE, 4116},       /* compatibility mapping */
+       {0xFCE0, 0, 2 | DECOMP_NO_COMPOSE, 4118},       /* compatibility mapping */
+       {0xFCE1, 0, 2 | DECOMP_NO_COMPOSE, 4120},       /* compatibility mapping */
+       {0xFCE2, 0, 2 | DECOMP_NO_COMPOSE, 4122},       /* compatibility mapping */
+       {0xFCE3, 0, 2 | DECOMP_NO_COMPOSE, 4124},       /* compatibility mapping */
+       {0xFCE4, 0, 2 | DECOMP_NO_COMPOSE, 4126},       /* compatibility mapping */
+       {0xFCE5, 0, 2 | DECOMP_NO_COMPOSE, 4128},       /* compatibility mapping */
+       {0xFCE6, 0, 2 | DECOMP_NO_COMPOSE, 4130},       /* compatibility mapping */
+       {0xFCE7, 0, 2 | DECOMP_NO_COMPOSE, 4132},       /* compatibility mapping */
+       {0xFCE8, 0, 2 | DECOMP_NO_COMPOSE, 4134},       /* compatibility mapping */
+       {0xFCE9, 0, 2 | DECOMP_NO_COMPOSE, 4136},       /* compatibility mapping */
+       {0xFCEA, 0, 2 | DECOMP_NO_COMPOSE, 4138},       /* compatibility mapping */
+       {0xFCEB, 0, 2 | DECOMP_NO_COMPOSE, 4140},       /* compatibility mapping */
+       {0xFCEC, 0, 2 | DECOMP_NO_COMPOSE, 4142},       /* compatibility mapping */
+       {0xFCED, 0, 2 | DECOMP_NO_COMPOSE, 4144},       /* compatibility mapping */
+       {0xFCEE, 0, 2 | DECOMP_NO_COMPOSE, 4146},       /* compatibility mapping */
+       {0xFCEF, 0, 2 | DECOMP_NO_COMPOSE, 4148},       /* compatibility mapping */
+       {0xFCF0, 0, 2 | DECOMP_NO_COMPOSE, 4150},       /* compatibility mapping */
+       {0xFCF1, 0, 2 | DECOMP_NO_COMPOSE, 4152},       /* compatibility mapping */
+       {0xFCF2, 0, 3, 4154},
+       {0xFCF3, 0, 3, 4157},
+       {0xFCF4, 0, 3, 4160},
+       {0xFCF5, 0, 2 | DECOMP_NO_COMPOSE, 4163},       /* compatibility mapping */
+       {0xFCF6, 0, 2 | DECOMP_NO_COMPOSE, 4165},       /* compatibility mapping */
+       {0xFCF7, 0, 2 | DECOMP_NO_COMPOSE, 4167},       /* compatibility mapping */
+       {0xFCF8, 0, 2 | DECOMP_NO_COMPOSE, 4169},       /* compatibility mapping */
+       {0xFCF9, 0, 2 | DECOMP_NO_COMPOSE, 4171},       /* compatibility mapping */
+       {0xFCFA, 0, 2 | DECOMP_NO_COMPOSE, 4173},       /* compatibility mapping */
+       {0xFCFB, 0, 2 | DECOMP_NO_COMPOSE, 4175},       /* compatibility mapping */
+       {0xFCFC, 0, 2 | DECOMP_NO_COMPOSE, 4177},       /* compatibility mapping */
+       {0xFCFD, 0, 2 | DECOMP_NO_COMPOSE, 4179},       /* compatibility mapping */
+       {0xFCFE, 0, 2 | DECOMP_NO_COMPOSE, 4181},       /* compatibility mapping */
+       {0xFCFF, 0, 2 | DECOMP_NO_COMPOSE, 4183},       /* compatibility mapping */
+       {0xFD00, 0, 2 | DECOMP_NO_COMPOSE, 4185},       /* compatibility mapping */
+       {0xFD01, 0, 2 | DECOMP_NO_COMPOSE, 4187},       /* compatibility mapping */
+       {0xFD02, 0, 2 | DECOMP_NO_COMPOSE, 4189},       /* compatibility mapping */
+       {0xFD03, 0, 2 | DECOMP_NO_COMPOSE, 4191},       /* compatibility mapping */
+       {0xFD04, 0, 2 | DECOMP_NO_COMPOSE, 4193},       /* compatibility mapping */
+       {0xFD05, 0, 2 | DECOMP_NO_COMPOSE, 4195},       /* compatibility mapping */
+       {0xFD06, 0, 2 | DECOMP_NO_COMPOSE, 4197},       /* compatibility mapping */
+       {0xFD07, 0, 2 | DECOMP_NO_COMPOSE, 4199},       /* compatibility mapping */
+       {0xFD08, 0, 2 | DECOMP_NO_COMPOSE, 4201},       /* compatibility mapping */
+       {0xFD09, 0, 2 | DECOMP_NO_COMPOSE, 4203},       /* compatibility mapping */
+       {0xFD0A, 0, 2 | DECOMP_NO_COMPOSE, 4205},       /* compatibility mapping */
+       {0xFD0B, 0, 2 | DECOMP_NO_COMPOSE, 4207},       /* compatibility mapping */
+       {0xFD0C, 0, 2 | DECOMP_NO_COMPOSE, 4209},       /* compatibility mapping */
+       {0xFD0D, 0, 2 | DECOMP_NO_COMPOSE, 4211},       /* compatibility mapping */
+       {0xFD0E, 0, 2 | DECOMP_NO_COMPOSE, 4213},       /* compatibility mapping */
+       {0xFD0F, 0, 2 | DECOMP_NO_COMPOSE, 4215},       /* compatibility mapping */
+       {0xFD10, 0, 2 | DECOMP_NO_COMPOSE, 4217},       /* compatibility mapping */
+       {0xFD11, 0, 2 | DECOMP_NO_COMPOSE, 4219},       /* compatibility mapping */
+       {0xFD12, 0, 2 | DECOMP_NO_COMPOSE, 4221},       /* compatibility mapping */
+       {0xFD13, 0, 2 | DECOMP_NO_COMPOSE, 4223},       /* compatibility mapping */
+       {0xFD14, 0, 2 | DECOMP_NO_COMPOSE, 4225},       /* compatibility mapping */
+       {0xFD15, 0, 2 | DECOMP_NO_COMPOSE, 4227},       /* compatibility mapping */
+       {0xFD16, 0, 2 | DECOMP_NO_COMPOSE, 4229},       /* compatibility mapping */
+       {0xFD17, 0, 2 | DECOMP_NO_COMPOSE, 4231},       /* compatibility mapping */
+       {0xFD18, 0, 2 | DECOMP_NO_COMPOSE, 4233},       /* compatibility mapping */
+       {0xFD19, 0, 2 | DECOMP_NO_COMPOSE, 4235},       /* compatibility mapping */
+       {0xFD1A, 0, 2 | DECOMP_NO_COMPOSE, 4237},       /* compatibility mapping */
+       {0xFD1B, 0, 2 | DECOMP_NO_COMPOSE, 4239},       /* compatibility mapping */
+       {0xFD1C, 0, 2 | DECOMP_NO_COMPOSE, 4241},       /* compatibility mapping */
+       {0xFD1D, 0, 2 | DECOMP_NO_COMPOSE, 4243},       /* compatibility mapping */
+       {0xFD1E, 0, 2 | DECOMP_NO_COMPOSE, 4245},       /* compatibility mapping */
+       {0xFD1F, 0, 2 | DECOMP_NO_COMPOSE, 4247},       /* compatibility mapping */
+       {0xFD20, 0, 2 | DECOMP_NO_COMPOSE, 4249},       /* compatibility mapping */
+       {0xFD21, 0, 2 | DECOMP_NO_COMPOSE, 4251},       /* compatibility mapping */
+       {0xFD22, 0, 2 | DECOMP_NO_COMPOSE, 4253},       /* compatibility mapping */
+       {0xFD23, 0, 2 | DECOMP_NO_COMPOSE, 4255},       /* compatibility mapping */
+       {0xFD24, 0, 2 | DECOMP_NO_COMPOSE, 4257},       /* compatibility mapping */
+       {0xFD25, 0, 2 | DECOMP_NO_COMPOSE, 4259},       /* compatibility mapping */
+       {0xFD26, 0, 2 | DECOMP_NO_COMPOSE, 4261},       /* compatibility mapping */
+       {0xFD27, 0, 2 | DECOMP_NO_COMPOSE, 4263},       /* compatibility mapping */
+       {0xFD28, 0, 2 | DECOMP_NO_COMPOSE, 4265},       /* compatibility mapping */
+       {0xFD29, 0, 2 | DECOMP_NO_COMPOSE, 4267},       /* compatibility mapping */
+       {0xFD2A, 0, 2 | DECOMP_NO_COMPOSE, 4269},       /* compatibility mapping */
+       {0xFD2B, 0, 2 | DECOMP_NO_COMPOSE, 4271},       /* compatibility mapping */
+       {0xFD2C, 0, 2 | DECOMP_NO_COMPOSE, 4273},       /* compatibility mapping */
+       {0xFD2D, 0, 2 | DECOMP_NO_COMPOSE, 4275},       /* compatibility mapping */
+       {0xFD2E, 0, 2 | DECOMP_NO_COMPOSE, 4277},       /* compatibility mapping */
+       {0xFD2F, 0, 2 | DECOMP_NO_COMPOSE, 4279},       /* compatibility mapping */
+       {0xFD30, 0, 2 | DECOMP_NO_COMPOSE, 4281},       /* compatibility mapping */
+       {0xFD31, 0, 2 | DECOMP_NO_COMPOSE, 4283},       /* compatibility mapping */
+       {0xFD32, 0, 2 | DECOMP_NO_COMPOSE, 4285},       /* compatibility mapping */
+       {0xFD33, 0, 2 | DECOMP_NO_COMPOSE, 4287},       /* compatibility mapping */
+       {0xFD34, 0, 2 | DECOMP_NO_COMPOSE, 4289},       /* compatibility mapping */
+       {0xFD35, 0, 2 | DECOMP_NO_COMPOSE, 4291},       /* compatibility mapping */
+       {0xFD36, 0, 2 | DECOMP_NO_COMPOSE, 4293},       /* compatibility mapping */
+       {0xFD37, 0, 2 | DECOMP_NO_COMPOSE, 4295},       /* compatibility mapping */
+       {0xFD38, 0, 2 | DECOMP_NO_COMPOSE, 4297},       /* compatibility mapping */
+       {0xFD39, 0, 2 | DECOMP_NO_COMPOSE, 4299},       /* compatibility mapping */
+       {0xFD3A, 0, 2 | DECOMP_NO_COMPOSE, 4301},       /* compatibility mapping */
+       {0xFD3B, 0, 2 | DECOMP_NO_COMPOSE, 4303},       /* compatibility mapping */
+       {0xFD3C, 0, 2 | DECOMP_NO_COMPOSE, 4305},       /* compatibility mapping */
+       {0xFD3D, 0, 2 | DECOMP_NO_COMPOSE, 4307},       /* compatibility mapping */
+       {0xFD50, 0, 3, 4309},
+       {0xFD51, 0, 3, 4312},
+       {0xFD52, 0, 3, 4315},
+       {0xFD53, 0, 3, 4318},
+       {0xFD54, 0, 3, 4321},
+       {0xFD55, 0, 3, 4324},
+       {0xFD56, 0, 3, 4327},
+       {0xFD57, 0, 3, 4330},
+       {0xFD58, 0, 3, 4333},
+       {0xFD59, 0, 3, 4336},
+       {0xFD5A, 0, 3, 4339},
+       {0xFD5B, 0, 3, 4342},
+       {0xFD5C, 0, 3, 4345},
+       {0xFD5D, 0, 3, 4348},
+       {0xFD5E, 0, 3, 4351},
+       {0xFD5F, 0, 3, 4354},
+       {0xFD60, 0, 3, 4357},
+       {0xFD61, 0, 3, 4360},
+       {0xFD62, 0, 3, 4363},
+       {0xFD63, 0, 3, 4366},
+       {0xFD64, 0, 3, 4369},
+       {0xFD65, 0, 3, 4372},
+       {0xFD66, 0, 3, 4375},
+       {0xFD67, 0, 3, 4378},
+       {0xFD68, 0, 3, 4381},
+       {0xFD69, 0, 3, 4384},
+       {0xFD6A, 0, 3, 4387},
+       {0xFD6B, 0, 3, 4390},
+       {0xFD6C, 0, 3, 4393},
+       {0xFD6D, 0, 3, 4396},
+       {0xFD6E, 0, 3, 4399},
+       {0xFD6F, 0, 3, 4402},
+       {0xFD70, 0, 3, 4405},
+       {0xFD71, 0, 3, 4408},
+       {0xFD72, 0, 3, 4411},
+       {0xFD73, 0, 3, 4414},
+       {0xFD74, 0, 3, 4417},
+       {0xFD75, 0, 3, 4420},
+       {0xFD76, 0, 3, 4423},
+       {0xFD77, 0, 3, 4426},
+       {0xFD78, 0, 3, 4429},
+       {0xFD79, 0, 3, 4432},
+       {0xFD7A, 0, 3, 4435},
+       {0xFD7B, 0, 3, 4438},
+       {0xFD7C, 0, 3, 4441},
+       {0xFD7D, 0, 3, 4444},
+       {0xFD7E, 0, 3, 4447},
+       {0xFD7F, 0, 3, 4450},
+       {0xFD80, 0, 3, 4453},
+       {0xFD81, 0, 3, 4456},
+       {0xFD82, 0, 3, 4459},
+       {0xFD83, 0, 3, 4462},
+       {0xFD84, 0, 3, 4465},
+       {0xFD85, 0, 3, 4468},
+       {0xFD86, 0, 3, 4471},
+       {0xFD87, 0, 3, 4474},
+       {0xFD88, 0, 3, 4477},
+       {0xFD89, 0, 3, 4480},
+       {0xFD8A, 0, 3, 4483},
+       {0xFD8B, 0, 3, 4486},
+       {0xFD8C, 0, 3, 4489},
+       {0xFD8D, 0, 3, 4492},
+       {0xFD8E, 0, 3, 4495},
+       {0xFD8F, 0, 3, 4498},
+       {0xFD92, 0, 3, 4501},
+       {0xFD93, 0, 3, 4504},
+       {0xFD94, 0, 3, 4507},
+       {0xFD95, 0, 3, 4510},
+       {0xFD96, 0, 3, 4513},
+       {0xFD97, 0, 3, 4516},
+       {0xFD98, 0, 3, 4519},
+       {0xFD99, 0, 3, 4522},
+       {0xFD9A, 0, 3, 4525},
+       {0xFD9B, 0, 3, 4528},
+       {0xFD9C, 0, 3, 4531},
+       {0xFD9D, 0, 3, 4534},
+       {0xFD9E, 0, 3, 4537},
+       {0xFD9F, 0, 3, 4540},
+       {0xFDA0, 0, 3, 4543},
+       {0xFDA1, 0, 3, 4546},
+       {0xFDA2, 0, 3, 4549},
+       {0xFDA3, 0, 3, 4552},
+       {0xFDA4, 0, 3, 4555},
+       {0xFDA5, 0, 3, 4558},
+       {0xFDA6, 0, 3, 4561},
+       {0xFDA7, 0, 3, 4564},
+       {0xFDA8, 0, 3, 4567},
+       {0xFDA9, 0, 3, 4570},
+       {0xFDAA, 0, 3, 4573},
+       {0xFDAB, 0, 3, 4576},
+       {0xFDAC, 0, 3, 4579},
+       {0xFDAD, 0, 3, 4582},
+       {0xFDAE, 0, 3, 4585},
+       {0xFDAF, 0, 3, 4588},
+       {0xFDB0, 0, 3, 4591},
+       {0xFDB1, 0, 3, 4594},
+       {0xFDB2, 0, 3, 4597},
+       {0xFDB3, 0, 3, 4600},
+       {0xFDB4, 0, 3, 4603},
+       {0xFDB5, 0, 3, 4606},
+       {0xFDB6, 0, 3, 4609},
+       {0xFDB7, 0, 3, 4612},
+       {0xFDB8, 0, 3, 4615},
+       {0xFDB9, 0, 3, 4618},
+       {0xFDBA, 0, 3, 4621},
+       {0xFDBB, 0, 3, 4624},
+       {0xFDBC, 0, 3, 4627},
+       {0xFDBD, 0, 3, 4630},
+       {0xFDBE, 0, 3, 4633},
+       {0xFDBF, 0, 3, 4636},
+       {0xFDC0, 0, 3, 4639},
+       {0xFDC1, 0, 3, 4642},
+       {0xFDC2, 0, 3, 4645},
+       {0xFDC3, 0, 3, 4648},
+       {0xFDC4, 0, 3, 4651},
+       {0xFDC5, 0, 3, 4654},
+       {0xFDC6, 0, 3, 4657},
+       {0xFDC7, 0, 3, 4660},
+       {0xFDF0, 0, 3, 4663},
+       {0xFDF1, 0, 3, 4666},
+       {0xFDF2, 0, 4, 4669},
+       {0xFDF3, 0, 4, 4673},
+       {0xFDF4, 0, 4, 4677},
+       {0xFDF5, 0, 4, 4681},
+       {0xFDF6, 0, 4, 4685},
+       {0xFDF7, 0, 4, 4689},
+       {0xFDF8, 0, 4, 4693},
+       {0xFDF9, 0, 3, 4697},
+       {0xFDFA, 0, 18, 4700},
+       {0xFDFB, 0, 8, 4718},
+       {0xFDFC, 0, 4, 4726},
+       {0xFE10, 0, 1 | DECOMP_INLINE, 0x002C},
+       {0xFE11, 0, 1 | DECOMP_INLINE, 0x3001},
+       {0xFE12, 0, 1 | DECOMP_INLINE, 0x3002},
+       {0xFE13, 0, 1 | DECOMP_INLINE, 0x003A},
+       {0xFE14, 0, 1 | DECOMP_INLINE, 0x003B},
+       {0xFE15, 0, 1 | DECOMP_INLINE, 0x0021},
+       {0xFE16, 0, 1 | DECOMP_INLINE, 0x003F},
+       {0xFE17, 0, 1 | DECOMP_INLINE, 0x3016},
+       {0xFE18, 0, 1 | DECOMP_INLINE, 0x3017},
+       {0xFE19, 0, 1 | DECOMP_INLINE, 0x2026},
+       {0xFE20, 230, 0, 0},
+       {0xFE21, 230, 0, 0},
+       {0xFE22, 230, 0, 0},
+       {0xFE23, 230, 0, 0},
+       {0xFE24, 230, 0, 0},
+       {0xFE25, 230, 0, 0},
+       {0xFE26, 230, 0, 0},
+       {0xFE27, 220, 0, 0},
+       {0xFE28, 220, 0, 0},
+       {0xFE29, 220, 0, 0},
+       {0xFE2A, 220, 0, 0},
+       {0xFE2B, 220, 0, 0},
+       {0xFE2C, 220, 0, 0},
+       {0xFE2D, 220, 0, 0},
+       {0xFE2E, 230, 0, 0},
+       {0xFE2F, 230, 0, 0},
+       {0xFE30, 0, 1 | DECOMP_INLINE, 0x2025},
+       {0xFE31, 0, 1 | DECOMP_INLINE, 0x2014},
+       {0xFE32, 0, 1 | DECOMP_INLINE, 0x2013},
+       {0xFE33, 0, 1 | DECOMP_INLINE, 0x005F},
+       {0xFE34, 0, 1 | DECOMP_INLINE, 0x005F},
+       {0xFE35, 0, 1 | DECOMP_INLINE, 0x0028},
+       {0xFE36, 0, 1 | DECOMP_INLINE, 0x0029},
+       {0xFE37, 0, 1 | DECOMP_INLINE, 0x007B},
+       {0xFE38, 0, 1 | DECOMP_INLINE, 0x007D},
+       {0xFE39, 0, 1 | DECOMP_INLINE, 0x3014},
+       {0xFE3A, 0, 1 | DECOMP_INLINE, 0x3015},
+       {0xFE3B, 0, 1 | DECOMP_INLINE, 0x3010},
+       {0xFE3C, 0, 1 | DECOMP_INLINE, 0x3011},
+       {0xFE3D, 0, 1 | DECOMP_INLINE, 0x300A},
+       {0xFE3E, 0, 1 | DECOMP_INLINE, 0x300B},
+       {0xFE3F, 0, 1 | DECOMP_INLINE, 0x3008},
+       {0xFE40, 0, 1 | DECOMP_INLINE, 0x3009},
+       {0xFE41, 0, 1 | DECOMP_INLINE, 0x300C},
+       {0xFE42, 0, 1 | DECOMP_INLINE, 0x300D},
+       {0xFE43, 0, 1 | DECOMP_INLINE, 0x300E},
+       {0xFE44, 0, 1 | DECOMP_INLINE, 0x300F},
+       {0xFE47, 0, 1 | DECOMP_INLINE, 0x005B},
+       {0xFE48, 0, 1 | DECOMP_INLINE, 0x005D},
+       {0xFE49, 0, 1 | DECOMP_INLINE, 0x203E},
+       {0xFE4A, 0, 1 | DECOMP_INLINE, 0x203E},
+       {0xFE4B, 0, 1 | DECOMP_INLINE, 0x203E},
+       {0xFE4C, 0, 1 | DECOMP_INLINE, 0x203E},
+       {0xFE4D, 0, 1 | DECOMP_INLINE, 0x005F},
+       {0xFE4E, 0, 1 | DECOMP_INLINE, 0x005F},
+       {0xFE4F, 0, 1 | DECOMP_INLINE, 0x005F},
+       {0xFE50, 0, 1 | DECOMP_INLINE, 0x002C},
+       {0xFE51, 0, 1 | DECOMP_INLINE, 0x3001},
+       {0xFE52, 0, 1 | DECOMP_INLINE, 0x002E},
+       {0xFE54, 0, 1 | DECOMP_INLINE, 0x003B},
+       {0xFE55, 0, 1 | DECOMP_INLINE, 0x003A},
+       {0xFE56, 0, 1 | DECOMP_INLINE, 0x003F},
+       {0xFE57, 0, 1 | DECOMP_INLINE, 0x0021},
+       {0xFE58, 0, 1 | DECOMP_INLINE, 0x2014},
+       {0xFE59, 0, 1 | DECOMP_INLINE, 0x0028},
+       {0xFE5A, 0, 1 | DECOMP_INLINE, 0x0029},
+       {0xFE5B, 0, 1 | DECOMP_INLINE, 0x007B},
+       {0xFE5C, 0, 1 | DECOMP_INLINE, 0x007D},
+       {0xFE5D, 0, 1 | DECOMP_INLINE, 0x3014},
+       {0xFE5E, 0, 1 | DECOMP_INLINE, 0x3015},
+       {0xFE5F, 0, 1 | DECOMP_INLINE, 0x0023},
+       {0xFE60, 0, 1 | DECOMP_INLINE, 0x0026},
+       {0xFE61, 0, 1 | DECOMP_INLINE, 0x002A},
+       {0xFE62, 0, 1 | DECOMP_INLINE, 0x002B},
+       {0xFE63, 0, 1 | DECOMP_INLINE, 0x002D},
+       {0xFE64, 0, 1 | DECOMP_INLINE, 0x003C},
+       {0xFE65, 0, 1 | DECOMP_INLINE, 0x003E},
+       {0xFE66, 0, 1 | DECOMP_INLINE, 0x003D},
+       {0xFE68, 0, 1 | DECOMP_INLINE, 0x005C},
+       {0xFE69, 0, 1 | DECOMP_INLINE, 0x0024},
+       {0xFE6A, 0, 1 | DECOMP_INLINE, 0x0025},
+       {0xFE6B, 0, 1 | DECOMP_INLINE, 0x0040},
+       {0xFE70, 0, 2 | DECOMP_NO_COMPOSE, 4730},       /* compatibility mapping */
+       {0xFE71, 0, 2 | DECOMP_NO_COMPOSE, 4732},       /* compatibility mapping */
+       {0xFE72, 0, 2 | DECOMP_NO_COMPOSE, 4734},       /* compatibility mapping */
+       {0xFE74, 0, 2 | DECOMP_NO_COMPOSE, 4736},       /* compatibility mapping */
+       {0xFE76, 0, 2 | DECOMP_NO_COMPOSE, 4738},       /* compatibility mapping */
+       {0xFE77, 0, 2 | DECOMP_NO_COMPOSE, 4740},       /* compatibility mapping */
+       {0xFE78, 0, 2 | DECOMP_NO_COMPOSE, 4742},       /* compatibility mapping */
+       {0xFE79, 0, 2 | DECOMP_NO_COMPOSE, 4744},       /* compatibility mapping */
+       {0xFE7A, 0, 2 | DECOMP_NO_COMPOSE, 4746},       /* compatibility mapping */
+       {0xFE7B, 0, 2 | DECOMP_NO_COMPOSE, 4748},       /* compatibility mapping */
+       {0xFE7C, 0, 2 | DECOMP_NO_COMPOSE, 4750},       /* compatibility mapping */
+       {0xFE7D, 0, 2 | DECOMP_NO_COMPOSE, 4752},       /* compatibility mapping */
+       {0xFE7E, 0, 2 | DECOMP_NO_COMPOSE, 4754},       /* compatibility mapping */
+       {0xFE7F, 0, 2 | DECOMP_NO_COMPOSE, 4756},       /* compatibility mapping */
+       {0xFE80, 0, 1 | DECOMP_INLINE, 0x0621},
+       {0xFE81, 0, 1 | DECOMP_INLINE, 0x0622},
+       {0xFE82, 0, 1 | DECOMP_INLINE, 0x0622},
+       {0xFE83, 0, 1 | DECOMP_INLINE, 0x0623},
+       {0xFE84, 0, 1 | DECOMP_INLINE, 0x0623},
+       {0xFE85, 0, 1 | DECOMP_INLINE, 0x0624},
+       {0xFE86, 0, 1 | DECOMP_INLINE, 0x0624},
+       {0xFE87, 0, 1 | DECOMP_INLINE, 0x0625},
+       {0xFE88,&nb