--- /dev/null
+/* gchecksum.h - data hashing functions
+ *
+ * Copyright (C) 2007 Emmanuele Bassi <ebassi@gnome.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include "config.h"
+
+#include <string.h>
+
+#include "glibconfig.h"
+#include "gchecksum.h"
+#include "glib.h"
+
+
+#define IS_VALID_TYPE(type) ((type) >= G_CHECKSUM_MD5 && (type) <= G_CHECKSUM_SHA256)
+
+/* The fact that these are lower case characters is part of the ABI */
+static const gchar hex_digits[] = "0123456789abcdef";
+
+#define MD5_DATASIZE 64
+#define MD5_DIGEST_LEN 16
+
+typedef struct
+{
+ guint32 buf[4];
+ guint32 bits[2];
+
+ guchar data[MD5_DATASIZE];
+
+ guchar digest[MD5_DIGEST_LEN];
+} Md5sum;
+
+#define SHA1_DATASIZE 64
+#define SHA1_DIGEST_LEN 20
+
+typedef struct
+{
+ guint32 buf[5];
+ guint32 bits[2];
+
+ /* we pack 64 unsigned chars into 16 32-bit unsigned integers */
+ guint32 data[16];
+
+ guchar digest[SHA1_DIGEST_LEN];
+} Sha1sum;
+
+#define SHA256_DATASIZE 64
+#define SHA256_DIGEST_LEN 32
+
+typedef struct
+{
+ guint32 buf[8];
+ guint32 bits[2];
+
+ guint8 data[SHA256_DATASIZE];
+
+ guchar digest[SHA256_DIGEST_LEN];
+} Sha256sum;
+
+struct _GChecksum
+{
+ GChecksumType type;
+
+ gchar *digest_str;
+
+ union {
+ Md5sum md5;
+ Sha1sum sha1;
+ Sha256sum sha256;
+ } sum;
+};
+
+/* we need different byte swapping functions because MD5 expects buffers
+ * to be little-endian, while SHA1 and SHA256 expect them in big-endian
+ * form.
+ */
+
+#if G_BYTE_ORDER == G_LITTLE_ENDIAN
+#define md5_byte_reverse(buffer,length)
+#else
+/* assume that the passed buffer is integer aligned */
+static inline void
+md5_byte_reverse (guchar *buffer,
+ gulong length)
+{
+ guint32 bit;
+
+ do
+ {
+ bit = (guint32) ((unsigned) buffer[3] << 8 | buffer[2]) << 16 |
+ ((unsigned) buffer[1] << 8 | buffer[0]);
+ * (guint32 *) buffer = bit;
+ buffer += 4;
+ }
+ while (--length);
+}
+#endif /* G_BYTE_ORDER == G_LITTLE_ENDIAN */
+
+#if G_BYTE_ORDER == G_BIG_ENDIAN
+#define sha_byte_reverse(buffer,length)
+#else
+static inline void
+sha_byte_reverse (guint32 *buffer,
+ gint length)
+{
+ length /= sizeof (guint32);
+ while (length--)
+ {
+ *buffer = GUINT32_SWAP_LE_BE (*buffer);
+ ++buffer;
+ }
+}
+#endif /* G_BYTE_ORDER == G_BIG_ENDIAN */
+
+static gchar *
+digest_to_string (guint8 *digest,
+ gsize digest_len)
+{
+ gint len = digest_len * 2;
+ gint i;
+ gchar *retval;
+
+ retval = g_new (gchar, len + 1);
+
+ for (i = 0; i < digest_len; i++)
+ {
+ guint8 byte = digest[i];
+
+ retval[2 * i] = hex_digits[byte >> 4];
+ retval[2 * i + 1] = hex_digits[byte & 0xf];
+ }
+
+ retval[len] = 0;
+
+ return retval;
+}
+
+/*
+ * MD5 Checksum
+ */
+
+/* This MD5 digest computation is based on the equivalent code
+ * written by Colin Plumb. It came with this notice:
+ *
+ * This code implements the MD5 message-digest algorithm.
+ * The algorithm is due to Ron Rivest. This code was
+ * written by Colin Plumb in 1993, no copyright is claimed.
+ * This code is in the public domain; do with it what you wish.
+ *
+ * Equivalent code is available from RSA Data Security, Inc.
+ * This code has been tested against that, and is equivalent,
+ * except that you don't need to include two pages of legalese
+ * with every copy.
+ */
+
+static void
+md5_sum_init (Md5sum *md5)
+{
+ /* arbitrary constants */
+ md5->buf[0] = 0x67452301;
+ md5->buf[1] = 0xefcdab89;
+ md5->buf[2] = 0x98badcfe;
+ md5->buf[3] = 0x10325476;
+
+ md5->bits[0] = md5->bits[1] = 0;
+}
+
+/*
+ * The core of the MD5 algorithm, this alters an existing MD5 hash to
+ * reflect the addition of 16 longwords of new data. md5_sum_update()
+ * blocks the data and converts bytes into longwords for this routine.
+ */
+static void
+md5_transform (guint32 buf[4],
+ guint32 const in[16])
+{
+ register guint32 a, b, c, d;
+
+/* The four core functions - F1 is optimized somewhat */
+#define F1(x, y, z) (z ^ (x & (y ^ z)))
+#define F2(x, y, z) F1 (z, x, y)
+#define F3(x, y, z) (x ^ y ^ z)
+#define F4(x, y, z) (y ^ (x | ~z))
+
+/* This is the central step in the MD5 algorithm. */
+#define md5_step(f, w, x, y, z, data, s) \
+ ( w += f (x, y, z) + data, w = w << s | w >> (32 - s), w += x )
+
+ a = buf[0];
+ b = buf[1];
+ c = buf[2];
+ d = buf[3];
+
+ md5_step (F1, a, b, c, d, in[0] + 0xd76aa478, 7);
+ md5_step (F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
+ md5_step (F1, c, d, a, b, in[2] + 0x242070db, 17);
+ md5_step (F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
+ md5_step (F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
+ md5_step (F1, d, a, b, c, in[5] + 0x4787c62a, 12);
+ md5_step (F1, c, d, a, b, in[6] + 0xa8304613, 17);
+ md5_step (F1, b, c, d, a, in[7] + 0xfd469501, 22);
+ md5_step (F1, a, b, c, d, in[8] + 0x698098d8, 7);
+ md5_step (F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
+ md5_step (F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
+ md5_step (F1, b, c, d, a, in[11] + 0x895cd7be, 22);
+ md5_step (F1, a, b, c, d, in[12] + 0x6b901122, 7);
+ md5_step (F1, d, a, b, c, in[13] + 0xfd987193, 12);
+ md5_step (F1, c, d, a, b, in[14] + 0xa679438e, 17);
+ md5_step (F1, b, c, d, a, in[15] + 0x49b40821, 22);
+
+ md5_step (F2, a, b, c, d, in[1] + 0xf61e2562, 5);
+ md5_step (F2, d, a, b, c, in[6] + 0xc040b340, 9);
+ md5_step (F2, c, d, a, b, in[11] + 0x265e5a51, 14);
+ md5_step (F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
+ md5_step (F2, a, b, c, d, in[5] + 0xd62f105d, 5);
+ md5_step (F2, d, a, b, c, in[10] + 0x02441453, 9);
+ md5_step (F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
+ md5_step (F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
+ md5_step (F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
+ md5_step (F2, d, a, b, c, in[14] + 0xc33707d6, 9);
+ md5_step (F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
+ md5_step (F2, b, c, d, a, in[8] + 0x455a14ed, 20);
+ md5_step (F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
+ md5_step (F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
+ md5_step (F2, c, d, a, b, in[7] + 0x676f02d9, 14);
+ md5_step (F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
+
+ md5_step (F3, a, b, c, d, in[5] + 0xfffa3942, 4);
+ md5_step (F3, d, a, b, c, in[8] + 0x8771f681, 11);
+ md5_step (F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
+ md5_step (F3, b, c, d, a, in[14] + 0xfde5380c, 23);
+ md5_step (F3, a, b, c, d, in[1] + 0xa4beea44, 4);
+ md5_step (F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
+ md5_step (F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
+ md5_step (F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
+ md5_step (F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
+ md5_step (F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
+ md5_step (F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
+ md5_step (F3, b, c, d, a, in[6] + 0x04881d05, 23);
+ md5_step (F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
+ md5_step (F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
+ md5_step (F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
+ md5_step (F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
+
+ md5_step (F4, a, b, c, d, in[0] + 0xf4292244, 6);
+ md5_step (F4, d, a, b, c, in[7] + 0x432aff97, 10);
+ md5_step (F4, c, d, a, b, in[14] + 0xab9423a7, 15);
+ md5_step (F4, b, c, d, a, in[5] + 0xfc93a039, 21);
+ md5_step (F4, a, b, c, d, in[12] + 0x655b59c3, 6);
+ md5_step (F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
+ md5_step (F4, c, d, a, b, in[10] + 0xffeff47d, 15);
+ md5_step (F4, b, c, d, a, in[1] + 0x85845dd1, 21);
+ md5_step (F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
+ md5_step (F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
+ md5_step (F4, c, d, a, b, in[6] + 0xa3014314, 15);
+ md5_step (F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
+ md5_step (F4, a, b, c, d, in[4] + 0xf7537e82, 6);
+ md5_step (F4, d, a, b, c, in[11] + 0xbd3af235, 10);
+ md5_step (F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
+ md5_step (F4, b, c, d, a, in[9] + 0xeb86d391, 21);
+
+ buf[0] += a;
+ buf[1] += b;
+ buf[2] += c;
+ buf[3] += d;
+
+#undef F1
+#undef F2
+#undef F3
+#undef F4
+#undef md5_step
+}
+
+static void
+md5_sum_update (Md5sum *md5,
+ const guchar *data,
+ gsize length)
+{
+ guint32 bit;
+
+ bit = md5->bits[0];
+ md5->bits[0] = bit + ((guint32) length << 3);
+
+ /* carry from low to high */
+ if (md5->bits[0] < bit)
+ md5->bits[1] += 1;
+
+ md5->bits[1] += length >> 29;
+
+ /* bytes already in Md5sum->data */
+ bit = (bit >> 3) & 0x3f;
+
+ /* handle any leading odd-sized chunks */
+ if (bit)
+ {
+ guchar *p = (guchar *) md5->data + bit;
+
+ bit = MD5_DATASIZE - bit;
+ if (length < bit)
+ {
+ memcpy (p, data, length);
+ return;
+ }
+
+ memcpy (p, data, bit);
+
+ md5_byte_reverse (md5->data, 16);
+ md5_transform (md5->buf, (guint32 *) md5->data);
+
+ data += bit;
+ length -= bit;
+ }
+
+ /* process data in 64-byte chunks */
+ while (length >= MD5_DATASIZE)
+ {
+ memcpy (md5->data, data, MD5_DATASIZE);
+
+ md5_byte_reverse (md5->data, 16);
+ md5_transform (md5->buf, (guint32 *) md5->data);
+
+ data += MD5_DATASIZE;
+ length -= MD5_DATASIZE;
+ }
+
+ /* handle any remaining bytes of data */
+ memcpy (md5->data, data, length);
+}
+
+/* closes a checksum */
+static void
+md5_sum_close (Md5sum *md5)
+{
+ guint count;
+ guchar *p;
+
+ /* Compute number of bytes mod 64 */
+ count = (md5->bits[0] >> 3) & 0x3F;
+
+ /* Set the first char of padding to 0x80.
+ * This is safe since there is always at least one byte free
+ */
+ p = md5->data + count;
+ *p++ = 0x80;
+
+ /* Bytes of padding needed to make 64 bytes */
+ count = MD5_DATASIZE - 1 - count;
+
+ /* Pad out to 56 mod 64 */
+ if (count < 8)
+ {
+ /* Two lots of padding: Pad the first block to 64 bytes */
+ memset (p, 0, count);
+
+ md5_byte_reverse (md5->data, 16);
+ md5_transform (md5->buf, (guint32 *) md5->data);
+
+ /* Now fill the next block with 56 bytes */
+ memset (md5->data, 0, MD5_DATASIZE - 8);
+ }
+ else
+ {
+ /* Pad block to 56 bytes */
+ memset (p, 0, count - 8);
+ }
+
+ md5_byte_reverse (md5->data, 14);
+
+ /* Append length in bits and transform */
+ ((guint32 *) md5->data)[14] = md5->bits[0];
+ ((guint32 *) md5->data)[15] = md5->bits[1];
+
+ md5_transform (md5->buf, (guint32 *) md5->data);
+ md5_byte_reverse ((guchar *) md5->buf, 4);
+
+ memcpy (md5->digest, md5->buf, 16);
+
+ /* Reset buffers in case they contain sensitive data */
+ memset (md5->buf, 0, sizeof (md5->buf));
+ memset (md5->data, 0, sizeof (md5->data));
+}
+
+static gchar *
+md5_sum_to_string (Md5sum *md5)
+{
+ return digest_to_string (md5->digest, MD5_DIGEST_LEN);
+}
+
+static void
+md5_sum_digest (Md5sum *md5,
+ guint8 *digest)
+{
+ gint i;
+
+ for (i = 0; i < MD5_DIGEST_LEN; i++)
+ digest[i] = md5->digest[i];
+}
+
+/*
+ * SHA-1 Checksum
+ */
+
+/* The following implementation comes from D-Bus dbus-sha.c. I've changed
+ * it to use GLib types and to work more like the MD5 implementation above.
+ * I left the comments to have an history of this code.
+ * -- Emmanuele Bassi, ebassi@gnome.org
+ */
+
+/* The following comments have the history of where this code
+ * comes from. I actually copied it from GNet in GNOME CVS.
+ * - hp@redhat.com
+ */
+
+/*
+ * sha.h : Implementation of the Secure Hash Algorithm
+ *
+ * Part of the Python Cryptography Toolkit, version 1.0.0
+ *
+ * Copyright (C) 1995, A.M. Kuchling
+ *
+ * Distribute and use freely; there are no restrictions on further
+ * dissemination and usage except those imposed by the laws of your
+ * country of residence.
+ *
+ */
+
+/* SHA: NIST's Secure Hash Algorithm */
+
+/* Based on SHA code originally posted to sci.crypt by Peter Gutmann
+ in message <30ajo5$oe8@ccu2.auckland.ac.nz>.
+ Modified to test for endianness on creation of SHA objects by AMK.
+ Also, the original specification of SHA was found to have a weakness
+ by NSA/NIST. This code implements the fixed version of SHA.
+*/
+
+/* Here's the first paragraph of Peter Gutmann's posting:
+
+The following is my SHA (FIPS 180) code updated to allow use of the "fixed"
+SHA, thanks to Jim Gillogly and an anonymous contributor for the information on
+what's changed in the new version. The fix is a simple change which involves
+adding a single rotate in the initial expansion function. It is unknown
+whether this is an optimal solution to the problem which was discovered in the
+SHA or whether it's simply a bandaid which fixes the problem with a minimum of
+effort (for example the reengineering of a great many Capstone chips).
+*/
+
+static void
+sha1_sum_init (Sha1sum *sha1)
+{
+ /* initialize constants */
+ sha1->buf[0] = 0x67452301L;
+ sha1->buf[1] = 0xEFCDAB89L;
+ sha1->buf[2] = 0x98BADCFEL;
+ sha1->buf[3] = 0x10325476L;
+ sha1->buf[4] = 0xC3D2E1F0L;
+
+ /* initialize bits */
+ sha1->bits[0] = sha1->bits[1] = 0;
+}
+
+/* The SHA f()-functions. */
+
+#define f1(x,y,z) (z ^ (x & (y ^ z))) /* Rounds 0-19 */
+#define f2(x,y,z) (x ^ y ^ z) /* Rounds 20-39 */
+#define f3(x,y,z) (( x & y) | (z & (x | y))) /* Rounds 40-59 */
+#define f4(x,y,z) (x ^ y ^ z) /* Rounds 60-79 */
+
+/* The SHA Mysterious Constants */
+#define K1 0x5A827999L /* Rounds 0-19 */
+#define K2 0x6ED9EBA1L /* Rounds 20-39 */
+#define K3 0x8F1BBCDCL /* Rounds 40-59 */
+#define K4 0xCA62C1D6L /* Rounds 60-79 */
+
+/* 32-bit rotate left - kludged with shifts */
+#define ROTL(n,X) (((X) << n ) | ((X) >> (32 - n)))
+
+/* The initial expanding function. The hash function is defined over an
+ 80-word expanded input array W, where the first 16 are copies of the input
+ data, and the remaining 64 are defined by
+
+ W[ i ] = W[ i - 16 ] ^ W[ i - 14 ] ^ W[ i - 8 ] ^ W[ i - 3 ]
+
+ This implementation generates these values on the fly in a circular
+ buffer - thanks to Colin Plumb, colin@nyx10.cs.du.edu for this
+ optimization.
+
+ The updated SHA changes the expanding function by adding a rotate of 1
+ bit. Thanks to Jim Gillogly, jim@rand.org, and an anonymous contributor
+ for this information */
+
+#define expand(W,i) (W[ i & 15 ] = ROTL (1, (W[ i & 15] ^ \
+ W[(i - 14) & 15] ^ \
+ W[(i - 8) & 15] ^ \
+ W[(i - 3) & 15])))
+
+
+/* The prototype SHA sub-round. The fundamental sub-round is:
+
+ a' = e + ROTL( 5, a ) + f( b, c, d ) + k + data;
+ b' = a;
+ c' = ROTL( 30, b );
+ d' = c;
+ e' = d;
+
+ but this is implemented by unrolling the loop 5 times and renaming the
+ variables ( e, a, b, c, d ) = ( a', b', c', d', e' ) each iteration.
+ This code is then replicated 20 times for each of the 4 functions, using
+ the next 20 values from the W[] array each time */
+
+#define subRound(a, b, c, d, e, f, k, data) \
+ (e += ROTL (5, a) + f(b, c, d) + k + data, b = ROTL (30, b))
+
+static void
+sha1_transform (guint32 buf[5],
+ guint32 in[16])
+{
+ guint32 A, B, C, D, E;
+
+ A = buf[0];
+ B = buf[1];
+ C = buf[2];
+ D = buf[3];
+ E = buf[4];
+
+ /* Heavy mangling, in 4 sub-rounds of 20 interations each. */
+ subRound (A, B, C, D, E, f1, K1, in[0]);
+ subRound (E, A, B, C, D, f1, K1, in[1]);
+ subRound (D, E, A, B, C, f1, K1, in[2]);
+ subRound (C, D, E, A, B, f1, K1, in[3]);
+ subRound (B, C, D, E, A, f1, K1, in[4]);
+ subRound (A, B, C, D, E, f1, K1, in[5]);
+ subRound (E, A, B, C, D, f1, K1, in[6]);
+ subRound (D, E, A, B, C, f1, K1, in[7]);
+ subRound (C, D, E, A, B, f1, K1, in[8]);
+ subRound (B, C, D, E, A, f1, K1, in[9]);
+ subRound (A, B, C, D, E, f1, K1, in[10]);
+ subRound (E, A, B, C, D, f1, K1, in[11]);
+ subRound (D, E, A, B, C, f1, K1, in[12]);
+ subRound (C, D, E, A, B, f1, K1, in[13]);
+ subRound (B, C, D, E, A, f1, K1, in[14]);
+ subRound (A, B, C, D, E, f1, K1, in[15]);
+ subRound (E, A, B, C, D, f1, K1, expand (in, 16));
+ subRound (D, E, A, B, C, f1, K1, expand (in, 17));
+ subRound (C, D, E, A, B, f1, K1, expand (in, 18));
+ subRound (B, C, D, E, A, f1, K1, expand (in, 19));
+
+ subRound (A, B, C, D, E, f2, K2, expand (in, 20));
+ subRound (E, A, B, C, D, f2, K2, expand (in, 21));
+ subRound (D, E, A, B, C, f2, K2, expand (in, 22));
+ subRound (C, D, E, A, B, f2, K2, expand (in, 23));
+ subRound (B, C, D, E, A, f2, K2, expand (in, 24));
+ subRound (A, B, C, D, E, f2, K2, expand (in, 25));
+ subRound (E, A, B, C, D, f2, K2, expand (in, 26));
+ subRound (D, E, A, B, C, f2, K2, expand (in, 27));
+ subRound (C, D, E, A, B, f2, K2, expand (in, 28));
+ subRound (B, C, D, E, A, f2, K2, expand (in, 29));
+ subRound (A, B, C, D, E, f2, K2, expand (in, 30));
+ subRound (E, A, B, C, D, f2, K2, expand (in, 31));
+ subRound (D, E, A, B, C, f2, K2, expand (in, 32));
+ subRound (C, D, E, A, B, f2, K2, expand (in, 33));
+ subRound (B, C, D, E, A, f2, K2, expand (in, 34));
+ subRound (A, B, C, D, E, f2, K2, expand (in, 35));
+ subRound (E, A, B, C, D, f2, K2, expand (in, 36));
+ subRound (D, E, A, B, C, f2, K2, expand (in, 37));
+ subRound (C, D, E, A, B, f2, K2, expand (in, 38));
+ subRound (B, C, D, E, A, f2, K2, expand (in, 39));
+
+ subRound (A, B, C, D, E, f3, K3, expand (in, 40));
+ subRound (E, A, B, C, D, f3, K3, expand (in, 41));
+ subRound (D, E, A, B, C, f3, K3, expand (in, 42));
+ subRound (C, D, E, A, B, f3, K3, expand (in, 43));
+ subRound (B, C, D, E, A, f3, K3, expand (in, 44));
+ subRound (A, B, C, D, E, f3, K3, expand (in, 45));
+ subRound (E, A, B, C, D, f3, K3, expand (in, 46));
+ subRound (D, E, A, B, C, f3, K3, expand (in, 47));
+ subRound (C, D, E, A, B, f3, K3, expand (in, 48));
+ subRound (B, C, D, E, A, f3, K3, expand (in, 49));
+ subRound (A, B, C, D, E, f3, K3, expand (in, 50));
+ subRound (E, A, B, C, D, f3, K3, expand (in, 51));
+ subRound (D, E, A, B, C, f3, K3, expand (in, 52));
+ subRound (C, D, E, A, B, f3, K3, expand (in, 53));
+ subRound (B, C, D, E, A, f3, K3, expand (in, 54));
+ subRound (A, B, C, D, E, f3, K3, expand (in, 55));
+ subRound (E, A, B, C, D, f3, K3, expand (in, 56));
+ subRound (D, E, A, B, C, f3, K3, expand (in, 57));
+ subRound (C, D, E, A, B, f3, K3, expand (in, 58));
+ subRound (B, C, D, E, A, f3, K3, expand (in, 59));
+
+ subRound (A, B, C, D, E, f4, K4, expand (in, 60));
+ subRound (E, A, B, C, D, f4, K4, expand (in, 61));
+ subRound (D, E, A, B, C, f4, K4, expand (in, 62));
+ subRound (C, D, E, A, B, f4, K4, expand (in, 63));
+ subRound (B, C, D, E, A, f4, K4, expand (in, 64));
+ subRound (A, B, C, D, E, f4, K4, expand (in, 65));
+ subRound (E, A, B, C, D, f4, K4, expand (in, 66));
+ subRound (D, E, A, B, C, f4, K4, expand (in, 67));
+ subRound (C, D, E, A, B, f4, K4, expand (in, 68));
+ subRound (B, C, D, E, A, f4, K4, expand (in, 69));
+ subRound (A, B, C, D, E, f4, K4, expand (in, 70));
+ subRound (E, A, B, C, D, f4, K4, expand (in, 71));
+ subRound (D, E, A, B, C, f4, K4, expand (in, 72));
+ subRound (C, D, E, A, B, f4, K4, expand (in, 73));
+ subRound (B, C, D, E, A, f4, K4, expand (in, 74));
+ subRound (A, B, C, D, E, f4, K4, expand (in, 75));
+ subRound (E, A, B, C, D, f4, K4, expand (in, 76));
+ subRound (D, E, A, B, C, f4, K4, expand (in, 77));
+ subRound (C, D, E, A, B, f4, K4, expand (in, 78));
+ subRound (B, C, D, E, A, f4, K4, expand (in, 79));
+
+ /* Build message digest */
+ buf[0] += A;
+ buf[1] += B;
+ buf[2] += C;
+ buf[3] += D;
+ buf[4] += E;
+}
+
+#undef K1
+#undef K2
+#undef K3
+#undef K4
+#undef f1
+#undef f2
+#undef f3
+#undef f4
+#undef ROTL
+#undef expand
+#undef subRound
+
+static void
+sha1_sum_update (Sha1sum *sha1,
+ const guchar *buffer,
+ gsize count)
+{
+ guint32 tmp;
+ guint dataCount;
+
+ /* Update bitcount */
+ tmp = sha1->bits[0];
+ if ((sha1->bits[0] = tmp + ((guint32) count << 3) ) < tmp)
+ sha1->bits[1] += 1; /* Carry from low to high */
+ sha1->bits[1] += count >> 29;
+
+ /* Get count of bytes already in data */
+ dataCount = (guint) (tmp >> 3) & 0x3F;
+
+ /* Handle any leading odd-sized chunks */
+ if (dataCount)
+ {
+ guchar *p = (guchar *) sha1->data + dataCount;
+
+ dataCount = SHA1_DATASIZE - dataCount;
+ if (count < dataCount)
+ {
+ memcpy (p, buffer, count);
+ return;
+ }
+
+ memcpy (p, buffer, dataCount);
+
+ sha_byte_reverse (sha1->data, SHA1_DATASIZE);
+ sha1_transform (sha1->buf, sha1->data);
+
+ buffer += dataCount;
+ count -= dataCount;
+ }
+
+ /* Process data in SHA1_DATASIZE chunks */
+ while (count >= SHA1_DATASIZE)
+ {
+ memcpy (sha1->data, buffer, SHA1_DATASIZE);
+
+ sha_byte_reverse (sha1->data, SHA1_DATASIZE);
+ sha1_transform (sha1->buf, sha1->data);
+
+ buffer += SHA1_DATASIZE;
+ count -= SHA1_DATASIZE;
+ }
+
+ /* Handle any remaining bytes of data. */
+ memcpy (sha1->data, buffer, count);
+}
+
+/* Final wrapup - pad to SHA_DATASIZE-byte boundary with the bit pattern
+ 1 0* (64-bit count of bits processed, MSB-first) */
+static void
+sha1_sum_close (Sha1sum *sha1)
+{
+ gint count;
+ guchar *data_p;
+
+ /* Compute number of bytes mod 64 */
+ count = (gint) ((sha1->bits[0] >> 3) & 0x3f);
+
+ /* Set the first char of padding to 0x80. This is safe since there is
+ always at least one byte free */
+ data_p = (guchar *) sha1->data + count;
+ *data_p++ = 0x80;
+
+ /* Bytes of padding needed to make 64 bytes */
+ count = SHA1_DATASIZE - 1 - count;
+
+ /* Pad out to 56 mod 64 */
+ if (count < 8)
+ {
+ /* Two lots of padding: Pad the first block to 64 bytes */
+ memset (data_p, 0, count);
+
+ sha_byte_reverse (sha1->data, SHA1_DATASIZE);
+ sha1_transform (sha1->buf, sha1->data);
+
+ /* Now fill the next block with 56 bytes */
+ memset (sha1->data, 0, SHA1_DATASIZE - 8);
+ }
+ else
+ {
+ /* Pad block to 56 bytes */
+ memset (data_p, 0, count - 8);
+ }
+
+ /* Append length in bits and transform */
+ sha1->data[14] = sha1->bits[1];
+ sha1->data[15] = sha1->bits[0];
+
+ sha_byte_reverse (sha1->data, SHA1_DATASIZE - 8);
+ sha1_transform (sha1->buf, sha1->data);
+ sha_byte_reverse (sha1->buf, SHA1_DIGEST_LEN);
+
+ memcpy (sha1->digest, sha1->buf, SHA1_DIGEST_LEN);
+
+ /* Reset buffers in case they contain sensitive data */
+ memset (sha1->buf, 0, sizeof (sha1->buf));
+ memset (sha1->data, 0, sizeof (sha1->data));
+}
+
+static gchar *
+sha1_sum_to_string (Sha1sum *sha1)
+{
+ return digest_to_string (sha1->digest, SHA1_DIGEST_LEN);
+}
+
+static void
+sha1_sum_digest (Sha1sum *sha1,
+ guint8 *digest)
+{
+ gint i;
+
+ for (i = 0; i < SHA1_DIGEST_LEN; i++)
+ digest[i] = sha1->digest[i];
+}
+
+/*
+ * SHA-256 Checksum
+ */
+
+/* adapted from the SHA256 implementation in gsk/src/hash/gskhash.c.
+ *
+ * Copyright (C) 2006 Dave Benson
+ * Released under the terms of the GNU Lesser General Public License
+ */
+
+static void
+sha256_sum_init (Sha256sum *sha256)
+{
+ sha256->buf[0] = 0x6a09e667;
+ sha256->buf[1] = 0xbb67ae85;
+ sha256->buf[2] = 0x3c6ef372;
+ sha256->buf[3] = 0xa54ff53a;
+ sha256->buf[4] = 0x510e527f;
+ sha256->buf[5] = 0x9b05688c;
+ sha256->buf[6] = 0x1f83d9ab;
+ sha256->buf[7] = 0x5be0cd19;
+
+ sha256->bits[0] = sha256->bits[1] = 0;
+}
+
+#define GET_UINT32(n,b,i) G_STMT_START{ \
+ (n) = ((guint32) (b)[(i) ] << 24) \
+ | ((guint32) (b)[(i) + 1] << 16) \
+ | ((guint32) (b)[(i) + 2] << 8) \
+ | ((guint32) (b)[(i) + 3] ); } G_STMT_END
+
+#define PUT_UINT32(n,b,i) G_STMT_START{ \
+ (b)[(i) ] = (guint8) ((n) >> 24); \
+ (b)[(i) + 1] = (guint8) ((n) >> 16); \
+ (b)[(i) + 2] = (guint8) ((n) >> 8); \
+ (b)[(i) + 3] = (guint8) ((n) ); } G_STMT_END
+
+static void
+sha256_transform (guint32 buf[8],
+ guint8 const data[64])
+{
+ guint32 temp1, temp2, W[64];
+ guint32 A, B, C, D, E, F, G, H;
+
+ GET_UINT32 (W[0], data, 0);
+ GET_UINT32 (W[1], data, 4);
+ GET_UINT32 (W[2], data, 8);
+ GET_UINT32 (W[3], data, 12);
+ GET_UINT32 (W[4], data, 16);
+ GET_UINT32 (W[5], data, 20);
+ GET_UINT32 (W[6], data, 24);
+ GET_UINT32 (W[7], data, 28);
+ GET_UINT32 (W[8], data, 32);
+ GET_UINT32 (W[9], data, 36);
+ GET_UINT32 (W[10], data, 40);
+ GET_UINT32 (W[11], data, 44);
+ GET_UINT32 (W[12], data, 48);
+ GET_UINT32 (W[13], data, 52);
+ GET_UINT32 (W[14], data, 56);
+ GET_UINT32 (W[15], data, 60);
+
+#define SHR(x,n) ((x & 0xFFFFFFFF) >> n)
+#define ROTR(x,n) (SHR (x,n) | (x << (32 - n)))
+
+#define S0(x) (ROTR (x, 7) ^ ROTR (x,18) ^ SHR (x, 3))
+#define S1(x) (ROTR (x,17) ^ ROTR (x,19) ^ SHR (x,10))
+#define S2(x) (ROTR (x, 2) ^ ROTR (x,13) ^ ROTR (x,22))
+#define S3(x) (ROTR (x, 6) ^ ROTR (x,11) ^ ROTR (x,25))
+
+#define F0(x,y,z) ((x & y) | (z & (x | y)))
+#define F1(x,y,z) (z ^ (x & (y ^ z)))
+
+#define R(t) (W[t] = S1(W[t - 2]) + W[t - 7] + \
+ S0(W[t - 15]) + W[t - 16])
+
+#define P(a,b,c,d,e,f,g,h,x,K) G_STMT_START { \
+ temp1 = h + S3(e) + F1(e,f,g) + K + x; \
+ temp2 = S2(a) + F0(a,b,c); \
+ d += temp1; h = temp1 + temp2; } G_STMT_END
+
+ A = buf[0];
+ B = buf[1];
+ C = buf[2];
+ D = buf[3];
+ E = buf[4];
+ F = buf[5];
+ G = buf[6];
+ H = buf[7];
+
+ P (A, B, C, D, E, F, G, H, W[ 0], 0x428A2F98);
+ P (H, A, B, C, D, E, F, G, W[ 1], 0x71374491);
+ P (G, H, A, B, C, D, E, F, W[ 2], 0xB5C0FBCF);
+ P (F, G, H, A, B, C, D, E, W[ 3], 0xE9B5DBA5);
+ P (E, F, G, H, A, B, C, D, W[ 4], 0x3956C25B);
+ P (D, E, F, G, H, A, B, C, W[ 5], 0x59F111F1);
+ P (C, D, E, F, G, H, A, B, W[ 6], 0x923F82A4);
+ P (B, C, D, E, F, G, H, A, W[ 7], 0xAB1C5ED5);
+ P (A, B, C, D, E, F, G, H, W[ 8], 0xD807AA98);
+ P (H, A, B, C, D, E, F, G, W[ 9], 0x12835B01);
+ P (G, H, A, B, C, D, E, F, W[10], 0x243185BE);
+ P (F, G, H, A, B, C, D, E, W[11], 0x550C7DC3);
+ P (E, F, G, H, A, B, C, D, W[12], 0x72BE5D74);
+ P (D, E, F, G, H, A, B, C, W[13], 0x80DEB1FE);
+ P (C, D, E, F, G, H, A, B, W[14], 0x9BDC06A7);
+ P (B, C, D, E, F, G, H, A, W[15], 0xC19BF174);
+ P (A, B, C, D, E, F, G, H, R(16), 0xE49B69C1);
+ P (H, A, B, C, D, E, F, G, R(17), 0xEFBE4786);
+ P (G, H, A, B, C, D, E, F, R(18), 0x0FC19DC6);
+ P (F, G, H, A, B, C, D, E, R(19), 0x240CA1CC);
+ P (E, F, G, H, A, B, C, D, R(20), 0x2DE92C6F);
+ P (D, E, F, G, H, A, B, C, R(21), 0x4A7484AA);
+ P (C, D, E, F, G, H, A, B, R(22), 0x5CB0A9DC);
+ P (B, C, D, E, F, G, H, A, R(23), 0x76F988DA);
+ P (A, B, C, D, E, F, G, H, R(24), 0x983E5152);
+ P (H, A, B, C, D, E, F, G, R(25), 0xA831C66D);
+ P (G, H, A, B, C, D, E, F, R(26), 0xB00327C8);
+ P (F, G, H, A, B, C, D, E, R(27), 0xBF597FC7);
+ P (E, F, G, H, A, B, C, D, R(28), 0xC6E00BF3);
+ P (D, E, F, G, H, A, B, C, R(29), 0xD5A79147);
+ P (C, D, E, F, G, H, A, B, R(30), 0x06CA6351);
+ P (B, C, D, E, F, G, H, A, R(31), 0x14292967);
+ P (A, B, C, D, E, F, G, H, R(32), 0x27B70A85);
+ P (H, A, B, C, D, E, F, G, R(33), 0x2E1B2138);
+ P (G, H, A, B, C, D, E, F, R(34), 0x4D2C6DFC);
+ P (F, G, H, A, B, C, D, E, R(35), 0x53380D13);
+ P (E, F, G, H, A, B, C, D, R(36), 0x650A7354);
+ P (D, E, F, G, H, A, B, C, R(37), 0x766A0ABB);
+ P (C, D, E, F, G, H, A, B, R(38), 0x81C2C92E);
+ P (B, C, D, E, F, G, H, A, R(39), 0x92722C85);
+ P (A, B, C, D, E, F, G, H, R(40), 0xA2BFE8A1);
+ P (H, A, B, C, D, E, F, G, R(41), 0xA81A664B);
+ P (G, H, A, B, C, D, E, F, R(42), 0xC24B8B70);
+ P (F, G, H, A, B, C, D, E, R(43), 0xC76C51A3);
+ P (E, F, G, H, A, B, C, D, R(44), 0xD192E819);
+ P (D, E, F, G, H, A, B, C, R(45), 0xD6990624);
+ P (C, D, E, F, G, H, A, B, R(46), 0xF40E3585);
+ P (B, C, D, E, F, G, H, A, R(47), 0x106AA070);
+ P (A, B, C, D, E, F, G, H, R(48), 0x19A4C116);
+ P (H, A, B, C, D, E, F, G, R(49), 0x1E376C08);
+ P (G, H, A, B, C, D, E, F, R(50), 0x2748774C);
+ P (F, G, H, A, B, C, D, E, R(51), 0x34B0BCB5);
+ P (E, F, G, H, A, B, C, D, R(52), 0x391C0CB3);
+ P (D, E, F, G, H, A, B, C, R(53), 0x4ED8AA4A);
+ P (C, D, E, F, G, H, A, B, R(54), 0x5B9CCA4F);
+ P (B, C, D, E, F, G, H, A, R(55), 0x682E6FF3);
+ P (A, B, C, D, E, F, G, H, R(56), 0x748F82EE);
+ P (H, A, B, C, D, E, F, G, R(57), 0x78A5636F);
+ P (G, H, A, B, C, D, E, F, R(58), 0x84C87814);
+ P (F, G, H, A, B, C, D, E, R(59), 0x8CC70208);
+ P (E, F, G, H, A, B, C, D, R(60), 0x90BEFFFA);
+ P (D, E, F, G, H, A, B, C, R(61), 0xA4506CEB);
+ P (C, D, E, F, G, H, A, B, R(62), 0xBEF9A3F7);
+ P (B, C, D, E, F, G, H, A, R(63), 0xC67178F2);
+
+#undef SHR
+#undef ROTR
+#undef S0
+#undef S1
+#undef S2
+#undef S3
+#undef F0
+#undef F1
+#undef R
+#undef P
+
+ buf[0] += A;
+ buf[1] += B;
+ buf[2] += C;
+ buf[3] += D;
+ buf[4] += E;
+ buf[5] += F;
+ buf[6] += G;
+ buf[7] += H;
+}
+
+static void
+sha256_sum_update (Sha256sum *sha256,
+ const guchar *buffer,
+ gsize length)
+{
+ guint32 left, fill;
+ const guint8 *input = buffer;
+
+ if (length == 0)
+ return;
+
+ left = sha256->bits[0] & 0x3F;
+ fill = 64 - left;
+
+ sha256->bits[0] += length;
+ sha256->bits[0] &= 0xFFFFFFFF;
+
+ if (sha256->bits[0] < length)
+ sha256->bits[1]++;
+
+ if (left > 0 && length >= fill)
+ {
+ memcpy ((sha256->data + left), input, fill);
+
+ sha256_transform (sha256->buf, sha256->data);
+ length -= fill;
+ input += fill;
+
+ left = 0;
+ }
+
+ while (length >= SHA256_DATASIZE)
+ {
+ sha256_transform (sha256->buf, input);
+
+ length -= 64;
+ input += 64;
+ }
+
+ if (length)
+ memcpy (sha256->data + left, input, length);
+}
+
+static guint8 sha256_padding[64] =
+{
+ 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+static void
+sha256_sum_close (Sha256sum *sha256)
+{
+ guint32 last, padn;
+ guint32 high, low;
+ guint8 msglen[8];
+
+ high = (sha256->bits[0] >> 29)
+ | (sha256->bits[1] << 3);
+ low = (sha256->bits[0] << 3);
+
+ PUT_UINT32 (high, msglen, 0);
+ PUT_UINT32 (low, msglen, 4);
+
+ last = sha256->bits[0] & 0x3F;
+ padn = (last < 56) ? (56 - last) : (120 - last);
+
+ sha256_sum_update (sha256, sha256_padding, padn);
+ sha256_sum_update (sha256, msglen, 8);
+
+ PUT_UINT32 (sha256->buf[0], sha256->digest, 0);
+ PUT_UINT32 (sha256->buf[1], sha256->digest, 4);
+ PUT_UINT32 (sha256->buf[2], sha256->digest, 8);
+ PUT_UINT32 (sha256->buf[3], sha256->digest, 12);
+ PUT_UINT32 (sha256->buf[4], sha256->digest, 16);
+ PUT_UINT32 (sha256->buf[5], sha256->digest, 20);
+ PUT_UINT32 (sha256->buf[6], sha256->digest, 24);
+ PUT_UINT32 (sha256->buf[7], sha256->digest, 28);
+}
+
+#undef PUT_UINT32
+#undef GET_UINT32
+
+static gchar *
+sha256_sum_to_string (Sha256sum *sha256)
+{
+ return digest_to_string (sha256->digest, SHA256_DIGEST_LEN);
+}
+
+static void
+sha256_sum_digest (Sha256sum *sha256,
+ guint8 *digest)
+{
+ gint i;
+
+ for (i = 0; i < SHA256_DIGEST_LEN; i++)
+ digest[i] = sha256->digest[i];
+}
+
+
+/*
+ * Public API
+ */
+
+/**
+ * g_checksum_type_get_length:
+ * @checksum_type: a #GChecksumType
+ *
+ * Gets the length in bytes of digests of type @checksum_type
+ *
+ * Return value: the checksum length, or -1 if @checksum_type is
+ * not supported.
+ *
+ * Since: 2.16
+ */
+gssize
+g_checksum_type_get_length (GChecksumType checksum_type)
+{
+ gssize len = -1;
+
+ switch (checksum_type)
+ {
+ case G_CHECKSUM_MD5:
+ len = MD5_DIGEST_LEN;
+ break;
+ case G_CHECKSUM_SHA1:
+ len = SHA1_DIGEST_LEN;
+ break;
+ case G_CHECKSUM_SHA256:
+ len = SHA256_DIGEST_LEN;
+ break;
+ default:
+ len = -1;
+ break;
+ }
+
+ return len;
+}
+
+/**
+ * g_checksum_new:
+ * @checksum_type: the desired type of checksum
+ *
+ * Creates a new #GChecksum, using the checksum algorithm @checksum_type.
+ * If the @checksum_type is not known, %NULL is returned.
+ * A #GChecksum can be used to compute the checksum, or digest, of an
+ * arbitrary binary blob, using different hashing algorithms.
+ *
+ * A #GChecksum works by feeding a binary blob through g_checksum_update()
+ * until there is data to be checked; the digest can then be extracted
+ * using g_checksum_get_string(), which will return the checksum as a
+ * hexadecimal string; or g_checksum_get_digest(), which will return a
+ * vector of raw bytes. Once either g_checksum_get_string() or
+ * g_checksum_get_digest() have been called on a #GChecksum, the checksum
+ * will be closed and it won't be possible to call g_checksum_update()
+ * on it anymore.
+ *
+ * Return value: the newly created #GChecksum, or %NULL.
+ * Use g_checksum_free() to free the memory allocated by it.
+ *
+ * Since: 2.16
+ */
+GChecksum *
+g_checksum_new (GChecksumType checksum_type)
+{
+ GChecksum *checksum;
+
+ if (! IS_VALID_TYPE (checksum_type))
+ return NULL;
+
+ checksum = g_slice_new0 (GChecksum);
+ checksum->type = checksum_type;
+
+ g_checksum_reset (checksum);
+
+ return checksum;
+}
+
+/**
+ * g_checksum_reset:
+ * @checksum: the #GChecksum to reset
+ *
+ * Resets the state of the @checksum back to its initial state.
+ *
+ * Since: 2.18
+ **/
+void
+g_checksum_reset (GChecksum *checksum)
+{
+ g_return_if_fail (checksum != NULL);
+
+ g_free (checksum->digest_str);
+ checksum->digest_str = NULL;
+
+ switch (checksum->type)
+ {
+ case G_CHECKSUM_MD5:
+ md5_sum_init (&(checksum->sum.md5));
+ break;
+ case G_CHECKSUM_SHA1:
+ sha1_sum_init (&(checksum->sum.sha1));
+ break;
+ case G_CHECKSUM_SHA256:
+ sha256_sum_init (&(checksum->sum.sha256));
+ break;
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+}
+
+/**
+ * g_checksum_copy:
+ * @checksum: the #GChecksum to copy
+ *
+ * Copies a #GChecksum. If @checksum has been closed, by calling
+ * g_checksum_get_string() or g_checksum_get_digest(), the copied
+ * checksum will be closed as well.
+ *
+ * Return value: the copy of the passed #GChecksum. Use g_checksum_free()
+ * when finished using it.
+ *
+ * Since: 2.16
+ */
+GChecksum *
+g_checksum_copy (const GChecksum *checksum)
+{
+ GChecksum *copy;
+
+ g_return_val_if_fail (checksum != NULL, NULL);
+
+ copy = g_slice_new (GChecksum);
+ *copy = *checksum;
+
+ copy->digest_str = g_strdup (checksum->digest_str);
+
+ return copy;
+}
+
+/**
+ * g_checksum_free:
+ * @checksum: a #GChecksum
+ *
+ * Frees the memory allocated for @checksum.
+ *
+ * Since: 2.16
+ */
+void
+g_checksum_free (GChecksum *checksum)
+{
+ if (G_LIKELY (checksum))
+ {
+ g_free (checksum->digest_str);
+
+ g_slice_free (GChecksum, checksum);
+ }
+}
+
+/**
+ * g_checksum_update:
+ * @checksum: a #GChecksum
+ * @data: buffer used to compute the checksum
+ * @length: size of the buffer, or -1 if it is a null-terminated string.
+ *
+ * Feeds @data into an existing #GChecksum. The checksum must still be
+ * open, that is g_checksum_get_string() or g_checksum_get_digest() must
+ * not have been called on @checksum.
+ *
+ * Since: 2.16
+ */
+void
+g_checksum_update (GChecksum *checksum,
+ const guchar *data,
+ gssize length)
+{
+ g_return_if_fail (checksum != NULL);
+ g_return_if_fail (data != NULL);
+
+ if (length < 0)
+ length = strlen ((const gchar *) data);
+
+ if (checksum->digest_str)
+ {
+ g_warning ("The checksum `%s' has been closed and cannot be updated "
+ "anymore.",
+ checksum->digest_str);
+ return;
+ }
+
+ switch (checksum->type)
+ {
+ case G_CHECKSUM_MD5:
+ md5_sum_update (&(checksum->sum.md5), data, length);
+ break;
+ case G_CHECKSUM_SHA1:
+ sha1_sum_update (&(checksum->sum.sha1), data, length);
+ break;
+ case G_CHECKSUM_SHA256:
+ sha256_sum_update (&(checksum->sum.sha256), data, length);
+ break;
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+}
+
+/**
+ * g_checksum_get_string:
+ * @checksum: a #GChecksum
+ *
+ * Gets the digest as an hexadecimal string.
+ *
+ * Once this function has been called the #GChecksum can no longer be
+ * updated with g_checksum_update().
+ *
+ * The hexadecimal characters will be lower case.
+ *
+ * Return value: the hexadecimal representation of the checksum. The
+ * returned string is owned by the checksum and should not be modified
+ * or freed.
+ *
+ * Since: 2.16
+ */
+G_CONST_RETURN gchar *
+g_checksum_get_string (GChecksum *checksum)
+{
+ gchar *str = NULL;
+
+ g_return_val_if_fail (checksum != NULL, NULL);
+
+ if (checksum->digest_str)
+ return checksum->digest_str;
+
+ switch (checksum->type)
+ {
+ case G_CHECKSUM_MD5:
+ md5_sum_close (&(checksum->sum.md5));
+ str = md5_sum_to_string (&(checksum->sum.md5));
+ break;
+ case G_CHECKSUM_SHA1:
+ sha1_sum_close (&(checksum->sum.sha1));
+ str = sha1_sum_to_string (&(checksum->sum.sha1));
+ break;
+ case G_CHECKSUM_SHA256:
+ sha256_sum_close (&(checksum->sum.sha256));
+ str = sha256_sum_to_string (&(checksum->sum.sha256));
+ break;
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+
+ checksum->digest_str = str;
+
+ return checksum->digest_str;
+}
+
+/**
+ * g_checksum_get_digest:
+ * @checksum: a #GChecksum
+ * @buffer: output buffer
+ * @digest_len: an inout parameter. The caller initializes it to the size of @buffer.
+ * After the call it contains the length of the digest.
+ *
+ * Gets the digest from @checksum as a raw binary vector and places it
+ * into @buffer. The size of the digest depends on the type of checksum.
+ *
+ * Once this function has been called, the #GChecksum is closed and can
+ * no longer be updated with g_checksum_update().
+ *
+ * Since: 2.16
+ */
+void
+g_checksum_get_digest (GChecksum *checksum,
+ guint8 *buffer,
+ gsize *digest_len)
+{
+ gboolean checksum_open = FALSE;
+ gchar *str = NULL;
+ gsize len;
+
+ g_return_if_fail (checksum != NULL);
+
+ len = g_checksum_type_get_length (checksum->type);
+ g_return_if_fail (*digest_len >= len);
+
+ checksum_open = !!(checksum->digest_str == NULL);
+
+ switch (checksum->type)
+ {
+ case G_CHECKSUM_MD5:
+ if (checksum_open)
+ {
+ md5_sum_close (&(checksum->sum.md5));
+ str = md5_sum_to_string (&(checksum->sum.md5));
+ }
+ md5_sum_digest (&(checksum->sum.md5), buffer);
+ break;
+ case G_CHECKSUM_SHA1:
+ if (checksum_open)
+ {
+ sha1_sum_close (&(checksum->sum.sha1));
+ str = sha1_sum_to_string (&(checksum->sum.sha1));
+ }
+ sha1_sum_digest (&(checksum->sum.sha1), buffer);
+ break;
+ case G_CHECKSUM_SHA256:
+ if (checksum_open)
+ {
+ sha256_sum_close (&(checksum->sum.sha256));
+ str = sha256_sum_to_string (&(checksum->sum.sha256));
+ }
+ sha256_sum_digest (&(checksum->sum.sha256), buffer);
+ break;
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+
+ if (str)
+ checksum->digest_str = str;
+
+ *digest_len = len;
+}
+
+/**
+ * g_compute_checksum_for_data:
+ * @checksum_type: a #GChecksumType
+ * @data: binary blob to compute the digest of
+ * @length: length of @data
+ *
+ * Computes the checksum for a binary @data of @length. This is a
+ * convenience wrapper for g_checksum_new(), g_checksum_get_string()
+ * and g_checksum_free().
+ *
+ * The hexadecimal string returned will be in lower case.
+ *
+ * Return value: the digest of the binary data as a string in hexadecimal.
+ * The returned string should be freed with g_free() when done using it.
+ *
+ * Since: 2.16
+ */
+gchar *
+g_compute_checksum_for_data (GChecksumType checksum_type,
+ const guchar *data,
+ gsize length)
+{
+ GChecksum *checksum;
+ gchar *retval;
+
+ g_return_val_if_fail (IS_VALID_TYPE (checksum_type), NULL);
+ g_return_val_if_fail (data != NULL, NULL);
+
+ checksum = g_checksum_new (checksum_type);
+ if (!checksum)
+ return NULL;
+
+ g_checksum_update (checksum, data, length);
+ retval = g_strdup (g_checksum_get_string (checksum));
+ g_checksum_free (checksum);
+
+ return retval;
+}
+
+/**
+ * g_compute_checksum_for_string:
+ * @checksum_type: a #GChecksumType
+ * @str: the string to compute the checksum of
+ * @length: the length of the string, or -1 if the string is null-terminated.
+ *
+ * Computes the checksum of a string.
+ *
+ * The hexadecimal string returned will be in lower case.
+ *
+ * Return value: the checksum as a hexadecimal string. The returned string
+ * should be freed with g_free() when done using it.
+ *
+ * Since: 2.16
+ */
+gchar *
+g_compute_checksum_for_string (GChecksumType checksum_type,
+ const gchar *str,
+ gssize length)
+{
+ g_return_val_if_fail (IS_VALID_TYPE (checksum_type), NULL);
+ g_return_val_if_fail (str != NULL, NULL);
+
+ if (length < 0)
+ length = strlen (str);
+
+ return g_compute_checksum_for_data (checksum_type, (const guchar *) str, length);
+}
+
+#define __G_CHECKSUM_C__
--- /dev/null
+/* GRegex -- regular expression API wrapper around PCRE.
+ *
+ * Copyright (C) 1999, 2000 Scott Wimer
+ * Copyright (C) 2004, Matthias Clasen <mclasen@redhat.com>
+ * Copyright (C) 2005 - 2007, Marco Barisione <marco@barisione.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "config.h"
+
+#include <string.h>
+
+#include "glib.h"
+#include "gregex.h"
+#include <pcre.h>
+
+
+/* PCRE 7.3 does not contain the definition of PCRE_ERROR_NULLWSLIMIT */
+#ifndef PCRE_ERROR_NULLWSLIMIT
+#define PCRE_ERROR_NULLWSLIMIT (-22)
+#endif
+
+/* Mask of all the possible values for GRegexCompileFlags. */
+#define G_REGEX_COMPILE_MASK (G_REGEX_CASELESS | \
+ G_REGEX_MULTILINE | \
+ G_REGEX_DOTALL | \
+ G_REGEX_EXTENDED | \
+ G_REGEX_ANCHORED | \
+ G_REGEX_DOLLAR_ENDONLY | \
+ G_REGEX_UNGREEDY | \
+ G_REGEX_RAW | \
+ G_REGEX_NO_AUTO_CAPTURE | \
+ G_REGEX_OPTIMIZE | \
+ G_REGEX_DUPNAMES | \
+ G_REGEX_NEWLINE_CR | \
+ G_REGEX_NEWLINE_LF | \
+ G_REGEX_NEWLINE_CRLF)
+
+/* Mask of all the possible values for GRegexMatchFlags. */
+#define G_REGEX_MATCH_MASK (G_REGEX_MATCH_ANCHORED | \
+ G_REGEX_MATCH_NOTBOL | \
+ G_REGEX_MATCH_NOTEOL | \
+ G_REGEX_MATCH_NOTEMPTY | \
+ G_REGEX_MATCH_PARTIAL | \
+ G_REGEX_MATCH_NEWLINE_CR | \
+ G_REGEX_MATCH_NEWLINE_LF | \
+ G_REGEX_MATCH_NEWLINE_CRLF | \
+ G_REGEX_MATCH_NEWLINE_ANY)
+
+/* if the string is in UTF-8 use g_utf8_ functions, else use
+ * use just +/- 1. */
+#define NEXT_CHAR(re, s) (((re)->compile_opts & PCRE_UTF8) ? \
+ g_utf8_next_char (s) : \
+ ((s) + 1))
+#define PREV_CHAR(re, s) (((re)->compile_opts & PCRE_UTF8) ? \
+ g_utf8_prev_char (s) : \
+ ((s) - 1))
+
+struct _GMatchInfo
+{
+ GRegex *regex; /* the regex */
+ GRegexMatchFlags match_opts; /* options used at match time on the regex */
+ gint matches; /* number of matching sub patterns */
+ gint pos; /* position in the string where last match left off */
+ gint *offsets; /* array of offsets paired 0,1 ; 2,3 ; 3,4 etc */
+ gint n_offsets; /* number of offsets */
+ gint *workspace; /* workspace for pcre_dfa_exec() */
+ gint n_workspace; /* number of workspace elements */
+ const gchar *string; /* string passed to the match function */
+ gssize string_len; /* length of string */
+};
+
+struct _GRegex
+{
+ volatile gint ref_count; /* the ref count for the immutable part */
+ gchar *pattern; /* the pattern */
+ pcre *pcre_re; /* compiled form of the pattern */
+ GRegexCompileFlags compile_opts; /* options used at compile time on the pattern */
+ GRegexMatchFlags match_opts; /* options used at match time on the regex */
+ pcre_extra *extra; /* data stored when G_REGEX_OPTIMIZE is used */
+};
+
+/* TRUE if ret is an error code, FALSE otherwise. */
+#define IS_PCRE_ERROR(ret) ((ret) < PCRE_ERROR_NOMATCH && (ret) != PCRE_ERROR_PARTIAL)
+
+typedef struct _InterpolationData InterpolationData;
+static gboolean interpolation_list_needs_match (GList *list);
+static gboolean interpolate_replacement (const GMatchInfo *match_info,
+ GString *result,
+ gpointer data);
+static GList *split_replacement (const gchar *replacement,
+ GError **error);
+static void free_interpolation_data (InterpolationData *data);
+
+
+static const gchar *
+match_error (gint errcode)
+{
+ switch (errcode)
+ {
+ case PCRE_ERROR_NOMATCH:
+ /* not an error */
+ break;
+ case PCRE_ERROR_NULL:
+ /* NULL argument, this should not happen in GRegex */
+ g_warning ("A NULL argument was passed to PCRE");
+ break;
+ case PCRE_ERROR_BADOPTION:
+ return "bad options";
+ case PCRE_ERROR_BADMAGIC:
+ return "corrupted object";
+ case PCRE_ERROR_NOMEMORY:
+ return "out of memory";
+ case PCRE_ERROR_NOSUBSTRING:
+ /* not used by pcre_exec() */
+ break;
+ case PCRE_ERROR_MATCHLIMIT:
+ return "backtracking limit reached";
+ case PCRE_ERROR_CALLOUT:
+ /* callouts are not implemented */
+ break;
+ case PCRE_ERROR_BADUTF8:
+ case PCRE_ERROR_BADUTF8_OFFSET:
+ /* we do not check if strings are valid */
+ break;
+ case PCRE_ERROR_PARTIAL:
+ /* not an error */
+ break;
+ case PCRE_ERROR_BADPARTIAL:
+ return "the pattern contains items not supported for partial matching";
+ case PCRE_ERROR_INTERNAL:
+ return "internal error";
+ case PCRE_ERROR_BADCOUNT:
+ /* negative ovecsize, this should not happen in GRegex */
+ g_warning ("A negative ovecsize was passed to PCRE");
+ break;
+ case PCRE_ERROR_DFA_UITEM:
+ return "the pattern contains items not supported for partial matching";
+ case PCRE_ERROR_DFA_UCOND:
+ return "back references as conditions are not supported for partial matching";
+ case PCRE_ERROR_DFA_UMLIMIT:
+ /* the match_field field is not used in GRegex */
+ break;
+ case PCRE_ERROR_DFA_WSSIZE:
+ /* handled expanding the workspace */
+ break;
+ case PCRE_ERROR_DFA_RECURSE:
+ case PCRE_ERROR_RECURSIONLIMIT:
+ return "recursion limit reached";
+ case PCRE_ERROR_NULLWSLIMIT:
+ return "workspace limit for empty substrings reached";
+ default:
+ break;
+ }
+ return "unknown error";
+}
+
+static void
+translate_compile_error (gint *errcode, const gchar **errmsg)
+{
+ /* Compile errors are created adding 100 to the error code returned
+ * by PCRE.
+ * If errcode is known we put the translatable error message in
+ * erromsg. If errcode is unknown we put the generic
+ * G_REGEX_ERROR_COMPILE error code in errcode and keep the
+ * untranslated error message returned by PCRE.
+ * Note that there can be more PCRE errors with the same GRegexError
+ * and that some PCRE errors are useless for us.
+ */
+ *errcode += 100;
+
+ switch (*errcode)
+ {
+ case G_REGEX_ERROR_STRAY_BACKSLASH:
+ *errmsg = "\\ at end of pattern";
+ break;
+ case G_REGEX_ERROR_MISSING_CONTROL_CHAR:
+ *errmsg = "\\c at end of pattern";
+ break;
+ case G_REGEX_ERROR_UNRECOGNIZED_ESCAPE:
+ *errmsg = "unrecognized character follows \\";
+ break;
+ case 137:
+ /* A number of Perl escapes are not handled by PCRE.
+ * Therefore it explicitly raises ERR37.
+ */
+ *errcode = G_REGEX_ERROR_UNRECOGNIZED_ESCAPE;
+ *errmsg = "case-changing escapes (\\l, \\L, \\u, \\U) are not allowed here";
+ break;
+ case G_REGEX_ERROR_QUANTIFIERS_OUT_OF_ORDER:
+ *errmsg = "numbers out of order in {} quantifier";
+ break;
+ case G_REGEX_ERROR_QUANTIFIER_TOO_BIG:
+ *errmsg = "number too big in {} quantifier";
+ break;
+ case G_REGEX_ERROR_UNTERMINATED_CHARACTER_CLASS:
+ *errmsg = "missing terminating ] for character class";
+ break;
+ case G_REGEX_ERROR_INVALID_ESCAPE_IN_CHARACTER_CLASS:
+ *errmsg = "invalid escape sequence in character class";
+ break;
+ case G_REGEX_ERROR_RANGE_OUT_OF_ORDER:
+ *errmsg = "range out of order in character class";
+ break;
+ case G_REGEX_ERROR_NOTHING_TO_REPEAT:
+ *errmsg = "nothing to repeat";
+ break;
+ case G_REGEX_ERROR_UNRECOGNIZED_CHARACTER:
+ *errmsg = "unrecognized character after (?";
+ break;
+ case 124:
+ *errcode = G_REGEX_ERROR_UNRECOGNIZED_CHARACTER;
+ *errmsg = "unrecognized character after (?<";
+ break;
+ case 141:
+ *errcode = G_REGEX_ERROR_UNRECOGNIZED_CHARACTER;
+ *errmsg = "unrecognized character after (?P";
+ break;
+ case G_REGEX_ERROR_POSIX_NAMED_CLASS_OUTSIDE_CLASS:
+ *errmsg = "POSIX named classes are supported only within a class";
+ break;
+ case G_REGEX_ERROR_UNMATCHED_PARENTHESIS:
+ *errmsg = "missing terminating )";
+ break;
+ case 122:
+ *errcode = G_REGEX_ERROR_UNMATCHED_PARENTHESIS;
+ *errmsg = ") without opening (";
+ break;
+ case 129:
+ *errcode = G_REGEX_ERROR_UNMATCHED_PARENTHESIS;
+ /* translators: '(?R' and '(?[+-]digits' are both meant as (groups of)
+ * sequences here, '(?-54' would be an example for the second group.
+ */
+ *errmsg = "(?R or (?[+-]digits must be followed by )";
+ break;
+ case G_REGEX_ERROR_INEXISTENT_SUBPATTERN_REFERENCE:
+ *errmsg = "reference to non-existent subpattern";
+ break;
+ case G_REGEX_ERROR_UNTERMINATED_COMMENT:
+ *errmsg = "missing ) after comment";
+ break;
+ case G_REGEX_ERROR_EXPRESSION_TOO_LARGE:
+ *errmsg = "regular expression too large";
+ break;
+ case G_REGEX_ERROR_MEMORY_ERROR:
+ *errmsg = "failed to get memory";
+ break;
+ case G_REGEX_ERROR_VARIABLE_LENGTH_LOOKBEHIND:
+ *errmsg = "lookbehind assertion is not fixed length";
+ break;
+ case G_REGEX_ERROR_MALFORMED_CONDITION:
+ *errmsg = "malformed number or name after (?(";
+ break;
+ case G_REGEX_ERROR_TOO_MANY_CONDITIONAL_BRANCHES:
+ *errmsg = "conditional group contains more than two branches";
+ break;
+ case G_REGEX_ERROR_ASSERTION_EXPECTED:
+ *errmsg = "assertion expected after (?(";
+ break;
+ case G_REGEX_ERROR_UNKNOWN_POSIX_CLASS_NAME:
+ *errmsg = "unknown POSIX class name";
+ break;
+ case G_REGEX_ERROR_POSIX_COLLATING_ELEMENTS_NOT_SUPPORTED:
+ *errmsg = "POSIX collating elements are not supported";
+ break;
+ case G_REGEX_ERROR_HEX_CODE_TOO_LARGE:
+ *errmsg = "character value in \\x{...} sequence is too large";
+ break;
+ case G_REGEX_ERROR_INVALID_CONDITION:
+ *errmsg = "invalid condition (?(0)";
+ break;
+ case G_REGEX_ERROR_SINGLE_BYTE_MATCH_IN_LOOKBEHIND:
+ *errmsg = "\\C not allowed in lookbehind assertion";
+ break;
+ case G_REGEX_ERROR_INFINITE_LOOP:
+ *errmsg = "recursive call could loop indefinitely";
+ break;
+ case G_REGEX_ERROR_MISSING_SUBPATTERN_NAME_TERMINATOR:
+ *errmsg = "missing terminator in subpattern name";
+ break;
+ case G_REGEX_ERROR_DUPLICATE_SUBPATTERN_NAME:
+ *errmsg = "two named subpatterns have the same name";
+ break;
+ case G_REGEX_ERROR_MALFORMED_PROPERTY:
+ *errmsg = "malformed \\P or \\p sequence";
+ break;
+ case G_REGEX_ERROR_UNKNOWN_PROPERTY:
+ *errmsg = "unknown property name after \\P or \\p";
+ break;
+ case G_REGEX_ERROR_SUBPATTERN_NAME_TOO_LONG:
+ *errmsg = "subpattern name is too long (maximum 32 characters)";
+ break;
+ case G_REGEX_ERROR_TOO_MANY_SUBPATTERNS:
+ *errmsg = "too many named subpatterns (maximum 10,000)";
+ break;
+ case G_REGEX_ERROR_INVALID_OCTAL_VALUE:
+ *errmsg = "octal value is greater than \\377";
+ break;
+ case G_REGEX_ERROR_TOO_MANY_BRANCHES_IN_DEFINE:
+ *errmsg = "DEFINE group contains more than one branch";
+ break;
+ case G_REGEX_ERROR_DEFINE_REPETION:
+ *errmsg = "repeating a DEFINE group is not allowed";
+ break;
+ case G_REGEX_ERROR_INCONSISTENT_NEWLINE_OPTIONS:
+ *errmsg = "inconsistent NEWLINE options";
+ break;
+ case G_REGEX_ERROR_MISSING_BACK_REFERENCE:
+ *errmsg = "\\g is not followed by a braced name or an optionally "
+ "braced non-zero number";
+ break;
+ case 11:
+ *errcode = G_REGEX_ERROR_INTERNAL;
+ *errmsg = "unexpected repeat";
+ break;
+ case 23:
+ *errcode = G_REGEX_ERROR_INTERNAL;
+ *errmsg = "code overflow";
+ break;
+ case 52:
+ *errcode = G_REGEX_ERROR_INTERNAL;
+ *errmsg = "overran compiling workspace";
+ break;
+ case 53:
+ *errcode = G_REGEX_ERROR_INTERNAL;
+ *errmsg = "previously-checked referenced subpattern not found";
+ break;
+ case 16:
+ /* This should not happen as we never pass a NULL erroffset */
+ g_warning ("erroffset passed as NULL");
+ *errcode = G_REGEX_ERROR_COMPILE;
+ break;
+ case 17:
+ /* This should not happen as we check options before passing them
+ * to pcre_compile2() */
+ g_warning ("unknown option bit(s) set");
+ *errcode = G_REGEX_ERROR_COMPILE;
+ break;
+ case 32:
+ case 44:
+ case 45:
+ /* These errors should not happen as we are using an UTF8-enabled PCRE
+ * and we do not check if strings are valid */
+ g_warning ("%s", *errmsg);
+ *errcode = G_REGEX_ERROR_COMPILE;
+ break;
+ default:
+ *errcode = G_REGEX_ERROR_COMPILE;
+ }
+}
+
+/* GMatchInfo */
+
+static GMatchInfo *
+match_info_new (const GRegex *regex,
+ const gchar *string,
+ gint string_len,
+ gint start_position,
+ gint match_options,
+ gboolean is_dfa)
+{
+ GMatchInfo *match_info;
+
+ if (string_len < 0)
+ string_len = strlen (string);
+
+ match_info = g_new0 (GMatchInfo, 1);
+ match_info->regex = g_regex_ref ((GRegex *)regex);
+ match_info->string = string;
+ match_info->string_len = string_len;
+ match_info->matches = PCRE_ERROR_NOMATCH;
+ match_info->pos = start_position;
+ match_info->match_opts = match_options;
+
+ if (is_dfa)
+ {
+ /* These values should be enough for most cases, if they are not
+ * enough g_regex_match_all_full() will expand them. */
+ match_info->n_offsets = 24;
+ match_info->n_workspace = 100;
+ match_info->workspace = g_new (gint, match_info->n_workspace);
+ }
+ else
+ {
+ gint capture_count;
+ pcre_fullinfo (regex->pcre_re, regex->extra,
+ PCRE_INFO_CAPTURECOUNT, &capture_count);
+ match_info->n_offsets = (capture_count + 1) * 3;
+ }
+
+ match_info->offsets = g_new0 (gint, match_info->n_offsets);
+ /* Set an invalid position for the previous match. */
+ match_info->offsets[0] = -1;
+ match_info->offsets[1] = -1;
+
+ return match_info;
+}
+
+/**
+ * g_match_info_get_regex:
+ * @match_info: a #GMatchInfo
+ *
+ * Returns #GRegex object used in @match_info. It belongs to Glib
+ * and must not be freed. Use g_regex_ref() if you need to keep it
+ * after you free @match_info object.
+ *
+ * Returns: #GRegex object used in @match_info
+ *
+ * Since: 2.14
+ */
+GRegex *
+g_match_info_get_regex (const GMatchInfo *match_info)
+{
+ g_return_val_if_fail (match_info != NULL, NULL);
+ return match_info->regex;
+}
+
+/**
+ * g_match_info_get_string:
+ * @match_info: a #GMatchInfo
+ *
+ * Returns the string searched with @match_info. This is the
+ * string passed to g_regex_match() or g_regex_replace() so
+ * you may not free it before calling this function.
+ *
+ * Returns: the string searched with @match_info
+ *
+ * Since: 2.14
+ */
+const gchar *
+g_match_info_get_string (const GMatchInfo *match_info)
+{
+ g_return_val_if_fail (match_info != NULL, NULL);
+ return match_info->string;
+}
+
+/**
+ * g_match_info_free:
+ * @match_info: a #GMatchInfo
+ *
+ * Frees all the memory associated with the #GMatchInfo structure.
+ *
+ * Since: 2.14
+ */
+void
+g_match_info_free (GMatchInfo *match_info)
+{
+ if (match_info)
+ {
+ g_regex_unref (match_info->regex);
+ g_free (match_info->offsets);
+ g_free (match_info->workspace);
+ g_free (match_info);
+ }
+}
+
+/**
+ * g_match_info_next:
+ * @match_info: a #GMatchInfo structure
+ * @error: location to store the error occuring, or %NULL to ignore errors
+ *
+ * Scans for the next match using the same parameters of the previous
+ * call to g_regex_match_full() or g_regex_match() that returned
+ * @match_info.
+ *
+ * The match is done on the string passed to the match function, so you
+ * cannot free it before calling this function.
+ *
+ * Returns: %TRUE is the string matched, %FALSE otherwise
+ *
+ * Since: 2.14
+ */
+gboolean
+g_match_info_next (GMatchInfo *match_info,
+ GError **error)
+{
+ gint prev_match_start;
+ gint prev_match_end;
+
+ g_return_val_if_fail (match_info != NULL, FALSE);
+ g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+ g_return_val_if_fail (match_info->pos >= 0, FALSE);
+
+ prev_match_start = match_info->offsets[0];
+ prev_match_end = match_info->offsets[1];
+
+ match_info->matches = pcre_exec (match_info->regex->pcre_re,
+ match_info->regex->extra,
+ match_info->string,
+ match_info->string_len,
+ match_info->pos,
+ match_info->regex->match_opts | match_info->match_opts,
+ match_info->offsets,
+ match_info->n_offsets);
+ if (IS_PCRE_ERROR (match_info->matches))
+ {
+ g_set_error (error, G_REGEX_ERROR, G_REGEX_ERROR_MATCH,
+ "Error while matching regular expression %s: %s",
+ match_info->regex->pattern, match_error (match_info->matches));
+ return FALSE;
+ }
+
+ /* avoid infinite loops if the pattern is an empty string or something
+ * equivalent */
+ if (match_info->pos == match_info->offsets[1])
+ {
+ if (match_info->pos > match_info->string_len)
+ {
+ /* we have reached the end of the string */
+ match_info->pos = -1;
+ match_info->matches = PCRE_ERROR_NOMATCH;
+ return FALSE;
+ }
+
+ match_info->pos = NEXT_CHAR (match_info->regex,
+ &match_info->string[match_info->pos]) -
+ match_info->string;
+ }
+ else
+ {
+ match_info->pos = match_info->offsets[1];
+ }
+
+ /* it's possibile to get two identical matches when we are matching
+ * empty strings, for instance if the pattern is "(?=[A-Z0-9])" and
+ * the string is "RegExTest" we have:
+ * - search at position 0: match from 0 to 0
+ * - search at position 1: match from 3 to 3
+ * - search at position 3: match from 3 to 3 (duplicate)
+ * - search at position 4: match from 5 to 5
+ * - search at position 5: match from 5 to 5 (duplicate)
+ * - search at position 6: no match -> stop
+ * so we have to ignore the duplicates.
+ * see bug #515944: http://bugzilla.gnome.org/show_bug.cgi?id=515944 */
+ if (match_info->matches >= 0 &&
+ prev_match_start == match_info->offsets[0] &&
+ prev_match_end == match_info->offsets[1])
+ {
+ /* ignore this match and search the next one */
+ return g_match_info_next (match_info, error);
+ }
+
+ return match_info->matches >= 0;
+}
+
+/**
+ * g_match_info_matches:
+ * @match_info: a #GMatchInfo structure
+ *
+ * Returns whether the previous match operation succeeded.
+ *
+ * Returns: %TRUE if the previous match operation succeeded,
+ * %FALSE otherwise
+ *
+ * Since: 2.14
+ */
+gboolean
+g_match_info_matches (const GMatchInfo *match_info)
+{
+ g_return_val_if_fail (match_info != NULL, FALSE);
+
+ return match_info->matches >= 0;
+}
+
+/**
+ * g_match_info_get_match_count:
+ * @match_info: a #GMatchInfo structure
+ *
+ * Retrieves the number of matched substrings (including substring 0,
+ * that is the whole matched text), so 1 is returned if the pattern
+ * has no substrings in it and 0 is returned if the match failed.
+ *
+ * If the last match was obtained using the DFA algorithm, that is
+ * using g_regex_match_all() or g_regex_match_all_full(), the retrieved
+ * count is not that of the number of capturing parentheses but that of
+ * the number of matched substrings.
+ *
+ * Returns: Number of matched substrings, or -1 if an error occurred
+ *
+ * Since: 2.14
+ */
+gint
+g_match_info_get_match_count (const GMatchInfo *match_info)
+{
+ g_return_val_if_fail (match_info, -1);
+
+ if (match_info->matches == PCRE_ERROR_NOMATCH)
+ /* no match */
+ return 0;
+ else if (match_info->matches < PCRE_ERROR_NOMATCH)
+ /* error */
+ return -1;
+ else
+ /* match */
+ return match_info->matches;
+}
+
+/**
+ * g_match_info_is_partial_match:
+ * @match_info: a #GMatchInfo structure
+ *
+ * Usually if the string passed to g_regex_match*() matches as far as
+ * it goes, but is too short to match the entire pattern, %FALSE is
+ * returned. There are circumstances where it might be helpful to
+ * distinguish this case from other cases in which there is no match.
+ *
+ * Consider, for example, an application where a human is required to
+ * type in data for a field with specific formatting requirements. An
+ * example might be a date in the form ddmmmyy, defined by the pattern
+ * "^\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d$".
+ * If the application sees the user’s keystrokes one by one, and can
+ * check that what has been typed so far is potentially valid, it is
+ * able to raise an error as soon as a mistake is made.
+ *
+ * GRegex supports the concept of partial matching by means of the
+ * #G_REGEX_MATCH_PARTIAL flag. When this is set the return code for
+ * g_regex_match() or g_regex_match_full() is, as usual, %TRUE
+ * for a complete match, %FALSE otherwise. But, when these functions
+ * return %FALSE, you can check if the match was partial calling
+ * g_match_info_is_partial_match().
+ *
+ * When using partial matching you cannot use g_match_info_fetch*().
+ *
+ * Because of the way certain internal optimizations are implemented
+ * the partial matching algorithm cannot be used with all patterns.
+ * So repeated single characters such as "a{2,4}" and repeated single
+ * meta-sequences such as "\d+" are not permitted if the maximum number
+ * of occurrences is greater than one. Optional items such as "\d?"
+ * (where the maximum is one) are permitted. Quantifiers with any values
+ * are permitted after parentheses, so the invalid examples above can be
+ * coded thus "(a){2,4}" and "(\d)+". If #G_REGEX_MATCH_PARTIAL is set
+ * for a pattern that does not conform to the restrictions, matching
+ * functions return an error.
+ *
+ * Returns: %TRUE if the match was partial, %FALSE otherwise
+ *
+ * Since: 2.14
+ */
+gboolean
+g_match_info_is_partial_match (const GMatchInfo *match_info)
+{
+ g_return_val_if_fail (match_info != NULL, FALSE);
+
+ return match_info->matches == PCRE_ERROR_PARTIAL;
+}
+
+/**
+ * g_match_info_expand_references:
+ * @match_info: a #GMatchInfo or %NULL
+ * @string_to_expand: the string to expand
+ * @error: location to store the error occuring, or %NULL to ignore errors
+ *
+ * Returns a new string containing the text in @string_to_expand with
+ * references and escape sequences expanded. References refer to the last
+ * match done with @string against @regex and have the same syntax used by
+ * g_regex_replace().
+ *
+ * The @string_to_expand must be UTF-8 encoded even if #G_REGEX_RAW was
+ * passed to g_regex_new().
+ *
+ * The backreferences are extracted from the string passed to the match
+ * function, so you cannot call this function after freeing the string.
+ *
+ * @match_info may be %NULL in which case @string_to_expand must not
+ * contain references. For instance "foo\n" does not refer to an actual
+ * pattern and '\n' merely will be replaced with \n character,
+ * while to expand "\0" (whole match) one needs the result of a match.
+ * Use g_regex_check_replacement() to find out whether @string_to_expand
+ * contains references.
+ *
+ * Returns: the expanded string, or %NULL if an error occurred
+ *
+ * Since: 2.14
+ */
+gchar *
+g_match_info_expand_references (const GMatchInfo *match_info,
+ const gchar *string_to_expand,
+ GError **error)
+{
+ GString *result;
+ GList *list;
+ GError *tmp_error = NULL;
+
+ g_return_val_if_fail (string_to_expand != NULL, NULL);
+ g_return_val_if_fail (error == NULL || *error == NULL, NULL);
+
+ list = split_replacement (string_to_expand, &tmp_error);
+ if (tmp_error != NULL)
+ {
+ g_propagate_error (error, tmp_error);
+ return NULL;
+ }
+
+ if (!match_info && interpolation_list_needs_match (list))
+ {
+ g_critical ("String '%s' contains references to the match, can't "
+ "expand references without GMatchInfo object",
+ string_to_expand);
+ return NULL;
+ }
+
+ result = g_string_sized_new (strlen (string_to_expand));
+ interpolate_replacement (match_info, result, list);
+
+ g_list_foreach (list, (GFunc)free_interpolation_data, NULL);
+ g_list_free (list);
+
+ return g_string_free (result, FALSE);
+}
+
+/**
+ * g_match_info_fetch:
+ * @match_info: #GMatchInfo structure
+ * @match_num: number of the sub expression
+ *
+ * Retrieves the text matching the @match_num<!-- -->'th capturing
+ * parentheses. 0 is the full text of the match, 1 is the first paren
+ * set, 2 the second, and so on.
+ *
+ * If @match_num is a valid sub pattern but it didn't match anything
+ * (e.g. sub pattern 1, matching "b" against "(a)?b") then an empty
+ * string is returned.
+ *
+ * If the match was obtained using the DFA algorithm, that is using
+ * g_regex_match_all() or g_regex_match_all_full(), the retrieved
+ * string is not that of a set of parentheses but that of a matched
+ * substring. Substrings are matched in reverse order of length, so
+ * 0 is the longest match.
+ *
+ * The string is fetched from the string passed to the match function,
+ * so you cannot call this function after freeing the string.
+ *
+ * Returns: The matched substring, or %NULL if an error occurred.
+ * You have to free the string yourself
+ *
+ * Since: 2.14
+ */
+gchar *
+g_match_info_fetch (const GMatchInfo *match_info,
+ gint match_num)
+{
+ /* we cannot use pcre_get_substring() because it allocates the
+ * string using pcre_malloc(). */
+ gchar *match = NULL;
+ gint start, end;
+
+ g_return_val_if_fail (match_info != NULL, NULL);
+ g_return_val_if_fail (match_num >= 0, NULL);
+
+ /* match_num does not exist or it didn't matched, i.e. matching "b"
+ * against "(a)?b" then group 0 is empty. */
+ if (!g_match_info_fetch_pos (match_info, match_num, &start, &end))
+ match = NULL;
+ else if (start == -1)
+ match = g_strdup ("");
+ else
+ match = g_strndup (&match_info->string[start], end - start);
+
+ return match;
+}
+
+/**
+ * g_match_info_fetch_pos:
+ * @match_info: #GMatchInfo structure
+ * @match_num: number of the sub expression
+ * @start_pos: pointer to location where to store the start position
+ * @end_pos: pointer to location where to store the end position
+ *
+ * Retrieves the position in bytes of the @match_num<!-- -->'th capturing
+ * parentheses. 0 is the full text of the match, 1 is the first
+ * paren set, 2 the second, and so on.
+ *
+ * If @match_num is a valid sub pattern but it didn't match anything
+ * (e.g. sub pattern 1, matching "b" against "(a)?b") then @start_pos
+ * and @end_pos are set to -1 and %TRUE is returned.
+ *
+ * If the match was obtained using the DFA algorithm, that is using
+ * g_regex_match_all() or g_regex_match_all_full(), the retrieved
+ * position is not that of a set of parentheses but that of a matched
+ * substring. Substrings are matched in reverse order of length, so
+ * 0 is the longest match.
+ *
+ * Returns: %TRUE if the position was fetched, %FALSE otherwise. If
+ * the position cannot be fetched, @start_pos and @end_pos are left
+ * unchanged
+ *
+ * Since: 2.14
+ */
+gboolean
+g_match_info_fetch_pos (const GMatchInfo *match_info,
+ gint match_num,
+ gint *start_pos,
+ gint *end_pos)
+{
+ g_return_val_if_fail (match_info != NULL, FALSE);
+ g_return_val_if_fail (match_num >= 0, FALSE);
+
+ /* make sure the sub expression number they're requesting is less than
+ * the total number of sub expressions that were matched. */
+ if (match_num >= match_info->matches)
+ return FALSE;
+
+ if (start_pos != NULL)
+ *start_pos = match_info->offsets[2 * match_num];
+
+ if (end_pos != NULL)
+ *end_pos = match_info->offsets[2 * match_num + 1];
+
+ return TRUE;
+}
+
+static gint
+int_pcre_get_stringtable_entries(const pcre *code, const gchar *stringname,
+ gchar **firstptr, gchar **lastptr)
+{
+ gint rc;
+ gint entrysize;
+ gint top, bot;
+ guchar *nametable, *lastentry;
+
+ if ((rc = pcre_fullinfo (code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0)
+ return rc;
+ if (top <= 0)
+ return PCRE_ERROR_NOSUBSTRING;
+
+ if ((rc = pcre_fullinfo (code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize))
+ != 0)
+ return rc;
+ if ((rc = pcre_fullinfo (code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0)
+ return rc;
+
+ lastentry = nametable + entrysize * (top - 1);
+ bot = 0;
+ while (top > bot)
+ {
+ int mid = (top + bot) / 2;
+ char *entry = nametable + entrysize * mid;
+ int c = strcmp (stringname, (char *) (entry + 2));
+ if (c == 0) {
+ char *first = entry;
+ char *last = entry;
+ while (first > nametable) {
+ if (strcmp (stringname, (char *) (first - entrysize + 2)) != 0)break
+; first -= entrysize;
+ }
+ while (last < lastentry) {
+ if (strcmp (stringname, (char *) (last + entrysize + 2)) != 0)break
+; last += entrysize;
+ }
+ *firstptr = (char *) first;
+ *lastptr = (char *) last;
+ return entrysize;
+ }
+ if (c > 0)
+ bot = mid + 1;
+ else
+ top = mid;
+ }
+
+ return PCRE_ERROR_NOSUBSTRING;
+}
+
+/*
+ * Returns number of first matched subpattern with name @name.
+ * There may be more than one in case when DUPNAMES is used,
+ * and not all subpatterns with that name match;
+ * pcre_get_stringnumber() does not work in that case.
+ */
+static gint
+get_matched_substring_number (const GMatchInfo *match_info,
+ const gchar *name)
+{
+ gint entrysize;
+ gchar *first, *last;
+ guchar *entry;
+
+ if (!(match_info->regex->compile_opts & G_REGEX_DUPNAMES))
+ return pcre_get_stringnumber (match_info->regex->pcre_re, name);
+
+ /* This code is copied from pcre_get.c: get_first_set() */
+ entrysize = int_pcre_get_stringtable_entries (match_info->regex->pcre_re,
+ name,
+ &first,
+ &last);
+
+ if (entrysize <= 0)
+ return entrysize;
+
+ for (entry = (guchar*) first; entry <= (guchar*) last; entry += entrysize)
+ {
+ gint n = (entry[0] << 8) + entry[1];
+ if (match_info->offsets[n*2] >= 0)
+ return n;
+ }
+
+ return (first[0] << 8) + first[1];
+}
+
+/**
+ * g_match_info_fetch_named:
+ * @match_info: #GMatchInfo structure
+ * @name: name of the subexpression
+ *
+ * Retrieves the text matching the capturing parentheses named @name.
+ *
+ * If @name is a valid sub pattern name but it didn't match anything
+ * (e.g. sub pattern "X", matching "b" against "(?P<X>a)?b")
+ * then an empty string is returned.
+ *
+ * The string is fetched from the string passed to the match function,
+ * so you cannot call this function after freeing the string.
+ *
+ * Returns: The matched substring, or %NULL if an error occurred.
+ * You have to free the string yourself
+ *
+ * Since: 2.14
+ */
+gchar *
+g_match_info_fetch_named (const GMatchInfo *match_info,
+ const gchar *name)
+{
+ /* we cannot use pcre_get_named_substring() because it allocates the
+ * string using pcre_malloc(). */
+ gint num;
+
+ g_return_val_if_fail (match_info != NULL, NULL);
+ g_return_val_if_fail (name != NULL, NULL);
+
+ num = get_matched_substring_number (match_info, name);
+ if (num < 0)
+ return NULL;
+ else
+ return g_match_info_fetch (match_info, num);
+}
+
+/**
+ * g_match_info_fetch_named_pos:
+ * @match_info: #GMatchInfo structure
+ * @name: name of the subexpression
+ * @start_pos: pointer to location where to store the start position
+ * @end_pos: pointer to location where to store the end position
+ *
+ * Retrieves the position in bytes of the capturing parentheses named @name.
+ *
+ * If @name is a valid sub pattern name but it didn't match anything
+ * (e.g. sub pattern "X", matching "b" against "(?P<X>a)?b")
+ * then @start_pos and @end_pos are set to -1 and %TRUE is returned.
+ *
+ * Returns: %TRUE if the position was fetched, %FALSE otherwise. If
+ * the position cannot be fetched, @start_pos and @end_pos are left
+ * unchanged
+ *
+ * Since: 2.14
+ */
+gboolean
+g_match_info_fetch_named_pos (const GMatchInfo *match_info,
+ const gchar *name,
+ gint *start_pos,
+ gint *end_pos)
+{
+ gint num;
+
+ g_return_val_if_fail (match_info != NULL, FALSE);
+ g_return_val_if_fail (name != NULL, FALSE);
+
+ num = get_matched_substring_number (match_info, name);
+ if (num < 0)
+ return FALSE;
+
+ return g_match_info_fetch_pos (match_info, num, start_pos, end_pos);
+}
+
+/**
+ * g_match_info_fetch_all:
+ * @match_info: a #GMatchInfo structure
+ *
+ * Bundles up pointers to each of the matching substrings from a match
+ * and stores them in an array of gchar pointers. The first element in
+ * the returned array is the match number 0, i.e. the entire matched
+ * text.
+ *
+ * If a sub pattern didn't match anything (e.g. sub pattern 1, matching
+ * "b" against "(a)?b") then an empty string is inserted.
+ *
+ * If the last match was obtained using the DFA algorithm, that is using
+ * g_regex_match_all() or g_regex_match_all_full(), the retrieved
+ * strings are not that matched by sets of parentheses but that of the
+ * matched substring. Substrings are matched in reverse order of length,
+ * so the first one is the longest match.
+ *
+ * The strings are fetched from the string passed to the match function,
+ * so you cannot call this function after freeing the string.
+ *
+ * Returns: a %NULL-terminated array of gchar * pointers. It must be
+ * freed using g_strfreev(). If the previous match failed %NULL is
+ * returned
+ *
+ * Since: 2.14
+ */
+gchar **
+g_match_info_fetch_all (const GMatchInfo *match_info)
+{
+ /* we cannot use pcre_get_substring_list() because the returned value
+ * isn't suitable for g_strfreev(). */
+ gchar **result;
+ gint i;
+
+ g_return_val_if_fail (match_info != NULL, NULL);
+
+ if (match_info->matches < 0)
+ return NULL;
+
+ result = g_new (gchar *, match_info->matches + 1);
+ for (i = 0; i < match_info->matches; i++)
+ result[i] = g_match_info_fetch (match_info, i);
+ result[i] = NULL;
+
+ return result;
+}
+
+
+/* GRegex */
+
+GQuark
+g_regex_error_quark (void)
+{
+ static GQuark error_quark = 0;
+
+ if (error_quark == 0)
+ error_quark = g_quark_from_static_string ("g-regex-error-quark");
+
+ return error_quark;
+}
+
+/**
+ * g_regex_ref:
+ * @regex: a #GRegex
+ *
+ * Increases reference count of @regex by 1.
+ *
+ * Returns: @regex
+ *
+ * Since: 2.14
+ */
+GRegex *
+g_regex_ref (GRegex *regex)
+{
+ g_return_val_if_fail (regex != NULL, NULL);
+ g_atomic_int_inc (®ex->ref_count);
+ return regex;
+}
+
+/**
+ * g_regex_unref:
+ * @regex: a #GRegex
+ *
+ * Decreases reference count of @regex by 1. When reference count drops
+ * to zero, it frees all the memory associated with the regex structure.
+ *
+ * Since: 2.14
+ */
+void
+g_regex_unref (GRegex *regex)
+{
+ g_return_if_fail (regex != NULL);
+
+ if (g_atomic_int_exchange_and_add (®ex->ref_count, -1) - 1 == 0)
+ {
+ g_free (regex->pattern);
+ if (regex->pcre_re != NULL)
+ pcre_free (regex->pcre_re);
+ if (regex->extra != NULL)
+ pcre_free (regex->extra);
+ g_free (regex);
+ }
+}
+
+/**
+ * g_regex_new:
+ * @pattern: the regular expression
+ * @compile_options: compile options for the regular expression, or 0
+ * @match_options: match options for the regular expression, or 0
+ * @error: return location for a #GError
+ *
+ * Compiles the regular expression to an internal form, and does
+ * the initial setup of the #GRegex structure.
+ *
+ * Returns: a #GRegex structure. Call g_regex_unref() when you
+ * are done with it
+ *
+ * Since: 2.14
+ */
+GRegex *
+g_regex_new (const gchar *pattern,
+ GRegexCompileFlags compile_options,
+ GRegexMatchFlags match_options,
+ GError **error)
+{
+ GRegex *regex;
+ pcre *re;
+ const gchar *errmsg;
+ gint erroffset;
+ gint errcode;
+ gboolean optimize = FALSE;
+ static gboolean initialized = FALSE;
+ unsigned long int pcre_compile_options;
+
+ g_return_val_if_fail (pattern != NULL, NULL);
+ g_return_val_if_fail (error == NULL || *error == NULL, NULL);
+ g_return_val_if_fail ((compile_options & ~G_REGEX_COMPILE_MASK) == 0, NULL);
+ g_return_val_if_fail ((match_options & ~G_REGEX_MATCH_MASK) == 0, NULL);
+
+ if (!initialized)
+ {
+ gint support;
+ const gchar *msg;
+
+ pcre_config (PCRE_CONFIG_UTF8, &support);
+ if (!support)
+ {
+ msg = "PCRE library is compiled without UTF8 support";
+ g_critical ("%s", msg);
+ g_set_error (error, G_REGEX_ERROR, G_REGEX_ERROR_COMPILE, msg);
+ return NULL;
+ }
+
+ pcre_config (PCRE_CONFIG_UNICODE_PROPERTIES, &support);
+ if (!support)
+ {
+ msg = "PCRE library is compiled without UTF8 properties support";
+ g_critical ("%s", msg);
+ g_set_error (error, G_REGEX_ERROR, G_REGEX_ERROR_COMPILE, msg);
+ return NULL;
+ }
+
+ initialized = TRUE;
+ }
+
+ /* G_REGEX_OPTIMIZE has the same numeric value of PCRE_NO_UTF8_CHECK,
+ * as we do not need to wrap PCRE_NO_UTF8_CHECK. */
+ if (compile_options & G_REGEX_OPTIMIZE)
+ optimize = TRUE;
+
+ /* In GRegex the string are, by default, UTF-8 encoded. PCRE
+ * instead uses UTF-8 only if required with PCRE_UTF8. */
+ if (compile_options & G_REGEX_RAW)
+ {
+ /* disable utf-8 */
+ compile_options &= ~G_REGEX_RAW;
+ }
+ else
+ {
+ /* enable utf-8 */
+ compile_options |= PCRE_UTF8 | PCRE_NO_UTF8_CHECK;
+ match_options |= PCRE_NO_UTF8_CHECK;
+ }
+
+ /* PCRE_NEWLINE_ANY is the default for the internal PCRE but
+ * not for the system one. */
+
+ /* compile the pattern */
+ re = pcre_compile2 (pattern, compile_options, &errcode,
+ &errmsg, &erroffset, NULL);
+
+ /* if the compilation failed, set the error member and return
+ * immediately */
+ if (re == NULL)
+ {
+ GError *tmp_error;
+
+ /* Translate the PCRE error code to GRegexError and use a translated
+ * error message if possible */
+ translate_compile_error (&errcode, &errmsg);
+
+ /* PCRE uses byte offsets but we want to show character offsets */
+ erroffset = g_utf8_pointer_to_offset (pattern, &pattern[erroffset]);
+
+ tmp_error = g_error_new (G_REGEX_ERROR, errcode,
+ "Error while compiling regular "
+ "expression %s at char %d: %s",
+ pattern, erroffset, errmsg);
+ g_propagate_error (error, tmp_error);
+
+ return NULL;
+ }
+
+ /* For options set at the beginning of the pattern, pcre puts them into
+ * compile options, e.g. "(?i)foo" will make the pcre structure store
+ * PCRE_CASELESS even though it wasn't explicitly given for compilation. */
+ pcre_fullinfo (re, NULL, PCRE_INFO_OPTIONS, &pcre_compile_options);
+ compile_options = pcre_compile_options;
+
+ regex = g_new0 (GRegex, 1);
+ regex->ref_count = 1;
+ regex->pattern = g_strdup (pattern);
+ regex->pcre_re = re;
+ regex->compile_opts = compile_options;
+ regex->match_opts = match_options;
+
+ if (optimize)
+ {
+ regex->extra = pcre_study (regex->pcre_re, 0, &errmsg);
+ if (errmsg != NULL)
+ {
+ GError *tmp_error = g_error_new (G_REGEX_ERROR,
+ G_REGEX_ERROR_OPTIMIZE,
+ "Error while optimizing "
+ "regular expression %s: %s",
+ regex->pattern,
+ errmsg);
+ g_propagate_error (error, tmp_error);
+
+ g_regex_unref (regex);
+ return NULL;
+ }
+ }
+
+ return regex;
+}
+
+/**
+ * g_regex_get_pattern:
+ * @regex: a #GRegex structure
+ *
+ * Gets the pattern string associated with @regex, i.e. a copy of
+ * the string passed to g_regex_new().
+ *
+ * Returns: the pattern of @regex
+ *
+ * Since: 2.14
+ */
+const gchar *
+g_regex_get_pattern (const GRegex *regex)
+{
+ g_return_val_if_fail (regex != NULL, NULL);
+
+ return regex->pattern;
+}
+
+/**
+ * g_regex_get_max_backref:
+ * @regex: a #GRegex
+ *
+ * Returns the number of the highest back reference
+ * in the pattern, or 0 if the pattern does not contain
+ * back references.
+ *
+ * Returns: the number of the highest back reference
+ *
+ * Since: 2.14
+ */
+gint
+g_regex_get_max_backref (const GRegex *regex)
+{
+ gint value;
+
+ pcre_fullinfo (regex->pcre_re, regex->extra,
+ PCRE_INFO_BACKREFMAX, &value);
+
+ return value;
+}
+
+/**
+ * g_regex_get_capture_count:
+ * @regex: a #GRegex
+ *
+ * Returns the number of capturing subpatterns in the pattern.
+ *
+ * Returns: the number of capturing subpatterns
+ *
+ * Since: 2.14
+ */
+gint
+g_regex_get_capture_count (const GRegex *regex)
+{
+ gint value;
+
+ pcre_fullinfo (regex->pcre_re, regex->extra,
+ PCRE_INFO_CAPTURECOUNT, &value);
+
+ return value;
+}
+
+/**
+ * g_regex_match_simple:
+ * @pattern: the regular expression
+ * @string: the string to scan for matches
+ * @compile_options: compile options for the regular expression, or 0
+ * @match_options: match options, or 0
+ *
+ * Scans for a match in @string for @pattern.
+ *
+ * This function is equivalent to g_regex_match() but it does not
+ * require to compile the pattern with g_regex_new(), avoiding some
+ * lines of code when you need just to do a match without extracting
+ * substrings, capture counts, and so on.
+ *
+ * If this function is to be called on the same @pattern more than
+ * once, it's more efficient to compile the pattern once with
+ * g_regex_new() and then use g_regex_match().
+ *
+ * Returns: %TRUE if the string matched, %FALSE otherwise
+ *
+ * Since: 2.14
+ */
+gboolean
+g_regex_match_simple (const gchar *pattern,
+ const gchar *string,
+ GRegexCompileFlags compile_options,
+ GRegexMatchFlags match_options)
+{
+ GRegex *regex;
+ gboolean result;
+
+ regex = g_regex_new (pattern, compile_options, 0, NULL);
+ if (!regex)
+ return FALSE;
+ result = g_regex_match_full (regex, string, -1, 0, match_options, NULL, NULL);
+ g_regex_unref (regex);
+ return result;
+}
+
+/**
+ * g_regex_match:
+ * @regex: a #GRegex structure from g_regex_new()
+ * @string: the string to scan for matches
+ * @match_options: match options
+ * @match_info: pointer to location where to store the #GMatchInfo,
+ * or %NULL if you do not need it
+ *
+ * Scans for a match in string for the pattern in @regex.
+ * The @match_options are combined with the match options specified
+ * when the @regex structure was created, letting you have more
+ * flexibility in reusing #GRegex structures.
+ *
+ * A #GMatchInfo structure, used to get information on the match,
+ * is stored in @match_info if not %NULL. Note that if @match_info
+ * is not %NULL then it is created even if the function returns %FALSE,
+ * i.e. you must free it regardless if regular expression actually matched.
+ *
+ * To retrieve all the non-overlapping matches of the pattern in
+ * string you can use g_match_info_next().
+ *
+ * |[
+ * static void
+ * print_uppercase_words (const gchar *string)
+ * {
+ * /* Print all uppercase-only words. */
+ * GRegex *regex;
+ * GMatchInfo *match_info;
+ *
+ * regex = g_regex_new ("[A-Z]+", 0, 0, NULL);
+ * g_regex_match (regex, string, 0, &match_info);
+ * while (g_match_info_matches (match_info))
+ * {
+ * gchar *word = g_match_info_fetch (match_info, 0);
+ * g_print ("Found: %s\n", word);
+ * g_free (word);
+ * g_match_info_next (match_info, NULL);
+ * }
+ * g_match_info_free (match_info);
+ * g_regex_unref (regex);
+ * }
+ * ]|
+ *
+ * @string is not copied and is used in #GMatchInfo internally. If
+ * you use any #GMatchInfo method (except g_match_info_free()) after
+ * freeing or modifying @string then the behaviour is undefined.
+ *
+ * Returns: %TRUE is the string matched, %FALSE otherwise
+ *
+ * Since: 2.14
+ */
+gboolean
+g_regex_match (const GRegex *regex,
+ const gchar *string,
+ GRegexMatchFlags match_options,
+ GMatchInfo **match_info)
+{
+ return g_regex_match_full (regex, string, -1, 0, match_options,
+ match_info, NULL);
+}
+
+/**
+ * g_regex_match_full:
+ * @regex: a #GRegex structure from g_regex_new()
+ * @string: the string to scan for matches
+ * @string_len: the length of @string, or -1 if @string is nul-terminated
+ * @start_position: starting index of the string to match
+ * @match_options: match options
+ * @match_info: pointer to location where to store the #GMatchInfo,
+ * or %NULL if you do not need it
+ * @error: location to store the error occuring, or %NULL to ignore errors
+ *
+ * Scans for a match in string for the pattern in @regex.
+ * The @match_options are combined with the match options specified
+ * when the @regex structure was created, letting you have more
+ * flexibility in reusing #GRegex structures.
+ *
+ * Setting @start_position differs from just passing over a shortened
+ * string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern
+ * that begins with any kind of lookbehind assertion, such as "\b".
+ *
+ * A #GMatchInfo structure, used to get information on the match, is
+ * stored in @match_info if not %NULL. Note that if @match_info is
+ * not %NULL then it is created even if the function returns %FALSE,
+ * i.e. you must free it regardless if regular expression actually
+ * matched.
+ *
+ * @string is not copied and is used in #GMatchInfo internally. If
+ * you use any #GMatchInfo method (except g_match_info_free()) after
+ * freeing or modifying @string then the behaviour is undefined.
+ *
+ * To retrieve all the non-overlapping matches of the pattern in
+ * string you can use g_match_info_next().
+ *
+ * |[
+ * static void
+ * print_uppercase_words (const gchar *string)
+ * {
+ * /* Print all uppercase-only words. */
+ * GRegex *regex;
+ * GMatchInfo *match_info;
+ * GError *error = NULL;
+ *
+ * regex = g_regex_new ("[A-Z]+", 0, 0, NULL);
+ * g_regex_match_full (regex, string, -1, 0, 0, &match_info, &error);
+ * while (g_match_info_matches (match_info))
+ * {
+ * gchar *word = g_match_info_fetch (match_info, 0);
+ * g_print ("Found: %s\n", word);
+ * g_free (word);
+ * g_match_info_next (match_info, &error);
+ * }
+ * g_match_info_free (match_info);
+ * g_regex_unref (regex);
+ * if (error != NULL)
+ * {
+ * g_printerr ("Error while matching: %s\n", error->message);
+ * g_error_free (error);
+ * }
+ * }
+ * ]|
+ *
+ * Returns: %TRUE is the string matched, %FALSE otherwise
+ *
+ * Since: 2.14
+ */
+gboolean
+g_regex_match_full (const GRegex *regex,
+ const gchar *string,
+ gssize string_len,
+ gint start_position,
+ GRegexMatchFlags match_options,
+ GMatchInfo **match_info,
+ GError **error)
+{
+ GMatchInfo *info;
+ gboolean match_ok;
+
+ g_return_val_if_fail (regex != NULL, FALSE);
+ g_return_val_if_fail (string != NULL, FALSE);
+ g_return_val_if_fail (start_position >= 0, FALSE);
+ g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+ g_return_val_if_fail ((match_options & ~G_REGEX_MATCH_MASK) == 0, FALSE);
+
+ info = match_info_new (regex, string, string_len, start_position,
+ match_options, FALSE);
+ match_ok = g_match_info_next (info, error);
+ if (match_info != NULL)
+ *match_info = info;
+ else
+ g_match_info_free (info);
+
+ return match_ok;
+}
+
+/**
+ * g_regex_match_all:
+ * @regex: a #GRegex structure from g_regex_new()
+ * @string: the string to scan for matches
+ * @match_options: match options
+ * @match_info: pointer to location where to store the #GMatchInfo,
+ * or %NULL if you do not need it
+ *
+ * Using the standard algorithm for regular expression matching only
+ * the longest match in the string is retrieved. This function uses
+ * a different algorithm so it can retrieve all the possible matches.
+ * For more documentation see g_regex_match_all_full().
+ *
+ * A #GMatchInfo structure, used to get information on the match, is
+ * stored in @match_info if not %NULL. Note that if @match_info is
+ * not %NULL then it is created even if the function returns %FALSE,
+ * i.e. you must free it regardless if regular expression actually
+ * matched.
+ *
+ * @string is not copied and is used in #GMatchInfo internally. If
+ * you use any #GMatchInfo method (except g_match_info_free()) after
+ * freeing or modifying @string then the behaviour is undefined.
+ *
+ * Returns: %TRUE is the string matched, %FALSE otherwise
+ *
+ * Since: 2.14
+ */
+gboolean
+g_regex_match_all (const GRegex *regex,
+ const gchar *string,
+ GRegexMatchFlags match_options,
+ GMatchInfo **match_info)
+{
+ return g_regex_match_all_full (regex, string, -1, 0, match_options,
+ match_info, NULL);
+}
+
+/**
+ * g_regex_match_all_full:
+ * @regex: a #GRegex structure from g_regex_new()
+ * @string: the string to scan for matches
+ * @string_len: the length of @string, or -1 if @string is nul-terminated
+ * @start_position: starting index of the string to match
+ * @match_options: match options
+ * @match_info: pointer to location where to store the #GMatchInfo,
+ * or %NULL if you do not need it
+ * @error: location to store the error occuring, or %NULL to ignore errors
+ *
+ * Using the standard algorithm for regular expression matching only
+ * the longest match in the string is retrieved, it is not possibile
+ * to obtain all the available matches. For instance matching
+ * "<a> <b> <c>" against the pattern "<.*>"
+ * you get "<a> <b> <c>".
+ *
+ * This function uses a different algorithm (called DFA, i.e. deterministic
+ * finite automaton), so it can retrieve all the possible matches, all
+ * starting at the same point in the string. For instance matching
+ * "<a> <b> <c>" against the pattern "<.*>"
+ * you would obtain three matches: "<a> <b> <c>",
+ * "<a> <b>" and "<a>".
+ *
+ * The number of matched strings is retrieved using
+ * g_match_info_get_match_count(). To obtain the matched strings and
+ * their position you can use, respectively, g_match_info_fetch() and
+ * g_match_info_fetch_pos(). Note that the strings are returned in
+ * reverse order of length; that is, the longest matching string is
+ * given first.
+ *
+ * Note that the DFA algorithm is slower than the standard one and it
+ * is not able to capture substrings, so backreferences do not work.
+ *
+ * Setting @start_position differs from just passing over a shortened
+ * string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern
+ * that begins with any kind of lookbehind assertion, such as "\b".
+ *
+ * A #GMatchInfo structure, used to get information on the match, is
+ * stored in @match_info if not %NULL. Note that if @match_info is
+ * not %NULL then it is created even if the function returns %FALSE,
+ * i.e. you must free it regardless if regular expression actually
+ * matched.
+ *
+ * @string is not copied and is used in #GMatchInfo internally. If
+ * you use any #GMatchInfo method (except g_match_info_free()) after
+ * freeing or modifying @string then the behaviour is undefined.
+ *
+ * Returns: %TRUE is the string matched, %FALSE otherwise
+ *
+ * Since: 2.14
+ */
+gboolean
+g_regex_match_all_full (const GRegex *regex,
+ const gchar *string,
+ gssize string_len,
+ gint start_position,
+ GRegexMatchFlags match_options,
+ GMatchInfo **match_info,
+ GError **error)
+{
+ GMatchInfo *info;
+ gboolean done;
+
+ g_return_val_if_fail (regex != NULL, FALSE);
+ g_return_val_if_fail (string != NULL, FALSE);
+ g_return_val_if_fail (start_position >= 0, FALSE);
+ g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+ g_return_val_if_fail ((match_options & ~G_REGEX_MATCH_MASK) == 0, FALSE);
+
+ info = match_info_new (regex, string, string_len, start_position,
+ match_options, TRUE);
+
+ done = FALSE;
+ while (!done)
+ {
+ done = TRUE;
+ info->matches = pcre_dfa_exec (regex->pcre_re, regex->extra,
+ info->string, info->string_len,
+ info->pos,
+ regex->match_opts | match_options,
+ info->offsets, info->n_offsets,
+ info->workspace, info->n_workspace);
+ if (info->matches == PCRE_ERROR_DFA_WSSIZE)
+ {
+ /* info->workspace is too small. */
+ info->n_workspace *= 2;
+ info->workspace = g_realloc (info->workspace,
+ info->n_workspace * sizeof (gint));
+ done = FALSE;
+ }
+ else if (info->matches == 0)
+ {
+ /* info->offsets is too small. */
+ info->n_offsets *= 2;
+ info->offsets = g_realloc (info->offsets,
+ info->n_offsets * sizeof (gint));
+ done = FALSE;
+ }
+ else if (IS_PCRE_ERROR (info->matches))
+ {
+ g_set_error (error, G_REGEX_ERROR, G_REGEX_ERROR_MATCH,
+ "Error while matching regular expression %s: %s",
+ regex->pattern, match_error (info->matches));
+ }
+ }
+
+ /* set info->pos to -1 so that a call to g_match_info_next() fails. */
+ info->pos = -1;
+
+ if (match_info != NULL)
+ *match_info = info;
+ else
+ g_match_info_free (info);
+
+ return info->matches >= 0;
+}
+
+/**
+ * g_regex_get_string_number:
+ * @regex: #GRegex structure
+ * @name: name of the subexpression
+ *
+ * Retrieves the number of the subexpression named @name.
+ *
+ * Returns: The number of the subexpression or -1 if @name
+ * does not exists
+ *
+ * Since: 2.14
+ */
+gint
+g_regex_get_string_number (const GRegex *regex,
+ const gchar *name)
+{
+ gint num;
+
+ g_return_val_if_fail (regex != NULL, -1);
+ g_return_val_if_fail (name != NULL, -1);
+
+ num = pcre_get_stringnumber (regex->pcre_re, name);
+ if (num == PCRE_ERROR_NOSUBSTRING)
+ num = -1;
+
+ return num;
+}
+
+/**
+ * g_regex_split_simple:
+ * @pattern: the regular expression
+ * @string: the string to scan for matches
+ * @compile_options: compile options for the regular expression, or 0
+ * @match_options: match options, or 0
+ *
+ * Breaks the string on the pattern, and returns an array of
+ * the tokens. If the pattern contains capturing parentheses,
+ * then the text for each of the substrings will also be returned.
+ * If the pattern does not match anywhere in the string, then the
+ * whole string is returned as the first token.
+ *
+ * This function is equivalent to g_regex_split() but it does
+ * not require to compile the pattern with g_regex_new(), avoiding
+ * some lines of code when you need just to do a split without
+ * extracting substrings, capture counts, and so on.
+ *
+ * If this function is to be called on the same @pattern more than
+ * once, it's more efficient to compile the pattern once with
+ * g_regex_new() and then use g_regex_split().
+ *
+ * As a special case, the result of splitting the empty string ""
+ * is an empty vector, not a vector containing a single string.
+ * The reason for this special case is that being able to represent
+ * a empty vector is typically more useful than consistent handling
+ * of empty elements. If you do need to represent empty elements,
+ * you'll need to check for the empty string before calling this
+ * function.
+ *
+ * A pattern that can match empty strings splits @string into
+ * separate characters wherever it matches the empty string between
+ * characters. For example splitting "ab c" using as a separator
+ * "\s*", you will get "a", "b" and "c".
+ *
+ * Returns: a %NULL-terminated array of strings. Free it using g_strfreev()
+ *
+ * Since: 2.14
+ **/
+gchar **
+g_regex_split_simple (const gchar *pattern,
+ const gchar *string,
+ GRegexCompileFlags compile_options,
+ GRegexMatchFlags match_options)
+{
+ GRegex *regex;
+ gchar **result;
+
+ regex = g_regex_new (pattern, compile_options, 0, NULL);
+ if (!regex)
+ return NULL;
+ result = g_regex_split_full (regex, string, -1, 0, match_options, 0, NULL);
+ g_regex_unref (regex);
+ return result;
+}
+
+/**
+ * g_regex_split:
+ * @regex: a #GRegex structure
+ * @string: the string to split with the pattern
+ * @match_options: match time option flags
+ *
+ * Breaks the string on the pattern, and returns an array of the tokens.
+ * If the pattern contains capturing parentheses, then the text for each
+ * of the substrings will also be returned. If the pattern does not match
+ * anywhere in the string, then the whole string is returned as the first
+ * token.
+ *
+ * As a special case, the result of splitting the empty string "" is an
+ * empty vector, not a vector containing a single string. The reason for
+ * this special case is that being able to represent a empty vector is
+ * typically more useful than consistent handling of empty elements. If
+ * you do need to represent empty elements, you'll need to check for the
+ * empty string before calling this function.
+ *
+ * A pattern that can match empty strings splits @string into separate
+ * characters wherever it matches the empty string between characters.
+ * For example splitting "ab c" using as a separator "\s*", you will get
+ * "a", "b" and "c".
+ *
+ * Returns: a %NULL-terminated gchar ** array. Free it using g_strfreev()
+ *
+ * Since: 2.14
+ **/
+gchar **
+g_regex_split (const GRegex *regex,
+ const gchar *string,
+ GRegexMatchFlags match_options)
+{
+ return g_regex_split_full (regex, string, -1, 0,
+ match_options, 0, NULL);
+}
+
+/**
+ * g_regex_split_full:
+ * @regex: a #GRegex structure
+ * @string: the string to split with the pattern
+ * @string_len: the length of @string, or -1 if @string is nul-terminated
+ * @start_position: starting index of the string to match
+ * @match_options: match time option flags
+ * @max_tokens: the maximum number of tokens to split @string into.
+ * If this is less than 1, the string is split completely
+ * @error: return location for a #GError
+ *
+ * Breaks the string on the pattern, and returns an array of the tokens.
+ * If the pattern contains capturing parentheses, then the text for each
+ * of the substrings will also be returned. If the pattern does not match
+ * anywhere in the string, then the whole string is returned as the first
+ * token.
+ *
+ * As a special case, the result of splitting the empty string "" is an
+ * empty vector, not a vector containing a single string. The reason for
+ * this special case is that being able to represent a empty vector is
+ * typically more useful than consistent handling of empty elements. If
+ * you do need to represent empty elements, you'll need to check for the
+ * empty string before calling this function.
+ *
+ * A pattern that can match empty strings splits @string into separate
+ * characters wherever it matches the empty string between characters.
+ * For example splitting "ab c" using as a separator "\s*", you will get
+ * "a", "b" and "c".
+ *
+ * Setting @start_position differs from just passing over a shortened
+ * string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern
+ * that begins with any kind of lookbehind assertion, such as "\b".
+ *
+ * Returns: a %NULL-terminated gchar ** array. Free it using g_strfreev()
+ *
+ * Since: 2.14
+ **/
+gchar **
+g_regex_split_full (const GRegex *regex,
+ const gchar *string,
+ gssize string_len,
+ gint start_position,
+ GRegexMatchFlags match_options,
+ gint max_tokens,
+ GError **error)
+{
+ GError *tmp_error = NULL;
+ GMatchInfo *match_info;
+ GList *list, *last;
+ gint i;
+ gint token_count;
+ gboolean match_ok;
+ /* position of the last separator. */
+ gint last_separator_end;
+ /* was the last match 0 bytes long? */
+ gboolean last_match_is_empty;
+ /* the returned array of char **s */
+ gchar **string_list;
+
+ g_return_val_if_fail (regex != NULL, NULL);
+ g_return_val_if_fail (string != NULL, NULL);
+ g_return_val_if_fail (start_position >= 0, NULL);
+ g_return_val_if_fail (error == NULL || *error == NULL, NULL);
+ g_return_val_if_fail ((match_options & ~G_REGEX_MATCH_MASK) == 0, NULL);
+
+ if (max_tokens <= 0)
+ max_tokens = G_MAXINT;
+
+ if (string_len < 0)
+ string_len = strlen (string);
+
+ /* zero-length string */
+ if (string_len - start_position == 0)
+ return g_new0 (gchar *, 1);
+
+ if (max_tokens == 1)
+ {
+ string_list = g_new0 (gchar *, 2);
+ string_list[0] = g_strndup (&string[start_position],
+ string_len - start_position);
+ return string_list;
+ }
+
+ list = NULL;
+ token_count = 0;
+ last_separator_end = start_position;
+ last_match_is_empty = FALSE;
+
+ match_ok = g_regex_match_full (regex, string, string_len, start_position,
+ match_options, &match_info, &tmp_error);
+ while (tmp_error == NULL)
+ {
+ if (match_ok)
+ {
+ last_match_is_empty =
+ (match_info->offsets[0] == match_info->offsets[1]);
+
+ /* we need to skip empty separators at the same position of the end
+ * of another separator. e.g. the string is "a b" and the separator
+ * is " *", so from 1 to 2 we have a match and at position 2 we have
+ * an empty match. */
+ if (last_separator_end != match_info->offsets[1])
+ {
+ gchar *token;
+ gint match_count;
+
+ token = g_strndup (string + last_separator_end,
+ match_info->offsets[0] - last_separator_end);
+ list = g_list_prepend (list, token);
+ token_count++;
+
+ /* if there were substrings, these need to be added to
+ * the list. */
+ match_count = g_match_info_get_match_count (match_info);
+ if (match_count > 1)
+ {
+ for (i = 1; i < match_count; i++)
+ list = g_list_prepend (list, g_match_info_fetch (match_info, i));
+ }
+ }
+ }
+ else
+ {
+ /* if there was no match, copy to end of string. */
+ if (!last_match_is_empty)
+ {
+ gchar *token = g_strndup (string + last_separator_end,
+ match_info->string_len - last_separator_end);
+ list = g_list_prepend (list, token);
+ }
+ /* no more tokens, end the loop. */
+ break;
+ }
+
+ /* -1 to leave room for the last part. */
+ if (token_count >= max_tokens - 1)
+ {
+ /* we have reached the maximum number of tokens, so we copy
+ * the remaining part of the string. */
+ if (last_match_is_empty)
+ {
+ /* the last match was empty, so we have moved one char
+ * after the real position to avoid empty matches at the
+ * same position. */
+ match_info->pos = PREV_CHAR (regex, &string[match_info->pos]) - string;
+ }
+ /* the if is needed in the case we have terminated the available
+ * tokens, but we are at the end of the string, so there are no
+ * characters left to copy. */
+ if (string_len > match_info->pos)
+ {
+ gchar *token = g_strndup (string + match_info->pos,
+ string_len - match_info->pos);
+ list = g_list_prepend (list, token);
+ }
+ /* end the loop. */
+ break;
+ }
+
+ last_separator_end = match_info->pos;
+ if (last_match_is_empty)
+ /* if the last match was empty, g_match_info_next() has moved
+ * forward to avoid infinite loops, but we still need to copy that
+ * character. */
+ last_separator_end = PREV_CHAR (regex, &string[last_separator_end]) - string;
+
+ match_ok = g_match_info_next (match_info, &tmp_error);
+ }
+ g_match_info_free (match_info);
+ if (tmp_error != NULL)
+ {
+ g_propagate_error (error, tmp_error);
+ g_list_foreach (list, (GFunc)g_free, NULL);
+ g_list_free (list);
+ match_info->pos = -1;
+ return NULL;
+ }
+
+ string_list = g_new (gchar *, g_list_length (list) + 1);
+ i = 0;
+ for (last = g_list_last (list); last; last = g_list_previous (last))
+ string_list[i++] = last->data;
+ string_list[i] = NULL;
+ g_list_free (list);
+
+ return string_list;
+}
+
+enum
+{
+ REPL_TYPE_STRING,
+ REPL_TYPE_CHARACTER,
+ REPL_TYPE_SYMBOLIC_REFERENCE,
+ REPL_TYPE_NUMERIC_REFERENCE,
+ REPL_TYPE_CHANGE_CASE
+};
+
+typedef enum
+{
+ CHANGE_CASE_NONE = 1 << 0,
+ CHANGE_CASE_UPPER = 1 << 1,
+ CHANGE_CASE_LOWER = 1 << 2,
+ CHANGE_CASE_UPPER_SINGLE = 1 << 3,
+ CHANGE_CASE_LOWER_SINGLE = 1 << 4,
+ CHANGE_CASE_SINGLE_MASK = CHANGE_CASE_UPPER_SINGLE | CHANGE_CASE_LOWER_SINGLE,
+ CHANGE_CASE_LOWER_MASK = CHANGE_CASE_LOWER | CHANGE_CASE_LOWER_SINGLE,
+ CHANGE_CASE_UPPER_MASK = CHANGE_CASE_UPPER | CHANGE_CASE_UPPER_SINGLE
+} ChangeCase;
+
+struct _InterpolationData
+{
+ gchar *text;
+ gint type;
+ gint num;
+ gchar c;
+ ChangeCase change_case;
+};
+
+static void
+free_interpolation_data (InterpolationData *data)
+{
+ g_free (data->text);
+ g_free (data);
+}
+
+static const gchar *
+expand_escape (const gchar *replacement,
+ const gchar *p,
+ InterpolationData *data,
+ GError **error)
+{
+ const gchar *q, *r;
+ gint x, d, h, i;
+ const gchar *error_detail;
+ gint base = 0;
+ GError *tmp_error = NULL;
+
+ p++;
+ switch (*p)
+ {
+ case 't':
+ p++;
+ data->c = '\t';
+ data->type = REPL_TYPE_CHARACTER;
+ break;
+ case 'n':
+ p++;
+ data->c = '\n';
+ data->type = REPL_TYPE_CHARACTER;
+ break;
+ case 'v':
+ p++;
+ data->c = '\v';
+ data->type = REPL_TYPE_CHARACTER;
+ break;
+ case 'r':
+ p++;
+ data->c = '\r';
+ data->type = REPL_TYPE_CHARACTER;
+ break;
+ case 'f':
+ p++;
+ data->c = '\f';
+ data->type = REPL_TYPE_CHARACTER;
+ break;
+ case 'a':
+ p++;
+ data->c = '\a';
+ data->type = REPL_TYPE_CHARACTER;
+ break;
+ case 'b':
+ p++;
+ data->c = '\b';
+ data->type = REPL_TYPE_CHARACTER;
+ break;
+ case '\\':
+ p++;
+ data->c = '\\';
+ data->type = REPL_TYPE_CHARACTER;
+ break;
+ case 'x':
+ p++;
+ x = 0;
+ if (*p == '{')
+ {
+ p++;
+ do
+ {
+ h = g_ascii_xdigit_value (*p);
+ if (h < 0)
+ {
+ error_detail = "hexadecimal digit or '}' expected";
+ goto error;
+ }
+ x = x * 16 + h;
+ p++;
+ }
+ while (*p != '}');
+ p++;
+ }
+ else
+ {
+ for (i = 0; i < 2; i++)
+ {
+ h = g_ascii_xdigit_value (*p);
+ if (h < 0)
+ {
+ error_detail = "hexadecimal digit expected";
+ goto error;
+ }
+ x = x * 16 + h;
+ p++;
+ }
+ }
+ data->type = REPL_TYPE_STRING;
+ data->text = g_new0 (gchar, 8);
+ g_unichar_to_utf8 (x, data->text);
+ break;
+ case 'l':
+ p++;
+ data->type = REPL_TYPE_CHANGE_CASE;
+ data->change_case = CHANGE_CASE_LOWER_SINGLE;
+ break;
+ case 'u':
+ p++;
+ data->type = REPL_TYPE_CHANGE_CASE;
+ data->change_case = CHANGE_CASE_UPPER_SINGLE;
+ break;
+ case 'L':
+ p++;
+ data->type = REPL_TYPE_CHANGE_CASE;
+ data->change_case = CHANGE_CASE_LOWER;
+ break;
+ case 'U':
+ p++;
+ data->type = REPL_TYPE_CHANGE_CASE;
+ data->change_case = CHANGE_CASE_UPPER;
+ break;
+ case 'E':
+ p++;
+ data->type = REPL_TYPE_CHANGE_CASE;
+ data->change_case = CHANGE_CASE_NONE;
+ break;
+ case 'g':
+ p++;
+ if (*p != '<')
+ {
+ error_detail = "missing '<' in symbolic reference";
+ goto error;
+ }
+ q = p + 1;
+ do
+ {
+ p++;
+ if (!*p)
+ {
+ error_detail = "unfinished symbolic reference";
+ goto error;
+ }
+ }
+ while (*p != '>');
+ if (p - q == 0)
+ {
+ error_detail = "zero-length symbolic reference";
+ goto error;
+ }
+ if (g_ascii_isdigit (*q))
+ {
+ x = 0;
+ do
+ {
+ h = g_ascii_digit_value (*q);
+ if (h < 0)
+ {
+ error_detail = "digit expected";
+ p = q;
+ goto error;
+ }
+ x = x * 10 + h;
+ q++;
+ }
+ while (q != p);
+ data->num = x;
+ data->type = REPL_TYPE_NUMERIC_REFERENCE;
+ }
+ else
+ {
+ r = q;
+ do
+ {
+ if (!g_ascii_isalnum (*r))
+ {
+ error_detail = "illegal symbolic reference";
+ p = r;
+ goto error;
+ }
+ r++;
+ }
+ while (r != p);
+ data->text = g_strndup (q, p - q);
+ data->type = REPL_TYPE_SYMBOLIC_REFERENCE;
+ }
+ p++;
+ break;
+ case '0':
+ /* if \0 is followed by a number is an octal number representing a
+ * character, else it is a numeric reference. */
+ if (g_ascii_digit_value (*g_utf8_next_char (p)) >= 0)
+ {
+ base = 8;
+ p = g_utf8_next_char (p);
+ }
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ x = 0;
+ d = 0;
+ for (i = 0; i < 3; i++)
+ {
+ h = g_ascii_digit_value (*p);
+ if (h < 0)
+ break;
+ if (h > 7)
+ {
+ if (base == 8)
+ break;
+ else
+ base = 10;
+ }
+ if (i == 2 && base == 10)
+ break;
+ x = x * 8 + h;
+ d = d * 10 + h;
+ p++;
+ }
+ if (base == 8 || i == 3)
+ {
+ data->type = REPL_TYPE_STRING;
+ data->text = g_new0 (gchar, 8);
+ g_unichar_to_utf8 (x, data->text);
+ }
+ else
+ {
+ data->type = REPL_TYPE_NUMERIC_REFERENCE;
+ data->num = d;
+ }
+ break;
+ case 0:
+ error_detail = "stray final '\\'";
+ goto error;
+ break;
+ default:
+ error_detail = "unknown escape sequence";
+ goto error;
+ }
+
+ return p;
+
+ error:
+ /* G_GSSIZE_FORMAT doesn't work with gettext, so we use %lu */
+ tmp_error = g_error_new (G_REGEX_ERROR,
+ G_REGEX_ERROR_REPLACE,
+ "Error while parsing replacement "
+ "text \"%s\" at char %lu: %s",
+ replacement,
+ (gulong)(p - replacement),
+ error_detail);
+ g_propagate_error (error, tmp_error);
+
+ return NULL;
+}
+
+static GList *
+split_replacement (const gchar *replacement,
+ GError **error)
+{
+ GList *list = NULL;
+ InterpolationData *data;
+ const gchar *p, *start;
+
+ start = p = replacement;
+ while (*p)
+ {
+ if (*p == '\\')
+ {
+ data = g_new0 (InterpolationData, 1);
+ start = p = expand_escape (replacement, p, data, error);
+ if (p == NULL)
+ {
+ g_list_foreach (list, (GFunc)free_interpolation_data, NULL);
+ g_list_free (list);
+ free_interpolation_data (data);
+
+ return NULL;
+ }
+ list = g_list_prepend (list, data);
+ }
+ else
+ {
+ p++;
+ if (*p == '\\' || *p == '\0')
+ {
+ if (p - start > 0)
+ {
+ data = g_new0 (InterpolationData, 1);
+ data->text = g_strndup (start, p - start);
+ data->type = REPL_TYPE_STRING;
+ list = g_list_prepend (list, data);
+ }
+ }
+ }
+ }
+
+ return g_list_reverse (list);
+}
+
+/* Change the case of c based on change_case. */
+#define CHANGE_CASE(c, change_case) \
+ (((change_case) & CHANGE_CASE_LOWER_MASK) ? \
+ g_unichar_tolower (c) : \
+ g_unichar_toupper (c))
+
+static void
+string_append (GString *string,
+ const gchar *text,
+ ChangeCase *change_case)
+{
+ gunichar c;
+
+ if (text[0] == '\0')
+ return;
+
+ if (*change_case == CHANGE_CASE_NONE)
+ {
+ g_string_append (string, text);
+ }
+ else if (*change_case & CHANGE_CASE_SINGLE_MASK)
+ {
+ c = g_utf8_get_char (text);
+ g_string_append_unichar (string, CHANGE_CASE (c, *change_case));
+ g_string_append (string, g_utf8_next_char (text));
+ *change_case = CHANGE_CASE_NONE;
+ }
+ else
+ {
+ while (*text != '\0')
+ {
+ c = g_utf8_get_char (text);
+ g_string_append_unichar (string, CHANGE_CASE (c, *change_case));
+ text = g_utf8_next_char (text);
+ }
+ }
+}
+
+static gboolean
+interpolate_replacement (const GMatchInfo *match_info,
+ GString *result,
+ gpointer data)
+{
+ GList *list;
+ InterpolationData *idata;
+ gchar *match;
+ ChangeCase change_case = CHANGE_CASE_NONE;
+
+ for (list = data; list; list = list->next)
+ {
+ idata = list->data;
+ switch (idata->type)
+ {
+ case REPL_TYPE_STRING:
+ string_append (result, idata->text, &change_case);
+ break;
+ case REPL_TYPE_CHARACTER:
+ g_string_append_c (result, CHANGE_CASE (idata->c, change_case));
+ if (change_case & CHANGE_CASE_SINGLE_MASK)
+ change_case = CHANGE_CASE_NONE;
+ break;
+ case REPL_TYPE_NUMERIC_REFERENCE:
+ match = g_match_info_fetch (match_info, idata->num);
+ if (match)
+ {
+ string_append (result, match, &change_case);
+ g_free (match);
+ }
+ break;
+ case REPL_TYPE_SYMBOLIC_REFERENCE:
+ match = g_match_info_fetch_named (match_info, idata->text);
+ if (match)
+ {
+ string_append (result, match, &change_case);
+ g_free (match);
+ }
+ break;
+ case REPL_TYPE_CHANGE_CASE:
+ change_case = idata->change_case;
+ break;
+ }
+ }
+
+ return FALSE;
+}
+
+/* whether actual match_info is needed for replacement, i.e.
+ * whether there are references
+ */
+static gboolean
+interpolation_list_needs_match (GList *list)
+{
+ while (list != NULL)
+ {
+ InterpolationData *data = list->data;
+
+ if (data->type == REPL_TYPE_SYMBOLIC_REFERENCE ||
+ data->type == REPL_TYPE_NUMERIC_REFERENCE)
+ {
+ return TRUE;
+ }
+
+ list = list->next;
+ }
+
+ return FALSE;
+}
+
+/**
+ * g_regex_replace:
+ * @regex: a #GRegex structure
+ * @string: the string to perform matches against
+ * @string_len: the length of @string, or -1 if @string is nul-terminated
+ * @start_position: starting index of the string to match
+ * @replacement: text to replace each match with
+ * @match_options: options for the match
+ * @error: location to store the error occuring, or %NULL to ignore errors
+ *
+ * Replaces all occurrences of the pattern in @regex with the
+ * replacement text. Backreferences of the form '\number' or
+ * '\g<number>' in the replacement text are interpolated by the
+ * number-th captured subexpression of the match, '\g<name>' refers
+ * to the captured subexpression with the given name. '\0' refers to the
+ * complete match, but '\0' followed by a number is the octal representation
+ * of a character. To include a literal '\' in the replacement, write '\\'.
+ * There are also escapes that changes the case of the following text:
+ *
+ * <variablelist>
+ * <varlistentry><term>\l</term>
+ * <listitem>
+ * <para>Convert to lower case the next character</para>
+ * </listitem>
+ * </varlistentry>
+ * <varlistentry><term>\u</term>
+ * <listitem>
+ * <para>Convert to upper case the next character</para>
+ * </listitem>
+ * </varlistentry>
+ * <varlistentry><term>\L</term>
+ * <listitem>
+ * <para>Convert to lower case till \E</para>
+ * </listitem>
+ * </varlistentry>
+ * <varlistentry><term>\U</term>
+ * <listitem>
+ * <para>Convert to upper case till \E</para>
+ * </listitem>
+ * </varlistentry>
+ * <varlistentry><term>\E</term>
+ * <listitem>
+ * <para>End case modification</para>
+ * </listitem>
+ * </varlistentry>
+ * </variablelist>
+ *
+ * If you do not need to use backreferences use g_regex_replace_literal().
+ *
+ * The @replacement string must be UTF-8 encoded even if #G_REGEX_RAW was
+ * passed to g_regex_new(). If you want to use not UTF-8 encoded stings
+ * you can use g_regex_replace_literal().
+ *
+ * Setting @start_position differs from just passing over a shortened
+ * string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern that
+ * begins with any kind of lookbehind assertion, such as "\b".
+ *
+ * Returns: a newly allocated string containing the replacements
+ *
+ * Since: 2.14
+ */
+gchar *
+g_regex_replace (const GRegex *regex,
+ const gchar *string,
+ gssize string_len,
+ gint start_position,
+ const gchar *replacement,
+ GRegexMatchFlags match_options,
+ GError **error)
+{
+ gchar *result;
+ GList *list;
+ GError *tmp_error = NULL;
+
+ g_return_val_if_fail (regex != NULL, NULL);
+ g_return_val_if_fail (string != NULL, NULL);
+ g_return_val_if_fail (start_position >= 0, NULL);
+ g_return_val_if_fail (replacement != NULL, NULL);
+ g_return_val_if_fail (error == NULL || *error == NULL, NULL);
+ g_return_val_if_fail ((match_options & ~G_REGEX_MATCH_MASK) == 0, NULL);
+
+ list = split_replacement (replacement, &tmp_error);
+ if (tmp_error != NULL)
+ {
+ g_propagate_error (error, tmp_error);
+ return NULL;
+ }
+
+ result = g_regex_replace_eval (regex,
+ string, string_len, start_position,
+ match_options,
+ interpolate_replacement,
+ (gpointer)list,
+ &tmp_error);
+ if (tmp_error != NULL)
+ g_propagate_error (error, tmp_error);
+
+ g_list_foreach (list, (GFunc)free_interpolation_data, NULL);
+ g_list_free (list);
+
+ return result;
+}
+
+static gboolean
+literal_replacement (const GMatchInfo *match_info,
+ GString *result,
+ gpointer data)
+{
+ g_string_append (result, data);
+ return FALSE;
+}
+
+/**
+ * g_regex_replace_literal:
+ * @regex: a #GRegex structure
+ * @string: the string to perform matches against
+ * @string_len: the length of @string, or -1 if @string is nul-terminated
+ * @start_position: starting index of the string to match
+ * @replacement: text to replace each match with
+ * @match_options: options for the match
+ * @error: location to store the error occuring, or %NULL to ignore errors
+ *
+ * Replaces all occurrences of the pattern in @regex with the
+ * replacement text. @replacement is replaced literally, to
+ * include backreferences use g_regex_replace().
+ *
+ * Setting @start_position differs from just passing over a
+ * shortened string and setting #G_REGEX_MATCH_NOTBOL in the
+ * case of a pattern that begins with any kind of lookbehind
+ * assertion, such as "\b".
+ *
+ * Returns: a newly allocated string containing the replacements
+ *
+ * Since: 2.14
+ */
+gchar *
+g_regex_replace_literal (const GRegex *regex,
+ const gchar *string,
+ gssize string_len,
+ gint start_position,
+ const gchar *replacement,
+ GRegexMatchFlags match_options,
+ GError **error)
+{
+ g_return_val_if_fail (replacement != NULL, NULL);
+ g_return_val_if_fail ((match_options & ~G_REGEX_MATCH_MASK) == 0, NULL);
+
+ return g_regex_replace_eval (regex,
+ string, string_len, start_position,
+ match_options,
+ literal_replacement,
+ (gpointer)replacement,
+ error);
+}
+
+/**
+ * g_regex_replace_eval:
+ * @regex: a #GRegex structure from g_regex_new()
+ * @string: string to perform matches against
+ * @string_len: the length of @string, or -1 if @string is nul-terminated
+ * @start_position: starting index of the string to match
+ * @match_options: options for the match
+ * @eval: a function to call for each match
+ * @user_data: user data to pass to the function
+ * @error: location to store the error occuring, or %NULL to ignore errors
+ *
+ * Replaces occurrences of the pattern in regex with the output of
+ * @eval for that occurrence.
+ *
+ * Setting @start_position differs from just passing over a shortened
+ * string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern
+ * that begins with any kind of lookbehind assertion, such as "\b".
+ *
+ * The following example uses g_regex_replace_eval() to replace multiple
+ * strings at once:
+ * |[
+ * static gboolean
+ * eval_cb (const GMatchInfo *info,
+ * GString *res,
+ * gpointer data)
+ * {
+ * gchar *match;
+ * gchar *r;
+ *
+ * match = g_match_info_fetch (info, 0);
+ * r = g_hash_table_lookup ((GHashTable *)data, match);
+ * g_string_append (res, r);
+ * g_free (match);
+ *
+ * return FALSE;
+ * }
+ *
+ * /* ... */
+ *
+ * GRegex *reg;
+ * GHashTable *h;
+ * gchar *res;
+ *
+ * h = g_hash_table_new (g_str_hash, g_str_equal);
+ *
+ * g_hash_table_insert (h, "1", "ONE");
+ * g_hash_table_insert (h, "2", "TWO");
+ * g_hash_table_insert (h, "3", "THREE");
+ * g_hash_table_insert (h, "4", "FOUR");
+ *
+ * reg = g_regex_new ("1|2|3|4", 0, 0, NULL);
+ * res = g_regex_replace_eval (reg, text, -1, 0, 0, eval_cb, h, NULL);
+ * g_hash_table_destroy (h);
+ *
+ * /* ... */
+ * ]|
+ *
+ * Returns: a newly allocated string containing the replacements
+ *
+ * Since: 2.14
+ */
+gchar *
+g_regex_replace_eval (const GRegex *regex,
+ const gchar *string,
+ gssize string_len,
+ gint start_position,
+ GRegexMatchFlags match_options,
+ GRegexEvalCallback eval,
+ gpointer user_data,
+ GError **error)
+{
+ GMatchInfo *match_info;
+ GString *result;
+ gint str_pos = 0;
+ gboolean done = FALSE;
+ GError *tmp_error = NULL;
+
+ g_return_val_if_fail (regex != NULL, NULL);
+ g_return_val_if_fail (string != NULL, NULL);
+ g_return_val_if_fail (start_position >= 0, NULL);
+ g_return_val_if_fail (eval != NULL, NULL);
+ g_return_val_if_fail ((match_options & ~G_REGEX_MATCH_MASK) == 0, NULL);
+
+ if (string_len < 0)
+ string_len = strlen (string);
+
+ result = g_string_sized_new (string_len);
+
+ /* run down the string making matches. */
+ g_regex_match_full (regex, string, string_len, start_position,
+ match_options, &match_info, &tmp_error);
+ while (!done && g_match_info_matches (match_info))
+ {
+ g_string_append_len (result,
+ string + str_pos,
+ match_info->offsets[0] - str_pos);
+ done = (*eval) (match_info, result, user_data);
+ str_pos = match_info->offsets[1];
+ g_match_info_next (match_info, &tmp_error);
+ }
+ g_match_info_free (match_info);
+ if (tmp_error != NULL)
+ {
+ g_propagate_error (error, tmp_error);
+ g_string_free (result, TRUE);
+ return NULL;
+ }
+
+ g_string_append_len (result, string + str_pos, string_len - str_pos);
+ return g_string_free (result, FALSE);
+}
+
+/**
+ * g_regex_check_replacement:
+ * @replacement: the replacement string
+ * @has_references: location to store information about
+ * references in @replacement or %NULL
+ * @error: location to store error
+ *
+ * Checks whether @replacement is a valid replacement string
+ * (see g_regex_replace()), i.e. that all escape sequences in
+ * it are valid.
+ *
+ * If @has_references is not %NULL then @replacement is checked
+ * for pattern references. For instance, replacement text 'foo\n'
+ * does not contain references and may be evaluated without information
+ * about actual match, but '\0\1' (whole match followed by first
+ * subpattern) requires valid #GMatchInfo object.
+ *
+ * Returns: whether @replacement is a valid replacement string
+ *
+ * Since: 2.14
+ */
+gboolean
+g_regex_check_replacement (const gchar *replacement,
+ gboolean *has_references,
+ GError **error)
+{
+ GList *list;
+ GError *tmp = NULL;
+
+ list = split_replacement (replacement, &tmp);
+
+ if (tmp)
+ {
+ g_propagate_error (error, tmp);
+ return FALSE;
+ }
+
+ if (has_references)
+ *has_references = interpolation_list_needs_match (list);
+
+ g_list_foreach (list, (GFunc) free_interpolation_data, NULL);
+ g_list_free (list);
+
+ return TRUE;
+}
+
+/**
+ * g_regex_escape_string:
+ * @string: the string to escape
+ * @length: the length of @string, or -1 if @string is nul-terminated
+ *
+ * Escapes the special characters used for regular expressions
+ * in @string, for instance "a.b*c" becomes "a\.b\*c". This
+ * function is useful to dynamically generate regular expressions.
+ *
+ * @string can contain nul characters that are replaced with "\0",
+ * in this case remember to specify the correct length of @string
+ * in @length.
+ *
+ * Returns: a newly-allocated escaped string
+ *
+ * Since: 2.14
+ */
+gchar *
+g_regex_escape_string (const gchar *string,
+ gint length)
+{
+ GString *escaped;
+ const char *p, *piece_start, *end;
+
+ g_return_val_if_fail (string != NULL, NULL);
+
+ if (length < 0)
+ length = strlen (string);
+
+ end = string + length;
+ p = piece_start = string;
+ escaped = g_string_sized_new (length + 1);
+
+ while (p < end)
+ {
+ switch (*p)
+ {
+ case '\0':
+ case '\\':
+ case '|':
+ case '(':
+ case ')':
+ case '[':
+ case ']':
+ case '{':
+ case '}':
+ case '^':
+ case '$':
+ case '*':
+ case '+':
+ case '?':
+ case '.':
+ if (p != piece_start)
+ /* copy the previous piece. */
+ g_string_append_len (escaped, piece_start, p - piece_start);
+ g_string_append_c (escaped, '\\');
+ if (*p == '\0')
+ g_string_append_c (escaped, '0');
+ else
+ g_string_append_c (escaped, *p);
+ piece_start = ++p;
+ break;
+ default:
+ p = g_utf8_next_char (p);
+ break;
+ }
+ }
+
+ if (piece_start < end)
+ g_string_append_len (escaped, piece_start, end - piece_start);
+
+ return g_string_free (escaped, FALSE);
+}
+
--- /dev/null
+/* guniprop.c - Unicode character properties.
+ *
+ * Copyright (C) 1999 Tom Tromey
+ * Copyright (C) 2000 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include "guniscript.h"
+
+#define G_EASY_SCRIPTS_RANGE 8192
+
+static const guchar g_script_easy_table[8192] = {
+
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_COPTIC, G_UNICODE_SCRIPT_COPTIC,
+ G_UNICODE_SCRIPT_COPTIC, G_UNICODE_SCRIPT_COPTIC, G_UNICODE_SCRIPT_COPTIC,
+ G_UNICODE_SCRIPT_COPTIC, G_UNICODE_SCRIPT_COPTIC, G_UNICODE_SCRIPT_COPTIC,
+ G_UNICODE_SCRIPT_COPTIC, G_UNICODE_SCRIPT_COPTIC, G_UNICODE_SCRIPT_COPTIC,
+ G_UNICODE_SCRIPT_COPTIC, G_UNICODE_SCRIPT_COPTIC, G_UNICODE_SCRIPT_COPTIC,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN,
+ G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN,
+ G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN,
+ G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN,
+ G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN,
+ G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN,
+ G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN,
+ G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN,
+ G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN,
+ G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN,
+ G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN,
+ G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN,
+ G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN,
+ G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN,
+ G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN,
+ G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN,
+ G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN,
+ G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN,
+ G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN,
+ G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN,
+ G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN,
+ G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN,
+ G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN,
+ G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN,
+ G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN,
+ G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN,
+ G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN, G_UNICODE_SCRIPT_ARMENIAN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_ARMENIAN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW,
+ G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW,
+ G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW,
+ G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW,
+ G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW,
+ G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW,
+ G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW,
+ G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW,
+ G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW,
+ G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW,
+ G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW,
+ G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW,
+ G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW,
+ G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW,
+ G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW,
+ G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW,
+ G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW,
+ G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW,
+ G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW,
+ G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW,
+ G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW,
+ G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW,
+ G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW,
+ G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW,
+ G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW,
+ G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW,
+ G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_HEBREW,
+ G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_HEBREW,
+ G_UNICODE_SCRIPT_HEBREW, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC,
+ G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC,
+ G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC,
+ G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC,
+ G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC,
+ G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC,
+ G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC,
+ G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC,
+ G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC,
+ G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC,
+ G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC,
+ G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC,
+ G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC,
+ G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC,
+ G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC,
+ G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC,
+ G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC,
+ G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC,
+ G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC,
+ G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC,
+ G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC,
+ G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC,
+ G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC,
+ G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC,
+ G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC, G_UNICODE_SCRIPT_SYRIAC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC, G_UNICODE_SCRIPT_ARABIC,
+ G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA,
+ G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA,
+ G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA,
+ G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA,
+ G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA,
+ G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA,
+ G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA,
+ G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA,
+ G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA,
+ G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA,
+ G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA,
+ G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA,
+ G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA,
+ G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA,
+ G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA,
+ G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA,
+ G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_THAANA, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO,
+ G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO,
+ G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO,
+ G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO,
+ G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO,
+ G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO,
+ G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO,
+ G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO,
+ G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO,
+ G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO,
+ G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO,
+ G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO,
+ G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO,
+ G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO,
+ G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO,
+ G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO,
+ G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO,
+ G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO,
+ G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO,
+ G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO, G_UNICODE_SCRIPT_NKO,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI,
+ G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_DEVANAGARI, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI,
+ G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_BENGALI, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_GURMUKHI,
+ G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI,
+ G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_GURMUKHI,
+ G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI,
+ G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI,
+ G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI,
+ G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI,
+ G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI,
+ G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI,
+ G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI,
+ G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI,
+ G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI,
+ G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI,
+ G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI,
+ G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_GURMUKHI,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI,
+ G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI,
+ G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI,
+ G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI,
+ G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI,
+ G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_GURMUKHI, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI,
+ G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_GUJARATI,
+ G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI,
+ G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI,
+ G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI,
+ G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI,
+ G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI,
+ G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI,
+ G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI,
+ G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI,
+ G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI,
+ G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI,
+ G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI,
+ G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_GUJARATI,
+ G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_GUJARATI,
+ G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI,
+ G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI,
+ G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI,
+ G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI,
+ G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_GUJARATI,
+ G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_GUJARATI,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI,
+ G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI,
+ G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI,
+ G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_GUJARATI,
+ G_UNICODE_SCRIPT_GUJARATI, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_GUJARATI,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA,
+ G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA,
+ G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_ORIYA,
+ G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA,
+ G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA,
+ G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA,
+ G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA,
+ G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA,
+ G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA,
+ G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA,
+ G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_ORIYA,
+ G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA,
+ G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA,
+ G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_ORIYA,
+ G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA,
+ G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA,
+ G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_ORIYA,
+ G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA,
+ G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_ORIYA,
+ G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA,
+ G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA,
+ G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA,
+ G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_ORIYA, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL,
+ G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL,
+ G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_TAMIL,
+ G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_TAMIL,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_TAMIL,
+ G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_TAMIL,
+ G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL,
+ G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL,
+ G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL,
+ G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL,
+ G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_TAMIL,
+ G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL,
+ G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL,
+ G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL,
+ G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL,
+ G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL,
+ G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL,
+ G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL,
+ G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_TAMIL,
+ G_UNICODE_SCRIPT_TAMIL, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_TELUGU,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_TELUGU,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_TELUGU,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_TELUGU,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU,
+ G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_TELUGU, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA,
+ G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA,
+ G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA,
+ G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_KANNADA,
+ G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA,
+ G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA,
+ G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA,
+ G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA,
+ G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA,
+ G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA,
+ G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA,
+ G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_KANNADA,
+ G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA,
+ G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA,
+ G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA,
+ G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_KANNADA,
+ G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA,
+ G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA,
+ G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA,
+ G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_KANNADA,
+ G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_KANNADA,
+ G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA,
+ G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA,
+ G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA, G_UNICODE_SCRIPT_KANNADA,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM,
+ G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM,
+ G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM,
+ G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM,
+ G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM,
+ G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM,
+ G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM,
+ G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM,
+ G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM,
+ G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM,
+ G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM,
+ G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM,
+ G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM,
+ G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM,
+ G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_MALAYALAM,
+ G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM,
+ G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM,
+ G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_MALAYALAM,
+ G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM,
+ G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM,
+ G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM,
+ G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM,
+ G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM,
+ G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM,
+ G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM,
+ G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_MALAYALAM,
+ G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM,
+ G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM, G_UNICODE_SCRIPT_MALAYALAM,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_SINHALA,
+ G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_SINHALA,
+ G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA,
+ G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA,
+ G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA,
+ G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA,
+ G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA,
+ G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_SINHALA,
+ G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA,
+ G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA,
+ G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA,
+ G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA,
+ G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA,
+ G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA,
+ G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA,
+ G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA,
+ G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA,
+ G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA,
+ G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA,
+ G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_SINHALA,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA,
+ G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA,
+ G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_SINHALA,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA,
+ G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA,
+ G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA, G_UNICODE_SCRIPT_SINHALA,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI,
+ G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI,
+ G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI,
+ G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI,
+ G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI,
+ G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI,
+ G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI,
+ G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI,
+ G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI,
+ G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI,
+ G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI,
+ G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI,
+ G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI,
+ G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI,
+ G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI,
+ G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI,
+ G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI,
+ G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI,
+ G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI,
+ G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI,
+ G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI,
+ G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI,
+ G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI,
+ G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI,
+ G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI,
+ G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI,
+ G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI,
+ G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_THAI,
+ G_UNICODE_SCRIPT_THAI, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_LAO,
+ G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_LAO,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_LAO,
+ G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_LAO,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_LAO,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_LAO,
+ G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_LAO,
+ G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_LAO,
+ G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_LAO,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_LAO,
+ G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_LAO,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_LAO,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_LAO,
+ G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_LAO,
+ G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_LAO,
+ G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_LAO,
+ G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_LAO,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_LAO,
+ G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_LAO,
+ G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_LAO,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_LAO,
+ G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_LAO,
+ G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_LAO,
+ G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_LAO,
+ G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_LAO,
+ G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_LAO, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN, G_UNICODE_SCRIPT_TIBETAN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_MYANMAR, G_UNICODE_SCRIPT_GEORGIAN,
+ G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN,
+ G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN,
+ G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN,
+ G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN,
+ G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN,
+ G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN,
+ G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN,
+ G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN,
+ G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN,
+ G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN,
+ G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN,
+ G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN,
+ G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_GEORGIAN,
+ G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN,
+ G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN,
+ G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN,
+ G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN,
+ G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN,
+ G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN,
+ G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN,
+ G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN,
+ G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN,
+ G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN,
+ G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN,
+ G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN,
+ G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN,
+ G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_GEORGIAN,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_GEORGIAN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL, G_UNICODE_SCRIPT_HANGUL,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC,
+ G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_ETHIOPIC, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_CHEROKEE,
+ G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE,
+ G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE,
+ G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE,
+ G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE,
+ G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE,
+ G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE,
+ G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE,
+ G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE,
+ G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE,
+ G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE,
+ G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE,
+ G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE,
+ G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE,
+ G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE,
+ G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE,
+ G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE,
+ G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE,
+ G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE,
+ G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE,
+ G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE,
+ G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE,
+ G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE,
+ G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE,
+ G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE,
+ G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE,
+ G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE,
+ G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE,
+ G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE, G_UNICODE_SCRIPT_CHEROKEE,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_OGHAM, G_UNICODE_SCRIPT_OGHAM, G_UNICODE_SCRIPT_OGHAM,
+ G_UNICODE_SCRIPT_OGHAM, G_UNICODE_SCRIPT_OGHAM, G_UNICODE_SCRIPT_OGHAM,
+ G_UNICODE_SCRIPT_OGHAM, G_UNICODE_SCRIPT_OGHAM, G_UNICODE_SCRIPT_OGHAM,
+ G_UNICODE_SCRIPT_OGHAM, G_UNICODE_SCRIPT_OGHAM, G_UNICODE_SCRIPT_OGHAM,
+ G_UNICODE_SCRIPT_OGHAM, G_UNICODE_SCRIPT_OGHAM, G_UNICODE_SCRIPT_OGHAM,
+ G_UNICODE_SCRIPT_OGHAM, G_UNICODE_SCRIPT_OGHAM, G_UNICODE_SCRIPT_OGHAM,
+ G_UNICODE_SCRIPT_OGHAM, G_UNICODE_SCRIPT_OGHAM, G_UNICODE_SCRIPT_OGHAM,
+ G_UNICODE_SCRIPT_OGHAM, G_UNICODE_SCRIPT_OGHAM, G_UNICODE_SCRIPT_OGHAM,
+ G_UNICODE_SCRIPT_OGHAM, G_UNICODE_SCRIPT_OGHAM, G_UNICODE_SCRIPT_OGHAM,
+ G_UNICODE_SCRIPT_OGHAM, G_UNICODE_SCRIPT_OGHAM, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_RUNIC,
+ G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC,
+ G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC,
+ G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC,
+ G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC,
+ G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC,
+ G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC,
+ G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC,
+ G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC,
+ G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC,
+ G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC,
+ G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC,
+ G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC,
+ G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC,
+ G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC,
+ G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC,
+ G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC,
+ G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC,
+ G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC,
+ G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC,
+ G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC,
+ G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC,
+ G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC,
+ G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC,
+ G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC,
+ G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_RUNIC,
+ G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_RUNIC, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_TAGALOG,
+ G_UNICODE_SCRIPT_TAGALOG, G_UNICODE_SCRIPT_TAGALOG, G_UNICODE_SCRIPT_TAGALOG,
+ G_UNICODE_SCRIPT_TAGALOG, G_UNICODE_SCRIPT_TAGALOG, G_UNICODE_SCRIPT_TAGALOG,
+ G_UNICODE_SCRIPT_TAGALOG, G_UNICODE_SCRIPT_TAGALOG, G_UNICODE_SCRIPT_TAGALOG,
+ G_UNICODE_SCRIPT_TAGALOG, G_UNICODE_SCRIPT_TAGALOG, G_UNICODE_SCRIPT_TAGALOG,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_TAGALOG, G_UNICODE_SCRIPT_TAGALOG,
+ G_UNICODE_SCRIPT_TAGALOG, G_UNICODE_SCRIPT_TAGALOG, G_UNICODE_SCRIPT_TAGALOG,
+ G_UNICODE_SCRIPT_TAGALOG, G_UNICODE_SCRIPT_TAGALOG, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_HANUNOO, G_UNICODE_SCRIPT_HANUNOO,
+ G_UNICODE_SCRIPT_HANUNOO, G_UNICODE_SCRIPT_HANUNOO, G_UNICODE_SCRIPT_HANUNOO,
+ G_UNICODE_SCRIPT_HANUNOO, G_UNICODE_SCRIPT_HANUNOO, G_UNICODE_SCRIPT_HANUNOO,
+ G_UNICODE_SCRIPT_HANUNOO, G_UNICODE_SCRIPT_HANUNOO, G_UNICODE_SCRIPT_HANUNOO,
+ G_UNICODE_SCRIPT_HANUNOO, G_UNICODE_SCRIPT_HANUNOO, G_UNICODE_SCRIPT_HANUNOO,
+ G_UNICODE_SCRIPT_HANUNOO, G_UNICODE_SCRIPT_HANUNOO, G_UNICODE_SCRIPT_HANUNOO,
+ G_UNICODE_SCRIPT_HANUNOO, G_UNICODE_SCRIPT_HANUNOO, G_UNICODE_SCRIPT_HANUNOO,
+ G_UNICODE_SCRIPT_HANUNOO, G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_BUHID, G_UNICODE_SCRIPT_BUHID, G_UNICODE_SCRIPT_BUHID,
+ G_UNICODE_SCRIPT_BUHID, G_UNICODE_SCRIPT_BUHID, G_UNICODE_SCRIPT_BUHID,
+ G_UNICODE_SCRIPT_BUHID, G_UNICODE_SCRIPT_BUHID, G_UNICODE_SCRIPT_BUHID,
+ G_UNICODE_SCRIPT_BUHID, G_UNICODE_SCRIPT_BUHID, G_UNICODE_SCRIPT_BUHID,
+ G_UNICODE_SCRIPT_BUHID, G_UNICODE_SCRIPT_BUHID, G_UNICODE_SCRIPT_BUHID,
+ G_UNICODE_SCRIPT_BUHID, G_UNICODE_SCRIPT_BUHID, G_UNICODE_SCRIPT_BUHID,
+ G_UNICODE_SCRIPT_BUHID, G_UNICODE_SCRIPT_BUHID, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_TAGBANWA,
+ G_UNICODE_SCRIPT_TAGBANWA, G_UNICODE_SCRIPT_TAGBANWA, G_UNICODE_SCRIPT_TAGBANWA,
+ G_UNICODE_SCRIPT_TAGBANWA, G_UNICODE_SCRIPT_TAGBANWA, G_UNICODE_SCRIPT_TAGBANWA,
+ G_UNICODE_SCRIPT_TAGBANWA, G_UNICODE_SCRIPT_TAGBANWA, G_UNICODE_SCRIPT_TAGBANWA,
+ G_UNICODE_SCRIPT_TAGBANWA, G_UNICODE_SCRIPT_TAGBANWA, G_UNICODE_SCRIPT_TAGBANWA,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_TAGBANWA, G_UNICODE_SCRIPT_TAGBANWA,
+ G_UNICODE_SCRIPT_TAGBANWA, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_TAGBANWA,
+ G_UNICODE_SCRIPT_TAGBANWA, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_COMMON, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_COMMON,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN, G_UNICODE_SCRIPT_MONGOLIAN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU,
+ G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU,
+ G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU,
+ G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU,
+ G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU,
+ G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU,
+ G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU,
+ G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU,
+ G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU,
+ G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU,
+ G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU,
+ G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU,
+ G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU,
+ G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU,
+ G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU,
+ G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU,
+ G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_LIMBU,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU,
+ G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU,
+ G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU,
+ G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU, G_UNICODE_SCRIPT_LIMBU,
+ G_UNICODE_SCRIPT_TAI_LE, G_UNICODE_SCRIPT_TAI_LE, G_UNICODE_SCRIPT_TAI_LE,
+ G_UNICODE_SCRIPT_TAI_LE, G_UNICODE_SCRIPT_TAI_LE, G_UNICODE_SCRIPT_TAI_LE,
+ G_UNICODE_SCRIPT_TAI_LE, G_UNICODE_SCRIPT_TAI_LE, G_UNICODE_SCRIPT_TAI_LE,
+ G_UNICODE_SCRIPT_TAI_LE, G_UNICODE_SCRIPT_TAI_LE, G_UNICODE_SCRIPT_TAI_LE,
+ G_UNICODE_SCRIPT_TAI_LE, G_UNICODE_SCRIPT_TAI_LE, G_UNICODE_SCRIPT_TAI_LE,
+ G_UNICODE_SCRIPT_TAI_LE, G_UNICODE_SCRIPT_TAI_LE, G_UNICODE_SCRIPT_TAI_LE,
+ G_UNICODE_SCRIPT_TAI_LE, G_UNICODE_SCRIPT_TAI_LE, G_UNICODE_SCRIPT_TAI_LE,
+ G_UNICODE_SCRIPT_TAI_LE, G_UNICODE_SCRIPT_TAI_LE, G_UNICODE_SCRIPT_TAI_LE,
+ G_UNICODE_SCRIPT_TAI_LE, G_UNICODE_SCRIPT_TAI_LE, G_UNICODE_SCRIPT_TAI_LE,
+ G_UNICODE_SCRIPT_TAI_LE, G_UNICODE_SCRIPT_TAI_LE, G_UNICODE_SCRIPT_TAI_LE,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_TAI_LE,
+ G_UNICODE_SCRIPT_TAI_LE, G_UNICODE_SCRIPT_TAI_LE, G_UNICODE_SCRIPT_TAI_LE,
+ G_UNICODE_SCRIPT_TAI_LE, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE,
+ G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE,
+ G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE,
+ G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE,
+ G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE,
+ G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE,
+ G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE,
+ G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE,
+ G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE,
+ G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE,
+ G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE,
+ G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE,
+ G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE,
+ G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE,
+ G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE,
+ G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE,
+ G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE,
+ G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE,
+ G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE,
+ G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE,
+ G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE,
+ G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_NEW_TAI_LUE,
+ G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE,
+ G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE,
+ G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_NEW_TAI_LUE, G_UNICODE_SCRIPT_NEW_TAI_LUE,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER,
+ G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_KHMER, G_UNICODE_SCRIPT_BUGINESE,
+ G_UNICODE_SCRIPT_BUGINESE, G_UNICODE_SCRIPT_BUGINESE, G_UNICODE_SCRIPT_BUGINESE,
+ G_UNICODE_SCRIPT_BUGINESE, G_UNICODE_SCRIPT_BUGINESE, G_UNICODE_SCRIPT_BUGINESE,
+ G_UNICODE_SCRIPT_BUGINESE, G_UNICODE_SCRIPT_BUGINESE, G_UNICODE_SCRIPT_BUGINESE,
+ G_UNICODE_SCRIPT_BUGINESE, G_UNICODE_SCRIPT_BUGINESE, G_UNICODE_SCRIPT_BUGINESE,
+ G_UNICODE_SCRIPT_BUGINESE, G_UNICODE_SCRIPT_BUGINESE, G_UNICODE_SCRIPT_BUGINESE,
+ G_UNICODE_SCRIPT_BUGINESE, G_UNICODE_SCRIPT_BUGINESE, G_UNICODE_SCRIPT_BUGINESE,
+ G_UNICODE_SCRIPT_BUGINESE, G_UNICODE_SCRIPT_BUGINESE, G_UNICODE_SCRIPT_BUGINESE,
+ G_UNICODE_SCRIPT_BUGINESE, G_UNICODE_SCRIPT_BUGINESE, G_UNICODE_SCRIPT_BUGINESE,
+ G_UNICODE_SCRIPT_BUGINESE, G_UNICODE_SCRIPT_BUGINESE, G_UNICODE_SCRIPT_BUGINESE,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_BUGINESE,
+ G_UNICODE_SCRIPT_BUGINESE, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE,
+ G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_BALINESE, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_SUNDANESE,
+ G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE,
+ G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE,
+ G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE,
+ G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE,
+ G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE,
+ G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE,
+ G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE,
+ G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE,
+ G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE,
+ G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE,
+ G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE,
+ G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE,
+ G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE,
+ G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE,
+ G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE,
+ G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE,
+ G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE, G_UNICODE_SCRIPT_SUNDANESE,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA,
+ G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA,
+ G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA,
+ G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA,
+ G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA,
+ G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA,
+ G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA,
+ G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA,
+ G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA,
+ G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA,
+ G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA,
+ G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA,
+ G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA,
+ G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA,
+ G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA,
+ G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA,
+ G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA,
+ G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA,
+ G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA,
+ G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA,
+ G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA,
+ G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA,
+ G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA, G_UNICODE_SCRIPT_LEPCHA,
+ G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI,
+ G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI,
+ G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI,
+ G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI,
+ G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI,
+ G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI,
+ G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI,
+ G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI,
+ G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI,
+ G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI,
+ G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI,
+ G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI,
+ G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI,
+ G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI,
+ G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI,
+ G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI, G_UNICODE_SCRIPT_OL_CHIKI,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_CYRILLIC, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_CYRILLIC,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_INHERITED, G_UNICODE_SCRIPT_INHERITED,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_LATIN,
+ G_UNICODE_SCRIPT_LATIN, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_UNKNOWN,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_UNKNOWN, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_GREEK,
+ G_UNICODE_SCRIPT_GREEK, G_UNICODE_SCRIPT_UNKNOWN,
+};
+
+static const struct {
+ gunichar start;
+ guint16 chars;
+ guint16 script;
+} g_script_table[] = {
+ { 0x2000, 12, G_UNICODE_SCRIPT_COMMON },
+ { 0x200c, 2, G_UNICODE_SCRIPT_INHERITED },
+ { 0x200e, 87, G_UNICODE_SCRIPT_COMMON },
+ { 0x206a, 7, G_UNICODE_SCRIPT_COMMON },
+ { 0x2071, 1, G_UNICODE_SCRIPT_LATIN },
+ { 0x2074, 11, G_UNICODE_SCRIPT_COMMON },
+ { 0x207f, 1, G_UNICODE_SCRIPT_LATIN },
+ { 0x2080, 15, G_UNICODE_SCRIPT_COMMON },
+ { 0x2090, 5, G_UNICODE_SCRIPT_LATIN },
+ { 0x20a0, 22, G_UNICODE_SCRIPT_COMMON },
+ { 0x20d0, 33, G_UNICODE_SCRIPT_INHERITED },
+ { 0x2100, 38, G_UNICODE_SCRIPT_COMMON },
+ { 0x2126, 1, G_UNICODE_SCRIPT_GREEK },
+ { 0x2127, 3, G_UNICODE_SCRIPT_COMMON },
+ { 0x212a, 2, G_UNICODE_SCRIPT_LATIN },
+ { 0x212c, 6, G_UNICODE_SCRIPT_COMMON },
+ { 0x2132, 1, G_UNICODE_SCRIPT_LATIN },
+ { 0x2133, 27, G_UNICODE_SCRIPT_COMMON },
+ { 0x214e, 1, G_UNICODE_SCRIPT_LATIN },
+ { 0x214f, 1, G_UNICODE_SCRIPT_COMMON },
+ { 0x2153, 13, G_UNICODE_SCRIPT_COMMON },
+ { 0x2160, 41, G_UNICODE_SCRIPT_LATIN },
+ { 0x2190, 600, G_UNICODE_SCRIPT_COMMON },
+ { 0x2400, 39, G_UNICODE_SCRIPT_COMMON },
+ { 0x2440, 11, G_UNICODE_SCRIPT_COMMON },
+ { 0x2460, 574, G_UNICODE_SCRIPT_COMMON },
+ { 0x26a0, 29, G_UNICODE_SCRIPT_COMMON },
+ { 0x26c0, 4, G_UNICODE_SCRIPT_COMMON },
+ { 0x2701, 4, G_UNICODE_SCRIPT_COMMON },
+ { 0x2706, 4, G_UNICODE_SCRIPT_COMMON },
+ { 0x270c, 28, G_UNICODE_SCRIPT_COMMON },
+ { 0x2729, 35, G_UNICODE_SCRIPT_COMMON },
+ { 0x274d, 1, G_UNICODE_SCRIPT_COMMON },
+ { 0x274f, 4, G_UNICODE_SCRIPT_COMMON },
+ { 0x2756, 1, G_UNICODE_SCRIPT_COMMON },
+ { 0x2758, 7, G_UNICODE_SCRIPT_COMMON },
+ { 0x2761, 52, G_UNICODE_SCRIPT_COMMON },
+ { 0x2798, 24, G_UNICODE_SCRIPT_COMMON },
+ { 0x27b1, 14, G_UNICODE_SCRIPT_COMMON },
+ { 0x27c0, 11, G_UNICODE_SCRIPT_COMMON },
+ { 0x27cc, 1, G_UNICODE_SCRIPT_COMMON },
+ { 0x27d0, 48, G_UNICODE_SCRIPT_COMMON },
+ { 0x2800, 256, G_UNICODE_SCRIPT_BRAILLE },
+ { 0x2900, 589, G_UNICODE_SCRIPT_COMMON },
+ { 0x2b50, 5, G_UNICODE_SCRIPT_COMMON },
+ { 0x2c00, 47, G_UNICODE_SCRIPT_GLAGOLITIC },
+ { 0x2c30, 47, G_UNICODE_SCRIPT_GLAGOLITIC },
+ { 0x2c60, 16, G_UNICODE_SCRIPT_LATIN },
+ { 0x2c71, 13, G_UNICODE_SCRIPT_LATIN },
+ { 0x2c80, 107, G_UNICODE_SCRIPT_COPTIC },
+ { 0x2cf9, 7, G_UNICODE_SCRIPT_COPTIC },
+ { 0x2d00, 38, G_UNICODE_SCRIPT_GEORGIAN },
+ { 0x2d30, 54, G_UNICODE_SCRIPT_TIFINAGH },
+ { 0x2d6f, 1, G_UNICODE_SCRIPT_TIFINAGH },
+ { 0x2d80, 23, G_UNICODE_SCRIPT_ETHIOPIC },
+ { 0x2da0, 7, G_UNICODE_SCRIPT_ETHIOPIC },
+ { 0x2da8, 7, G_UNICODE_SCRIPT_ETHIOPIC },
+ { 0x2db0, 7, G_UNICODE_SCRIPT_ETHIOPIC },
+ { 0x2db8, 7, G_UNICODE_SCRIPT_ETHIOPIC },
+ { 0x2dc0, 7, G_UNICODE_SCRIPT_ETHIOPIC },
+ { 0x2dc8, 7, G_UNICODE_SCRIPT_ETHIOPIC },
+ { 0x2dd0, 7, G_UNICODE_SCRIPT_ETHIOPIC },
+ { 0x2dd8, 7, G_UNICODE_SCRIPT_ETHIOPIC },
+ { 0x2de0, 32, G_UNICODE_SCRIPT_CYRILLIC },
+ { 0x2e00, 49, G_UNICODE_SCRIPT_COMMON },
+ { 0x2e80, 26, G_UNICODE_SCRIPT_HAN },
+ { 0x2e9b, 89, G_UNICODE_SCRIPT_HAN },
+ { 0x2f00, 214, G_UNICODE_SCRIPT_HAN },
+ { 0x2ff0, 12, G_UNICODE_SCRIPT_COMMON },
+ { 0x3000, 5, G_UNICODE_SCRIPT_COMMON },
+ { 0x3005, 1, G_UNICODE_SCRIPT_HAN },
+ { 0x3006, 1, G_UNICODE_SCRIPT_COMMON },
+ { 0x3007, 1, G_UNICODE_SCRIPT_HAN },
+ { 0x3008, 25, G_UNICODE_SCRIPT_COMMON },
+ { 0x3021, 9, G_UNICODE_SCRIPT_HAN },
+ { 0x302a, 6, G_UNICODE_SCRIPT_INHERITED },
+ { 0x3030, 8, G_UNICODE_SCRIPT_COMMON },
+ { 0x3038, 4, G_UNICODE_SCRIPT_HAN },
+ { 0x303c, 4, G_UNICODE_SCRIPT_COMMON },
+ { 0x3041, 86, G_UNICODE_SCRIPT_HIRAGANA },
+ { 0x3099, 2, G_UNICODE_SCRIPT_INHERITED },
+ { 0x309b, 2, G_UNICODE_SCRIPT_COMMON },
+ { 0x309d, 3, G_UNICODE_SCRIPT_HIRAGANA },
+ { 0x30a0, 1, G_UNICODE_SCRIPT_COMMON },
+ { 0x30a1, 90, G_UNICODE_SCRIPT_KATAKANA },
+ { 0x30fb, 2, G_UNICODE_SCRIPT_COMMON },
+ { 0x30fd, 3, G_UNICODE_SCRIPT_KATAKANA },
+ { 0x3105, 41, G_UNICODE_SCRIPT_BOPOMOFO },
+ { 0x3131, 94, G_UNICODE_SCRIPT_HANGUL },
+ { 0x3190, 16, G_UNICODE_SCRIPT_COMMON },
+ { 0x31a0, 24, G_UNICODE_SCRIPT_BOPOMOFO },
+ { 0x31c0, 36, G_UNICODE_SCRIPT_COMMON },
+ { 0x31f0, 16, G_UNICODE_SCRIPT_KATAKANA },
+ { 0x3200, 31, G_UNICODE_SCRIPT_HANGUL },
+ { 0x3220, 36, G_UNICODE_SCRIPT_COMMON },
+ { 0x3250, 16, G_UNICODE_SCRIPT_COMMON },
+ { 0x3260, 31, G_UNICODE_SCRIPT_HANGUL },
+ { 0x327f, 81, G_UNICODE_SCRIPT_COMMON },
+ { 0x32d0, 47, G_UNICODE_SCRIPT_KATAKANA },
+ { 0x3300, 88, G_UNICODE_SCRIPT_KATAKANA },
+ { 0x3358, 168, G_UNICODE_SCRIPT_COMMON },
+ { 0x3400, 6582, G_UNICODE_SCRIPT_HAN },
+ { 0x4dc0, 64, G_UNICODE_SCRIPT_COMMON },
+ { 0x4e00, 20932, G_UNICODE_SCRIPT_HAN },
+ { 0xa000, 1165, G_UNICODE_SCRIPT_YI },
+ { 0xa490, 55, G_UNICODE_SCRIPT_YI },
+ { 0xa500, 300, G_UNICODE_SCRIPT_VAI },
+ { 0xa640, 32, G_UNICODE_SCRIPT_CYRILLIC },
+ { 0xa662, 18, G_UNICODE_SCRIPT_CYRILLIC },
+ { 0xa67c, 28, G_UNICODE_SCRIPT_CYRILLIC },
+ { 0xa700, 34, G_UNICODE_SCRIPT_COMMON },
+ { 0xa722, 102, G_UNICODE_SCRIPT_LATIN },
+ { 0xa788, 3, G_UNICODE_SCRIPT_COMMON },
+ { 0xa78b, 2, G_UNICODE_SCRIPT_LATIN },
+ { 0xa7fb, 5, G_UNICODE_SCRIPT_LATIN },
+ { 0xa800, 44, G_UNICODE_SCRIPT_SYLOTI_NAGRI },
+ { 0xa840, 56, G_UNICODE_SCRIPT_PHAGS_PA },
+ { 0xa880, 69, G_UNICODE_SCRIPT_SAURASHTRA },
+ { 0xa8ce, 12, G_UNICODE_SCRIPT_SAURASHTRA },
+ { 0xa900, 48, G_UNICODE_SCRIPT_KAYAH_LI },
+ { 0xa930, 36, G_UNICODE_SCRIPT_REJANG },
+ { 0xa95f, 1, G_UNICODE_SCRIPT_REJANG },
+ { 0xaa00, 55, G_UNICODE_SCRIPT_CHAM },
+ { 0xaa40, 14, G_UNICODE_SCRIPT_CHAM },
+ { 0xaa50, 10, G_UNICODE_SCRIPT_CHAM },
+ { 0xaa5c, 4, G_UNICODE_SCRIPT_CHAM },
+ { 0xac00, 11172, G_UNICODE_SCRIPT_HANGUL },
+ { 0xf900, 302, G_UNICODE_SCRIPT_HAN },
+ { 0xfa30, 59, G_UNICODE_SCRIPT_HAN },
+ { 0xfa70, 106, G_UNICODE_SCRIPT_HAN },
+ { 0xfb00, 7, G_UNICODE_SCRIPT_LATIN },
+ { 0xfb13, 5, G_UNICODE_SCRIPT_ARMENIAN },
+ { 0xfb1d, 26, G_UNICODE_SCRIPT_HEBREW },
+ { 0xfb38, 5, G_UNICODE_SCRIPT_HEBREW },
+ { 0xfb3e, 1, G_UNICODE_SCRIPT_HEBREW },
+ { 0xfb40, 2, G_UNICODE_SCRIPT_HEBREW },
+ { 0xfb43, 2, G_UNICODE_SCRIPT_HEBREW },
+ { 0xfb46, 10, G_UNICODE_SCRIPT_HEBREW },
+ { 0xfb50, 98, G_UNICODE_SCRIPT_ARABIC },
+ { 0xfbd3, 363, G_UNICODE_SCRIPT_ARABIC },
+ { 0xfd3e, 2, G_UNICODE_SCRIPT_COMMON },
+ { 0xfd50, 64, G_UNICODE_SCRIPT_ARABIC },
+ { 0xfd92, 54, G_UNICODE_SCRIPT_ARABIC },
+ { 0xfdf0, 13, G_UNICODE_SCRIPT_ARABIC },
+ { 0xfdfd, 1, G_UNICODE_SCRIPT_COMMON },
+ { 0xfe00, 16, G_UNICODE_SCRIPT_INHERITED },
+ { 0xfe10, 10, G_UNICODE_SCRIPT_COMMON },
+ { 0xfe20, 7, G_UNICODE_SCRIPT_INHERITED },
+ { 0xfe30, 35, G_UNICODE_SCRIPT_COMMON },
+ { 0xfe54, 19, G_UNICODE_SCRIPT_COMMON },
+ { 0xfe68, 4, G_UNICODE_SCRIPT_COMMON },
+ { 0xfe70, 5, G_UNICODE_SCRIPT_ARABIC },
+ { 0xfe76, 135, G_UNICODE_SCRIPT_ARABIC },
+ { 0xfeff, 1, G_UNICODE_SCRIPT_COMMON },
+ { 0xff01, 32, G_UNICODE_SCRIPT_COMMON },
+ { 0xff21, 26, G_UNICODE_SCRIPT_LATIN },
+ { 0xff3b, 6, G_UNICODE_SCRIPT_COMMON },
+ { 0xff41, 26, G_UNICODE_SCRIPT_LATIN },
+ { 0xff5b, 11, G_UNICODE_SCRIPT_COMMON },
+ { 0xff66, 10, G_UNICODE_SCRIPT_KATAKANA },
+ { 0xff70, 1, G_UNICODE_SCRIPT_COMMON },
+ { 0xff71, 45, G_UNICODE_SCRIPT_KATAKANA },
+ { 0xff9e, 2, G_UNICODE_SCRIPT_COMMON },
+ { 0xffa0, 31, G_UNICODE_SCRIPT_HANGUL },
+ { 0xffc2, 6, G_UNICODE_SCRIPT_HANGUL },
+ { 0xffca, 6, G_UNICODE_SCRIPT_HANGUL },
+ { 0xffd2, 6, G_UNICODE_SCRIPT_HANGUL },
+ { 0xffda, 3, G_UNICODE_SCRIPT_HANGUL },
+ { 0xffe0, 7, G_UNICODE_SCRIPT_COMMON },
+ { 0xffe8, 7, G_UNICODE_SCRIPT_COMMON },
+ { 0xfff9, 5, G_UNICODE_SCRIPT_COMMON },
+ { 0x10000, 12, G_UNICODE_SCRIPT_LINEAR_B },
+ { 0x1000d, 26, G_UNICODE_SCRIPT_LINEAR_B },
+ { 0x10028, 19, G_UNICODE_SCRIPT_LINEAR_B },
+ { 0x1003c, 2, G_UNICODE_SCRIPT_LINEAR_B },
+ { 0x1003f, 15, G_UNICODE_SCRIPT_LINEAR_B },
+ { 0x10050, 14, G_UNICODE_SCRIPT_LINEAR_B },
+ { 0x10080, 123, G_UNICODE_SCRIPT_LINEAR_B },
+ { 0x10100, 3, G_UNICODE_SCRIPT_COMMON },
+ { 0x10107, 45, G_UNICODE_SCRIPT_COMMON },
+ { 0x10137, 9, G_UNICODE_SCRIPT_COMMON },
+ { 0x10140, 75, G_UNICODE_SCRIPT_GREEK },
+ { 0x10190, 12, G_UNICODE_SCRIPT_COMMON },
+ { 0x101d0, 45, G_UNICODE_SCRIPT_COMMON },
+ { 0x101fd, 1, G_UNICODE_SCRIPT_INHERITED },
+ { 0x10280, 29, G_UNICODE_SCRIPT_LYCIAN },
+ { 0x102a0, 49, G_UNICODE_SCRIPT_CARIAN },
+ { 0x10300, 31, G_UNICODE_SCRIPT_OLD_ITALIC },
+ { 0x10320, 4, G_UNICODE_SCRIPT_OLD_ITALIC },
+ { 0x10330, 27, G_UNICODE_SCRIPT_GOTHIC },
+ { 0x10380, 30, G_UNICODE_SCRIPT_UGARITIC },
+ { 0x1039f, 1, G_UNICODE_SCRIPT_UGARITIC },
+ { 0x103a0, 36, G_UNICODE_SCRIPT_OLD_PERSIAN },
+ { 0x103c8, 14, G_UNICODE_SCRIPT_OLD_PERSIAN },
+ { 0x10400, 80, G_UNICODE_SCRIPT_DESERET },
+ { 0x10450, 48, G_UNICODE_SCRIPT_SHAVIAN },
+ { 0x10480, 30, G_UNICODE_SCRIPT_OSMANYA },
+ { 0x104a0, 10, G_UNICODE_SCRIPT_OSMANYA },
+ { 0x10800, 6, G_UNICODE_SCRIPT_CYPRIOT },
+ { 0x10808, 1, G_UNICODE_SCRIPT_CYPRIOT },
+ { 0x1080a, 44, G_UNICODE_SCRIPT_CYPRIOT },
+ { 0x10837, 2, G_UNICODE_SCRIPT_CYPRIOT },
+ { 0x1083c, 1, G_UNICODE_SCRIPT_CYPRIOT },
+ { 0x1083f, 1, G_UNICODE_SCRIPT_CYPRIOT },
+ { 0x10900, 26, G_UNICODE_SCRIPT_PHOENICIAN },
+ { 0x1091f, 1, G_UNICODE_SCRIPT_PHOENICIAN },
+ { 0x10920, 26, G_UNICODE_SCRIPT_LYDIAN },
+ { 0x1093f, 1, G_UNICODE_SCRIPT_LYDIAN },
+ { 0x10a00, 4, G_UNICODE_SCRIPT_KHAROSHTHI },
+ { 0x10a05, 2, G_UNICODE_SCRIPT_KHAROSHTHI },
+ { 0x10a0c, 8, G_UNICODE_SCRIPT_KHAROSHTHI },
+ { 0x10a15, 3, G_UNICODE_SCRIPT_KHAROSHTHI },
+ { 0x10a19, 27, G_UNICODE_SCRIPT_KHAROSHTHI },
+ { 0x10a38, 3, G_UNICODE_SCRIPT_KHAROSHTHI },
+ { 0x10a3f, 9, G_UNICODE_SCRIPT_KHAROSHTHI },
+ { 0x10a50, 9, G_UNICODE_SCRIPT_KHAROSHTHI },
+ { 0x12000, 879, G_UNICODE_SCRIPT_CUNEIFORM },
+ { 0x12400, 99, G_UNICODE_SCRIPT_CUNEIFORM },
+ { 0x12470, 4, G_UNICODE_SCRIPT_CUNEIFORM },
+ { 0x1d000, 246, G_UNICODE_SCRIPT_COMMON },
+ { 0x1d100, 39, G_UNICODE_SCRIPT_COMMON },
+ { 0x1d129, 62, G_UNICODE_SCRIPT_COMMON },
+ { 0x1d167, 3, G_UNICODE_SCRIPT_INHERITED },
+ { 0x1d16a, 17, G_UNICODE_SCRIPT_COMMON },
+ { 0x1d17b, 8, G_UNICODE_SCRIPT_INHERITED },
+ { 0x1d183, 2, G_UNICODE_SCRIPT_COMMON },
+ { 0x1d185, 7, G_UNICODE_SCRIPT_INHERITED },
+ { 0x1d18c, 30, G_UNICODE_SCRIPT_COMMON },
+ { 0x1d1aa, 4, G_UNICODE_SCRIPT_INHERITED },
+ { 0x1d1ae, 48, G_UNICODE_SCRIPT_COMMON },
+ { 0x1d200, 70, G_UNICODE_SCRIPT_GREEK },
+ { 0x1d300, 87, G_UNICODE_SCRIPT_COMMON },
+ { 0x1d360, 18, G_UNICODE_SCRIPT_COMMON },
+ { 0x1d400, 85, G_UNICODE_SCRIPT_COMMON },
+ { 0x1d456, 71, G_UNICODE_SCRIPT_COMMON },
+ { 0x1d49e, 2, G_UNICODE_SCRIPT_COMMON },
+ { 0x1d4a2, 1, G_UNICODE_SCRIPT_COMMON },
+ { 0x1d4a5, 2, G_UNICODE_SCRIPT_COMMON },
+ { 0x1d4a9, 4, G_UNICODE_SCRIPT_COMMON },
+ { 0x1d4ae, 12, G_UNICODE_SCRIPT_COMMON },
+ { 0x1d4bb, 1, G_UNICODE_SCRIPT_COMMON },
+ { 0x1d4bd, 7, G_UNICODE_SCRIPT_COMMON },
+ { 0x1d4c5, 65, G_UNICODE_SCRIPT_COMMON },
+ { 0x1d507, 4, G_UNICODE_SCRIPT_COMMON },
+ { 0x1d50d, 8, G_UNICODE_SCRIPT_COMMON },
+ { 0x1d516, 7, G_UNICODE_SCRIPT_COMMON },
+ { 0x1d51e, 28, G_UNICODE_SCRIPT_COMMON },
+ { 0x1d53b, 4, G_UNICODE_SCRIPT_COMMON },
+ { 0x1d540, 5, G_UNICODE_SCRIPT_COMMON },
+ { 0x1d546, 1, G_UNICODE_SCRIPT_COMMON },
+ { 0x1d54a, 7, G_UNICODE_SCRIPT_COMMON },
+ { 0x1d552, 340, G_UNICODE_SCRIPT_COMMON },
+ { 0x1d6a8, 292, G_UNICODE_SCRIPT_COMMON },
+ { 0x1d7ce, 50, G_UNICODE_SCRIPT_COMMON },
+ { 0x1f000, 44, G_UNICODE_SCRIPT_COMMON },
+ { 0x1f030, 100, G_UNICODE_SCRIPT_COMMON },
+ { 0x20000, 42711, G_UNICODE_SCRIPT_HAN },
+ { 0x2f800, 542, G_UNICODE_SCRIPT_HAN },
+ { 0xe0001, 1, G_UNICODE_SCRIPT_COMMON },
+ { 0xe0020, 96, G_UNICODE_SCRIPT_COMMON },
+ { 0xe0100, 240, G_UNICODE_SCRIPT_INHERITED },
+};
+
+#define G_SCRIPT_TABLE_MIDPOINT (G_N_ELEMENTS (g_script_table) / 2)
+
+static inline GUnicodeScript
+g_unichar_get_script_bsearch (gunichar ch)
+{
+ int lower = 0;
+ int upper = G_N_ELEMENTS (g_script_table) - 1;
+ static int saved_mid = G_SCRIPT_TABLE_MIDPOINT;
+ int mid = saved_mid;
+
+
+ do
+ {
+ if (ch < g_script_table[mid].start)
+ upper = mid - 1;
+ else if (ch >= g_script_table[mid].start + g_script_table[mid].chars)
+ lower = mid + 1;
+ else
+ return g_script_table[saved_mid = mid].script;
+
+ mid = (lower + upper) / 2;
+ }
+ while (lower <= upper);
+
+ return G_UNICODE_SCRIPT_UNKNOWN;
+}
+
+/**
+ * g_unichar_get_script:
+ * @ch: a Unicode character
+ *
+ * Looks up the #GUnicodeScript for a particular character (as defined
+ * by Unicode Standard Annex #24). No check is made for @ch being a
+ * valid Unicode character; if you pass in invalid character, the
+ * result is undefined.
+ *
+ * This function is equivalent to pango_script_for_unichar() and the
+ * two are interchangeable.
+ *
+ * Return value: the #GUnicodeScript for the character.
+ *
+ * Since: 2.14
+ */
+GUnicodeScript
+g_unichar_get_script (gunichar ch)
+{
+ if (ch < G_EASY_SCRIPTS_RANGE)
+ return g_script_easy_table[ch];
+ else
+ return g_unichar_get_script_bsearch (ch);
+}
projects / rspamd.git / commitdiff