6437624 RFE: Add ksh93 (as /usr/bin/ksh93) and libshell.so to OS/Net

6505835 AST tools and library (libpp) required for creating l10n messages for ksh93
PSARC/2006/550 Korn Shell 93 Integration
PSARC/2006/587 /etc/ksh.kshrc for ksh93
PSARC/2007/035 ksh93 Amendments
Contributed by Roland Mainz <roland.mainz@nrubsig.org>

--HG--
rename : usr/src/lib/libcmd/common/mapfile-vers => deleted_files/usr/src/lib/libcmd/common/mapfile-vers
rename : usr/src/lib/libcmd/common/placeholder.c => deleted_files/usr/src/lib/libcmd/common/placeholder.c

19 files changed, 15469 insertions, 0 deletions

diff --git a/usr/src/lib/libast/common/regex/regalloc.c b/usr/src/lib/libast/common/regex/regalloc.c
new file mode 100644
index 0000000000..76d37de427
--- /dev/null
+++ b/usr/src/lib/libast/common/regex/regalloc.c
@@ -0,0 +1,36 @@
+/***********************************************************************
+*                                                                      *
+*               This software is part of the ast package               *
+*           Copyright (c) 1985-2007 AT&T Knowledge Ventures            *
+*                      and is licensed under the                       *
+*                  Common Public License, Version 1.0                  *
+*                      by AT&T Knowledge Ventures                      *
+*                                                                      *
+*                A copy of the License is available at                 *
+*            http://www.opensource.org/licenses/cpl1.0.txt             *
+*         (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9)         *
+*                                                                      *
+*              Information and Software Systems Research               *
+*                            AT&T Research                             *
+*                           Florham Park NJ                            *
+*                                                                      *
+*                 Glenn Fowler <gsf@research.att.com>                  *
+*                  David Korn <dgk@research.att.com>                   *
+*                   Phong Vo <kpv@research.att.com>                    *
+*                                                                      *
+***********************************************************************/
+#pragma prototyped
+
+/*
+ * posix regex alloc control
+ */
+
+#include "reglib.h"
+
+void
+regalloc(void* handle, void*(*resize)(void*,void*,size_t), regflags_t flags)
+{
+	state.disc.re_flags = flags;
+	state.disc.re_resizef = resize;
+	state.disc.re_resizehandle = handle;
+}
diff --git a/usr/src/lib/libast/common/regex/regcache.c b/usr/src/lib/libast/common/regex/regcache.c
new file mode 100644
index 0000000000..ff9554e904
--- /dev/null
+++ b/usr/src/lib/libast/common/regex/regcache.c
@@ -0,0 +1,174 @@
+/***********************************************************************
+*                                                                      *
+*               This software is part of the ast package               *
+*           Copyright (c) 1985-2007 AT&T Knowledge Ventures            *
+*                      and is licensed under the                       *
+*                  Common Public License, Version 1.0                  *
+*                      by AT&T Knowledge Ventures                      *
+*                                                                      *
+*                A copy of the License is available at                 *
+*            http://www.opensource.org/licenses/cpl1.0.txt             *
+*         (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9)         *
+*                                                                      *
+*              Information and Software Systems Research               *
+*                            AT&T Research                             *
+*                           Florham Park NJ                            *
+*                                                                      *
+*                 Glenn Fowler <gsf@research.att.com>                  *
+*                  David Korn <dgk@research.att.com>                   *
+*                   Phong Vo <kpv@research.att.com>                    *
+*                                                                      *
+***********************************************************************/
+#pragma prototyped
+
+/*
+ * regcomp() regex_t cache
+ * AT&T Research
+ */
+
+#include <ast.h>
+#include <regex.h>
+
+#define CACHE		8		/* # cached re's		*/
+#define MAXPAT		256		/* max pattern length + 1	*/
+
+#define KEEP		01
+#define DROP		02
+
+typedef struct Cache_s
+{
+	regex_t		re;
+	unsigned long	serial;
+	regflags_t	reflags;
+	int		flags;
+	char		pattern[MAXPAT];
+} Cache_t;
+
+static struct State_s
+{
+	Cache_t*	cache[CACHE];
+	unsigned long	serial;
+	char*		locale;
+} matchstate;
+
+/*
+ * flush the cache
+ */
+
+static void
+flushcache(void)
+{
+	register int		i;
+
+	for (i = 0; i < elementsof(matchstate.cache); i++)
+		if (matchstate.cache[i] && matchstate.cache[i]->flags)
+		{
+			matchstate.cache[i]->flags = 0;
+			regfree(&matchstate.cache[i]->re);
+		}
+}
+
+/*
+ * return regcomp() compiled re for pattern and reflags
+ */
+
+regex_t*
+regcache(const char* pattern, regflags_t reflags, int* status)
+{
+	register Cache_t*	cp;
+	register int		i;
+	char*			s;
+	int			empty;
+	int			unused;
+	int			old;
+
+	/*
+	 * 0 pattern flushes the cache
+	 */
+
+	if (!pattern)
+	{
+		flushcache();
+		if (status)
+			*status = 0;
+		return 0;
+	}
+
+	/*
+	 * flush the cache if the locale changed
+	 * the ast setlocale() intercept maintains
+	 * persistent setlocale() return values
+	 */
+
+	if ((s = setlocale(LC_CTYPE, NiL)) != matchstate.locale)
+	{
+		matchstate.locale = s;
+		flushcache();
+	}
+
+	/*
+	 * check if the pattern is in the cache
+	 */
+
+	empty = unused = -1;
+	old = 0;
+	for (i = 0; i < elementsof(matchstate.cache); i++)
+		if (!matchstate.cache[i])
+			empty = i;
+		else if (!(matchstate.cache[i]->flags & KEEP))
+		{
+			if (matchstate.cache[i]->flags)
+			{
+				matchstate.cache[i]->flags = 0;
+				regfree(&matchstate.cache[i]->re);
+			}
+			unused = i;
+		}
+		else if (streq(matchstate.cache[i]->pattern, pattern) && matchstate.cache[i]->reflags == reflags)
+			break;
+		else if (!matchstate.cache[old] || matchstate.cache[old]->serial > matchstate.cache[i]->serial)
+			old = i;
+	if (i >= elementsof(matchstate.cache))
+	{
+		if (unused < 0)
+		{
+			if (empty < 0)
+				unused = old;
+			else
+				unused = empty;
+		}
+		if (!(cp = matchstate.cache[unused]) && !(cp = matchstate.cache[unused] = newof(0, Cache_t, 1, 0)))
+		{
+			if (status)
+				*status = REG_ESPACE;
+			return 0;
+		}
+		if (cp->flags)
+		{
+			cp->flags = 0;
+			regfree(&cp->re);
+		}
+		cp->reflags = reflags;
+		if (strlen(pattern) < sizeof(cp->pattern))
+		{
+			strcpy(cp->pattern, pattern);
+			pattern = (const char*)cp->pattern;
+			cp->flags = KEEP;
+		}
+		else
+			cp->flags = DROP;
+		if (i = regcomp(&cp->re, pattern, cp->reflags))
+		{
+			if (status)
+				*status = i;
+			cp->flags = 0;
+			return 0;
+		}
+	}
+	else
+		cp = matchstate.cache[i];
+	cp->serial = ++matchstate.serial;
+	if (status)
+		*status = 0;
+	return &cp->re;
+}
diff --git a/usr/src/lib/libast/common/regex/regclass.c b/usr/src/lib/libast/common/regex/regclass.c
new file mode 100644
index 0000000000..85eac41f55
--- /dev/null
+++ b/usr/src/lib/libast/common/regex/regclass.c
@@ -0,0 +1,243 @@
+/***********************************************************************
+*                                                                      *
+*               This software is part of the ast package               *
+*           Copyright (c) 1985-2007 AT&T Knowledge Ventures            *
+*                      and is licensed under the                       *
+*                  Common Public License, Version 1.0                  *
+*                      by AT&T Knowledge Ventures                      *
+*                                                                      *
+*                A copy of the License is available at                 *
+*            http://www.opensource.org/licenses/cpl1.0.txt             *
+*         (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9)         *
+*                                                                      *
+*              Information and Software Systems Research               *
+*                            AT&T Research                             *
+*                           Florham Park NJ                            *
+*                                                                      *
+*                 Glenn Fowler <gsf@research.att.com>                  *
+*                  David Korn <dgk@research.att.com>                   *
+*                   Phong Vo <kpv@research.att.com>                    *
+*                                                                      *
+***********************************************************************/
+#pragma prototyped
+/*
+ * RE character class support
+ */
+
+#include "reglib.h"
+
+struct Ctype_s; typedef struct Ctype_s Ctype_t;
+
+struct Ctype_s
+{
+	const char*	name;
+	size_t		size;
+	regclass_t	ctype;
+	Ctype_t*	next;
+#if _lib_wctype
+	wctype_t	wtype;
+#endif
+};
+
+static Ctype_t*		ctypes;
+
+#define CTYPES		12
+#if _lib_wctype
+#define WTYPES		8
+#else
+#define WTYPES		0
+#endif
+
+/*
+ * this stuff gets around posix failure to define isblank,
+ * and the fact that ctype functions are macros
+ * and any local extensions that may not even have functions or macros
+ */
+
+#if _need_iswblank
+
+int
+_reg_iswblank(wint_t wc)
+{
+	static int	initialized;
+	static wctype_t	wt;
+
+	if (!initialized)
+	{
+		initialized = 1;
+		wt = wctype("blank");
+	}
+	return iswctype(wc, wt);
+}
+
+#endif
+
+static int  Isalnum(int c) { return  iswalnum(c); }
+static int  Isalpha(int c) { return  iswalpha(c); }
+static int  Isblank(int c) { return  iswblank(c); }
+static int  Iscntrl(int c) { return  iswcntrl(c); }
+static int  Isdigit(int c) { return  iswdigit(c); }
+static int Notdigit(int c) { return !iswdigit(c); }
+static int  Isgraph(int c) { return  iswgraph(c); }
+static int  Islower(int c) { return  iswlower(c); }
+static int  Isprint(int c) { return  iswprint(c); }
+static int  Ispunct(int c) { return  iswpunct(c); }
+static int  Isspace(int c) { return  iswspace(c); }
+static int Notspace(int c) { return !iswspace(c); }
+static int  Isupper(int c) { return  iswupper(c); }
+static int   Isword(int c) { return  iswalnum(c) || c == '_'; }
+static int  Notword(int c) { return !iswalnum(c) && c != '_'; }
+static int Isxdigit(int c) { return  iswxdigit(c);}
+
+#if _lib_wctype
+
+static int Is_wc_1(int);
+static int Is_wc_2(int);
+static int Is_wc_3(int);
+static int Is_wc_4(int);
+static int Is_wc_5(int);
+static int Is_wc_6(int);
+static int Is_wc_7(int);
+static int Is_wc_8(int);
+
+#endif
+
+#define SZ(s)		s,(sizeof(s)-1)
+
+static Ctype_t ctype[] =
+{
+	{ SZ("alnum"), Isalnum },
+	{ SZ("alpha"), Isalpha },
+	{ SZ("blank"), Isblank },
+	{ SZ("cntrl"), Iscntrl },
+	{ SZ("digit"), Isdigit },
+	{ SZ("graph"), Isgraph },
+	{ SZ("lower"), Islower },
+	{ SZ("print"), Isprint },
+	{ SZ("punct"), Ispunct },
+	{ SZ("space"), Isspace },
+	{ SZ("upper"), Isupper },
+	{ SZ("word"),  Isword  },
+	{ SZ("xdigit"),Isxdigit},
+#if _lib_wctype
+	{ 0, 0,        Is_wc_1 },
+	{ 0, 0,        Is_wc_2 },
+	{ 0, 0,        Is_wc_3 },
+	{ 0, 0,        Is_wc_4 },
+	{ 0, 0,        Is_wc_5 },
+	{ 0, 0,        Is_wc_6 },
+	{ 0, 0,        Is_wc_7 },
+	{ 0, 0,        Is_wc_8 },
+#endif
+};
+
+#if _lib_wctype
+
+static int Is_wc_1(int c) { return iswctype(c, ctype[CTYPES+0].wtype); }
+static int Is_wc_2(int c) { return iswctype(c, ctype[CTYPES+1].wtype); }
+static int Is_wc_3(int c) { return iswctype(c, ctype[CTYPES+2].wtype); }
+static int Is_wc_4(int c) { return iswctype(c, ctype[CTYPES+3].wtype); }
+static int Is_wc_5(int c) { return iswctype(c, ctype[CTYPES+4].wtype); }
+static int Is_wc_6(int c) { return iswctype(c, ctype[CTYPES+5].wtype); }
+static int Is_wc_7(int c) { return iswctype(c, ctype[CTYPES+6].wtype); }
+static int Is_wc_8(int c) { return iswctype(c, ctype[CTYPES+7].wtype); }
+
+#endif
+
+/*
+ * return pointer to ctype function for :class:] in s
+ * s points to the first char after the initial [
+ * if e!=0 it points to next char in s
+ * 0 returned on error
+ */
+
+regclass_t
+regclass(const char* s, char** e)
+{
+	register Ctype_t*	cp;
+	register int		c;
+	register size_t		n;
+	register const char*	t;
+
+	if (c = *s++)
+	{
+		for (t = s; *t && (*t != c || *(t + 1) != ']'); t++);
+		if (*t != c)
+			return 0;
+		n = t - s;
+		for (cp = ctypes; cp; cp = cp->next)
+			if (n == cp->size && strneq(s, cp->name, n))
+				goto found;
+		for (cp = ctype; cp < &ctype[elementsof(ctype)]; cp++)
+		{
+#if _lib_wctype
+			if (!cp->size && (cp->name = (const char*)memdup(s, n + 1)))
+			{
+				*((char*)cp->name + n) = 0;
+				/* mvs.390 needs the (char*) cast -- barf */
+				if (!(cp->wtype = wctype((char*)cp->name)))
+				{
+					free((char*)cp->name);
+					return 0;
+				}
+				cp->size = n;
+				goto found;
+			}
+#endif
+			if (n == cp->size && strneq(s, cp->name, n))
+				goto found;
+		}
+	}
+	return 0;
+ found:
+	if (e)
+		*e = (char*)t + 2;
+	return cp->ctype;
+}
+
+/*
+ * associate the ctype function fun with name
+ */
+
+int
+regaddclass(const char* name, regclass_t fun)
+{
+	register Ctype_t*	cp;
+	register Ctype_t*	np;
+	register size_t		n;
+
+	n = strlen(name);
+	for (cp = ctypes; cp; cp = cp->next)
+		if (cp->size == n && strneq(name, cp->name, n))
+		{
+			cp->ctype = fun;
+			return 0;
+		}
+	if (!(np = newof(0, Ctype_t, 1, n + 1)))
+		return REG_ESPACE;
+	np->size = n;
+	np->name = strcpy((char*)(np + 1), name);
+	np->ctype = fun;
+	np->next = ctypes;
+	ctypes = np;
+	return 0;
+}
+
+/*
+ * return pointer to ctype function for token
+ */
+
+regclass_t
+classfun(int type)
+{
+	switch (type)
+	{
+	case T_ALNUM:		return  Isword;
+	case T_ALNUM_NOT:	return Notword;
+	case T_DIGIT:		return  Isdigit;
+	case T_DIGIT_NOT:	return Notdigit;
+	case T_SPACE:		return  Isspace;
+	case T_SPACE_NOT:	return Notspace;
+	}
+	return 0;
+}
diff --git a/usr/src/lib/libast/common/regex/regcoll.c b/usr/src/lib/libast/common/regex/regcoll.c
new file mode 100644
index 0000000000..29bb85ffc0
--- /dev/null
+++ b/usr/src/lib/libast/common/regex/regcoll.c
@@ -0,0 +1,297 @@
+/***********************************************************************
+*                                                                      *
+*               This software is part of the ast package               *
+*           Copyright (c) 1985-2007 AT&T Knowledge Ventures            *
+*                      and is licensed under the                       *
+*                  Common Public License, Version 1.0                  *
+*                      by AT&T Knowledge Ventures                      *
+*                                                                      *
+*                A copy of the License is available at                 *
+*            http://www.opensource.org/licenses/cpl1.0.txt             *
+*         (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9)         *
+*                                                                      *
+*              Information and Software Systems Research               *
+*                            AT&T Research                             *
+*                           Florham Park NJ                            *
+*                                                                      *
+*                 Glenn Fowler <gsf@research.att.com>                  *
+*                  David Korn <dgk@research.att.com>                   *
+*                   Phong Vo <kpv@research.att.com>                    *
+*                                                                      *
+***********************************************************************/
+#pragma prototyped
+/*
+ * regex collation symbol support
+ */
+
+#include "reglib.h"
+
+#include <ccode.h>
+
+#ifndef UCS_BYTE
+#define UCS_BYTE	1
+#endif
+
+#include "ucs_names.h"
+
+typedef struct Ucs_map_s
+{
+	Ucs_attr_t		attr[3];
+	Ucs_code_t		code;
+	const char*		name;
+	Dtlink_t		link;
+	struct Ucs_map_s*	next;
+} Ucs_map_t;
+
+#define setattr(a,i)	((a)[(i)>>5]|=(1<<((i)&((1<<5)-1))))
+#define tstattr(a,i)	((a)[(i)>>5]&(1<<((i)&((1<<5)-1))))
+#define clrattr(a,i)	((a)[(i)>>5]&=~(1<<((i)&((1<<5)-1))))
+
+static struct Local_s
+{
+	int		fatal;
+	Dt_t*		attrs;
+	Dt_t*		names;
+	Dtdisc_t	dtdisc;
+#if CC_NATIVE != CC_ASCII
+	unsigned char*	a2n;
+#endif
+} local;
+
+/*
+ * initialize the writeable tables from the readonly data
+ * the tables are big enough to be concerned about text vs. data vs. bss
+ *	UCS_BYTE==0 100K
+ *	UCS_BYTE==1  20K
+ */
+
+static int
+initialize(void)
+{
+	register int		i;
+	register Ucs_map_t*	a;
+	register Ucs_map_t*	w;
+
+	if (local.fatal)
+		return -1;
+	local.dtdisc.link = offsetof(Ucs_map_t, link);
+	local.dtdisc.key = offsetof(Ucs_map_t, name);
+	local.dtdisc.size = -1;
+	if (!(w = (Ucs_map_t*)malloc(sizeof(Ucs_map_t) * (elementsof(ucs_attrs) + elementsof(ucs_names)))))
+	{
+		local.fatal = 1;
+		return -1;
+	}
+	if (!(local.attrs = dtopen(&local.dtdisc, Dttree)))
+	{
+		free(w);
+		local.fatal = 1;
+		return -1;
+	}
+	if (!(local.names = dtopen(&local.dtdisc, Dttree)))
+	{
+		free(w);
+		dtclose(local.attrs);
+		local.fatal = 1;
+		return -1;
+	}
+	for (i = 0; i < elementsof(ucs_attrs); i++, w++)
+	{
+		memcpy(w, &ucs_attrs[i], offsetof(Ucs_dat_t, table));
+		w->name = ucs_strings[ucs_attrs[i].table] + ucs_attrs[i].index;
+		w->next = 0;
+		dtinsert(local.attrs, w);
+	}
+	for (i = 0; i < elementsof(ucs_names); i++, w++)
+	{
+		memcpy(w, &ucs_names[i], offsetof(Ucs_dat_t, table));
+		w->name = ucs_strings[ucs_names[i].table] + ucs_names[i].index;
+		w->next = 0;
+		if (a = (Ucs_map_t*)dtsearch(local.names, w))
+		{
+			while (a->next)
+				a = a->next;
+			a->next = w;
+		}
+		else
+			dtinsert(local.names, w);
+	}
+#if CC_NATIVE != CC_ASCII
+	local.a2n = ccmap(CC_ASCII, CC_NATIVE);
+#endif
+	return 0;
+}
+
+/*
+ * return the collating symbol delimited by [c c], where c is either '=' or '.'
+ * s points to the first char after the initial [
+ * if e!=0 it is set to point to the next char in s on return
+ *
+ * the collating symbol is converted to multibyte in <buf,size>
+ * the return value is:
+ *	-1	syntax error or buf not large enough
+ *	>=0	size with 0-terminated mb collation element
+ *		or ligature value in buf
+ */
+
+int
+regcollate(register const char* s, char** e, char* buf, int size)
+{
+	register int		c;
+	register char*		u;
+	register char*		b;
+	register char*		x;
+	register Ucs_map_t*	a;
+	Ucs_map_t*		z;
+	const char*		t;
+	const char*		v;
+	int			n;
+	int			r;
+	int			ul;
+	int			term;
+	wchar_t			w[2];
+	Ucs_attr_t		attr[3];
+
+	if (size < 2)
+		r = -1;
+	else if ((term = *s++) != '.' && term != '=')
+	{
+		s--;
+		r = -1;
+	}
+	else if (*s == term && *(s + 1) == ']')
+		r = -1;
+	else
+	{
+		t = s;
+		mbchar(s);
+		if ((n = (s - t)) == 1)
+		{
+			if (*s == term && *(s + 1) == ']')
+			{
+				s += 2;
+				r = -1;
+			}
+			else
+			{
+				if (!local.attrs && initialize())
+					return -1;
+				attr[0] = attr[1] = attr[2] = 0;
+				ul = 0;
+				b = buf;
+				x = buf + size - 2;
+				r = 1;
+				s = t;
+				do
+				{
+					v = s;
+					u = b;
+					for (;;)
+					{
+						if (!(c = *s++))
+							return -1;
+						if (c == term)
+						{
+							if (!(c = *s++))
+								return -1;
+							if (c != term)
+							{
+								if (c != ']')
+									return -1;
+								r = -1;
+								break;
+							}
+						}
+						if (c == ' ' || c == '-' && u > b && *s != ' ' && *s != '-')
+							break;
+						if (isupper(c))
+							c = tolower(c);
+						if (u > x)
+							break;
+						*u++ = c;
+					}
+					*u = 0;
+					if (a = (Ucs_map_t*)dtmatch(local.attrs, b))
+						setattr(attr, a->code);
+					else
+					{
+						if (u < x)
+							*u++ = ' ';
+						if (b == buf)
+						{
+							if (isupper(*v))
+								ul = UCS_UC;
+							else if (islower(*v))
+								ul = UCS_LC;
+						}
+						b = u;
+					}
+				} while (r > 0);
+				if (b > buf && *(b - 1) == ' ')
+					b--;
+				*b = 0;
+				attr[0] &= ~((Ucs_attr_t)1);
+				if (ul)
+				{
+					if (tstattr(attr, UCS_UC) || tstattr(attr, UCS_LC))
+						ul = 0;
+					else
+						setattr(attr, ul);
+				}
+				if (z = (Ucs_map_t*)dtmatch(local.names, buf))
+					for(;;)
+					{
+						for (a = z; a; a = a->next)
+							if ((attr[0] & a->attr[0]) == attr[0] && (attr[1] & a->attr[1]) == attr[1] && (attr[2] & a->attr[2]) == attr[2])
+							{
+								if (a->code <= 0xff)
+								{
+#if CC_NATIVE != CC_ASCII
+									buf[0] = local.a2n[a->code];
+#else
+									buf[0] = a->code;
+#endif
+									buf[r = 1] = 0;
+									ul = 0;
+									break;
+								}
+								w[0] = a->code;
+								w[1] = 0;
+								if ((r = wcstombs(buf, w, size)) > 0)
+								{
+									r--;
+									ul = 0;
+								}
+								break;
+							}
+						if (!ul)
+							break;
+						clrattr(attr, ul);
+						ul = 0;
+					}
+			}
+			if (r < 0)
+			{
+				if ((r = s - t - 2) > (size - 1))
+					return -1;
+				memcpy(buf, t, r);
+				buf[r] = 0;
+			}
+		}
+		else if (*s++ != term || *s++ != ']')
+		{
+			s--;
+			r = -1;
+		}
+		else if (n > (size - 1))
+			r = -1;
+		else
+		{
+			memcpy(buf, t, n);
+			buf[r = n] = 0;
+		}
+	}
+	if (e)
+		*e = (char*)s;
+	return r;
+}
diff --git a/usr/src/lib/libast/common/regex/regcomp.c b/usr/src/lib/libast/common/regex/regcomp.c
new file mode 100644
index 0000000000..dc34df68fa
--- /dev/null
+++ b/usr/src/lib/libast/common/regex/regcomp.c
@@ -0,0 +1,3485 @@
+/***********************************************************************
+*                                                                      *
+*               This software is part of the ast package               *
+*           Copyright (c) 1985-2007 AT&T Knowledge Ventures            *
+*                      and is licensed under the                       *
+*                  Common Public License, Version 1.0                  *
+*                      by AT&T Knowledge Ventures                      *
+*                                                                      *
+*                A copy of the License is available at                 *
+*            http://www.opensource.org/licenses/cpl1.0.txt             *
+*         (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9)         *
+*                                                                      *
+*              Information and Software Systems Research               *
+*                            AT&T Research                             *
+*                           Florham Park NJ                            *
+*                                                                      *
+*                 Glenn Fowler <gsf@research.att.com>                  *
+*                  David Korn <dgk@research.att.com>                   *
+*                   Phong Vo <kpv@research.att.com>                    *
+*                                                                      *
+***********************************************************************/
+#pragma prototyped
+
+/*
+ * posix regex compiler
+ */
+
+#include "reglib.h"
+
+#if _PACKAGE_ast
+#include "lclib.h"
+#endif
+
+#define serialize		re_serialize	/* hp.ia64 <unistd.h>! */
+
+#define C_ESC			(-1)
+#define C_MB			(-2)
+
+#if _AST_REGEX_DEBUG
+
+#define DEBUG_TEST(f,y,n)	((debug&(debug_flag=f))?(y):(n))
+#define DEBUG_CODE(f,y,n)	do if(debug&(f)){y}else{n} while(0)
+#define DEBUG_INIT()		do { char* t; if (!debug) { debug = 0x80000000; if (t = getenv("_AST_regex_comp_debug")) debug |= strtoul(t, NiL, 0); } } while (0)
+
+static unsigned long	debug;
+static unsigned long	debug_flag;
+
+#else
+
+#define DEBUG_INIT()
+#define DEBUG_TEST(f,y,n)	(n)
+#define DEBUG_CODE(f,y,n)	do {n} while(0)
+
+#endif
+
+#if _PACKAGE_ast
+
+typedef struct Cchr_s
+{
+	Dtlink_t	lnk;
+	unsigned char	nam[2];
+	Ckey_t		key;
+} Cchr_t;
+
+#endif
+
+#define eat(p)		do{if ((p)->token.push)(p)->token.push=0;else (p)->cursor+=(p)->token.len;}while (0)
+
+/*
+ * determine whether greedy matching will work, i.e. produce
+ * the best match first.  such expressions are "easy", and
+ * need no backtracking once a complete match is found.  
+ * if an expression has backreferences or alts it's hard
+ * else if it has only one closure it's easy
+ * else if all closures are simple (i.e. one-character) it's easy
+ * else it's hard.
+ */
+
+typedef struct Stats_s
+{
+	unsigned long	l;	/* min length to left of x		*/
+	unsigned long	k;	/* min length to left of y		*/
+	unsigned long	m;	/* min length				*/
+	unsigned long	n;	/* max length				*/
+	unsigned short	a;	/* number of alternations		*/
+	unsigned short	b;	/* number of backrefs			*/
+	unsigned short	c;	/* number of closures			*/
+	unsigned short	i;	/* number of negations			*/
+	unsigned short	p;	/* number of named subexpressions	*/
+	unsigned short	s;	/* number of simple closures		*/
+	unsigned short	t;	/* number of tries			*/
+	unsigned short	u;	/* number of unnamed subexpressions	*/
+	Rex_t*		x;	/* max length REX_STRING		*/
+	Rex_t*		y;	/* max length REX_TRIE			*/
+} Stats_t;
+
+typedef struct Token_s
+{
+	unsigned long	min;
+	unsigned long	max;
+	short		lex;
+	short		len;
+	short		esc;
+	short		att;
+	short		push;
+} Token_t;
+
+typedef struct Cenv_s
+{
+	int		delimiter;	/* pattern delimiter		*/
+	int		error;		/* last error			*/
+	int		explicit;	/* explicit match on this char	*/
+	int		mappeddot;	/* inverse mapped '.'		*/
+	int		mappednewline;	/* inverse mapped '\n'		*/
+	int		mappedslash;	/* inverse mapped '/'		*/
+	regflags_t	flags;		/* flags arg to regcomp		*/
+	int		type;		/* BRE,ERE,ARE,SRE,KRE		*/
+	unsigned char*	cursor;		/* curent point in re		*/
+	unsigned char*	pattern;	/* the original pattern		*/
+	unsigned char*	literal;	/* literal restart pattern	*/
+	int		parno;		/* number of last open paren	*/
+	int		parnest;	/* paren nest count		*/
+	int		posixkludge; 	/* to make * nonspecial		*/
+	Token_t		token;		/* token lookahead		*/
+	Stats_t		stats;		/* RE statistics		*/
+	int		terminator;	/* pattern terminator		*/
+	Rex_t*		paren[2*(BACK_REF_MAX+2)];
+					/* paren[i]!=0 if \i defined	*/
+	regex_t*	regex;		/* user handle			*/
+	regdisc_t*	disc;		/* user discipline		*/
+	unsigned char*	map;		/* external to native ccode map	*/
+	unsigned char*	MAP;		/* fold and/or map		*/
+} Cenv_t;
+
+/*
+ * allocate a new Rex_t node
+ */
+
+static Rex_t*
+node(Cenv_t* env, int type, int lo, int hi, size_t extra)
+{
+	register Rex_t*	e;
+
+	if (e = (Rex_t*)alloc(env->disc, 0, sizeof(Rex_t) + extra))
+	{
+		memset(e, 0, sizeof(Rex_t) + extra);
+		e->type = type;
+		e->marked = 0;
+		e->lo = lo;
+		e->hi = hi;
+		e->flags = env->flags;
+		e->map = (e->flags & REG_ICASE) ? env->MAP : env->map;
+		e->explicit = env->explicit;
+		if (extra)
+			e->re.data = (char*)e + sizeof(Rex_t);
+	}
+	return e;
+}
+
+/*
+ * free a Trie_node_t node
+ */
+
+static void
+triedrop(regdisc_t* disc, Trie_node_t* e)
+{
+	if (e)
+	{
+		triedrop(disc, e->son);
+		triedrop(disc, e->sib);
+		alloc(disc, e, 0);
+	}
+}
+
+/*
+ * free a Rex_t node
+ */
+
+void
+drop(regdisc_t* disc, Rex_t* e)
+{
+	int	i;
+	Rex_t*	x;
+
+	if (e && !(disc->re_flags & REG_NOFREE))
+		do
+		{
+			switch (e->type)
+			{
+			case REX_ALT:
+			case REX_CONJ:
+				drop(disc, e->re.group.expr.binary.left);
+				drop(disc, e->re.group.expr.binary.right);
+				break;
+			case REX_GROUP:
+			case REX_GROUP_AHEAD:
+			case REX_GROUP_AHEAD_NOT:
+			case REX_GROUP_BEHIND:
+			case REX_GROUP_BEHIND_NOT:
+			case REX_GROUP_CUT:
+			case REX_NEG:
+			case REX_REP:
+				drop(disc, e->re.group.expr.rex);
+				break;
+			case REX_TRIE:
+				for (i = 0; i <= UCHAR_MAX; i++)
+					triedrop(disc, e->re.trie.root[i]);
+				break;
+			}
+			x = e->next;
+			alloc(disc, e, 0);
+		} while (e = x);
+}
+
+/*
+ * mark e and descendants minimal
+ */
+
+static void
+mark(register Rex_t* e, int set)
+{
+	if (e && !e->marked)
+		do
+		{
+			e->marked = 1;
+			if (set)
+				e->flags |= REG_MINIMAL;
+			else
+				e->flags &= ~REG_MINIMAL;
+			switch (e->type)
+			{
+			case REX_ALT:
+			case REX_CONJ:
+			case REX_GROUP_COND:
+				if (e->re.group.expr.binary.left)
+					mark(e->re.group.expr.binary.left, set);
+				if (e->re.group.expr.binary.right)
+					mark(e->re.group.expr.binary.right, set);
+				break;
+			case REX_GROUP:
+			case REX_GROUP_AHEAD:
+			case REX_GROUP_AHEAD_NOT:
+			case REX_GROUP_BEHIND:
+			case REX_GROUP_BEHIND_NOT:
+			case REX_GROUP_CUT:
+			case REX_NEG:
+			case REX_REP:
+			case REX_TRIE:
+				mark(e->re.group.expr.rex, set);
+				break;
+			}
+		} while (e = e->next);
+}
+
+/*
+ * assign subexpression numbers by a preorder tree walk
+ */
+
+static int
+serialize(Cenv_t* env, Rex_t* e, int n)
+{
+	do
+	{
+		e->serial = n++;
+		switch (e->type)
+		{
+		case REX_ALT:
+		case REX_GROUP_COND:
+			if (e->re.group.expr.binary.left)
+				n = serialize(env, e->re.group.expr.binary.left, n);
+			e->re.group.expr.binary.serial = n++;
+			if (e->re.group.expr.binary.right)
+				n = serialize(env, e->re.group.expr.binary.right, n);
+			break;
+		case REX_CONJ:
+			n = serialize(env, e->re.group.expr.binary.left, n);
+			n = serialize(env, e->re.group.expr.binary.right, n);
+			break;
+		case REX_GROUP:
+		case REX_GROUP_AHEAD:
+		case REX_GROUP_AHEAD_NOT:
+		case REX_GROUP_BEHIND:
+		case REX_GROUP_BEHIND_NOT:
+		case REX_GROUP_CUT:
+		case REX_NEG:
+		case REX_REP:
+			n = serialize(env, e->re.group.expr.rex, n);
+			break;
+		}
+	} while (e = e->next);
+	return n;
+}
+
+/*
+ * catenate e and f into a sequence, collapsing them if possible
+ */
+
+static Rex_t*
+cat(Cenv_t* env, Rex_t* e, Rex_t* f)
+{
+	Rex_t*	g;
+
+	if (!f)
+	{
+		drop(env->disc, e);
+		return 0;
+	}
+	if (e->type == REX_NULL)
+	{
+		drop(env->disc, e);
+		return f;
+	}
+	if (f->type == REX_NULL)
+	{
+		g = f->next;
+		f->next = 0;
+		drop(env->disc, f);
+		f = g;
+	}
+	else if (e->type == REX_DOT && f->type == REX_DOT)
+	{
+		unsigned int	m = e->lo + f->lo;
+		unsigned int	n = e->hi + f->hi;
+
+		if (m <= RE_DUP_MAX)
+		{
+			if (e->hi > RE_DUP_MAX || f->hi > RE_DUP_MAX)
+			{
+				n = RE_DUP_INF;	
+				goto combine;
+			}
+			else if (n <= RE_DUP_MAX)
+			{
+			combine:
+				e->lo = m;
+				e->hi = n;
+				g = f->next;
+				f->next = 0;
+				drop(env->disc, f);
+				f = g;
+			}
+		}
+	}
+	e->next = f;
+	return e;
+}
+
+/*
+ * collect re statistics
+ */
+
+static int
+stats(register Cenv_t* env, register Rex_t* e)
+{
+	register unsigned long	n;
+	register unsigned long	m;
+	unsigned long		cm;
+	unsigned long		nm;
+	unsigned long		cn;
+	unsigned long		nn;
+	unsigned long		l;
+	unsigned long		k;
+	unsigned long		t;
+	Rex_t*			q;
+	Rex_t*			x;
+	Rex_t*			y;
+	unsigned char		c;
+	unsigned char		b;
+
+	do
+	{
+		switch (e->type)
+		{
+		case REX_ALT:
+			x = env->stats.x;
+			l = env->stats.l;
+			y = env->stats.y;
+			k = env->stats.k;
+			t = env->stats.t;
+			if (++env->stats.a <= 0)
+				return 1;
+			cm = env->stats.m;
+			env->stats.m = 0;
+			cn = env->stats.n;
+			env->stats.n = 0;
+			if (stats(env, e->re.group.expr.binary.left))
+				return 1;
+			m = env->stats.m;
+			env->stats.m = 0;
+			n = env->stats.n;
+			env->stats.n = 0;
+			if (e->re.group.expr.binary.right && stats(env, e->re.group.expr.binary.right))
+				return 1;
+			if (env->stats.m > m)
+				env->stats.m = m;
+			else
+				m = env->stats.m;
+			if ((env->stats.m += cm) < m)
+				return 1;
+			if (env->stats.n < n)
+				env->stats.n = n;
+			else
+				n = env->stats.n;
+			if ((env->stats.n += cn) < n)
+				return 1;
+			env->stats.x = x;
+			env->stats.l = l;
+			env->stats.y = y;
+			env->stats.k = k;
+			env->stats.t = t;
+			break;
+		case REX_BACK:
+			if (++env->stats.b <= 0)
+				return 1;
+			break;
+		case REX_CLASS:
+		case REX_COLL_CLASS:
+		case REX_DOT:
+		case REX_ONECHAR:
+			n = env->stats.m;
+			if ((env->stats.m += e->lo) < n)
+				return 1;
+			if (e->hi != RE_DUP_INF)
+			{
+				n = env->stats.n;
+				if ((env->stats.n += e->hi) < n)
+					return 1;
+			}
+			if (e->lo != e->hi)
+			{
+				if (++env->stats.c <= 0)
+					return 1;
+				if (++env->stats.s <= 0)
+					return 1;
+			}
+			break;
+		case REX_CONJ:
+			cm = env->stats.m;
+			env->stats.m = 0;
+			cn = env->stats.n;
+			env->stats.n = 0;
+			if (stats(env, e->re.group.expr.binary.left))
+				return 1;
+			nm = env->stats.m;
+			env->stats.m = 0;
+			nn = env->stats.n;
+			env->stats.n = 0;
+			if (stats(env, e->re.group.expr.binary.right))
+				return 1;
+			if (env->stats.m < nm)
+				env->stats.m = nm;
+			else
+				nm = env->stats.m;
+			if ((env->stats.m += cm) < nm)
+				return 1;
+			if (env->stats.n < nn)
+				env->stats.n = nn;
+			else
+				nn = env->stats.n;
+			if ((env->stats.n += cn) < nn)
+				return 1;
+			break;
+		case REX_GROUP:
+			if (e->re.group.number && ++env->stats.p <= 0 || !e->re.group.number && ++env->stats.u <= 0)
+				return 1;
+			if (stats(env, e->re.group.expr.rex))
+				return 1;
+			break;
+		case REX_GROUP_AHEAD:
+		case REX_GROUP_AHEAD_NOT:
+		case REX_GROUP_BEHIND:
+		case REX_GROUP_BEHIND_NOT:
+			m = env->stats.m;
+			n = env->stats.n;
+			x = env->stats.x;
+			y = env->stats.y;
+			if (stats(env, e->re.group.expr.rex))
+				return 1;
+			env->stats.m = m;
+			env->stats.n = n;
+			env->stats.x = x;
+			env->stats.y = y;
+			switch (e->type)
+			{
+			case REX_GROUP_AHEAD:
+			case REX_GROUP_BEHIND:
+				if (++env->stats.u <= 0)
+					return 1;
+				break;
+			}
+			break;
+		case REX_GROUP_COND:
+			if (++env->stats.u <= 0)
+				return 1;
+			m = env->stats.m;
+			n = env->stats.n;
+			x = env->stats.x;
+			y = env->stats.y;
+			if (e->re.group.size > 0 && ++env->stats.b <= 0)
+				return 1;
+			if (e->re.group.expr.binary.left && stats(env, e->re.group.expr.binary.left))
+				return 1;
+			if (q = e->re.group.expr.binary.right)
+			{
+				if (q->re.group.expr.binary.left && stats(env, q->re.group.expr.binary.left))
+					return 1;
+				if (q->re.group.expr.binary.right && stats(env, q->re.group.expr.binary.right))
+					return 1;
+			}
+			env->stats.m = m;
+			env->stats.n = n;
+			env->stats.x = x;
+			env->stats.y = y;
+			break;
+		case REX_GROUP_CUT:
+			if (++env->stats.u <= 0)
+				return 1;
+			m = env->stats.m;
+			n = env->stats.n;
+			x = env->stats.x;
+			y = env->stats.y;
+			if (stats(env, e->re.group.expr.rex))
+				return 1;
+			env->stats.m = m;
+			env->stats.n = n;
+			env->stats.x = x;
+			env->stats.y = y;
+			break;
+		case REX_NEG:
+			env->stats.i++;
+			x = env->stats.x;
+			l = env->stats.l;
+			y = env->stats.y;
+			k = env->stats.k;
+			t = env->stats.t;
+			cm = env->stats.m;
+			env->stats.m = 0;
+			if (stats(env, e->re.group.expr.rex))
+				return 1;
+			env->stats.m = !env->stats.m;
+			if ((env->stats.m += cm) < cm)
+				return 1;
+			env->stats.x = x;
+			env->stats.l = l;
+			env->stats.y = y;
+			env->stats.k = k;
+			env->stats.t = t;
+			break;
+		case REX_REP:
+			x = env->stats.x;
+			l = env->stats.l;
+			y = env->stats.y;
+			k = env->stats.k;
+			t = env->stats.t;
+			if (++env->stats.c <= 0)
+				return 1;
+			b = env->stats.b;
+			c = env->stats.c;
+			cm = env->stats.m;
+			env->stats.m = 0;
+			if (stats(env, e->re.group.expr.rex))
+				return 1;
+			if (env->stats.m == 1 && b == env->stats.b && c == env->stats.c && ++env->stats.s <= 0)
+				return 1;
+			if (e->lo < 1)
+			{
+				env->stats.x = x;
+				env->stats.l = l;
+				env->stats.y = y;
+				env->stats.k = k;
+				env->stats.t = t;
+				env->stats.m = cm;
+			}
+			else
+			{
+				m = env->stats.m;
+				if ((env->stats.m *= e->lo) > 0 && env->stats.m < m)
+					return 1;
+				m = env->stats.m;
+				if ((env->stats.m += cm) < m)
+					return 1;
+				if (env->stats.x != x)
+					env->stats.l = cm;
+				if (env->stats.y != y)
+					env->stats.k = cm;
+			}
+			break;
+		case REX_STRING:
+			cm = env->stats.m;
+			if ((env->stats.m += e->re.string.size) < cm)
+				return 1;
+			cn = env->stats.n;
+			if ((env->stats.n += e->re.string.size) < cn)
+				return 1;
+			if (!env->stats.x || env->stats.x->re.string.size < e->re.string.size)
+			{
+				env->stats.x = e;
+				env->stats.l = cm;
+			}
+			break;
+		case REX_TRIE:
+			if (++env->stats.s <= 0)
+				return 1;
+			cm = env->stats.m;
+			if ((env->stats.m += e->re.trie.min) < cm)
+				return 1;
+			cn = env->stats.n;
+			if ((env->stats.n += e->re.trie.max) < cn)
+				return 1;
+			env->stats.t++;
+			if (!env->stats.y || env->stats.y->re.trie.min < e->re.trie.min)
+			{
+				env->stats.y = e;
+				env->stats.k = cm;
+			}
+			break;
+		}
+	} while (e = e->next);
+	return 0;
+}
+
+static int	token(Cenv_t*);
+
+static int
+magic(register Cenv_t* env, register int c, int escaped)
+{
+	register char*	sp;
+	register int	n;
+	int		o = c;
+	int		e = env->error;
+	int		l = env->token.len;
+	short*		mp;
+	char*		ep;
+
+	if (mp = state.magic[c])
+	{
+		c = mp[env->type+escaped];
+		if (c >= T_META)
+		{
+			sp = (char*)env->cursor + env->token.len;
+			switch (c)
+			{
+			case T_LEFT:
+				n = 0;
+				ep = sp;
+				while (*sp >= '0' && *sp <= '9')
+				{
+					if (n > (INT_MAX / 10))
+					{
+						env->error = REG_BADBR;
+						goto bad;
+					}
+					n = n * 10 + *sp++ - '0';
+				}
+				if (sp == ep)
+				{
+					env->error = *sp ? REG_BADBR : REG_EBRACE;
+					goto bad;
+				}
+				else if (n > RE_DUP_MAX)
+				{
+					env->error = REG_BADBR;
+					goto bad;
+				}
+				env->token.min = n;
+				if (*sp == ',')
+				{
+					n = 0;
+					ep = ++sp;
+					while (*sp >= '0' && *sp <= '9')
+					{
+						if (n > (INT_MAX / 10))
+						{
+							env->error = REG_BADBR;
+							goto bad;
+						}
+						n = n * 10 + *sp++ - '0';
+					}
+					if (sp == ep)
+						n = RE_DUP_INF;
+					else if (n < env->token.min)
+					{
+						env->error = REG_BADBR;
+						goto bad;
+					}
+				}
+				env->token.max = n;
+				switch (*sp)
+				{
+				case 0:
+					env->error = REG_EBRACE;
+					goto bad;
+				case '\\':
+					if (!escaped)
+					{
+						env->error = REG_BADBR;
+						goto bad;
+					}
+					sp++;
+					break;
+				default:
+					if (escaped)
+					{
+						env->error = REG_BADBR;
+						goto bad;
+					}
+					break;
+				}
+				switch (*sp++)
+				{
+				case 0:
+					env->error = REG_EBRACE;
+					goto bad;
+				case '}':
+					break;
+				default:
+					env->error = REG_BADBR;
+					goto bad;
+				}
+				env->token.len = sp - (char*)env->cursor;
+				break;
+			case T_RIGHT:
+				env->error = REG_EBRACE;
+				goto bad;
+			case T_OPEN:
+				if (env->type < SRE && *sp == '?')
+				{
+					env->token.len++;
+					env->token.lex = 0;
+					goto group;
+				}
+				break;
+			case T_ESCAPE:
+				c = chresc(sp - 2, &ep);
+				if (ep < sp)
+					goto bad;
+				env->token.len += ep - sp;
+				if (c >= T_META)
+				{
+					env->token.lex = c;
+					c = C_ESC;
+				}
+				return c;
+			case T_BACK+0:
+			case T_BACK+1:
+			case T_BACK+2:
+			case T_BACK+3:
+			case T_BACK+4:
+			case T_BACK+5:
+			case T_BACK+6:
+			case T_BACK+7:
+				n = chresc(sp - 2, &ep);
+				if (ep > sp + 1)
+				{
+					env->token.len += ep - sp;
+					return n;
+				}
+				/*FALLTHROUGH*/
+			case T_BACK+8:
+			case T_BACK+9:
+				if (env->type == SRE || c == T_BACK && !(env->flags & REG_LENIENT))
+				{
+					env->error = REG_BADESC;
+					goto bad;
+				}
+				if ((env->flags & REG_MULTIREF) && isdigit(*sp))
+				{
+					c = (c - T_BACK) * 10 + (*sp - '0');
+					if (c > 0 && c <= env->parno && env->paren[c])
+						c += T_BACK;
+					else
+						c = chresc(sp - 2, &ep);
+					env->token.len++;
+				}
+				if (c == T_BACK)
+					c = 0;
+				break;
+			case T_BAD:
+				if (escaped == 1 && (env->flags & REG_LENIENT) && (c = mp[env->type+escaped+2]) >= T_META)
+					return c;
+				goto bad;
+			}
+			if (env->type >= SRE)
+			{
+				if (c == T_DOT)
+					c = '.';
+				else if (c < T_OPEN)
+				{
+					if (env->type == KRE && *(env->cursor + env->token.len) == '-' && *(env->cursor + env->token.len + 1) == '(')
+					{
+						env->token.len++;
+						env->token.att = 1;
+					}
+					if (env->type == KRE && *(env->cursor + env->token.len) == '(')
+					{
+						env->token.len++;
+						switch (c)
+						{
+						case T_AT:
+							break;
+						case T_PERCENT:
+							env->token.lex = c;
+							goto group;
+						case T_TILDE:
+							env->token.lex = 0;
+							goto group;
+						default:
+							env->token.lex = c;
+							break;
+						}
+						c = T_OPEN;
+					}
+					else if (c == T_STAR)
+						c = T_DOTSTAR;
+					else if (c == T_QUES)
+						c = T_DOT;
+					else
+					{
+						c = o;
+						env->token.len = l;
+					}
+				}
+				else if (c > T_BACK)
+				{
+					c = (c - T_BACK) * 2 - 1;
+					c = (c > env->parno || !env->paren[c]) ? o : T_BACK + c;
+				}
+				else if (env->type == KRE && !env->parnest && (env->flags & REG_SHELL_GROUP))
+				{
+					if (c == T_AND)
+						c = '&';
+					else if (c == T_BAR)
+						c = '|';
+					else if (c == T_OPEN)
+						c = '(';
+				}
+			}
+		}
+	}
+	else if (escaped == 2)
+	{
+		if (env->type >= SRE && !(env->flags & REG_SHELL_ESCAPED) || (env->flags & REG_ESCAPE) && (c == '[' || c == '-' || c == ']' || env->delimiter && c == env->delimiter))
+			/*ok*/;
+		else
+		{
+			env->error = REG_BADESC;
+			goto bad;
+		}
+	}
+	else if (escaped && !(env->flags & REG_LENIENT) && c != ']')
+	{
+		env->error = REG_BADESC;
+		goto bad;
+	}
+	return c;
+ group:
+	sp = (char*)env->cursor + env->token.len;
+	switch (*sp++)
+	{
+	case ')':
+		break;
+	case '#':
+		for (;;)
+		{
+			switch (*sp++)
+			{
+			case 0:
+				env->error = REG_EPAREN;
+				return T_BAD;
+			case ')':
+				break;
+			default:
+				continue;
+			}
+			break;
+		}
+		break;
+	default:
+		return T_GROUP;
+	}
+	env->cursor = (unsigned char*)sp;
+	return token(env);
+ bad:
+	if (escaped == 2)
+		env->error = e;
+	else if (env->flags & REG_LENIENT)
+		return o;
+	else if (escaped == 1 && !env->error)
+	{
+		if (mp || o == ']')
+			return o;
+		env->error = REG_BADESC;
+	}
+	return T_BAD;
+}
+
+static int
+token(register Cenv_t* env)
+{
+	int	c;
+	int	posixkludge;
+
+	if (env->token.push)
+		return env->token.lex;
+	env->token.att = env->token.esc = 0;
+	if ((env->token.len = MBSIZE(env->cursor)) > 1)
+		return env->token.lex = C_MB;
+	env->token.lex = 0;
+	for (;;)
+	{
+		c = *env->cursor;
+		if (c == 0 || c == env->delimiter || c == env->terminator)
+			return T_END;
+		if (!(env->flags & REG_COMMENT))
+			break;
+		if (c == '#')
+		{
+			do
+			{
+				c = *++env->cursor;
+				if (c == 0 || c == env->delimiter)
+					return T_END;
+			} while (c != '\n');
+		}
+		else if (!isspace(c))
+			break;
+		env->cursor++;
+	}
+	if (c == '\n' && (env->flags & REG_MULTIPLE) && !env->delimiter)
+	{
+		if (env->parnest)
+		{
+			env->error = REG_EPAREN;
+			return T_BAD;
+		}
+		env->parno = 0;
+		env->pattern = env->cursor + 1;
+		return T_BAR;
+	}
+	if (env->flags & REG_LITERAL)
+		return c;
+	if (posixkludge = env->posixkludge)
+	{
+		env->posixkludge = 0;
+		if (c == '*')
+			return c;
+	}
+	if (c == '\\')
+	{
+		if (env->flags & REG_SHELL_ESCAPED)
+			return c;
+		if (!(c = *(env->cursor + 1)) || c == env->terminator)
+		{
+			if (env->flags & REG_LENIENT)
+			{
+				if (c)
+				{
+					env->token.esc = env->token.len;
+					env->token.len += MBSIZE(env->cursor + 1);
+					return c;
+				}
+				return '\\';
+			}
+			env->error = REG_EESCAPE;
+			return T_BAD;
+		}
+		env->token.esc = env->token.len;
+		env->token.len += MBSIZE(env->cursor + 1);
+		if (env->delimiter && c == 'n')
+			return '\n';
+		else if (c == env->delimiter)
+			return magic(env, c, 0);
+		else if (c == '(' && env->type == BRE)
+			env->posixkludge = 1;
+		else if (c == ')' && env->type == BRE && env->parnest <= 0)
+		{
+			env->error = REG_EPAREN;
+			return T_BAD;
+		}
+		else if (isspace(c) && (env->flags & REG_COMMENT))
+			return c;
+		return magic(env, c, 1);
+	}
+	else if (c == '$')
+	{
+		if (env->type == BRE && (*(env->cursor + 1) == 0 || *(env->cursor + 1) == env->delimiter || *(env->cursor + 1) == env->terminator || *(env->cursor + 1) == '\\' && *(env->cursor + 2) == ')') || (env->flags & REG_MULTIPLE) && *(env->cursor + 1) == '\n')
+			return T_DOLL;
+	}
+	else if (c == '^')
+	{
+		if (env->type == BRE && (env->cursor == env->pattern || posixkludge))
+		{
+			env->posixkludge = 1;
+			return T_CFLX;
+		}
+	}
+	else if (c == ')')
+	{
+		if (env->type != BRE && env->parnest <= 0)
+			return c;
+	}
+	else if (c == '/' && env->explicit == env->mappedslash)
+	{
+		while (*(env->cursor + env->token.len) == c)
+			env->token.len++;
+		return T_SLASHPLUS;
+	}
+	return magic(env, c, 0);
+}
+
+static Celt_t*
+col(Celt_t* ce, int ic, unsigned char* bp, int bw, int bc, unsigned char* ep, int ew, int ec)
+{
+	register unsigned char*	s;
+	register unsigned char*	k;
+	register unsigned char*	e;
+	register int		c;
+	register int		cc;
+	int			bt;
+	int			et;
+	Ckey_t			key;
+
+	cc = 0;
+	for (;;)
+	{
+		k = key;
+		if (bw == 1)
+		{
+			c = bc;
+			if (ic)
+			{
+				if (iswupper(c))
+				{
+					c = towlower(c);
+					cc = 1;
+				}
+				else if (iswlower(c))
+				{
+					c = towupper(c);
+					cc = 1;
+				}
+			}
+			*k++ = c;
+		}
+		else if (bw < COLL_KEY_MAX)
+		{
+			s = bp;
+			e = s + bw;
+			while (s < e)
+			{
+				c = *s++;
+				if (ic)
+				{
+					if (isupper(c))
+					{
+						c = tolower(c);
+						cc = 1;
+					}
+					else if (islower(c))
+					{
+						c = toupper(c);
+						cc = 1;
+					}
+				}
+				*k++ = c;
+			}
+		}
+		*k = 0;
+		mbxfrm(ce->beg, key, COLL_KEY_MAX);
+		if (ep)
+		{
+			k = key;
+			c = mbchar(k);
+			if (iswupper(c))
+				bt = COLL_range_uc;
+			else if (iswlower(c))
+				bt = COLL_range_lc;
+			else
+				bt = COLL_range;
+			k = key;
+			if (ew == 1)
+			{
+				c = ec;
+				if (ic)
+				{
+					if (iswupper(c))
+					{
+						c = towlower(c);
+						cc = 1;
+					}
+					else if (iswlower(c))
+					{
+						c = towupper(c);
+						cc = 1;
+					}
+				}
+				*k++ = c;
+			}
+			else if (ew < COLL_KEY_MAX)
+			{
+				s = ep;
+				e = s + ew;
+				while (s < e)
+				{
+					c = *s++;
+					if (ic)
+					{
+						if (isupper(c))
+						{
+							c = tolower(c);
+							cc = 1;
+						}
+						else if (islower(c))
+						{
+							c = toupper(c);
+							cc = 1;
+						}
+					}
+					*k++ = c;
+				}
+			}
+			*k = 0;
+			mbxfrm(ce->end, key, COLL_KEY_MAX);
+			k = key;
+			c = mbchar(k);
+			if (iswupper(c))
+				et = COLL_range_uc;
+			else if (iswlower(c))
+				et = COLL_range_lc;
+			else
+				et = COLL_range;
+			ce->typ = bt == et ? bt : COLL_range;
+		}
+		else
+			ce->typ = COLL_char;
+		ce++;
+		if (!ic || !cc)
+			break;
+		ic = 0;
+	}
+	return ce;
+}
+
+static Rex_t*
+bra(Cenv_t* env)
+{
+	Rex_t*		e;
+	int		c;
+	int		i;
+	int		w;
+	int		neg;
+	int		last;
+	int		inrange;
+	int		complicated;
+	int		collate;
+	int		elements;
+	unsigned char*	first;
+	unsigned char*	start;
+	unsigned char*	begin;
+	unsigned char*	s;
+	regclass_t	f;
+	unsigned char	buf[4 * (COLL_KEY_MAX + 1)];
+#if _PACKAGE_ast
+	int		ic;
+	char		mbc[COLL_KEY_MAX + 1];
+#endif
+
+	if (!(e = node(env, REX_CLASS, 1, 1, sizeof(Set_t))))
+		return 0;
+	collate = complicated = elements = 0;
+	first = env->cursor;
+	start = first + MBSIZE(first);
+	if (*env->cursor == '^' || env->type >= SRE && *env->cursor == '!')
+	{
+		env->cursor++;
+		neg = 1;
+	}
+	else
+		neg = 0;
+	if (*env->cursor == 0 || *(env->cursor + 1) == 0 || *env->cursor == env->terminator || *(env->cursor + 1) == env->terminator || (env->flags & REG_ESCAPE) && (*env->cursor == env->delimiter || *env->cursor != '\\' && *(env->cursor + 1) == env->delimiter))
+		goto error;
+	begin = env->cursor + MBSIZE(env->cursor);
+
+	/*
+	 * inrange: 0=no, 1=possibly, 2=definitely
+	 */
+
+	inrange = 0;
+	for (;;)
+	{
+		if (!(c = *env->cursor) || c == env->terminator || (env->flags & REG_ESCAPE) && c == env->delimiter)
+			goto error;
+		env->cursor += (w = MBSIZE(env->cursor));
+		if (c == '\\')
+		{
+			if (*env->cursor)
+			{
+				if (*env->cursor == 'n')
+				{
+					env->cursor++;
+					c = '\n';
+				}
+				else if (env->type < SRE || !(env->flags & REG_SHELL_ESCAPED))
+				{
+					env->token.len = 1;
+					w = magic(env, *env->cursor, 2);
+					if (env->token.len > 1 || w != T_BAD)
+					{
+						if (env->token.len == 1 && (f = classfun(w)))
+						{
+							if (inrange > 1)
+							{
+								if (env->type < SRE && !(env->flags & REG_LENIENT))
+									goto erange;
+								inrange = 0;
+							}
+							env->cursor++;
+							for (c = 0; c <= UCHAR_MAX; c++)
+								if ((*f)(c))
+									setadd(e->re.charclass, c);
+							complicated++;
+							elements++;
+							continue;
+						}
+						if (env->token.len > 1 || w >= 0 && w < T_META)
+						{
+							c = w;
+							if (c > UCHAR_MAX)
+							{
+								if (env->type < SRE && !(env->flags & REG_LENIENT) && !mbwide())
+									goto erange;
+								c = UCHAR_MAX;
+							}
+							env->cursor += env->token.len;
+						}
+					}
+				}
+			}
+		}
+		else if (c == ']')
+		{
+			if (env->cursor == begin)
+			{
+				last = c;
+				inrange = 1;
+				continue;
+			}
+			if (inrange != 0)
+			{
+				setadd(e->re.charclass, last);
+				elements++;
+				if (inrange == 2)
+				{
+					setadd(e->re.charclass, '-');
+					elements++;
+				}
+			}
+			break;
+		}
+		else if (c == '-')
+		{
+			if (!inrange && env->cursor != begin && *env->cursor != ']')
+			{
+				if (env->type < SRE && !(env->flags & REG_LENIENT))
+					goto erange;
+				continue;
+			}
+			else if (inrange == 1)
+			{
+				inrange = 2;
+				complicated++;
+				continue;
+			}
+		}
+		else if (c == '[')
+		{
+			switch (*env->cursor)
+			{
+			case 0:
+				goto error;
+			case ':':
+				if (inrange == 1)
+				{
+					setadd(e->re.charclass, last);
+					elements++;
+				}
+				if (!(f = regclass((char*)env->cursor, (char**)&env->cursor)))
+				{
+					if (env->cursor == start && (c = *(env->cursor + 1)))
+					{
+						s = start = env->cursor + 1;
+						while (*++s && *s != ':');
+						if (*s == ':' && *(s + 1) == ']' && *(s + 2) == ']')
+						{
+							if ((i = (s - start)) == 1)
+							{
+								switch (c)
+								{
+								case '<':
+									i = REX_WBEG;
+									break;
+								case '>':
+									i = REX_WEND;
+									break;
+								default:
+									i = 0;
+									break;
+								}
+								if (i)
+								{
+									env->cursor = s + 3;
+									drop(env->disc, e);
+									return node(env, i, 0, 0, 0);
+								}
+							}
+						}
+					}
+					env->error = REG_ECTYPE;
+					goto error;
+				}
+				for (c = 0; c <= UCHAR_MAX; c++)
+					if ((*f)(c))
+						setadd(e->re.charclass, c);
+				inrange = 0;
+				complicated++;
+				elements++;
+				continue;
+			case '=':
+				if (inrange == 2)
+					goto erange;
+				if (inrange == 1)
+				{
+					setadd(e->re.charclass, last);
+					elements++;
+				}
+				if ((c = regcollate((char*)env->cursor, (char**)&env->cursor, (char*)buf, sizeof(buf))) < 0)
+					goto ecollate;
+				if (c > 1)
+					collate++;
+				else
+					setadd(e->re.charclass, buf[0]);
+				c = buf[0];
+				inrange = 0;
+				complicated++;
+				elements++;
+				continue;
+			case '.':
+				if ((c = regcollate((char*)env->cursor, (char**)&env->cursor, (char*)buf, sizeof(buf))) < 0)
+					goto ecollate;
+				if (c > 1)
+					collate++;
+				c = buf[0];
+				complicated++;
+				break;
+			default:
+				if (*env->cursor == env->terminator || *env->cursor == env->delimiter && (env->flags & REG_ESCAPE))
+					goto error;
+				break;
+			}
+		}
+		else if (w > 1)
+			complicated++;
+		if (inrange == 2)
+		{
+			if (last > c)
+			{
+				if (env->type < SRE && !(env->flags & REG_LENIENT))
+					goto erange;
+				setadd(e->re.charclass, last);
+				setadd(e->re.charclass, c);
+			}
+			else
+				for (i = last; i <= c; i++)
+					setadd(e->re.charclass, i);
+			inrange = env->type >= SRE || (env->flags & REG_LENIENT);
+			elements += 2;
+		}
+		else if (inrange == 1)
+		{
+			setadd(e->re.charclass, last);
+			elements++;
+		}
+		else
+			inrange = 1;
+		last = c;
+	}
+#if _PACKAGE_ast
+	if (complicated && mbcoll())
+	{
+		Dt_t*			dt;
+		Cchr_t*			cc;
+		Cchr_t*			tc;
+		Cchr_t*			xc;
+		Celt_t*			ce;
+		Cchr_t			key;
+		int			cw;
+		int			rw;
+		int			rc;
+		unsigned char*		rp;
+		unsigned char*		pp;
+
+		static Dtdisc_t		disc;
+
+		static const char	primary[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+
+		if (!(dt = (Dt_t*)LCINFO(AST_LC_COLLATE)->data))
+		{
+			disc.key = offsetof(Cchr_t, key);
+			if ((cc = newof(0, Cchr_t, elementsof(primary), 0)) && (dt = dtopen(&disc, Dttree)))
+			{
+				for (i = 0; i < elementsof(primary) - 1; i++, cc++)
+				{
+					cc->nam[0] = primary[i];
+					mbxfrm(cc->key, cc->nam, COLL_KEY_MAX);
+					dtinsert(dt, cc);
+				}
+				for (i = 0; i < elementsof(cc->key); i++)
+					cc->key[i] = ~0;
+				dtinsert(dt, cc);
+				LCINFO(AST_LC_COLLATE)->data = (void*)dt;
+			}
+			else
+			{
+				if (cc)
+					free(cc);
+				drop(env->disc, e);
+				return 0;
+			}
+		}
+		if (dt)
+		{
+			drop(env->disc, e);
+			if (ic = env->flags & REG_ICASE)
+				elements *= 2;
+			if (!(e = node(env, REX_COLL_CLASS, 1, 1, (elements + 1) * sizeof(Celt_t))))
+				return 0;
+			ce = (Celt_t*)e->re.data;
+			e->re.collate.invert = neg;
+			e->re.collate.elements = ce;
+			env->cursor = first;
+			inrange = 0;
+			for (;;)
+			{
+				if ((c = *env->cursor) == 0 || c == env->terminator || (env->flags & REG_ESCAPE) && c == env->delimiter)
+					goto error;
+				pp = env->cursor;
+				env->cursor += (w = MBSIZE(env->cursor));
+				if (c == '\\')
+				{
+					if (*env->cursor)
+					{
+						if (*env->cursor == 'n')
+						{
+							pp = env->cursor++;
+							c = '\n';
+						}
+						else if (env->type < SRE || !(env->flags & REG_SHELL_ESCAPED))
+						{
+							env->token.len = 1;
+							w = magic(env, *env->cursor, 2);
+							if (env->token.len > 1 || w != T_BAD)
+							{
+								if (env->token.len == 1 && (f = classfun(w)))
+								{
+									if (inrange > 1)
+									{
+										if (env->type < SRE && !(env->flags & REG_LENIENT))
+											goto erange;
+										inrange = 0;
+									}
+									env->cursor++;
+									ce->fun = f;
+									ce->typ = COLL_call;
+									ce++;
+									continue;
+								}
+								if (env->token.len > 1 || w >= 0 && w < T_META)
+								{
+									c = w;
+									w = wctomb(mbc, c);
+									pp = (unsigned char*)mbc;
+									env->cursor += env->token.len;
+								}
+							}
+						}
+					}
+				}
+				else if (c == ']')
+				{
+					if (env->cursor == begin)
+					{
+						rp = pp;
+						rw = w;
+						inrange = 1;
+						continue;
+					}
+					if (inrange != 0)
+					{
+						ce = col(ce, ic, rp, rw, rc, NiL, 0, 0);
+						if (inrange == 2)
+							ce = col(ce, ic, NiL, 1, '-', NiL, 0, 0);
+					}
+					break;
+				}
+				else if (c == '-')
+				{
+					if (!inrange && env->cursor != begin && *env->cursor != ']')
+					{
+						if (env->type < SRE && !(env->flags & REG_LENIENT))
+							goto erange;
+						continue;
+					}
+					else if (inrange == 1)
+					{
+						inrange = 2;
+						continue;
+					}
+				}
+				else if (c == '[')
+				{
+					switch (*env->cursor)
+					{
+					case 0:
+						goto error;
+					case ':':
+						if (inrange == 1)
+							ce = col(ce, ic, rp, rw, rc, NiL, 0, 0);
+						if (!(f = regclass((char*)env->cursor, (char**)&env->cursor)))
+						{
+							if (env->cursor == start && (c = *(env->cursor + 1)) && *(env->cursor + 2) == ':' && *(env->cursor + 3) == ']' && *(env->cursor + 4) == ']')
+							{
+								switch (c)
+								{
+								case '<':
+									i = REX_WBEG;
+									break;
+								case '>':
+									i = REX_WEND;
+									break;
+								default:
+									i = 0;
+									break;
+								}
+								if (i)
+								{
+									env->cursor += 5;
+									drop(env->disc, e);
+									return node(env, i, 0, 0, 0);
+								}
+							}
+							env->error = REG_ECTYPE;
+							goto error;
+						}
+						ce->fun = f;
+						ce->typ = COLL_call;
+						ce++;
+						inrange = 0;
+						continue;
+					case '=':
+						if (inrange == 2)
+							goto erange;
+						if (inrange == 1)
+							ce = col(ce, ic, rp, rw, rc, NiL, 0, 0);
+						rp = env->cursor + 1;
+						if ((rw = regcollate((char*)env->cursor, (char**)&env->cursor, (char*)buf, sizeof(buf) - 1)) < 0)
+							goto ecollate;
+						c = 0;
+						if (ic)
+							for (i = 0; i < rw; i += MBSIZE(buf+i))
+								if (isupper(buf[i]))
+								{
+									buf[i] = tolower(buf[i]);
+									c = 1;
+								}
+								else if (islower(buf[i]))
+									c = 1;
+						for (;;)
+						{
+							mbxfrm(key.key, buf, COLL_KEY_MAX);
+							if (!(cc = (Cchr_t*)dtsearch(dt, &key)))
+							{
+								if (!isalnum(buf[0]))
+								{
+									strcpy((char*)ce->beg, (char*)key.key);
+									ce->typ = COLL_char;
+									ce++;
+									break;
+								}
+								if (!(cc = (Cchr_t*)dtprev(dt, &key)))
+									goto ecollate;
+							}
+							xc = cc;
+							if (islower(buf[0]))
+							{
+								ce->typ = COLL_range_lc;
+								if ((tc = (Cchr_t*)dtprev(dt, cc)) && !strcasecmp((char*)tc->nam, (char*)cc->nam))
+									xc = tc;
+							}
+							else if (isupper(buf[0]))
+							{
+								ce->typ = COLL_range_uc;
+								if ((tc = (Cchr_t*)dtprev(dt, cc)) && !strcasecmp((char*)tc->nam, (char*)cc->nam))
+									xc = tc;
+							}
+							else
+							{
+								ce->typ = COLL_range;
+								xc = cc;
+							}
+							strcpy((char*)ce->beg, (char*)xc->key);
+							if (!(cc = (Cchr_t*)dtnext(dt, cc)))
+								goto ecollate;
+							if (!strcasecmp((char*)xc->nam, (char*)cc->nam) && (tc = (Cchr_t*)dtnext(dt, cc)))
+								cc = tc;
+							strcpy((char*)ce->end, (char*)cc->key);
+							ce->max = -1;
+							ce++;
+							if (!c)
+								break;
+							c = 0;
+							for (i = 0; i < rw; i++)
+								if (islower(buf[i]))
+									buf[i] = toupper(buf[i]);
+						}
+						inrange = 0;
+						c = buf[0];
+						continue;
+					case '.':
+						pp = env->cursor + 1;
+						if ((w = regcollate((char*)env->cursor, (char**)&env->cursor, (char*)buf, sizeof(buf) - 1)) < 0)
+							goto ecollate;
+						if (w > 1)
+						{
+							if (w > COLL_KEY_MAX)
+								goto ecollate;
+							if (ic)
+								for (i = 0; i < w; i += MBSIZE(buf+i))
+									if (isupper(buf[i]))
+										buf[i] = tolower(buf[i]);
+							cw = mbxfrm(ce->beg, buf, COLL_KEY_MAX);
+							buf[1] = 0;
+							if (mbxfrm(ce->beg, buf, COLL_KEY_MAX) < cw)
+								goto ecollate;
+						}
+						c = buf[0];
+						break;
+					default:
+						if (*env->cursor == env->terminator || *env->cursor == env->delimiter && (env->flags & REG_ESCAPE))
+							goto error;
+						break;
+					}
+				}
+				if (inrange == 2)
+				{
+					ce = col(ce, ic, rp, rw, rc, pp, w, c);
+					if (strcmp((char*)ce->beg, (char*)ce->end) > 0)
+					{
+						if (env->type < SRE && !(env->flags & REG_LENIENT))
+							goto erange;
+						(ce-1)->typ = COLL_char;
+						strcpy((char*)ce->beg, (char*)(ce-1)->end);
+						ce->typ = COLL_char;
+						ce++;
+					}
+					inrange = env->type >= SRE || (env->flags & REG_LENIENT);
+				}
+				else if (inrange == 1)
+					ce = col(ce, ic, rp, rw, rc, NiL, 0, 0);
+				else
+					inrange = 1;
+				rp = pp;
+				rw = w;
+				rc = c;
+			}
+			ce->typ = COLL_end;
+			return e;
+		}
+	}
+#endif
+	if (collate)
+		goto ecollate;
+	if (env->flags & REG_ICASE)
+		for (i = 0; i <= UCHAR_MAX; i++)
+			if (settst(e->re.charclass, i))
+			{
+				if (isupper(i))
+					c = tolower(i);
+				else if (islower(i))
+					c = toupper(i);
+				else
+					continue;
+				setadd(e->re.charclass, c);
+			}
+	if (neg)
+	{
+		for (i = 0; i < elementsof(e->re.charclass->bits); i++)
+			e->re.charclass->bits[i] ^= ~0;
+		if (env->explicit >= 0)
+			setclr(e->re.charclass, env->explicit);
+	}
+	return e;
+ ecollate:
+	env->error = REG_ECOLLATE;
+	goto error;
+ erange:
+	env->error = REG_ERANGE;
+ error:
+	drop(env->disc, e);
+	if (!env->error)
+		env->error = REG_EBRACK;
+	return 0;
+}
+
+static Rex_t*
+ccl(Cenv_t* env, int type)
+{
+	int		i;
+	Rex_t*		e;
+	Celt_t*		ce;
+	regclass_t	f;
+
+	if (!(f = classfun(type)))
+	{
+		env->error = REG_BADESC;
+		return 0;
+	}
+	if (!mbcoll())
+	{
+		if (!(e = node(env, REX_CLASS, 1, 1, sizeof(Set_t))))
+			return 0;
+		for (i = 0; i <= UCHAR_MAX; i++)
+			if ((*f)(i))
+				setadd(e->re.charclass, i);
+		if (env->explicit >= 0)
+			setclr(e->re.charclass, env->explicit);
+	}
+	else
+	{
+		if (!(e = node(env, REX_COLL_CLASS, 1, 1, 2 * sizeof(Celt_t))))
+			return 0;
+		ce = (Celt_t*)e->re.data;
+		e->re.collate.invert = 0;
+		e->re.collate.elements = ce;
+		ce->typ = COLL_call;
+		ce->fun = f;
+		ce++;
+		ce->typ = COLL_end;
+	}
+	return e;
+}
+
+static Rex_t*
+rep(Cenv_t* env, Rex_t* e, int number, int last)
+{
+	Rex_t*		f;
+	unsigned long	m = 0;
+	unsigned long	n = RE_DUP_INF;
+	int		minimal = -1;
+
+	if (!e)
+		return 0;
+	switch (token(env))
+	{
+	case T_BANG:
+		eat(env);
+		if (!(f = node(env, REX_NEG, m, n, 0)))
+		{
+			drop(env->disc, e);
+			return 0;
+		}
+		f->re.group.expr.rex = e;
+		return f;
+	case T_QUES:
+		eat(env);
+		n = 1;
+		break;
+	case T_STAR:
+		eat(env);
+		break;
+	case T_PLUS:
+		eat(env);
+		m = 1;
+		break;
+	case T_LEFT:
+		eat(env);
+		m = env->token.min;
+		n = env->token.max;
+		break;
+	default:
+		return e;
+	}
+	if (env->token.att)
+		minimal = 1;
+	else if (env->type < SRE)
+		switch (token(env))
+		{
+		case T_QUES:
+			eat(env);
+			minimal = !(env->flags & REG_MINIMAL);
+			break;
+		case T_STAR: /*AST*/
+			eat(env);
+			minimal = !!(env->flags & REG_MINIMAL);
+			break;
+		}
+	switch (e->type)
+	{
+	case REX_DOT:
+	case REX_CLASS:
+	case REX_COLL_CLASS:
+	case REX_ONECHAR:
+		e->lo = m;
+		e->hi = n;
+		if (minimal >= 0)
+			mark(e, minimal);
+		return e;
+#if HUH_2002_08_07
+	case REX_BEG:
+#endif
+	case REX_BEG_STR:
+	case REX_END_STR:
+	case REX_FIN_STR:
+	case REX_WBEG:
+	case REX_WEND:
+	case REX_WORD:
+	case REX_WORD_NOT:
+		env->error = REG_BADRPT;
+		drop(env->disc, e);
+		return 0;
+	}
+	if (m == 1 && n == 1)
+	{
+		if (minimal >= 0)
+			mark(e, minimal);
+		return e;
+	}
+	if (!(f = node(env, REX_REP, m, n, 0)))
+	{
+		drop(env->disc, e);
+		return 0;
+	}
+	f->re.group.expr.rex = e;
+	f->re.group.number = number;
+	f->re.group.last = last;
+	if (minimal >= 0)
+		mark(f, minimal);
+	if (m <= n && n)
+	{
+		for (; e && e->type >= REX_GROUP && e->type <= REX_GROUP_CUT; e = e->re.group.expr.rex);
+		if (e && e->type == REX_NEG)
+			f->type = REX_GROUP;
+	}
+	return f;
+}
+
+static int
+isstring(Rex_t* e)
+{
+	switch (e->type)
+	{
+	case REX_ONECHAR:
+		return e->lo == 1 && e->hi == 1;
+	case REX_STRING:
+		return 1;
+	}
+	return 0;
+}
+
+static Trie_node_t*
+trienode(Cenv_t* env, int c)
+{
+	Trie_node_t*	t;
+
+	if (t = (Trie_node_t*)alloc(env->disc, 0, sizeof(Trie_node_t)))
+	{
+		memset(t, 0, sizeof(Trie_node_t));
+		t->c = c;
+	}
+	return t;
+}
+
+static int
+insert(Cenv_t* env, Rex_t* f, Rex_t* g)
+{
+	unsigned char*	s;
+	unsigned char*	e;
+	Trie_node_t*	t;
+	int		len;
+	unsigned char	tmp[2];
+
+	switch (f->type)
+	{
+	case REX_ONECHAR:
+		*(s = tmp) = f->re.onechar;
+		e = s + 1;
+		break;
+	case REX_STRING:
+		s = f->re.string.base;
+		e = s + f->re.string.size;
+		break;
+	default:
+		return 1;
+	}
+	if (!(t = g->re.trie.root[*s]) && !(t = g->re.trie.root[*s] = trienode(env, *s)))
+		return 1;
+	for (len = 1;;)
+	{
+		if (t->c == *s)
+		{
+			if (++s >= e)
+				break;
+			if (!t->son && !(t->son = trienode(env, *s)))
+				return 1;
+			t = t->son;
+			len++;
+		}
+		else
+		{
+			if (!t->sib && !(t->sib = trienode(env, *s)))
+				return 1;
+			t = t->sib;
+		}
+	}
+	if (g->re.trie.min > len)
+		g->re.trie.min = len;
+	if (g->re.trie.max < len)
+		g->re.trie.max = len;
+	t->end = 1;
+	return 0;
+}
+
+/*
+ * trie() tries to combine nontrivial e and f into a REX_TRIE
+ * unless 0 is returned, e and f are deleted as far as possible
+ * also called by regcomb
+ */
+
+static Rex_t*
+trie(Cenv_t* env, Rex_t* e, Rex_t* f)
+{
+	Rex_t*	g;
+
+	if (e->next || f->next || !isstring(e) || e->flags != f->flags)
+		return 0;
+	if (isstring(f))
+	{
+		if (!(g = node(env, REX_TRIE, 0, 0, (UCHAR_MAX + 1) * sizeof(Trie_node_t*))))
+			return 0;
+		g->re.trie.min = INT_MAX;
+		if (insert(env, f, g))
+			goto nospace;
+		drop(env->disc, f);
+	}
+	else if (f->type != REX_TRIE)
+		return 0;
+	else
+		g = f;
+	if (insert(env, e, g))
+		goto nospace;
+	drop(env->disc, e);
+	return g;
+ nospace:
+	if (g != f)
+		drop(env->disc, g);
+	return 0;
+}
+
+static Rex_t*		alt(Cenv_t*, int, int);
+
+static int
+chr(register Cenv_t* env, int* escaped)
+{
+	unsigned char*	p;
+	int		c;
+
+	*escaped = 0;
+	if (!(c = *env->cursor))
+		return -1;
+	env->cursor++;
+	if (c == '\\')
+	{
+		if (env->flags & REG_SHELL_ESCAPED)
+			return c;
+		if (!(c = *(env->cursor + 1)) || c == env->terminator)
+		{
+			if (env->flags & REG_LENIENT)
+				return c ? c : '\\';
+			env->error = REG_EESCAPE;
+			return -1;
+		}
+		p = env->cursor;
+		c = chresc((char*)env->cursor - 1, (char**)&env->cursor);
+		*escaped = env->cursor - p;
+	}
+	return c;
+}
+
+/*
+ * open the perly gates
+ */
+
+static Rex_t*
+grp(Cenv_t* env, int parno)
+{
+	Rex_t*		e;
+	Rex_t*		f;
+	int		c;
+	int		i;
+	int		n;
+	int		x;
+	int		esc;
+	int		typ;
+	int		beg;
+	unsigned char*	p;
+
+	beg = env->pattern == env->cursor - env->token.len;
+	if (!(c = env->token.lex) && (c = *env->cursor))
+		env->cursor++;
+	env->token.len = 0;
+	env->parnest++;
+	typ = -1;
+	switch (c)
+	{
+	case '-':
+	case '+':
+	case 'a':
+	case 'g':
+	case 'i':
+	case 'l':
+	case 'm':
+	case 'p':
+	case 'r':
+	case 's':
+	case 'x':
+	case 'A':
+	case 'B':
+	case 'E':
+	case 'F':
+	case 'G':
+	case 'I':
+	case 'K':
+	case 'M':
+	case 'N':
+	case 'R':
+	case 'S':
+	case 'U':	/* pcre */
+	case 'X':	/* pcre */
+		x = REX_GROUP;
+		i = 1;
+		env->token.push = 1;
+		for (;;)
+		{
+			switch (c)
+			{
+			case 0:
+			case T_CLOSE:
+				x = 0;
+				goto done;
+			case ':':
+				eat(env);
+				if (token(env) == T_CLOSE)
+					x = 0;
+				goto done;
+			case '-':
+				i = 0;
+				break;
+			case '+':
+				i = 1;
+				break;
+			case 'a':
+				if (i)
+					env->flags |= (REG_LEFT|REG_RIGHT);
+				else
+					env->flags &= ~(REG_LEFT|REG_RIGHT);
+				break;
+			case 'g':
+				if (i)
+					env->flags &= ~REG_MINIMAL;
+				else
+					env->flags |= REG_MINIMAL;
+				break;
+			case 'i':
+				if (i)
+					env->flags |= REG_ICASE;
+				else
+					env->flags &= ~REG_ICASE;
+				break;
+			case 'l':
+				if (i)
+					env->flags |= REG_LEFT;
+				else
+					env->flags &= ~REG_LEFT;
+				break;
+			case 'm':
+				if (i)
+					env->flags |= REG_NEWLINE;
+				else
+					env->flags &= ~REG_NEWLINE;
+				env->explicit = (env->flags & (REG_NEWLINE|REG_SPAN)) == REG_NEWLINE ? env->mappednewline : -1;
+				break;
+			case 'p':
+				if (i)
+					env->flags &= ~REG_LENIENT;
+				else
+					env->flags |= REG_LENIENT;
+				break;
+			case 'r':
+				if (i)
+					env->flags |= REG_RIGHT;
+				else
+					env->flags &= ~REG_RIGHT;
+				break;
+			case 's':
+				if (i)
+					env->flags |= REG_SPAN;
+				else
+					env->flags &= ~REG_SPAN;
+				env->explicit = (env->flags & (REG_NEWLINE|REG_SPAN)) == REG_NEWLINE ? env->mappednewline : -1;
+				break;
+			case 'x':
+				if (i)
+					env->flags |= REG_COMMENT;
+				else
+					env->flags &= ~REG_COMMENT;
+				break;
+			case 'A':
+				env->flags &= ~(REG_AUGMENTED|REG_EXTENDED|REG_LITERAL|REG_SHELL|REG_LEFT|REG_RIGHT);
+				env->flags |= REG_AUGMENTED|REG_EXTENDED;
+				typ = ARE;
+				break;
+			case 'B':
+			case 'G':
+				env->flags &= ~(REG_AUGMENTED|REG_EXTENDED|REG_LITERAL|REG_SHELL|REG_LEFT|REG_RIGHT);
+				typ = BRE;
+				break;
+			case 'E':
+				env->flags &= ~(REG_AUGMENTED|REG_EXTENDED|REG_LITERAL|REG_SHELL|REG_LEFT|REG_RIGHT);
+				env->flags |= REG_EXTENDED;
+				typ = ERE;
+				break;
+			case 'F':
+			case 'L':
+				env->flags &= ~(REG_AUGMENTED|REG_EXTENDED|REG_LITERAL|REG_SHELL|REG_LEFT|REG_RIGHT);
+				env->flags |= REG_LITERAL;
+				typ = ERE;
+				break;
+			case 'K':
+				env->flags &= ~(REG_AUGMENTED|REG_EXTENDED|REG_LITERAL|REG_SHELL|REG_LEFT|REG_RIGHT);
+				env->flags |= REG_AUGMENTED|REG_SHELL|REG_LEFT|REG_RIGHT;
+				typ = KRE;
+				break;
+			case 'M':
+				/* used by caller to disable glob(3) GLOB_BRACE */
+				break;
+			case 'N':
+				/* used by caller to disable glob(3) GLOB_NOCHECK */
+				break;
+			case 'R':
+				/* used by caller to disable glob(3) GLOB_STARSTAR */
+				break;
+			case 'S':
+				env->flags &= ~(REG_AUGMENTED|REG_EXTENDED|REG_LITERAL|REG_SHELL|REG_LEFT|REG_RIGHT);
+				env->flags |= REG_SHELL|REG_LEFT|REG_RIGHT;
+				typ = SRE;
+				break;
+			case 'U': /* PCRE_UNGREEDY */
+				if (i)
+					env->flags |= REG_MINIMAL;
+				else
+					env->flags &= ~REG_MINIMAL;
+				break;
+			case 'X': /* PCRE_EXTRA */
+				break;
+			default:
+				env->error = REG_BADRPT;
+				return 0;
+			}
+			eat(env);
+			c = token(env);
+		}
+	done:
+		break;
+	case ':':
+		x = REX_GROUP;
+		break;
+	case '=':
+		x = REX_GROUP_AHEAD;
+		break;
+	case '!':
+		x = REX_GROUP_AHEAD_NOT;
+		break;
+	case '<':
+		switch (token(env))
+		{
+		case '=':
+			x = REX_GROUP_BEHIND;
+			break;
+		case '!':
+		case T_BANG:
+			x = REX_GROUP_BEHIND_NOT;
+			break;
+		default:
+			env->error = REG_BADRPT;
+			return 0;
+		}
+		eat(env);
+		break;
+	case '>':
+		x = REX_GROUP_CUT;
+		break;
+	case '%':
+	case T_PERCENT:
+		e = node(env, REX_NEST, 0, 0, (UCHAR_MAX + 1) * sizeof(unsigned short));
+		e->re.nest.primary = isalnum(*env->cursor) ? -1 : *env->cursor;
+		n = 1;
+		for (;;)
+		{
+			switch (i = chr(env, &esc))
+			{
+			case -1:
+			case 0:
+			invalid:
+				env->cursor -= esc + 1;
+				env->error = REG_EPAREN;
+				return 0;
+			case 'D':
+				x = REX_NEST_delimiter;
+				/*FALLTHROUGH*/
+			delimiter:
+				if ((i = chr(env, &esc)) < 0)
+					goto invalid;
+				if (e->re.nest.type[i] & ~x)
+					goto invalid;
+				e->re.nest.type[i] = x;
+				continue;
+			case 'E':
+				x = REX_NEST_escape;
+				goto delimiter;
+			case 'L':
+				x = REX_NEST_literal;
+				goto quote;
+			case 'O':
+				switch (i = chr(env, &esc))
+				{
+				case 'T':
+					e->re.nest.type[UCHAR_MAX+1] |= REX_NEST_terminator;
+					break;
+				default:
+					goto invalid;
+				}
+				continue;
+			case 'Q':
+				x = REX_NEST_quote;
+				/*FALLTHROUGH*/
+			quote:
+				if ((i = chr(env, &esc)) < 0)
+					goto invalid;
+				if (e->re.nest.type[i] & ~x)
+					goto invalid;
+				e->re.nest.type[i] = x|REX_NEST_open|REX_NEST_close|(i<<REX_NEST_SHIFT);
+				continue;
+			case 'S':
+				x = REX_NEST_separator;
+				goto delimiter;
+			case 'T':
+				x = REX_NEST_terminator;
+				goto delimiter;
+			case '|':
+			case '&':
+				if (!esc)
+					goto invalid;
+				goto nesting;
+			case '(':
+				if (!esc)
+					n++;
+				goto nesting;
+			case ')':
+				if (!esc && !--n)
+					break;
+				goto nesting;
+			default:
+			nesting:
+				if (isalnum(i) || (e->re.nest.type[i] & (REX_NEST_close|REX_NEST_escape|REX_NEST_literal|REX_NEST_quote|REX_NEST_delimiter|REX_NEST_separator|REX_NEST_terminator)))
+					goto invalid;
+				e->re.nest.type[i] = REX_NEST_open;
+				if ((x = chr(env, &esc)) < 0 || (e->re.nest.type[x] & (REX_NEST_close|REX_NEST_escape|REX_NEST_delimiter|REX_NEST_separator|REX_NEST_terminator)))
+					goto invalid;
+				if (!esc)
+				{
+					if (x == ')' && !--n)
+						goto invalid;
+					else if (x == '(')
+						n++;
+				}
+				e->re.nest.type[x] |= REX_NEST_close;
+				e->re.nest.type[i] |= x << REX_NEST_SHIFT;
+				continue;
+			}
+			break;
+		}
+		env->parnest--;
+		if (c == T_PERCENT)
+			for (n = 0; n < 2; n++)
+			{
+				parno = ++env->parno;
+				if (!(f = node(env, REX_GROUP, 0, 0, 0)))
+				{
+					drop(env->disc, e);
+					return 0;
+				}
+				if (parno < elementsof(env->paren))
+					env->paren[parno] = f;
+				f->re.group.back = 0;
+				f->re.group.number = parno;
+				f->re.group.expr.rex = e;
+				e = f;
+			}
+		return e;
+	case '(':
+		c = 0;
+		if (isdigit(*env->cursor))
+		{
+			f = 0;
+			do
+			{
+				if (c > (INT_MAX / 10))
+				{
+					env->error = REG_BADRPT;
+					return 0;
+				}
+				c = c * 10 + (*env->cursor++ - '0');
+			} while (isdigit(*env->cursor));
+			if (*env->cursor++ != ')')
+			{
+				env->error = REG_BADRPT;
+				return 0;
+			}
+			if (c && env->type >= SRE)
+				c = c * 2 - 1;
+			if (!c || c > env->parno || !env->paren[c])
+			{
+				if (!(env->flags & REG_LENIENT))
+				{
+					env->error = REG_ESUBREG;
+					return 0;
+				}
+				if (c)
+					c = -1;
+			}
+		}
+		else
+		{
+			if (env->type < SRE && *env->cursor++ != '?')
+			{
+				env->error = REG_BADRPT;
+				return 0;
+			}
+			if (!(f = grp(env, parno + 1)) && env->error)
+				return 0;
+		}
+		if (!(e = node(env, REX_GROUP_COND, 0, 0, 0)))
+		{
+			drop(env->disc, f);
+			return 0;
+		}
+		e->re.group.size = c;
+		e->re.group.expr.binary.left = f;
+		if (!(e->re.group.expr.binary.right = alt(env, parno, 1)))
+		{
+			drop(env->disc, e);
+			return 0;
+		}
+		if (token(env) != T_CLOSE)
+		{
+			env->error = REG_EPAREN;
+			return 0;
+		}
+		eat(env);
+		env->parnest--;
+		return rep(env, e, parno, parno);
+	case '{':
+		p = env->cursor;
+		n = 1;
+		while (c = *env->cursor)
+		{
+			if (c == '\\' && *(env->cursor + 1))
+				env->cursor++;
+			else if (c == '{')
+				n++;
+			else if (c == '}' && !--n)
+				break;
+			else if (c == env->delimiter || c == env->terminator)
+				break;
+			env->cursor++;
+		}
+		if (c != '}')
+		{
+			env->error = REG_EBRACE;
+			return 0;
+		}
+		if (*++env->cursor != ')')
+		{
+			env->error = REG_EPAREN;
+			return 0;
+		}
+		env->cursor++;
+		env->parnest--;
+		if (env->disc->re_version < REG_VERSION_EXEC)
+		{
+			env->error = REG_BADRPT;
+			return 0;
+		}
+		if (!env->disc->re_execf)
+			return 0;
+		if (!(e = node(env, REX_EXEC, 0, 0, 0)))
+			return 0;
+		e->re.exec.text = (const char*)p;
+		e->re.exec.size = env->cursor - p - 2;
+		if (!env->disc->re_compf)
+			e->re.exec.data = 0;
+		else
+			e->re.exec.data = (*env->disc->re_compf)(env->regex, e->re.exec.text, e->re.exec.size, env->disc);
+		return e;
+	case '0': case '1': case '2': case '3': case '4':
+	case '5': case '6': case '7': case '8': case '9':
+		c -= '0';
+		while (isdigit(*env->cursor))
+		{
+			if (c > (INT_MAX / 10))
+			{
+				env->error = REG_ESUBREG;
+				return 0;
+			}
+			c = c * 10 + *env->cursor++ - '0';
+		}
+		if (*env->cursor == ')')
+		{
+			env->cursor++;
+			env->parnest--;
+			env->token.len = 1;
+			if (c > env->parno || !env->paren[c])
+			{
+				env->error = REG_ESUBREG;
+				return 0;
+			}
+			env->paren[c]->re.group.back = 1;
+			return rep(env, node(env, REX_BACK, c, 0, 0), 0, 0);
+		}
+		/*FALLTHROUGH*/
+	default:
+		env->error = REG_BADRPT;
+		return 0;
+	}
+	if (x && !(e = alt(env, parno, 0)))
+		return 0;
+	c = token(env);
+	env->parnest--;
+	if (c != T_CLOSE)
+	{
+		env->error = REG_EPAREN;
+		return 0;
+	}
+	eat(env);
+	if (typ >= 0)
+	{
+		if (beg)
+			env->pattern = env->cursor;
+		env->type = typ;
+	}
+	if (!x)
+		return 0;
+	if (!(f = node(env, x, 0, 0, 0)))
+	{
+		drop(env->disc, e);
+		return 0;
+	}
+	f->re.group.expr.rex = e;
+	if (x == REX_GROUP_BEHIND || x == REX_GROUP_BEHIND_NOT)
+	{
+		if (stats(env, e))
+		{
+			drop(env->disc, f);
+			if (!env->error)
+				env->error = REG_ECOUNT;
+			return 0;
+		}
+		f->re.group.size = env->stats.m;
+		memset(&env->stats, 0, sizeof(env->stats));
+	}
+	switch (x)
+	{
+	case REX_GROUP:
+	case REX_GROUP_CUT:
+		f = rep(env, f, parno, env->parno);
+		break;
+	}
+	return f;
+}
+
+static Rex_t*
+seq(Cenv_t* env)
+{
+	Rex_t*		e;
+	Rex_t*		f;
+	Token_t		tok;
+	int		c;
+	int		i;
+	int		n;
+	int		x;
+	int		parno;
+	int		type;
+	regflags_t	flags;
+	unsigned char*	s;
+	unsigned char*	p;
+	unsigned char*	t;
+	unsigned char*	u;
+	unsigned char	buf[256];
+
+	for (;;)
+	{
+		s = buf;
+		while ((c = token(env)) < T_META && s < &buf[sizeof(buf) - env->token.len])
+		{	
+			x = c;
+			p = env->cursor;
+			if (c >= 0)
+			{
+				n = 1;
+				*s++ = (env->flags & REG_ICASE) ? toupper(c) : c;
+			}
+			else if (c == C_ESC)
+			{
+				if ((n = wctomb(NiL, env->token.lex)) < 0)
+					continue;
+				if (!n)
+				{
+					n = 1;
+					*s++ = 0;
+				}
+				else if (s < &buf[sizeof(buf) - n])
+				{
+					wctomb((char*)s, c);
+					s += n;
+				}
+				else
+					break;
+			}
+			else
+			{
+				n = env->token.len - env->token.esc;
+				for (t = p, u = s + n; s < u; *s++ = *t++);
+			}
+			eat(env);
+		}
+		if (c == T_BAD)
+			return 0;
+		if (s > buf)
+			switch (c)
+			{
+			case T_STAR:
+			case T_PLUS:
+			case T_LEFT:
+			case T_QUES:
+			case T_BANG:
+				if ((s -= n) == buf)
+					e = 0;
+				else
+				{
+					i = s - buf;
+					if (!(e = node(env, REX_STRING, 0, 0, i)))
+						return 0;
+					memcpy((char*)(e->re.string.base = (unsigned char*)e->re.data), (char*)buf, i);
+					e->re.string.size = i;
+				}
+				if (x >= 0)
+				{
+					if (!(f = node(env, REX_ONECHAR, 1, 1, 0)))
+					{
+						drop(env->disc, e);
+						return 0;
+					}
+					f->re.onechar = (env->flags & REG_ICASE) ? toupper(x) : x;
+				}
+				else
+				{
+					if (!(e = node(env, REX_STRING, 0, 0, n)))
+						return 0;
+					memcpy((char*)(e->re.string.base = (unsigned char*)e->re.data), (char*)p, n);
+					e->re.string.size = n;
+				}
+				if (!(f = rep(env, f, 0, 0)) || !(f = cat(env, f, seq(env))))
+				{
+					drop(env->disc, e);
+					return 0;
+				}
+				if (e)
+					f = cat(env, e, f);
+				return f;
+			default:
+				c = s - buf;
+				if (!(e = node(env, REX_STRING, 0, 0, c)))
+					return 0;
+				memcpy((char*)(e->re.string.base = (unsigned char*)e->re.data), (char*)buf, c);
+				e->re.string.size = c;
+				return cat(env, e, seq(env));
+			}
+		else if (c > T_BACK)
+		{
+			eat(env);
+			c -= T_BACK;
+			if (c > env->parno || !env->paren[c])
+			{
+				env->error = REG_ESUBREG;
+				return 0;
+			}
+			env->paren[c]->re.group.back = 1;
+			e = rep(env, node(env, REX_BACK, c, 0, 0), 0, 0);
+		}
+		else
+			switch (c)
+			{
+			case T_AND:
+			case T_CLOSE:
+			case T_BAR:
+			case T_END:
+				return node(env, REX_NULL, 0, 0, 0);
+			case T_DOLL:
+				eat(env);
+				e = rep(env, node(env, REX_END, 0, 0, 0), 0, 0);
+				break;
+			case T_CFLX:
+				eat(env);
+				if ((e = node(env, REX_BEG, 0, 0, 0)) && (env->flags & REG_EXTENDED))
+					e = rep(env, e, 0, 0);
+				break;
+			case T_OPEN:
+				tok = env->token;
+				eat(env);
+				flags = env->flags;
+				type = env->type;
+				if (env->token.att)
+					env->flags |= REG_MINIMAL;
+				env->parnest++;
+				if (env->type == KRE)
+					++env->parno;
+				parno = ++env->parno;
+				if (!(e = alt(env, parno + 1, 0)))
+					break;
+				if (e->type == REX_NULL && env->type == ERE && !(env->flags & REG_NULL))
+				{
+					drop(env->disc, e);
+					env->error = (*env->cursor == 0 || *env->cursor == env->delimiter || *env->cursor == env->terminator) ? REG_EPAREN : REG_ENULL;
+					return 0;
+				} 
+				if (token(env) != T_CLOSE)
+				{
+					drop(env->disc, e);
+					env->error = REG_EPAREN;
+					return 0;
+				} 
+				env->parnest--;
+				eat(env);
+				if (!(f = node(env, REX_GROUP, 0, 0, 0)))
+				{
+					drop(env->disc, e);
+					return 0;
+				}
+				if (parno < elementsof(env->paren))
+					env->paren[parno] = f;
+				f->re.group.back = 0;
+				f->re.group.number = parno;
+				f->re.group.expr.rex = e;
+				if (tok.lex)
+				{
+					tok.push = 1;
+					env->token = tok;
+				}
+				if (!(e = rep(env, f, parno, env->parno)))
+					return 0;
+				if (env->type == KRE)
+				{
+					if (!(f = node(env, REX_GROUP, 0, 0, 0)))
+					{
+						drop(env->disc, e);
+						return 0;
+					}
+					if (--parno < elementsof(env->paren))
+						env->paren[parno] = f;
+					f->re.group.back = 0;
+					f->re.group.number = parno;
+					f->re.group.expr.rex = e;
+					e = f;
+				}
+				env->flags = flags;
+				env->type = type;
+				break;
+			case T_GROUP:
+				p = env->cursor;
+				eat(env);
+				flags = env->flags;
+				type = env->type;
+				if (!(e = grp(env, env->parno + 1)))
+				{
+					if (env->error)
+						return 0;
+					if (env->literal == env->pattern && env->literal == p)
+						env->literal = env->cursor;
+					continue;
+				}
+				env->flags = flags;
+				env->type = type;
+				break;
+			case T_BRA:
+				eat(env);
+				if (e = bra(env))
+					e = rep(env, e, 0, 0);
+				break;
+			case T_ALNUM:
+			case T_ALNUM_NOT:
+			case T_DIGIT:
+			case T_DIGIT_NOT:
+			case T_SPACE:
+			case T_SPACE_NOT:
+				eat(env);
+				if (e = ccl(env, c))
+					e = rep(env, e, 0, 0);
+				break;
+			case T_LT:
+				eat(env);
+				e = rep(env, node(env, REX_WBEG, 0, 0, 0), 0, 0);
+				break;
+			case T_GT:
+				eat(env);
+				e = rep(env, node(env, REX_WEND, 0, 0, 0), 0, 0);
+				break;
+			case T_DOT:
+				eat(env);
+				e = rep(env, node(env, REX_DOT, 1, 1, 0), 0, 0);
+				break;
+			case T_DOTSTAR:
+				eat(env);
+				env->token.lex = T_STAR;
+				env->token.push = 1;
+				e = rep(env, node(env, REX_DOT, 1, 1, 0), 0, 0);
+				break;
+			case T_SLASHPLUS:
+				eat(env);
+				env->token.lex = T_PLUS;
+				env->token.push = 1;
+				if (e = node(env, REX_ONECHAR, 1, 1, 0))
+				{
+					e->re.onechar = '/';
+					e = rep(env, e, 0, 0);
+				}
+				break;
+			case T_WORD:
+				eat(env);
+				e = rep(env, node(env, REX_WORD, 0, 0, 0), 0, 0);
+				break;
+			case T_WORD_NOT:
+				eat(env);
+				e = rep(env, node(env, REX_WORD_NOT, 0, 0, 0), 0, 0);
+				break;
+			case T_BEG_STR:
+				eat(env);
+				e = rep(env, node(env, REX_BEG_STR, 0, 0, 0), 0, 0);
+				break;
+			case T_END_STR:
+				eat(env);
+				e = rep(env, node(env, REX_END_STR, 0, 0, 0), 0, 0);
+				break;
+			case T_FIN_STR:
+				eat(env);
+				e = rep(env, node(env, REX_FIN_STR, 0, 0, 0), 0, 0);
+				break;
+			default:
+				env->error = REG_BADRPT;
+				return 0;
+			}
+		if (e && *env->cursor != 0 && *env->cursor != env->delimiter && *env->cursor != env->terminator)
+			e = cat(env, e, seq(env));
+		return e;
+	}
+}
+
+static Rex_t*
+con(Cenv_t* env)
+{
+	Rex_t*	e;
+	Rex_t*	f;
+	Rex_t*	g;
+
+	if (!(e = seq(env)) || !(env->flags & REG_AUGMENTED) || token(env) != T_AND)
+		return e;
+	eat(env);
+	if (!(f = con(env)))
+	{
+		drop(env->disc, e);
+		return 0;
+	}
+	if (!(g = node(env, REX_CONJ, 0, 0, 0)))
+	{
+		drop(env->disc, e);
+		drop(env->disc, f);
+		return 0;
+	}
+	g->re.group.expr.binary.left = e;
+	g->re.group.expr.binary.right = f;
+	return g;
+}
+
+static Rex_t*
+alt(Cenv_t* env, int number, int cond)
+{
+	Rex_t*	e;
+	Rex_t*	f;
+	Rex_t*	g;
+
+	if (!(e = con(env)))
+		return 0;
+	else if (token(env) != T_BAR)
+	{
+		if (!cond)
+			return e;
+		f = 0;
+		if (e->type == REX_NULL)
+			goto bad;
+	}
+	else
+	{
+		eat(env);
+		if (!(f = alt(env, number, 0)))
+		{
+			drop(env->disc, e);
+			return 0;
+		}
+		if ((e->type == REX_NULL || f->type == REX_NULL) && !(env->flags & REG_NULL))
+			goto bad;
+		if (!cond && (g = trie(env, e, f)))
+			return g;
+	}
+	if (!(g = node(env, REX_ALT, 0, 0, 0)))
+	{
+		env->error = REG_ESPACE;
+		goto bad;
+	}
+	g->re.group.number = number;
+	g->re.group.last = env->parno;
+	g->re.group.expr.binary.left = e;
+	g->re.group.expr.binary.right = f;
+	return g;
+ bad:
+	drop(env->disc, e);
+	drop(env->disc, f);
+	if (!env->error)
+		env->error = REG_ENULL;
+	return 0;
+}
+
+/*
+ * add v to REX_BM tables
+ */
+
+static void
+bmstr(Cenv_t* env, register Rex_t* a, unsigned char* v, int n, Bm_mask_t b)
+{
+	int	c;
+	int	m;
+	size_t	z;
+
+	for (m = 0; m < n; m++)
+	{
+		if (!(z = n - m - 1))
+			z = HIT;
+		c = v[m];
+		a->re.bm.mask[m][c] |= b;
+		if (z == HIT || !a->re.bm.skip[c] || a->re.bm.skip[c] > z && a->re.bm.skip[c] < HIT)
+			a->re.bm.skip[c] = z;
+		if (a->flags & REG_ICASE)
+		{
+			if (isupper(c))
+				c = tolower(c);
+			else if (islower(c))
+				c = toupper(c);
+			else
+				continue;
+			a->re.bm.mask[m][c] |= b;
+			if (z == HIT || !a->re.bm.skip[c] || a->re.bm.skip[c] > z && a->re.bm.skip[c] < HIT)
+				a->re.bm.skip[c] = z;
+		}
+	}
+}
+
+/*
+ * set up BM table from trie
+ */
+
+static int
+bmtrie(Cenv_t* env, Rex_t* a, unsigned char* v, Trie_node_t* x, int n, int m, Bm_mask_t b)
+{
+	do
+	{
+		v[m] = x->c;
+		if (m >= (n - 1))
+		{
+			bmstr(env, a, v, n, b);
+			if (!(b <<= 1))
+			{
+				b = 1;
+				a->re.bm.complete = 0;
+			}
+			else if (x->son)
+				a->re.bm.complete = 0;
+		}
+		else if (x->son)
+			b = bmtrie(env, a, v, x->son, n, m + 1, b);
+	} while (x = x->sib);
+	return b;
+}
+
+/*
+ * rewrite the expression tree for some special cases
+ * 1. it is a null expression - illegal
+ * 2. max length fixed string found -- use BM algorithm
+ * 3. it begins with an unanchored string - use KMP algorithm
+ * 0 returned on success
+ */		
+
+static int
+special(Cenv_t* env, regex_t* p)
+{
+	Rex_t*		a;
+	Rex_t*		e;
+	Rex_t*		t;
+	Rex_t*		x;
+	Rex_t*		y;
+	unsigned char*	s;
+	int*		f;
+	int		n;
+	int		m;
+	int		k;
+
+	DEBUG_INIT();
+	if (e = p->env->rex)
+	{
+		if ((x = env->stats.x) && x->re.string.size < 3)
+			x = 0;
+		if ((t = env->stats.y) && t->re.trie.min < 3)
+			t = 0;
+		if (x && t)
+		{
+			if (x->re.string.size >= t->re.trie.min)
+				t = 0;
+			else
+				x = 0;
+		}
+		if ((x || t) && !env->map) /* HERE: figure out map */
+		{
+			Bm_mask_t**	mask;
+			Bm_mask_t*	h;
+			unsigned char*	v;
+			size_t*		q;
+			unsigned long	l;
+			int		i;
+			int		j;
+
+			if (x)
+			{
+				y = x;
+				n = m = x->re.string.size;
+				l = env->stats.l;
+			}
+			else
+			{
+				y = t;
+				n = t->re.trie.min;
+				m = t->re.trie.max;
+				l = env->stats.k;
+			}
+			if (!(q = (size_t*)alloc(env->disc, 0, (n + 1) * sizeof(size_t))))
+				return 1;
+			if (!(a = node(env, REX_BM, 0, 0, n * (sizeof(Bm_mask_t*) + (UCHAR_MAX + 1) * sizeof(Bm_mask_t)) + (UCHAR_MAX + n + 2) * sizeof(size_t))))
+			{
+				alloc(env->disc, q, 0);
+				return 1;
+			}
+			a->flags = y->flags;
+			a->map = y->map;
+			a->re.bm.size = n;
+			a->re.bm.back = (y == e || y == e->re.group.expr.rex) ? (m - n) : -1;
+			a->re.bm.left = l - 1;
+			a->re.bm.right = env->stats.m - l - n;
+			a->re.bm.complete = (y != e && (e->type != REX_GROUP || y != e->re.group.expr.rex) || e->next || ((a->re.bm.left + a->re.bm.right) >= 0)) ? 0 : n;
+			h = (Bm_mask_t*)&a->re.bm.mask[n];
+			a->re.bm.skip = (size_t*)(h + n * (UCHAR_MAX + 1));
+			a->re.bm.fail = &a->re.bm.skip[UCHAR_MAX + 1];
+			for (m = 0; m <= UCHAR_MAX; m++)
+				a->re.bm.skip[m] = n;
+			a->re.bm.skip[0] = a->re.bm.skip[env->mappednewline] = (y->next && y->next->type == REX_END) ? HIT : (n + a->re.bm.left);
+			for (i = 1; i <= n; i++)
+				a->re.bm.fail[i] = 2 * n - i;
+			mask = a->re.bm.mask;
+			for (m = 0; m < n; m++)
+			{
+				mask[m] = h;
+				h += UCHAR_MAX + 1;
+			}
+			if (x)
+				bmstr(env, a, x->re.string.base, n, 1);
+			else
+			{
+				v = (unsigned char*)q;
+				memset(v, 0, n);
+				m = 1;
+				for (i = 0; i <= UCHAR_MAX; i++)
+					if (t->re.trie.root[i])
+						m = bmtrie(env, a, v, t->re.trie.root[i], n, 0, m);
+			}
+			mask--;
+			memset(q, 0, n * sizeof(*q));
+			for (k = (j = n) + 1; j > 0; j--, k--)
+			{
+				DEBUG_TEST(0x0010,(sfprintf(sfstderr, "BM#0: k=%d j=%d\n", k, j)),(0));
+				for (q[j] = k; k <= n; k = q[k])
+				{
+					for (m = 0; m <= UCHAR_MAX; m++)
+						if (mask[k][m] == mask[j][m])
+						{
+							DEBUG_TEST(0x0010,sfprintf(sfstderr, "CUT1: mask[%d][%c]=mask[%d][%c]\n", k, m, j, m), (0));
+							goto cut;
+						}
+					DEBUG_TEST(0x0010,sfprintf(sfstderr, "BM#2: fail[%d]=%d => %d\n", k, a->re.bm.fail[k], (a->re.bm.fail[k] > n - j) ? (n - j) : a->re.bm.fail[k]), (0));
+					if (a->re.bm.fail[k] > n - j)
+						a->re.bm.fail[k] = n - j;
+				}
+			cut:	;
+			}
+			for (i = 1; i <= n; i++)
+				if (a->re.bm.fail[i] > n + k - i)
+				{
+					DEBUG_TEST(0x0010,sfprintf(sfstderr, "BM#4: fail[%d]=%d => %d\n", i, a->re.bm.fail[i], n + k - i), (0));
+					a->re.bm.fail[i] = n + k - i;
+				}
+#if _AST_REGEX_DEBUG
+			if (DEBUG_TEST(0x0020,(1),(0)))
+			{
+				sfprintf(sfstderr, "STAT: complete=%d n=%d k=%d l=%d r=%d y=%d:%d e=%d:%d\n", a->re.bm.complete, n, k, a->re.bm.left, a->re.bm.right, y->type, y->next ? y->next->type : 0, e->type, e->next ? e->next->type : 0);
+				for (m = 0; m < n; m++)
+					for (i = 1; i <= UCHAR_MAX; i++)
+						if (a->re.bm.mask[m][i])
+							sfprintf(sfstderr, "MASK: [%d]['%c'] = %032..2u\n", m, i, a->re.bm.mask[m][i]);
+				for (i = ' '; i <= UCHAR_MAX; i++)
+					if (a->re.bm.skip[i] >= HIT)
+						sfprintf(sfstderr, "SKIP: ['%c'] =   *\n", i);
+					else if (a->re.bm.skip[i] > 0 && a->re.bm.skip[i] < n)
+						sfprintf(sfstderr, "SKIP: ['%c'] = %3d\n", i, a->re.bm.skip[i]);
+				for (j = 31; j >= 0; j--)
+				{
+					sfprintf(sfstderr, "      ");
+				next:
+					for (m = 0; m < n; m++)
+					{
+						for (i = 0040; i < 0177; i++)
+							if (a->re.bm.mask[m][i] & (1 << j))
+							{
+								sfprintf(sfstderr, "  %c", i);
+								break;
+							}
+						if (i >= 0177)
+						{
+							if (j > 0)
+							{
+								j--;
+								goto next;
+							}
+							sfprintf(sfstderr, "  ?");
+						}
+					}
+					sfprintf(sfstderr, "\n");
+				}
+				sfprintf(sfstderr, "FAIL: ");
+				for (m = 1; m <= n; m++)
+					sfprintf(sfstderr, "%3d", a->re.bm.fail[m]);
+				sfprintf(sfstderr, "\n");
+			}
+#endif
+			alloc(env->disc, q, 0);
+			a->next = e;
+			p->env->rex = a;
+			return 0;
+		}
+		switch (e->type)
+		{
+		case REX_BEG:
+			if (env->flags & REG_NEWLINE)
+				return 0;
+			break;
+		case REX_GROUP:
+			if (env->stats.b)
+				return 0;
+			e = e->re.group.expr.rex;
+			if (e->type != REX_DOT)
+				return 0;
+			/*FALLTHROUGH*/
+		case REX_DOT:
+			if (e->lo == 0 && e->hi == RE_DUP_INF)
+				break;
+			return 0;
+		case REX_NULL:
+			if (env->flags & REG_NULL)
+				break;
+			env->error = REG_ENULL;
+			return 1;
+		case REX_STRING:
+			if (env->flags & (REG_LEFT|REG_LITERAL|REG_RIGHT))
+				return 0;
+			s = e->re.string.base;
+			n = e->re.string.size;
+			if (!(a = node(env, REX_KMP, 0, 0, n * (sizeof(int*) + 1))))
+				return 1;
+			a->flags = e->flags;
+			a->map = e->map;
+			f = a->re.string.fail;
+			memcpy((char*)(a->re.string.base = (unsigned char*)&f[n]), (char*)s, n);
+			s = a->re.string.base;
+			a->re.string.size = n;
+			f[0] = m = -1;
+			for (k = 1; k < n; k++)
+			{
+				while (m >= 0 && s[m+1] != s[k])
+					m = f[m];
+				if (s[m+1] == s[k])
+					m++;
+				f[k] = m;
+			}
+			a->next = e->next;
+			p->env->rex = a;
+			e->next = 0;
+			drop(env->disc, e);
+			break;
+		default:
+			return 0;
+		}
+	}
+	p->env->once = 1;
+	return 0;
+}		
+
+int
+regcomp(regex_t* p, const char* pattern, regflags_t flags)
+{
+	Rex_t*			e;
+	Rex_t*			f;
+	regdisc_t*		disc;
+	unsigned char*		fold;
+	int			i;
+	Cenv_t			env;
+
+	if (!p)
+		return REG_BADPAT;
+	if (flags & REG_DISCIPLINE)
+	{
+		flags &= ~REG_DISCIPLINE;
+		disc = p->re_disc;
+	}
+	else
+		disc = &state.disc;
+	if (!disc->re_errorlevel)
+		disc->re_errorlevel = 2;
+	p->env = 0;
+	if (!pattern)
+		return fatal(disc, REG_BADPAT, pattern);
+	if (!state.initialized)
+	{
+		state.initialized = 1;
+		for (i = 0; i < elementsof(state.escape); i++)
+			state.magic[state.escape[i].key] = state.escape[i].val;
+	}
+	if (!(fold = (unsigned char*)LCINFO(AST_LC_CTYPE)->data))
+	{
+		if (!(fold = newof(0, unsigned char, UCHAR_MAX, 1)))
+			return fatal(disc, REG_ESPACE, pattern);
+		for (i = 0; i <= UCHAR_MAX; i++)
+			fold[i] = toupper(i);
+		LCINFO(AST_LC_CTYPE)->data = (void*)fold;
+	}
+ again:
+	if (!(p->env = (Env_t*)alloc(disc, 0, sizeof(Env_t))))
+		return fatal(disc, REG_ESPACE, pattern);
+	memset(p->env, 0, sizeof(*p->env));
+	memset(&env, 0, sizeof(env));
+	env.regex = p;
+	env.flags = flags;
+	env.disc = p->env->disc = disc;
+	if (env.flags & REG_AUGMENTED)
+		env.flags |= REG_EXTENDED;
+	env.mappeddot = '.';
+	env.mappednewline = '\n';
+	env.mappedslash = '/';
+	if (disc->re_version >= REG_VERSION_MAP && disc->re_map)
+	{
+		env.map = disc->re_map;
+		env.MAP = p->env->fold;
+		for (i = 0; i <= UCHAR_MAX; i++)
+		{
+			env.MAP[i] = fold[env.map[i]];
+			if (env.map[i] == '.')
+				env.mappeddot = i;
+			if (env.map[i] == '\n')
+				env.mappednewline = i;
+			if (env.map[i] == '/')
+				env.mappedslash = i;
+		}
+	}
+	else
+		env.MAP = fold;
+	env.type = (env.flags & REG_AUGMENTED) ? ARE : (env.flags & REG_EXTENDED) ? ERE : BRE;
+	env.explicit = -1;
+	if (env.flags & REG_SHELL)
+	{
+		if (env.flags & REG_SHELL_PATH)
+			env.explicit = env.mappedslash;
+		env.flags |= REG_LENIENT|REG_NULL;
+		env.type = env.type == BRE ? SRE : KRE;
+	}
+	if ((env.flags & (REG_NEWLINE|REG_SPAN)) == REG_NEWLINE)
+		env.explicit = env.mappednewline;
+	p->env->leading = (env.flags & REG_SHELL_DOT) ? env.mappeddot : -1;
+	env.posixkludge = !(env.flags & (REG_EXTENDED|REG_SHELL));
+	env.token.lex = 0;
+	env.token.push = 0;
+	if (env.flags & REG_DELIMITED)
+	{
+		switch (env.delimiter = *pattern++)
+		{
+		case 0:
+		case '\\':
+		case '\n':
+		case '\r':
+			env.error = REG_EDELIM;
+			goto bad;
+		}
+		env.terminator = '\n';
+	}
+	env.literal = env.pattern = env.cursor = (unsigned char*)pattern;
+	if (!(p->env->rex = alt(&env, 1, 0)))
+		goto bad;
+	if (env.parnest)
+	{
+		env.error = REG_EPAREN;
+		goto bad;
+	}
+	p->env->stats.re_flags = env.flags & (REG_EXTENDED|REG_AUGMENTED|REG_SHELL);
+	if (env.flags & REG_LEFT)
+	{
+		if (p->env->rex->type != REX_BEG)
+		{
+			if (p->env->rex->type == REX_ALT)
+				env.flags &= ~REG_FIRST;
+			if (!(e = node(&env, REX_BEG, 0, 0, 0)))
+			{
+				regfree(p);
+				return fatal(disc, REG_ESPACE, pattern);
+			}
+			e->next = p->env->rex;
+			p->env->rex = e;
+			p->env->once = 1;
+		}
+		p->env->stats.re_flags |= REG_LEFT;
+	}
+	for (e = p->env->rex; e->next; e = e->next);
+	p->env->done.type = REX_DONE;
+	p->env->done.flags = e->flags;
+	if (env.flags & REG_RIGHT)
+	{
+		if (e->type != REX_END)
+		{
+			if (p->env->rex->type == REX_ALT)
+				env.flags &= ~REG_FIRST;
+			if (!(f = node(&env, REX_END, 0, 0, 0)))
+			{
+				regfree(p);
+				return fatal(disc, REG_ESPACE, pattern);
+			}
+			f->flags = e->flags;
+			f->map = e->map;
+			e->next = f;
+		}
+		p->env->stats.re_flags |= REG_RIGHT;
+	}
+	if (stats(&env, p->env->rex))
+	{
+		if (!env.error)
+			env.error = REG_ECOUNT;
+		goto bad;
+	}
+	if (env.stats.b)
+		p->env->hard = p->env->separate = 1;
+	else if (!(env.flags & REG_FIRST) && (env.stats.a || env.stats.c > 1 && env.stats.c != env.stats.s || env.stats.t && (env.stats.t > 1 || env.stats.a || env.stats.c)))
+		p->env->hard = 1;
+	if (p->env->hard || env.stats.c || env.stats.i)
+		p->env->stats.re_min = p->env->stats.re_max = -1;
+	else
+	{
+		if (!(p->env->stats.re_min = env.stats.m))
+			p->env->stats.re_min = -1;
+		if (!(p->env->stats.re_max = env.stats.n))
+			p->env->stats.re_max = -1;
+	}
+	if (special(&env, p))
+		goto bad;
+	serialize(&env, p->env->rex, 1);
+	p->re_nsub = env.stats.p;
+	if (env.type == KRE)
+		p->re_nsub /= 2;
+	if (env.flags & REG_DELIMITED)
+	{
+		p->re_npat = env.cursor - env.pattern + 1;
+		if (*env.cursor == env.delimiter)
+			p->re_npat++;
+		else if (env.flags & REG_MUSTDELIM)
+		{
+			env.error = REG_EDELIM;
+			goto bad;
+		}
+		else
+			env.flags &= ~REG_DELIMITED;
+	}
+	p->env->explicit = env.explicit;
+	p->env->flags = env.flags & REG_COMP;
+	p->env->min = env.stats.m;
+	p->env->nsub = env.stats.p + env.stats.u;
+	p->env->refs = 1;
+	return 0;
+ bad:
+	regfree(p);
+	if (!env.error)
+		env.error = REG_ESPACE;
+	if (env.type >= SRE && env.error != REG_ESPACE && !(flags & REG_LITERAL))
+	{
+		flags |= REG_LITERAL;
+		pattern = (const char*)env.literal;
+		goto again;
+	}
+	return fatal(disc, env.error, pattern);
+}
+
+/*
+ * regcomp() on sized pattern
+ * the lazy way around adding and checking env.end
+ */
+
+int
+regncomp(regex_t* p, const char* pattern, size_t size, regflags_t flags)
+{
+	char*	s;
+	int	r;
+
+	if (!(s = malloc(size + 1)))
+		return fatal((flags & REG_DISCIPLINE) ? p->re_disc : &state.disc, REG_ESPACE, pattern);
+	memcpy(s, pattern, size);
+	s[size] = 0;
+	r = regcomp(p, s, flags);
+	free(s);
+	return r;
+}
+
+/*
+ * combine two compiled regular expressions if possible,
+ * replacing first with the combination and freeing second.
+ * return 0 on success.
+ * the only combinations handled are building a Trie
+ * from String|Kmp|Trie and String|Kmp
+ */
+
+int
+regcomb(regex_t* p, regex_t* q)
+{
+	Rex_t*	e = p->env->rex;
+	Rex_t*	f = q->env->rex;
+	Rex_t*	g;
+	Cenv_t	env;
+
+	if (!e || !f)
+		return fatal(p->env->disc, REG_BADPAT, NiL);
+	if (p->env->separate || q->env->separate)
+		return REG_ESUBREG;
+	memset(&env, 0, sizeof(env));
+	env.disc = p->env->disc;
+	if (e->type == REX_BM)
+	{
+		p->env->rex = e->next;
+		e->next = 0;
+		drop(env.disc, e);
+		e = p->env->rex;
+	}
+	if (f->type == REX_BM)
+	{
+		q->env->rex = f->next;
+		f->next = 0;
+		drop(env.disc, f);
+		f = q->env->rex;
+	}
+	if (e->type == REX_BEG && f->type == REX_BEG)
+	{
+		p->env->flags |= REG_LEFT;
+		p->env->rex = e->next;
+		e->next = 0;
+		drop(env.disc, e);
+		e = p->env->rex;
+		q->env->rex = f->next;
+		f->next = 0;
+		drop(env.disc, f);
+		f = q->env->rex;
+	}
+	if (e->next && e->next->type == REX_END && f->next && f->next->type == REX_END)
+	{
+		p->env->flags |= REG_RIGHT;
+		drop(env.disc, e->next);
+		e->next = 0;
+		drop(env.disc, f->next);
+		f->next = 0;
+	}
+	if (!(g = trie(&env, f, e)))
+		return fatal(p->env->disc, REG_BADPAT, NiL);
+	p->env->rex = g;
+	if (!q->env->once)
+		p->env->once = 0;
+	q->env->rex = 0;
+	if (p->env->flags & REG_LEFT)
+	{
+		if (!(e = node(&env, REX_BEG, 0, 0, 0)))
+		{
+			regfree(p);
+			return fatal(p->env->disc, REG_ESPACE, NiL);
+		}
+		e->next = p->env->rex;
+		p->env->rex = e;
+		p->env->once = 1;
+	}
+	if (p->env->flags & REG_RIGHT)
+	{
+		for (f = p->env->rex; f->next; f = f->next);
+		if (f->type != REX_END)
+		{
+			if (!(e = node(&env, REX_END, 0, 0, 0)))
+			{
+				regfree(p);
+				return fatal(p->env->disc, REG_ESPACE, NiL);
+			}
+			f->next = e;
+		}
+	}
+	env.explicit = p->env->explicit;
+	env.flags = p->env->flags;
+	env.disc = p->env->disc;
+	if (stats(&env, p->env->rex))
+	{
+		regfree(p);
+		return fatal(p->env->disc, env.error ? env.error : REG_ECOUNT, NiL);
+	}
+	if (special(&env, p))
+	{
+		regfree(p);
+		return fatal(p->env->disc, env.error ? env.error : REG_ESPACE, NiL);
+	}
+	p->env->min = g->re.trie.min;
+	return 0;
+}
+
+/*
+ * copy a reference of p into q
+ * p and q may then have separate regsubcomp() instantiations
+ */
+
+int
+regdup(regex_t* p, regex_t* q)
+{
+	if (!p || !q)
+		return REG_BADPAT;
+	*q = *p;
+	p->env->refs++;
+	q->re_sub = 0;
+	return 0;
+}
diff --git a/usr/src/lib/libast/common/regex/regdecomp.c b/usr/src/lib/libast/common/regex/regdecomp.c
new file mode 100644
index 0000000000..8f5a2af04e
--- /dev/null
+++ b/usr/src/lib/libast/common/regex/regdecomp.c
@@ -0,0 +1,448 @@
+/***********************************************************************
+*                                                                      *
+*               This software is part of the ast package               *
+*           Copyright (c) 1985-2007 AT&T Knowledge Ventures            *
+*                      and is licensed under the                       *
+*                  Common Public License, Version 1.0                  *
+*                      by AT&T Knowledge Ventures                      *
+*                                                                      *
+*                A copy of the License is available at                 *
+*            http://www.opensource.org/licenses/cpl1.0.txt             *
+*         (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9)         *
+*                                                                      *
+*              Information and Software Systems Research               *
+*                            AT&T Research                             *
+*                           Florham Park NJ                            *
+*                                                                      *
+*                 Glenn Fowler <gsf@research.att.com>                  *
+*                  David Korn <dgk@research.att.com>                   *
+*                   Phong Vo <kpv@research.att.com>                    *
+*                                                                      *
+***********************************************************************/
+#pragma prototyped
+
+/*
+ * posix regex decompiler
+ */
+
+#include "reglib.h"
+
+#undef	ismeta
+#define ismeta(c,t,e,d)	(state.magic[c] && state.magic[c][(t)+(e)] >= T_META || (c) == (d))
+#define meta(f,c,t,e,d)	do { if (ismeta(c,t,e,d)) sfputc(f, '\\'); sfputc(f, c); } while (0)
+
+static void
+detrie(Trie_node_t* x, Sfio_t* sp, char* b, char* p, char* e, int delimiter)
+{
+	register Trie_node_t*	y;
+	char*			o;
+	int			k;
+
+	o = p;
+	k = 1;
+	do
+	{
+		if (k)
+		{
+			o = p;
+			if (p < e)
+				*p++ = x->c;
+		}
+		sfputc(sp, x->c);
+		for (y = x->sib; y; y = y->sib)
+		{
+			sfputc(sp, '|');
+			sfputc(sp, '<');
+			sfwrite(sp, b, p - b);
+			sfputc(sp, '>');
+			detrie(y, sp, b, p, e, delimiter);
+		}
+		if (x->end && x->son)
+		{
+			sfputc(sp, '|');
+			sfputc(sp, '{');
+			sfwrite(sp, b, p - b);
+			sfputc(sp, '}');
+			p = o;
+		}
+	} while (x = x->son);
+}
+
+static int
+decomp(register Rex_t* e, Sfio_t* sp, int type, int delimiter, regflags_t flags)
+{
+	Rex_t*		q;
+	unsigned char*	s;
+	unsigned char*	t;
+	int		c;
+	int		d;
+	int		cb;
+	int		cd;
+	int		cr;
+	int		ib;
+	int		ie;
+	int		nb;
+	int		ne;
+	unsigned char	ic[2*UCHAR_MAX];
+	unsigned char	nc[2*UCHAR_MAX];
+
+	do
+	{
+		switch (e->type)
+		{
+		case REX_ALT:
+			if (decomp(e->re.group.expr.binary.left, sp, type, delimiter, flags))
+				return 1;
+			sfputc(sp, '|');
+			if (e->re.group.expr.binary.right && decomp(e->re.group.expr.binary.right, sp, type, delimiter, flags))
+				return 1;
+			break;
+		case REX_BACK:
+			sfprintf(sp, "\\%d", e->lo);
+			break;
+		case REX_BEG:
+			if (type < SRE)
+				sfputc(sp, '^');
+			break;
+		case REX_END:
+			if (type < SRE)
+				sfputc(sp, '$');
+			break;
+		case REX_WBEG:
+			meta(sp, '<', type, 1, delimiter);
+			break;
+		case REX_WEND:
+			meta(sp, '<', type, 1, delimiter);
+			break;
+		case REX_WORD:
+			sfprintf(sp, "\\w");
+			break;
+		case REX_CLASS:
+		case REX_COLL_CLASS:
+		case REX_ONECHAR:
+		case REX_DOT:
+		case REX_REP:
+			if (type >= SRE)
+			{
+				c = ')';
+				if (e->hi == RE_DUP_INF)
+				{
+					if (!e->lo)
+						sfputc(sp, '*');
+					else if (e->lo == 1)
+						sfputc(sp, '+');
+					else
+						sfprintf(sp, "{%d,}", e->lo);
+				}
+				else if (e->hi != 1)
+					sfprintf(sp, "{%d,%d}", e->lo, e->hi);
+				else if (e->lo == 0)
+					sfputc(sp, '?');
+				else
+					c = 0;
+			}
+			switch (e->type)
+			{
+			case REX_REP:
+				if (decomp(e->re.group.expr.rex, sp, type, delimiter, flags))
+					return 1;
+				break;
+			case REX_CLASS:
+				sfputc(sp, '[');
+				nb = ne = ib = ie = -2;
+				cb = cd = cr = 0;
+				s = nc;
+				t = ic;
+				for (c = 0; c <= UCHAR_MAX; c++)
+					if (settst(e->re.charclass, c))
+					{
+						if (c == ']')
+							cb = 1;
+						else if (c == '-')
+							cr = 1;
+						else if (c == delimiter)
+							cd = 1;
+						else if (nb < 0)
+							ne = nb = c;
+						else if (ne == (c - 1))
+							ne = c;
+						else
+						{
+							if (ne == nb)
+								*s++ = ne;
+							else
+							{
+								*s++ = nb;
+								*s++ = '-';
+								*s++ = ne;
+							}
+							ne = nb = c;
+						}
+					}
+					else
+					{
+						if (c == ']')
+							cb = -1;
+						else if (c == '-')
+							cr = -1;
+						else if (c == delimiter)
+							cd = -1;
+						else if (ib < 0)
+							ie = ib = c;
+						else if (ie == (c - 1))
+							ie = c;
+						else
+						{
+							if (ie == ib)
+								*t++ = ie;
+							else
+							{
+								*t++ = ib;
+								*t++ = '-';
+								*t++ = ie;
+							}
+							ie = ib = c;
+						}
+					}
+				if (nb >= 0)
+				{
+					*s++ = nb;
+					if (ne != nb)
+					{
+						*s++ = '-';
+						*s++ = ne;
+					}
+				}
+				if (ib >= 0)
+				{
+					*t++ = ib;
+					if (ie != ib)
+					{
+						*t++ = '-';
+						*t++ = ie;
+					}
+				}
+				if ((t - ic + 1) < (s - nc + (nc[0] == '^')))
+				{
+					sfputc(sp, '^');
+					if (cb < 0)
+						sfputc(sp, ']');
+					if (cr < 0)
+						sfputc(sp, '-');
+					if (cd < 0)
+					{
+						if (flags & REG_ESCAPE)
+							sfputc(sp, '\\');
+						sfputc(sp, delimiter);
+					}
+					sfwrite(sp, ic, t - ic);
+				}
+				else
+				{
+					if (cb > 0)
+						sfputc(sp, ']');
+					if (cr > 0)
+						sfputc(sp, '-');
+					if (cd > 0)
+					{
+						if (flags & REG_ESCAPE)
+							sfputc(sp, '\\');
+						sfputc(sp, delimiter);
+					}
+					if (nc[0] == '^')
+					{
+						sfwrite(sp, nc + 1, s - nc - 1);
+						sfputc(sp, '^');
+					}
+					else
+						sfwrite(sp, nc, s - nc);
+				}
+				sfputc(sp, ']');
+				break;
+			case REX_COLL_CLASS:
+				break;
+			case REX_ONECHAR:
+				meta(sp, e->re.onechar, type, 0, delimiter);
+				break;
+			case REX_DOT:
+				sfputc(sp, '.');
+				break;
+			}
+			if (type < SRE)
+			{
+				if (e->hi == RE_DUP_INF)
+				{
+					if (!e->lo)
+						sfputc(sp, '*');
+					else if (e->lo == 1 && ismeta('+', type, 0, delimiter))
+						meta(sp, '+', type, 1, delimiter);
+					else
+					{
+						meta(sp, '{', type, 1, delimiter);
+						sfprintf(sp, "%d,", e->lo);
+						meta(sp, '}', type, 1, delimiter);
+					}
+				}
+				else if (e->hi != 1 || e->lo == 0 && !ismeta('?', type, 0, delimiter))
+				{
+					meta(sp, '{', type, 1, delimiter);
+					sfprintf(sp, "%d,%d", e->lo, e->hi);
+					meta(sp, '}', type, 1, delimiter);
+				}
+				else if (e->lo == 0)
+					meta(sp, '?', type, 1, delimiter);
+			}
+			else if (c)
+				sfputc(sp, c);
+			break;
+		case REX_STRING:
+		case REX_KMP:
+			t = (s = e->re.string.base) + e->re.string.size;
+			while (s < t)
+			{
+				c = *s++;
+				meta(sp, c, type, 0, delimiter);
+			}
+			break;
+		case REX_TRIE:
+			ib = 0;
+			for (c = 0; c <= UCHAR_MAX; c++)
+				if (e->re.trie.root[c])
+				{
+					char	pfx[1024];
+
+					if (ib)
+						sfputc(sp, '|');
+					else
+						ib = 1;
+					detrie(e->re.trie.root[c], sp, pfx, pfx, &pfx[sizeof(pfx)], delimiter);
+				}
+			break;
+		case REX_NEG:
+			if (type >= SRE)
+				sfprintf(sp, "!(");
+			if (decomp(e->re.group.expr.rex, sp, type, delimiter, flags))
+				return 1;
+			if (type >= SRE)
+				sfputc(sp, ')');
+			else
+				sfputc(sp, '!');
+			break;
+		case REX_CONJ:
+			if (decomp(e->re.group.expr.binary.left, sp, type, delimiter, flags))
+				return 1;
+			sfputc(sp, '&');
+			if (decomp(e->re.group.expr.binary.right, sp, type, delimiter, flags))
+				return 1;
+			break;
+		case REX_GROUP:
+			if (type >= SRE)
+				sfputc(sp, '@');
+			meta(sp, '(', type, 1, delimiter);
+			if (decomp(e->re.group.expr.rex, sp, type, delimiter, flags))
+				return 1;
+			meta(sp, ')', type, 1, delimiter);
+			break;
+		case REX_GROUP_AHEAD:
+		case REX_GROUP_AHEAD_NOT:
+		case REX_GROUP_BEHIND:
+		case REX_GROUP_BEHIND_NOT:
+			meta(sp, '(', type, 1, delimiter);
+			sfputc(sp, '?');
+			if (decomp(e->re.group.expr.rex, sp, type, delimiter, flags))
+				return 1;
+			meta(sp, ')', type, 1, delimiter);
+			break;
+		case REX_GROUP_COND:
+			meta(sp, '(', type, 1, delimiter);
+			sfputc(sp, '?');
+			if (e->re.group.expr.binary.left && decomp(e->re.group.expr.binary.left, sp, type, delimiter, flags))
+				return 1;
+			if (q = e->re.group.expr.binary.right)
+			{
+				sfputc(sp, ':');
+				if (q->re.group.expr.binary.left && decomp(q->re.group.expr.binary.left, sp, type, delimiter, flags))
+					return 1;
+				sfputc(sp, ':');
+				if (q->re.group.expr.binary.right && decomp(q->re.group.expr.binary.right, sp, type, delimiter, flags))
+					return 1;
+			}
+			meta(sp, ')', type, 1, delimiter);
+			break;
+		case REX_GROUP_CUT:
+			meta(sp, '(', type, 1, delimiter);
+			sfputc(sp, '?');
+			if (decomp(e->re.group.expr.rex, sp, type, delimiter, flags))
+				return 1;
+			meta(sp, ')', type, 1, delimiter);
+			break;
+		case REX_BM:
+			break;
+		default:
+			sfprintf(sp, "<ERROR:REX_%d>", e->type);
+			break;
+		}
+	} while (e = e->next);
+	return 0;
+}
+
+/*
+ * reconstruct pattern from compiled re p into sp
+ */
+
+size_t
+regdecomp(regex_t* p, regflags_t flags, char* buf, size_t n)
+{
+	Sfio_t*		sp;
+	char*		s;
+	int		type;
+	int		delimiter;
+	size_t		r;
+
+	if (!(sp = sfstropen()))
+		return 0;
+	if (flags < 0)
+		flags = p->env->flags;
+	switch (flags & (REG_AUGMENTED|REG_EXTENDED|REG_SHELL))
+	{
+	case 0:
+		type = BRE;
+		break;
+	case REG_AUGMENTED:
+	case REG_AUGMENTED|REG_EXTENDED:
+		type = ARE;
+		break;
+	case REG_EXTENDED:
+		type = ERE;
+		break;
+	case REG_SHELL:
+		type = SRE;
+		break;
+	default:
+		type = KRE;
+		break;
+	}
+	if (flags & REG_DELIMITED)
+	{
+		delimiter = '/';
+		sfputc(sp, delimiter);
+	}
+	else
+		delimiter = 0;
+	if (decomp(p->env->rex, sp, type, delimiter, flags))
+		r = 0;
+	else
+	{
+		if (delimiter)
+			sfputc(sp, delimiter);
+		if ((r = sfstrtell(sp) + 1) <= n)
+		{
+			if (!(s = sfstruse(sp)))
+				r = 0;
+			else
+				memcpy(buf, s, r);
+		}
+	}
+	sfstrclose(sp);
+	return r;
+}
diff --git a/usr/src/lib/libast/common/regex/regerror.c b/usr/src/lib/libast/common/regex/regerror.c
new file mode 100644
index 0000000000..e58d6701dc
--- /dev/null
+++ b/usr/src/lib/libast/common/regex/regerror.c
@@ -0,0 +1,95 @@
+/***********************************************************************
+*                                                                      *
+*               This software is part of the ast package               *
+*           Copyright (c) 1985-2007 AT&T Knowledge Ventures            *
+*                      and is licensed under the                       *
+*                  Common Public License, Version 1.0                  *
+*                      by AT&T Knowledge Ventures                      *
+*                                                                      *
+*                A copy of the License is available at                 *
+*            http://www.opensource.org/licenses/cpl1.0.txt             *
+*         (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9)         *
+*                                                                      *
+*              Information and Software Systems Research               *
+*                            AT&T Research                             *
+*                           Florham Park NJ                            *
+*                                                                      *
+*                 Glenn Fowler <gsf@research.att.com>                  *
+*                  David Korn <dgk@research.att.com>                   *
+*                   Phong Vo <kpv@research.att.com>                    *
+*                                                                      *
+***********************************************************************/
+#pragma prototyped
+
+/*
+ * posix regex error message handler
+ */
+
+static const char id[] = "\n@(#)$Id: regex (AT&T Research) 2004-05-24 $\0\n";
+
+#include "reglib.h"
+
+static const char*	reg_error[] =
+{
+	/* REG_ENOSYS	*/	"not supported",
+	/* REG_SUCCESS	*/	"success",
+	/* REG_NOMATCH	*/	"no match",
+	/* REG_BADPAT	*/	"invalid regular expression",
+	/* REG_ECOLLATE	*/	"invalid collation element",
+	/* REG_ECTYPE	*/	"invalid character class",
+	/* REG_EESCAPE	*/	"trailing \\ in pattern",
+	/* REG_ESUBREG	*/	"invalid \\digit backreference",
+	/* REG_EBRACK	*/	"[...] imbalance",
+	/* REG_EPAREN	*/	"\\(...\\) or (...) imbalance",
+	/* REG_EBRACE	*/	"\\{...\\} or {...} imbalance",
+	/* REG_BADBR	*/	"invalid {...} digits",
+	/* REG_ERANGE	*/	"invalid [...] range endpoint",
+	/* REG_ESPACE	*/	"out of space",
+	/* REG_BADRPT	*/	"unary op not preceeded by re",
+	/* REG_ENULL	*/	"empty subexpr in pattern",
+	/* REG_ECOUNT	*/	"re component count overflow",
+	/* REG_BADESC	*/	"invalid \\char escape",
+	/* REG_VERSIONID*/	&id[10],
+	/* REG_EFLAGS	*/	"conflicting flags",
+	/* REG_EDELIM	*/	"invalid or omitted delimiter",
+	/* REG_PANIC	*/	"unrecoverable internal error",
+};
+
+size_t
+regerror(int code, const regex_t* p, char* buf, size_t size)
+{
+	const char*	s;
+
+	NoP(p);
+	if (code++ == REG_VERSIONID)
+		s = (const char*)fmtident(&id[1]);
+	else if (code >= 0 && code < elementsof(reg_error))
+		s = reg_error[code];
+	else
+		s = (const char*)"unknown error";
+	if (size)
+	{
+		strncpy(buf, s, size);
+		buf[size - 1] = 0;
+	}
+	else
+		buf = (char*)s;
+	return strlen(buf) + 1;
+}
+
+/*
+ * discipline error intercept
+ */
+
+int
+fatal(regdisc_t* disc, int code, const char* pattern)
+{
+	if (disc->re_errorf)
+	{
+		if (pattern)
+			(*disc->re_errorf)(NiL, disc, disc->re_errorlevel, "regular expression: %s: %s", pattern, reg_error[code+1]);
+		else
+			(*disc->re_errorf)(NiL, disc, disc->re_errorlevel, "regular expression: %s", reg_error[code+1]);
+	}
+	return code;
+}
diff --git a/usr/src/lib/libast/common/regex/regexec.c b/usr/src/lib/libast/common/regex/regexec.c
new file mode 100644
index 0000000000..60acf41934
--- /dev/null
+++ b/usr/src/lib/libast/common/regex/regexec.c
@@ -0,0 +1,54 @@
+/***********************************************************************
+*                                                                      *
+*               This software is part of the ast package               *
+*           Copyright (c) 1985-2007 AT&T Knowledge Ventures            *
+*                      and is licensed under the                       *
+*                  Common Public License, Version 1.0                  *
+*                      by AT&T Knowledge Ventures                      *
+*                                                                      *
+*                A copy of the License is available at                 *
+*            http://www.opensource.org/licenses/cpl1.0.txt             *
+*         (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9)         *
+*                                                                      *
+*              Information and Software Systems Research               *
+*                            AT&T Research                             *
+*                           Florham Park NJ                            *
+*                                                                      *
+*                 Glenn Fowler <gsf@research.att.com>                  *
+*                  David Korn <dgk@research.att.com>                   *
+*                   Phong Vo <kpv@research.att.com>                    *
+*                                                                      *
+***********************************************************************/
+#pragma prototyped
+
+/*
+ * posix regex executor
+ * single unsized-string interface
+ */
+
+#include "reglib.h"
+
+/*
+ * standard wrapper for the sized-record interface
+ */
+
+int
+regexec(const regex_t* p, const char* s, size_t nmatch, regmatch_t* match, regflags_t flags)
+{
+	if (flags & REG_STARTEND)
+	{
+		int		r;
+		int		m = match->rm_so;
+		regmatch_t*	e;
+
+		if (!(r = regnexec(p, s + m, match->rm_eo - m, nmatch, match, flags)) && m > 0)
+			for (e = match + nmatch; match < e; match++)
+				if (match->rm_so >= 0)
+				{
+					match->rm_so += m;
+					match->rm_eo += m;
+				}
+		return r;
+	}
+	return regnexec(p, s, s ? strlen(s) : 0, nmatch, match, flags);
+}
diff --git a/usr/src/lib/libast/common/regex/regfatal.c b/usr/src/lib/libast/common/regex/regfatal.c
new file mode 100644
index 0000000000..4d0b94e27a
--- /dev/null
+++ b/usr/src/lib/libast/common/regex/regfatal.c
@@ -0,0 +1,49 @@
+/***********************************************************************
+*                                                                      *
+*               This software is part of the ast package               *
+*           Copyright (c) 1985-2007 AT&T Knowledge Ventures            *
+*                      and is licensed under the                       *
+*                  Common Public License, Version 1.0                  *
+*                      by AT&T Knowledge Ventures                      *
+*                                                                      *
+*                A copy of the License is available at                 *
+*            http://www.opensource.org/licenses/cpl1.0.txt             *
+*         (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9)         *
+*                                                                      *
+*              Information and Software Systems Research               *
+*                            AT&T Research                             *
+*                           Florham Park NJ                            *
+*                                                                      *
+*                 Glenn Fowler <gsf@research.att.com>                  *
+*                  David Korn <dgk@research.att.com>                   *
+*                   Phong Vo <kpv@research.att.com>                    *
+*                                                                      *
+***********************************************************************/
+#pragma prototyped
+
+/*
+ * posix regex fatal error interface to error()
+ */
+
+#include "reglib.h"
+
+#include <error.h>
+
+void
+regfatalpat(regex_t* p, int level, int code, const char* pat)
+{
+	char	buf[128];
+
+	regerror(code, p, buf, sizeof(buf));
+	regfree(p);
+	if (pat)
+		error(level, "regular expression: %s: %s", pat, buf);
+	else
+		error(level, "regular expression: %s", buf);
+}
+
+void
+regfatal(regex_t* p, int level, int code)
+{
+	regfatalpat(p, level, code, NiL);
+}
diff --git a/usr/src/lib/libast/common/regex/reginit.c b/usr/src/lib/libast/common/regex/reginit.c
new file mode 100644
index 0000000000..e27fd10a70
--- /dev/null
+++ b/usr/src/lib/libast/common/regex/reginit.c
@@ -0,0 +1,402 @@
+/***********************************************************************
+*                                                                      *
+*               This software is part of the ast package               *
+*           Copyright (c) 1985-2007 AT&T Knowledge Ventures            *
+*                      and is licensed under the                       *
+*                  Common Public License, Version 1.0                  *
+*                      by AT&T Knowledge Ventures                      *
+*                                                                      *
+*                A copy of the License is available at                 *
+*            http://www.opensource.org/licenses/cpl1.0.txt             *
+*         (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9)         *
+*                                                                      *
+*              Information and Software Systems Research               *
+*                            AT&T Research                             *
+*                           Florham Park NJ                            *
+*                                                                      *
+*                 Glenn Fowler <gsf@research.att.com>                  *
+*                  David Korn <dgk@research.att.com>                   *
+*                   Phong Vo <kpv@research.att.com>                    *
+*                                                                      *
+***********************************************************************/
+#pragma prototyped
+
+/*
+ * posix regex state and alloc
+ */
+
+#include "reglib.h"
+
+#include <ccode.h>
+
+/*
+ * state shared by all threads
+ */
+
+State_t		state =
+{
+	{ -1, -1 },
+
+	/*
+	 * escape code table
+	 * the "funny" things get special treatment at ends of BRE
+	 *
+	 *	BRE  0:normal  1:escaped  2:escaped-char-class
+	 *	ERE  3:normal  4:escaped  5:escaped-char-class
+	 *	ARE  6:normal  7:escaped  8:escaped-char-class
+	 *	SRE  9:normal 10:escaped 11:escaped-char-class
+	 *	KRE 12:normal 13:escaped 14:escaped-char-class
+	 */
+
+	'\\',
+		'\\',		'\\',		'\\',
+		'\\',		'\\',		'\\',
+		'\\',		'\\',		'\\',
+		'\\',		'\\',		'\\',
+		'\\',		'\\',		'\\',
+	'^',	/* funny */
+		'^',		'^',		'^',
+		T_CFLX,		'^',		'^',
+		T_CFLX,		'^',		'^',
+		'^',		'^',		'^',
+		'^',		'^',		'^',
+	'.',
+		T_DOT,		'.',		T_BAD,
+		T_DOT, 		'.',		T_BAD,
+		T_DOT, 		'.',		T_BAD,
+		'.',		'.',		T_BAD,
+		'.',		'.',		T_BAD,
+	'$',	/* funny */
+		'$',		'$',		T_BAD,
+		T_DOLL, 	'$',		T_BAD,
+		T_DOLL, 	'$',		T_BAD,
+		'$',		'$',		T_BAD,
+		'$',		'$',		T_BAD,
+	'*',
+		T_STAR,		'*',		T_BAD,
+		T_STAR, 	'*',		T_BAD,
+		T_STAR, 	'*',		T_BAD,
+		T_STAR, 	'*',		'*',
+		T_STAR, 	'*',		'*',
+	'[',
+		T_BRA,		'[',		'[',
+		T_BRA,		'[',		'[',
+		T_BRA,		'[',		'[',
+		T_BRA,		'[',		'[',
+		T_BRA,		'[',		'[',
+	'|',
+		'|',		T_BAD,		T_BAD,
+		T_BAR,		'|',		T_BAD,
+		T_BAR,		'|',		T_BAD,
+		'|',		'|',		T_BAD,
+		T_BAR,		'|',		T_BAD,
+	'+',
+		'+',		T_BAD,		T_BAD,
+		T_PLUS,		'+',		T_BAD,
+		T_PLUS,		'+',		T_BAD,
+		'+',		'+',		T_BAD,
+		T_PLUS,		'+',		T_BAD,
+	'?',
+		'?',		T_BAD,		T_BAD,
+		T_QUES, 	'?',		T_BAD,
+		T_QUES, 	'?',		T_BAD,
+		T_QUES,		'?',		'?',
+		T_QUES,		'?',		'?',
+	'(',
+		'(',		T_OPEN,		T_BAD,
+		T_OPEN, 	'(',		T_BAD,
+		T_OPEN, 	'(',		T_BAD,
+		'(',		'(',		'(',
+		T_OPEN,		'(',		'(',
+	')',
+		')',		T_CLOSE,	T_BAD,
+		T_CLOSE,	')',		T_BAD,
+		T_CLOSE,	')',		T_BAD,
+		')',		')',		')',
+		T_CLOSE,	')',		')',
+	'{',
+		'{',		T_LEFT,		T_BAD,
+		T_LEFT,		'{',		T_BAD,
+		T_LEFT,		'{',		T_BAD,
+		'{',		'{',		'{',
+		T_LEFT,		'{',		'{',
+	'}',
+		'}',		T_RIGHT,	T_BAD,
+		'}',		T_BAD,		T_BAD,
+		'}',		T_BAD,		T_BAD,
+		'}',		'}',		'}',
+		'}',		'}',		'}',
+	'&',
+		'&',		T_BAD,		T_BAD,
+		'&',		T_AND,		T_BAD,
+		T_AND,		'&',		T_BAD,
+		'&',		'&',		T_BAD,
+		T_AND,		'&',		T_BAD,
+	'!',
+		'!',		T_BAD,		T_BAD,
+		'!',		T_BANG,		T_BAD,
+		T_BANG, 	'!',		T_BAD,
+		'!',		'!',		T_BAD,
+		T_BANG,		'!',		T_BAD,
+	'@',
+		'@',		T_BAD,		T_BAD,
+		'@',		T_BAD,		T_BAD,
+		'@',		T_BAD,		T_BAD,
+		'@',		'@',		T_BAD,
+		T_AT,		'@',		T_BAD,
+	'~',
+		'~',		T_BAD,		T_BAD,
+		'~',		T_BAD,		T_BAD,
+		'~',		T_BAD,		T_BAD,
+		'~',		'~',		T_BAD,
+		T_TILDE,	'~',		T_BAD,
+	'%',
+		'%',		T_BAD,		T_BAD,
+		'%',		T_BAD,		T_BAD,
+		'%',		T_BAD,		T_BAD,
+		'%',		'%',		T_BAD,
+		T_PERCENT,	'%',		T_BAD,
+	'<',
+		'<',		T_LT,		T_BAD,
+		'<',		T_LT,		T_BAD,
+		T_LT,   	'<',		T_BAD,
+		'<',		'<',		T_BAD,
+		'<',		'<',		T_BAD,
+	'>',
+		'>',		T_GT,		T_BAD,
+		'>',		T_GT,		T_BAD,
+		T_GT,   	'>',		T_BAD,
+		'>',		'>',		T_BAD,
+		'>',		'>',		T_BAD,
+
+	/* backrefs */
+
+	'0',
+		'0',		T_BACK+0,	T_ESCAPE,
+		'0',		T_BACK+0,	T_ESCAPE,
+		'0',		T_BACK+0,	T_ESCAPE,
+		'0',		T_BACK+0,	T_ESCAPE,
+		'0',		T_BACK+0,	T_ESCAPE,
+	'1',
+		'1',		T_BACK+1,	T_ESCAPE,
+		'1',		T_BACK+1,	T_ESCAPE,
+		'1',		T_BACK+1,	T_ESCAPE,
+		'1',		T_BACK+1,	T_ESCAPE,
+		'1',		T_BACK+1,	T_ESCAPE,
+	'2',
+		'2',		T_BACK+2,	T_ESCAPE,
+		'2',		T_BACK+2,	T_ESCAPE,
+		'2',		T_BACK+2,	T_ESCAPE,
+		'2',		T_BACK+2,	T_ESCAPE,
+		'2',		T_BACK+2,	T_ESCAPE,
+	'3',
+		'3',		T_BACK+3,	T_ESCAPE,
+		'3',		T_BACK+3,	T_ESCAPE,
+		'3',		T_BACK+3,	T_ESCAPE,
+		'3',		T_BACK+3,	T_ESCAPE,
+		'3',		T_BACK+3,	T_ESCAPE,
+	'4',
+		'4',		T_BACK+4,	T_ESCAPE,
+		'4',		T_BACK+4,	T_ESCAPE,
+		'4',		T_BACK+4,	T_ESCAPE,
+		'4',		T_BACK+4,	T_ESCAPE,
+		'4',		T_BACK+4,	T_ESCAPE,
+	'5',
+		'5',		T_BACK+5,	T_ESCAPE,
+		'5',		T_BACK+5,	T_ESCAPE,
+		'5',		T_BACK+5,	T_ESCAPE,
+		'5',		T_BACK+5,	T_ESCAPE,
+		'5',		T_BACK+5,	T_ESCAPE,
+	'6',
+		'6',		T_BACK+6,	T_ESCAPE,
+		'6',		T_BACK+6,	T_ESCAPE,
+		'6',		T_BACK+6,	T_ESCAPE,
+		'6',		T_BACK+6,	T_ESCAPE,
+		'6',		T_BACK+6,	T_ESCAPE,
+	'7',
+		'7',		T_BACK+7,	T_ESCAPE,
+		'7',		T_BACK+7,	T_ESCAPE,
+		'7',		T_BACK+7,	T_ESCAPE,
+		'7',		T_BACK+7,	T_ESCAPE,
+		'7',		T_BACK+7,	T_ESCAPE,
+	'8',
+		'8',		T_BACK+8,	T_ESCAPE,
+		'8',		T_BACK+8,	T_ESCAPE,
+		'8',		T_BACK+8,	T_ESCAPE,
+		'8',		'8',		T_ESCAPE,
+		'8',		T_BACK+8,	T_ESCAPE,
+	'9',
+		'9',		T_BACK+9,	T_ESCAPE,
+		'9',		T_BACK+9,	T_ESCAPE,
+		'9',		T_BACK+9,	T_ESCAPE,
+		'9',		'9',		T_ESCAPE,
+		'9',		T_BACK+9,	T_ESCAPE,
+
+	/* perl */
+
+	'A',
+		'A',		T_BEG_STR,	T_BAD,
+		'A',		T_BEG_STR,	T_BAD,
+		'A',		T_BEG_STR,	T_BAD,
+		'A',		T_BEG_STR,	T_BAD,
+		'A',		T_BEG_STR,	T_BAD,
+	'b',
+		'b',		T_WORD,		'\b',
+		'b',		T_WORD,		'\b',
+		'b',		T_WORD,		'\b',
+		'b',		T_WORD,		'\b',
+		'b',		T_WORD,		'\b',
+	'B',
+		'B',		T_WORD_NOT,	T_BAD,
+		'B',		T_WORD_NOT,	T_BAD,
+		'B',		T_WORD_NOT,	T_BAD,
+		'B',		T_WORD_NOT,	T_BAD,
+		'B',		T_WORD_NOT,	T_BAD,
+	'd',
+		'd',		T_DIGIT,	T_DIGIT,
+		'd',		T_DIGIT,	T_DIGIT,
+		'd',		T_DIGIT,	T_DIGIT,
+		'd',		T_DIGIT,	T_DIGIT,
+		'd',		T_DIGIT,	T_DIGIT,
+	'D',
+		'D',		T_DIGIT_NOT,	T_DIGIT_NOT,
+		'D',		T_DIGIT_NOT,	T_DIGIT_NOT,
+		'D',		T_DIGIT_NOT,	T_DIGIT_NOT,
+		'D',		T_DIGIT_NOT,	T_DIGIT_NOT,
+		'D',		T_DIGIT_NOT,	T_DIGIT_NOT,
+	's',
+		's',		T_SPACE,	T_SPACE,
+		's',		T_SPACE,	T_SPACE,
+		's',		T_SPACE,	T_SPACE,
+		's',		T_SPACE,	T_SPACE,
+		's',		T_SPACE,	T_SPACE,
+	'S',
+		'S',		T_SPACE_NOT,	T_SPACE_NOT,
+		'S',		T_SPACE_NOT,	T_SPACE_NOT,
+		'S',		T_SPACE_NOT,	T_SPACE_NOT,
+		'S',		T_SPACE_NOT,	T_SPACE_NOT,
+		'S',		T_SPACE_NOT,	T_SPACE_NOT,
+	'w',
+		'w',		T_ALNUM,	T_ALNUM,
+		'w',		T_ALNUM,	T_ALNUM,
+		'w',		T_ALNUM,	T_ALNUM,
+		'w',		T_ALNUM,	T_ALNUM,
+		'w',		T_ALNUM,	T_ALNUM,
+	'W',
+		'W',		T_ALNUM_NOT,	T_ALNUM_NOT,
+		'W',		T_ALNUM_NOT,	T_ALNUM_NOT,
+		'W',		T_ALNUM_NOT,	T_ALNUM_NOT,
+		'W',		T_ALNUM_NOT,	T_ALNUM_NOT,
+		'W',		T_ALNUM_NOT,	T_ALNUM_NOT,
+	'z',
+		'z',		T_FIN_STR,	T_BAD,
+		'z',		T_FIN_STR,	T_BAD,
+		'z',		T_FIN_STR,	T_BAD,
+		'z',		T_FIN_STR,	T_BAD,
+		'z',		T_FIN_STR,	T_BAD,
+	'Z',
+		'Z',		T_END_STR,	T_BAD,
+		'Z',		T_END_STR,	T_BAD,
+		'Z',		T_END_STR,	T_BAD,
+		'Z',		T_END_STR,	T_BAD,
+		'Z',		T_END_STR,	T_BAD,
+
+	/* C escapes */
+
+	'a',
+		'a',		CC_bel,		CC_bel,
+		'a',		CC_bel,		CC_bel,
+		'a',		CC_bel,		CC_bel,
+		'a',		CC_bel,		CC_bel,
+		'a',		CC_bel,		CC_bel,
+	'c',
+		'c',		T_ESCAPE,	T_ESCAPE,
+		'c',		T_ESCAPE,	T_ESCAPE,
+		'c',		T_ESCAPE,	T_ESCAPE,
+		'c',		T_ESCAPE,	T_ESCAPE,
+		'c',		T_ESCAPE,	T_ESCAPE,
+	'C',
+		'C',		T_ESCAPE,	T_ESCAPE,
+		'C',		T_ESCAPE,	T_ESCAPE,
+		'C',		T_ESCAPE,	T_ESCAPE,
+		'C',		T_ESCAPE,	T_ESCAPE,
+		'C',		T_ESCAPE,	T_ESCAPE,
+	'e',
+		'e',		CC_esc,		CC_esc,
+		'e',		CC_esc,		CC_esc,
+		'e',		CC_esc,		CC_esc,
+		'e',		CC_esc,		CC_esc,
+		'e',		CC_esc,		CC_esc,
+	'E',
+		'E',		CC_esc,		CC_esc,
+		'E',		CC_esc,		CC_esc,
+		'E',		CC_esc,		CC_esc,
+		'E',		CC_esc,		CC_esc,
+		'E',		CC_esc,		CC_esc,
+	'f',
+		'f',		'\f',		'\f',
+		'f',		'\f',		'\f',
+		'f',		'\f',		'\f',
+		'f',		'\f',		'\f',
+		'f',		'\f',		'\f',
+	'n',
+		'n',		'\n',		'\n',
+		'n',		'\n',		'\n',
+		'n',		'\n',		'\n',
+		'n',		'\n',		'\n',
+		'n',		'\n',		'\n',
+	'r',
+		'r',		'\r',		'\r',
+		'r',		'\r',		'\r',
+		'r',		'\r',		'\r',
+		'r',		'\r',		'\r',
+		'r',		'\r',		'\r',
+	't',
+		't',		'\t',		'\t',
+		't',		'\t',		'\t',
+		't',		'\t',		'\t',
+		't',		'\t',		'\t',
+		't',		'\t',		'\t',
+	'v',
+		'v',		CC_vt,		CC_vt,
+		'v',		CC_vt,		CC_vt,
+		'v',		CC_vt,		CC_vt,
+		'v',		CC_vt,		CC_vt,
+		'v',		CC_vt,		CC_vt,
+	'x',
+		'x',		T_ESCAPE,	T_ESCAPE,
+		'x',		T_ESCAPE,	T_ESCAPE,
+		'x',		T_ESCAPE,	T_ESCAPE,
+		'x',		T_ESCAPE,	T_ESCAPE,
+		'x',		T_ESCAPE,	T_ESCAPE,
+};
+
+/*
+ * all allocation/free done here
+ * interface compatible with vmresize()
+ *
+ *	malloc(n)	alloc(0,n)
+ *	realloc(p,n)	alloc(p,n)
+ *	free(p)		alloc(p,0)
+ */
+
+void*
+alloc(register regdisc_t* disc, void* p, size_t n)
+{
+	if (disc->re_resizef)
+	{
+		if (!n && (disc->re_flags & REG_NOFREE))
+			return 0;
+		return (*disc->re_resizef)(disc->re_resizehandle, p, n);
+	}
+	else if (!n)
+	{
+		if (!(disc->re_flags & REG_NOFREE))
+			free(p);
+		return 0;
+	}
+	else if (p)
+		return realloc(p, n);
+	else
+		return malloc(n);
+}
diff --git a/usr/src/lib/libast/common/regex/reglib.h b/usr/src/lib/libast/common/regex/reglib.h
new file mode 100644
index 0000000000..e2a85fea2a
--- /dev/null
+++ b/usr/src/lib/libast/common/regex/reglib.h
@@ -0,0 +1,578 @@
+/***********************************************************************
+*                                                                      *
+*               This software is part of the ast package               *
+*           Copyright (c) 1985-2007 AT&T Knowledge Ventures            *
+*                      and is licensed under the                       *
+*                  Common Public License, Version 1.0                  *
+*                      by AT&T Knowledge Ventures                      *
+*                                                                      *
+*                A copy of the License is available at                 *
+*            http://www.opensource.org/licenses/cpl1.0.txt             *
+*         (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9)         *
+*                                                                      *
+*              Information and Software Systems Research               *
+*                            AT&T Research                             *
+*                           Florham Park NJ                            *
+*                                                                      *
+*                 Glenn Fowler <gsf@research.att.com>                  *
+*                  David Korn <dgk@research.att.com>                   *
+*                   Phong Vo <kpv@research.att.com>                    *
+*                                                                      *
+***********************************************************************/
+#pragma prototyped
+
+/*
+ * posix regex implementation
+ *
+ * based on Doug McIlroy's C++ implementation
+ * Knuth-Morris-Pratt adapted from Corman-Leiserson-Rivest
+ * Boyer-Moore from conversations with David Korn, Phong Vo, Andrew Hume
+ */
+
+#ifndef _REGLIB_H
+#define _REGLIB_H
+
+#define REG_VERSION_EXEC	20020509L
+#define REG_VERSION_MAP		20030916L	/* regdisc_t.re_map	*/
+
+#define re_info		env
+
+#define alloc		_reg_alloc
+#define classfun	_reg_classfun
+#define drop		_reg_drop
+#define fatal		_reg_fatal
+#define state		_reg_state
+
+typedef struct regsubop_s
+{
+	int		op;		/* REG_SUB_LOWER,REG_SUB_UPPER	*/
+	int		off;		/* re_rhs or match[] offset	*/
+	int		len;		/* re_rhs len or len==0 match[]	*/
+} regsubop_t;
+
+#define _REG_SUB_PRIVATE_ \
+	char*		re_cur;		/* re_buf cursor		*/ \
+	char*		re_end;		/* re_buf end			*/ \
+	regsubop_t*	re_ops;		/* rhs ops			*/ \
+	char		re_rhs[1];	/* substitution rhs		*/
+
+#include <ast.h>
+#include <cdt.h>
+#include <stk.h>
+
+#include "regex.h"
+
+#include <ctype.h>
+#include <errno.h>
+
+#define MBSIZE(p)	((ast.tmp_int=mbsize(p))>0?ast.tmp_int:1)
+
+#undef	RE_DUP_MAX			/* posix puts this in limits.h!	*/
+#define RE_DUP_MAX	(INT_MAX/2-1)	/* 2*RE_DUP_MAX won't overflow	*/
+#define RE_DUP_INF	(RE_DUP_MAX+1)	/* infinity, for *		*/
+#define BACK_REF_MAX	9
+
+#define REG_COMP	(REG_DELIMITED|REG_ESCAPE|REG_EXTENDED|REG_FIRST|REG_ICASE|REG_NOSUB|REG_NEWLINE|REG_SHELL|REG_AUGMENTED|REG_LEFT|REG_LITERAL|REG_MINIMAL|REG_NULL|REG_RIGHT|REG_LENIENT|REG_MUSTDELIM)
+#define REG_EXEC	(REG_ADVANCE|REG_INVERT|REG_NOTBOL|REG_NOTEOL|REG_STARTEND)
+
+#define REX_NULL		0	/* null string (internal)	*/
+#define REX_ALT			1	/* a|b				*/
+#define REX_ALT_CATCH		2	/* REX_ALT catcher		*/
+#define REX_BACK		3	/* \1, \2, etc			*/
+#define REX_BEG			4	/* initial ^			*/
+#define REX_BEG_STR		5	/* initial ^ w/ no newline	*/
+#define REX_BM			6	/* Boyer-Moore			*/
+#define REX_CAT			7	/* catenation catcher		*/
+#define REX_CLASS		8	/* [...]			*/
+#define REX_COLL_CLASS		9	/* collation order [...]	*/
+#define REX_CONJ		10	/* a&b				*/
+#define REX_CONJ_LEFT		11	/* REX_CONJ left catcher	*/
+#define REX_CONJ_RIGHT		12	/* REX_CONJ right catcher	*/
+#define REX_DONE		13	/* completed match (internal)	*/
+#define REX_DOT			14	/* .				*/
+#define REX_END			15	/* final $			*/
+#define REX_END_STR		16	/* final $ before tail newline	*/
+#define REX_EXEC		17	/* call re.re_exec()		*/
+#define REX_FIN_STR		18	/* final $ w/ no newline	*/
+#define REX_GROUP		19	/* \(...\)			*/
+#define REX_GROUP_CATCH		20	/* REX_GROUP catcher		*/
+#define REX_GROUP_AHEAD		21	/* 0-width lookahead		*/
+#define REX_GROUP_AHEAD_CATCH	22	/* REX_GROUP_AHEAD catcher	*/
+#define REX_GROUP_AHEAD_NOT	23	/* inverted 0-width lookahead	*/
+#define REX_GROUP_BEHIND	24	/* 0-width lookbehind		*/
+#define REX_GROUP_BEHIND_CATCH	25	/* REX_GROUP_BEHIND catcher	*/
+#define REX_GROUP_BEHIND_NOT	26	/* inverted 0-width lookbehind	*/
+#define REX_GROUP_BEHIND_NOT_CATCH 27	/* REX_GROUP_BEHIND_NOT catcher	*/
+#define REX_GROUP_COND		28	/* conditional group		*/
+#define REX_GROUP_COND_CATCH	29	/* conditional group catcher	*/
+#define REX_GROUP_CUT		30	/* don't backtrack over this	*/
+#define REX_GROUP_CUT_CATCH	31	/* REX_GROUP_CUT catcher	*/
+#define REX_KMP			32	/* Knuth-Morris-Pratt		*/
+#define REX_NEG			33	/* negation			*/
+#define REX_NEG_CATCH		34	/* REX_NEG catcher		*/
+#define REX_NEST		35	/* nested match			*/
+#define REX_ONECHAR		36	/* a single-character literal	*/
+#define REX_REP			37	/* Kleene closure		*/
+#define REX_REP_CATCH		38	/* REX_REP catcher		*/
+#define REX_STRING		39	/* some chars			*/
+#define REX_TRIE		40	/* alternation of strings	*/
+#define REX_WBEG		41	/* \<				*/
+#define REX_WEND		42	/* \>				*/
+#define REX_WORD		43	/* word boundary		*/
+#define REX_WORD_NOT		44	/* not word boundary		*/
+
+#define T_META		((int)UCHAR_MAX+1)
+#define T_STAR		(T_META+0)
+#define T_PLUS		(T_META+1)
+#define T_QUES		(T_META+2)
+#define T_BANG		(T_META+3)
+#define T_AT		(T_META+4)
+#define T_TILDE		(T_META+5)
+#define T_PERCENT	(T_META+6)
+#define T_LEFT		(T_META+7)
+#define T_OPEN		(T_META+8)
+#define T_CLOSE		(T_OPEN+1)
+#define T_RIGHT		(T_OPEN+2)
+#define T_CFLX		(T_OPEN+3)
+#define T_DOT		(T_OPEN+4)
+#define T_DOTSTAR	(T_OPEN+5)
+#define T_END		(T_OPEN+6)
+#define T_BAD		(T_OPEN+7)
+#define T_DOLL		(T_OPEN+8)
+#define T_BRA		(T_OPEN+9)
+#define T_BAR		(T_OPEN+10)
+#define T_AND		(T_OPEN+11)
+#define T_LT		(T_OPEN+12)
+#define T_GT		(T_OPEN+13)
+#define T_SLASHPLUS	(T_OPEN+14)
+#define T_GROUP		(T_OPEN+15)
+#define T_WORD		(T_OPEN+16)
+#define T_WORD_NOT	(T_WORD+1)
+#define T_BEG_STR	(T_WORD+2)
+#define T_END_STR	(T_WORD+3)
+#define T_FIN_STR	(T_WORD+4)
+#define T_ESCAPE	(T_WORD+5)
+#define T_ALNUM		(T_WORD+6)
+#define T_ALNUM_NOT	(T_ALNUM+1)
+#define T_DIGIT		(T_ALNUM+2)
+#define T_DIGIT_NOT	(T_ALNUM+3)
+#define T_SPACE		(T_ALNUM+4)
+#define T_SPACE_NOT	(T_ALNUM+5)
+#define T_BACK		(T_ALNUM+6)
+
+#define BRE		0
+#define ERE		3
+#define ARE		6
+#define SRE		9
+#define KRE		12
+
+#define HIT		SSIZE_MAX
+
+#define bitclr(p,c)	((p)[((c)>>3)&037]&=(~(1<<((c)&07))))
+#define bitset(p,c)	((p)[((c)>>3)&037]|=(1<<((c)&07)))
+#define bittst(p,c)	((p)[((c)>>3)&037]&(1<<((c)&07)))
+
+#define setadd(p,c)	bitset((p)->bits,c)
+#define setclr(p,c)	bitclr((p)->bits,c)
+#define settst(p,c)	bittst((p)->bits,c)
+
+#if _hdr_wchar && _lib_wctype && _lib_iswctype
+
+#include <stdio.h> /* because <wchar.h> includes it and we generate it */
+#include <wchar.h>
+#if _hdr_wctype
+#include <wctype.h>
+#endif
+
+#if !defined(iswblank) && !_lib_iswblank
+#define _need_iswblank	1
+#define iswblank(x)	_reg_iswblank(x)
+extern int		_reg_iswblank(wint_t);
+#endif
+
+#if !defined(towupper) && !_lib_towupper
+#define towupper(x)	toupper(x)
+#endif
+
+#if !defined(towlower) && !_lib_towlower
+#define towlower(x)	tolower(x)
+#endif
+
+#else
+
+#undef	_lib_wctype
+
+#ifndef iswalnum
+#define iswalnum(x)	isalnum(x)
+#endif
+#ifndef iswalpha
+#define iswalpha(x)	isalpha(x)
+#endif
+#ifndef iswcntrl
+#define iswcntrl(x)	iscntrl(x)
+#endif
+#ifndef iswdigit
+#define iswdigit(x)	isdigit(x)
+#endif
+#ifndef iswgraph
+#define iswgraph(x)	isgraph(x)
+#endif
+#ifndef iswlower
+#define iswlower(x)	islower(x)
+#endif
+#ifndef iswprint
+#define iswprint(x)	isprint(x)
+#endif
+#ifndef iswpunct
+#define iswpunct(x)	ispunct(x)
+#endif
+#ifndef iswspace
+#define iswspace(x)	isspace(x)
+#endif
+#ifndef iswupper
+#define iswupper(x)	isupper(x)
+#endif
+#ifndef iswxdigit
+#define iswxdigit(x)	isxdigit(x)
+#endif
+
+#ifndef towlower
+#define towlower(x)	tolower(x)
+#endif
+#ifndef towupper
+#define towupper(x)	toupper(x)
+#endif
+
+#endif
+
+#ifndef	iswblank
+#define	iswblank(x)	((x)==' '||(x)=='\t')
+#endif
+
+#ifndef iswgraph
+#define	iswgraph(x)	(iswprint(x)&&!iswblank(x))
+#endif
+
+#define isword(x)	(isalnum(x)||(x)=='_')
+
+/*
+ * collation element support
+ */
+
+#define COLL_KEY_MAX	15
+
+#if COLL_KEY_MAX < MB_LEN_MAX
+#undef	COLL_KEY_MAX
+#define COLL_KEY_MAX	MB_LEN_MAX
+#endif
+
+typedef unsigned char Ckey_t[COLL_KEY_MAX+1];
+
+#define COLL_end	0
+#define COLL_call	1
+#define COLL_char	2
+#define COLL_range	3
+#define COLL_range_lc	4
+#define COLL_range_uc	5
+
+typedef struct Celt_s
+{
+	short		typ;
+	short		min;
+	short		max;
+	regclass_t	fun;
+	Ckey_t		beg;
+	Ckey_t		end;
+} Celt_t;
+
+/*
+ * private stuff hanging off regex_t
+ */
+
+typedef struct Stk_pos_s
+{
+	off_t		offset;
+	char*		base;
+} Stk_pos_t;
+
+typedef struct Vector_s
+{
+	Stk_t*		stk;		/* stack pointer		*/
+	char*		vec;		/* the data			*/
+	int		inc;		/* growth increment		*/
+	int		siz;		/* element size			*/
+	int		max;		/* max index			*/
+	int		cur;		/* current index -- user domain	*/
+} Vector_t;
+
+/*
+ * Rex_t subtypes
+ */
+
+typedef struct Cond_s
+{
+	unsigned char*	beg;		/* beginning of next match	*/
+	struct Rex_s*	next[2];	/* 0:no 1:yes next pattern	*/
+	struct Rex_s*	cont;		/* right catcher		*/
+	int		yes;		/* yes condition hit		*/
+} Cond_t;
+
+typedef struct Conj_left_s
+{
+	unsigned char*	beg;		/* beginning of left match	*/
+	struct Rex_s*	right;		/* right pattern		*/
+	struct Rex_s*	cont;		/* right catcher		*/
+} Conj_left_t;
+
+typedef struct Conj_right_s
+{
+	unsigned char*	end;		/* end of left match		*/
+	struct Rex_s*	cont;		/* ambient continuation		*/
+} Conj_right_t;
+
+typedef unsigned int Bm_mask_t;
+
+typedef struct Bm_s
+{
+	Bm_mask_t**	mask;
+	size_t*		skip;
+	size_t*		fail;
+	size_t		size;
+	ssize_t		back;
+	ssize_t		left;
+	ssize_t		right;
+	size_t		complete;
+} Bm_t;
+
+typedef struct String_s
+{
+	int*		fail;
+	unsigned char*	base;
+	size_t		size;
+} String_t;
+
+typedef struct Set_s
+{
+	unsigned char	bits[(UCHAR_MAX+1)/CHAR_BIT];
+} Set_t;
+
+typedef struct Collate_s
+{
+	int		invert;
+	Celt_t*		elements;
+} Collate_t;
+
+typedef struct Binary_s
+{
+	struct Rex_s*	left;
+	struct Rex_s*	right;
+	int		serial;
+} Binary_t;
+
+typedef struct Group_s
+{
+	int		number;		/* group number			*/
+	int		last;		/* last contained group number	*/
+	int		size;		/* lookbehind size		*/
+	int		back;		/* backreferenced		*/
+	regflags_t	flags;		/* group flags			*/
+	union
+	{
+	Binary_t	binary;
+	struct Rex_s*	rex;
+	}		expr;
+} Group_t;
+
+typedef struct Exec_s
+{
+	void*		data;
+	const char*	text;
+	size_t		size;
+} Exec_t;
+
+#define REX_NEST_open		0x01
+#define REX_NEST_close		0x02
+#define REX_NEST_escape		0x04
+#define REX_NEST_quote		0x08
+#define REX_NEST_literal	0x10
+#define REX_NEST_delimiter	0x20
+#define REX_NEST_terminator	0x40
+#define REX_NEST_separator	0x80
+
+#define REX_NEST_SHIFT		8
+
+typedef struct Nest_s
+{
+	int		primary;
+	unsigned short	none;		/* for Nest_t.type[-1] */
+	unsigned short	type[1];
+} Nest_t;
+
+/*
+ * REX_ALT catcher, solely to get control at the end of an
+ * alternative to keep records for comparing matches.
+ */
+
+typedef struct Alt_catch_s
+{
+	struct Rex_s*	cont;
+} Alt_catch_t;
+
+typedef struct Group_catch_s
+{
+	struct Rex_s*	cont;
+	regoff_t*	eo;
+} Group_catch_t;
+
+typedef struct Behind_catch_s
+{
+	struct Rex_s*	cont;
+	unsigned char*	beg;
+	unsigned char*	end;
+} Behind_catch_t;
+
+/*
+ * REX_NEG catcher determines what string lengths can be matched,
+ * then Neg investigates continuations of other lengths.
+ * This is inefficient.  For !POSITIONS expressions, we can do better:
+ * since matches to rex will be enumerated in decreasing order,
+ * we can investigate continuations whenever a length is skipped.
+ */
+
+typedef struct Neg_catch_s
+{
+	unsigned char*	beg;
+	unsigned char*	index;
+} Neg_catch_t;
+
+/*
+ * REX_REP catcher.  One is created on the stack for
+ * each iteration of a complex repetition.
+ */
+
+typedef struct Rep_catch_s
+{
+	struct Rex_s*	cont;
+	struct Rex_s*	ref;
+	unsigned char*	beg;
+	int		n;
+} Rep_catch_t;
+
+/*
+ * data structure for an alternation of pure strings
+ * son points to a subtree of all strings with a common
+ * prefix ending in character c.  sib links alternate
+ * letters in the same position of a word.  end=1 if
+ * some word ends with c.  the order of strings is
+ * irrelevant, except long words must be investigated
+ * before short ones.
+ */
+
+typedef struct Trie_node_s
+{
+	unsigned char		c;
+	unsigned char		end;
+	struct Trie_node_s*	son;
+	struct Trie_node_s*	sib;
+} Trie_node_t;
+
+typedef struct Trie_s
+{
+	Trie_node_t**	root;
+	int		min;
+	int		max;
+} Trie_t;
+
+/*
+ * Rex_t is a node in a regular expression
+ */
+
+typedef struct Rex_s
+{
+	unsigned char	type;			/* node type		*/
+	unsigned char	marked;			/* already marked	*/
+	short		serial;			/* subpattern number	*/
+	regflags_t	flags;			/* scoped flags		*/
+	int		explicit;		/* scoped explicit match*/
+	struct Rex_s*	next;			/* remaining parts	*/
+	int		lo;			/* lo dup count		*/
+	int		hi;			/* hi dup count		*/
+	unsigned char*	map;			/* fold and/or ccode map*/
+	union
+	{
+	Alt_catch_t	alt_catch;		/* alt catcher		*/
+	Bm_t		bm;			/* bm			*/
+	Behind_catch_t	behind_catch;		/* behind catcher	*/
+	Set_t*		charclass;		/* char class		*/
+	Collate_t	collate;		/* collation class	*/
+	Cond_t		cond_catch;		/* cond catcher		*/
+	Conj_left_t	conj_left;		/* conj left catcher	*/
+	Conj_right_t	conj_right;		/* conj right catcher	*/
+	void*		data;			/* data after Rex_t	*/
+	Exec_t		exec;			/* re.re_exec() args	*/
+	Group_t		group;			/* a|b or rep		*/
+	Group_catch_t	group_catch;		/* group catcher	*/
+	Neg_catch_t	neg_catch;		/* neg catcher		*/
+	Nest_t		nest;			/* nested match		*/
+	unsigned char	onechar;		/* single char		*/
+	Rep_catch_t	rep_catch;		/* rep catcher		*/
+	String_t	string;			/* string/kmp		*/
+	Trie_t		trie;			/* trie			*/
+	}		re;
+} Rex_t;
+
+typedef struct reglib_s			/* library private regex_t info	*/
+{
+	struct Rex_s*	rex;		/* compiled expression		*/
+	regdisc_t*	disc;		/* REG_DISCIPLINE discipline	*/
+	const regex_t*	regex;		/* from regexec			*/
+	unsigned char*	beg;		/* beginning of string		*/
+	unsigned char*	end;		/* end of string		*/
+	Vector_t*	pos;		/* posns of certain subpatterns	*/
+	Vector_t*	bestpos;	/* ditto for best match		*/
+	regmatch_t*	match;		/* subexrs in current match 	*/
+	regmatch_t*	best;		/* ditto in best match yet	*/
+	Stk_pos_t	stk;		/* exec stack pos		*/
+	size_t		min;		/* minimum match length		*/
+	size_t		nsub;		/* internal re_nsub		*/
+	regflags_t	flags;		/* flags from regcomp()		*/
+	int		error;		/* last error			*/
+	int		explicit;	/* explicit match on this char	*/
+	int		leading;	/* leading match on this char	*/
+	int		refs;		/* regcomp()+regdup() references*/
+	Rex_t		done;		/* the last continuation	*/
+	regstat_t	stats;		/* for regstat()		*/
+	unsigned char	fold[UCHAR_MAX+1]; /* REG_ICASE map		*/
+	unsigned char	hard;		/* hard comp			*/
+	unsigned char	once;		/* if 1st parse fails, quit	*/
+	unsigned char	separate;	/* cannot combine		*/
+	unsigned char	stack;		/* hard comp or exec		*/
+	unsigned char	sub;		/* re_sub is valid		*/
+	unsigned char	test;		/* debug/test bitmask		*/
+} Env_t;
+
+typedef struct State_s				/* shared state		*/
+{
+	regmatch_t	nomatch;
+	struct
+	{
+	unsigned char	key;
+	short		val[15];
+	}		escape[52];
+	short*		magic[UCHAR_MAX+1];
+	regdisc_t	disc;
+	int		fatal;
+	int		initialized;
+	Dt_t*		attrs;
+	Dt_t*		names;
+	Dtdisc_t	dtdisc;
+} State_t;
+
+extern State_t		state;
+
+extern void*		alloc(regdisc_t*, void*, size_t);
+extern regclass_t	classfun(int);
+extern void		drop(regdisc_t*, Rex_t*);
+extern int		fatal(regdisc_t*, int, const char*);
+
+#endif
diff --git a/usr/src/lib/libast/common/regex/regnexec.c b/usr/src/lib/libast/common/regex/regnexec.c
new file mode 100644
index 0000000000..3406e33a0a
--- /dev/null
+++ b/usr/src/lib/libast/common/regex/regnexec.c
@@ -0,0 +1,2047 @@
+/***********************************************************************
+*                                                                      *
+*               This software is part of the ast package               *
+*           Copyright (c) 1985-2007 AT&T Knowledge Ventures            *
+*                      and is licensed under the                       *
+*                  Common Public License, Version 1.0                  *
+*                      by AT&T Knowledge Ventures                      *
+*                                                                      *
+*                A copy of the License is available at                 *
+*            http://www.opensource.org/licenses/cpl1.0.txt             *
+*         (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9)         *
+*                                                                      *
+*              Information and Software Systems Research               *
+*                            AT&T Research                             *
+*                           Florham Park NJ                            *
+*                                                                      *
+*                 Glenn Fowler <gsf@research.att.com>                  *
+*                  David Korn <dgk@research.att.com>                   *
+*                   Phong Vo <kpv@research.att.com>                    *
+*                                                                      *
+***********************************************************************/
+#pragma prototyped
+
+/*
+ * posix regex executor
+ * single sized-record interface
+ */
+
+#include "reglib.h"
+
+#if _AST_REGEX_DEBUG
+
+#define DEBUG_TEST(f,y,n)	((debug&(debug_flag=f))?(y):(n))
+#define DEBUG_CODE(f,y,n)	do if(debug&(f)){y}else{n} while(0)
+#define DEBUG_INIT()		do { char* t; if (!debug) { debug = 0x80000000; if (t = getenv("_AST_regex_exec_debug")) debug |= strtoul(t, NiL, 0); } } while (0)
+
+static unsigned long	debug;
+static unsigned long	debug_flag;
+
+static const char*	rexnames[] =
+{
+	"REX_NULL",
+	"REX_ALT",
+	"REX_ALT_CATCH",
+	"REX_BACK",
+	"REX_BEG",
+	"REX_BEG_STR",
+	"REX_BM",
+	"REX_CAT",
+	"REX_CLASS",
+	"REX_COLL_CLASS",
+	"REX_CONJ",
+	"REX_CONJ_LEFT",
+	"REX_CONJ_RIGHT",
+	"REX_DONE",
+	"REX_DOT",
+	"REX_END",
+	"REX_END_STR",
+	"REX_EXEC",
+	"REX_FIN_STR",
+	"REX_GROUP",
+	"REX_GROUP_CATCH",
+	"REX_GROUP_AHEAD",
+	"REX_GROUP_AHEAD_CATCH",
+	"REX_GROUP_AHEAD_NOT",
+	"REX_GROUP_BEHIND",
+	"REX_GROUP_BEHIND_CATCH",
+	"REX_GROUP_BEHIND_NOT",
+	"REX_GROUP_BEHIND_NOT_CATCH",
+	"REX_GROUP_COND",
+	"REX_GROUP_COND_CATCH",
+	"REX_GROUP_CUT",
+	"REX_GROUP_CUT_CATCH",
+	"REX_KMP",
+	"REX_NEG",
+	"REX_NEG_CATCH",
+	"REX_NEST",
+	"REX_ONECHAR",
+	"REX_REP",
+	"REX_REP_CATCH",
+	"REX_STRING",
+	"REX_TRIE",
+	"REX_WBEG",
+	"REX_WEND",
+	"REX_WORD",
+	"REX_WORD_NOT"
+};
+
+static const char* rexname(Rex_t* rex)
+{
+	if (!rex)
+		return "NIL";
+	if (rex->type >= elementsof(rexnames))
+		return "ERROR";
+	return rexnames[rex->type];
+}
+
+#else
+
+#define DEBUG_INIT()
+#define DEBUG_TEST(f,y,n)	(n)
+#define DEBUG_CODE(f,y,n)	do {n} while(0)
+
+#endif
+
+#define BEG_ALT		1	/* beginning of an alt			*/
+#define BEG_ONE		2	/* beginning of one iteration of a rep	*/
+#define BEG_REP		3	/* beginning of a repetition		*/
+#define BEG_SUB		4	/* beginning of a subexpression		*/
+#define END_ANY		5	/* end of any of above			*/
+
+/*
+ * returns from parse()
+ */
+
+#define NONE		0	/* no parse found			*/
+#define GOOD		1	/* some parse was found			*/
+#define CUT		2	/* no match and no backtrack		*/
+#define BEST		3	/* an unbeatable parse was found	*/
+#define BAD		4	/* error ocurred			*/
+
+/*
+ * REG_SHELL_DOT test
+ */
+
+#define LEADING(e,r,s)	(*(s)==(e)->leading&&((s)==(e)->beg||*((s)-1)==(r)->explicit))
+
+/*
+ * Pos_t is for comparing parses. An entry is made in the
+ * array at the beginning and at the end of each Group_t,
+ * each iteration in a Group_t, and each Binary_t.
+ */
+
+typedef struct
+{
+	unsigned char*	p;		/* where in string		*/
+	size_t		length;		/* length in string		*/
+	short		serial;		/* preorder subpattern number	*/
+	short		be;		/* which end of pair		*/
+} Pos_t;
+
+/* ===== begin library support ===== */
+
+#define vector(t,v,i)	(((i)<(v)->max)?(t*)((v)->vec+(i)*(v)->siz):(t*)vecseek(&(v),i))
+
+static Vector_t*
+vecopen(int inc, int siz)
+{
+	Vector_t*	v;
+	Stk_t*		sp;
+
+	if (inc <= 0)
+		inc = 16;
+	if (!(sp = stkopen(STK_SMALL|STK_NULL)))
+		return 0;
+	if (!(v = (Vector_t*)stkseek(sp, sizeof(Vector_t) + inc * siz)))
+	{
+		stkclose(sp);
+		return 0;
+	}
+	v->stk = sp;
+	v->vec = (char*)v + sizeof(Vector_t);
+	v->max = v->inc = inc;
+	v->siz = siz;
+	v->cur = 0;
+	return v;
+}
+
+static void*
+vecseek(Vector_t** p, int index)
+{
+	Vector_t*	v = *p;
+
+	if (index >= v->max)
+	{
+		while ((v->max += v->inc) <= index);
+		if (!(v = (Vector_t*)stkseek(v->stk, sizeof(Vector_t) + v->max * v->siz)))
+			return 0;
+		*p = v;
+		v->vec = (char*)v + sizeof(Vector_t);
+	}
+	return v->vec + index * v->siz;
+}
+
+static void
+vecclose(Vector_t* v)
+{
+	if (v)
+		stkclose(v->stk);
+}
+
+typedef struct
+{
+	Stk_pos_t	pos;
+	char		data[1];
+} Stk_frame_t;
+
+#define stknew(s,p)	((p)->offset=stktell(s),(p)->base=stkfreeze(s,0))
+#define stkold(s,p)	stkset(s,(p)->base,(p)->offset)
+
+#define stkframe(s)	(*((Stk_frame_t**)stktop(s)-1))
+#define stkdata(s,t)	((t*)stkframe(s)->data)
+#define stkpop(s)	stkold(s,&(stkframe(s)->pos))
+
+static void*
+stkpush(Stk_t* sp, size_t size)
+{
+	Stk_frame_t*	f;
+	Stk_pos_t	p;
+
+	stknew(sp, &p);
+	size = sizeof(Stk_frame_t) + sizeof(size_t) + size - 1;
+	if (!(f = (Stk_frame_t*)stkalloc(sp, sizeof(Stk_frame_t) + sizeof(Stk_frame_t*) + size - 1)))
+		return 0;
+	f->pos = p;
+	stkframe(sp) = f;
+	return f->data;
+}
+
+/* ===== end library support ===== */
+
+/*
+ * Match_frame_t is for saving and restoring match records
+ * around alternate attempts, so that fossils will not be
+ * left in the match array.  These are the only entries in
+ * the match array that are not otherwise guaranteed to
+ * have current data in them when they get used.
+ */
+
+typedef struct
+{
+	size_t			size;
+	regmatch_t*		match;
+	regmatch_t		save[1];
+} Match_frame_t;
+
+#define matchframe	stkdata(stkstd,Match_frame_t)
+#define matchpush(e,x)	((x)->re.group.number?_matchpush(e,x):0)
+#define matchcopy(e,x)	((x)->re.group.number?memcpy(matchframe->match,matchframe->save,matchframe->size):(void*)0)
+#define matchpop(e,x)	((x)->re.group.number?memcpy(matchframe->match,matchframe->save,matchframe->size),stkpop(stkstd):(void*)0)
+
+#define pospop(e)	(--(e)->pos->cur)
+
+/*
+ * allocate a frame and push a match onto the stack
+ */
+
+static int
+_matchpush(Env_t* env, Rex_t* rex)
+{
+	Match_frame_t*	f;
+	regmatch_t*	m;
+	regmatch_t*	e;
+	regmatch_t*	s;
+	int		num;
+
+	if (rex->re.group.number <= 0 || (num = rex->re.group.last - rex->re.group.number + 1) <= 0)
+		num = 0;
+	if (!(f = (Match_frame_t*)stkpush(stkstd, sizeof(Match_frame_t) + (num - 1) * sizeof(regmatch_t))))
+	{
+		env->error = REG_ESPACE;
+		return 1;
+	}
+	f->size = num * sizeof(regmatch_t);
+	f->match = m = env->match + rex->re.group.number;
+	e = m + num;
+	s = f->save;
+	while (m < e)
+	{
+		*s++ = *m;
+		*m++ = state.nomatch;
+	}
+	return 0;
+}
+
+/*
+ * allocate a frame and push a pos onto the stack
+ */
+
+static int
+pospush(Env_t* env, Rex_t* rex, unsigned char* p, int be)
+{
+	Pos_t*	pos;
+
+	if (!(pos = vector(Pos_t, env->pos, env->pos->cur)))
+	{
+		env->error = REG_ESPACE;
+		return 1;
+	}
+	pos->serial = rex->serial;
+	pos->p = p;
+	pos->be = be;
+	env->pos->cur++;
+	return 0;
+}
+
+/*
+ * two matches are known to have the same length
+ * os is start of old pos array, ns is start of new,
+ * oend and nend are end+1 pointers to ends of arrays.
+ * oe and ne are ends (not end+1) of subarrays.
+ * returns 1 if new is better, -1 if old, else 0.
+ */
+
+#if _AST_REGEX_DEBUG
+
+static void
+showmatch(regmatch_t* p)
+{
+	sfputc(sfstdout, '(');
+	if (p->rm_so < 0)
+		sfputc(sfstdout, '?');
+	else
+		sfprintf(sfstdout, "%d", p->rm_so);
+	sfputc(sfstdout, ',');
+	if (p->rm_eo < 0)
+		sfputc(sfstdout, '?');
+	else
+		sfprintf(sfstdout, "%d", p->rm_eo);
+	sfputc(sfstdout, ')');
+}
+
+static int
+better(Env_t* env, Pos_t* os, Pos_t* ns, Pos_t* oend, Pos_t* nend, int level)
+#define better	_better
+{
+	int	i;
+
+	DEBUG_CODE(0x0040,{sfprintf(sfstdout, "AHA better old ");for (i = 0; i <= env->nsub; i++)showmatch(&env->best[i]);sfprintf(sfstdout, "\n           new ");for (i = 0; i <= env->nsub; i++)showmatch(&env->match[i]);sfprintf(sfstdout, "\n");},{0;});
+	i = better(env, os, ns, oend, nend, 0);
+	DEBUG_TEST(0x0040,(sfprintf(sfstdout, "           %s\n", i <= 0 ? "OLD" : "NEW")),(0));
+	return i;
+}
+
+#endif
+
+static int
+better(Env_t* env, Pos_t* os, Pos_t* ns, Pos_t* oend, Pos_t* nend, int level)
+{
+	Pos_t*	oe;
+	Pos_t*	ne;
+	int	k;
+	int	n;
+
+	if (env->error)
+		return -1;
+	for (;;)
+	{
+		DEBUG_CODE(0x0080,{sfprintf(sfstdout, "   %-*.*sold ", (level + 3) * 4, (level + 3) * 4, "");for (oe = os; oe < oend; oe++)sfprintf(sfstdout, "<%d,%d,%d>", oe->p - env->beg, oe->serial, oe->be);sfprintf(sfstdout, "\n   %-*.*snew ", (level + 3) * 4, (level + 3) * 4, "");for (oe = ns; oe < nend; oe++)sfprintf(sfstdout, "<%d,%d,%d>", oe->p - env->beg, oe->serial, oe->be);sfprintf(sfstdout, "\n");},{0;});
+		if (ns >= nend)
+			return DEBUG_TEST(0x8000,(os < oend),(0));
+		if (os >= oend)
+			return DEBUG_TEST(0x8000,(-1),(1));
+		n = os->serial;
+		if (ns->serial > n)
+			return -1;
+		if (n > ns->serial)
+		{
+			env->error = REG_PANIC;
+			return -1;
+		}
+		if (ns->p > os->p)
+			return 1;
+		if (os->p > ns->p)
+			return -1;
+		oe = os;
+		k = 0;
+		for (;;)
+			if ((++oe)->serial == n)
+			{
+				if (oe->be != END_ANY)
+					k++;
+				else if (k-- <= 0)
+					break;
+			}
+		ne = ns;
+		k = 0;
+		for (;;)
+			if ((++ne)->serial == n)
+			{
+				if (ne->be != END_ANY)
+					k++;
+				else if (k-- <= 0)
+					break;
+			}
+		if (ne->p > oe->p)
+			return 1;
+		if (oe->p > ne->p)
+			return -1;
+		if (k = better(env, os + 1, ns + 1, oe, ne, level + 1))
+			return k;
+		os = oe + 1;
+		ns = ne + 1;
+	}
+}
+
+#undef	better
+
+#define follow(e,r,c,s)	((r)->next?parse(e,(r)->next,c,s):(c)?parse(e,c,0,s):BEST)
+
+static int		parse(Env_t*, Rex_t*, Rex_t*, unsigned char*);
+
+static int
+parserep(Env_t* env, Rex_t* rex, Rex_t* cont, unsigned char* s, int n)
+{
+	int	i;
+	int	r = NONE;
+	Rex_t	catcher;
+
+	DEBUG_TEST(0x0010,(sfprintf(sfstdout, "AHA#%04d 0x%04x parserep %s %d %d %d `%-.*s'\n", __LINE__, debug_flag, rexname(rex->re.group.expr.rex), rex->lo, n, rex->hi, env->end - s, s)),(0));
+	if ((rex->flags & REG_MINIMAL) && n >= rex->lo && n < rex->hi)
+	{
+		if (env->stack && pospush(env, rex, s, END_ANY))
+			return BAD;
+		i = follow(env, rex, cont, s);
+		if (env->stack)
+			pospop(env);
+		switch (i)
+		{
+		case BAD:
+			return BAD;
+		case CUT:
+			return CUT;
+		case BEST:
+		case GOOD:
+			return BEST;
+		}
+	}
+	if (n < rex->hi)
+	{
+		catcher.type = REX_REP_CATCH;
+		catcher.serial = rex->serial;
+		catcher.re.rep_catch.ref = rex;
+		catcher.re.rep_catch.cont = cont;
+		catcher.re.rep_catch.beg = s;
+		catcher.re.rep_catch.n = n + 1;
+		catcher.next = rex->next;
+		if (n == 0)
+			rex->re.rep_catch.beg = s;
+		if (env->stack)
+		{
+DEBUG_TEST(0x0004,(sfprintf(sfstdout,"AHA#%04d 0x%04x PUSH (%d,%d)(%d,%d) (%d,%d)(%d,%d)\n", __LINE__, debug_flag, rex->re.group.number, env->best[0].rm_so, env->best[0].rm_eo, env->best[1].rm_so, env->best[1].rm_eo, env->match[0].rm_so, env->match[0].rm_eo, env->match[1].rm_so, env->match[1].rm_eo)),(0));
+			if (matchpush(env, rex))
+				return BAD;
+			if (pospush(env, rex, s, BEG_ONE))	
+				return BAD;
+DEBUG_TEST(0x0004,(sfprintf(sfstdout,"AHA#%04d 0x%04x PUSH (%d,%d)(%d,%d) (%d,%d)(%d,%d)\n", __LINE__, debug_flag, rex->re.group.number, env->best[0].rm_so, env->best[0].rm_eo, env->best[1].rm_so, env->best[1].rm_eo, env->match[0].rm_so, env->match[0].rm_eo, env->match[1].rm_so, env->match[1].rm_eo)),(0));
+		}
+		r = parse(env, rex->re.group.expr.rex, &catcher, s);
+		DEBUG_TEST(0x0010,(sfprintf(sfstdout, "AHA#%04d 0x%04x parserep parse %d `%-.*s'\n", __LINE__, debug_flag, r, env->end - s, s)),(0));
+		if (env->stack)
+		{
+DEBUG_TEST(0x0004,(sfprintf(sfstdout,"AHA#%04d 0x%04x POP (%d,%d)(%d,%d) (%d,%d)(%d,%d)\n", __LINE__, debug_flag, rex->re.group.number, env->best[0].rm_so, env->best[0].rm_eo, env->best[1].rm_so, env->best[1].rm_eo, env->match[0].rm_so, env->match[0].rm_eo, env->match[1].rm_so, env->match[1].rm_eo)),(0));
+			pospop(env);
+			matchpop(env, rex);
+DEBUG_TEST(0x0004,(sfprintf(sfstdout,"AHA#%04d 0x%04x POP (%d,%d)(%d,%d) (%d,%d)(%d,%d)\n", __LINE__, debug_flag, rex->re.group.number, env->best[0].rm_so, env->best[0].rm_eo, env->best[1].rm_so, env->best[1].rm_eo, env->match[0].rm_so, env->match[0].rm_eo, env->match[1].rm_so, env->match[1].rm_eo)),(0));
+		}
+		switch (r)
+		{
+		case BAD:
+			return BAD;
+		case BEST:
+			return BEST;
+		case CUT:
+			r = NONE;
+			break;
+		case GOOD:
+			if (rex->flags & REG_MINIMAL)
+				return BEST;
+			r = GOOD;
+			break;
+		}
+	}
+	if (n < rex->lo)
+		return r;
+	if (!(rex->flags & REG_MINIMAL) || n >= rex->hi)
+	{
+		if (env->stack && pospush(env, rex, s, END_ANY))
+			return BAD;
+		i = follow(env, rex, cont, s);
+		if (env->stack)
+			pospop(env);
+		switch (i)
+		{
+		case BAD:
+			r = BAD;
+			break;
+		case CUT:
+			r = CUT;
+			break;
+		case BEST:
+			r = BEST;
+			break;
+		case GOOD:
+			r = (rex->flags & REG_MINIMAL) ? BEST : GOOD;
+			break;
+		}
+	}
+	return r;
+}
+
+static int
+parsetrie(Env_t* env, Trie_node_t* x, Rex_t* rex, Rex_t* cont, unsigned char* s)
+{
+	unsigned char*	p;
+	int		r;
+
+	if (p = rex->map)
+	{
+		for (;;)
+		{
+			if (s >= env->end)
+				return NONE;
+			while (x->c != p[*s])
+				if (!(x = x->sib))
+					return NONE;
+			if (x->end)
+				break;
+			x = x->son;
+			s++;
+		}
+	}
+	else
+	{
+		for (;;)
+		{
+			if (s >= env->end)
+				return NONE;
+			while (x->c != *s)
+				if (!(x = x->sib))
+					return NONE;
+			if (x->end)
+				break;
+			x = x->son;
+			s++;
+		}
+	}
+	s++;
+	if (rex->flags & REG_MINIMAL)
+		switch (follow(env, rex, cont, s))
+		{
+		case BAD:
+			return BAD;
+		case CUT:
+			return CUT;
+		case BEST:
+		case GOOD:
+			return BEST;
+		}
+	if (x->son)
+		switch (parsetrie(env, x->son, rex, cont, s))
+		{
+		case BAD:
+			return BAD;
+		case CUT:
+			return CUT;
+		case BEST:
+			return BEST;
+		case GOOD:
+			if (rex->flags & REG_MINIMAL)
+				return BEST;
+			r = GOOD;
+			break;
+		default:
+			r = NONE;
+			break;
+		}
+	else
+		r = NONE;
+	if (!(rex->flags & REG_MINIMAL))
+		switch (follow(env, rex, cont, s))
+		{
+		case BAD:
+			return BAD;
+		case CUT:
+			return CUT;
+		case BEST:
+			return BEST;
+		case GOOD:
+			return GOOD;
+	}
+	return r;
+}
+
+static int
+collelt(register Celt_t* ce, char* key, int c, int x)
+{
+	Ckey_t	elt;
+
+	mbxfrm(elt, key, COLL_KEY_MAX);
+	for (;; ce++)
+	{
+		switch (ce->typ)
+		{
+		case COLL_call:
+			if (!x && (*ce->fun)(c))
+				return 1;
+			continue;
+		case COLL_char:
+			if (!strcmp((char*)ce->beg, (char*)elt))
+				return 1;
+			continue;
+		case COLL_range:
+			if (strcmp((char*)ce->beg, (char*)elt) <= ce->min && strcmp((char*)elt, (char*)ce->end) <= ce->max)
+				return 1;
+			continue;
+		case COLL_range_lc:
+			if (strcmp((char*)ce->beg, (char*)elt) <= ce->min && strcmp((char*)elt, (char*)ce->end) <= ce->max && (iswlower(c) || !iswupper(c)))
+				return 1;
+			continue;
+		case COLL_range_uc:
+			if (strcmp((char*)ce->beg, (char*)elt) <= ce->min && strcmp((char*)elt, (char*)ce->end) <= ce->max && (iswupper(c) || !iswlower(c)))
+				return 1;
+			continue;
+		}
+		break;
+	}
+	return 0;
+}
+
+static int
+collic(register Celt_t* ce, char* key, register char* nxt, int c, int x)
+{
+	if (!x)
+	{
+		if (collelt(ce, key, c, x))
+			return 1;
+		if (iswlower(c))
+			c = towupper(c);
+		else if (iswupper(c))
+			c = towlower(c);
+		else
+			return 0;
+		x = wctomb(key, c);
+		key[x] = 0;
+		return collelt(ce, key, c, 0);
+	}
+	while (*nxt)
+	{
+		if (collic(ce, key, nxt + 1, c, x))
+			return 1;
+		if (islower(*nxt))
+			*nxt = toupper(*nxt);
+		else if (isupper(*nxt))
+			*nxt = tolower(*nxt);
+		else
+			return 0;
+		nxt++;
+	}
+	return collelt(ce, key, c, x);
+}
+
+static int
+collmatch(Rex_t* rex, unsigned char* s, unsigned char* e, unsigned char** p)
+{
+	unsigned char*		t;
+	wchar_t			c;
+	int			w;
+	int			r;
+	int			x;
+	int			ic;
+	Ckey_t			key;
+	Ckey_t			elt;
+
+	ic = (rex->flags & REG_ICASE);
+	if ((w = MBSIZE(s)) > 1)
+	{
+		memcpy((char*)key, (char*)s, w);
+		key[w] = 0;
+		t = s;
+		c = mbchar(t);
+#if !_lib_wctype
+		c &= 0xff;
+#endif
+		x = 0;
+	}
+	else
+	{
+		c = s[0];
+		if (ic && isupper(c))
+			c = tolower(c);
+		key[0] = c;
+		key[1] = 0;
+		if (isalpha(c))
+		{
+			x = e - s;
+			if (x > COLL_KEY_MAX)
+				x = COLL_KEY_MAX;
+			while (w < x)
+			{
+				c = s[w];
+				if (!isalpha(c))
+					break;
+				r = mbxfrm(elt, key, COLL_KEY_MAX);
+				if (ic && isupper(c))
+					c = tolower(c);
+				key[w] = c;
+				key[w + 1] = 0;
+				if (mbxfrm(elt, key, COLL_KEY_MAX) != r)
+					break;
+				w++;
+			}
+		}
+		key[w] = 0;
+		c = key[0];
+		x = w - 1;
+	}
+	r = 1;
+	for (;;)
+	{
+		if (ic ? collic(rex->re.collate.elements, (char*)key, (char*)key, c, x) : collelt(rex->re.collate.elements, (char*)key, c, x))
+			break;
+		if (!x)
+		{
+			r = 0;
+			break;
+		}
+		w = x--;
+		key[w] = 0;
+	}
+	*p = s + w;
+	return rex->re.collate.invert ? !r : r;
+}
+
+static unsigned char*
+nestmatch(register unsigned char* s, register unsigned char* e, const unsigned short* type, register int co)
+{
+	register int	c;
+	register int	cc;
+	unsigned int	n;
+	int		oc;
+
+	if (type[co] & (REX_NEST_literal|REX_NEST_quote))
+	{
+		n = (type[co] & REX_NEST_literal) ? REX_NEST_terminator : (REX_NEST_escape|REX_NEST_terminator);
+		while (s < e)
+		{
+			c = *s++;
+			if (c == co)
+				return s;
+			else if (type[c] & n)
+			{
+				if (s >= e || (type[c] & REX_NEST_terminator))
+					break;
+				s++;
+			}
+		}
+	}
+	else
+	{
+		cc = type[co] >> REX_NEST_SHIFT;
+		oc = type[co] & (REX_NEST_open|REX_NEST_close);
+		n = 1;
+		while (s < e)
+		{
+			c = *s++;
+			switch (type[c] & (REX_NEST_escape|REX_NEST_open|REX_NEST_close|REX_NEST_delimiter|REX_NEST_separator|REX_NEST_terminator))
+			{
+			case REX_NEST_delimiter:
+			case REX_NEST_terminator:
+				return oc ? 0 : s;
+			case REX_NEST_separator:
+				if (!oc)
+					return s;
+				break;
+			case REX_NEST_escape:
+				if (s >= e)
+					return 0;
+				s++;
+				break;
+			case REX_NEST_open|REX_NEST_close:
+				if (c == cc)
+				{
+					if (!--n)
+						return s;
+				}
+				/*FALLTHROUGH*/
+			case REX_NEST_open:
+				if (c == co)
+				{
+					if (!++n)
+						return 0;
+				}
+				else if (!(s = nestmatch(s, e, type, c)))
+					return 0;
+				break;
+			case REX_NEST_close:
+				if (c != cc)
+					return 0;
+				if (!--n)
+					return s;
+				break;
+			}
+		}
+		return (oc || !(type[UCHAR_MAX+1] & REX_NEST_terminator)) ? 0 : s;
+	}
+	return 0;
+}
+
+static int
+parse(Env_t* env, Rex_t* rex, Rex_t* cont, unsigned char* s)
+{
+	int		c;
+	int		d;
+	int		i;
+	int		m;
+	int		n;
+	int		r;
+	int*		f;
+	unsigned char*	p;
+	unsigned char*	t;
+	unsigned char*	b;
+	unsigned char*	e;
+	char*		u;
+	regmatch_t*	o;
+	Trie_node_t*	x;
+	Rex_t*		q;
+	Rex_t		catcher;
+	Rex_t		next;
+
+	for (;;)
+	{
+DEBUG_TEST(0x0008,(sfprintf(sfstdout, "AHA#%04d 0x%04x parse %s `%-.*s'\n", __LINE__, debug_flag, rexname(rex), env->end - s, s)),(0));
+		switch (rex->type)
+		{
+		case REX_ALT:
+			if (env->stack)
+			{
+				if (matchpush(env, rex))
+					return BAD;
+				if (pospush(env, rex, s, BEG_ALT))
+					return BAD;
+				catcher.type = REX_ALT_CATCH;
+				catcher.serial = rex->serial;
+				catcher.re.alt_catch.cont = cont;
+				catcher.next = rex->next;
+				r = parse(env, rex->re.group.expr.binary.left, &catcher, s);
+				if (r < BEST || (rex->flags & REG_MINIMAL))
+				{
+					matchcopy(env, rex);
+					((Pos_t*)env->pos->vec + env->pos->cur - 1)->serial = catcher.serial = rex->re.group.expr.binary.serial;
+					n = parse(env, rex->re.group.expr.binary.right, &catcher, s);
+					if (n != NONE)
+						r = n;
+				}
+				pospop(env);
+				matchpop(env, rex);
+			}
+			else
+			{
+				if ((r = parse(env, rex->re.group.expr.binary.left, cont, s)) == NONE)
+					r = parse(env, rex->re.group.expr.binary.right, cont, s);
+				if (r == GOOD)
+					r = BEST;
+			}
+			return r;
+		case REX_ALT_CATCH:
+			if (pospush(env, rex, s, END_ANY))
+				return BAD;
+			r = follow(env, rex, rex->re.alt_catch.cont, s);
+			pospop(env);
+			return r;
+		case REX_BACK:
+			o = &env->match[rex->lo];
+			if (o->rm_so < 0)
+				return NONE;
+			i = o->rm_eo - o->rm_so;
+			e = s + i;
+			if (e > env->end)
+				return NONE;
+			t = env->beg + o->rm_so;
+			if (!(p = rex->map))
+			{
+				while (s < e)
+					if (*s++ != *t++)
+						return NONE;
+			}
+			else if (!mbwide())
+			{
+				while (s < e)
+					if (p[*s++] != p[*t++])
+						return NONE;
+			}
+			else
+			{
+				while (s < e)
+				{
+					c = mbchar(s);
+					d = mbchar(t);
+					if (towupper(c) != towupper(d))
+						return NONE;
+				}
+			}
+			break;
+		case REX_BEG:
+			if ((!(rex->flags & REG_NEWLINE) || s <= env->beg || *(s - 1) != '\n') && ((env->flags & REG_NOTBOL) || s != env->beg))
+				return NONE;
+			break;
+		case REX_CLASS:
+			if (LEADING(env, rex, s))
+				return NONE;
+			n = rex->hi;
+			if (n > env->end - s)
+				n = env->end - s;
+			m = rex->lo;
+			if (m > n)
+				return NONE;
+			r = NONE;
+			if (!(rex->flags & REG_MINIMAL))
+			{
+				for (i = 0; i < n; i++)
+					if (!settst(rex->re.charclass, s[i]))
+					{
+						n = i;
+						break;
+					}
+				for (s += n; n-- >= m; s--)
+					switch (follow(env, rex, cont, s))
+					{
+					case BAD:
+						return BAD;
+					case CUT:
+						return CUT;
+					case BEST:
+						return BEST;
+					case GOOD:
+						r = GOOD;
+						break;
+					}
+			}
+			else
+			{
+				for (e = s + m; s < e; s++)
+					if (!settst(rex->re.charclass, *s))
+						return r;
+				e += n - m;
+				for (;;)
+				{
+					switch (follow(env, rex, cont, s))
+					{
+					case BAD:
+						return BAD;
+					case CUT:
+						return CUT;
+					case BEST:
+					case GOOD:
+						return BEST;
+					}
+					if (s >= e || !settst(rex->re.charclass, *s))
+						break;
+					s++;
+				}
+			}
+			return r;
+		case REX_COLL_CLASS:
+			if (LEADING(env, rex, s))
+				return NONE;
+			n = rex->hi;
+			if (n > env->end - s)
+				n = env->end - s;
+			m = rex->lo;
+			if (m > n)
+				return NONE;
+			r = NONE;
+			e = env->end;
+			if (!(rex->flags & REG_MINIMAL))
+			{
+				if (!(b = (unsigned char*)stkpush(stkstd, n)))
+				{
+					env->error = REG_ESPACE;
+					return BAD;
+				}
+				for (i = 0; s < e && i < n && collmatch(rex, s, e, &t); i++)
+				{
+					b[i] = t - s;
+					s = t;
+				}
+				for (; i-- >= rex->lo; s -= b[i])
+					switch (follow(env, rex, cont, s))
+					{
+					case BAD:
+						stkpop(stkstd);
+						return BAD;
+					case CUT:
+						stkpop(stkstd);
+						return CUT;
+					case BEST:
+						stkpop(stkstd);
+						return BEST;
+					case GOOD:
+						r = GOOD;
+						break;
+					}
+				stkpop(stkstd);
+			}
+			else
+			{
+				for (i = 0; i < m && s < e; i++, s = t)
+					if (!collmatch(rex, s, e, &t))
+						return r;
+				while (i++ <= n)
+				{
+					switch (follow(env, rex, cont, s))
+					{
+					case BAD:
+						return BAD;
+					case CUT:
+						return CUT;
+					case BEST:
+					case GOOD:
+						return BEST;
+					}
+					if (s >= e || !collmatch(rex, s, e, &s))
+						break;
+				}
+			}
+			return r;
+		case REX_CONJ:
+			next.type = REX_CONJ_RIGHT;
+			next.re.conj_right.cont = cont;
+			next.next = rex->next;
+			catcher.type = REX_CONJ_LEFT;
+			catcher.re.conj_left.right = rex->re.group.expr.binary.right;
+			catcher.re.conj_left.cont = &next;
+			catcher.re.conj_left.beg = s;
+			catcher.next = 0;
+			return parse(env, rex->re.group.expr.binary.left, &catcher, s);
+		case REX_CONJ_LEFT:
+			rex->re.conj_left.cont->re.conj_right.end = s;
+			cont = rex->re.conj_left.cont;
+			s = rex->re.conj_left.beg;
+			rex = rex->re.conj_left.right;
+			continue;
+		case REX_CONJ_RIGHT:
+			if (rex->re.conj_right.end != s)
+				return NONE;
+			cont = rex->re.conj_right.cont;
+			break;
+		case REX_DONE:
+			if (!env->stack)
+				return BEST;
+			n = s - env->beg;
+			r = env->nsub;
+			DEBUG_TEST(0x0100,(sfprintf(sfstdout,"AHA#%04d 0x%04x %s (%d,%d)(%d,%d)(%d,%d)(%d,%d) (%d,%d)(%d,%d)\n", __LINE__, debug_flag, rexname(rex), env->best[0].rm_so, env->best[0].rm_eo, env->best[1].rm_so, env->best[1].rm_eo, env->best[2].rm_so, env->best[2].rm_eo, env->best[3].rm_so, env->best[3].rm_eo, env->match[0].rm_so, env->match[0].rm_eo, env->match[1].rm_so, env->match[1].rm_eo)),(0));
+			if ((i = env->best[0].rm_eo) >= 0)
+			{
+				if (rex->flags & REG_MINIMAL)
+				{
+					if (n > i)
+						return GOOD;
+				}
+				else
+				{
+					if (n < i)
+						return GOOD;
+				}
+				if (n == i && better(env,
+						     (Pos_t*)env->bestpos->vec,
+				   		     (Pos_t*)env->pos->vec,
+				   		     (Pos_t*)env->bestpos->vec+env->bestpos->cur,
+				   		     (Pos_t*)env->pos->vec+env->pos->cur,
+						     0) <= 0)
+					return GOOD;
+			}
+			env->best[0].rm_eo = n;
+			memcpy(&env->best[1], &env->match[1], r * sizeof(regmatch_t));
+			n = env->pos->cur;
+			if (!vector(Pos_t, env->bestpos, n))
+			{
+				env->error = REG_ESPACE;
+				return BAD;
+			}
+			env->bestpos->cur = n;
+			memcpy(env->bestpos->vec, env->pos->vec, n * sizeof(Pos_t));
+			DEBUG_TEST(0x0100,(sfprintf(sfstdout,"AHA#%04d 0x%04x %s (%d,%d)(%d,%d)(%d,%d)(%d,%d) (%d,%d)(%d,%d)\n", __LINE__, debug_flag, rexname(rex), env->best[0].rm_so, env->best[0].rm_eo, env->best[1].rm_so, env->best[1].rm_eo, env->best[2].rm_so, env->best[2].rm_eo, env->best[3].rm_so, env->best[3].rm_eo, env->match[0].rm_so, env->match[0].rm_eo, env->match[1].rm_so, env->match[1].rm_eo)),(0));
+			return GOOD;
+		case REX_DOT:
+			if (LEADING(env, rex, s))
+				return NONE;
+			n = rex->hi;
+			if (n > env->end - s)
+				n = env->end - s;
+			m = rex->lo;
+			if (m > n)
+				return NONE;
+			if ((c = rex->explicit) >= 0 && !mbwide())
+				for (i = 0; i < n; i++)
+					if (s[i] == c)
+					{
+						n = i;
+						break;
+					}
+			r = NONE;
+			if (!(rex->flags & REG_MINIMAL))
+			{
+				if (!mbwide())
+				{
+					for (s += n; n-- >= m; s--)
+						switch (follow(env, rex, cont, s))
+						{
+						case BAD:
+							return BAD;
+						case CUT:
+							return CUT;
+						case BEST:
+							return BEST;
+						case GOOD:
+							r = GOOD;
+							break;
+						}
+				}
+				else
+				{
+					if (!(b = (unsigned char*)stkpush(stkstd, n)))
+					{
+						env->error = REG_ESPACE;
+						return BAD;
+					}
+					e = env->end;
+					for (i = 0; s < e && i < n && *s != c; i++)
+						s += b[i] = MBSIZE(s);
+					for (; i-- >= m; s -= b[i])
+						switch (follow(env, rex, cont, s))
+						{
+						case BAD:
+							stkpop(stkstd);
+							return BAD;
+						case CUT:
+							stkpop(stkstd);
+							return CUT;
+						case BEST:
+							stkpop(stkstd);
+							return BEST;
+						case GOOD:
+							r = GOOD;
+							break;
+						}
+					stkpop(stkstd);
+				}
+			}
+			else
+			{
+				if (!mbwide())
+				{
+					e = s + n;
+					for (s += m; s <= e; s++)
+						switch (follow(env, rex, cont, s))
+						{
+						case BAD:
+							return BAD;
+						case CUT:
+							return CUT;
+						case BEST:
+						case GOOD:
+							return BEST;
+						}
+				}
+				else
+				{
+					e = env->end;
+					for (i = 0; s < e && i < m && *s != c; i++)
+						s += MBSIZE(s);
+					if (i >= m)
+						for (; s <= e && i <= n; s += MBSIZE(s), i++)
+							switch (follow(env, rex, cont, s))
+							{
+							case BAD:
+								return BAD;
+							case CUT:
+								return CUT;
+							case BEST:
+							case GOOD:
+								return BEST;
+							}
+				}
+			}
+			return r;
+		case REX_END:
+			if ((!(rex->flags & REG_NEWLINE) || *s != '\n') && ((env->flags & REG_NOTEOL) || s < env->end))
+				return NONE;
+			break;
+		case REX_GROUP:
+DEBUG_TEST(0x0200,(sfprintf(sfstdout,"AHA#%04d 0x%04x parse %s `%-.*s'\n", __LINE__, debug_flag, rexname(rex), env->end - s, s)),(0));
+			if (env->stack)
+			{
+				if (rex->re.group.number)
+					env->match[rex->re.group.number].rm_so = s - env->beg;
+				if (pospush(env, rex, s, BEG_SUB))
+					return BAD;
+				catcher.re.group_catch.eo = rex->re.group.number ? &env->match[rex->re.group.number].rm_eo : (regoff_t*)0;
+			}
+			catcher.type = REX_GROUP_CATCH;
+			catcher.serial = rex->serial;
+			catcher.re.group_catch.cont = cont;
+			catcher.next = rex->next;
+			r = parse(env, rex->re.group.expr.rex, &catcher, s);
+			if (env->stack)
+			{
+				pospop(env);
+				if (rex->re.group.number)
+					env->match[rex->re.group.number].rm_so = -1;
+			}
+			return r;
+		case REX_GROUP_CATCH:
+DEBUG_TEST(0x0200,(sfprintf(sfstdout,"AHA#%04d 0x%04x parse %s=>%s `%-.*s'\n", __LINE__, debug_flag, rexname(rex), rexname(rex->re.group_catch.cont), env->end - s, s)),(0));
+			if (env->stack)
+			{
+				if (rex->re.group_catch.eo)
+					*rex->re.group_catch.eo = s - env->beg;
+				if (pospush(env, rex, s, END_ANY))
+					return BAD;
+			}
+			r = follow(env, rex, rex->re.group_catch.cont, s);
+			if (env->stack)
+			{
+				pospop(env);
+				if (rex->re.group_catch.eo)
+					*rex->re.group_catch.eo = -1;
+			}
+			return r;
+		case REX_GROUP_AHEAD:
+			catcher.type = REX_GROUP_AHEAD_CATCH;
+			catcher.flags = rex->flags;
+			catcher.serial = rex->serial;
+			catcher.re.rep_catch.beg = s;
+			catcher.re.rep_catch.cont = cont;
+			catcher.next = rex->next;
+			return parse(env, rex->re.group.expr.rex, &catcher, s);
+		case REX_GROUP_AHEAD_CATCH:
+			return follow(env, rex, rex->re.rep_catch.cont, rex->re.rep_catch.beg);
+		case REX_GROUP_AHEAD_NOT:
+			r = parse(env, rex->re.group.expr.rex, NiL, s);
+			if (r == NONE)
+				r = follow(env, rex, cont, s);
+			else if (r != BAD)
+				r = NONE;
+			return r;
+		case REX_GROUP_BEHIND:
+			if ((s - env->beg) < rex->re.group.size)
+				return NONE;
+			catcher.type = REX_GROUP_BEHIND_CATCH;
+			catcher.flags = rex->flags;
+			catcher.serial = rex->serial;
+			catcher.re.behind_catch.beg = s;
+			catcher.re.behind_catch.end = e = env->end;
+			catcher.re.behind_catch.cont = cont;
+			catcher.next = rex->next;
+			for (t = s - rex->re.group.size; t >= env->beg; t--)
+			{
+				env->end = s;
+				r = parse(env, rex->re.group.expr.rex, &catcher, t);
+				env->end = e;
+				if (r != NONE)
+					return r;
+			}
+			return NONE;
+		case REX_GROUP_BEHIND_CATCH:
+			if (s != rex->re.behind_catch.beg)
+				return NONE;
+			env->end = rex->re.behind_catch.end;
+			return follow(env, rex, rex->re.behind_catch.cont, rex->re.behind_catch.beg);
+		case REX_GROUP_BEHIND_NOT:
+			if ((s - env->beg) < rex->re.group.size)
+				r = NONE;
+			else
+			{
+				catcher.type = REX_GROUP_BEHIND_NOT_CATCH;
+				catcher.re.neg_catch.beg = s;
+				catcher.next = 0;
+				e = env->end;
+				env->end = s;
+				for (t = s - rex->re.group.size; t >= env->beg; t--)
+				{
+					r = parse(env, rex->re.group.expr.rex, &catcher, t);
+					if (r != NONE)
+						break;
+				}
+				env->end = e;
+			}
+			if (r == NONE)
+				r = follow(env, rex, cont, s);
+			else if (r != BAD)
+				r = NONE;
+			return r;
+		case REX_GROUP_BEHIND_NOT_CATCH:
+			return s == rex->re.neg_catch.beg ? GOOD : NONE;
+		case REX_GROUP_COND:
+			if (q = rex->re.group.expr.binary.right)
+			{
+				catcher.re.cond_catch.next[0] = q->re.group.expr.binary.right;
+				catcher.re.cond_catch.next[1] = q->re.group.expr.binary.left;
+			}
+			else
+				catcher.re.cond_catch.next[0] = catcher.re.cond_catch.next[1] = 0;
+			if (q = rex->re.group.expr.binary.left)
+			{
+				catcher.type = REX_GROUP_COND_CATCH;
+				catcher.flags = rex->flags;
+				catcher.serial = rex->serial;
+				catcher.re.cond_catch.yes = 0;
+				catcher.re.cond_catch.beg = s;
+				catcher.re.cond_catch.cont = cont;
+				catcher.next = rex->next;
+				r = parse(env, q, &catcher, s);
+				if (r == BAD || catcher.re.cond_catch.yes)
+					return r;
+			}
+			else if (!rex->re.group.size || rex->re.group.size > 0 && env->match[rex->re.group.size].rm_so >= 0)
+				r = GOOD;
+			else
+				r = NONE;
+			if (q = catcher.re.cond_catch.next[r != NONE])
+			{
+				catcher.type = REX_CAT;
+				catcher.flags = q->flags;
+				catcher.serial = q->serial;
+				catcher.re.group_catch.cont = cont;
+				catcher.next = rex->next;
+				return parse(env, q, &catcher, s);
+			}
+			return follow(env, rex, cont, s);
+		case REX_GROUP_COND_CATCH:
+			rex->re.cond_catch.yes = 1;
+			catcher.type = REX_CAT;
+			catcher.flags = rex->flags;
+			catcher.serial = rex->serial;
+			catcher.re.group_catch.cont = rex->re.cond_catch.cont;
+			catcher.next = rex->next;
+			return parse(env, rex->re.cond_catch.next[1], &catcher, rex->re.cond_catch.beg);
+		case REX_CAT:
+			return follow(env, rex, rex->re.group_catch.cont, s);
+		case REX_GROUP_CUT:
+			catcher.type = REX_GROUP_CUT_CATCH;
+			catcher.flags = rex->flags;
+			catcher.serial = rex->serial;
+			catcher.re.group_catch.cont = cont;
+			catcher.next = rex->next;
+			return parse(env, rex->re.group.expr.rex, &catcher, s);
+		case REX_GROUP_CUT_CATCH:
+			switch (r = follow(env, rex, rex->re.group_catch.cont, s))
+			{
+			case GOOD:
+				r = BEST;
+				break;
+			case NONE:
+				r = CUT;
+				break;
+			}
+			return r;
+		case REX_KMP:
+			f = rex->re.string.fail;
+			b = rex->re.string.base;
+			n = rex->re.string.size;
+			t = s;
+			e = env->end;
+			if (p = rex->map)
+			{
+				while (t + n <= e)
+				{
+					for (i = -1; t < e; t++)
+					{
+						while (i >= 0 && b[i+1] != p[*t])
+							i = f[i];
+						if (b[i+1] == p[*t])
+							i++;
+						if (i + 1 == n)
+						{
+							t++;
+							if (env->stack)
+								env->best[0].rm_so = t - s - n;
+							switch (follow(env, rex, cont, t))
+							{
+							case BAD:
+								return BAD;
+							case CUT:
+								return CUT;
+							case BEST:
+							case GOOD:
+								return BEST;
+							}
+							t -= n - 1;
+							break;
+						}
+					}
+				}
+			}
+			else
+			{
+				while (t + n <= e)
+				{
+					for (i = -1; t < e; t++)
+					{
+						while (i >= 0 && b[i+1] != *t)
+							i = f[i];
+						if (b[i+1] == *t)
+							i++;
+						if (i + 1 == n)
+						{
+							t++;
+							if (env->stack)
+								env->best[0].rm_so = t - s - n;
+							switch (follow(env, rex, cont, t))
+							{
+							case BAD:
+								return BAD;
+							case CUT:
+								return CUT;
+							case BEST:
+							case GOOD:
+								return BEST;
+							}
+							t -= n - 1;
+							break;
+						}
+					}
+				}
+			}
+			return NONE;
+		case REX_NEG:
+			if (LEADING(env, rex, s))
+				return NONE;
+			i = env->end - s;
+			n = ((i + 7) >> 3) + 1;
+			catcher.type = REX_NEG_CATCH;
+			catcher.re.neg_catch.beg = s;
+			if (!(p = (unsigned char*)stkpush(stkstd, n)))
+				return BAD;
+			memset(catcher.re.neg_catch.index = p, 0, n);
+			catcher.next = rex->next;
+			if (parse(env, rex->re.group.expr.rex, &catcher, s) == BAD)
+				r = BAD;
+			else
+			{
+				r = NONE;
+				for (; i >= 0; i--)
+					if (!bittst(p, i))
+					{
+						switch (follow(env, rex, cont, s + i))
+						{
+						case BAD:
+							r = BAD;
+							break;
+						case BEST:
+							r = BEST;
+							break;
+						case CUT:
+							r = CUT;
+							break;
+						case GOOD:
+							r = GOOD;
+							/*FALLTHROUGH*/
+						default:
+							continue;
+						}
+						break;
+					}
+			}
+			stkpop(stkstd);
+			return r;
+		case REX_NEG_CATCH:
+			bitset(rex->re.neg_catch.index, s - rex->re.neg_catch.beg);
+			return NONE;
+		case REX_NEST:
+			do
+			{
+				if ((c = *s++) == rex->re.nest.primary)
+				{
+					if (s >= env->end || !(s = nestmatch(s, env->end, rex->re.nest.type, c)))
+						return NONE;
+					break;
+				}
+				if (rex->re.nest.primary >= 0)
+					return NONE;
+			    	if (rex->re.nest.type[c] & (REX_NEST_delimiter|REX_NEST_separator|REX_NEST_terminator))
+					break;
+			    	if (!(s = nestmatch(s, env->end, rex->re.nest.type, c)))
+					return NONE;
+			} while (s < env->end && !(rex->re.nest.type[*(s-1)] & (REX_NEST_delimiter|REX_NEST_separator|REX_NEST_terminator)));
+			break;
+		case REX_NULL:
+			break;
+		case REX_ONECHAR:
+			n = rex->hi;
+			if (n > env->end - s)
+				n = env->end - s;
+			m = rex->lo;
+			if (m > n)
+				return NONE;
+			r = NONE;
+			c = rex->re.onechar;
+			if (!(rex->flags & REG_MINIMAL))
+			{
+				if (!mbwide())
+				{
+					if (p = rex->map)
+					{
+						for (i = 0; i < n; i++, s++)
+							if (p[*s] != c)
+								break;
+					}
+					else
+					{
+						for (i = 0; i < n; i++, s++)
+							if (*s != c)
+								break;
+					}
+					for (; i-- >= m; s--)
+						switch (follow(env, rex, cont, s))
+						{
+						case BAD:
+							return BAD;
+						case BEST:
+							return BEST;
+						case CUT:
+							return CUT;
+						case GOOD:
+							r = GOOD;
+							break;
+						}
+				}
+				else
+				{
+					if (!(b = (unsigned char*)stkpush(stkstd, n)))
+					{
+						env->error = REG_ESPACE;
+						return BAD;
+					}
+					e = env->end;
+					if (!(rex->flags & REG_ICASE))
+					{
+						for (i = 0; s < e && i < n; i++, s = t)
+						{
+							t = s;
+							if (mbchar(t) != c)
+								break;
+							b[i] = t - s;
+						}
+					}
+					else
+					{
+						for (i = 0; s < e && i < n; i++, s = t)
+						{
+							t = s;
+							if (towupper(mbchar(t)) != c)
+								break;
+							b[i] = t - s;
+						}
+					}
+					for (; i-- >= m; s -= b[i])
+						switch (follow(env, rex, cont, s))
+						{
+						case BAD:
+							stkpop(stkstd);
+							return BAD;
+						case BEST:
+							stkpop(stkstd);
+							return BEST;
+						case CUT:
+							stkpop(stkstd);
+							return CUT;
+						case GOOD:
+							r = GOOD;
+							break;
+						}
+					stkpop(stkstd);
+				}
+			}
+			else
+			{
+				if (!mbwide())
+				{
+					e = s + m;
+					if (p = rex->map)
+					{
+						for (; s < e; s++)
+							if (p[*s] != c)
+								return r;
+						e += n - m;
+						for (;;)
+						{
+							switch (follow(env, rex, cont, s))
+							{
+							case BAD:
+								return BAD;
+							case CUT:
+								return CUT;
+							case BEST:
+							case GOOD:
+								return BEST;
+							}
+							if (s >= e || p[*s++] != c)
+								break;
+						}
+					}
+					else
+					{
+						for (; s < e; s++)
+							if (*s != c)
+								return r;
+						e += n - m;
+						for (;;)
+						{
+							switch (follow(env, rex, cont, s))
+							{
+							case BAD:
+								return BAD;
+							case CUT:
+								return CUT;
+							case BEST:
+							case GOOD:
+								return BEST;
+							}
+							if (s >= e || *s++ != c)
+								break;
+						}
+					}
+				}
+				else
+				{
+					if (!(rex->flags & REG_ICASE))
+					{
+						for (i = 0; i < m && s < e; i++, s = t)
+						{
+							t = s;
+							if (mbchar(t) != c)
+								return r;
+						}
+						while (i++ <= n)
+						{
+							switch (follow(env, rex, cont, s))
+							{
+							case BAD:
+								return BAD;
+							case CUT:
+								return CUT;
+							case BEST:
+							case GOOD:
+								return BEST;
+							}
+							if (s >= e || mbchar(s) != c)
+								break;
+						}
+					}
+					else
+					{
+						for (i = 0; i < m && s < e; i++, s = t)
+						{
+							t = s;
+							if (towupper(mbchar(t)) != c)
+								return r;
+						}
+						while (i++ <= n)
+						{
+							switch (follow(env, rex, cont, s))
+							{
+							case BAD:
+								return BAD;
+							case CUT:
+								return CUT;
+							case BEST:
+							case GOOD:
+								return BEST;
+							}
+							if (s >= e || towupper(mbchar(s)) != c)
+								break;
+						}
+					}
+				}
+			}
+			return r;
+		case REX_REP:
+			if (env->stack && pospush(env, rex, s, BEG_REP))
+				return BAD;
+			r = parserep(env, rex, cont, s, 0);
+			if (env->stack)
+				pospop(env);
+			return r;
+		case REX_REP_CATCH:
+			DEBUG_TEST(0x0020,(sfprintf(sfstdout, "AHA#%04d 0x%04x %s n %d len %d s `%-.*s'\n", __LINE__, debug_flag, rexname(rex), rex->re.rep_catch.n, s - rex->re.rep_catch.beg, env->end - s, s)),(0));
+			if (env->stack && pospush(env, rex, s, END_ANY))
+				return BAD;
+			if (s == rex->re.rep_catch.beg && rex->re.rep_catch.n > rex->re.rep_catch.ref->lo)
+			{
+				/*
+				 * optional empty iteration
+				 */
+
+DEBUG_TEST(0x0002,(sfprintf(sfstdout, "AHA#%04d %p re.group.back=%d re.group.expr.rex=%s\n", __LINE__, rex->re.rep_catch.ref->re.group.expr.rex, rex->re.rep_catch.ref->re.group.expr.rex->re.group.back, rexname(rex->re.rep_catch.ref->re.group.expr.rex))),(0));
+				if (!env->stack || s != rex->re.rep_catch.ref->re.rep_catch.beg && !rex->re.rep_catch.ref->re.group.expr.rex->re.group.back)
+					r = NONE;
+				else if (pospush(env, rex, s, END_ANY))
+					r = BAD;
+				else
+				{
+					r = follow(env, rex, rex->re.rep_catch.cont, s);
+					pospop(env);
+				}
+			}
+			else
+				r = parserep(env, rex->re.rep_catch.ref, rex->re.rep_catch.cont, s, rex->re.rep_catch.n);
+			if (env->stack)
+				pospop(env);
+			return r;
+		case REX_STRING:
+DEBUG_TEST(0x0200,(sfprintf(sfstdout,"AHA#%04d 0x%04x parse %s \"%-.*s\" `%-.*s'\n", __LINE__, debug_flag, rexname(rex), rex->re.string.size, rex->re.string.base, env->end - s, s)),(0));
+			if (rex->re.string.size > (env->end - s))
+				return NONE;
+			t = rex->re.string.base;
+			e = t + rex->re.string.size;
+			if (!(p = rex->map))
+			{
+				while (t < e)
+					if (*s++ != *t++)
+						return NONE;
+			}
+			else if (!mbwide())
+			{
+				while (t < e)
+					if (p[*s++] != *t++)
+						return NONE;
+			}
+			else
+			{
+				while (t < e)
+				{
+					c = mbchar(s);
+					d = mbchar(t);
+					if (towupper(c) != d)
+						return NONE;
+				}
+			}
+			break;
+		case REX_TRIE:
+			if (((s + rex->re.trie.min) > env->end) || !(x = rex->re.trie.root[rex->map ? rex->map[*s] : *s]))
+				return NONE;
+			return parsetrie(env, x, rex, cont, s);
+		case REX_EXEC:
+			u = 0;
+			r = (*env->disc->re_execf)(env->regex, rex->re.exec.data, rex->re.exec.text, rex->re.exec.size, (const char*)s, env->end - s, &u, env->disc);
+			e = (unsigned char*)u;
+			if (e >= s && e <= env->end)
+				s = e;
+			switch (r)
+			{
+			case 0:
+				break;
+			case REG_NOMATCH:
+				return NONE;
+			default:
+				env->error = r;
+				return BAD;
+			}
+			break;
+		case REX_WBEG:
+			if (!isword(*s) || s > env->beg && isword(*(s - 1)))
+				return NONE;
+			break;
+		case REX_WEND:
+			if (isword(*s) || s > env->beg && !isword(*(s - 1)))
+				return NONE;
+			break;
+		case REX_WORD:
+			if (s > env->beg && isword(*(s - 1)) == isword(*s))
+				return NONE;
+			break;
+		case REX_WORD_NOT:
+			if (s == env->beg || isword(*(s - 1)) != isword(*s))
+				return NONE;
+			break;
+		case REX_BEG_STR:
+			if (s != env->beg)
+				return NONE;
+			break;
+		case REX_END_STR:
+			for (t = s; t < env->end && *t == '\n'; t++);
+			if (t < env->end)
+				return NONE;
+			break;
+		case REX_FIN_STR:
+			if (s < env->end)
+				return NONE;
+			break;
+		}
+		if (!(rex = rex->next))
+		{
+			if (!(rex = cont))
+				break;
+			cont = 0;
+		}
+	}
+	return GOOD;
+}
+
+#if _AST_REGEX_DEBUG
+
+static void
+listnode(Rex_t* e, int level)
+{
+	int	i;
+
+	if (e)
+	{
+		do
+		{
+			for (i = 0; i < level; i++)
+				sfprintf(sfstderr, "  ");
+			sfprintf(sfstderr, "%s\n", rexname(e));
+			switch (e->type)
+			{
+			case REX_ALT:
+			case REX_CONJ:
+				listnode(e->re.group.expr.binary.left, level + 1);
+				listnode(e->re.group.expr.binary.right, level + 1);
+				break;
+			case REX_GROUP:
+			case REX_GROUP_AHEAD:
+			case REX_GROUP_AHEAD_NOT:
+			case REX_GROUP_BEHIND:
+			case REX_GROUP_BEHIND_NOT:
+			case REX_GROUP_CUT:
+			case REX_NEG:
+			case REX_REP:
+				listnode(e->re.group.expr.rex, level + 1);
+				break;
+			}
+		} while (e = e->next);
+	}
+}
+
+static int
+list(Env_t* env, Rex_t* rex)
+{
+	sfprintf(sfstderr, "AHA regex hard=%d stack=%p\n", env->hard, env->stack);
+	if (rex)
+		listnode(rex, 1);
+	return 0;
+}
+
+#endif
+
+/*
+ * returning REG_BADPAT or REG_ESPACE is not explicitly
+ * countenanced by the standard
+ */
+
+int
+regnexec(const regex_t* p, const char* s, size_t len, size_t nmatch, regmatch_t* match, regflags_t flags)
+{
+	register int	n;
+	register int	i;
+	int		j;
+	int		k;
+	int		m;
+	int		advance;
+	Env_t*		env;
+	Rex_t*		e;
+
+	DEBUG_INIT();
+	DEBUG_TEST(0x0001,(sfprintf(sfstdout, "AHA#%04d 0x%04x regnexec %d 0x%08x `%-.*s'\n", __LINE__, debug_flag, nmatch, flags, len, s)),(0));
+	if (!p || !(env = p->env))
+		return REG_BADPAT;
+	if (!s)
+		return fatal(env->disc, REG_BADPAT, NiL);
+	if (len < env->min)
+	{
+		DEBUG_TEST(0x0080,(sfprintf(sfstdout, "AHA#%04d REG_NOMATCH %d %d\n", __LINE__, len, env->min)),(0));
+		return REG_NOMATCH;
+	}
+	env->regex = p;
+	env->beg = (unsigned char*)s;
+	env->end = env->beg + len;
+	stknew(stkstd, &env->stk);
+	env->flags &= ~REG_EXEC;
+	env->flags |= (flags & REG_EXEC);
+	advance = 0;
+	if (env->stack = env->hard || !(env->flags & REG_NOSUB) && nmatch)
+	{
+		n = env->nsub;
+		if (!(env->match = (regmatch_t*)stkpush(stkstd, 2 * (n + 1) * sizeof(regmatch_t))) ||
+		    !env->pos && !(env->pos = vecopen(16, sizeof(Pos_t))) ||
+		    !env->bestpos && !(env->bestpos = vecopen(16, sizeof(Pos_t))))
+		{
+			k = REG_ESPACE;
+			goto done;
+		}
+		env->pos->cur = env->bestpos->cur = 0;
+		env->best = &env->match[n + 1];
+		env->best[0].rm_so = 0;
+		env->best[0].rm_eo = -1;
+		for (i = 0; i <= n; i++)
+			env->match[i] = state.nomatch;
+		if (flags & REG_ADVANCE)
+			advance = 1;
+	}
+	DEBUG_TEST(0x1000,(list(env,env->rex)),(0));
+	k = REG_NOMATCH;
+	if ((e = env->rex)->type == REX_BM)
+	{
+		DEBUG_TEST(0x0080,(sfprintf(sfstdout, "AHA#%04d REX_BM\n", __LINE__)),(0));
+		if (len < e->re.bm.right)
+		{
+			DEBUG_TEST(0x0080,(sfprintf(sfstdout, "AHA#%04d REG_NOMATCH %d %d\n", __LINE__, len, e->re.bm.right)),(0));
+			goto done;
+		}
+		else if (!(flags & REG_LEFT))
+		{
+			register unsigned char*	buf = (unsigned char*)s;
+			register size_t		index = e->re.bm.left + e->re.bm.size;
+			register size_t		mid = len - e->re.bm.right;
+			register size_t*	skip = e->re.bm.skip;
+			register size_t*	fail = e->re.bm.fail;
+			register Bm_mask_t**	mask = e->re.bm.mask;
+			Bm_mask_t		m;
+			size_t			x;
+
+			DEBUG_TEST(0x0080,(sfprintf(sfstdout, "AHA#%04d REX_BM len=%d right=%d left=%d size=%d %d %d\n", __LINE__, len, e->re.bm.right, e->re.bm.left, e->re.bm.size, index, mid)),(0));
+			for (;;)
+			{
+				while ((index += skip[buf[index]]) < mid);
+				if (index < HIT)
+				{
+					DEBUG_TEST(0x0080,(sfprintf(sfstdout, "AHA#%04d REG_NOMATCH %d %d\n", __LINE__, index, HIT)),(0));
+					goto done;
+				}
+				index -= HIT;
+				m = mask[n = e->re.bm.size - 1][buf[index]];
+				do
+				{
+					if (!n--)
+					{
+						if (e->re.bm.back < 0)
+							goto possible;
+						if (advance)
+						{
+							i = index - e->re.bm.back;
+							s += i;
+							if (env->stack)
+								env->best[0].rm_so += i;
+							goto possible;
+						}
+						x = index;
+						if (index < e->re.bm.back)
+							index = 0;
+						else
+							index -= e->re.bm.back;
+						while (index <= x)
+						{
+							if ((i = parse(env, e->next, &env->done, buf + index)) != NONE)
+							{
+								if (env->stack)
+									env->best[0].rm_so = index;
+								n = env->nsub;
+								goto hit;
+							}
+							index++;
+						}
+						index += e->re.bm.size;
+						break;
+					}
+				} while (m &= mask[n][buf[--index]]);
+				if ((index += fail[n + 1]) >= len)
+					goto done;
+			}
+		}
+ possible:
+		n = env->nsub;
+		e = e->next;
+	}
+	j = env->once || (flags & REG_LEFT);
+	DEBUG_TEST(0x0080,(sfprintf(sfstdout, "AHA#%04d parse once=%d\n", __LINE__, j)),(0));
+	while ((i = parse(env, e, &env->done, (unsigned char*)s)) == NONE || advance && !env->best[0].rm_eo && !(advance = 0))
+	{
+		if (j)
+			goto done;
+		i = MBSIZE(s);
+		s += i;
+		if ((unsigned char*)s > env->end - env->min)
+			goto done;
+		if (env->stack)
+			env->best[0].rm_so += i;
+	}
+	if ((flags & REG_LEFT) && env->stack && env->best[0].rm_so)
+		goto done;
+ hit:
+	if (k = env->error)
+		goto done;
+	if (i == CUT)
+	{
+		k = env->error = REG_NOMATCH;
+		goto done;
+	}
+	if (!(env->flags & REG_NOSUB))
+	{
+		k = (env->flags & (REG_SHELL|REG_AUGMENTED)) == (REG_SHELL|REG_AUGMENTED);
+		for (i = j = m = 0; j < nmatch; i++)
+			if (!i || !k || (i & 1))
+			{
+				if (i > n)
+					match[j] = state.nomatch;
+				else
+					match[m = j] = env->best[i];
+				j++;
+			}
+		if (k)
+		{
+			while (m > 0 && match[m].rm_so == -1 && match[m].rm_eo == -1)
+				m--;
+			((regex_t*)p)->re_nsub = m;
+		}
+	}
+	k = 0;
+ done:
+	stkold(stkstd, &env->stk);
+	env->stk.base = 0;
+	if (k > REG_NOMATCH)
+		fatal(p->env->disc, k, NiL);
+	return k;
+}
+
+void
+regfree(regex_t* p)
+{
+	Env_t*	env;
+
+	if (p && (env = p->env))
+	{
+#if _REG_subcomp
+		if (env->sub)
+		{
+			regsubfree(p);
+			p->re_sub = 0;
+		}
+#endif
+		p->env = 0;
+		if (--env->refs <= 0 && !(env->disc->re_flags & REG_NOFREE))
+		{
+			drop(env->disc, env->rex);
+			if (env->pos)
+				vecclose(env->pos);
+			if (env->bestpos)
+				vecclose(env->bestpos);
+			if (env->stk.base)
+				stkold(stkstd, &env->stk);
+			alloc(env->disc, env, 0);
+		}
+	}
+}
diff --git a/usr/src/lib/libast/common/regex/regrecord.c b/usr/src/lib/libast/common/regex/regrecord.c
new file mode 100644
index 0000000000..b17b143a87
--- /dev/null
+++ b/usr/src/lib/libast/common/regex/regrecord.c
@@ -0,0 +1,34 @@
+/***********************************************************************
+*                                                                      *
+*               This software is part of the ast package               *
+*           Copyright (c) 1985-2007 AT&T Knowledge Ventures            *
+*                      and is licensed under the                       *
+*                  Common Public License, Version 1.0                  *
+*                      by AT&T Knowledge Ventures                      *
+*                                                                      *
+*                A copy of the License is available at                 *
+*            http://www.opensource.org/licenses/cpl1.0.txt             *
+*         (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9)         *
+*                                                                      *
+*              Information and Software Systems Research               *
+*                            AT&T Research                             *
+*                           Florham Park NJ                            *
+*                                                                      *
+*                 Glenn Fowler <gsf@research.att.com>                  *
+*                  David Korn <dgk@research.att.com>                   *
+*                   Phong Vo <kpv@research.att.com>                    *
+*                                                                      *
+***********************************************************************/
+#pragma prototyped
+
+/*
+ * return 1 if regrexec() can be used
+ */
+
+#include "reglib.h"
+
+int
+regrecord(const regex_t* p)
+{
+	return p && p->env && p->env->rex->type == REX_BM;
+}
diff --git a/usr/src/lib/libast/common/regex/regrexec.c b/usr/src/lib/libast/common/regex/regrexec.c
new file mode 100644
index 0000000000..cefc7bc7fb
--- /dev/null
+++ b/usr/src/lib/libast/common/regex/regrexec.c
@@ -0,0 +1,145 @@
+/***********************************************************************
+*                                                                      *
+*               This software is part of the ast package               *
+*           Copyright (c) 1985-2007 AT&T Knowledge Ventures            *
+*                      and is licensed under the                       *
+*                  Common Public License, Version 1.0                  *
+*                      by AT&T Knowledge Ventures                      *
+*                                                                      *
+*                A copy of the License is available at                 *
+*            http://www.opensource.org/licenses/cpl1.0.txt             *
+*         (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9)         *
+*                                                                      *
+*              Information and Software Systems Research               *
+*                            AT&T Research                             *
+*                           Florham Park NJ                            *
+*                                                                      *
+*                 Glenn Fowler <gsf@research.att.com>                  *
+*                  David Korn <dgk@research.att.com>                   *
+*                   Phong Vo <kpv@research.att.com>                    *
+*                                                                      *
+***********************************************************************/
+#pragma prototyped
+
+/*
+ * posix regex record executor
+ * multiple record sized-buffer interface
+ */
+
+#include "reglib.h"
+
+/*
+ * call regnexec() on records selected by Boyer-Moore
+ */
+
+int
+regrexec(const regex_t* p, const char* s, size_t len, size_t nmatch, regmatch_t* match, regflags_t flags, int sep, void* handle, regrecord_t record)
+{
+	register unsigned char*	buf = (unsigned char*)s;
+	register unsigned char*	beg;
+	register unsigned char*	l;
+	register unsigned char*	r;
+	register unsigned char*	x;
+	register size_t*	skip;
+	register size_t*	fail;
+	register Bm_mask_t**	mask;
+	register size_t		index;
+	register int		n;
+	unsigned char*		end;
+	size_t			mid;
+	int			complete;
+	int			exactlen;
+	int			leftlen;
+	int			rightlen;
+	int			inv;
+	Bm_mask_t		m;
+	Env_t*			env;
+	Rex_t*			e;
+
+	if (!s || !p || !(env = p->env) || (e = env->rex)->type != REX_BM)
+		return REG_BADPAT;
+	inv = (flags & REG_INVERT) != 0;
+	buf = beg = (unsigned char*)s;
+	end = buf + len;
+	mid = (len < e->re.bm.right) ? 0 : (len - e->re.bm.right);
+	skip = e->re.bm.skip;
+	fail = e->re.bm.fail;
+	mask = e->re.bm.mask;
+	complete = e->re.bm.complete && !nmatch;
+	exactlen = e->re.bm.size;
+	leftlen = e->re.bm.left + exactlen;
+	rightlen = exactlen + e->re.bm.right;
+	index = leftlen++;
+	for (;;)
+	{
+		while ((index += skip[buf[index]]) < mid);
+		if (index < HIT)
+			goto impossible;
+		index -= HIT;
+		m = mask[n = exactlen - 1][buf[index]];
+		do
+		{
+			if (!n--)
+				goto possible;
+		} while (m &= mask[n][buf[--index]]);
+		if ((index += fail[n + 1]) < len)
+			continue;
+ impossible:
+		if (inv)
+		{
+			l = r = buf + len;
+			goto invert;
+		}
+		n = 0;
+		goto done;
+ possible:
+		r = (l = buf + index) + exactlen;
+		while (l > beg)
+			if (*--l == sep)
+			{
+				l++;
+				break;
+			}
+		if ((r - l) < leftlen)
+			goto spanned;
+		while (r < end && *r != sep)
+			r++;
+		if ((r - (buf + index)) < rightlen)
+			goto spanned;
+		if (complete || (env->rex = ((r - l) > 128) ? e : e->next) && !(n = regnexec(p, (char*)l, r - l, nmatch, match, flags)))
+		{
+			if (inv)
+			{
+ invert:
+				x = beg;
+				while (beg < l)
+				{
+					while (x < l && *x != sep)
+						x++;
+					if (n = (*record)(handle, (char*)beg, x - beg))
+						goto done;
+					beg = ++x;
+				}
+			}
+			else if (n = (*record)(handle, (char*)l, r - l))
+				goto done;
+			if ((index = (r - buf) + leftlen) >= len)
+			{
+				n = (inv && (++r - buf) < len) ? (*record)(handle, (char*)r, (buf + len) - r): 0;
+				goto done;
+			}
+			beg = r + 1;
+		}
+		else if (n != REG_NOMATCH)
+			goto done;
+		else
+		{
+ spanned:
+			if ((index += exactlen) >= mid)
+				goto impossible;
+		}
+	}
+ done:
+	env->rex = e;
+	return n;
+}
diff --git a/usr/src/lib/libast/common/regex/regstat.c b/usr/src/lib/libast/common/regex/regstat.c
new file mode 100644
index 0000000000..af7a180b21
--- /dev/null
+++ b/usr/src/lib/libast/common/regex/regstat.c
@@ -0,0 +1,46 @@
+/***********************************************************************
+*                                                                      *
+*               This software is part of the ast package               *
+*           Copyright (c) 1985-2007 AT&T Knowledge Ventures            *
+*                      and is licensed under the                       *
+*                  Common Public License, Version 1.0                  *
+*                      by AT&T Knowledge Ventures                      *
+*                                                                      *
+*                A copy of the License is available at                 *
+*            http://www.opensource.org/licenses/cpl1.0.txt             *
+*         (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9)         *
+*                                                                      *
+*              Information and Software Systems Research               *
+*                            AT&T Research                             *
+*                           Florham Park NJ                            *
+*                                                                      *
+*                 Glenn Fowler <gsf@research.att.com>                  *
+*                  David Korn <dgk@research.att.com>                   *
+*                   Phong Vo <kpv@research.att.com>                    *
+*                                                                      *
+***********************************************************************/
+#pragma prototyped
+
+/*
+ * return p stat info
+ */
+
+#include "reglib.h"
+
+regstat_t*
+regstat(const regex_t* p)
+{
+	register Rex_t*	e;
+
+	e = p->env->rex;
+	if (e && e->type == REX_BM)
+		e = e->next;
+	if (e && e->type == REX_BEG)
+		e = e->next;
+	if (e && e->type == REX_STRING)
+		e = e->next;
+	if (!e || e->type == REX_END && !e->next)
+		p->env->stats.re_flags |= REG_LITERAL;
+	p->env->stats.re_record = (p && p->env && p->env->rex->type == REX_BM) ? p->env->rex->re.bm.size : -1;
+	return &p->env->stats;
+}
diff --git a/usr/src/lib/libast/common/regex/regsub.c b/usr/src/lib/libast/common/regex/regsub.c
new file mode 100644
index 0000000000..255fd0a05d
--- /dev/null
+++ b/usr/src/lib/libast/common/regex/regsub.c
@@ -0,0 +1,268 @@
+/***********************************************************************
+*                                                                      *
+*               This software is part of the ast package               *
+*           Copyright (c) 1985-2007 AT&T Knowledge Ventures            *
+*                      and is licensed under the                       *
+*                  Common Public License, Version 1.0                  *
+*                      by AT&T Knowledge Ventures                      *
+*                                                                      *
+*                A copy of the License is available at                 *
+*            http://www.opensource.org/licenses/cpl1.0.txt             *
+*         (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9)         *
+*                                                                      *
+*              Information and Software Systems Research               *
+*                            AT&T Research                             *
+*                           Florham Park NJ                            *
+*                                                                      *
+*                 Glenn Fowler <gsf@research.att.com>                  *
+*                  David Korn <dgk@research.att.com>                   *
+*                   Phong Vo <kpv@research.att.com>                    *
+*                                                                      *
+***********************************************************************/
+#pragma prototyped
+
+/*
+ * OBSOLETE Sfio_t buffer interface -- use regsubcomp(),regsubexec()
+ */
+
+#include "reglib.h"
+
+/*
+ * do a single substitution
+ */
+
+static int
+subold(register Sfio_t* dp, const char* op, register const char* sp, size_t nmatch, register regmatch_t* match, register regflags_t flags, int sre)
+{
+	register int	c;
+	char*		s;
+	char*		e;
+	const char*	b;
+	regflags_t	f;
+
+	f = flags &= (REG_SUB_LOWER|REG_SUB_UPPER);
+	for (;;)
+	{
+		switch (c = *sp++)
+		{
+		case 0:
+			return 0;
+		case '~':
+			if (!sre || *sp != '(')
+			{
+				sfputc(dp, c);
+				continue;
+			}
+			b = sp - 1;
+			sp++;
+			break;
+		case '\\':
+			if (sre)
+			{
+				sfputc(dp, chresc(sp - 1, &s));
+				sp = (const char*)s;
+				continue;
+			}
+			if (*sp == '&')
+			{
+				c = *sp++;
+				sfputc(dp, c);
+				continue;
+			}
+			break;
+		case '&':
+			if (sre)
+			{
+				sfputc(dp, c);
+				continue;
+			}
+			sp--;
+			break;
+		default:
+			switch (flags)
+			{
+			case REG_SUB_UPPER:
+				if (islower(c))
+					c = toupper(c);
+				break;
+			case REG_SUB_LOWER:
+				if (isupper(c))
+					c = tolower(c);
+				break;
+			case REG_SUB_UPPER|REG_SUB_LOWER:
+				if (isupper(c))
+					c = tolower(c);
+				else if (islower(c))
+					c = toupper(c);
+				break;
+			}
+			sfputc(dp, c);
+			continue;
+		}
+		switch (c = *sp++)
+		{
+		case 0:
+			sp--;
+			continue;
+		case '&':
+			c = 0;
+			break;
+		case '0': case '1': case '2': case '3': case '4':
+		case '5': case '6': case '7': case '8': case '9':
+			c -= '0';
+			if (sre)
+				while (isdigit(*sp))
+					c = c * 10 + *sp++ - '0';
+			break;
+		case 'l':
+			if (sre && *sp != ')')
+			{
+				c = -1;
+				break;
+			}
+			if (c = *sp)
+			{
+				sp++;
+				if (isupper(c))
+					c = tolower(c);
+				sfputc(dp, c);
+			}
+			continue;
+		case 'u':
+			if (sre)
+			{
+				if (*sp != ')')
+				{
+					c = -1;
+					break;
+				}
+				sp++;
+			}
+			if (c = *sp)
+			{
+				sp++;
+				if (islower(c))
+					c = toupper(c);
+				sfputc(dp, c);
+			}
+			continue;
+		case 'E':
+			if (sre)
+			{
+				if (*sp != ')')
+				{
+					c = -1;
+					break;
+				}
+				sp++;
+			}
+			flags = f;
+			continue;
+		case 'L':
+			if (sre)
+			{
+				if (*sp != ')')
+				{
+					c = -1;
+					break;
+				}
+				sp++;
+			}
+			f = flags;
+			flags = REG_SUB_LOWER;
+			continue;
+		case 'U':
+			if (sre)
+			{
+				if (*sp != ')')
+				{
+					c = -1;
+					break;
+				}
+				sp++;
+			}
+			f = flags;
+			flags = REG_SUB_UPPER;
+			continue;
+		default:
+			if (!sre)
+			{
+				sfputc(dp, chresc(sp - 2, &s));
+				sp = (const char*)s;
+				continue;
+			}
+			sp--;
+			c = -1;
+			break;
+		}
+		if (sre)
+		{
+			if (c < 0 || *sp != ')')
+			{
+				for (; b < sp; b++)
+					sfputc(dp, *b);
+				continue;
+			}
+			sp++;
+		}
+		if (c >= nmatch)
+			return REG_ESUBREG;
+		s = (char*)op + match[c].rm_so;
+		e = (char*)op + match[c].rm_eo;
+		while (s < e)
+		{
+			c = *s++;
+			switch (flags)
+			{
+			case REG_SUB_UPPER:
+				if (islower(c))
+					c = toupper(c);
+				break;
+			case REG_SUB_LOWER:
+				if (isupper(c))
+					c = tolower(c);
+				break;
+			case REG_SUB_UPPER|REG_SUB_LOWER:
+				if (isupper(c))
+					c = tolower(c);
+				else if (islower(c))
+					c = toupper(c);
+				break;
+			}
+			sfputc(dp, c);
+		}
+	}
+}
+
+/*
+ * ed(1) style substitute using matches from last regexec()
+ */
+
+int
+regsub(const regex_t* p, Sfio_t* dp, const char* op, const char* sp, size_t nmatch, regmatch_t* match, regflags_t flags)
+{
+	int	m;
+	int	r;
+	int	sre;
+
+	if ((p->env->flags & REG_NOSUB) || !nmatch)
+		return fatal(p->env->disc, REG_BADPAT, NiL);
+	m = (flags >> 16) & 0x3fff;
+	sre = !!(p->env->flags & REG_SHELL);
+	do
+	{
+		if (--m > 0)
+			sfwrite(dp, op, match->rm_eo);
+		else
+		{
+			sfwrite(dp, op, match->rm_so);
+			if (r = subold(dp, op, sp, nmatch, match, flags, sre))
+				return fatal(p->env->disc, r, NiL);
+		}
+		op += match->rm_eo;
+	} while ((m > 0 || (flags & REG_SUB_ALL)) && !(r = regexec(p, op, nmatch, match, p->env->flags|(match->rm_so == match->rm_eo ? REG_ADVANCE : 0))));
+	if (r && r != REG_NOMATCH)
+		return fatal(p->env->disc, r, NiL);
+	sfputr(dp, op, -1);
+	return 0;
+}
diff --git a/usr/src/lib/libast/common/regex/regsubcomp.c b/usr/src/lib/libast/common/regex/regsubcomp.c
new file mode 100644
index 0000000000..f8806a2544
--- /dev/null
+++ b/usr/src/lib/libast/common/regex/regsubcomp.c
@@ -0,0 +1,452 @@
+/***********************************************************************
+*                                                                      *
+*               This software is part of the ast package               *
+*           Copyright (c) 1985-2007 AT&T Knowledge Ventures            *
+*                      and is licensed under the                       *
+*                  Common Public License, Version 1.0                  *
+*                      by AT&T Knowledge Ventures                      *
+*                                                                      *
+*                A copy of the License is available at                 *
+*            http://www.opensource.org/licenses/cpl1.0.txt             *
+*         (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9)         *
+*                                                                      *
+*              Information and Software Systems Research               *
+*                            AT&T Research                             *
+*                           Florham Park NJ                            *
+*                                                                      *
+*                 Glenn Fowler <gsf@research.att.com>                  *
+*                  David Korn <dgk@research.att.com>                   *
+*                   Phong Vo <kpv@research.att.com>                    *
+*                                                                      *
+***********************************************************************/
+#pragma prototyped
+
+/*
+ * posix regex ed(1) style substitute compile
+ */
+
+#include "reglib.h"
+
+static const regflags_t	submap[] =
+{
+	'g',	REG_SUB_ALL,
+	'l',	REG_SUB_LOWER,
+	'n',	REG_SUB_NUMBER,
+	'p',	REG_SUB_PRINT,
+	's',	REG_SUB_STOP,
+	'u',	REG_SUB_UPPER,
+	'w',	REG_SUB_WRITE|REG_SUB_LAST,
+	0,	0
+};
+
+int
+regsubflags(regex_t* p, register const char* s, char** e, int delim, register const regflags_t* map, int* pm, regflags_t* pf)
+{
+	register int			c;
+	register const regflags_t*	m;
+	regflags_t			flags;
+	int				minmatch;
+	regdisc_t*			disc;
+
+	flags = pf ? *pf : 0;
+	minmatch = pm ? *pm : 0;
+	if (!map)
+		map = submap;
+	while (!(flags & REG_SUB_LAST))
+	{
+		if  (!(c = *s++) || c == delim)
+		{
+			s--;
+			break;
+		}
+		else if (c >= '0' && c <= '9')
+		{
+			if (minmatch)
+			{
+				disc = p->env->disc;
+				regfree(p);
+				return fatal(disc, REG_EFLAGS, s - 1);
+			}
+			minmatch = c - '0';
+			while (*s >= '0' && *s <= '9')
+				minmatch = minmatch * 10 + *s++ - '0';
+		}
+		else
+		{
+			for (m = map; *m; m++)
+				if (*m++ == c)
+				{
+					if (flags & *m)
+					{
+						disc = p->env->disc;
+						regfree(p);
+						return fatal(disc, REG_EFLAGS, s - 1);
+					}
+					flags |= *m--;
+					break;
+				}
+			if (!*m)
+			{
+				s--;
+				break;
+			}
+		}
+	}
+	if (pf)
+		*pf = flags;
+	if (pm)
+		*pm = minmatch;
+	if (e)
+		*e = (char*)s;
+	return 0;
+}
+
+/*
+ * compile substitute rhs and optional flags
+ */
+
+int
+regsubcomp(regex_t* p, register const char* s, const regflags_t* map, int minmatch, regflags_t flags)
+{
+	register regsub_t*	sub;
+	register int		c;
+	register int		d;
+	register char*		t;
+	register regsubop_t*	op;
+	char*			e;
+	const char*		r;
+	int			sre;
+	int			f;
+	int			g;
+	int			n;
+	int			nops;
+	const char*		o;
+	regdisc_t*		disc;
+
+	disc = p->env->disc;
+	if (p->env->flags & REG_NOSUB)
+	{
+		regfree(p);
+		return fatal(disc, REG_BADPAT, NiL);
+	}
+	if (!(sub = (regsub_t*)alloc(p->env->disc, 0, sizeof(regsub_t) + strlen(s))) || !(sub->re_ops = (regsubop_t*)alloc(p->env->disc, 0, (nops = 8) * sizeof(regsubop_t))))
+	{
+		if (sub)
+			alloc(p->env->disc, sub, 0);
+		regfree(p);
+		return fatal(disc, REG_ESPACE, s);
+	}
+	sub->re_buf = sub->re_end = 0;
+	p->re_sub = sub;
+	p->env->sub = 1;
+	op = sub->re_ops;
+	o = s;
+	if (!(p->env->flags & REG_DELIMITED))
+		d = 0;
+	else
+		switch (d = *(s - 1))
+		{
+		case '\\':
+		case '\n':
+		case '\r':
+			regfree(p);
+			return fatal(disc, REG_EDELIM, s);
+		}
+	sre = p->env->flags & REG_SHELL;
+	t = sub->re_rhs;
+	if (d)
+	{
+		r = s;
+		for (;;)
+		{
+			if (!*s)
+			{
+				if (p->env->flags & REG_MUSTDELIM)
+				{
+					regfree(p);
+					return fatal(disc, REG_EDELIM, r);
+				}
+				break;
+			}
+			else if (*s == d)
+			{
+				flags |= REG_SUB_FULL;
+				s++;
+				break;
+			}
+			else if (*s++ == '\\' && !*s++)
+			{
+				regfree(p);
+				return fatal(disc, REG_EESCAPE, r);
+			}
+		}
+		if (*s)
+		{
+			if (n = regsubflags(p, s, &e, d, map, &minmatch, &flags))
+				return n;
+			s = (const char*)e;
+		}
+		p->re_npat = s - o;
+		s = r;
+	}
+	else
+		p->re_npat = 0;
+	op->op = f = g = flags & (REG_SUB_LOWER|REG_SUB_UPPER);
+	op->off = 0;
+	while ((c = *s++) != d)
+	{
+	again:
+		if (!c)
+		{
+			p->re_npat = s - o - 1;
+			break;
+		}
+		else if (c == '~')
+		{
+			if (!sre || *s != '(')
+			{
+				*t++ = c;
+				continue;
+			}
+			r = s - 1;
+			s++;
+			c = *s++;
+		}
+		else if (c == '\\')
+		{
+			if (*s == c)
+			{
+				*t++ = *s++;
+				continue;
+			}
+			if ((c = *s++) == d)
+				goto again;
+			if (!c)
+			{
+				regfree(p);
+				return fatal(disc, REG_EESCAPE, s - 2);
+			}
+			if (sre)
+			{
+				*t++ = chresc(s - 2, &e);
+				s = (const char*)e;
+				continue;
+			}
+			if (c == '&')
+			{
+				*t++ = c;
+				continue;
+			}
+		}
+		else if (c == '&')
+		{
+			if (sre)
+			{
+				*t++ = c;
+				continue;
+			}
+		}
+		else
+		{
+			switch (op->op)
+			{
+			case REG_SUB_UPPER:
+				if (islower(c))
+					c = toupper(c);
+				break;
+			case REG_SUB_LOWER:
+				if (isupper(c))
+					c = tolower(c);
+				break;
+			case REG_SUB_UPPER|REG_SUB_LOWER:
+				if (isupper(c))
+					c = tolower(c);
+				else if (islower(c))
+					c = toupper(c);
+				break;
+			}
+			*t++ = c;
+			continue;
+		}
+		switch (c)
+		{
+		case 0:
+			s--;
+			continue;
+		case '&':
+			c = 0;
+			break;
+		case '0': case '1': case '2': case '3': case '4':
+		case '5': case '6': case '7': case '8': case '9':
+			c -= '0';
+			if (sre)
+				while (isdigit(*s))
+					c = c * 10 + *s++ - '0';
+			else if (isdigit(*s) && (p->env->flags & REG_MULTIREF))
+				c = c * 10 + *s++ - '0';
+			break;
+		case 'l':
+			if (sre)
+			{
+				if (*s != ')')
+				{
+					c = -1;
+					break;
+				}
+				s++;
+			}
+			if (c = *s)
+			{
+				s++;
+				if (isupper(c))
+					c = tolower(c);
+				*t++ = c;
+			}
+			continue;
+		case 'u':
+			if (sre)
+			{
+				if (*s != ')')
+				{
+					c = -1;
+					break;
+				}
+				s++;
+			}
+			if (c = *s)
+			{
+				s++;
+				if (islower(c))
+					c = toupper(c);
+				*t++ = c;
+			}
+			continue;
+		case 'E':
+			if (sre)
+			{
+				if (*s != ')')
+				{
+					c = -1;
+					break;
+				}
+				s++;
+			}
+			f = g;
+		set:
+			if ((op->len = (t - sub->re_rhs) - op->off) && (n = ++op - sub->re_ops) >= nops)
+			{
+				if (!(sub->re_ops = (regsubop_t*)alloc(p->env->disc, sub->re_ops, (nops *= 2) * sizeof(regsubop_t))))
+				{
+					regfree(p);
+					return fatal(disc, REG_ESPACE, NiL);
+				}
+				op = sub->re_ops + n;
+			}
+			op->op = f;
+			op->off = t - sub->re_rhs;
+			continue;
+		case 'L':
+			if (sre)
+			{
+				if (*s != ')')
+				{
+					c = -1;
+					break;
+				}
+				s++;
+			}
+			g = f;
+			f = REG_SUB_LOWER;
+			goto set;
+		case 'U':
+			if (sre)
+			{
+				if (*s != ')')
+				{
+					c = -1;
+					break;
+				}
+				s++;
+			}
+			g = f;
+			f = REG_SUB_UPPER;
+			goto set;
+		default:
+			if (!sre)
+			{
+				*t++ = chresc(s - 2, &e);
+				s = (const char*)e;
+				continue;
+			}
+			s--;
+			c = -1;
+			break;
+		}
+		if (sre)
+		{
+			if (c < 0 || *s != ')')
+			{
+				while (r < s)
+					*t++ = *r++;
+				continue;
+			}
+			s++;
+		}
+		if (c > p->re_nsub)
+		{
+			regfree(p);
+			return fatal(disc, REG_ESUBREG, s - 1);
+		}
+		if ((n = op - sub->re_ops) >= (nops - 2))
+		{
+			if (!(sub->re_ops = (regsubop_t*)alloc(p->env->disc, sub->re_ops, (nops *= 2) * sizeof(regsubop_t))))
+			{
+				regfree(p);
+				return fatal(disc, REG_ESPACE, NiL);
+			}
+			op = sub->re_ops + n;
+		}
+		if (op->len = (t - sub->re_rhs) - op->off)
+			op++;
+		op->op = f;
+		op->off = c;
+		op->len = 0;
+		op++;
+		op->op = f;
+		op->off = t - sub->re_rhs;
+	}
+	if ((op->len = (t - sub->re_rhs) - op->off) && (n = ++op - sub->re_ops) >= nops)
+	{
+		if (!(sub->re_ops = (regsubop_t*)alloc(p->env->disc, sub->re_ops, (nops *= 2) * sizeof(regsubop_t))))
+		{
+			regfree(p);
+			return fatal(disc, REG_ESPACE, NiL);
+		}
+		op = sub->re_ops + n;
+	}
+	op->len = -1;
+	sub->re_flags = flags;
+	sub->re_min = minmatch;
+	return 0;
+}
+
+void
+regsubfree(regex_t* p)
+{
+	Env_t*		env;
+	regsub_t*	sub;
+
+	if (p && (env = p->env) && env->sub && (sub = p->re_sub))
+	{
+		env->sub = 0;
+		p->re_sub = 0;
+		if (!(env->disc->re_flags & REG_NOFREE))
+		{
+			if (sub->re_buf)
+				alloc(env->disc, sub->re_buf, 0);
+			if (sub->re_ops)
+				alloc(env->disc, sub->re_ops, 0);
+			alloc(env->disc, sub, 0);
+		}
+	}
+}
diff --git a/usr/src/lib/libast/common/regex/regsubexec.c b/usr/src/lib/libast/common/regex/regsubexec.c
new file mode 100644
index 0000000000..9682e69f5d
--- /dev/null
+++ b/usr/src/lib/libast/common/regex/regsubexec.c
@@ -0,0 +1,190 @@
+/***********************************************************************
+*                                                                      *
+*               This software is part of the ast package               *
+*           Copyright (c) 1985-2007 AT&T Knowledge Ventures            *
+*                      and is licensed under the                       *
+*                  Common Public License, Version 1.0                  *
+*                      by AT&T Knowledge Ventures                      *
+*                                                                      *
+*                A copy of the License is available at                 *
+*            http://www.opensource.org/licenses/cpl1.0.txt             *
+*         (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9)         *
+*                                                                      *
+*              Information and Software Systems Research               *
+*                            AT&T Research                             *
+*                           Florham Park NJ                            *
+*                                                                      *
+*                 Glenn Fowler <gsf@research.att.com>                  *
+*                  David Korn <dgk@research.att.com>                   *
+*                   Phong Vo <kpv@research.att.com>                    *
+*                                                                      *
+***********************************************************************/
+#pragma prototyped
+
+/*
+ * posix regex ed(1) style substitute execute
+ */
+
+#include "reglib.h"
+
+#define NEED(p,b,n,r)	\
+	do \
+	{ \
+		if (((b)->re_end - (b)->re_cur) < (n)) \
+		{ \
+			size_t	o = (b)->re_cur - (b)->re_buf; \
+			size_t	a = ((b)->re_end - (b)->re_buf); \
+			if (a < n) \
+				a = roundof(n, 128); \
+			a *= 2; \
+			if (!((b)->re_buf = alloc(p->env->disc, (b)->re_buf, a))) \
+			{ \
+				(b)->re_buf = (b)->re_cur = (b)->re_end = 0; \
+				c = REG_ESPACE; \
+				r; \
+			} \
+			(b)->re_cur = (b)->re_buf + o; \
+			(b)->re_end = (b)->re_buf + a; \
+		} \
+	} while (0)
+
+#define PUTC(p,b,x,r)	\
+	do \
+	{ \
+		NEED(p, b, 1, r); \
+		*(b)->re_cur++ = (x); \
+	} while (0)
+
+#define PUTS(p,b,x,z,r)	\
+	do if (z) \
+	{ \
+		NEED(p, b, z, r); \
+		memcpy((b)->re_cur, x, z); \
+		(b)->re_cur += (z); \
+	} while (0)
+
+/*
+ * do a single substitution
+ */
+
+static int
+sub(const regex_t* p, register regsub_t* b, const char* ss, register regsubop_t* op, size_t nmatch, register regmatch_t* match)
+{
+	register char*	s;
+	register char*	e;
+	register int	c;
+
+	for (;; op++)
+	{
+		switch (op->len)
+		{
+		case -1:
+			break;
+		case 0:
+			if (op->off >= nmatch)
+				return REG_ESUBREG;
+			if ((c = match[op->off].rm_so) < 0)
+				continue;
+			s = (char*)ss + c;
+			if ((c = match[op->off].rm_eo) < 0)
+				continue;
+			e = (char*)ss + c;
+			NEED(p, b, e - s, return c);
+			switch (op->op)
+			{
+			case REG_SUB_UPPER:
+				while (s < e)
+				{
+					c = *s++;
+					if (islower(c))
+						c = toupper(c);
+					*b->re_cur++ = c;
+				}
+				break;
+			case REG_SUB_LOWER:
+				while (s < e)
+				{
+					c = *s++;
+					if (isupper(c))
+						c = tolower(c);
+					*b->re_cur++ = c;
+				}
+				break;
+			case REG_SUB_UPPER|REG_SUB_LOWER:
+				while (s < e)
+				{
+					c = *s++;
+					if (isupper(c))
+						c = tolower(c);
+					else if (islower(c))
+						c = toupper(c);
+					*b->re_cur++ = c;
+				}
+				break;
+			default:
+				while (s < e)
+					*b->re_cur++ = *s++;
+				break;
+			}
+			continue;
+		default:
+			NEED(p, b, op->len, return c);
+			s = b->re_rhs + op->off;
+			e = s + op->len;
+			while (s < e)
+				*b->re_cur++ = *s++;
+			continue;
+		}
+		break;
+	}
+	return 0;
+}
+
+/*
+ * ed(1) style substitute using matches from last regexec()
+ */
+
+int
+regsubexec(const regex_t* p, const char* s, size_t nmatch, regmatch_t* match)
+{
+	register int		c;
+	register regsub_t*	b;
+	const char*		e;
+	int			m;
+
+	if (!p->env->sub || (p->env->flags & REG_NOSUB) || !nmatch)
+		return fatal(p->env->disc, REG_BADPAT, NiL);
+	b = p->re_sub;
+	m = b->re_min;
+	b->re_cur = b->re_buf;
+	e = (const char*)p->env->end;
+	for (;;)
+	{
+		if (--m > 0)
+			PUTS(p, b, s, match->rm_eo, return fatal(p->env->disc, c, NiL));
+		else
+		{
+			PUTS(p, b, s, match->rm_so, return fatal(p->env->disc, c, NiL));
+			if (c = sub(p, b, s, b->re_ops, nmatch, match))
+				return fatal(p->env->disc, c, NiL);
+		}
+		s += match->rm_eo;
+		if (m <= 0 && !(b->re_flags & REG_SUB_ALL))
+			break;
+		if (c = regnexec(p, s, e - s, nmatch, match, p->env->flags|(match->rm_so == match->rm_eo ? REG_ADVANCE : 0)))
+		{
+			if (c != REG_NOMATCH)
+				return fatal(p->env->disc, c, NiL);
+			break;
+		}
+	}
+	while (s < e)
+	{
+		c = *s++;
+		PUTC(p, b, c, return fatal(p->env->disc, c, NiL));
+	}
+	NEED(p, b, 1, return fatal(p->env->disc, c, NiL));
+	*b->re_cur = 0;
+	b->re_len = b->re_cur - b->re_buf;
+	return 0;
+}
diff --git a/usr/src/lib/libast/common/regex/ucs_names.h b/usr/src/lib/libast/common/regex/ucs_names.h
new file mode 100644
index 0000000000..91c8a2aa91
--- /dev/null
+++ b/usr/src/lib/libast/common/regex/ucs_names.h
@@ -0,0 +1,6426 @@
+/***********************************************************************
+*                                                                      *
+*               This software is part of the ast package               *
+*           Copyright (c) 1985-2007 AT&T Knowledge Ventures            *
+*                      and is licensed under the                       *
+*                  Common Public License, Version 1.0                  *
+*                      by AT&T Knowledge Ventures                      *
+*                                                                      *
+*                A copy of the License is available at                 *
+*            http://www.opensource.org/licenses/cpl1.0.txt             *
+*         (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9)         *
+*                                                                      *
+*              Information and Software Systems Research               *
+*                            AT&T Research                             *
+*                           Florham Park NJ                            *
+*                                                                      *
+*                 Glenn Fowler <gsf@research.att.com>                  *
+*                  David Korn <dgk@research.att.com>                   *
+*                   Phong Vo <kpv@research.att.com>                    *
+*                                                                      *
+***********************************************************************/
+/* : : generated by ucs_names-index.c : : */
+
+/*
+ * ucs name and alias tables
+ * define UCS_BYTE for 8 bit ascii/latin only
+ */
+
+#include <ast_common.h>
+
+#define UCS_UC		1
+#define UCS_LC		2
+
+typedef uint16_t Ucs_code_t;
+typedef uint32_t Ucs_attr_t;
+
+typedef struct Ucs_dat_s
+{
+	Ucs_attr_t		attr[3];
+	Ucs_code_t		code;
+	Ucs_code_t		table;
+	Ucs_code_t		index;
+} Ucs_dat_t;
+
+static const char	ucs_strings_0[] = "\
+letter\0\
+with\0\
+and\0\
+digit\0\
+form\0\
+sign\0\
+capital\0\
+uc\0\
+small\0\
+lc\0\
+above\0\
+acute\0\
+alef\0\
+alpha\0\
+arabic\0\
+below\0\
+bopomofo\0\
+box\0\
+breve\0\
+caron\0\
+cedilla\0\
+circled\0\
+circumflex\0\
+cyrillic\0\
+dasia\0\
+diaeresis\0\
+dot\0\
+double\0\
+down\0\
+drawings\0\
+eta\0\
+final\0\
+full\0\
+grave\0\
+greek\0\
+heavy\0\
+hebrew\0\
+hiragana\0\
+hook\0\
+horizontal\0\
+horn\0\
+initial\0\
+iota\0\
+isolated\0\
+katakana\0\
+latin\0\
+left\0\
+light\0\
+line\0\
+macron\0\
+mark\0\
+medial\0\
+number\0\
+numeral\0\
+omega\0\
+one\0\
+oxia\0\
+parenthesized\0\
+perispomeni\0\
+prosgegrammeni\0\
+psili\0\
+right\0\
+roman\0\
+single\0\
+tilde\0\
+to\0\
+up\0\
+upsilon\0\
+varia\0\
+vertical\0\
+white\0\
+of\0\
+stop\0\
+"
+"black\0\
+fraction\0\
+vulgar\0\
+superscript\0\
+subscript\0\
+square\0\
+ligature\0\
+space\0\
+indic\0\
+ideograph\0\
+ideographic\0\
+equal\0\
+arrow\0\
+than\0\
+suit\0\
+or\0\
+bracket\0\
+ocr\0\
+half\0\
+end\0\
+big\0\
+byelorussian\0\
+inverted\0\
+middle\0\
+ogonek\0\
+ring\0\
+short\0\
+stroke\0\
+tonos\0\
+ukrainian\0\
+upturn\0\
+null\0\
+nul\0\
+nu\0\
+start heading\0\
+soh\0\
+sh\0\
+start text\0\
+stx\0\
+sx\0\
+text\0\
+etx\0\
+ex\0\
+transmission\0\
+eot\0\
+et\0\
+enquiry\0\
+enq\0\
+eq\0\
+acknowledge\0\
+ack\0\
+ak\0\
+bell\0\
+bel\0\
+bl\0\
+alert\0\
+backspace\0\
+bs\0\
+tabulation\0\
+tab\0\
+ht\0\
+feed\0\
+lf\0\
+newline\0\
+vt\0\
+ff\0\
+carriage return\0\
+cr\0\
+shift out\0\
+so\0\
+shift in\0\
+si\0\
+data link escape\0\
+dl\0\
+dle\0\
+"
+"device control\0\
+d1\0\
+dc1\0\
+device control two\0\
+d2\0\
+dc2\0\
+device control three\0\
+d3\0\
+dc3\0\
+device control four\0\
+d4\0\
+dc4\0\
+negative acknowledge\0\
+nak\0\
+nk\0\
+synchronous idle\0\
+sy\0\
+syn\0\
+transmission block\0\
+eb\0\
+etb\0\
+cancel\0\
+can\0\
+cn\0\
+medium\0\
+em\0\
+substitute\0\
+sb\0\
+sub\0\
+escape\0\
+ec\0\
+esc\0\
+file separator\0\
+fs\0\
+is4\0\
+group separator\0\
+gs\0\
+is3\0\
+intro\0\
+record separator\0\
+is2\0\
+rs\0\
+unit separator\0\
+is1\0\
+us\0\
+\0\
+sp\0\
+exclamation\0\
+quotation\0\
+nb\0\
+h-\0\
+dollar\0\
+do\0\
+!s\0\
+percent\0\
+ampersand\0\
+apostrophe\0\
+parenthesis\0\
+asterisk\0\
+plus\0\
+comma\0\
+hyphen minus\0\
+hyphen\0\
+period\0\
+solidus\0\
+slash\0\
+zero\0\
+two\0\
+three\0\
+four\0\
+five\0\
+six\0\
+"
+"seven\0\
+eight\0\
+nine\0\
+colon\0\
+semicolon\0\
+less\0\
+equals\0\
+greater\0\
+question\0\
+commercial at\0\
+at\0\
+oa\0\
+a\0\
+b\0\
+c\0\
+d\0\
+e\0\
+f\0\
+g\0\
+h\0\
+i\0\
+j\0\
+k\0\
+l\0\
+m\0\
+n\0\
+o\0\
+p\0\
+q\0\
+r\0\
+s\0\
+t\0\
+u\0\
+v\0\
+w\0\
+x\0\
+y\0\
+z\0\
+reverse solidus\0\
+backslash\0\
+)>\0\
+accent\0\
+hat\0\
+'>\0\
+low\0\
+underscore\0\
+'!\0\
+curly\0\
+brace\0\
+(!\0\
+bar\0\
+!)\0\
+'?e\0\
+delete\0\
+del\0\
+dt\0\
+padding character\0\
+pa\0\
+pad\0\
+high octet preset\0\
+ho\0\
+hop\0\
+break permitted here\0\
+bh\0\
+bph\0\
+no break here\0\
+nh\0\
+nbh\0\
+index\0\
+in\0\
+ind\0\
+next\0\
+nl\0\
+nel\0\
+start selected area\0\
+sa\0\
+ssa\0\
+selected area\0\
+es\0\
+esa\0\
+character tabulation set\0\
+hs\0\
+"
+"hts\0\
+character tabulation justification\0\
+hj\0\
+htj\0\
+tabulation set\0\
+vs\0\
+vts\0\
+partial forward\0\
+pd\0\
+pld\0\
+partial backward\0\
+pu\0\
+plu\0\
+reverse feed\0\
+ri\0\
+shift two\0\
+s2\0\
+ss2\0\
+shift three\0\
+s3\0\
+ss3\0\
+device control string\0\
+dc\0\
+dcs\0\
+private use\0\
+p1\0\
+pu1\0\
+private use two\0\
+p2\0\
+pu2\0\
+set transmit state\0\
+ts\0\
+sts\0\
+cancel character\0\
+cc\0\
+cch\0\
+message waiting\0\
+mw\0\
+start guarded area\0\
+sg\0\
+spa\0\
+guarded area\0\
+eg\0\
+epa\0\
+start string\0\
+sos\0\
+graphic character introducer\0\
+gc\0\
+sgci\0\
+character introducer\0\
+sc\0\
+sci\0\
+control sequence introducer\0\
+ci\0\
+csi\0\
+string terminator\0\
+st\0\
+operating system command\0\
+oc\0\
+osc\0\
+privacy message\0\
+pm\0\
+application program command\0\
+"
+"ac\0\
+apc\0\
+no break\0\
+ns\0\
+!i\0\
+cent\0\
+ct\0\
+!c\0\
+pound\0\
+l-\0\
+currency\0\
+cu\0\
+xo\0\
+yen\0\
+ye\0\
+y-\0\
+broken bar\0\
+bb\0\
+!b\0\
+section\0\
+se\0\
+':\0\
+copyright\0\
+co\0\
+feminine ordinal indicator\0\
+-a\0\
+pointing angle quotation\0\
+<<\0\
+not\0\
+no\0\
+7!\0\
+soft hyphen\0\
+--\0\
+registered\0\
+rg\0\
+'m\0\
+degree\0\
+dg\0\
+plus minus\0\
++-\0\
+2s\0\
+3s\0\
+micro\0\
+my\0\
+pilcrow\0\
+pi\0\
+9i\0\
+.m\0\
+',\0\
+1s\0\
+masculine ordinal indicator\0\
+-o\0\
+>>\0\
+quarter\0\
+14\0\
+12\0\
+three quarters\0\
+34\0\
+?i\0\
+a!\0\
+a'\0\
+a>\0\
+a?\0\
+a:\0\
+aa\0\
+ae\0\
+c,\0\
+e!\0\
+e'\0\
+e>\0\
+e:\0\
+i!\0\
+i'\0\
+i>\0\
+i:\0\
+eth\0\
+d-\0\
+n?\0\
+o!\0\
+o'\0\
+o>\0\
+o?\0\
+o:\0\
+"
+"multiplication\0\
+*x\0\
+o/\0\
+u!\0\
+u'\0\
+u>\0\
+u:\0\
+y'\0\
+thorn\0\
+th\0\
+sharp s\0\
+ss\0\
+division\0\
+-:\0\
+y:\0\
+";
+
+#if !UCS_BYTE
+static const char ucs_strings_1[] = "\
+a-\0\
+a(\0\
+a;\0\
+c'\0\
+c>\0\
+c.\0\
+c<\0\
+d<\0\
+d/\0\
+e-\0\
+e(\0\
+e.\0\
+e;\0\
+e<\0\
+g>\0\
+g(\0\
+g.\0\
+g,\0\
+h>\0\
+h/\0\
+i?\0\
+i-\0\
+i(\0\
+i;\0\
+i.\0\
+dotless i\0\
+ij\0\
+j>\0\
+k,\0\
+kra\0\
+kk\0\
+l'\0\
+l,\0\
+l<\0\
+l.\0\
+l/\0\
+n'\0\
+n,\0\
+n<\0\
+n preceded by apostrophe\0\
+'n\0\
+eng\0\
+ng\0\
+o-\0\
+o(\0\
+o\"\0\
+oe\0\
+r'\0\
+r,\0\
+r<\0\
+s'\0\
+s>\0\
+s,\0\
+s<\0\
+t,\0\
+t<\0\
+t/\0\
+u?\0\
+u-\0\
+u(\0\
+u0\0\
+u\"\0\
+u;\0\
+w>\0\
+y>\0\
+z'\0\
+z.\0\
+z<\0\
+long s\0\
+s1\0\
+b/\0\
+b2\0\
+c2\0\
+f2\0\
+k2\0\
+o9\0\
+oi\0\
+yr\0\
+u9\0\
+z/\0\
+ezh\0\
+ed\0\
+dz\0\
+dz<\0\
+d z\0\
+lj\0\
+lj3\0\
+l j\0\
+nj\0\
+nj3\0\
+n j\0\
+a<\0\
+i<\0\
+o<\0\
+u<\0\
+"
+"u:-\0\
+u:'\0\
+u:<\0\
+u:!\0\
+turned e\0\
+e1\0\
+a1\0\
+a7\0\
+a3\0\
+g/\0\
+g<\0\
+k<\0\
+o;\0\
+o1\0\
+ez\0\
+j<\0\
+dz3\0\
+g'\0\
+aa'\0\
+ae'\0\
+o/'\0\
+a!!\0\
+a)\0\
+e!!\0\
+e)\0\
+i!!\0\
+i)\0\
+o!!\0\
+o)\0\
+r!!\0\
+r)\0\
+u!!\0\
+u)\0\
+r long leg\0\
+r1\0\
+modifier turned comma\0\
+;s\0\
+modifier accent\0\
+1>\0\
+'<\0\
+modifier\0\
+1-\0\
+1!\0\
+'(\0\
+'.\0\
+'0\0\
+';\0\
+1?\0\
+'\"\0\
+combining accent\0\
+\"`\0\
+\"'\0\
+'g\0\
+lower\0\
+,g\0\
+ypogegrammeni\0\
+j3\0\
+?%\0\
+'*\0\
+dialytika\0\
+'%\0\
+a%\0\
+ano teleia\0\
+.*\0\
+epsilon\0\
+e%\0\
+y%\0\
+i%\0\
+omicron\0\
+o%\0\
+u%\0\
+w%\0\
+i3\0\
+a*\0\
+beta\0\
+b*\0\
+gamma\0\
+g*\0\
+delta\0\
+d*\0\
+e*\0\
+zeta\0\
+z*\0\
+y*\0\
+theta\0\
+h*\0\
+i*\0\
+"
+"kappa\0\
+k*\0\
+lamda\0\
+l*\0\
+mu\0\
+m*\0\
+n*\0\
+xi\0\
+c*\0\
+o*\0\
+p*\0\
+rho\0\
+r*\0\
+sigma\0\
+s*\0\
+tau\0\
+t*\0\
+u*\0\
+phi\0\
+f*\0\
+chi\0\
+x*\0\
+psi\0\
+q*\0\
+w*\0\
+j*\0\
+v*\0\
+u3\0\
+*s\0\
+beta symbol\0\
+b3\0\
+stigma\0\
+t3\0\
+digamma\0\
+m3\0\
+koppa\0\
+k3\0\
+sampi\0\
+p3\0\
+io\0\
+dje\0\
+d%\0\
+gje\0\
+g%\0\
+ie\0\
+dze\0\
+ds\0\
+ii\0\
+yi\0\
+je\0\
+j%\0\
+lje\0\
+nje\0\
+tshe\0\
+kje\0\
+kj\0\
+v%\0\
+dzhe\0\
+a=\0\
+be\0\
+b=\0\
+ve\0\
+v=\0\
+ghe\0\
+g=\0\
+de\0\
+d=\0\
+e=\0\
+zhe\0\
+z%\0\
+ze\0\
+z=\0\
+i=\0\
+j=\0\
+ka\0\
+k=\0\
+el\0\
+l=\0\
+m=\0\
+en\0\
+n=\0\
+o=\0\
+pe\0\
+p=\0\
+er\0\
+r=\0\
+s=\0\
+te\0\
+t=\0\
+u=\0\
+ef\0\
+f=\0\
+ha\0\
+h=\0\
+tse\0\
+c=\0\
+"
+"che\0\
+c%\0\
+sha\0\
+s%\0\
+shcha\0\
+hard\0\
+=\"\0\
+yeru\0\
+y=\0\
+soft\0\
+%\"\0\
+yu\0\
+ju\0\
+ya\0\
+ja\0\
+='\0\
+%'\0\
+yat\0\
+y3\0\
+yus\0\
+o3\0\
+fita\0\
+f3\0\
+izhitsa\0\
+v3\0\
+c3\0\
+g3\0\
+a+\0\
+bet\0\
+b+\0\
+gimel\0\
+g+\0\
+dalet\0\
+d+\0\
+he\0\
+h+\0\
+vav\0\
+w+\0\
+zayin\0\
+z+\0\
+het\0\
+x+\0\
+tet\0\
+tj\0\
+yod\0\
+j+\0\
+kaf\0\
+k%\0\
+k+\0\
+lamed\0\
+l+\0\
+mem\0\
+m%\0\
+m+\0\
+nun\0\
+n%\0\
+n+\0\
+samekh\0\
+s+\0\
+ayin\0\
+e+\0\
+p%\0\
+p+\0\
+tsadi\0\
+zj\0\
+qof\0\
+q+\0\
+resh\0\
+r+\0\
+shin\0\
+tav\0\
+t+\0\
+,+\0\
+;+\0\
+?+\0\
+hamza\0\
+h'\0\
+madda\0\
+am\0\
+ah\0\
+waw hamza\0\
+wh\0\
+yeh hamza\0\
+yh\0\
+beh\0\
+teh marbuta\0\
+tm\0\
+teh\0\
+theh\0\
+tk\0\
+jeem\0\
+hah\0\
+"
+"hk\0\
+khah\0\
+dal\0\
+thal\0\
+dk\0\
+reh\0\
+zain\0\
+seen\0\
+sheen\0\
+sn\0\
+sad\0\
+c+\0\
+dad\0\
+dd\0\
+tah\0\
+zah\0\
+zh\0\
+ain\0\
+ghain\0\
+i+\0\
+tatweel\0\
+++\0\
+feh\0\
+f+\0\
+qaf\0\
+lam\0\
+meem\0\
+noon\0\
+heh\0\
+waw\0\
+maksura\0\
+yeh\0\
+y+\0\
+fathatan\0\
+:+\0\
+dammatan\0\
+\"+\0\
+kasratan\0\
+=+\0\
+fatha\0\
+/+\0\
+damma\0\
+'+\0\
+kasra\0\
+1+\0\
+shadda\0\
+3+\0\
+sukun\0\
+0+\0\
+0a\0\
+1a\0\
+2a\0\
+3a\0\
+4a\0\
+5a\0\
+6a\0\
+7a\0\
+8a\0\
+9a\0\
+%a\0\
+as\0\
+peh\0\
+hah hamza\0\
+hh\0\
+tcheh\0\
+tc\0\
+jeh\0\
+veh\0\
+v+\0\
+gaf\0\
+gf\0\
+a-0\0\
+b.\0\
+b-.\0\
+b_\0\
+c,'\0\
+d.\0\
+d-.\0\
+d_\0\
+d,\0\
+d->\0\
+e-!\0\
+e-'\0\
+e->\0\
+e-?\0\
+e,(\0\
+f.\0\
+g-\0\
+h.\0\
+h-.\0\
+h:\0\
+"
+"h,\0\
+h-(\0\
+i-?\0\
+i:'\0\
+k'\0\
+k-.\0\
+k_\0\
+l-.\0\
+l--.\0\
+l_\0\
+l->\0\
+m'\0\
+m.\0\
+m-.\0\
+n.\0\
+n-.\0\
+n_\0\
+n->\0\
+o?'\0\
+o?:\0\
+o-!\0\
+o-'\0\
+p'\0\
+p.\0\
+r.\0\
+r-.\0\
+r--.\0\
+r_\0\
+s.\0\
+s-.\0\
+s'.\0\
+s<.\0\
+s.-.\0\
+t.\0\
+t-.\0\
+t_\0\
+t->\0\
+u--:\0\
+u-?\0\
+u->\0\
+u?'\0\
+u-:\0\
+v?\0\
+v-.\0\
+w!\0\
+w'\0\
+w:\0\
+w.\0\
+w-.\0\
+x.\0\
+x:\0\
+y.\0\
+z>\0\
+z-.\0\
+z_\0\
+a-.\0\
+a2\0\
+a>'\0\
+a>!\0\
+a>2\0\
+a>?\0\
+a>-.\0\
+a('\0\
+a(!\0\
+a(2\0\
+a(?\0\
+a(-.\0\
+e-.\0\
+e2\0\
+e?\0\
+e>'\0\
+e>!\0\
+e>2\0\
+e>?\0\
+e>-.\0\
+i2\0\
+i-.\0\
+o-.\0\
+o2\0\
+o>'\0\
+o>!\0\
+o>2\0\
+o>?\0\
+o>-.\0\
+o9'\0\
+o9!\0\
+o92\0\
+o9?\0\
+o9-.\0\
+u-.\0\
+u2\0\
+u9'\0\
+u9!\0\
+"
+"u92\0\
+u9?\0\
+u9-.\0\
+y!\0\
+y-.\0\
+y2\0\
+y?\0\
+a*,\0\
+a*;\0\
+a*,!\0\
+a*;!\0\
+a*,'\0\
+a*;'\0\
+a*,?\0\
+a*;?\0\
+e*,\0\
+e*;\0\
+e*,!\0\
+e*;!\0\
+e*,'\0\
+e*;'\0\
+y*,\0\
+y*;\0\
+y*,!\0\
+y*;!\0\
+y*,'\0\
+y*;'\0\
+y*,?\0\
+y*;?\0\
+i*,\0\
+i*;\0\
+i*,!\0\
+i*;!\0\
+i*,'\0\
+i*;'\0\
+i*,?\0\
+i*;?\0\
+o*,\0\
+o*;\0\
+o*,!\0\
+o*;!\0\
+o*,'\0\
+o*;'\0\
+u*,\0\
+u*;\0\
+u*,!\0\
+u*;!\0\
+u*,'\0\
+u*;'\0\
+u*,?\0\
+u*;?\0\
+w*,\0\
+w*;\0\
+w*,!\0\
+w*;!\0\
+w*,'\0\
+w*;'\0\
+w*,?\0\
+w*;?\0\
+a*!\0\
+a*'\0\
+e*!\0\
+e*'\0\
+y*!\0\
+y*'\0\
+i*!\0\
+i*'\0\
+o*!\0\
+o*'\0\
+u*!\0\
+u*'\0\
+w*!\0\
+w*'\0\
+a*,j\0\
+a*;j\0\
+a*,!j\0\
+a*;!j\0\
+a*,'j\0\
+a*;'j\0\
+a*,?j\0\
+a*;?j\0\
+y*,j\0\
+y*;j\0\
+y*,!j\0\
+y*;!j\0\
+y*,'j\0\
+"
+"y*;'j\0\
+y*,?j\0\
+y*;?j\0\
+w*,j\0\
+w*;j\0\
+w*,!j\0\
+w*;!j\0\
+w*,'j\0\
+w*;'j\0\
+w*,?j\0\
+w*;?j\0\
+vrachy\0\
+a*(\0\
+a*-\0\
+a*!j\0\
+a*j\0\
+a*'j\0\
+a*?\0\
+a*?j\0\
+koronis\0\
+)*\0\
+,,\0\
+?*\0\
+?:\0\
+y*!j\0\
+y*j\0\
+y*'j\0\
+y*?\0\
+y*?j\0\
+e*!!\0\
+,!\0\
+,'\0\
+?,\0\
+i*(\0\
+i*-\0\
+i*:!\0\
+i*:'\0\
+i*?\0\
+i*:?\0\
+;!\0\
+;'\0\
+?;\0\
+u*(\0\
+u*-\0\
+u*:!\0\
+u*:'\0\
+r*,\0\
+r*;\0\
+u*?\0\
+u*:?\0\
+!:\0\
+:'\0\
+!*\0\
+w*!j\0\
+w*j\0\
+w*'j\0\
+w*?\0\
+w*?j\0\
+/*\0\
+;;\0\
+1n\0\
+1m\0\
+three per em\0\
+3m\0\
+four per em\0\
+4m\0\
+six per em\0\
+6m\0\
+thin\0\
+1t\0\
+hair\0\
+1h\0\
+lr\0\
+rl\0\
+en dash\0\
+-n\0\
+em dash\0\
+-m\0\
+-3\0\
+!2\0\
+=2\0\
+'6\0\
+'9\0\
+low-9 quotation\0\
+.9\0\
+"
+"high reversed-9 quotation\0\
+9'\0\
+\"6\0\
+\"9\0\
+:9\0\
+9\"\0\
+dagger\0\
+/-\0\
+/=\0\
+bullet\0\
+triangular bullet\0\
+3b\0\
+two leader\0\
+..\0\
+ellipsis\0\
+.3\0\
+hyphenation point\0\
+.-\0\
+separator\0\
+linesep\0\
+paragraph separator\0\
+parsep\0\
+per mille\0\
+%0\0\
+prime\0\
+1'\0\
+2'\0\
+triple prime\0\
+3'\0\
+reversed prime\0\
+1\"\0\
+2\"\0\
+reversed triple prime\0\
+3\"\0\
+caret\0\
+ca\0\
+<1\0\
+>1\0\
+reference\0\
+:x\0\
+!*2\0\
+overline\0\
+'-\0\
+hyphen bullet\0\
+-b\0\
+/f\0\
+0s\0\
+4s\0\
+5s\0\
+6s\0\
+7s\0\
+8s\0\
+9s\0\
++s\0\
+minus\0\
+-s\0\
+=s\0\
+(s\0\
+)s\0\
+french franc\0\
+lira\0\
+peseta\0\
+won\0\
+w=\0\
+euro\0\
+combining harpoon\0\
+\"7\0\
+degree celsius\0\
+care\0\
+degree fahrenheit\0\
+numero\0\
+n0\0\
+sound recording copyright\0\
+po\0\
+"
+"prescription take\0\
+rx\0\
+service\0\
+sm\0\
+trade\0\
+ohm\0\
+om\0\
+angstrom\0\
+ao\0\
+estimated symbol\0\
+est\0\
+third\0\
+13\0\
+two thirds\0\
+23\0\
+fifth\0\
+15\0\
+two fifths\0\
+25\0\
+three fifths\0\
+35\0\
+four fifths\0\
+45\0\
+sixth\0\
+16\0\
+five sixths\0\
+56\0\
+eighth\0\
+18\0\
+three eighths\0\
+38\0\
+five eighths\0\
+58\0\
+seven eighths\0\
+78\0\
+1r\0\
+2r\0\
+3r\0\
+4r\0\
+5r\0\
+6r\0\
+7r\0\
+8r\0\
+9r\0\
+ten\0\
+ar\0\
+eleven\0\
+br\0\
+twelve\0\
+fifty\0\
+50r\0\
+hundred\0\
+100r\0\
+five hundred\0\
+500r\0\
+thousand\0\
+1000r\0\
+thousand c d\0\
+1000rcd\0\
+five thousand\0\
+5000r\0\
+ten thousand\0\
+10000r\0\
+leftwards\0\
+<-\0\
+upwards\0\
+-!\0\
+rightwards\0\
+->\0\
+downwards\0\
+-v\0\
+<>\0\
+ud\0\
+north west\0\
+<!!\0\
+north east\0\
+"
+"//>\0\
+south east\0\
+!!>\0\
+south west\0\
+<//\0\
+base\0\
+ud-\0\
+rightwards harpoon barb upwards\0\
+>v\0\
+<=\0\
+=>\0\
+==\0\
+for all\0\
+fa\0\
+partial differential\0\
+dp\0\
+there exists\0\
+empty set\0\
+/0\0\
+increment\0\
+nabla\0\
+element\0\
+(-\0\
+contains as member\0\
+-)\0\
+proof\0\
+fp\0\
+n ary product\0\
+*p\0\
+n ary summation\0\
++z\0\
+-2\0\
+minus plus\0\
+-+\0\
+.+\0\
+asterisk operator\0\
+*-\0\
+operator\0\
+ob\0\
+bullet operator\0\
+root\0\
+rt\0\
+proportional\0\
+0(\0\
+infinity\0\
+00\0\
+angle\0\
+-l\0\
+parallel\0\
+pp\0\
+logical\0\
+an\0\
+intersection\0\
+(u\0\
+union\0\
+)u\0\
+integral\0\
+di\0\
+contour integral\0\
+therefore\0\
+.:\0\
+because\0\
+:.\0\
+ratio\0\
+:r\0\
+proportion\0\
+::\0\
+?1\0\
+lazy s\0\
+cg\0\
+asymptotically\0\
+"
+"?-\0\
+approximately\0\
+?=\0\
+almost\0\
+?2\0\
+all\0\
+=?\0\
+image approximately\0\
+hi\0\
+!=\0\
+identical\0\
+=3\0\
+=<\0\
+>=\0\
+much less\0\
+<*\0\
+much greater\0\
+*>\0\
+not less\0\
+!<\0\
+not greater\0\
+!>\0\
+subset\0\
+(c\0\
+superset\0\
+)c\0\
+(_\0\
+)_\0\
+0.\0\
+02\0\
+tack\0\
+-t\0\
+.p\0\
+:3\0\
+house\0\
+eh\0\
+ceiling\0\
+<7\0\
+>7\0\
+floor\0\
+7<\0\
+7>\0\
+reversed not\0\
+ni\0\
+arc\0\
+(a\0\
+telephone recorder\0\
+tr\0\
+place interest\0\
+88\0\
+top integral\0\
+iu\0\
+bottom integral\0\
+il\0\
+pointing angle\0\
+</\0\
+/>\0\
+open\0\
+chair\0\
+3h\0\
+fork\0\
+2h\0\
+4h\0\
+branch bank identification\0\
+1j\0\
+amount check\0\
+2j\0\
+dash\0\
+3j\0\
+customer account\0\
+4j\0\
+1-o\0\
+2-o\0\
+3-o\0\
+4-o\0\
+5-o\0\
+6-o\0\
+"
+"7-o\0\
+8-o\0\
+9-o\0\
+10-o\0\
+11-o\0\
+12-o\0\
+thirteen\0\
+13-o\0\
+fourteen\0\
+14-o\0\
+fifteen\0\
+15-o\0\
+sixteen\0\
+16-o\0\
+seventeen\0\
+17-o\0\
+eighteen\0\
+18-o\0\
+nineteen\0\
+19-o\0\
+twenty\0\
+20-o\0\
+(1)\0\
+(2)\0\
+(3)\0\
+(4)\0\
+(5)\0\
+(6)\0\
+(7)\0\
+(8)\0\
+(9)\0\
+(10)\0\
+(11)\0\
+(12)\0\
+(13)\0\
+(14)\0\
+(15)\0\
+(16)\0\
+(17)\0\
+(18)\0\
+(19)\0\
+(20)\0\
+1.\0\
+2.\0\
+3.\0\
+4.\0\
+5.\0\
+6.\0\
+7.\0\
+8.\0\
+9.\0\
+10.\0\
+11.\0\
+12.\0\
+13.\0\
+14.\0\
+15.\0\
+16.\0\
+17.\0\
+18.\0\
+19.\0\
+20.\0\
+(a)\0\
+(b)\0\
+(c)\0\
+(d)\0\
+(e)\0\
+(f)\0\
+(g)\0\
+(h)\0\
+(i)\0\
+(j)\0\
+(k)\0\
+(l)\0\
+(m)\0\
+(n)\0\
+(o)\0\
+(p)\0\
+(q)\0\
+(r)\0\
+(s)\0\
+(t)\0\
+(u)\0\
+(v)\0\
+(w)\0\
+(x)\0\
+(y)\0\
+"
+"(z)\0\
+a o\0\
+b o\0\
+c o\0\
+d o\0\
+e o\0\
+f o\0\
+g o\0\
+h o\0\
+i o\0\
+j o\0\
+k o\0\
+l o\0\
+m o\0\
+n o\0\
+o o\0\
+p o\0\
+q o\0\
+r o\0\
+s o\0\
+t o\0\
+u o\0\
+v o\0\
+w o\0\
+x o\0\
+y o\0\
+z o\0\
+0-o\0\
+_-\0\
+hh-\0\
+_=\0\
+vv\0\
+_!\0\
+vv-\0\
+triple dash\0\
+3-\0\
+3_\0\
+3!\0\
+3/\0\
+quadruple dash\0\
+4-\0\
+4_\0\
+4!\0\
+4/\0\
+dr\0\
+_v>\0\
+dr-\0\
+_v<w\0\
+dl-\0\
+ld-\0\
+ur\0\
+_a>\0\
+ur-\0\
+ul\0\
+_a<\0\
+ul-\0\
+vr\0\
+_!>\0\
+vr-\0\
+udr\0\
+vl\0\
+_!<\0\
+vl-\0\
+udl\0\
+dh\0\
+_v-\0\
+dlr\0\
+dh-\0\
+uh\0\
+_-a\0\
+ulr\0\
+uh-\0\
+vh\0\
+_!-\0\
+vlr\0\
+vh-\0\
+udh\0\
+udlr\0\
+ld\0\
+diagonal upper lower\0\
+fd\0\
+_>/\0\
+bd\0\
+upper block\0\
+tb\0\
+lower block\0\
+lb\0\
+block\0\
+fb\0\
+"
+"rb\0\
+shade\0\
+.s\0\
+medium shade\0\
+:s\0\
+dark shade\0\
+?s\0\
+os\0\
+rounded corners\0\
+ro\0\
+containing\0\
+rr\0\
+fill\0\
+rf\0\
+ry\0\
+orthogonal crosshatch fill\0\
+rh\0\
+upper lower fill\0\
+rz\0\
+rk\0\
+diagonal crosshatch fill\0\
+rectangle\0\
+sr\0\
+pointing triangle\0\
+ut\0\
+pointing pointer\0\
+pr\0\
+tl\0\
+pl\0\
+diamond\0\
+db\0\
+dw\0\
+lozenge\0\
+lz\0\
+circle\0\
+0m\0\
+bullseye\0\
+0o\0\
+0l\0\
+0r\0\
+inverse bullet\0\
+inverse circle\0\
+ic\0\
+lower triangle\0\
+_.>/\0\
+large circle\0\
+star\0\
+*2\0\
+*1\0\
+telephone\0\
+tel\0\
+pointing index\0\
+<h\0\
+>h\0\
+smiling face\0\
+0u\0\
+sun rays\0\
+su\0\
+female\0\
+fm\0\
+male\0\
+ml\0\
+spade\0\
+cs\0\
+heart\0\
+ch\0\
+cd\0\
+club\0\
+cs-\0\
+ch-\0\
+cd-\0\
+cc-\0\
+quarter note\0\
+"
+"md\0\
+eighth note\0\
+m8\0\
+_d!\0\
+beamed eighth notes\0\
+m2\0\
+beamed sixteenth notes\0\
+m16\0\
+music flat\0\
+mb\0\
+music natural\0\
+mx\0\
+music sharp\0\
+check\0\
+ok\0\
+ballot x\0\
+xx\0\
+maltese cross\0\
+-x\0\
+is\0\
+,_\0\
+._\0\
+ditto\0\
++\"\0\
+japanese industrial standard symbol\0\
+jis\0\
+iteration\0\
+*_\0\
+closing\0\
+;_\0\
+0_\0\
+<+\0\
+>+\0\
+corner\0\
+<'\0\
+>'\0\
+<\"\0\
+>\"\0\
+lenticular\0\
+(\"\0\
+)\"\0\
+postal\0\
+=t\0\
+geta\0\
+=_\0\
+tortoise shell\0\
+('\0\
+)'\0\
+(i\0\
+)i\0\
+wave dash\0\
+-?\0\
+postal face\0\
+=t:)\0\
+a5\0\
+i5\0\
+u5\0\
+e5\0\
+o5\0\
+ga\0\
+ki\0\
+gi\0\
+ku\0\
+gu\0\
+ke\0\
+ge\0\
+ko\0\
+go\0\
+za\0\
+zi\0\
+zu\0\
+zo\0\
+ta\0\
+da\0\
+ti\0\
+tu\0\
+du\0\
+na\0\
+ne\0\
+ba\0\
+bi\0\
+"
+"hu\0\
+bu\0\
+bo\0\
+ma\0\
+mi\0\
+me\0\
+mo\0\
+yo\0\
+ra\0\
+ru\0\
+re\0\
+wa\0\
+wi\0\
+we\0\
+wo\0\
+n5\0\
+vu\0\
+voiced sound\0\
+\"5\0\
+semi voiced sound\0\
+05\0\
+*5\0\
+voiced iteration\0\
++5\0\
+a6\0\
+i6\0\
+u6\0\
+e6\0\
+o6\0\
+n6\0\
+va\0\
+vi\0\
+vo\0\
+.6\0\
+prolonged sound\0\
+-6\0\
+*6\0\
++6\0\
+b4\0\
+p4\0\
+m4\0\
+f4\0\
+t4\0\
+n4\0\
+l4\0\
+g4\0\
+k4\0\
+h4\0\
+j4\0\
+q4\0\
+x4\0\
+r4\0\
+z4\0\
+c4\0\
+s4\0\
+a4\0\
+o4\0\
+e4\0\
+eh4\0\
+ai\0\
+ei\0\
+au\0\
+ou\0\
+ang\0\
+i4\0\
+u4\0\
+v4\0\
+gn\0\
+hangul cieuc u\0\
+(ju)\0\
+1c\0\
+2c\0\
+3c\0\
+4c\0\
+5c\0\
+6c\0\
+7c\0\
+8c\0\
+9c\0\
+10c\0\
+korean standard symbol\0\
+ksc\0\
+fi\0\
+fl\0\
+ffi\0\
+ffl\0\
+long s t\0\
+3+;\0\
+h'-\0\
+am-\0\
+"
+"am.\0\
+ah-\0\
+ah.\0\
+wh-\0\
+yh,\0\
+a+-\0\
+a+.\0\
+b+-\0\
+b+.\0\
+b+,\0\
+b+;\0\
+tm-\0\
+tm.\0\
+t+-\0\
+t+.\0\
+t+,\0\
+t+;\0\
+tk-\0\
+tk.\0\
+tk,\0\
+tk;\0\
+g+-\0\
+g+.\0\
+g+,\0\
+g+;\0\
+hk-\0\
+hk.\0\
+hk,\0\
+hk;\0\
+x+-\0\
+x+.\0\
+x+,\0\
+x+;\0\
+d+-\0\
+d+.\0\
+dk-\0\
+dk.\0\
+r+-\0\
+r+.\0\
+z+-\0\
+z+.\0\
+s+-\0\
+s+.\0\
+s+,\0\
+s+;\0\
+sn-\0\
+sn.\0\
+sn,\0\
+sn;\0\
+c+-\0\
+c+.\0\
+c+,\0\
+c+;\0\
+dd-\0\
+dd.\0\
+dd,\0\
+dd;\0\
+tj-\0\
+tj.\0\
+tj,\0\
+tj;\0\
+zh-\0\
+zh.\0\
+zh,\0\
+zh;\0\
+e+-\0\
+e+.\0\
+e+,\0\
+e+;\0\
+i+-\0\
+i+.\0\
+i+,\0\
+i+;\0\
+f+-\0\
+f+.\0\
+f+,\0\
+f+;\0\
+q+-\0\
+q+.\0\
+q+,\0\
+q+;\0\
+k+-\0\
+k+.\0\
+k+,\0\
+k+;\0\
+l+-\0\
+l+.\0\
+l+,\0\
+l+;\0\
+m+-\0\
+m+.\0\
+"
+"m+,\0\
+m+;\0\
+n+-\0\
+n+.\0\
+n+,\0\
+n+;\0\
+h+-\0\
+h+.\0\
+h+,\0\
+h+;\0\
+w+-\0\
+w+.\0\
+j+-\0\
+j+.\0\
+y+-\0\
+y+.\0\
+y+,\0\
+y+;\0\
+lam madda\0\
+lm-\0\
+lm.\0\
+lam hamza\0\
+lh-\0\
+lh.\0\
+la-\0\
+la.\0\
+";
+#endif /* UCS_BYTE */
+
+static const char*	ucs_strings[] =
+{
+	&ucs_strings_0[0],
+#if !UCS_BYTE
+	&ucs_strings_1[0],
+#endif /* UCS_BYTE */
+};
+
+static const Ucs_dat_t	ucs_attrs[] =
+{
+	{{0x00000001,0x00000000,0x00000000},0x0000,0,0},
+	{{0x00000001,0x00000000,0x00000000},0x0000,0,7},
+	{{0x00000001,0x00000000,0x00000000},0x0000,0,12},
+	{{0x00000001,0x00000000,0x00000000},0x0000,0,16},
+	{{0x00000001,0x00000000,0x00000000},0x0000,0,22},
+	{{0x00000001,0x00000000,0x00000000},0x0000,0,27},
+	{{0x00000002,0x00000000,0x00000000},0x0001,0,32},
+	{{0x00000002,0x00000000,0x00000000},0x0001,0,40},
+	{{0x00000004,0x00000000,0x00000000},0x0002,0,43},
+	{{0x00000004,0x00000000,0x00000000},0x0002,0,49},
+	{{0x00000008,0x00000000,0x00000000},0x0003,0,52},
+	{{0x00000010,0x00000000,0x00000000},0x0004,0,58},
+	{{0x00000020,0x00000000,0x00000000},0x0005,0,64},
+	{{0x00000040,0x00000000,0x00000000},0x0006,0,69},
+	{{0x00000080,0x00000000,0x00000000},0x0007,0,75},
+	{{0x00000100,0x00000000,0x00000000},0x0008,0,82},
+	{{0x00000200,0x00000000,0x00000000},0x0009,0,88},
+	{{0x00000400,0x00000000,0x00000000},0x000a,0,97},
+	{{0x00000800,0x00000000,0x00000000},0x000b,0,101},
+	{{0x00001000,0x00000000,0x00000000},0x000c,0,107},
+	{{0x00002000,0x00000000,0x00000000},0x000d,0,113},
+	{{0x00004000,0x00000000,0x00000000},0x000e,0,121},
+	{{0x00008000,0x00000000,0x00000000},0x000f,0,129},
+	{{0x00010000,0x00000000,0x00000000},0x0010,0,140},
+	{{0x00020000,0x00000000,0x00000000},0x0011,0,149},
+	{{0x00040000,0x00000000,0x00000000},0x0012,0,155},
+	{{0x00080000,0x00000000,0x00000000},0x0013,0,165},
+	{{0x00100000,0x00000000,0x00000000},0x0014,0,169},
+	{{0x00200000,0x00000000,0x00000000},0x0015,0,176},
+	{{0x00400000,0x00000000,0x00000000},0x0016,0,181},
+	{{0x00800000,0x00000000,0x00000000},0x0017,0,190},
+	{{0x01000000,0x00000000,0x00000000},0x0018,0,194},
+	{{0x02000000,0x00000000,0x00000000},0x0019,0,200},
+	{{0x04000000,0x00000000,0x00000000},0x001a,0,205},
+	{{0x08000000,0x00000000,0x00000000},0x001b,0,211},
+	{{0x10000000,0x00000000,0x00000000},0x001c,0,217},
+	{{0x20000000,0x00000000,0x00000000},0x001d,0,223},
+	{{0x40000000,0x00000000,0x00000000},0x001e,0,230},
+	{{0x80000000,0x00000000,0x00000000},0x001f,0,239},
+	{{0x00000000,0x00000001,0x00000000},0x0020,0,244},
+	{{0x00000000,0x00000002,0x00000000},0x0021,0,255},
+	{{0x00000000,0x00000004,0x00000000},0x0022,0,260},
+	{{0x00000000,0x00000008,0x00000000},0x0023,0,268},
+	{{0x00000000,0x00000010,0x00000000},0x0024,0,273},
+	{{0x00000000,0x00000020,0x00000000},0x0025,0,282},
+	{{0x00000000,0x00000040,0x00000000},0x0026,0,291},
+	{{0x00000000,0x00000080,0x00000000},0x0027,0,297},
+	{{0x00000000,0x00000100,0x00000000},0x0028,0,302},
+	{{0x00000000,0x00000200,0x00000000},0x0029,0,308},
+	{{0x00000000,0x00000400,0x00000000},0x002a,0,313},
+	{{0x00000000,0x00000800,0x00000000},0x002b,0,320},
+	{{0x00000000,0x00001000,0x00000000},0x002c,0,325},
+	{{0x00000000,0x00002000,0x00000000},0x002d,0,332},
+	{{0x00000000,0x00004000,0x00000000},0x002e,0,339},
+	{{0x00000000,0x00008000,0x00000000},0x002f,0,347},
+	{{0x00000000,0x00010000,0x00000000},0x0030,0,353},
+	{{0x00000000,0x00020000,0x00000000},0x0031,0,357},
+	{{0x00000000,0x00040000,0x00000000},0x0032,0,362},
+	{{0x00000000,0x00080000,0x00000000},0x0033,0,376},
+	{{0x00000000,0x00100000,0x00000000},0x0034,0,388},
+	{{0x00000000,0x00200000,0x00000000},0x0035,0,403},
+	{{0x00000000,0x00400000,0x00000000},0x0036,0,409},
+	{{0x00000000,0x00800000,0x00000000},0x0037,0,415},
+	{{0x00000000,0x01000000,0x00000000},0x0038,0,421},
+	{{0x00000000,0x02000000,0x00000000},0x0039,0,428},
+	{{0x00000000,0x04000000,0x00000000},0x003a,0,434},
+	{{0x00000000,0x08000000,0x00000000},0x003b,0,437},
+	{{0x00000000,0x10000000,0x00000000},0x003c,0,440},
+	{{0x00000000,0x20000000,0x00000000},0x003d,0,448},
+	{{0x00000000,0x40000000,0x00000000},0x003e,0,454},
+	{{0x00000000,0x80000000,0x00000000},0x003f,0,463},
+	{{0x00000000,0x00000000,0x00000001},0x0040,0,469},
+	{{0x00000000,0x00000000,0x00000002},0x0041,0,472},
+	{{0x00000000,0x00000000,0x00000004},0x0042,0,477},
+	{{0x00000000,0x00000000,0x00000008},0x0043,0,483},
+	{{0x00000000,0x00000000,0x00000010},0x0044,0,492},
+	{{0x00000000,0x00000000,0x00000020},0x0045,0,499},
+	{{0x00000000,0x00000000,0x00000040},0x0046,0,511},
+	{{0x00000000,0x00000000,0x00000080},0x0047,0,521},
+	{{0x00000000,0x00000000,0x00000100},0x0048,0,528},
+	{{0x00000000,0x00000000,0x00000200},0x0049,0,537},
+	{{0x00000000,0x00000000,0x00000400},0x004a,0,543},
+	{{0x00000000,0x00000000,0x00000800},0x004b,0,549},
+	{{0x00000000,0x00000000,0x00000800},0x004b,0,559},
+	{{0x00000000,0x00000000,0x00001000},0x004c,0,571},
+	{{0x00000000,0x00000000,0x00002000},0x004d,0,577},
+	{{0x00000000,0x00000000,0x00004000},0x004e,0,583},
+	{{0x00000000,0x00000000,0x00008000},0x004f,0,588},
+	{{0x00000000,0x00000000,0x00010000},0x0050,0,593},
+	{{0x00000000,0x00000000,0x00020000},0x0051,0,596},
+	{{0x00000000,0x00000000,0x00040000},0x0052,0,604},
+	{{0x00000000,0x00000000,0x00080000},0x0053,0,608},
+	{{0x00000000,0x00000000,0x00100000},0x0054,0,613},
+	{{0x00000000,0x00000000,0x00200000},0x0055,0,617},
+	{{0x00000000,0x00000000,0x00400000},0x0056,0,621},
+	{{0x00000000,0x00000000,0x00800000},0x0057,0,634},
+	{{0x00000000,0x00000000,0x01000000},0x0058,0,643},
+	{{0x00000000,0x00000000,0x02000000},0x0059,0,650},
+	{{0x00000000,0x00000000,0x04000000},0x005a,0,657},
+	{{0x00000000,0x00000000,0x08000000},0x005b,0,662},
+	{{0x00000000,0x00000000,0x10000000},0x005c,0,668},
+	{{0x00000000,0x00000000,0x20000000},0x005d,0,675},
+	{{0x00000000,0x00000000,0x40000000},0x005e,0,681},
+	{{0x00000000,0x00000000,0x80000000},0x005f,0,691},
+};
+
+static const Ucs_dat_t	ucs_names[] =
+{
+	{{0x00000000,0x00000000,0x00000200},0x0020,0,1288},
+	{{0x00000001,0x00002000,0x00000000},0x0023,0,1288},
+	{{0x00080000,0x00000000,0x00000000},0x002e,0,1288},
+	{{0x00000001,0x00010000,0x00000000},0x0031,0,1288},
+	{{0x00008000,0x00000000,0x00000000},0x005e,0,1288},
+	{{0x00000000,0x02000000,0x00000000},0x007e,0,1288},
+	{{0x00040000,0x00000000,0x00000000},0x00a8,0,1288},
+	{{0x00000000,0x00000400,0x00000000},0x00af,0,1288},
+	{{0x00002000,0x00000000,0x00000000},0x00b8,0,1288},
+	{{0x02000000,0x00000000,0x00000002},0x002e,0,1288},
+	{{0x00000000,0x40000200,0x00000000},0x007c,0,1288},
+	{{0x00080000,0x00000000,0x01000000},0x00b7,0,1288},
+	{{0x00000000,0x00010000,0x00000020},0x00b9,0,1288},
+	{{0x00000000,0x00400000,0x00020080},0x005d,0,1288},
+	{{0x00000000,0x00010000,0x00080018},0x00bd,0,1288},
+	{{0x00000000,0x00000000,0x00000000},0x007d,0,1678},
+	{{0x00000000,0x00000000,0x00000000},0x00a6,0,2550},
+	{{0x00000000,0x00000000,0x00000000},0x00a2,0,2499},
+	{{0x00000000,0x00000000,0x00000000},0x00a1,0,2488},
+	{{0x00000000,0x00000000,0x00000000},0x0024,0,1330},
+	{{0x00000000,0x00000000,0x00000000},0x0060,0,1656},
+	{{0x00000000,0x00000000,0x00000000},0x00b8,0,2736},
+	{{0x00000000,0x00000000,0x00000000},0x00a8,0,2564},
+	{{0x00000000,0x00000000,0x00000000},0x005e,0,1638},
+	{{0x00000000,0x00000000,0x00000000},0x007e,0,1681},
+	{{0x00000000,0x00000000,0x00000000},0x00af,0,2677},
+	{{0x00000000,0x00000000,0x00000000},0x007b,0,1671},
+	{{0x00000000,0x00000000,0x00000000},0x005d,0,1624},
+	{{0x00000000,0x00000000,0x00000000},0x00d7,0,2899},
+	{{0x00000000,0x00000000,0x00000000},0x00b1,0,2701},
+	{{0x00000000,0x00000000,0x00000000},0x00ad,0,2660},
+	{{0x00000000,0x00000000,0x00000000},0x00f7,0,2949},
+	{{0x00000000,0x00000000,0x00000000},0x00aa,0,2607},
+	{{0x00000000,0x00000000,0x00000000},0x00ba,0,2770},
+	{{0x00000000,0x00000000,0x00000000},0x00b7,0,2733},
+	{{0x00000000,0x00000000,0x00000000},0x00bd,0,2787},
+	{{0x00000000,0x00000000,0x00000000},0x00bc,0,2784},
+	{{0x00000000,0x00000000,0x00000000},0x00b9,0,2739},
+	{{0x00000000,0x00000000,0x00000000},0x00b2,0,2704},
+	{{0x00000000,0x00000000,0x00000000},0x00be,0,2805},
+	{{0x00000000,0x00000000,0x00000000},0x00b3,0,2707},
+	{{0x00000000,0x00000000,0x00000000},0x00ac,0,2645},
+	{{0x00000000,0x00000000,0x00000000},0x00b6,0,2730},
+	{{0x00000000,0x00000000,0x00000000},0x00ab,0,2635},
+	{{0x00000000,0x00000000,0x00000000},0x00bb,0,2773},
+	{{0x00000000,0x00000000,0x00000000},0x00bf,0,2808},
+	{{0x00000003,0x00000040,0x00000000},0x0041,0,1546},
+	{{0x00000005,0x00000040,0x00000000},0x0061,0,1546},
+	{{0x04000003,0x00000040,0x00000000},0x00c0,0,1546},
+	{{0x00000013,0x00000040,0x00000000},0x00c1,0,1546},
+	{{0x00008003,0x00000040,0x00000000},0x00c2,0,1546},
+	{{0x00000003,0x02000040,0x00000000},0x00c3,0,1546},
+	{{0x00040003,0x00000040,0x00000000},0x00c4,0,1546},
+	{{0x04000005,0x00000040,0x00000000},0x00e0,0,1546},
+	{{0x00000015,0x00000040,0x00000000},0x00e1,0,1546},
+	{{0x00008005,0x00000040,0x00000000},0x00e2,0,1546},
+	{{0x00000005,0x02000040,0x00000000},0x00e3,0,1546},
+	{{0x00040005,0x00000040,0x00000000},0x00e4,0,1546},
+	{{0x0000000b,0x00000040,0x04000000},0x00c5,0,1546},
+	{{0x0000000d,0x00000040,0x04000000},0x00e5,0,1546},
+	{{0x00000000,0x00000000,0x00000000},0x00c0,0,2811},
+	{{0x00000000,0x00000000,0x00000000},0x00e0,0,2811},
+	{{0x00000000,0x00000000,0x00000000},0x00c1,0,2814},
+	{{0x00000000,0x00000000,0x00000000},0x00e1,0,2814},
+	{{0x00000000,0x00000000,0x00000000},0x00c4,0,2823},
+	{{0x00000000,0x00000000,0x00000000},0x00e4,0,2823},
+	{{0x00000000,0x00000000,0x00000000},0x00c2,0,2817},
+	{{0x00000000,0x00000000,0x00000000},0x00e2,0,2817},
+	{{0x00000000,0x00000000,0x00000000},0x00c3,0,2820},
+	{{0x00000000,0x00000000,0x00000000},0x00e3,0,2820},
+	{{0x00000000,0x00000000,0x00000000},0x00c5,0,2826},
+	{{0x00000000,0x00000000,0x00000000},0x00e5,0,2826},
+	{{0x00000000,0x00000000,0x00000000},0x009f,0,2469},
+	{{0x00008000,0x00000000,0x00000000},0x005e,0,1627},
+	{{0x04000000,0x00000000,0x00000000},0x0060,0,1627},
+	{{0x00000010,0x00000000,0x00000000},0x00b4,0,1627},
+	{{0x00000000,0x00000000,0x00000000},0x0006,0,808},
+	{{0x00000000,0x00000000,0x00000000},0x0006,0,796},
+	{{0x00000000,0x00000000,0x00000000},0x00c6,0,2829},
+	{{0x00000000,0x00000000,0x00000000},0x00e6,0,2829},
+	{{0x00000003,0x00000040,0x00000000},0x00c6,0,2829},
+	{{0x00000005,0x00000040,0x00000000},0x00e6,0,2829},
+	{{0x00000000,0x00000000,0x00000000},0x0006,0,812},
+	{{0x00000000,0x00000000,0x00000000},0x0007,0,827},
+	{{0x00000000,0x00000000,0x00000000},0x0026,0,1341},
+	{{0x00000000,0x00000000,0x00000000},0x009f,0,2472},
+	{{0x00000000,0x00000000,0x00000000},0x0027,0,1351},
+	{{0x00000000,0x00000000,0x00000000},0x009f,0,2441},
+	{{0x00000000,0x00000000,0x00000000},0x002a,0,1374},
+	{{0x00000000,0x00000000,0x00000000},0x0040,0,1540},
+	{{0x00000003,0x00000040,0x00000000},0x0042,0,1548},
+	{{0x00000005,0x00000040,0x00000000},0x0062,0,1548},
+	{{0x00000000,0x00000000,0x00000000},0x005c,0,1614},
+	{{0x00000000,0x00000000,0x00000000},0x0008,0,833},
+	{{0x00000000,0x00000000,0x00000000},0x007c,0,1674},
+	{{0x00000000,0x00000000,0x00000000},0x00a6,0,2547},
+	{{0x00000000,0x00000000,0x00000000},0x0007,0,820},
+	{{0x00000000,0x00000000,0x00000000},0x0007,0,815},
+	{{0x00000000,0x00000000,0x00000000},0x0082,0,1770},
+	{{0x00000000,0x00000000,0x00000000},0x0007,0,824},
+	{{0x00000000,0x00000000,0x00000000},0x0082,0,1773},
+	{{0x00000000,0x00000080,0x00000000},0x007b,0,1665},
+	{{0x00000000,0x00400000,0x00000000},0x007d,0,1665},
+	{{0x00000000,0x00000000,0x00000000},0x0082,0,1749},
+	{{0x00000000,0x00000000,0x00000000},0x00a6,0,2536},
+	{{0x00000000,0x00000000,0x00000000},0x0008,0,843},
+	{{0x00000003,0x00000040,0x00000000},0x0043,0,1550},
+	{{0x00000005,0x00000040,0x00000000},0x0063,0,1550},
+	{{0x00002003,0x00000040,0x00000000},0x00c7,0,1550},
+	{{0x00002005,0x00000040,0x00000000},0x00e7,0,1550},
+	{{0x00000000,0x00000000,0x00000000},0x00c7,0,2832},
+	{{0x00000000,0x00000000,0x00000000},0x00e7,0,2832},
+	{{0x00000000,0x00000000,0x00000000},0x0018,0,1142},
+	{{0x00000000,0x00000000,0x00000000},0x0018,0,1135},
+	{{0x00000000,0x00000000,0x00000000},0x0094,0,2163},
+	{{0x00000000,0x00000000,0x00000000},0x000d,0,886},
+	{{0x00000000,0x00000000,0x00000000},0x0094,0,2180},
+	{{0x00000000,0x00000000,0x00000000},0x0094,0,2183},
+	{{0x00000001,0x00000000,0x00000000},0x00a2,0,2491},
+	{{0x00000000,0x01000000,0x00000000},0x009a,0,2306},
+	{{0x00000001,0x00000000,0x00000000},0x0089,0,1903},
+	{{0x00000000,0x00000000,0x00000000},0x0088,0,1871},
+	{{0x00000000,0x00000000,0x00000000},0x009b,0,2362},
+	{{0x00000000,0x00000000,0x00000000},0x0018,0,1146},
+	{{0x00000000,0x00000000,0x00000000},0x00a9,0,2577},
+	{{0x00000000,0x00000000,0x00000000},0x003a,0,1481},
+	{{0x00000000,0x00000000,0x00000000},0x002c,0,1388},
+	{{0x00000000,0x00000000,0x00000000},0x0040,0,1526},
+	{{0x00000000,0x00000000,0x00000000},0x009b,0,2334},
+	{{0x00000001,0x00000000,0x00000000},0x00a9,0,2567},
+	{{0x00000000,0x00000000,0x00000000},0x000d,0,902},
+	{{0x00000000,0x00000000,0x00000000},0x009b,0,2365},
+	{{0x00000000,0x00000000,0x00000000},0x00a2,0,2496},
+	{{0x00000000,0x00000000,0x00000000},0x00a4,0,2520},
+	{{0x00000000,0x00000080,0x00020000},0x007b,0,1659},
+	{{0x00000000,0x00400000,0x00020000},0x007d,0,1659},
+	{{0x00000001,0x00000000,0x00000000},0x00a4,0,2511},
+	{{0x00000003,0x00000040,0x00000000},0x0044,0,1552},
+	{{0x00000005,0x00000040,0x00000000},0x0064,0,1552},
+	{{0x00000000,0x00000000,0x00000000},0x00d0,0,2863},
+	{{0x00000000,0x00000000,0x00000000},0x00f0,0,2863},
+	{{0x00000000,0x00000000,0x00000000},0x0011,0,969},
+	{{0x00000000,0x00000000,0x00000000},0x0012,0,995},
+	{{0x00000000,0x00000000,0x00000000},0x0013,0,1023},
+	{{0x00000000,0x00000000,0x00000000},0x0014,0,1050},
+	{{0x00000000,0x00000000,0x00000000},0x0010,0,930},
+	{{0x00000000,0x00000000,0x00000000},0x0090,0,2088},
+	{{0x00000000,0x00000000,0x00000000},0x0011,0,972},
+	{{0x00000000,0x00000000,0x00000000},0x0012,0,998},
+	{{0x00000000,0x00000000,0x00000000},0x0013,0,1026},
+	{{0x00000000,0x00000000,0x00000000},0x0014,0,1053},
+	{{0x00000000,0x00000000,0x00000000},0x0090,0,2091},
+	{{0x00000001,0x00000000,0x00000000},0x00b0,0,2680},
+	{{0x00000000,0x00000000,0x00000000},0x007f,0,1692},
+	{{0x00000000,0x00000000,0x00000000},0x007f,0,1685},
+	{{0x00000000,0x00010000,0x00000000},0x0011,0,954},
+	{{0x00000000,0x00000000,0x00000000},0x0014,0,1030},
+	{{0x00000000,0x00000000,0x00000000},0x0090,0,2066},
+	{{0x00000000,0x00000000,0x00000000},0x0013,0,1002},
+	{{0x00000000,0x00000000,0x00000000},0x0012,0,976},
+	{{0x00000000,0x00000000,0x00000000},0x00b0,0,2687},
+	{{0x00000001,0x00000000,0x00000000},0x00f7,0,2940},
+	{{0x00000000,0x00000000,0x00000000},0x0010,0,947},
+	{{0x00000000,0x00000000,0x00000000},0x0010,0,950},
+	{{0x00000000,0x00000000,0x00000000},0x0024,0,1327},
+	{{0x00000001,0x00000000,0x00000000},0x0024,0,1320},
+	{{0x00000000,0x00000000,0x00000000},0x007f,0,1696},
+	{{0x00000003,0x00000040,0x00000000},0x0045,0,1554},
+	{{0x00000005,0x00000040,0x00000000},0x0065,0,1554},
+	{{0x04000003,0x00000040,0x00000000},0x00c8,0,1554},
+	{{0x00000013,0x00000040,0x00000000},0x00c9,0,1554},
+	{{0x00008003,0x00000040,0x00000000},0x00ca,0,1554},
+	{{0x00040003,0x00000040,0x00000000},0x00cb,0,1554},
+	{{0x04000005,0x00000040,0x00000000},0x00e8,0,1554},
+	{{0x00000015,0x00000040,0x00000000},0x00e9,0,1554},
+	{{0x00008005,0x00000040,0x00000000},0x00ea,0,1554},
+	{{0x00040005,0x00000040,0x00000000},0x00eb,0,1554},
+	{{0x00000000,0x00000000,0x00000000},0x00c8,0,2835},
+	{{0x00000000,0x00000000,0x00000000},0x00e8,0,2835},
+	{{0x00000000,0x00000000,0x00000000},0x00c9,0,2838},
+	{{0x00000000,0x00000000,0x00000000},0x00e9,0,2838},
+	{{0x00000000,0x00000000,0x00000000},0x00cb,0,2844},
+	{{0x00000000,0x00000000,0x00000000},0x00eb,0,2844},
+	{{0x00000000,0x00000000,0x00000000},0x00ca,0,2841},
+	{{0x00000000,0x00000000,0x00000000},0x00ea,0,2841},
+	{{0x00000000,0x00000000,0x00000000},0x0017,0,1128},
+	{{0x00000000,0x00000000,0x00000000},0x001b,0,1184},
+	{{0x00000000,0x00000000,0x00000000},0x0097,0,2245},
+	{{0x00000001,0x00000000,0x00000000},0x0038,0,1470},
+	{{0x00000000,0x00000000,0x00000000},0x0019,0,1156},
+	{{0x00000000,0x00000000,0x00000000},0x0005,0,789},
+	{{0x00000000,0x00000000,0x00000000},0x0005,0,781},
+	{{0x00000000,0x00000000,0x00000000},0x0004,0,774},
+	{{0x00000000,0x00000000,0x00000000},0x0097,0,2248},
+	{{0x00000000,0x00000000,0x00000000},0x0005,0,793},
+	{{0x00000001,0x00000000,0x00000000},0x003d,0,1502},
+	{{0x00000000,0x00000000,0x00000000},0x0087,0,1864},
+	{{0x00000000,0x00000000,0x00000000},0x0087,0,1867},
+	{{0x00000000,0x00000000,0x00000000},0x001b,0,1187},
+	{{0x00000000,0x00000000,0x00000000},0x001b,0,1177},
+	{{0x00000000,0x00000000,0x00000000},0x0004,0,778},
+	{{0x00000000,0x00000000,0x00000000},0x0017,0,1131},
+	{{0x00000003,0x00000040,0x00000000},0x00d0,0,2859},
+	{{0x00000005,0x00000040,0x00000000},0x00f0,0,2859},
+	{{0x00000000,0x00000000,0x00000000},0x0003,0,754},
+	{{0x00000000,0x00000000,0x00000000},0x0003,0,758},
+	{{0x00000000,0x00000800,0x00000000},0x0021,0,1292},
+	{{0x00000000,0x00000800,0x00800000},0x00a1,0,1292},
+	{{0x00000003,0x00000040,0x00000000},0x0046,0,1556},
+	{{0x00000005,0x00000040,0x00000000},0x0066,0,1556},
+	{{0x00000001,0x00000000,0x00000000},0x000c,0,864},
+	{{0x00000000,0x00000200,0x00000000},0x000a,0,864},
+	{{0x00000000,0x00000000,0x00000000},0x00aa,0,2580},
+	{{0x00000000,0x00000000,0x00000000},0x000c,0,883},
+	{{0x00000000,0x00000000,0x00000000},0x001c,0,1191},
+	{{0x00000001,0x00000000,0x00000000},0x0035,0,1455},
+	{{0x00000001,0x00000000,0x00000000},0x0034,0,1450},
+	{{0x00000000,0x00000000,0x00000000},0x001c,0,1206},
+	{{0x00000003,0x00000040,0x00000000},0x0047,0,1558},
+	{{0x00000005,0x00000040,0x00000000},0x0067,0,1558},
+	{{0x00000000,0x00000000,0x00000000},0x0099,0,2298},
+	{{0x00000000,0x01000000,0x00000000},0x0099,0,2269},
+	{{0x00000001,0x00000000,0x00004000},0x003e,0,1509},
+	{{0x00000000,0x00000000,0x00000000},0x001d,0,1213},
+	{{0x00000000,0x00000000,0x00000000},0x001d,0,1229},
+	{{0x00000000,0x00000000,0x00100001},0x0097,0,2232},
+	{{0x00000003,0x00000040,0x00000000},0x0048,0,1560},
+	{{0x00000005,0x00000040,0x00000000},0x0068,0,1560},
+	{{0x00000000,0x00000000,0x00000000},0x0023,0,1317},
+	{{0x00000000,0x00000000,0x00000000},0x005e,0,1634},
+	{{0x00000000,0x00000000,0x00000000},0x0081,0,1724},
+	{{0x00000000,0x00000000,0x00000000},0x0089,0,1938},
+	{{0x00000000,0x00000000,0x00000000},0x0081,0,1742},
+	{{0x00000000,0x00000000,0x00000000},0x0081,0,1745},
+	{{0x00000000,0x00000000,0x00000000},0x0088,0,1896},
+	{{0x00000000,0x00000000,0x00000000},0x0009,0,861},
+	{{0x00000000,0x00000000,0x00000000},0x0089,0,1941},
+	{{0x00000000,0x00000000,0x00000000},0x0088,0,1899},
+	{{0x00000000,0x00000000,0x00000000},0x002d,0,1407},
+	{{0x00000000,0x00000000,0x00000000},0x002d,0,1394},
+	{{0x00000003,0x00000040,0x00000000},0x0049,0,1562},
+	{{0x00000005,0x00000040,0x00000000},0x0069,0,1562},
+	{{0x04000003,0x00000040,0x00000000},0x00cc,0,1562},
+	{{0x00000013,0x00000040,0x00000000},0x00cd,0,1562},
+	{{0x00008003,0x00000040,0x00000000},0x00ce,0,1562},
+	{{0x00040003,0x00000040,0x00000000},0x00cf,0,1562},
+	{{0x04000005,0x00000040,0x00000000},0x00ec,0,1562},
+	{{0x00000015,0x00000040,0x00000000},0x00ed,0,1562},
+	{{0x00008005,0x00000040,0x00000000},0x00ee,0,1562},
+	{{0x00040005,0x00000040,0x00000000},0x00ef,0,1562},
+	{{0x00000000,0x00000000,0x00000000},0x00cc,0,2847},
+	{{0x00000000,0x00000000,0x00000000},0x00ec,0,2847},
+	{{0x00000000,0x00000000,0x00000000},0x00cd,0,2850},
+	{{0x00000000,0x00000000,0x00000000},0x00ed,0,2850},
+	{{0x00000000,0x00000000,0x00000000},0x00cf,0,2856},
+	{{0x00000000,0x00000000,0x00000000},0x00ef,0,2856},
+	{{0x00000000,0x00000000,0x00000000},0x00ce,0,2853},
+	{{0x00000000,0x00000000,0x00000000},0x00ee,0,2853},
+	{{0x00000000,0x00000000,0x00000000},0x0084,0,1804},
+	{{0x00000000,0x00000000,0x00000000},0x0084,0,1807},
+	{{0x00000000,0x00000000,0x00000000},0x0084,0,1798},
+	{{0x00000000,0x00000000,0x00000000},0x001d,0,1236},
+	{{0x00000000,0x00000000,0x00000000},0x001f,0,1281},
+	{{0x00000000,0x00000000,0x00000000},0x001e,0,1259},
+	{{0x00000000,0x00000000,0x00000000},0x001d,0,1232},
+	{{0x00000000,0x00000000,0x00000000},0x001c,0,1209},
+	{{0x00000003,0x00000040,0x00000000},0x004a,0,1564},
+	{{0x00000005,0x00000040,0x00000000},0x006a,0,1564},
+	{{0x00000003,0x00000040,0x00000000},0x004b,0,1566},
+	{{0x00000005,0x00000040,0x00000000},0x006b,0,1566},
+	{{0x00000003,0x00000040,0x00000000},0x004c,0,1568},
+	{{0x00000005,0x00000040,0x00000000},0x006c,0,1568},
+	{{0x00000000,0x00000000,0x00000000},0x00a3,0,2508},
+	{{0x00000001,0x00000000,0x00004000},0x003c,0,1497},
+	{{0x00000000,0x00000000,0x00000000},0x000a,0,869},
+	{{0x00000000,0x00000200,0x00000000},0x005f,0,1641},
+	{{0x00000003,0x00000040,0x00000000},0x004d,0,1570},
+	{{0x00000005,0x00000040,0x00000000},0x006d,0,1570},
+	{{0x00000000,0x00000000,0x00000000},0x00ba,0,2742},
+	{{0x00000000,0x00000000,0x00100001},0x0019,0,1149},
+	{{0x00000000,0x00000000,0x00000000},0x0095,0,2187},
+	{{0x00000001,0x00000000,0x00000000},0x00b5,0,2710},
+	{{0x00000001,0x00000000,0x00000000},0x00d7,0,2884},
+	{{0x00000000,0x00000000,0x00000000},0x0095,0,2203},
+	{{0x00000000,0x00000000,0x00000000},0x00b5,0,2716},
+	{{0x00000003,0x00000040,0x00000000},0x004e,0,1572},
+	{{0x00000005,0x00000040,0x00000000},0x006e,0,1572},
+	{{0x00000003,0x02000040,0x00000000},0x00d1,0,1572},
+	{{0x00000005,0x02000040,0x00000000},0x00f1,0,1572},
+	{{0x00000000,0x00000000,0x00000000},0x00d1,0,2866},
+	{{0x00000000,0x00000000,0x00000000},0x00f1,0,2866},
+	{{0x00000000,0x00000000,0x00000000},0x0015,0,1078},
+	{{0x00000000,0x00000000,0x00000000},0x0023,0,1314},
+	{{0x00000000,0x00000000,0x00000000},0x0083,0,1794},
+	{{0x00000000,0x00000000,0x00000000},0x0015,0,1057},
+	{{0x00000000,0x00000000,0x00000000},0x0085,0,1819},
+	{{0x00000000,0x00000000,0x00000000},0x000a,0,872},
+	{{0x00000000,0x00000200,0x00000000},0x0085,0,1811},
+	{{0x00000000,0x00000000,0x00000000},0x0083,0,1791},
+	{{0x00000001,0x00000000,0x00000000},0x0039,0,1476},
+	{{0x00000000,0x00000000,0x00000000},0x0015,0,1082},
+	{{0x00000000,0x00000000,0x00000000},0x0085,0,1816},
+	{{0x00000000,0x00000000,0x00000000},0x00ac,0,2642},
+	{{0x00000000,0x00000000,0x00000200},0x00a0,0,2476},
+	{{0x00000000,0x00000000,0x00000000},0x0083,0,1777},
+	{{0x00000001,0x00000000,0x00000000},0x00ac,0,2638},
+	{{0x00000000,0x00000000,0x00000000},0x00a0,0,2485},
+	{{0x00000000,0x00000000,0x00000000},0x0000,0,707},
+	{{0x00000000,0x00000000,0x00000000},0x0000,0,703},
+	{{0x00000000,0x00000000,0x00000000},0x0000,0,698},
+	{{0x00000003,0x00000040,0x00000000},0x004f,0,1574},
+	{{0x00000005,0x00000040,0x00000000},0x006f,0,1574},
+	{{0x04000003,0x00000040,0x00000000},0x00d2,0,1574},
+	{{0x00000013,0x00000040,0x00000000},0x00d3,0,1574},
+	{{0x00008003,0x00000040,0x00000000},0x00d4,0,1574},
+	{{0x00000003,0x02000040,0x00000000},0x00d5,0,1574},
+	{{0x00040003,0x00000040,0x00000000},0x00d6,0,1574},
+	{{0x00000003,0x00000040,0x10000000},0x00d8,0,1574},
+	{{0x04000005,0x00000040,0x00000000},0x00f2,0,1574},
+	{{0x00000015,0x00000040,0x00000000},0x00f3,0,1574},
+	{{0x00008005,0x00000040,0x00000000},0x00f4,0,1574},
+	{{0x00000005,0x02000040,0x00000000},0x00f5,0,1574},
+	{{0x00040005,0x00000040,0x00000000},0x00f6,0,1574},
+	{{0x00000005,0x00000040,0x10000000},0x00f8,0,1574},
+	{{0x00000000,0x00000000,0x00000000},0x00d2,0,2869},
+	{{0x00000000,0x00000000,0x00000000},0x00f2,0,2869},
+	{{0x00000000,0x00000000,0x00000000},0x00d3,0,2872},
+	{{0x00000000,0x00000000,0x00000000},0x00f3,0,2872},
+	{{0x00000000,0x00000000,0x00000000},0x00d8,0,2902},
+	{{0x00000000,0x00000000,0x00000000},0x00f8,0,2902},
+	{{0x00000000,0x00000000,0x00000000},0x00d6,0,2881},
+	{{0x00000000,0x00000000,0x00000000},0x00f6,0,2881},
+	{{0x00000000,0x00000000,0x00000000},0x00d4,0,2875},
+	{{0x00000000,0x00000000,0x00000000},0x00f4,0,2875},
+	{{0x00000000,0x00000000,0x00000000},0x00d5,0,2878},
+	{{0x00000000,0x00000000,0x00000000},0x00f5,0,2878},
+	{{0x00000000,0x00000000,0x00000000},0x0040,0,1543},
+	{{0x00000000,0x00000000,0x00000000},0x009d,0,2415},
+	{{0x00000000,0x00000000,0x00000000},0x009d,0,2390},
+	{{0x00000000,0x00000000,0x00000000},0x009d,0,2418},
+	{{0x00000003,0x00000040,0x00000000},0x0050,0,1576},
+	{{0x00000005,0x00000040,0x00000000},0x0070,0,1576},
+	{{0x00000000,0x00000000,0x00000000},0x0091,0,2107},
+	{{0x00000000,0x00000000,0x00000000},0x0092,0,2130},
+	{{0x00000000,0x00000000,0x00000000},0x0080,0,1717},
+	{{0x00000000,0x00000000,0x00000000},0x0080,0,1720},
+	{{0x00000000,0x00000000,0x00000000},0x0080,0,1699},
+	{{0x00000000,0x00000080,0x00000000},0x0028,0,1362},
+	{{0x00000000,0x00400000,0x00000000},0x0029,0,1362},
+	{{0x00000000,0x00000200,0x00000000},0x008c,0,1990},
+	{{0x00000000,0x00000200,0x00000000},0x008b,0,1967},
+	{{0x00000000,0x00000000,0x00000000},0x008b,0,1983},
+	{{0x00000000,0x00000000,0x00000000},0x00a3,0,1983},
+	{{0x00000001,0x00000000,0x00000000},0x0025,0,1333},
+	{{0x00000000,0x00000000,0x00000000},0x002e,0,1414},
+	{{0x00000000,0x00000000,0x00000000},0x00b6,0,2727},
+	{{0x00000001,0x00000000,0x00000000},0x00b6,0,2719},
+	{{0x00000000,0x00000000,0x00000000},0x008b,0,1986},
+	{{0x00000000,0x00000000,0x00000000},0x008c,0,2010},
+	{{0x00000001,0x00000000,0x00000000},0x002b,0,1383},
+	{{0x00000001,0x00000000,0x00000000},0x00b1,0,2690},
+	{{0x00000000,0x00000000,0x00000000},0x009e,0,2438},
+	{{0x00100000,0x00000880,0x00000000},0x00ab,0,2610},
+	{{0x00100000,0x00400800,0x00000000},0x00bb,0,2610},
+	{{0x00000001,0x00000000,0x00000000},0x00a3,0,2502},
+	{{0x00000000,0x00000000,0x00000000},0x009e,0,2422},
+	{{0x00000000,0x00010000,0x00000000},0x0091,0,2095},
+	{{0x00000000,0x00000000,0x00000000},0x0092,0,2114},
+	{{0x00000000,0x00000000,0x00000000},0x008c,0,2007},
+	{{0x00000000,0x00000000,0x00000000},0x0091,0,2110},
+	{{0x00000000,0x00000000,0x00000000},0x0092,0,2133},
+	{{0x00000003,0x00000040,0x00000000},0x0051,0,1578},
+	{{0x00000005,0x00000040,0x00000000},0x0071,0,1578},
+	{{0x00000000,0x00010000,0x00000018},0x00bc,0,2776},
+	{{0x00000000,0x00000800,0x00000000},0x003f,0,1517},
+	{{0x00000000,0x00000800,0x00800000},0x00bf,0,1517},
+	{{0x00000000,0x00000800,0x00000000},0x0022,0,1304},
+	{{0x00000003,0x00000040,0x00000000},0x0052,0,1580},
+	{{0x00000005,0x00000040,0x00000000},0x0072,0,1580},
+	{{0x00000000,0x00000000,0x00000000},0x001e,0,1242},
+	{{0x00000001,0x00000000,0x00000000},0x00ae,0,2663},
+	{{0x00000000,0x00000200,0x00000000},0x008d,0,2014},
+	{{0x00000000,0x00000000,0x00000000},0x005c,0,1598},
+	{{0x00000000,0x00000000,0x00000000},0x00ae,0,2674},
+	{{0x00000000,0x00000000,0x00000000},0x008d,0,2027},
+	{{0x00000000,0x00000000,0x00000000},0x001e,0,1263},
+	{{0x00000003,0x00000040,0x00000000},0x0053,0,1582},
+	{{0x00000005,0x00000040,0x00000000},0x0073,0,1582},
+	{{0x00000000,0x00000000,0x00000000},0x008e,0,2040},
+	{{0x00000000,0x00000000,0x00000000},0x008f,0,2059},
+	{{0x00000000,0x00000000,0x00000000},0x0086,0,1843},
+	{{0x00000000,0x00000000,0x00000000},0x001a,0,1170},
+	{{0x00000000,0x00000000,0x00000000},0x009a,0,2327},
+	{{0x00000000,0x00000000,0x00000000},0x009a,0,2330},
+	{{0x00000000,0x00000000,0x00000000},0x00a7,0,2561},
+	{{0x00000001,0x00000000,0x00000000},0x00a7,0,2553},
+	{{0x00000000,0x00000000,0x00100001},0x0087,0,1850},
+	{{0x00000000,0x00000000,0x00000000},0x003b,0,1487},
+	{{0x00000000,0x00000000,0x00000000},0x0093,0,2137},
+	{{0x00000001,0x00000000,0x00000000},0x0037,0,1464},
+	{{0x00000000,0x00000000,0x00000000},0x0096,0,2225},
+	{{0x00000000,0x00000000,0x00000000},0x0099,0,2301},
+	{{0x00000000,0x00000000,0x00000000},0x0001,0,728},
+	{{0x00000005,0x00000040,0x00000000},0x00df,0,2929},
+	{{0x00000000,0x00000000,0x00000000},0x000f,0,918},
+	{{0x00000000,0x00000000,0x00000000},0x000e,0,905},
+	{{0x00000000,0x01000000,0x00000000},0x008f,0,2047},
+	{{0x00000000,0x01000000,0x00000000},0x008e,0,2030},
+	{{0x00000000,0x00000000,0x00000000},0x000f,0,927},
+	{{0x00000001,0x00000000,0x00000000},0x0036,0,1460},
+	{{0x00000000,0x00000000,0x00000000},0x002f,0,1429},
+	{{0x00000000,0x00000000,0x00000000},0x000e,0,915},
+	{{0x00000000,0x00000000,0x00000000},0x00ad,0,2648},
+	{{0x00000000,0x00000000,0x00000000},0x0001,0,724},
+	{{0x00000000,0x00000000,0x00000000},0x002f,0,1421},
+	{{0x00000000,0x00000000,0x00000000},0x0098,0,2265},
+	{{0x00000000,0x00000000,0x00000000},0x0020,0,1289},
+	{{0x00000000,0x00000000,0x00000000},0x0096,0,2228},
+	{{0x00000000,0x00000000,0x00000000},0x00df,0,2937},
+	{{0x00000000,0x00000000,0x00000000},0x008e,0,2043},
+	{{0x00000000,0x00000000,0x00000000},0x008f,0,2062},
+	{{0x00000000,0x00000000,0x00000000},0x0086,0,1846},
+	{{0x00000000,0x00000000,0x00000000},0x009c,0,2387},
+	{{0x00000000,0x00000000,0x00000001},0x0096,0,2206},
+	{{0x00000000,0x00000000,0x00000001},0x0001,0,710},
+	{{0x00000000,0x00000000,0x00000001},0x0086,0,1823},
+	{{0x00000000,0x00000000,0x00000001},0x0098,0,2252},
+	{{0x00000000,0x00000000,0x00000001},0x0002,0,731},
+	{{0x00000000,0x00000000,0x00000000},0x009c,0,2369},
+	{{0x00000000,0x00000000,0x00000000},0x0093,0,2159},
+	{{0x00000000,0x00000000,0x00000000},0x0002,0,742},
+	{{0x00000000,0x00000000,0x00000000},0x001a,0,1173},
+	{{0x00000000,0x00000000,0x00000000},0x001a,0,1159},
+	{{0x00000000,0x00000000,0x00000000},0x0002,0,746},
+	{{0x00000000,0x00000000,0x00000000},0x0016,0,1102},
+	{{0x00000000,0x00000000,0x00000000},0x0016,0,1105},
+	{{0x00000000,0x00000000,0x00000000},0x0016,0,1085},
+	{{0x00000003,0x00000040,0x00000000},0x0054,0,1584},
+	{{0x00000005,0x00000040,0x00000000},0x0074,0,1584},
+	{{0x00000000,0x00000000,0x00000000},0x0009,0,857},
+	{{0x00000000,0x00000001,0x00000000},0x0009,0,857},
+	{{0x00000000,0x40000000,0x00000000},0x000b,0,857},
+	{{0x00000000,0x00000001,0x00000000},0x0009,0,846},
+	{{0x00000000,0x40000000,0x00000000},0x000b,0,846},
+	{{0x00000000,0x00000200,0x00000000},0x008a,0,1945},
+	{{0x00000000,0x00000000,0x00100001},0x0003,0,749},
+	{{0x00000000,0x00000000,0x00000000},0x00de,0,2926},
+	{{0x00000000,0x00000000,0x00000000},0x00fe,0,2926},
+	{{0x00000003,0x00000040,0x00000000},0x00de,0,2920},
+	{{0x00000005,0x00000040,0x00000000},0x00fe,0,2920},
+	{{0x00000001,0x00000000,0x00000000},0x0033,0,1444},
+	{{0x00000000,0x00000000,0x00000020},0x00b3,0,1444},
+	{{0x00000000,0x00000000,0x00000018},0x00be,0,2790},
+	{{0x00000000,0x00000000,0x00100001},0x0004,0,761},
+	{{0x00000000,0x00000000,0x00100001},0x0017,0,1109},
+	{{0x00000000,0x00000000,0x00000000},0x0093,0,2156},
+	{{0x00000001,0x00000000,0x00000000},0x0032,0,1440},
+	{{0x00000000,0x00000000,0x00000020},0x00b2,0,1440},
+	{{0x00000003,0x00000040,0x00000000},0x0055,0,1586},
+	{{0x00000005,0x00000040,0x00000000},0x0075,0,1586},
+	{{0x04000003,0x00000040,0x00000000},0x00d9,0,1586},
+	{{0x00000013,0x00000040,0x00000000},0x00da,0,1586},
+	{{0x00008003,0x00000040,0x00000000},0x00db,0,1586},
+	{{0x00040003,0x00000040,0x00000000},0x00dc,0,1586},
+	{{0x04000005,0x00000040,0x00000000},0x00f9,0,1586},
+	{{0x00000015,0x00000040,0x00000000},0x00fa,0,1586},
+	{{0x00008005,0x00000040,0x00000000},0x00fb,0,1586},
+	{{0x00040005,0x00000040,0x00000000},0x00fc,0,1586},
+	{{0x00000000,0x00000000,0x00000000},0x00d9,0,2905},
+	{{0x00000000,0x00000000,0x00000000},0x00f9,0,2905},
+	{{0x00000000,0x00000000,0x00000000},0x00da,0,2908},
+	{{0x00000000,0x00000000,0x00000000},0x00fa,0,2908},
+	{{0x00000000,0x00000000,0x00000000},0x00dc,0,2914},
+	{{0x00000000,0x00000000,0x00000000},0x00fc,0,2914},
+	{{0x00000000,0x00000000,0x00000000},0x00db,0,2911},
+	{{0x00000000,0x00000000,0x00000000},0x00fb,0,2911},
+	{{0x00000000,0x00000000,0x00000000},0x005f,0,1645},
+	{{0x00000000,0x00000000,0x00000000},0x001f,0,1266},
+	{{0x00000000,0x00000000,0x00000000},0x001f,0,1285},
+	{{0x00000003,0x00000040,0x00000000},0x0056,0,1588},
+	{{0x00000005,0x00000040,0x00000000},0x0076,0,1588},
+	{{0x00000000,0x00000000,0x00000000},0x008a,0,1960},
+	{{0x00000000,0x00000000,0x00000000},0x000b,0,880},
+	{{0x00000000,0x00000000,0x00000000},0x008a,0,1963},
+	{{0x00000003,0x00000040,0x00000000},0x0057,0,1590},
+	{{0x00000005,0x00000040,0x00000000},0x0077,0,1590},
+	{{0x00000003,0x00000040,0x00000000},0x0058,0,1592},
+	{{0x00000005,0x00000040,0x00000000},0x0078,0,1592},
+	{{0x00000000,0x00000000,0x00000000},0x00a4,0,2523},
+	{{0x00000003,0x00000040,0x00000000},0x0059,0,1594},
+	{{0x00000005,0x00000040,0x00000000},0x0079,0,1594},
+	{{0x00000013,0x00000040,0x00000000},0x00dd,0,1594},
+	{{0x00000015,0x00000040,0x00000000},0x00fd,0,1594},
+	{{0x00040005,0x00000040,0x00000000},0x00ff,0,1594},
+	{{0x00000000,0x00000000,0x00000000},0x00dd,0,2917},
+	{{0x00000000,0x00000000,0x00000000},0x00fd,0,2917},
+	{{0x00000000,0x00000000,0x00000000},0x00a5,0,2533},
+	{{0x00000000,0x00000000,0x00000000},0x00ff,0,2952},
+	{{0x00000000,0x00000000,0x00000000},0x00a5,0,2530},
+	{{0x00000001,0x00000000,0x00000000},0x00a5,0,2526},
+	{{0x00000003,0x00000040,0x00000000},0x005a,0,1596},
+	{{0x00000005,0x00000040,0x00000000},0x007a,0,1596},
+	{{0x00000001,0x00000000,0x00000000},0x0030,0,1435},
+#if !UCS_BYTE
+	{{0x00001000,0x00000000,0x00000000},0x02c7,0,1288},
+	{{0x00000800,0x00000000,0x00000000},0x02d8,0,1288},
+	{{0x00000000,0x00000000,0x02000000},0x02db,0,1288},
+	{{0x00000000,0x00000000,0x00000001},0x2109,0,1288},
+	{{0x00000000,0x00000000,0x00010000},0x2228,0,1288},
+	{{0x00000000,0x00000000,0x00010000},0x25ad,0,1288},
+	{{0x00080008,0x00000000,0x00000000},0x02d9,0,1288},
+	{{0x00000008,0x00000000,0x04000000},0x02da,0,1288},
+	{{0x00000004,0x02000000,0x00000000},0x02dc,0,1288},
+	{{0x08000001,0x00004000,0x00000000},0x0374,0,1288},
+	{{0x08000000,0x00000000,0x20000000},0x0384,0,1288},
+	{{0x20000021,0x00000000,0x00000000},0x05d0,0,1288},
+	{{0x000000a1,0x00000000,0x00000000},0x0627,0,1288},
+	{{0x08000000,0x00100000,0x00000000},0x1fbe,0,1288},
+	{{0x08000000,0x00200000,0x00000000},0x1fbf,0,1288},
+	{{0x08000000,0x00080000,0x00000000},0x1fc0,0,1288},
+	{{0x08000000,0x20000000,0x00000000},0x1fef,0,1288},
+	{{0x08000000,0x00020000,0x00000000},0x1ffd,0,1288},
+	{{0x08020000,0x00000000,0x00000000},0x1ffe,0,1288},
+	{{0x00000000,0x00010000,0x00000040},0x2081,0,1288},
+	{{0x80000000,0x00000000,0x00040000},0x2440,0,1288},
+	{{0x00004001,0x00010000,0x00000000},0x2460,0,1288},
+	{{0x00000001,0x00050000,0x00000000},0x2474,0,1288},
+	{{0x00000000,0x00000000,0x00000084},0x25a0,0,1288},
+	{{0x00000000,0x80000000,0x00000080},0x25a1,0,1288},
+	{{0x00000000,0x00000000,0x00000a00},0x3000,0,1288},
+	{{0x40000001,0x04000000,0x00000000},0x3068,0,1288},
+	{{0x00000001,0x04000020,0x00000000},0x30c8,0,1288},
+	{{0x08000043,0x00000000,0x00000000},0x0391,0,1288},
+	{{0x08800003,0x00000000,0x00000000},0x0397,0,1288},
+	{{0x08000003,0x00000008,0x00000000},0x0399,0,1288},
+	{{0x08000003,0x10000000,0x00000000},0x03a5,0,1288},
+	{{0x08000003,0x00008000,0x00000000},0x03a9,0,1288},
+	{{0x08000045,0x00000000,0x00000000},0x03b1,0,1288},
+	{{0x08800005,0x00000000,0x00000000},0x03b7,0,1288},
+	{{0x08000005,0x00000008,0x00000000},0x03b9,0,1288},
+	{{0x08000005,0x10000000,0x00000000},0x03c5,0,1288},
+	{{0x08000005,0x00008000,0x00000000},0x03c9,0,1288},
+	{{0x00000081,0x00010000,0x00000400},0x0661,0,1288},
+	{{0x000000a1,0x00000000,0x00000020},0x0670,0,1288},
+	{{0x08000001,0x20200000,0x00000000},0x1fcd,0,1288},
+	{{0x08000001,0x00220000,0x00000000},0x1fce,0,1288},
+	{{0x08000001,0x00280000,0x00000000},0x1fcf,0,1288},
+	{{0x08020001,0x20000000,0x00000000},0x1fdd,0,1288},
+	{{0x08020001,0x00020000,0x00000000},0x1fde,0,1288},
+	{{0x08020001,0x00080000,0x00000000},0x1fdf,0,1288},
+	{{0x00100000,0x40000200,0x00000000},0x2016,0,1288},
+	{{0x00000000,0x00814000,0x00000000},0x2160,0,1288},
+	{{0x00000000,0x00400080,0x00002000},0x2194,0,1288},
+	{{0x00200000,0x08000000,0x00002000},0x2195,0,1288},
+	{{0x02000001,0x00010000,0x00000002},0x2488,0,1288},
+	{{0x00000004,0x00000000,0x00000084},0x25aa,0,1288},
+	{{0x02000000,0x00000000,0x00000802},0x3002,0,1288},
+	{{0x00080000,0x00000020,0x01000000},0x30fb,0,1288},
+	{{0x00000000,0x00050000,0x00000800},0x3220,0,1288},
+	{{0x000000a1,0x00000010,0x00000000},0xfe8d,0,1288},
+	{{0x010000a1,0x00000000,0x00000000},0xfe8e,0,1288},
+	{{0x08000043,0x00000000,0x20000000},0x0386,0,1288},
+	{{0x08800003,0x00000000,0x20000000},0x0389,0,1288},
+	{{0x08000003,0x00000008,0x20000000},0x038a,0,1288},
+	{{0x08000003,0x10000000,0x20000000},0x038e,0,1288},
+	{{0x08000003,0x00008000,0x20000000},0x038f,0,1288},
+	{{0x08000045,0x00000000,0x20000000},0x03ac,0,1288},
+	{{0x08800005,0x00000000,0x20000000},0x03ae,0,1288},
+	{{0x08000005,0x00000008,0x20000000},0x03af,0,1288},
+	{{0x08000005,0x10000000,0x20000000},0x03cd,0,1288},
+	{{0x08000005,0x00008000,0x20000000},0x03ce,0,1288},
+	{{0x08000045,0x00200000,0x00000000},0x1f00,0,1288},
+	{{0x08020045,0x00000000,0x00000000},0x1f01,0,1288},
+	{{0x08000043,0x00200000,0x00000000},0x1f08,0,1288},
+	{{0x08020043,0x00000000,0x00000000},0x1f09,0,1288},
+	{{0x08800005,0x00200000,0x00000000},0x1f20,0,1288},
+	{{0x08820005,0x00000000,0x00000000},0x1f21,0,1288},
+	{{0x08800003,0x00200000,0x00000000},0x1f28,0,1288},
+	{{0x08820003,0x00000000,0x00000000},0x1f29,0,1288},
+	{{0x08000005,0x00200008,0x00000000},0x1f30,0,1288},
+	{{0x08020005,0x00000008,0x00000000},0x1f31,0,1288},
+	{{0x08000003,0x00200008,0x00000000},0x1f38,0,1288},
+	{{0x08020003,0x00000008,0x00000000},0x1f39,0,1288},
+	{{0x08000005,0x10200000,0x00000000},0x1f50,0,1288},
+	{{0x08020005,0x10000000,0x00000000},0x1f51,0,1288},
+	{{0x08020003,0x10000000,0x00000000},0x1f59,0,1288},
+	{{0x08000005,0x00208000,0x00000000},0x1f60,0,1288},
+	{{0x08020005,0x00008000,0x00000000},0x1f61,0,1288},
+	{{0x08000003,0x00208000,0x00000000},0x1f68,0,1288},
+	{{0x08020003,0x00008000,0x00000000},0x1f69,0,1288},
+	{{0x08000045,0x20000000,0x00000000},0x1f70,0,1288},
+	{{0x08000045,0x00020000,0x00000000},0x1f71,0,1288},
+	{{0x08800005,0x20000000,0x00000000},0x1f74,0,1288},
+	{{0x08800005,0x00020000,0x00000000},0x1f75,0,1288},
+	{{0x08000005,0x20000008,0x00000000},0x1f76,0,1288},
+	{{0x08000005,0x00020008,0x00000000},0x1f77,0,1288},
+	{{0x08000005,0x30000000,0x00000000},0x1f7a,0,1288},
+	{{0x08000005,0x10020000,0x00000000},0x1f7b,0,1288},
+	{{0x08000005,0x20008000,0x00000000},0x1f7c,0,1288},
+	{{0x08000005,0x00028000,0x00000000},0x1f7d,0,1288},
+	{{0x08000045,0x00000400,0x00000000},0x1fb1,0,1288},
+	{{0x08000045,0x00080000,0x00000000},0x1fb6,0,1288},
+	{{0x08000043,0x00000400,0x00000000},0x1fb9,0,1288},
+	{{0x08000043,0x20000000,0x00000000},0x1fba,0,1288},
+	{{0x08000043,0x00020000,0x00000000},0x1fbb,0,1288},
+	{{0x08000043,0x00100000,0x00000000},0x1fbc,0,1288},
+	{{0x08800005,0x00080000,0x00000000},0x1fc6,0,1288},
+	{{0x08800003,0x20000000,0x00000000},0x1fca,0,1288},
+	{{0x08800003,0x00020000,0x00000000},0x1fcb,0,1288},
+	{{0x08800003,0x00100000,0x00000000},0x1fcc,0,1288},
+	{{0x08000005,0x00000408,0x00000000},0x1fd1,0,1288},
+	{{0x08000005,0x00080008,0x00000000},0x1fd6,0,1288},
+	{{0x08000003,0x00000408,0x00000000},0x1fd9,0,1288},
+	{{0x08000003,0x20000008,0x00000000},0x1fda,0,1288},
+	{{0x08000003,0x00020008,0x00000000},0x1fdb,0,1288},
+	{{0x08000005,0x10000400,0x00000000},0x1fe1,0,1288},
+	{{0x08000005,0x10080000,0x00000000},0x1fe6,0,1288},
+	{{0x08000003,0x10000400,0x00000000},0x1fe9,0,1288},
+	{{0x08000003,0x30000000,0x00000000},0x1fea,0,1288},
+	{{0x08000003,0x10020000,0x00000000},0x1feb,0,1288},
+	{{0x08000005,0x00088000,0x00000000},0x1ff6,0,1288},
+	{{0x08000003,0x20008000,0x00000000},0x1ffa,0,1288},
+	{{0x08000003,0x00028000,0x00000000},0x1ffb,0,1288},
+	{{0x08000003,0x00108000,0x00000000},0x1ffc,0,1288},
+	{{0x00000000,0x04400880,0x00000000},0x200e,0,1288},
+	{{0x00000000,0x04400880,0x00000000},0x200f,0,1288},
+	{{0x00000004,0x00814000,0x00000000},0x2170,0,1288},
+	{{0x00100000,0x00400080,0x00002000},0x21d4,0,1288},
+	{{0x00400400,0x00000101,0x00000000},0x2500,0,1288},
+	{{0x10400400,0x00000001,0x00000000},0x2501,0,1288},
+	{{0x00400400,0x40000100,0x00000000},0x2502,0,1288},
+	{{0x10400400,0x40000000,0x00000000},0x2503,0,1288},
+	{{0x00500400,0x00000001,0x00000000},0x2550,0,1288},
+	{{0x00500400,0x40000000,0x00000000},0x2551,0,1288},
+	{{0x08000045,0x20200000,0x00000000},0x1f02,0,1288},
+	{{0x08020045,0x20000000,0x00000000},0x1f03,0,1288},
+	{{0x08000045,0x00220000,0x00000000},0x1f04,0,1288},
+	{{0x08020045,0x00020000,0x00000000},0x1f05,0,1288},
+	{{0x08000045,0x00280000,0x00000000},0x1f06,0,1288},
+	{{0x08020045,0x00080000,0x00000000},0x1f07,0,1288},
+	{{0x08000043,0x20200000,0x00000000},0x1f0a,0,1288},
+	{{0x08020043,0x20000000,0x00000000},0x1f0b,0,1288},
+	{{0x08000043,0x00220000,0x00000000},0x1f0c,0,1288},
+	{{0x08020043,0x00020000,0x00000000},0x1f0d,0,1288},
+	{{0x08000043,0x00280000,0x00000000},0x1f0e,0,1288},
+	{{0x08020043,0x00080000,0x00000000},0x1f0f,0,1288},
+	{{0x08800005,0x20200000,0x00000000},0x1f22,0,1288},
+	{{0x08820005,0x20000000,0x00000000},0x1f23,0,1288},
+	{{0x08800005,0x00220000,0x00000000},0x1f24,0,1288},
+	{{0x08820005,0x00020000,0x00000000},0x1f25,0,1288},
+	{{0x08800005,0x00280000,0x00000000},0x1f26,0,1288},
+	{{0x08820005,0x00080000,0x00000000},0x1f27,0,1288},
+	{{0x08800003,0x20200000,0x00000000},0x1f2a,0,1288},
+	{{0x08820003,0x20000000,0x00000000},0x1f2b,0,1288},
+	{{0x08800003,0x00220000,0x00000000},0x1f2c,0,1288},
+	{{0x08820003,0x00020000,0x00000000},0x1f2d,0,1288},
+	{{0x08800003,0x00280000,0x00000000},0x1f2e,0,1288},
+	{{0x08820003,0x00080000,0x00000000},0x1f2f,0,1288},
+	{{0x08000005,0x20200008,0x00000000},0x1f32,0,1288},
+	{{0x08020005,0x20000008,0x00000000},0x1f33,0,1288},
+	{{0x08000005,0x00220008,0x00000000},0x1f34,0,1288},
+	{{0x08020005,0x00020008,0x00000000},0x1f35,0,1288},
+	{{0x08000005,0x00280008,0x00000000},0x1f36,0,1288},
+	{{0x08020005,0x00080008,0x00000000},0x1f37,0,1288},
+	{{0x08000003,0x20200008,0x00000000},0x1f3a,0,1288},
+	{{0x08020003,0x20000008,0x00000000},0x1f3b,0,1288},
+	{{0x08000003,0x00220008,0x00000000},0x1f3c,0,1288},
+	{{0x08020003,0x00020008,0x00000000},0x1f3d,0,1288},
+	{{0x08000003,0x00280008,0x00000000},0x1f3e,0,1288},
+	{{0x08020003,0x00080008,0x00000000},0x1f3f,0,1288},
+	{{0x08000005,0x30200000,0x00000000},0x1f52,0,1288},
+	{{0x08020005,0x30000000,0x00000000},0x1f53,0,1288},
+	{{0x08000005,0x10220000,0x00000000},0x1f54,0,1288},
+	{{0x08020005,0x10020000,0x00000000},0x1f55,0,1288},
+	{{0x08000005,0x10280000,0x00000000},0x1f56,0,1288},
+	{{0x08020005,0x10080000,0x00000000},0x1f57,0,1288},
+	{{0x08020003,0x30000000,0x00000000},0x1f5b,0,1288},
+	{{0x08020003,0x10020000,0x00000000},0x1f5d,0,1288},
+	{{0x08020003,0x10080000,0x00000000},0x1f5f,0,1288},
+	{{0x08000005,0x20208000,0x00000000},0x1f62,0,1288},
+	{{0x08020005,0x20008000,0x00000000},0x1f63,0,1288},
+	{{0x08000005,0x00228000,0x00000000},0x1f64,0,1288},
+	{{0x08020005,0x00028000,0x00000000},0x1f65,0,1288},
+	{{0x08000005,0x00288000,0x00000000},0x1f66,0,1288},
+	{{0x08020005,0x00088000,0x00000000},0x1f67,0,1288},
+	{{0x08000003,0x20208000,0x00000000},0x1f6a,0,1288},
+	{{0x08020003,0x20008000,0x00000000},0x1f6b,0,1288},
+	{{0x08000003,0x00228000,0x00000000},0x1f6c,0,1288},
+	{{0x08020003,0x00028000,0x00000000},0x1f6d,0,1288},
+	{{0x08000003,0x00288000,0x00000000},0x1f6e,0,1288},
+	{{0x08020003,0x00088000,0x00000000},0x1f6f,0,1288},
+	{{0x08000043,0x00300000,0x00000000},0x1f88,0,1288},
+	{{0x08020043,0x00100000,0x00000000},0x1f89,0,1288},
+	{{0x08800003,0x00300000,0x00000000},0x1f98,0,1288},
+	{{0x08820003,0x00100000,0x00000000},0x1f99,0,1288},
+	{{0x08000003,0x00308000,0x00000000},0x1fa8,0,1288},
+	{{0x08020003,0x00108000,0x00000000},0x1fa9,0,1288},
+	{{0x00600401,0x00400100,0x00000000},0x250c,0,1288},
+	{{0x10600401,0x00400000,0x00000000},0x250f,0,1288},
+	{{0x00600401,0x00000180,0x00000000},0x2510,0,1288},
+	{{0x10600401,0x00000080,0x00000000},0x2513,0,1288},
+	{{0x00400401,0x08400100,0x00000000},0x2514,0,1288},
+	{{0x10400401,0x08400000,0x00000000},0x2517,0,1288},
+	{{0x00400401,0x08000180,0x00000000},0x2518,0,1288},
+	{{0x10400401,0x08000080,0x00000000},0x251b,0,1288},
+	{{0x00400401,0x40400100,0x00000000},0x251c,0,1288},
+	{{0x10400401,0x40400000,0x00000000},0x2523,0,1288},
+	{{0x00400401,0x40000180,0x00000000},0x2524,0,1288},
+	{{0x10400401,0x40000080,0x00000000},0x252b,0,1288},
+	{{0x00600401,0x00000101,0x00000000},0x252c,0,1288},
+	{{0x10600401,0x00000001,0x00000000},0x2533,0,1288},
+	{{0x00400401,0x08000101,0x00000000},0x2534,0,1288},
+	{{0x10400401,0x08000001,0x00000000},0x253b,0,1288},
+	{{0x00400401,0x40000101,0x00000000},0x253c,0,1288},
+	{{0x10400401,0x40000001,0x00000000},0x254b,0,1288},
+	{{0x00700401,0x00400000,0x00000000},0x2554,0,1288},
+	{{0x00700401,0x00000080,0x00000000},0x2557,0,1288},
+	{{0x00500401,0x08400000,0x00000000},0x255a,0,1288},
+	{{0x00500401,0x08000080,0x00000000},0x255d,0,1288},
+	{{0x00500401,0x40400000,0x00000000},0x2560,0,1288},
+	{{0x00500401,0x40000080,0x00000000},0x2563,0,1288},
+	{{0x00700401,0x00000001,0x00000000},0x2566,0,1288},
+	{{0x00500401,0x08000001,0x00000000},0x2569,0,1288},
+	{{0x00500401,0x40000001,0x00000000},0x256c,0,1288},
+	{{0x08000043,0x20300000,0x00000000},0x1f8a,0,1288},
+	{{0x08020043,0x20100000,0x00000000},0x1f8b,0,1288},
+	{{0x08000043,0x00320000,0x00000000},0x1f8c,0,1288},
+	{{0x08020043,0x00120000,0x00000000},0x1f8d,0,1288},
+	{{0x08000043,0x00380000,0x00000000},0x1f8e,0,1288},
+	{{0x08020043,0x00180000,0x00000000},0x1f8f,0,1288},
+	{{0x08800003,0x20300000,0x00000000},0x1f9a,0,1288},
+	{{0x08820003,0x20100000,0x00000000},0x1f9b,0,1288},
+	{{0x08800003,0x00320000,0x00000000},0x1f9c,0,1288},
+	{{0x08820003,0x00120000,0x00000000},0x1f9d,0,1288},
+	{{0x08800003,0x00380000,0x00000000},0x1f9e,0,1288},
+	{{0x08820003,0x00180000,0x00000000},0x1f9f,0,1288},
+	{{0x08000003,0x20308000,0x00000000},0x1faa,0,1288},
+	{{0x08020003,0x20108000,0x00000000},0x1fab,0,1288},
+	{{0x08000003,0x00328000,0x00000000},0x1fac,0,1288},
+	{{0x08020003,0x00128000,0x00000000},0x1fad,0,1288},
+	{{0x08000003,0x00388000,0x00000000},0x1fae,0,1288},
+	{{0x08020003,0x00188000,0x00000000},0x1faf,0,1288},
+	{{0x10600401,0x00400100,0x00000000},0x250d,0,1288},
+	{{0x10600401,0x00400100,0x00000000},0x250e,0,1288},
+	{{0x10600401,0x00000180,0x00000000},0x2511,0,1288},
+	{{0x10600401,0x00000180,0x00000000},0x2512,0,1288},
+	{{0x10400401,0x08400100,0x00000000},0x2515,0,1288},
+	{{0x10400401,0x08400100,0x00000000},0x2516,0,1288},
+	{{0x10400401,0x08000180,0x00000000},0x2519,0,1288},
+	{{0x10400401,0x08000180,0x00000000},0x251a,0,1288},
+	{{0x10400401,0x40400100,0x00000000},0x251d,0,1288},
+	{{0x10400401,0x40400100,0x00000000},0x2520,0,1288},
+	{{0x10400401,0x40000180,0x00000000},0x2525,0,1288},
+	{{0x10400401,0x40000180,0x00000000},0x2528,0,1288},
+	{{0x10600401,0x00000101,0x00000000},0x252f,0,1288},
+	{{0x10600401,0x00000101,0x00000000},0x2530,0,1288},
+	{{0x10400401,0x08000101,0x00000000},0x2537,0,1288},
+	{{0x10400401,0x08000101,0x00000000},0x2538,0,1288},
+	{{0x10400401,0x40000101,0x00000000},0x253f,0,1288},
+	{{0x10400401,0x40000101,0x00000000},0x2542,0,1288},
+	{{0x00700401,0x01400000,0x00000000},0x2552,0,1288},
+	{{0x00700401,0x01400000,0x00000000},0x2553,0,1288},
+	{{0x00700401,0x01000080,0x00000000},0x2555,0,1288},
+	{{0x00700401,0x01000080,0x00000000},0x2556,0,1288},
+	{{0x00500401,0x09400000,0x00000000},0x2558,0,1288},
+	{{0x00500401,0x09400000,0x00000000},0x2559,0,1288},
+	{{0x00500401,0x09000080,0x00000000},0x255b,0,1288},
+	{{0x00500401,0x09000080,0x00000000},0x255c,0,1288},
+	{{0x00500401,0x41400000,0x00000000},0x255e,0,1288},
+	{{0x00500401,0x41400000,0x00000000},0x255f,0,1288},
+	{{0x00500401,0x41000080,0x00000000},0x2561,0,1288},
+	{{0x00500401,0x41000080,0x00000000},0x2562,0,1288},
+	{{0x00700401,0x01000001,0x00000000},0x2564,0,1288},
+	{{0x00700401,0x01000001,0x00000000},0x2565,0,1288},
+	{{0x00500401,0x09000001,0x00000000},0x2567,0,1288},
+	{{0x00500401,0x09000001,0x00000000},0x2568,0,1288},
+	{{0x00500401,0x41000001,0x00000000},0x256a,0,1288},
+	{{0x00500401,0x41000001,0x00000000},0x256b,0,1288},
+	{{0x10600401,0x08400100,0x00000000},0x251e,0,1288},
+	{{0x10600401,0x08400100,0x00000000},0x251f,0,1288},
+	{{0x10600401,0x08400100,0x00000000},0x2521,0,1288},
+	{{0x10600401,0x08400100,0x00000000},0x2522,0,1288},
+	{{0x10600401,0x08000180,0x00000000},0x2526,0,1288},
+	{{0x10600401,0x08000180,0x00000000},0x2527,0,1288},
+	{{0x10600401,0x08000180,0x00000000},0x2529,0,1288},
+	{{0x10600401,0x08000180,0x00000000},0x252a,0,1288},
+	{{0x10600401,0x00400180,0x00000000},0x252d,0,1288},
+	{{0x10600401,0x00400180,0x00000000},0x252e,0,1288},
+	{{0x10600401,0x00400180,0x00000000},0x2531,0,1288},
+	{{0x10600401,0x00400180,0x00000000},0x2532,0,1288},
+	{{0x10400401,0x08400180,0x00000000},0x2535,0,1288},
+	{{0x10400401,0x08400180,0x00000000},0x2536,0,1288},
+	{{0x10400401,0x08400180,0x00000000},0x2539,0,1288},
+	{{0x10400401,0x08400180,0x00000000},0x253a,0,1288},
+	{{0x10400401,0x40400180,0x00000000},0x253d,0,1288},
+	{{0x10400401,0x40400180,0x00000000},0x253e,0,1288},
+	{{0x10600401,0x08000101,0x00000000},0x2540,0,1288},
+	{{0x10600401,0x08000101,0x00000000},0x2541,0,1288},
+	{{0x10600401,0x08000101,0x00000000},0x2547,0,1288},
+	{{0x10600401,0x08000101,0x00000000},0x2548,0,1288},
+	{{0x10400401,0x40400180,0x00000000},0x2549,0,1288},
+	{{0x10400401,0x40400180,0x00000000},0x254a,0,1288},
+	{{0x10600401,0x08400180,0x00000000},0x2543,0,1288},
+	{{0x10600401,0x08400180,0x00000000},0x2544,0,1288},
+	{{0x10600401,0x08400180,0x00000000},0x2545,0,1288},
+	{{0x10600401,0x08400180,0x00000000},0x2546,0,1288},
+	{{0x00000000,0x00000000,0x00000000},0x2198,1,3955},
+	{{0x00000000,0x00000000,0x00000000},0x1fef,1,2787},
+	{{0x00000000,0x00000000,0x00000000},0x203c,1,3237},
+	{{0x00000000,0x00000000,0x00000000},0x2016,1,2917},
+	{{0x00000000,0x00000000,0x00000000},0x1fed,1,2781},
+	{{0x00000000,0x00000000,0x00000000},0x226e,1,4568},
+	{{0x00000000,0x00000000,0x00000000},0x2260,1,4508},
+	{{0x00000000,0x00000000,0x00000000},0x226f,1,4583},
+	{{0x00000000,0x00000000,0x00000000},0x0301,1,560},
+	{{0x00000000,0x00000000,0x00000000},0x064c,1,1587},
+	{{0x00000000,0x00000000,0x00000000},0x309b,1,6688},
+	{{0x00000000,0x00000000,0x00000000},0x201c,1,2977},
+	{{0x00000000,0x00000000,0x00000000},0x20d1,1,3370},
+	{{0x00000000,0x00000000,0x00000000},0x201d,1,2980},
+	{{0x00000000,0x00000000,0x00000000},0x0300,1,557},
+	{{0x00000000,0x00000000,0x00000000},0x042c,1,1100},
+	{{0x00000000,0x00000000,0x00000000},0x044c,1,1118},
+	{{0x00000000,0x00000000,0x00000000},0x2030,1,3132},
+	{{0x00000000,0x00000000,0x00000000},0x066a,1,1678},
+	{{0x00000000,0x00000000,0x00000000},0x02dd,1,537},
+	{{0x00000000,0x00000000,0x00000000},0x0385,1,608},
+	{{0x00000000,0x00000000,0x00000000},0x02d8,1,522},
+	{{0x00000000,0x00000000,0x00000000},0x0384,1,595},
+	{{0x00000000,0x00000000,0x00000000},0x064f,1,1617},
+	{{0x00000000,0x00000000,0x00000000},0x203e,1,3250},
+	{{0x00000000,0x00000000,0x00000000},0x02d9,1,525},
+	{{0x00000000,0x00000000,0x00000000},0x02da,1,528},
+	{{0x00000000,0x00000000,0x00000000},0x2018,1,2923},
+	{{0x00000000,0x00000000,0x00000000},0x2019,1,2926},
+	{{0x00000000,0x00000000,0x00000000},0x02db,1,531},
+	{{0x00000000,0x00000000,0x00000000},0x02c7,1,504},
+	{{0x00000000,0x00000000,0x00000000},0x0374,1,563},
+	{{0x00000000,0x00000000,0x00000000},0x0149,1,150},
+	{{0x00000000,0x00000000,0x00000000},0x3010,1,6462},
+	{{0x00000000,0x00000000,0x00000000},0x3014,1,6501},
+	{{0x00000000,0x00000000,0x00000000},0x2208,1,4112},
+	{{0x00000000,0x00000000,0x00000000},0x2474,1,5047},
+	{{0x00000000,0x00000000,0x00000000},0x247d,1,5083},
+	{{0x00000000,0x00000000,0x00000000},0x247e,1,5088},
+	{{0x00000000,0x00000000,0x00000000},0x247f,1,5093},
+	{{0x00000000,0x00000000,0x00000000},0x2480,1,5098},
+	{{0x00000000,0x00000000,0x00000000},0x2481,1,5103},
+	{{0x00000000,0x00000000,0x00000000},0x2482,1,5108},
+	{{0x00000000,0x00000000,0x00000000},0x2483,1,5113},
+	{{0x00000000,0x00000000,0x00000000},0x2484,1,5118},
+	{{0x00000000,0x00000000,0x00000000},0x2485,1,5123},
+	{{0x00000000,0x00000000,0x00000000},0x2486,1,5128},
+	{{0x00000000,0x00000000,0x00000000},0x2475,1,5051},
+	{{0x00000000,0x00000000,0x00000000},0x2487,1,5133},
+	{{0x00000000,0x00000000,0x00000000},0x2476,1,5055},
+	{{0x00000000,0x00000000,0x00000000},0x2477,1,5059},
+	{{0x00000000,0x00000000,0x00000000},0x2478,1,5063},
+	{{0x00000000,0x00000000,0x00000000},0x2479,1,5067},
+	{{0x00000000,0x00000000,0x00000000},0x247a,1,5071},
+	{{0x00000000,0x00000000,0x00000000},0x247b,1,5075},
+	{{0x00000000,0x00000000,0x00000000},0x247c,1,5079},
+	{{0x00000000,0x00000000,0x00000000},0x2286,1,4608},
+	{{0x00000000,0x00000000,0x00000000},0x2312,1,4689},
+	{{0x00000000,0x00000000,0x00000000},0x249c,1,5209},
+	{{0x00000000,0x00000000,0x00000000},0x249d,1,5213},
+	{{0x00000000,0x00000000,0x00000000},0x2282,1,4593},
+	{{0x00000000,0x00000000,0x00000000},0x249e,1,5217},
+	{{0x00000000,0x00000000,0x00000000},0x249f,1,5221},
+	{{0x00000000,0x00000000,0x00000000},0x24a0,1,5225},
+	{{0x00000000,0x00000000,0x00000000},0x24a1,1,5229},
+	{{0x00000000,0x00000000,0x00000000},0x24a2,1,5233},
+	{{0x00000000,0x00000000,0x00000000},0x24a3,1,5237},
+	{{0x00000000,0x00000000,0x00000000},0x3016,1,6507},
+	{{0x00000000,0x00000000,0x00000000},0x24a4,1,5241},
+	{{0x00000000,0x00000000,0x00000000},0x24a5,1,5245},
+	{{0x00000000,0x00000000,0x00000000},0x321c,1,6897},
+	{{0x00000000,0x00000000,0x00000000},0x24a6,1,5249},
+	{{0x00000000,0x00000000,0x00000000},0x24a7,1,5253},
+	{{0x00000000,0x00000000,0x00000000},0x24a8,1,5257},
+	{{0x00000000,0x00000000,0x00000000},0x24a9,1,5261},
+	{{0x00000000,0x00000000,0x00000000},0x24aa,1,5265},
+	{{0x00000000,0x00000000,0x00000000},0x24ab,1,5269},
+	{{0x00000000,0x00000000,0x00000000},0x24ac,1,5273},
+	{{0x00000000,0x00000000,0x00000000},0x24ad,1,5277},
+	{{0x00000000,0x00000000,0x00000000},0x207d,1,3309},
+	{{0x00000000,0x00000000,0x00000000},0x208d,1,3309},
+	{{0x00000000,0x00000000,0x00000000},0x24ae,1,5281},
+	{{0x00000000,0x00000000,0x00000000},0x24af,1,5285},
+	{{0x00000000,0x00000000,0x00000000},0x2229,1,4332},
+	{{0x00000000,0x00000000,0x00000000},0x24b0,1,5289},
+	{{0x00000000,0x00000000,0x00000000},0x24b1,1,5293},
+	{{0x00000000,0x00000000,0x00000000},0x24b2,1,5297},
+	{{0x00000000,0x00000000,0x00000000},0x24b3,1,5301},
+	{{0x00000000,0x00000000,0x00000000},0x24b4,1,5305},
+	{{0x00000000,0x00000000,0x00000000},0x24b5,1,5309},
+	{{0x00000000,0x00000000,0x00000000},0x3011,1,6465},
+	{{0x00000000,0x00000000,0x00000000},0x3015,1,6504},
+	{{0x00000000,0x00000000,0x00000000},0x1fbd,1,2661},
+	{{0x00000000,0x00000000,0x00000000},0x2287,1,4611},
+	{{0x00000000,0x00000000,0x00000000},0x2283,1,4605},
+	{{0x00000000,0x00000000,0x00000000},0x3017,1,6510},
+	{{0x00000000,0x00000000,0x00000000},0x207e,1,3312},
+	{{0x00000000,0x00000000,0x00000000},0x208e,1,3312},
+	{{0x00000000,0x00000000,0x00000000},0x222a,1,4341},
+	{{0x00000000,0x00000000,0x00000000},0x2217,1,4220},
+	{{0x00000000,0x00000000,0x00000000},0x2606,1,6049},
+	{{0x00000000,0x00000000,0x00000000},0x2605,1,6046},
+	{{0x00000000,0x00000000,0x00000000},0x309d,1,6712},
+	{{0x00000000,0x00000000,0x00000000},0x30fd,1,6784},
+	{{0x00000000,0x00000000,0x00000000},0x226b,1,4556},
+	{{0x00000000,0x00000000,0x00000000},0x3005,1,6409},
+	{{0x00000000,0x00000000,0x00000000},0x220f,1,4160},
+	{{0x00000000,0x00000000,0x00000000},0x03c2,1,818},
+	{{0x00000000,0x00000000,0x00000000},0x3003,1,6356},
+	{{0x00000000,0x00000000,0x00000000},0x0640,1,1515},
+	{{0x00000000,0x00000000,0x00000000},0x309e,1,6732},
+	{{0x00000000,0x00000000,0x00000000},0x30fe,1,6787},
+	{{0x00000000,0x00000000,0x00000000},0x207a,1,3294},
+	{{0x00000000,0x00000000,0x00000000},0x208a,1,3294},
+	{{0x00000000,0x00000000,0x00000000},0x2211,1,4179},
+	{{0x00000000,0x00000000,0x00000000},0x1fcd,1,2701},
+	{{0x00000000,0x00000000,0x00000000},0x1fce,1,2704},
+	{{0x00000000,0x00000000,0x00000000},0x060c,1,1330},
+	{{0x00000000,0x00000000,0x00000000},0x1fbf,1,2664},
+	{{0x00000000,0x00000000,0x00000000},0x3001,1,6344},
+	{{0x00000000,0x00000000,0x00000000},0x0375,1,572},
+	{{0x00000000,0x00000000,0x00000000},0x2191,1,3878},
+	{{0x00000000,0x00000000,0x00000000},0x220b,1,4134},
+	{{0x00000000,0x00000000,0x00000000},0x2213,1,4196},
+	{{0x00000000,0x00000000,0x00000000},0x2212,1,4182},
+	{{0x00000000,0x00000000,0x00000000},0x2015,1,2914},
+	{{0x00000000,0x00000000,0x00000000},0x30fc,1,6781},
+	{{0x00000000,0x00000000,0x00000000},0x2192,1,3892},
+	{{0x00000000,0x00000000,0x00000000},0x301c,1,6523},
+	{{0x00000000,0x00000000,0x00000000},0x2043,1,3267},
+	{{0x00000000,0x00000000,0x00000000},0x221f,1,4293},
+	{{0x00000000,0x00000000,0x00000000},0x2014,1,2911},
+	{{0x00000000,0x00000000,0x00000000},0x2013,1,2900},
+	{{0x00000000,0x00000000,0x00000000},0x207b,1,3303},
+	{{0x00000000,0x00000000,0x00000000},0x208b,1,3303},
+	{{0x00000000,0x00000000,0x00000000},0x22a5,1,4625},
+	{{0x00000000,0x00000000,0x00000000},0x2193,1,3905},
+	{{0x00000000,0x00000000,0x00000000},0x2220,1,3905},
+	{{0x00000000,0x00000000,0x00000000},0x2720,1,6338},
+	{{0x00000000,0x00000000,0x00000000},0x0387,1,625},
+	{{0x00000000,0x00000000,0x00000000},0x2214,1,4199},
+	{{0x00000000,0x00000000,0x00000000},0x2027,1,3074},
+	{{0x00000000,0x00000000,0x00000000},0x2025,1,3041},
+	{{0x00000000,0x00000000,0x00000000},0x2026,1,3053},
+	{{0x00000000,0x00000000,0x00000000},0x30fb,1,6762},
+	{{0x00000000,0x00000000,0x00000000},0x201a,1,2945},
+	{{0x00000000,0x00000000,0x00000000},0x2234,1,4383},
+	{{0x00000000,0x00000000,0x00000000},0x3002,1,6347},
+	{{0x00000000,0x00000000,0x00000000},0x22c5,1,4628},
+	{{0x00000000,0x00000000,0x00000000},0x2591,1,5704},
+	{{0x00000000,0x00000000,0x00000000},0x1ffd,1,2813},
+	{{0x00000000,0x00000000,0x00000000},0x064e,1,1608},
+	{{0x00000000,0x00000000,0x00000000},0x2020,1,2996},
+	{{0x00000000,0x00000000,0x00000000},0x2197,1,3940},
+	{{0x00000000,0x00000000,0x00000000},0x2205,1,4085},
+	{{0x00000000,0x00000000,0x00000000},0x2021,1,2999},
+	{{0x00000000,0x00000000,0x00000000},0x232a,1,4785},
+	{{0x00000000,0x00000000,0x00000000},0x2044,1,3270},
+	{{0x00000000,0x00000000,0x00000000},0x221d,1,4272},
+	{{0x00000000,0x00000000,0x00000000},0x0652,1,1645},
+	{{0x00000000,0x00000000,0x00000000},0x24ea,1,5417},
+	{{0x00000000,0x00000000,0x00000000},0x2299,1,4614},
+	{{0x00000000,0x00000000,0x00000000},0x221e,1,4284},
+	{{0x00000000,0x00000000,0x00000000},0x229a,1,4617},
+	{{0x00000000,0x00000000,0x00000000},0x309c,1,6709},
+	{{0x00000000,0x00000000,0x00000000},0x3007,1,6423},
+	{{0x00000000,0x00000000,0x00000000},0x0660,1,1648},
+	{{0x00000000,0x00000000,0x00000000},0x25d0,1,5969},
+	{{0x00000000,0x00000000,0x00000000},0x25cb,1,5954},
+	{{0x00000000,0x00000000,0x00000000},0x25cf,1,5954},
+	{{0x00000000,0x00000000,0x00000000},0x25ce,1,5966},
+	{{0x00000000,0x00000000,0x00000000},0x25d1,1,5972},
+	{{0x00000000,0x00000000,0x00000000},0x2070,1,3273},
+	{{0x00000000,0x00000000,0x00000000},0x2080,1,3273},
+	{{0x00000000,0x00000000,0x00000000},0x263a,1,6100},
+	{{0x00000000,0x00000000,0x00000000},0x263b,1,6100},
+	{{0x00000000,0x00000000,0x00000000},0x02cb,1,519},
+	{{0x00000000,0x00000000,0x00000000},0x2035,1,3178},
+	{{0x00000000,0x00000000,0x00000000},0x2032,1,3141},
+	{{0x00000000,0x00000000,0x00000000},0x0650,1,1626},
+	{{0x00000000,0x00000000,0x00000000},0x02c9,1,516},
+	{{0x00000000,0x00000000,0x00000000},0x2460,1,4887},
+	{{0x00000000,0x00000000,0x00000000},0x2488,1,5138},
+	{{0x00000000,0x00000000,0x00000000},0x2469,1,4923},
+	{{0x00000000,0x00000000,0x00000000},0x2491,1,5165},
+	{{0x00000000,0x00000000,0x00000000},0x2182,1,3850},
+	{{0x00000000,0x00000000,0x00000000},0x216f,1,3790},
+	{{0x00000000,0x00000000,0x00000000},0x217f,1,3790},
+	{{0x00000000,0x00000000,0x00000000},0x2180,1,3809},
+	{{0x00000000,0x00000000,0x00000000},0x216d,1,3758},
+	{{0x00000000,0x00000000,0x00000000},0x217d,1,3758},
+	{{0x00000000,0x00000000,0x00000000},0x3229,1,6929},
+	{{0x00000000,0x00000000,0x00000000},0x246a,1,4928},
+	{{0x00000000,0x00000000,0x00000000},0x2492,1,5169},
+	{{0x00000000,0x00000000,0x00000000},0x246b,1,4933},
+	{{0x00000000,0x00000000,0x00000000},0x2493,1,5173},
+	{{0x00000000,0x00000000,0x00000000},0x2153,1,3534},
+	{{0x00000000,0x00000000,0x00000000},0x246c,1,4947},
+	{{0x00000000,0x00000000,0x00000000},0x2494,1,5177},
+	{{0x00000000,0x00000000,0x00000000},0x246d,1,4961},
+	{{0x00000000,0x00000000,0x00000000},0x2495,1,5181},
+	{{0x00000000,0x00000000,0x00000000},0x2155,1,3557},
+	{{0x00000000,0x00000000,0x00000000},0x246e,1,4974},
+	{{0x00000000,0x00000000,0x00000000},0x2496,1,5185},
+	{{0x00000000,0x00000000,0x00000000},0x2159,1,3611},
+	{{0x00000000,0x00000000,0x00000000},0x246f,1,4987},
+	{{0x00000000,0x00000000,0x00000000},0x2497,1,5189},
+	{{0x00000000,0x00000000,0x00000000},0x2470,1,5002},
+	{{0x00000000,0x00000000,0x00000000},0x2498,1,5193},
+	{{0x00000000,0x00000000,0x00000000},0x215b,1,3636},
+	{{0x00000000,0x00000000,0x00000000},0x2471,1,5016},
+	{{0x00000000,0x00000000,0x00000000},0x2499,1,5197},
+	{{0x00000000,0x00000000,0x00000000},0x2472,1,5030},
+	{{0x00000000,0x00000000,0x00000000},0x249a,1,5201},
+	{{0x00000000,0x00000000,0x00000000},0x02c6,1,501},
+	{{0x00000000,0x00000000,0x00000000},0x02dc,1,534},
+	{{0x00000000,0x00000000,0x00000000},0x0661,1,1651},
+	{{0x00000000,0x00000000,0x00000000},0x3220,1,6902},
+	{{0x00000000,0x00000000,0x00000000},0x200a,1,2883},
+	{{0x00000000,0x00000000,0x00000000},0x2440,1,2883},
+	{{0x00000000,0x00000000,0x00000000},0x2446,1,4840},
+	{{0x00000000,0x00000000,0x00000000},0x2003,1,2822},
+	{{0x00000000,0x00000000,0x00000000},0x2002,1,2819},
+	{{0x00000000,0x00000000,0x00000000},0x2160,1,3689},
+	{{0x00000000,0x00000000,0x00000000},0x2170,1,3689},
+	{{0x00000000,0x00000000,0x00000000},0x2081,0,2739},
+	{{0x00000000,0x00000000,0x00000000},0x2009,1,2875},
+	{{0x00000000,0x00000000,0x00000000},0x2036,1,3181},
+	{{0x00000000,0x00000000,0x00000000},0x2033,1,3144},
+	{{0x00000000,0x00000000,0x00000000},0x2461,1,4891},
+	{{0x00000000,0x00000000,0x00000000},0x2489,1,5141},
+	{{0x00000000,0x00000000,0x00000000},0x2473,1,5042},
+	{{0x00000000,0x00000000,0x00000000},0x249b,1,5205},
+	{{0x00000000,0x00000000,0x00000000},0x2154,1,3548},
+	{{0x00000000,0x00000000,0x00000000},0x2156,1,3571},
+	{{0x00000000,0x00000000,0x00000000},0x0662,1,1654},
+	{{0x00000000,0x00000000,0x00000000},0x3221,1,6905},
+	{{0x00000000,0x00000000,0x00000000},0x2442,1,4807},
+	{{0x00000000,0x00000000,0x00000000},0x2447,1,4856},
+	{{0x00000000,0x00000000,0x00000000},0x2161,1,3692},
+	{{0x00000000,0x00000000,0x00000000},0x2171,1,3692},
+	{{0x00000000,0x00000000,0x00000000},0x2082,0,2704},
+	{{0x00000000,0x00000000,0x00000000},0x2506,1,5459},
+	{{0x00000000,0x00000000,0x00000000},0x2037,1,3206},
+	{{0x00000000,0x00000000,0x00000000},0x2034,1,3160},
+	{{0x00000000,0x00000000,0x00000000},0x0651,1,1636},
+	{{0x00000000,0x00000000,0x00000000},0xfe7d,1,6983},
+	{{0x00000000,0x00000000,0x00000000},0x2504,1,5453},
+	{{0x00000000,0x00000000,0x00000000},0x2462,1,4895},
+	{{0x00000000,0x00000000,0x00000000},0x248a,1,5144},
+	{{0x00000000,0x00000000,0x00000000},0x2507,1,5462},
+	{{0x00000000,0x00000000,0x00000000},0x2157,1,3587},
+	{{0x00000000,0x00000000,0x00000000},0x215c,1,3653},
+	{{0x00000000,0x00000000,0x00000000},0x2505,1,5456},
+	{{0x00000000,0x00000000,0x00000000},0x0663,1,1657},
+	{{0x00000000,0x00000000,0x00000000},0x2023,1,3027},
+	{{0x00000000,0x00000000,0x00000000},0x3222,1,6908},
+	{{0x00000000,0x00000000,0x00000000},0x2441,1,4799},
+	{{0x00000000,0x00000000,0x00000000},0x2448,1,4864},
+	{{0x00000000,0x00000000,0x00000000},0x2004,1,2838},
+	{{0x00000000,0x00000000,0x00000000},0x2162,1,3695},
+	{{0x00000000,0x00000000,0x00000000},0x2172,1,3695},
+	{{0x00000000,0x00000000,0x00000000},0x2083,0,2707},
+	{{0x00000000,0x00000000,0x00000000},0x250a,1,5486},
+	{{0x00000000,0x00000000,0x00000000},0x2508,1,5480},
+	{{0x00000000,0x00000000,0x00000000},0x2463,1,4899},
+	{{0x00000000,0x00000000,0x00000000},0x248b,1,5147},
+	{{0x00000000,0x00000000,0x00000000},0x250b,1,5489},
+	{{0x00000000,0x00000000,0x00000000},0x2158,1,3602},
+	{{0x00000000,0x00000000,0x00000000},0x2509,1,5483},
+	{{0x00000000,0x00000000,0x00000000},0x0664,1,1660},
+	{{0x00000000,0x00000000,0x00000000},0x3223,1,6911},
+	{{0x00000000,0x00000000,0x00000000},0x2443,1,4810},
+	{{0x00000000,0x00000000,0x00000000},0x2449,1,4884},
+	{{0x00000000,0x00000000,0x00000000},0x2005,1,2853},
+	{{0x00000000,0x00000000,0x00000000},0x2163,1,3698},
+	{{0x00000000,0x00000000,0x00000000},0x2173,1,3698},
+	{{0x00000000,0x00000000,0x00000000},0x2074,1,3276},
+	{{0x00000000,0x00000000,0x00000000},0x2084,1,3276},
+	{{0x00000000,0x00000000,0x00000000},0x2464,1,4903},
+	{{0x00000000,0x00000000,0x00000000},0x248c,1,5150},
+	{{0x00000000,0x00000000,0x00000000},0x2181,1,3831},
+	{{0x00000000,0x00000000,0x00000000},0x216e,1,3776},
+	{{0x00000000,0x00000000,0x00000000},0x217e,1,3776},
+	{{0x00000000,0x00000000,0x00000000},0x216c,1,3746},
+	{{0x00000000,0x00000000,0x00000000},0x217c,1,3746},
+	{{0x00000000,0x00000000,0x00000000},0x215a,1,3626},
+	{{0x00000000,0x00000000,0x00000000},0x215d,1,3669},
+	{{0x00000000,0x00000000,0x00000000},0x0665,1,1663},
+	{{0x00000000,0x00000000,0x00000000},0x3224,1,6914},
+	{{0x00000000,0x00000000,0x00000000},0x2164,1,3701},
+	{{0x00000000,0x00000000,0x00000000},0x2174,1,3701},
+	{{0x00000000,0x00000000,0x00000000},0x2075,1,3279},
+	{{0x00000000,0x00000000,0x00000000},0x2085,1,3279},
+	{{0x00000000,0x00000000,0x00000000},0x2465,1,4907},
+	{{0x00000000,0x00000000,0x00000000},0x248d,1,5153},
+	{{0x00000000,0x00000000,0x00000000},0x0666,1,1666},
+	{{0x00000000,0x00000000,0x00000000},0x3225,1,6917},
+	{{0x00000000,0x00000000,0x00000000},0x2006,1,2867},
+	{{0x00000000,0x00000000,0x00000000},0x2165,1,3704},
+	{{0x00000000,0x00000000,0x00000000},0x2175,1,3704},
+	{{0x00000000,0x00000000,0x00000000},0x2076,1,3282},
+	{{0x00000000,0x00000000,0x00000000},0x2086,1,3282},
+	{{0x00000000,0x00000000,0x00000000},0x2466,1,4911},
+	{{0x00000000,0x00000000,0x00000000},0x248e,1,5156},
+	{{0x00000000,0x00000000,0x00000000},0x215e,1,3686},
+	{{0x00000000,0x00000000,0x00000000},0x230a,1,4663},
+	{{0x00000000,0x00000000,0x00000000},0x230b,1,4666},
+	{{0x00000000,0x00000000,0x00000000},0x0667,1,1669},
+	{{0x00000000,0x00000000,0x00000000},0x3226,1,6920},
+	{{0x00000000,0x00000000,0x00000000},0x2166,1,3707},
+	{{0x00000000,0x00000000,0x00000000},0x2176,1,3707},
+	{{0x00000000,0x00000000,0x00000000},0x2077,1,3285},
+	{{0x00000000,0x00000000,0x00000000},0x2087,1,3285},
+	{{0x00000000,0x00000000,0x00000000},0x2467,1,4915},
+	{{0x00000000,0x00000000,0x00000000},0x248f,1,5159},
+	{{0x00000000,0x00000000,0x00000000},0x2318,1,4729},
+	{{0x00000000,0x00000000,0x00000000},0x0668,1,1672},
+	{{0x00000000,0x00000000,0x00000000},0x3227,1,6923},
+	{{0x00000000,0x00000000,0x00000000},0x2167,1,3710},
+	{{0x00000000,0x00000000,0x00000000},0x2177,1,3710},
+	{{0x00000000,0x00000000,0x00000000},0x2078,1,3288},
+	{{0x00000000,0x00000000,0x00000000},0x2088,1,3288},
+	{{0x00000000,0x00000000,0x00000000},0x201f,1,2986},
+	{{0x00000000,0x00000000,0x00000000},0x201b,1,2974},
+	{{0x00000000,0x00000000,0x00000000},0x2468,1,4919},
+	{{0x00000000,0x00000000,0x00000000},0x2490,1,5162},
+	{{0x00000000,0x00000000,0x00000000},0x0669,1,1675},
+	{{0x00000000,0x00000000,0x00000000},0x3228,1,6926},
+	{{0x00000000,0x00000000,0x00000000},0x2168,1,3713},
+	{{0x00000000,0x00000000,0x00000000},0x2178,1,3713},
+	{{0x00000000,0x00000000,0x00000000},0x2079,1,3291},
+	{{0x00000000,0x00000000,0x00000000},0x2089,1,3291},
+	{{0x00000000,0x00000000,0x00000000},0x1fee,1,2784},
+	{{0x00000000,0x00000000,0x00000000},0x064b,1,1575},
+	{{0x00000000,0x00000000,0x00000000},0x2235,1,4394},
+	{{0x00000000,0x00000000,0x00000000},0x22ee,1,4631},
+	{{0x00000000,0x00000000,0x00000000},0x201e,1,2983},
+	{{0x00000000,0x00000000,0x00000000},0x2237,1,4417},
+	{{0x00000000,0x00000000,0x00000000},0x2236,1,4403},
+	{{0x00000000,0x00000000,0x00000000},0x2592,1,5720},
+	{{0x00000000,0x00000000,0x00000000},0x203b,1,3234},
+	{{0x00000000,0x00000000,0x00000000},0x1fdd,1,2737},
+	{{0x00000000,0x00000000,0x00000000},0x1fde,1,2740},
+	{{0x00000000,0x00000000,0x00000000},0x061b,1,1333},
+	{{0x00000000,0x00000000,0x00000000},0x1ffe,1,2816},
+	{{0x00000000,0x00000000,0x00000000},0x3006,1,6420},
+	{{0x00000000,0x00000000,0x00000000},0x02bb,1,482},
+	{{0x00000000,0x00000000,0x00000000},0x2196,1,3925},
+	{{0x00000000,0x00000000,0x00000000},0x300e,1,6445},
+	{{0x00000000,0x00000000,0x00000000},0x300c,1,6439},
+	{{0x00000000,0x00000000,0x00000000},0x226a,1,4540},
+	{{0x00000000,0x00000000,0x00000000},0x300a,1,6426},
+	{{0x00000000,0x00000000,0x00000000},0x2190,1,3867},
+	{{0x00000000,0x00000000,0x00000000},0x2329,1,4782},
+	{{0x00000000,0x00000000,0x00000000},0x2199,1,3970},
+	{{0x00000000,0x00000000,0x00000000},0x2039,1,3218},
+	{{0x00000000,0x00000000,0x00000000},0x2308,1,4651},
+	{{0x00000000,0x00000000,0x00000000},0x21d0,1,4018},
+	{{0x00000000,0x00000000,0x00000000},0x2194,1,3908},
+	{{0x00000000,0x00000000,0x00000000},0x261c,1,6081},
+	{{0x00000000,0x00000000,0x00000000},0x042a,1,1084},
+	{{0x00000000,0x00000000,0x00000000},0x044a,1,1115},
+	{{0x00000000,0x00000000,0x00000000},0x064d,1,1599},
+	{{0x00000000,0x00000000,0x00000000},0x2017,1,2920},
+	{{0x00000000,0x00000000,0x00000000},0x2261,1,4521},
+	{{0x00000000,0x00000000,0x00000000},0x2264,1,4524},
+	{{0x00000000,0x00000000,0x00000000},0x21d4,1,4024},
+	{{0x00000000,0x00000000,0x00000000},0x21d2,1,4021},
+	{{0x00000000,0x00000000,0x00000000},0x224c,1,4482},
+	{{0x00000000,0x00000000,0x00000000},0x3013,1,6483},
+	{{0x00000000,0x00000000,0x00000000},0x207c,1,3306},
+	{{0x00000000,0x00000000,0x00000000},0x208c,1,3306},
+	{{0x00000000,0x00000000,0x00000000},0x3012,1,6475},
+	{{0x00000000,0x00000000,0x00000000},0x3020,1,6538},
+	{{0x00000000,0x00000000,0x00000000},0x300f,1,6448},
+	{{0x00000000,0x00000000,0x00000000},0x300d,1,6442},
+	{{0x00000000,0x00000000,0x00000000},0x300b,1,6429},
+	{{0x00000000,0x00000000,0x00000000},0x203a,1,3221},
+	{{0x00000000,0x00000000,0x00000000},0x2309,1,4654},
+	{{0x00000000,0x00000000,0x00000000},0x2265,1,4527},
+	{{0x00000000,0x00000000,0x00000000},0x261e,1,6084},
+	{{0x00000000,0x00000000,0x00000000},0x21c0,1,4015},
+	{{0x00000000,0x00000000,0x00000000},0x037e,1,592},
+	{{0x00000000,0x00000000,0x00000000},0x1fc0,1,2667},
+	{{0x00000000,0x00000000,0x00000000},0x061f,1,1336},
+	{{0x00000000,0x00000000,0x00000000},0x1fcf,1,2707},
+	{{0x00000000,0x00000000,0x00000000},0x2243,1,4448},
+	{{0x00000000,0x00000000,0x00000000},0x223c,1,4420},
+	{{0x00000000,0x00000000,0x00000000},0x2248,1,4475},
+	{{0x00000000,0x00000000,0x00000000},0x1fc1,1,2670},
+	{{0x00000000,0x00000000,0x00000000},0x1fdf,1,2743},
+	{{0x00000000,0x00000000,0x00000000},0x2245,1,4465},
+	{{0x00000000,0x00000000,0x00000000},0x2593,1,5734},
+	{{0x00000000,0x00000000,0x00000000},0x2502,1,5434},
+	{{0x00000000,0x00000000,0x00000000},0x253c,1,5601},
+	{{0x00000000,0x00000000,0x00000000},0x2524,1,5556},
+	{{0x00000000,0x00000000,0x00000000},0x251c,1,5541},
+	{{0x00000000,0x00000000,0x00000000},0x2500,1,5421},
+	{{0x00000000,0x00000000,0x00000000},0x2534,1,5586},
+	{{0x00000000,0x00000000,0x00000000},0x25e2,1,6023},
+	{{0x00000000,0x00000000,0x00000000},0x2501,1,5428},
+	{{0x00000000,0x00000000,0x00000000},0x2571,1,5649},
+	{{0x00000000,0x00000000,0x00000000},0x2518,1,5530},
+	{{0x00000000,0x00000000,0x00000000},0x2514,1,5519},
+	{{0x00000000,0x00000000,0x00000000},0x266a,1,6206},
+	{{0x00000000,0x00000000,0x00000000},0x252c,1,5571},
+	{{0x00000000,0x00000000,0x00000000},0x2510,1,5503},
+	{{0x00000000,0x00000000,0x00000000},0x250c,1,5495},
+	{{0x40000001,0x00000000,0x00000000},0x3042,0,1546},
+	{{0x00000001,0x00000020,0x00000000},0x30a2,0,1546},
+	{{0x00000201,0x00000000,0x00000000},0x311a,0,1546},
+	{{0x00010003,0x00000000,0x00000000},0x0410,0,1546},
+	{{0x00010005,0x00000000,0x00000000},0x0430,0,1546},
+	{{0x40000005,0x00000000,0x00000000},0x3041,0,1546},
+	{{0x00000005,0x00000020,0x00000000},0x30a1,0,1546},
+	{{0x00000003,0x00000440,0x00000000},0x0100,0,1546},
+	{{0x00000005,0x00000440,0x00000000},0x0101,0,1546},
+	{{0x00000803,0x00000040,0x00000000},0x0102,0,1546},
+	{{0x00000805,0x00000040,0x00000000},0x0103,0,1546},
+	{{0x00000003,0x00000040,0x02000000},0x0104,0,1546},
+	{{0x00000005,0x00000040,0x02000000},0x0105,0,1546},
+	{{0x00001003,0x00000040,0x00000000},0x01cd,0,1546},
+	{{0x00001005,0x00000040,0x00000000},0x01ce,0,1546},
+	{{0x00000005,0x00040040,0x00000000},0x249c,0,1546},
+	{{0x00004003,0x00000040,0x00000000},0x24b6,0,1546},
+	{{0x00004005,0x00000040,0x00000000},0x24d0,0,1546},
+	{{0x00040003,0x00000440,0x00000000},0x01de,0,1546},
+	{{0x00040005,0x00000440,0x00000000},0x01df,0,1546},
+	{{0x04100003,0x00000040,0x00000000},0x0200,0,1546},
+	{{0x04100005,0x00000040,0x00000000},0x0201,0,1546},
+	{{0x00000803,0x00000040,0x00800000},0x0202,0,1546},
+	{{0x00000805,0x00000040,0x00800000},0x0203,0,1546},
+	{{0x00000103,0x00000040,0x04000000},0x1e00,0,1546},
+	{{0x00000105,0x00000040,0x04000000},0x1e01,0,1546},
+	{{0x00080103,0x00000040,0x00000000},0x1ea0,0,1546},
+	{{0x00080105,0x00000040,0x00000000},0x1ea1,0,1546},
+	{{0x8000000b,0x00000040,0x00000000},0x1ea2,0,1546},
+	{{0x8000000d,0x00000040,0x00000000},0x1ea3,0,1546},
+	{{0x00008013,0x00000040,0x00000000},0x1ea4,0,1546},
+	{{0x00008015,0x00000040,0x00000000},0x1ea5,0,1546},
+	{{0x04008003,0x00000040,0x00000000},0x1ea6,0,1546},
+	{{0x04008005,0x00000040,0x00000000},0x1ea7,0,1546},
+	{{0x00008003,0x02000040,0x00000000},0x1eaa,0,1546},
+	{{0x00008005,0x02000040,0x00000000},0x1eab,0,1546},
+	{{0x00000813,0x00000040,0x00000000},0x1eae,0,1546},
+	{{0x00000815,0x00000040,0x00000000},0x1eaf,0,1546},
+	{{0x04000803,0x00000040,0x00000000},0x1eb0,0,1546},
+	{{0x04000805,0x00000040,0x00000000},0x1eb1,0,1546},
+	{{0x00000803,0x02000040,0x00000000},0x1eb4,0,1546},
+	{{0x00000805,0x02000040,0x00000000},0x1eb5,0,1546},
+	{{0x0008000b,0x00000440,0x00000000},0x01e0,0,1546},
+	{{0x0008000d,0x00000440,0x00000000},0x01e1,0,1546},
+	{{0x0000001b,0x00000040,0x04000000},0x01fa,0,1546},
+	{{0x0000001d,0x00000040,0x04000000},0x01fb,0,1546},
+	{{0x8000800b,0x00000040,0x00000000},0x1ea8,0,1546},
+	{{0x8000800d,0x00000040,0x00000000},0x1ea9,0,1546},
+	{{0x00088103,0x00000040,0x00000000},0x1eac,0,1546},
+	{{0x00088105,0x00000040,0x00000000},0x1ead,0,1546},
+	{{0x8000080b,0x00000040,0x00000000},0x1eb2,0,1546},
+	{{0x8000080d,0x00000040,0x00000000},0x1eb3,0,1546},
+	{{0x00080903,0x00000040,0x00000000},0x1eb6,0,1546},
+	{{0x00080905,0x00000040,0x00000000},0x1eb7,0,1546},
+	{{0x00000000,0x00000000,0x00000000},0x24b6,1,5313},
+	{{0x00000000,0x00000000,0x00000000},0x24d0,1,5313},
+	{{0x00000000,0x00000000,0x00000000},0x0200,1,404},
+	{{0x00000000,0x00000000,0x00000000},0x0201,1,404},
+	{{0x00000000,0x00000000,0x00000000},0x0386,1,611},
+	{{0x00000000,0x00000000,0x00000000},0x03ac,1,611},
+	{{0x00000000,0x00000000,0x00000000},0x0102,1,3},
+	{{0x00000000,0x00000000,0x00000000},0x0103,1,3},
+	{{0x00000000,0x00000000,0x00000000},0x1eb0,1,2030},
+	{{0x00000000,0x00000000,0x00000000},0x1eb1,1,2030},
+	{{0x00000000,0x00000000,0x00000000},0x1eae,1,2026},
+	{{0x00000000,0x00000000,0x00000000},0x1eaf,1,2026},
+	{{0x00000000,0x00000000,0x00000000},0x1eb6,1,2042},
+	{{0x00000000,0x00000000,0x00000000},0x1eb7,1,2042},
+	{{0x00000000,0x00000000,0x00000000},0x1eb2,1,2034},
+	{{0x00000000,0x00000000,0x00000000},0x1eb3,1,2034},
+	{{0x00000000,0x00000000,0x00000000},0x1eb4,1,2038},
+	{{0x00000000,0x00000000,0x00000000},0x1eb5,1,2038},
+	{{0x00000000,0x00000000,0x00000000},0x0202,1,408},
+	{{0x00000000,0x00000000,0x00000000},0x0203,1,408},
+	{{0x00000000,0x00000000,0x00000000},0x0391,1,665},
+	{{0x00000000,0x00000000,0x00000000},0x03b1,1,665},
+	{{0x00000000,0x00000000,0x00000000},0x1f70,1,2421},
+	{{0x00000000,0x00000000,0x00000000},0x1fba,1,2421},
+	{{0x00000000,0x00000000,0x00000000},0x1fb2,1,2630},
+	{{0x00000000,0x00000000,0x00000000},0x1f71,1,2425},
+	{{0x00000000,0x00000000,0x00000000},0x1fbb,1,2425},
+	{{0x00000000,0x00000000,0x00000000},0x1fb4,1,2639},
+	{{0x00000000,0x00000000,0x00000000},0x1fb0,1,2622},
+	{{0x00000000,0x00000000,0x00000000},0x1fb8,1,2622},
+	{{0x00000000,0x00000000,0x00000000},0x1f00,1,2175},
+	{{0x00000000,0x00000000,0x00000000},0x1f08,1,2175},
+	{{0x00000000,0x00000000,0x00000000},0x1f02,1,2183},
+	{{0x00000000,0x00000000,0x00000000},0x1f0a,1,2183},
+	{{0x00000000,0x00000000,0x00000000},0x1f82,1,2487},
+	{{0x00000000,0x00000000,0x00000000},0x1f8a,1,2487},
+	{{0x00000000,0x00000000,0x00000000},0x1f04,1,2193},
+	{{0x00000000,0x00000000,0x00000000},0x1f0c,1,2193},
+	{{0x00000000,0x00000000,0x00000000},0x1f84,1,2499},
+	{{0x00000000,0x00000000,0x00000000},0x1f8c,1,2499},
+	{{0x00000000,0x00000000,0x00000000},0x1f06,1,2203},
+	{{0x00000000,0x00000000,0x00000000},0x1f0e,1,2203},
+	{{0x00000000,0x00000000,0x00000000},0x1f86,1,2511},
+	{{0x00000000,0x00000000,0x00000000},0x1f8e,1,2511},
+	{{0x00000000,0x00000000,0x00000000},0x1f80,1,2477},
+	{{0x00000000,0x00000000,0x00000000},0x1f88,1,2477},
+	{{0x00000000,0x00000000,0x00000000},0x1fb1,1,2626},
+	{{0x00000000,0x00000000,0x00000000},0x1fb9,1,2626},
+	{{0x00000000,0x00000000,0x00000000},0x1f01,1,2179},
+	{{0x00000000,0x00000000,0x00000000},0x1f09,1,2179},
+	{{0x00000000,0x00000000,0x00000000},0x1f03,1,2188},
+	{{0x00000000,0x00000000,0x00000000},0x1f0b,1,2188},
+	{{0x00000000,0x00000000,0x00000000},0x1f83,1,2493},
+	{{0x00000000,0x00000000,0x00000000},0x1f8b,1,2493},
+	{{0x00000000,0x00000000,0x00000000},0x1f05,1,2198},
+	{{0x00000000,0x00000000,0x00000000},0x1f0d,1,2198},
+	{{0x00000000,0x00000000,0x00000000},0x1f85,1,2505},
+	{{0x00000000,0x00000000,0x00000000},0x1f8d,1,2505},
+	{{0x00000000,0x00000000,0x00000000},0x1f07,1,2208},
+	{{0x00000000,0x00000000,0x00000000},0x1f0f,1,2208},
+	{{0x00000000,0x00000000,0x00000000},0x1f87,1,2517},
+	{{0x00000000,0x00000000,0x00000000},0x1f8f,1,2517},
+	{{0x00000000,0x00000000,0x00000000},0x1f81,1,2482},
+	{{0x00000000,0x00000000,0x00000000},0x1f89,1,2482},
+	{{0x00000000,0x00000000,0x00000000},0x1fb6,1,2644},
+	{{0x00000000,0x00000000,0x00000000},0x1fb7,1,2648},
+	{{0x00000000,0x00000000,0x00000000},0x1fb3,1,2635},
+	{{0x00000000,0x00000000,0x00000000},0x1fbc,1,2635},
+	{{0x00000000,0x00000000,0x00000000},0x05d0,1,1160},
+	{{0x00000000,0x00000000,0x00000000},0x0627,1,1160},
+	{{0x00000000,0x00000000,0x00000000},0xfe8d,1,7015},
+	{{0x00000000,0x00000000,0x00000000},0xfe8e,1,7019},
+	{{0x00000000,0x00000000,0x00000000},0x0100,1,0},
+	{{0x00000000,0x00000000,0x00000000},0x0101,1,0},
+	{{0x00000000,0x00000000,0x00000000},0x1ea0,1,1998},
+	{{0x00000000,0x00000000,0x00000000},0x1ea1,1,1998},
+	{{0x00000000,0x00000000,0x00000000},0x1e00,1,1728},
+	{{0x00000000,0x00000000,0x00000000},0x1e01,1,1728},
+	{{0x00000000,0x00000000,0x00000000},0x01de,1,355},
+	{{0x00000000,0x00000000,0x00000000},0x01df,1,355},
+	{{0x00000000,0x00000000,0x00000000},0x1ea2,1,2002},
+	{{0x00000000,0x00000000,0x00000000},0x1ea3,1,2002},
+	{{0x00000000,0x00000000,0x00000000},0x01e2,1,361},
+	{{0x00000000,0x00000000,0x00000000},0x01e3,1,361},
+	{{0x00000000,0x00000000,0x00000000},0x311a,1,6841},
+	{{0x00000000,0x00000000,0x00000000},0x3041,1,6543},
+	{{0x00000000,0x00000000,0x00000000},0x3042,1,6543},
+	{{0x00000000,0x00000000,0x00000000},0x30a1,1,6735},
+	{{0x00000000,0x00000000,0x00000000},0x30a2,1,6735},
+	{{0x00000000,0x00000000,0x00000000},0x01e0,1,358},
+	{{0x00000000,0x00000000,0x00000000},0x01e1,1,358},
+	{{0x00000000,0x00000000,0x00000000},0x0104,1,6},
+	{{0x00000000,0x00000000,0x00000000},0x0105,1,6},
+	{{0x00000000,0x00000000,0x00000000},0x01cd,1,315},
+	{{0x00000000,0x00000000,0x00000000},0x01ce,1,315},
+	{{0x00000000,0x00000000,0x00000000},0x0410,1,942},
+	{{0x00000000,0x00000000,0x00000000},0x0430,1,942},
+	{{0x00000000,0x00000000,0x00000000},0x1ea6,1,2009},
+	{{0x00000000,0x00000000,0x00000000},0x1ea7,1,2009},
+	{{0x00000000,0x00000000,0x00000000},0x1ea4,1,2005},
+	{{0x00000000,0x00000000,0x00000000},0x1ea5,1,2005},
+	{{0x00000000,0x00000000,0x00000000},0x1eac,1,2021},
+	{{0x00000000,0x00000000,0x00000000},0x1ead,1,2021},
+	{{0x00000000,0x00000000,0x00000000},0x1ea8,1,2013},
+	{{0x00000000,0x00000000,0x00000000},0x1ea9,1,2013},
+	{{0x00000000,0x00000000,0x00000000},0x1eaa,1,2017},
+	{{0x00000000,0x00000000,0x00000000},0x1eab,1,2017},
+	{{0x00000000,0x00000000,0x00000000},0x01fa,1,392},
+	{{0x00000000,0x00000000,0x00000000},0x01fb,1,392},
+	{{0x00100010,0x00000000,0x00000000},0x02dd,0,1627},
+	{{0x00000003,0x00000440,0x00000000},0x01e2,0,2829},
+	{{0x00000005,0x00000440,0x00000000},0x01e3,0,2829},
+	{{0x00000013,0x00000040,0x00000000},0x01fc,0,2829},
+	{{0x00000015,0x00000040,0x00000000},0x01fd,0,2829},
+	{{0x00000000,0x00000000,0x00000000},0x01fc,1,396},
+	{{0x00000000,0x00000000,0x00000000},0x01fd,1,396},
+	{{0x00000000,0x00000000,0x00000000},0x0623,1,1357},
+	{{0x00000000,0x00000000,0x00000000},0x0625,1,1357},
+	{{0x00000000,0x00000000,0x00000000},0xfe83,1,6999},
+	{{0x00000000,0x00000000,0x00000000},0xfe84,1,7003},
+	{{0x00000000,0x00000000,0x00000000},0xfe88,1,7003},
+	{{0x00000201,0x00000000,0x00000000},0x311e,1,6854},
+	{{0x00000081,0x00000000,0x00000000},0x0639,1,1494},
+	{{0x00000081,0x00000010,0x00000000},0xfec9,1,1494},
+	{{0x01000081,0x00000000,0x00000000},0xfeca,1,1494},
+	{{0x00000081,0x00000004,0x00000000},0xfecb,1,1494},
+	{{0x00000081,0x00001000,0x00000000},0xfecc,1,1494},
+	{{0x00000000,0x04000000,0x00001000},0x224c,1,4478},
+	{{0x00000000,0x04000000,0x00001000},0x2248,1,4468},
+	{{0x00000000,0x00000000,0x00000000},0x0622,1,1354},
+	{{0x00000000,0x00000000,0x00000080},0x33c2,1,1354},
+	{{0x00000000,0x00000000,0x00000000},0xfe81,1,6991},
+	{{0x00000000,0x00000000,0x00000000},0xfe82,1,6995},
+	{{0x00000000,0x00000000,0x00040001},0x2447,1,4843},
+	{{0x00000000,0x00000000,0x00000000},0x2227,1,4316},
+	{{0x00000201,0x00000000,0x00000000},0x3122,1,4316},
+	{{0x00000201,0x00000000,0x00000000},0x3124,1,6866},
+	{{0x00000000,0x00000000,0x00000000},0x2220,1,4287},
+	{{0x00000000,0x00400000,0x00000000},0x221f,1,4287},
+	{{0x00100000,0x00000080,0x00020000},0x300a,1,4287},
+	{{0x00100000,0x00400000,0x00020000},0x300b,1,4287},
+	{{0x00000001,0x00000000,0x00000000},0x212b,1,3495},
+	{{0x08000000,0x00000000,0x00000000},0x0387,1,614},
+	{{0x00000000,0x00000000,0x00000000},0x212b,1,3504},
+	{{0x00000000,0x04000000,0x00001000},0x2245,1,4451},
+	{{0x00000000,0x00000000,0x00000000},0x2169,1,3720},
+	{{0x00000000,0x00000000,0x00000000},0x2179,1,3720},
+	{{0x00000000,0x00000000,0x00000000},0x2312,1,4685},
+	{{0x00000000,0x00000000,0x00000000},0x0670,1,1681},
+	{{0x00000000,0x00000000,0x00000000},0x2217,1,4202},
+	{{0x00000000,0x04000000,0x00001000},0x2243,1,4433},
+	{{0x00000201,0x00000000,0x00000000},0x3120,1,6860},
+	{{0x20000001,0x00000000,0x00000000},0x05e2,1,1280},
+	{{0x00000201,0x00000000,0x00000000},0x3105,0,1548},
+	{{0x00000005,0x00000040,0x10000000},0x0180,0,1548},
+	{{0x80000003,0x00000040,0x00000000},0x0181,0,1548},
+	{{0x00000005,0x00040040,0x00000000},0x249d,0,1548},
+	{{0x00004003,0x00000040,0x00000000},0x24b7,0,1548},
+	{{0x00004005,0x00000040,0x00000000},0x24d1,0,1548},
+	{{0x0008000b,0x00000040,0x00000000},0x1e02,0,1548},
+	{{0x0008000d,0x00000040,0x00000000},0x1e03,0,1548},
+	{{0x00080103,0x00000040,0x00000000},0x1e04,0,1548},
+	{{0x00080105,0x00000040,0x00000000},0x1e05,0,1548},
+	{{0x00000103,0x00000240,0x00000000},0x1e06,0,1548},
+	{{0x00000105,0x00000240,0x00000000},0x1e07,0,1548},
+	{{0x00000000,0x00000000,0x00000000},0x24b7,1,5317},
+	{{0x00000000,0x00000000,0x00000000},0x24d1,1,5317},
+	{{0x00000000,0x00000000,0x00000000},0x0392,1,673},
+	{{0x00000000,0x00000000,0x00000000},0x03b2,1,673},
+	{{0x00000000,0x00000000,0x00000000},0x05d1,1,1167},
+	{{0x00000000,0x00000000,0x00000000},0x0628,1,1167},
+	{{0x00000000,0x00000000,0x00000000},0xfe91,1,7031},
+	{{0x00000000,0x00000000,0x00000000},0xfe8f,1,7023},
+	{{0x00000000,0x00000000,0x00000000},0xfe90,1,7027},
+	{{0x00000000,0x00000000,0x00000000},0xfe92,1,7035},
+	{{0x00000000,0x00000000,0x00000000},0x1e04,1,1735},
+	{{0x00000000,0x00000000,0x00000000},0x1e05,1,1735},
+	{{0x00000000,0x00000000,0x00000000},0x1e02,1,1732},
+	{{0x00000000,0x00000000,0x00000000},0x1e03,1,1732},
+	{{0x00000000,0x00000000,0x00000000},0x0180,1,245},
+	{{0x00000000,0x00000000,0x00000000},0x0181,1,248},
+	{{0x00000000,0x00000000,0x00000000},0x03d0,1,833},
+	{{0x00000000,0x00000000,0x00000000},0x3105,1,6790},
+	{{0x00000000,0x00000000,0x00000000},0x0411,1,948},
+	{{0x00000000,0x00000000,0x00000000},0x0431,1,948},
+	{{0x00000000,0x00000000,0x00000000},0x1e06,1,1739},
+	{{0x00000000,0x00000000,0x00000000},0x1e07,1,1739},
+	{{0x40000001,0x00000000,0x00000000},0x3070,1,6618},
+	{{0x00000001,0x00000020,0x00000000},0x30d0,1,6618},
+	{{0x00000000,0x00000000,0x00000000},0x2717,1,6312},
+	{{0x00000000,0x00000001,0x00000000},0x2015,0,1674},
+	{{0x00200001,0x08000000,0x00002000},0x21a8,1,3974},
+	{{0x00000000,0x00000000,0x00000000},0x2572,1,5653},
+	{{0x00000000,0x00000000,0x00000000},0x25e3,1,5653},
+	{{0x40000001,0x00000000,0x00000000},0x3079,1,945},
+	{{0x00000001,0x00000020,0x00000000},0x30d9,1,945},
+	{{0x00010003,0x00000000,0x00000000},0x0411,1,945},
+	{{0x00010005,0x00000000,0x00000000},0x0431,1,945},
+	{{0x00000000,0x00000000,0x00000000},0x266b,1,6210},
+	{{0x00000000,0x00000000,0x00000000},0x266c,1,6233},
+	{{0x00000000,0x00000000,0x00000000},0x2235,1,4386},
+	{{0x00000081,0x00000000,0x00000000},0x0628,1,1386},
+	{{0x00000081,0x00000010,0x00000000},0xfe8f,1,1386},
+	{{0x01000081,0x00000000,0x00000000},0xfe90,1,1386},
+	{{0x00000081,0x00000004,0x00000000},0xfe91,1,1386},
+	{{0x00000081,0x00001000,0x00000000},0xfe92,1,1386},
+	{{0x20000001,0x00000000,0x00000000},0x05d1,1,1163},
+	{{0x08000003,0x00000000,0x00000000},0x0392,1,668},
+	{{0x08000005,0x00000000,0x00000000},0x03b2,1,668},
+	{{0x08000000,0x00000000,0x00000000},0x03d0,1,821},
+	{{0x40000001,0x00000000,0x00000000},0x3073,1,6621},
+	{{0x00000001,0x00000020,0x00000000},0x30d3,1,6621},
+	{{0x02000000,0x00000000,0x00000000},0x2588,1,5686},
+	{{0x00000000,0x00000080,0x00080000},0x258c,1,5686},
+	{{0x00000000,0x00400000,0x00080000},0x2590,1,5686},
+	{{0x40000001,0x00000000,0x00000000},0x307c,1,6630},
+	{{0x00000001,0x00000020,0x00000000},0x30dc,1,6630},
+	{{0x00000000,0x00000000,0x00080000},0x2321,1,4748},
+	{{0x00000000,0x00000000,0x00000000},0x216a,1,3730},
+	{{0x00000000,0x00000000,0x00000000},0x217a,1,3730},
+	{{0x00000000,0x00000000,0x00040000},0x2446,1,4813},
+	{{0x40000001,0x00000000,0x00000000},0x3076,1,6627},
+	{{0x00000001,0x00000020,0x00000000},0x30d6,1,6627},
+	{{0x00000000,0x00000000,0x00000000},0x2022,1,3002},
+	{{0x00000000,0x00000000,0x00000000},0x2219,1,4235},
+	{{0x00000000,0x00000000,0x00000000},0x25ce,1,5957},
+	{{0x00000201,0x00000000,0x00000000},0x3118,0,1550},
+	{{0x00000013,0x00000040,0x00000000},0x0106,0,1550},
+	{{0x00000015,0x00000040,0x00000000},0x0107,0,1550},
+	{{0x00008003,0x00000040,0x00000000},0x0108,0,1550},
+	{{0x00008005,0x00000040,0x00000000},0x0109,0,1550},
+	{{0x00001003,0x00000040,0x00000000},0x010c,0,1550},
+	{{0x00001005,0x00000040,0x00000000},0x010d,0,1550},
+	{{0x80000003,0x00000040,0x00000000},0x0187,0,1550},
+	{{0x80000005,0x00000040,0x00000000},0x0188,0,1550},
+	{{0x00000005,0x00040040,0x00000000},0x249e,0,1550},
+	{{0x00004003,0x00000040,0x00000000},0x24b8,0,1550},
+	{{0x00004005,0x00000040,0x00000000},0x24d2,0,1550},
+	{{0x0008000b,0x00000040,0x00000000},0x010a,0,1550},
+	{{0x0008000d,0x00000040,0x00000000},0x010b,0,1550},
+	{{0x00002013,0x00000040,0x00000000},0x1e08,0,1550},
+	{{0x00002015,0x00000040,0x00000000},0x1e09,0,1550},
+	{{0x00000000,0x00000000,0x00000000},0x24b8,1,5321},
+	{{0x00000000,0x00000000,0x00000000},0x24d2,1,5321},
+	{{0x00000000,0x00000000,0x00000000},0x0427,1,1063},
+	{{0x00000000,0x00000000,0x00000000},0x0447,1,1063},
+	{{0x00000000,0x00000000,0x00000000},0x0106,1,9},
+	{{0x00000000,0x00000000,0x00000000},0x0107,1,9},
+	{{0x00000000,0x00000000,0x00000000},0x039e,1,750},
+	{{0x00000000,0x00000000,0x00000000},0x03be,1,750},
+	{{0x00000000,0x00000000,0x00000000},0x0635,1,1473},
+	{{0x00000000,0x00000000,0x00000000},0xfebb,1,7199},
+	{{0x00000000,0x00000000,0x00000000},0xfeb9,1,7191},
+	{{0x00000000,0x00000000,0x00000000},0xfeba,1,7195},
+	{{0x00000000,0x00000000,0x00000000},0xfebc,1,7203},
+	{{0x00000000,0x00000000,0x00000000},0x1e08,1,1742},
+	{{0x00000000,0x00000000,0x00000000},0x1e09,1,1742},
+	{{0x00000000,0x00000000,0x00000000},0x010a,1,15},
+	{{0x00000000,0x00000000,0x00000000},0x010b,1,15},
+	{{0x00000000,0x00000000,0x00000000},0x0187,1,251},
+	{{0x00000000,0x00000000,0x00000000},0x0188,1,251},
+	{{0x00000000,0x00000000,0x00000000},0x0480,1,1154},
+	{{0x00000000,0x00000000,0x00000000},0x0481,1,1154},
+	{{0x00000000,0x00000000,0x00000000},0x3118,1,6835},
+	{{0x00000000,0x00000000,0x00000000},0x010c,1,18},
+	{{0x00000000,0x00000000,0x00000000},0x010d,1,18},
+	{{0x00000000,0x00000000,0x00000000},0x0426,1,1056},
+	{{0x00000000,0x00000000,0x00000000},0x0446,1,1056},
+	{{0x00000000,0x00000000,0x00000000},0x0108,1,12},
+	{{0x00000000,0x00000000,0x00000000},0x0109,1,12},
+	{{0x00000000,0x00000000,0x00000000},0x2038,1,3215},
+	{{0x00000000,0x00000000,0x00000001},0x2105,1,3388},
+	{{0x00000000,0x00000000,0x00000000},0x2038,1,3209},
+	{{0x00000000,0x00000000,0x00000000},0x2663,0,2180},
+	{{0x00000000,0x00000000,0x00000000},0x2667,1,6171},
+	{{0x00000000,0x00000000,0x00000000},0x2662,1,6151},
+	{{0x00000000,0x00000000,0x00000000},0x2666,1,6167},
+	{{0x00000000,0x00000080,0x00000000},0x2308,1,4643},
+	{{0x00000000,0x00400000,0x00000000},0x2309,1,4643},
+	{{0x00000000,0x00000000,0x00000000},0x223e,1,4430},
+	{{0x00000000,0x00000000,0x00000000},0x2661,1,6148},
+	{{0x00000201,0x00000000,0x00000000},0x3114,1,6148},
+	{{0x00000000,0x00000000,0x00000000},0x2665,1,6163},
+	{{0x00000000,0x00000000,0x00040000},0x2441,1,4793},
+	{{0x00010003,0x00000000,0x00000000},0x0427,1,1059},
+	{{0x00010005,0x00000000,0x00000000},0x0447,1,1059},
+	{{0x00000000,0x00000800,0x00000000},0x2713,1,6303},
+	{{0x08000003,0x00000000,0x00000000},0x03a7,1,792},
+	{{0x08000005,0x00000000,0x00000000},0x03c7,1,792},
+	{{0x00000000,0x00000000,0x00000000},0x25ef,0,2362},
+	{{0x00000000,0x80000000,0x00000000},0x25cb,1,5947},
+	{{0x00000000,0x00000000,0x00000004},0x25cf,1,5947},
+	{{0x00000001,0x00000080,0x00080004},0x25d0,1,5947},
+	{{0x00000001,0x00400000,0x00080004},0x25d1,1,5947},
+	{{0x00000000,0x00000800,0x00000800},0x3006,1,6412},
+	{{0x00000000,0x00000000,0x00008004},0x2663,1,6154},
+	{{0x00000000,0x80000000,0x00008000},0x2667,1,6154},
+	{{0x00000000,0x00000000,0x00000000},0x2105,0,2577},
+	{{0x04000000,0x00000000,0x00000000},0x0300,1,540},
+	{{0x00000010,0x00000000,0x00000000},0x0301,1,540},
+	{{0x00000008,0x00400000,0x00000000},0x20d1,1,3352},
+	{{0x00000080,0x00000000,0x00000000},0x060c,0,1388},
+	{{0x00000000,0x00000000,0x00000800},0x3001,0,1388},
+	{{0x00000004,0x80000000,0x00000084},0x25a3,1,5759},
+	{{0x00000000,0x00000000,0x00000000},0x220b,1,4115},
+	{{0x00000000,0x00000000,0x00000000},0x222e,1,4356},
+	{{0x00000000,0x00000080,0x00020000},0x300c,1,6432},
+	{{0x00000000,0x00400000,0x00020000},0x300d,1,6432},
+	{{0x00000000,0x80000080,0x00020000},0x300e,1,6432},
+	{{0x00000000,0x80400000,0x00020000},0x300f,1,6432},
+	{{0x00000000,0x00000000,0x00000000},0x216b,0,902},
+	{{0x00000000,0x00000000,0x00000000},0x217b,0,902},
+	{{0x00000000,0x00000000,0x00000000},0x2660,1,6139},
+	{{0x00000000,0x00000000,0x00000000},0x2664,1,6159},
+	{{0x00000000,0x00002000,0x00040000},0x2449,1,4867},
+	{{0x00000201,0x00000000,0x00000000},0x3109,0,1552},
+	{{0x00001003,0x00000040,0x00000000},0x010e,0,1552},
+	{{0x00001005,0x00000040,0x00000000},0x010f,0,1552},
+	{{0x00000003,0x00000040,0x10000000},0x0110,0,1552},
+	{{0x00000005,0x00000040,0x10000000},0x0111,0,1552},
+	{{0x00002003,0x00000040,0x00000000},0x1e10,0,1552},
+	{{0x00002005,0x00000040,0x00000000},0x1e11,0,1552},
+	{{0x00000005,0x00040040,0x00000000},0x249f,0,1552},
+	{{0x00004003,0x00000040,0x00000000},0x24b9,0,1552},
+	{{0x00004005,0x00000040,0x00000000},0x24d3,0,1552},
+	{{0x0008000b,0x00000040,0x00000000},0x1e0a,0,1552},
+	{{0x0008000d,0x00000040,0x00000000},0x1e0b,0,1552},
+	{{0x00080103,0x00000040,0x00000000},0x1e0c,0,1552},
+	{{0x00080105,0x00000040,0x00000000},0x1e0d,0,1552},
+	{{0x00000103,0x00000240,0x00000000},0x1e0e,0,1552},
+	{{0x00000105,0x00000240,0x00000000},0x1e0f,0,1552},
+	{{0x00008103,0x00000040,0x00000000},0x1e12,0,1552},
+	{{0x00008105,0x00000040,0x00000000},0x1e13,0,1552},
+	{{0x00000000,0x00000000,0x00000000},0x24b9,1,5325},
+	{{0x00000000,0x00000000,0x00000000},0x24d3,1,5325},
+	{{0x00000007,0x00000040,0x00000000},0x01f2,1,289},
+	{{0x00001007,0x00000040,0x00000000},0x01c5,1,289},
+	{{0x00000000,0x00000000,0x00000000},0x0402,1,882},
+	{{0x00000000,0x00000000,0x00000000},0x0452,1,882},
+	{{0x00000000,0x00000000,0x00000000},0x0394,1,691},
+	{{0x00000000,0x00000000,0x00000000},0x03b4,1,691},
+	{{0x00000000,0x00000000,0x00000000},0x05d3,1,1185},
+	{{0x00000000,0x00000000,0x00000000},0x062f,1,1185},
+	{{0x00000000,0x00000000,0x00000000},0xfea9,1,7127},
+	{{0x00000000,0x00000000,0x00000000},0xfeaa,1,7131},
+	{{0x00000000,0x00000000,0x00000000},0x1e10,1,1756},
+	{{0x00000000,0x00000000,0x00000000},0x1e11,1,1756},
+	{{0x00000000,0x00000000,0x00000000},0x1e0c,1,1749},
+	{{0x00000000,0x00000000,0x00000000},0x1e0d,1,1749},
+	{{0x00000000,0x00000000,0x00000000},0x1e12,1,1759},
+	{{0x00000000,0x00000000,0x00000000},0x1e13,1,1759},
+	{{0x00000000,0x00000000,0x00000000},0x1e0a,1,1746},
+	{{0x00000000,0x00000000,0x00000000},0x1e0b,1,1746},
+	{{0x00000000,0x00000000,0x00000000},0x0110,1,24},
+	{{0x00000000,0x00000000,0x00000000},0x0111,1,24},
+	{{0x00000000,0x00000000,0x00000000},0x3109,0,1050},
+	{{0x00000000,0x00000000,0x00000000},0x010e,1,21},
+	{{0x00000000,0x00000000,0x00000000},0x010f,1,21},
+	{{0x00000000,0x00000000,0x00000000},0x0414,1,967},
+	{{0x00000000,0x00000000,0x00000000},0x0434,1,967},
+	{{0x00000000,0x00000000,0x00000000},0x1e0e,1,1753},
+	{{0x00000000,0x00000000,0x00000000},0x1e0f,1,1753},
+	{{0x40000001,0x00000000,0x00000000},0x3060,1,6600},
+	{{0x00000001,0x00000020,0x00000000},0x30c0,1,6600},
+	{{0x00000081,0x00000000,0x00000000},0x0636,1,1476},
+	{{0x00000081,0x00000010,0x00000000},0xfebd,1,1476},
+	{{0x01000081,0x00000000,0x00000000},0xfebe,1,1476},
+	{{0x00000081,0x00000004,0x00000000},0xfebf,1,1476},
+	{{0x00000081,0x00001000,0x00000000},0xfec0,1,1476},
+	{{0x00000000,0x00000000,0x00000000},0x2020,1,2989},
+	{{0x00100000,0x00000000,0x00000000},0x2021,1,2989},
+	{{0x00000081,0x00000000,0x00000000},0x062f,1,1434},
+	{{0x00000081,0x00000010,0x00000000},0xfea9,1,1434},
+	{{0x01000081,0x00000000,0x00000000},0xfeaa,1,1434},
+	{{0x20000001,0x00000000,0x00000000},0x05d3,1,1179},
+	{{0x00000080,0x00000000,0x00000000},0x064f,1,1611},
+	{{0x00000080,0x00000000,0x00000000},0x064c,1,1578},
+	{{0x00000000,0x00000000,0x00000000},0x2593,1,5723},
+	{{0x00000000,0x00000000,0x00040000},0x2448,1,4859},
+	{{0x00000000,0x00000000,0x00000000},0x25c6,1,5930},
+	{{0x00000000,0x00000000,0x00000000},0x0636,1,1480},
+	{{0x00000000,0x00000000,0x00000000},0xfebf,1,7215},
+	{{0x00000000,0x00000000,0x00000000},0xfebd,1,7207},
+	{{0x00000000,0x00000000,0x00000000},0xfebe,1,7211},
+	{{0x00000000,0x00000000,0x00000000},0xfec0,1,7219},
+	{{0x00000000,0x00000000,0x00000000},0x2206,1,964},
+	{{0x40000001,0x00000000,0x00000000},0x3067,1,964},
+	{{0x00000001,0x00000020,0x00000000},0x30c7,1,964},
+	{{0x00010003,0x00000000,0x00000000},0x0414,1,964},
+	{{0x00010005,0x00000000,0x00000000},0x0434,1,964},
+	{{0x00000000,0x00000000,0x00000000},0x2103,1,3373},
+	{{0x00000000,0x00000000,0x00000000},0x2109,1,3393},
+	{{0x08000003,0x00000000,0x00000000},0x0394,1,685},
+	{{0x08000005,0x00000000,0x00000000},0x03b4,1,685},
+	{{0x00000000,0x00000000,0x00000000},0x252c,1,5568},
+	{{0x00000000,0x00000000,0x00000000},0x2564,1,5568},
+	{{0x00000000,0x00000000,0x00000000},0x2565,1,5568},
+	{{0x00000000,0x00000000,0x00000000},0x2566,1,5568},
+	{{0x00000000,0x00000000,0x00000000},0x252f,1,5579},
+	{{0x00000000,0x00000000,0x00000000},0x2530,1,5579},
+	{{0x00000000,0x00000000,0x00000000},0x2533,1,5579},
+	{{0x00000000,0x00000000,0x00000000},0x222c,1,4353},
+	{{0x40000001,0x00000000,0x00000000},0x3062,1,4353},
+	{{0x00000001,0x00000020,0x00000000},0x30c2,1,4353},
+	{{0x00000001,0x00000000,0x00000080},0x25a9,1,5837},
+	{{0x00400400,0x04400180,0x00000000},0x2571,1,5625},
+	{{0x00400400,0x04400180,0x00000000},0x2572,1,5625},
+	{{0x08000000,0x00000000,0x20000000},0x0385,1,598},
+	{{0x08000001,0x00080000,0x00000000},0x1fc1,1,598},
+	{{0x08000001,0x20000000,0x00000000},0x1fed,1,598},
+	{{0x08000001,0x00020000,0x00000000},0x1fee,1,598},
+	{{0x08000003,0x00000008,0x00000000},0x03aa,1,598},
+	{{0x08000003,0x10000000,0x00000000},0x03ab,1,598},
+	{{0x08000005,0x00000008,0x00000000},0x03ca,1,598},
+	{{0x08000005,0x10000000,0x00000000},0x03cb,1,598},
+	{{0x08000005,0x00000008,0x20000000},0x0390,1,598},
+	{{0x08000005,0x10000000,0x20000000},0x03b0,1,598},
+	{{0x08000005,0x20000008,0x00000000},0x1fd2,1,598},
+	{{0x08000005,0x00020008,0x00000000},0x1fd3,1,598},
+	{{0x08000005,0x00080008,0x00000000},0x1fd7,1,598},
+	{{0x08000005,0x30000000,0x00000000},0x1fe2,1,598},
+	{{0x08000005,0x10020000,0x00000000},0x1fe3,1,598},
+	{{0x08000005,0x10080000,0x00000000},0x1fe7,1,598},
+	{{0x00000000,0x00000000,0x00000004},0x25c6,1,5922},
+	{{0x00000000,0x80000000,0x00000000},0x25c7,1,5922},
+	{{0x00000000,0x80000000,0x00008000},0x2662,1,5922},
+	{{0x00000000,0x00000000,0x00008004},0x2666,1,5922},
+	{{0x08000001,0x00000000,0x00000000},0x03dc,1,846},
+	{{0x00000000,0x00000800,0x00000000},0x3003,1,6350},
+	{{0x00010003,0x00000000,0x00000000},0x0402,1,878},
+	{{0x00010005,0x00000000,0x00000000},0x0452,1,878},
+	{{0x00000000,0x00000000,0x00000000},0x0630,1,1443},
+	{{0x00000000,0x00000000,0x00000000},0xfeab,1,7135},
+	{{0x00000000,0x00000000,0x00000000},0xfeac,1,7139},
+	{{0x00000000,0x00000000,0x00000000},0x2510,0,947},
+	{{0x00000000,0x00000000,0x00000000},0x2555,0,947},
+	{{0x00000000,0x00000000,0x00000000},0x2556,0,947},
+	{{0x00000000,0x00000000,0x00000000},0x2511,1,5508},
+	{{0x00000000,0x00000000,0x00000000},0x2512,1,5508},
+	{{0x00000000,0x00000000,0x00000000},0x252d,1,5575},
+	{{0x00000000,0x00000000,0x00000000},0x252e,1,5575},
+	{{0x00000000,0x00000000,0x00000000},0x2531,1,5575},
+	{{0x00000000,0x00000000,0x00000000},0x2532,1,5575},
+	{{0x40000001,0x00000000,0x00000000},0x3069,0,1327},
+	{{0x00000001,0x00000020,0x00000000},0x30c9,0,1327},
+	{{0x00000005,0x00000040,0x00000000},0x0131,1,75},
+	{{0x00000000,0x00000000,0x00002000},0x2193,1,3895},
+	{{0x00000000,0x00000000,0x00000000},0x2202,1,4059},
+	{{0x00000000,0x00000000,0x00000000},0x250c,1,5492},
+	{{0x00000000,0x00000000,0x00000000},0x2552,1,5492},
+	{{0x00000000,0x00000000,0x00000000},0x2553,1,5492},
+	{{0x00000000,0x00000000,0x00000000},0x2554,1,5492},
+	{{0x00000000,0x00000000,0x00000000},0x250d,1,5499},
+	{{0x00000000,0x00000000,0x00000000},0x250e,1,5499},
+	{{0x00000000,0x00000000,0x00000000},0x250f,1,5499},
+	{{0x00000000,0x00000000,0x00000000},0x0405,1,899},
+	{{0x00000000,0x00000000,0x00000000},0x0455,1,899},
+	{{0x00000000,0x00000000,0x00000000},0x25bc,0,1696},
+	{{0x00000000,0x00000000,0x00000000},0x25bd,0,1696},
+	{{0x40000001,0x00000000,0x00000000},0x3065,1,6609},
+	{{0x00000001,0x00000020,0x00000000},0x30c5,1,6609},
+	{{0x00000000,0x00000000,0x00000000},0x25c7,1,5933},
+	{{0x00000000,0x00000000,0x00000000},0x040f,1,282},
+	{{0x00000000,0x00000000,0x00000000},0x045f,1,282},
+	{{0x00000003,0x00000040,0x00000000},0x01f1,1,282},
+	{{0x00000005,0x00000040,0x00000000},0x01f3,1,282},
+	{{0x00001003,0x00000040,0x00000000},0x01c4,1,282},
+	{{0x00001005,0x00000040,0x00000000},0x01c6,1,282},
+	{{0x00000000,0x00000000,0x00000000},0x01f1,1,385},
+	{{0x00000000,0x00000000,0x00000000},0x01f2,1,385},
+	{{0x00000000,0x00000000,0x00000000},0x01f3,1,385},
+	{{0x00000000,0x00000000,0x00000000},0x01c4,1,285},
+	{{0x00000000,0x00000000,0x00000000},0x01c5,1,285},
+	{{0x00000000,0x00000000,0x00000000},0x01c6,1,285},
+	{{0x00010003,0x00000000,0x00000000},0x0405,1,895},
+	{{0x00010005,0x00000000,0x00000000},0x0455,1,895},
+	{{0x00010003,0x00000000,0x00000000},0x040f,1,937},
+	{{0x00010005,0x00000000,0x00000000},0x045f,1,937},
+	{{0x40000001,0x00000000,0x00000000},0x3048,0,1554},
+	{{0x00000001,0x00000020,0x00000000},0x30a8,0,1554},
+	{{0x00000201,0x00000000,0x00000000},0x311c,0,1554},
+	{{0x00010003,0x00000000,0x00000000},0x042d,0,1554},
+	{{0x00010005,0x00000000,0x00000000},0x044d,0,1554},
+	{{0x40000005,0x00000000,0x00000000},0x3047,0,1554},
+	{{0x00000005,0x00000020,0x00000000},0x30a7,0,1554},
+	{{0x00000003,0x00000440,0x00000000},0x0112,0,1554},
+	{{0x00000005,0x00000440,0x00000000},0x0113,0,1554},
+	{{0x00000803,0x00000040,0x00000000},0x0114,0,1554},
+	{{0x00000805,0x00000040,0x00000000},0x0115,0,1554},
+	{{0x00000003,0x00000040,0x02000000},0x0118,0,1554},
+	{{0x00000005,0x00000040,0x02000000},0x0119,0,1554},
+	{{0x00001003,0x00000040,0x00000000},0x011a,0,1554},
+	{{0x00001005,0x00000040,0x00000000},0x011b,0,1554},
+	{{0x00000003,0x02000040,0x00000000},0x1ebc,0,1554},
+	{{0x00000005,0x02000040,0x00000000},0x1ebd,0,1554},
+	{{0x00000005,0x00040040,0x00000000},0x24a0,0,1554},
+	{{0x00004003,0x00000040,0x00000000},0x24ba,0,1554},
+	{{0x00004005,0x00000040,0x00000000},0x24d4,0,1554},
+	{{0x0008000b,0x00000040,0x00000000},0x0116,0,1554},
+	{{0x0008000d,0x00000040,0x00000000},0x0117,0,1554},
+	{{0x04100003,0x00000040,0x00000000},0x0204,0,1554},
+	{{0x04100005,0x00000040,0x00000000},0x0205,0,1554},
+	{{0x00000803,0x00000040,0x00800000},0x0206,0,1554},
+	{{0x00000805,0x00000040,0x00800000},0x0207,0,1554},
+	{{0x04000003,0x00000440,0x00000000},0x1e14,0,1554},
+	{{0x04000005,0x00000440,0x00000000},0x1e15,0,1554},
+	{{0x00000013,0x00000440,0x00000000},0x1e16,0,1554},
+	{{0x00000015,0x00000440,0x00000000},0x1e17,0,1554},
+	{{0x00008103,0x00000040,0x00000000},0x1e18,0,1554},
+	{{0x00008105,0x00000040,0x00000000},0x1e19,0,1554},
+	{{0x00000103,0x02000040,0x00000000},0x1e1a,0,1554},
+	{{0x00000105,0x02000040,0x00000000},0x1e1b,0,1554},
+	{{0x00002803,0x00000040,0x00000000},0x1e1c,0,1554},
+	{{0x00002805,0x00000040,0x00000000},0x1e1d,0,1554},
+	{{0x00080103,0x00000040,0x00000000},0x1eb8,0,1554},
+	{{0x00080105,0x00000040,0x00000000},0x1eb9,0,1554},
+	{{0x8000000b,0x00000040,0x00000000},0x1eba,0,1554},
+	{{0x8000000d,0x00000040,0x00000000},0x1ebb,0,1554},
+	{{0x00008013,0x00000040,0x00000000},0x1ebe,0,1554},
+	{{0x00008015,0x00000040,0x00000000},0x1ebf,0,1554},
+	{{0x04008003,0x00000040,0x00000000},0x1ec0,0,1554},
+	{{0x04008005,0x00000040,0x00000000},0x1ec1,0,1554},
+	{{0x00008003,0x02000040,0x00000000},0x1ec4,0,1554},
+	{{0x00008005,0x02000040,0x00000000},0x1ec5,0,1554},
+	{{0x8000800b,0x00000040,0x00000000},0x1ec2,0,1554},
+	{{0x8000800d,0x00000040,0x00000000},0x1ec3,0,1554},
+	{{0x00088103,0x00000040,0x00000000},0x1ec6,0,1554},
+	{{0x00088105,0x00000040,0x00000000},0x1ec7,0,1554},
+	{{0x00000000,0x00000000,0x00000000},0x24ba,1,5329},
+	{{0x00000000,0x00000000,0x00000000},0x24d4,1,5329},
+	{{0x00000000,0x00000000,0x00000000},0x0204,1,411},
+	{{0x00000000,0x00000000,0x00000000},0x0205,1,411},
+	{{0x00000000,0x00000000,0x00000000},0x0388,1,636},
+	{{0x00000000,0x00000000,0x00000000},0x03ad,1,636},
+	{{0x00000000,0x00000000,0x00000000},0x0114,1,30},
+	{{0x00000000,0x00000000,0x00000000},0x0115,1,30},
+	{{0x00000000,0x00000000,0x00000000},0x0206,1,415},
+	{{0x00000000,0x00000000,0x00000000},0x0207,1,415},
+	{{0x00000000,0x00000000,0x00000000},0x0395,1,694},
+	{{0x00000000,0x00000000,0x00000000},0x03b5,1,694},
+	{{0x00000000,0x00000000,0x00000000},0x1f72,1,2429},
+	{{0x00000000,0x00000000,0x00000000},0x1fc8,1,2696},
+	{{0x00000000,0x00000000,0x00000000},0x1f73,1,2433},
+	{{0x00000000,0x00000000,0x00000000},0x1fc9,1,2433},
+	{{0x00000000,0x00000000,0x00000000},0x1f10,1,2213},
+	{{0x00000000,0x00000000,0x00000000},0x1f18,1,2213},
+	{{0x00000000,0x00000000,0x00000000},0x1f12,1,2221},
+	{{0x00000000,0x00000000,0x00000000},0x1f1a,1,2221},
+	{{0x00000000,0x00000000,0x00000000},0x1f14,1,2231},
+	{{0x00000000,0x00000000,0x00000000},0x1f1c,1,2231},
+	{{0x00000000,0x00000000,0x00000000},0x1f11,1,2217},
+	{{0x00000000,0x00000000,0x00000000},0x1f19,1,2217},
+	{{0x00000000,0x00000000,0x00000000},0x1f13,1,2226},
+	{{0x00000000,0x00000000,0x00000000},0x1f1b,1,2226},
+	{{0x00000000,0x00000000,0x00000000},0x1f15,1,2236},
+	{{0x00000000,0x00000000,0x00000000},0x1f1d,1,2236},
+	{{0x00000000,0x00000000,0x00000000},0x05e2,1,1285},
+	{{0x00000000,0x00000000,0x00000000},0x0639,1,1285},
+	{{0x00000000,0x00000000,0x00000000},0xfecb,1,7263},
+	{{0x00000000,0x00000000,0x00000000},0xfec9,1,7255},
+	{{0x00000000,0x00000000,0x00000000},0xfeca,1,7259},
+	{{0x00000000,0x00000000,0x00000000},0xfecc,1,7267},
+	{{0x00000000,0x00000000,0x00000000},0x1e1c,1,1779},
+	{{0x00000000,0x00000000,0x00000000},0x1e1d,1,1779},
+	{{0x00000000,0x00000000,0x00000000},0x0112,1,27},
+	{{0x00000000,0x00000000,0x00000000},0x0113,1,27},
+	{{0x00000000,0x00000000,0x00000000},0x1e14,1,1763},
+	{{0x00000000,0x00000000,0x00000000},0x1e15,1,1763},
+	{{0x00000000,0x00000000,0x00000000},0x1e16,1,1767},
+	{{0x00000000,0x00000000,0x00000000},0x1e17,1,1767},
+	{{0x00000000,0x00000000,0x00000000},0x1eb8,1,2047},
+	{{0x00000000,0x00000000,0x00000000},0x1eb9,1,2047},
+	{{0x00000000,0x00000000,0x00000000},0x1e18,1,1771},
+	{{0x00000000,0x00000000,0x00000000},0x1e19,1,1771},
+	{{0x00000000,0x00000000,0x00000000},0x1e1a,1,1775},
+	{{0x00000000,0x00000000,0x00000000},0x1e1b,1,1775},
+	{{0x00000000,0x00000000,0x00000000},0x0116,1,33},
+	{{0x00000000,0x00000000,0x00000000},0x0117,1,33},
+	{{0x00000000,0x00000000,0x00000000},0x01dd,1,352},
+	{{0x00000000,0x00000000,0x00000000},0x1eba,1,2051},
+	{{0x00000000,0x00000000,0x00000000},0x1ebb,1,2051},
+	{{0x00000000,0x00000000,0x00000000},0x311c,1,6847},
+	{{0x00000000,0x00000000,0x00000000},0x3047,1,6552},
+	{{0x00000000,0x00000000,0x00000000},0x3048,1,6552},
+	{{0x00000000,0x00000000,0x00000000},0x30a7,1,6744},
+	{{0x00000000,0x00000000,0x00000000},0x30a8,1,6744},
+	{{0x00000000,0x00000000,0x00000000},0x0118,1,36},
+	{{0x00000000,0x00000000,0x00000000},0x0119,1,36},
+	{{0x00000000,0x00000000,0x00000000},0x011a,1,39},
+	{{0x00000000,0x00000000,0x00000000},0x011b,1,39},
+	{{0x00000000,0x00000000,0x00000000},0x0415,1,970},
+	{{0x00000000,0x00000000,0x00000000},0x0435,1,970},
+	{{0x00000000,0x00000000,0x00000000},0x1ec0,1,2061},
+	{{0x00000000,0x00000000,0x00000000},0x1ec1,1,2061},
+	{{0x00000000,0x00000000,0x00000000},0x1ebe,1,2057},
+	{{0x00000000,0x00000000,0x00000000},0x1ebf,1,2057},
+	{{0x00000000,0x00000000,0x00000000},0x1ec6,1,2073},
+	{{0x00000000,0x00000000,0x00000000},0x1ec7,1,2073},
+	{{0x00000000,0x00000000,0x00000000},0x1ec2,1,2065},
+	{{0x00000000,0x00000000,0x00000000},0x1ec3,1,2065},
+	{{0x00000000,0x00000000,0x00000000},0x1ec4,1,2069},
+	{{0x00000000,0x00000000,0x00000000},0x1ec5,1,2069},
+	{{0x00000000,0x00000000,0x00000000},0x1ebc,1,2054},
+	{{0x00000000,0x00000000,0x00000000},0x1ebd,1,2054},
+	{{0x00000000,0x00000000,0x00000000},0x01b7,1,279},
+	{{0x00000000,0x00000000,0x00000000},0x0292,1,279},
+	{{0x00010003,0x00000000,0x00000000},0x0424,1,1040},
+	{{0x00010005,0x00000000,0x00000000},0x0444,1,1040},
+	{{0x00000000,0x00000000,0x00000000},0x2302,1,4640},
+	{{0x00000201,0x00000000,0x00000000},0x311d,1,4640},
+	{{0x00000000,0x00000000,0x00000000},0x311d,1,6850},
+	{{0x00000201,0x00000000,0x00000000},0x311f,1,6857},
+	{{0x00000000,0x00000000,0x00000020},0x2078,0,1470},
+	{{0x00000000,0x00000000,0x00000040},0x2088,0,1470},
+	{{0x00004001,0x00000000,0x00000000},0x2467,0,1470},
+	{{0x00000001,0x00040000,0x00000000},0x247b,0,1470},
+	{{0x00000081,0x00000000,0x00000400},0x0668,0,1470},
+	{{0x00000000,0x00804000,0x00000000},0x2167,0,1470},
+	{{0x02000001,0x00000000,0x00000002},0x248f,0,1470},
+	{{0x00000000,0x00040000,0x00000800},0x3227,0,1470},
+	{{0x00000004,0x00804000,0x00000000},0x2177,0,1470},
+	{{0x00004000,0x00002000,0x00000000},0x2471,1,5007},
+	{{0x00000000,0x00042000,0x00000000},0x2485,1,5007},
+	{{0x02000000,0x00002000,0x00000002},0x2499,1,5007},
+	{{0x00000000,0x00010000,0x00000018},0x215b,1,3629},
+	{{0x00000000,0x00000000,0x00000000},0x266a,1,6191},
+	{{0x00010003,0x00000000,0x00000000},0x041b,1,998},
+	{{0x00010005,0x00000000,0x00000000},0x043b,1,998},
+	{{0x00000000,0x00000000,0x00000001},0x2208,1,4104},
+	{{0x00000000,0x00804000,0x00000000},0x216a,1,3723},
+	{{0x00004000,0x00002000,0x00000000},0x246a,1,3723},
+	{{0x00000000,0x00042000,0x00000000},0x247e,1,3723},
+	{{0x00000004,0x00804000,0x00000000},0x217a,1,3723},
+	{{0x02000000,0x00002000,0x00000002},0x2492,1,3723},
+	{{0x00000000,0x00000001,0x00000000},0x2026,1,3044},
+	{{0x00000000,0x40000000,0x00000000},0x22ee,1,3044},
+	{{0x00000000,0x00000000,0x00000200},0x2003,0,1156},
+	{{0x00010003,0x00000000,0x00000000},0x041c,0,1156},
+	{{0x00010005,0x00000000,0x00000000},0x043c,0,1156},
+	{{0x00000000,0x00000000,0x00000000},0x2014,1,2903},
+	{{0x00000000,0x00000000,0x00000000},0x2205,1,4075},
+	{{0x00000000,0x00000000,0x00000200},0x2002,1,1007},
+	{{0x00000201,0x00000000,0x00000000},0x3123,1,1007},
+	{{0x00010003,0x00000000,0x00000000},0x041d,1,1007},
+	{{0x00010005,0x00000000,0x00000000},0x043d,1,1007},
+	{{0x00000000,0x00000000,0x00000000},0x2013,1,2892},
+	{{0x00000201,0x00000000,0x00000000},0x3125,1,153},
+	{{0x00000003,0x00000040,0x00000000},0x014a,1,153},
+	{{0x00000005,0x00000040,0x00000000},0x014b,1,153},
+	{{0x08000003,0x00000000,0x00000000},0x0395,1,628},
+	{{0x08000005,0x00000000,0x00000000},0x03b5,1,628},
+	{{0x08000003,0x00000000,0x20000000},0x0388,1,628},
+	{{0x08000005,0x00000000,0x20000000},0x03ad,1,628},
+	{{0x08000005,0x00200000,0x00000000},0x1f10,1,628},
+	{{0x08020005,0x00000000,0x00000000},0x1f11,1,628},
+	{{0x08000003,0x00200000,0x00000000},0x1f18,1,628},
+	{{0x08020003,0x00000000,0x00000000},0x1f19,1,628},
+	{{0x08000005,0x20000000,0x00000000},0x1f72,1,628},
+	{{0x08000005,0x00020000,0x00000000},0x1f73,1,628},
+	{{0x08000003,0x20000000,0x00000000},0x1fc8,1,628},
+	{{0x08000003,0x00020000,0x00000000},0x1fc9,1,628},
+	{{0x08000005,0x20200000,0x00000000},0x1f12,1,628},
+	{{0x08020005,0x20000000,0x00000000},0x1f13,1,628},
+	{{0x08000005,0x00220000,0x00000000},0x1f14,1,628},
+	{{0x08020005,0x00020000,0x00000000},0x1f15,1,628},
+	{{0x08000003,0x20200000,0x00000000},0x1f1a,1,628},
+	{{0x08020003,0x20000000,0x00000000},0x1f1b,1,628},
+	{{0x08000003,0x00220000,0x00000000},0x1f1c,1,628},
+	{{0x08020003,0x00020000,0x00000000},0x1f1d,1,628},
+	{{0x00000001,0x00000000,0x00000020},0x207c,0,1502},
+	{{0x00000001,0x00000000,0x00000040},0x208c,0,1502},
+	{{0x00000201,0x00000000,0x00000000},0x3126,1,1022},
+	{{0x00010003,0x00000000,0x00000000},0x0420,1,1022},
+	{{0x00010005,0x00000000,0x00000000},0x0440,1,1022},
+	{{0x00010003,0x00000000,0x00000000},0x0421,0,1864},
+	{{0x00010005,0x00000000,0x00000000},0x0441,0,1864},
+	{{0x00000000,0x00000000,0x00000000},0x212e,1,3524},
+	{{0x00000000,0x00000000,0x00000000},0x212e,1,3507},
+	{{0x00000001,0x00000000,0x00000000},0x20ac,1,3347},
+	{{0x00100000,0x00000800,0x00000000},0x203c,0,1292},
+	{{0x00000000,0x00000000,0x00000000},0x01ee,1,379},
+	{{0x00000000,0x00000000,0x00000000},0x01ef,1,379},
+	{{0x00000003,0x00000040,0x00000000},0x01b7,1,275},
+	{{0x00000005,0x00000040,0x00000000},0x0292,1,275},
+	{{0x00001003,0x00000040,0x00000000},0x01ee,1,275},
+	{{0x00001005,0x00000040,0x00000000},0x01ef,1,275},
+	{{0x00000201,0x00000000,0x00000000},0x3108,0,1556},
+	{{0x80000003,0x00000040,0x00000000},0x0191,0,1556},
+	{{0x80000005,0x00000040,0x00000000},0x0192,0,1556},
+	{{0x00000005,0x00040040,0x00000000},0x24a1,0,1556},
+	{{0x00004003,0x00000040,0x00000000},0x24bb,0,1556},
+	{{0x00004005,0x00000040,0x00000000},0x24d5,0,1556},
+	{{0x0008000b,0x00000040,0x00000000},0x1e1e,0,1556},
+	{{0x0008000d,0x00000040,0x00000000},0x1e1f,0,1556},
+	{{0x00000000,0x00000000,0x00000000},0x24bb,1,5333},
+	{{0x00000000,0x00000000,0x00000000},0x24d5,1,5333},
+	{{0x00000000,0x00000000,0x00000000},0x03a6,1,789},
+	{{0x00000000,0x00000000,0x00000000},0x03c6,1,789},
+	{{0x00000000,0x00000000,0x00000000},0x0641,1,1522},
+	{{0x00000000,0x00000000,0x00000000},0xfed3,1,7295},
+	{{0x00000000,0x00000000,0x00000000},0xfed1,1,7287},
+	{{0x00000000,0x00000000,0x00000000},0xfed2,1,7291},
+	{{0x00000000,0x00000000,0x00000000},0xfed4,1,7299},
+	{{0x00000000,0x00000000,0x00000000},0x1e1e,1,1783},
+	{{0x00000000,0x00000000,0x00000000},0x1e1f,1,1783},
+	{{0x00000000,0x00000000,0x00000000},0x0191,1,254},
+	{{0x00000000,0x00000000,0x00000000},0x0192,1,254},
+	{{0x00000000,0x00000000,0x00000000},0x0472,1,1140},
+	{{0x00000000,0x00000000,0x00000000},0x0473,1,1140},
+	{{0x00000000,0x00000000,0x00000000},0x3108,1,6799},
+	{{0x00000000,0x00000000,0x00000000},0x0424,1,1043},
+	{{0x00000000,0x00000000,0x00000000},0x0444,1,1043},
+	{{0x00000000,0x00000000,0x00000000},0x2200,1,4035},
+	{{0x00000080,0x00000000,0x00000000},0x064e,1,1602},
+	{{0x00000080,0x00000000,0x00000000},0x064b,1,1566},
+	{{0x00000000,0x00000000,0x00000000},0x2588,1,5692},
+	{{0x00000000,0x00000000,0x00000000},0x2571,1,5646},
+	{{0x00000000,0x00000000,0x00000000},0x25e2,1,5646},
+	{{0x00000081,0x00000000,0x00000000},0x0641,1,1518},
+	{{0x00000081,0x00000010,0x00000000},0xfed1,1,1518},
+	{{0x01000081,0x00000000,0x00000000},0xfed2,1,1518},
+	{{0x00000081,0x00000004,0x00000000},0xfed3,1,1518},
+	{{0x00000081,0x00001000,0x00000000},0xfed4,1,1518},
+	{{0x00000001,0x00000000,0x00000000},0x2640,1,6115},
+	{{0x00000000,0x00000000,0x00000000},0xfb00,0,883},
+	{{0x00000004,0x00000040,0x00000100},0xfb00,0,883},
+	{{0x00000000,0x00000000,0x00000000},0xfb03,1,6966},
+	{{0x00000004,0x00000040,0x00000100},0xfb03,1,6966},
+	{{0x00000000,0x00000000,0x00000000},0xfb04,1,6970},
+	{{0x00000004,0x00000040,0x00000100},0xfb04,1,6970},
+	{{0x00000000,0x00000000,0x00000000},0xfb01,1,6960},
+	{{0x00000004,0x00000040,0x00000100},0xfb01,1,6960},
+	{{0x00004000,0x00002000,0x00000000},0x246e,1,4966},
+	{{0x00000000,0x00042000,0x00000000},0x2482,1,4966},
+	{{0x02000000,0x00002000,0x00000002},0x2496,1,4966},
+	{{0x00000000,0x00010000,0x00000018},0x2155,1,3551},
+	{{0x00000000,0x00804000,0x00000000},0x216c,1,3740},
+	{{0x00000004,0x00804000,0x00000000},0x217c,1,3740},
+	{{0x00000001,0x00000001,0x00000080},0x25a4,1,5773},
+	{{0x00000001,0x40000000,0x00000080},0x25a5,1,5773},
+	{{0x00010003,0x00000000,0x00000000},0x0472,1,1135},
+	{{0x00010005,0x00000000,0x00000000},0x0473,1,1135},
+	{{0x00000000,0x00000000,0x00000020},0x2075,0,1455},
+	{{0x00000000,0x00000000,0x00000040},0x2085,0,1455},
+	{{0x00004001,0x00000000,0x00000000},0x2464,0,1455},
+	{{0x00000001,0x00040000,0x00000000},0x2478,0,1455},
+	{{0x00000081,0x00000000,0x00000400},0x0665,0,1455},
+	{{0x00000000,0x00804000,0x00000000},0x2164,0,1455},
+	{{0x02000001,0x00000000,0x00000002},0x248c,0,1455},
+	{{0x00000000,0x00040000,0x00000800},0x3224,0,1455},
+	{{0x00000004,0x00804000,0x00000000},0x2174,0,1455},
+	{{0x00000000,0x00000000,0x00000018},0x215d,1,3656},
+	{{0x00000000,0x00804000,0x00000000},0x216e,1,3763},
+	{{0x00000004,0x00804000,0x00000000},0x217e,1,3763},
+	{{0x00000000,0x00000000,0x00000018},0x215a,1,3614},
+	{{0x00000000,0x00804000,0x00000000},0x2181,1,3817},
+	{{0x00000000,0x00000000,0x00000000},0xfb02,1,6963},
+	{{0x00000004,0x00000040,0x00000100},0xfb02,1,6963},
+	{{0x00000000,0x00000080,0x00000000},0x230a,1,4657},
+	{{0x00000000,0x00400000,0x00000000},0x230b,1,4657},
+	{{0x00000000,0x00000000,0x00000000},0x2640,1,6122},
+	{{0x00000000,0x00000000,0x00000000},0x2200,1,4027},
+	{{0x00000000,0x00000000,0x00040000},0x2442,1,4802},
+	{{0x00000000,0x00000000,0x00840000},0x2443,1,4802},
+	{{0x00000000,0x00000000,0x00000020},0x2074,0,1450},
+	{{0x00000000,0x00000000,0x00000040},0x2084,0,1450},
+	{{0x00004001,0x00000000,0x00000000},0x2463,0,1450},
+	{{0x00000001,0x00040000,0x00000000},0x2477,0,1450},
+	{{0x00000081,0x00000000,0x00000400},0x0664,0,1450},
+	{{0x00000000,0x00804000,0x00000000},0x2163,0,1450},
+	{{0x02000001,0x00000000,0x00000002},0x248b,0,1450},
+	{{0x00000000,0x00040000,0x00000800},0x3223,0,1450},
+	{{0x00000004,0x00804000,0x00000000},0x2173,0,1450},
+	{{0x00000000,0x00000000,0x00000018},0x2158,1,3590},
+	{{0x00000000,0x00000000,0x00000200},0x2005,1,2841},
+	{{0x00004000,0x00002000,0x00000000},0x246d,1,4952},
+	{{0x00000000,0x00042000,0x00000000},0x2481,1,4952},
+	{{0x02000000,0x00002000,0x00000002},0x2495,1,4952},
+	{{0x00000000,0x00000000,0x00000000},0x220e,1,4143},
+	{{0x00000001,0x00000000,0x00000000},0x20a3,1,3315},
+	{{0x00000000,0x00000000,0x00000000},0x25a0,0,1206},
+	{{0x00000201,0x00000000,0x00000000},0x310d,0,1558},
+	{{0x00008003,0x00000040,0x00000000},0x011c,0,1558},
+	{{0x00008005,0x00000040,0x00000000},0x011d,0,1558},
+	{{0x00000803,0x00000040,0x00000000},0x011e,0,1558},
+	{{0x00000805,0x00000040,0x00000000},0x011f,0,1558},
+	{{0x00002003,0x00000040,0x00000000},0x0122,0,1558},
+	{{0x00002005,0x00000040,0x00000000},0x0123,0,1558},
+	{{0x00000003,0x00000040,0x10000000},0x01e4,0,1558},
+	{{0x00000005,0x00000040,0x10000000},0x01e5,0,1558},
+	{{0x00001003,0x00000040,0x00000000},0x01e6,0,1558},
+	{{0x00001005,0x00000040,0x00000000},0x01e7,0,1558},
+	{{0x00000013,0x00000040,0x00000000},0x01f4,0,1558},
+	{{0x00000015,0x00000040,0x00000000},0x01f5,0,1558},
+	{{0x00000003,0x00000440,0x00000000},0x1e20,0,1558},
+	{{0x00000005,0x00000440,0x00000000},0x1e21,0,1558},
+	{{0x00000005,0x00040040,0x00000000},0x24a2,0,1558},
+	{{0x00004003,0x00000040,0x00000000},0x24bc,0,1558},
+	{{0x00004005,0x00000040,0x00000000},0x24d6,0,1558},
+	{{0x0008000b,0x00000040,0x00000000},0x0120,0,1558},
+	{{0x0008000d,0x00000040,0x00000000},0x0121,0,1558},
+	{{0x00000000,0x00000000,0x00000000},0x24bc,1,5337},
+	{{0x00000000,0x00000000,0x00000000},0x24d6,1,5337},
+	{{0x00000000,0x00000000,0x00000000},0x0403,1,889},
+	{{0x00000000,0x00000000,0x00000000},0x0453,1,889},
+	{{0x00000000,0x00000000,0x00000000},0x01f4,1,389},
+	{{0x00000000,0x00000000,0x00000000},0x01f5,1,389},
+	{{0x00000000,0x00000000,0x00000000},0x011e,1,45},
+	{{0x00000000,0x00000000,0x00000000},0x011f,1,45},
+	{{0x00000000,0x00000000,0x00000000},0x0393,1,682},
+	{{0x00000000,0x00000000,0x00000000},0x03b3,1,682},
+	{{0x00000000,0x00000000,0x00000000},0x05d2,1,1176},
+	{{0x00000000,0x00000000,0x00000000},0x062c,1,1176},
+	{{0x00000000,0x00000000,0x00000000},0xfe9f,1,7087},
+	{{0x00000000,0x00000000,0x00000000},0xfe9d,1,7079},
+	{{0x00000000,0x00000000,0x00000000},0xfe9e,1,7083},
+	{{0x00000000,0x00000000,0x00000000},0xfea0,1,7091},
+	{{0x00000000,0x00000000,0x00000000},0x0122,1,51},
+	{{0x00000000,0x00000000,0x00000000},0x0123,1,51},
+	{{0x00000000,0x00000000,0x00000000},0x1e20,1,1786},
+	{{0x00000000,0x00000000,0x00000000},0x1e21,1,1786},
+	{{0x00000000,0x00000000,0x00000000},0x0120,1,48},
+	{{0x00000000,0x00000000,0x00000000},0x0121,1,48},
+	{{0x00000000,0x00000000,0x00000000},0x01e4,1,364},
+	{{0x00000000,0x00000000,0x00000000},0x01e5,1,364},
+	{{0x00000000,0x00000000,0x00000000},0x0490,1,1157},
+	{{0x00000000,0x00000000,0x00000000},0x0491,1,1157},
+	{{0x00000000,0x00000000,0x00000000},0x310d,1,6811},
+	{{0x00000000,0x00000000,0x00000000},0x01e6,1,367},
+	{{0x00000000,0x00000000,0x00000000},0x01e7,1,367},
+	{{0x00000000,0x00000000,0x00000000},0x0413,1,961},
+	{{0x00000000,0x00000000,0x00000000},0x0433,1,961},
+	{{0x00000000,0x00000000,0x00000000},0x011c,1,42},
+	{{0x00000000,0x00000000,0x00000000},0x011d,1,42},
+	{{0x40000001,0x00000000,0x00000000},0x304c,1,6558},
+	{{0x00000001,0x00000020,0x00000000},0x30ac,1,6558},
+	{{0x00000081,0x00000000,0x00000000},0x06af,1,1721},
+	{{0x08000003,0x00000000,0x00000000},0x0393,1,676},
+	{{0x08000005,0x00000000,0x00000000},0x03b3,1,676},
+	{{0x40000001,0x00000000,0x00000000},0x3052,1,6576},
+	{{0x00000001,0x00000020,0x00000000},0x30b2,1,6576},
+	{{0x00000000,0x00000800,0x00000000},0x3013,1,6478},
+	{{0x00000000,0x00000000,0x00000000},0x06af,1,1725},
+	{{0x00000081,0x00000000,0x00000000},0x063a,1,1498},
+	{{0x00000081,0x00000010,0x00000000},0xfecd,1,1498},
+	{{0x01000081,0x00000000,0x00000000},0xfece,1,1498},
+	{{0x00000081,0x00000004,0x00000000},0xfecf,1,1498},
+	{{0x00000081,0x00001000,0x00000000},0xfed0,1,1498},
+	{{0x00010003,0x00000000,0x00000000},0x0413,1,957},
+	{{0x00010005,0x00000000,0x00000000},0x0433,1,957},
+	{{0x00010003,0x00000000,0x80000000},0x0490,1,957},
+	{{0x00010005,0x00000000,0x80000000},0x0491,1,957},
+	{{0x40000001,0x00000000,0x00000000},0x304e,1,6564},
+	{{0x00000001,0x00000020,0x00000000},0x30ae,1,6564},
+	{{0x20000001,0x00000000,0x00000000},0x05d2,1,1170},
+	{{0x00010003,0x00000000,0x00000000},0x0403,1,885},
+	{{0x00010005,0x00000000,0x00000000},0x0453,1,885},
+	{{0x00000201,0x00000000,0x00000000},0x312c,1,6879},
+	{{0x40000001,0x00000000,0x00000000},0x3054,1,6582},
+	{{0x00000001,0x00000020,0x00000000},0x30b4,1,6582},
+	{{0x00000000,0x04000000,0x00015000},0x2265,0,1509},
+	{{0x40000001,0x00000000,0x00000000},0x3050,1,6570},
+	{{0x00000001,0x00000020,0x00000000},0x30b0,1,6570},
+	{{0x00000201,0x00000000,0x00000000},0x310f,0,1560},
+	{{0x00008003,0x00000040,0x00000000},0x0124,0,1560},
+	{{0x00008005,0x00000040,0x00000000},0x0125,0,1560},
+	{{0x00000003,0x00000040,0x10000000},0x0126,0,1560},
+	{{0x00000005,0x00000040,0x10000000},0x0127,0,1560},
+	{{0x00040003,0x00000040,0x00000000},0x1e26,0,1560},
+	{{0x00040005,0x00000040,0x00000000},0x1e27,0,1560},
+	{{0x00002003,0x00000040,0x00000000},0x1e28,0,1560},
+	{{0x00002005,0x00000040,0x00000000},0x1e29,0,1560},
+	{{0x00000005,0x00040040,0x00000000},0x24a3,0,1560},
+	{{0x00004003,0x00000040,0x00000000},0x24bd,0,1560},
+	{{0x00004005,0x00000040,0x00000000},0x24d7,0,1560},
+	{{0x0008000b,0x00000040,0x00000000},0x1e22,0,1560},
+	{{0x0008000d,0x00000040,0x00000000},0x1e23,0,1560},
+	{{0x00080103,0x00000040,0x00000000},0x1e24,0,1560},
+	{{0x00080105,0x00000040,0x00000000},0x1e25,0,1560},
+	{{0x00000903,0x00000040,0x00000000},0x1e2a,0,1560},
+	{{0x00000905,0x00000040,0x00000000},0x1e2b,0,1560},
+	{{0x00000000,0x00000000,0x00000000},0x24bd,1,5341},
+	{{0x00000000,0x00000000,0x00000000},0x24d7,1,5341},
+	{{0x00000000,0x00000000,0x00000000},0x0621,1,1345},
+	{{0x00000000,0x00000000,0x00000000},0xfe80,1,6987},
+	{{0x00000000,0x00000000,0x00000000},0x0398,1,714},
+	{{0x00000000,0x00000000,0x00000000},0x03b8,1,714},
+	{{0x00000000,0x00000000,0x00000000},0x05d4,1,1191},
+	{{0x00000000,0x00000000,0x00000000},0x0647,1,1191},
+	{{0x00000000,0x00000000,0x00000000},0xfeeb,1,7391},
+	{{0x00000000,0x00000000,0x00000000},0xfee9,1,7383},
+	{{0x00000000,0x00000000,0x00000000},0xfeea,1,7387},
+	{{0x00000000,0x00000000,0x00000000},0xfeec,1,7395},
+	{{0x00000000,0x00000000,0x00000000},0x1e28,1,1799},
+	{{0x00000000,0x00000000,0x00000000},0x1e29,1,1799},
+	{{0x00000000,0x00000000,0x00000000},0x1e2a,1,1802},
+	{{0x00000000,0x00000000,0x00000000},0x1e2b,1,1802},
+	{{0x00000000,0x00000000,0x00000000},0x1e24,1,1792},
+	{{0x00000000,0x00000000,0x00000000},0x1e25,1,1792},
+	{{0x00000000,0x00000000,0x00000000},0x1e22,1,1789},
+	{{0x00000000,0x00000000,0x00000000},0x1e23,1,1789},
+	{{0x00000000,0x00000000,0x00000000},0x0126,1,57},
+	{{0x00000000,0x00000000,0x00000000},0x0127,1,57},
+	{{0x00000000,0x00000000,0x00000000},0x310f,1,6817},
+	{{0x00000000,0x00000000,0x00000000},0x1e26,1,1796},
+	{{0x00000000,0x00000000,0x00000000},0x1e27,1,1796},
+	{{0x00000000,0x00000000,0x00000000},0x0425,1,1049},
+	{{0x00000000,0x00000000,0x00000000},0x0445,1,1049},
+	{{0x00000000,0x00000000,0x00000000},0x0124,1,54},
+	{{0x00000000,0x00000000,0x00000000},0x0125,1,54},
+	{{0x40000001,0x00000000,0x00000000},0x306f,1,1046},
+	{{0x00000001,0x00000020,0x00000000},0x30cf,1,1046},
+	{{0x00010003,0x00000000,0x00000000},0x0425,1,1046},
+	{{0x00010005,0x00000000,0x00000000},0x0445,1,1046},
+	{{0x00000081,0x00000000,0x00000000},0x062d,1,1422},
+	{{0x00000081,0x00000010,0x00000000},0xfea1,1,1422},
+	{{0x01000081,0x00000000,0x00000000},0xfea2,1,1422},
+	{{0x00000081,0x00000004,0x00000000},0xfea3,1,1422},
+	{{0x00000081,0x00001000,0x00000000},0xfea4,1,1422},
+	{{0x00000089,0x00000000,0x00000000},0x0681,1,1688},
+	{{0x00000000,0x00000000,0x00000200},0x200a,1,2878},
+	{{0x00000081,0x00000000,0x00000000},0x0621,1,1339},
+	{{0x00000081,0x00000010,0x00000000},0xfe80,1,1339},
+	{{0x000000a9,0x00000000,0x00000000},0x0623,1,1339},
+	{{0x000001a1,0x00000000,0x00000000},0x0625,1,1339},
+	{{0x000000a9,0x00000010,0x00000000},0xfe83,1,1339},
+	{{0x010000a9,0x00000000,0x00000000},0xfe84,1,1339},
+	{{0x010001a1,0x00000000,0x00000000},0xfe88,1,1339},
+	{{0x00000000,0x00040000,0x00000000},0x321c,1,6882},
+	{{0x00010003,0x00000000,0x00000000},0x042a,1,1079},
+	{{0x00010005,0x00000000,0x00000000},0x044a,1,1079},
+	{{0x20000001,0x00000000,0x00000000},0x05d4,1,1188},
+	{{0x40000001,0x00000000,0x00000000},0x3078,1,1188},
+	{{0x00000001,0x00000020,0x00000000},0x30d8,1,1188},
+	{{0x00000000,0x80000000,0x00008000},0x2661,1,6142},
+	{{0x00000000,0x00000000,0x00008004},0x2665,1,6142},
+	{{0x00000081,0x00000000,0x00000000},0x0647,1,1543},
+	{{0x00000081,0x00000010,0x00000000},0xfee9,1,1543},
+	{{0x01000081,0x00000000,0x00000000},0xfeea,1,1543},
+	{{0x00000081,0x00000004,0x00000000},0xfeeb,1,1543},
+	{{0x00000081,0x00001000,0x00000000},0xfeec,1,1543},
+	{{0x20000001,0x00000000,0x00000000},0x05d7,1,1210},
+	{{0x00000000,0x00000000,0x00000000},0x0681,1,1698},
+	{{0x00000000,0x00000000,0x00000000},0x2500,1,1698},
+	{{0x00000000,0x00000000,0x00000000},0x2550,1,1698},
+	{{0x00000000,0x00000000,0x00000000},0x2501,1,5424},
+	{{0x00000000,0x00000000,0x00000000},0x2253,1,4505},
+	{{0x40000001,0x00000000,0x00000000},0x3072,1,4505},
+	{{0x00000001,0x00000020,0x00000000},0x30d2,1,4505},
+	{{0x00000000,0x01000800,0x00000000},0x201b,1,2948},
+	{{0x00100000,0x00000800,0x00000000},0x201f,1,2948},
+	{{0x00000000,0x00000000,0x00000000},0x062d,1,1426},
+	{{0x00000000,0x00000000,0x00000000},0xfea3,1,7103},
+	{{0x00000000,0x00000000,0x00000000},0xfea1,1,7095},
+	{{0x00000000,0x00000000,0x00000000},0xfea2,1,7099},
+	{{0x00000000,0x00000000,0x00000000},0xfea4,1,7107},
+	{{0x40000001,0x00000000,0x00000000},0x307b,0,1742},
+	{{0x00000001,0x00000020,0x00000000},0x30db,0,1742},
+	{{0x00000000,0x00000000,0x00000000},0x2302,1,4634},
+	{{0x40000001,0x00000000,0x00000000},0x3075,1,6624},
+	{{0x00000001,0x00000020,0x00000000},0x30d5,1,6624},
+	{{0x00000000,0x00814000,0x00000000},0x216d,1,3750},
+	{{0x00000004,0x00814000,0x00000000},0x217d,1,3750},
+	{{0x00000000,0x00000000,0x00000000},0x2010,0,1407},
+	{{0x00000000,0x00000000,0x00000000},0x2043,1,3253},
+	{{0x00000000,0x00000000,0x00000000},0x2027,1,3056},
+	{{0x40000001,0x00000000,0x00000000},0x3044,0,1562},
+	{{0x00000001,0x00000020,0x00000000},0x30a4,0,1562},
+	{{0x00000201,0x00000000,0x00000000},0x3127,0,1562},
+	{{0x00010003,0x00000000,0x00000000},0x0418,0,1562},
+	{{0x00010005,0x00000000,0x00000000},0x0438,0,1562},
+	{{0x40000005,0x00000000,0x00000000},0x3043,0,1562},
+	{{0x00000005,0x00000020,0x00000000},0x30a3,0,1562},
+	{{0x00000003,0x02000040,0x00000000},0x0128,0,1562},
+	{{0x00000005,0x02000040,0x00000000},0x0129,0,1562},
+	{{0x00000003,0x00000440,0x00000000},0x012a,0,1562},
+	{{0x00000005,0x00000440,0x00000000},0x012b,0,1562},
+	{{0x00000803,0x00000040,0x00000000},0x012c,0,1562},
+	{{0x00000805,0x00000040,0x00000000},0x012d,0,1562},
+	{{0x00000003,0x00000040,0x02000000},0x012e,0,1562},
+	{{0x00000005,0x00000040,0x02000000},0x012f,0,1562},
+	{{0x00001003,0x00000040,0x00000000},0x01cf,0,1562},
+	{{0x00001005,0x00000040,0x00000000},0x01d0,0,1562},
+	{{0x00010003,0x00000000,0x08000000},0x0419,0,1562},
+	{{0x00010005,0x00000000,0x08000000},0x0439,0,1562},
+	{{0x00000005,0x00040040,0x00000000},0x24a4,0,1562},
+	{{0x00004003,0x00000040,0x00000000},0x24be,0,1562},
+	{{0x00004005,0x00000040,0x00000000},0x24d8,0,1562},
+	{{0x0008000b,0x00000040,0x00000000},0x0130,0,1562},
+	{{0x04100003,0x00000040,0x00000000},0x0208,0,1562},
+	{{0x04100005,0x00000040,0x00000000},0x0209,0,1562},
+	{{0x00000803,0x00000040,0x00800000},0x020a,0,1562},
+	{{0x00000805,0x00000040,0x00800000},0x020b,0,1562},
+	{{0x00010003,0x00000000,0x40400000},0x0406,0,1562},
+	{{0x00010005,0x00000000,0x40400000},0x0456,0,1562},
+	{{0x00000103,0x02000040,0x00000000},0x1e2c,0,1562},
+	{{0x00000105,0x02000040,0x00000000},0x1e2d,0,1562},
+	{{0x00040013,0x00000040,0x00000000},0x1e2e,0,1562},
+	{{0x00040015,0x00000040,0x00000000},0x1e2f,0,1562},
+	{{0x8000000b,0x00000040,0x00000000},0x1ec8,0,1562},
+	{{0x8000000d,0x00000040,0x00000000},0x1ec9,0,1562},
+	{{0x00080103,0x00000040,0x00000000},0x1eca,0,1562},
+	{{0x00080105,0x00000040,0x00000000},0x1ecb,0,1562},
+	{{0x00000000,0x00000000,0x00000000},0x24be,1,5345},
+	{{0x00000000,0x00000000,0x00000000},0x24d8,1,5345},
+	{{0x00000000,0x00000000,0x00000000},0x0208,1,418},
+	{{0x00000000,0x00000000,0x00000000},0x0209,1,418},
+	{{0x00000000,0x00000000,0x00000000},0x038a,1,642},
+	{{0x00000000,0x00000000,0x00000000},0x03af,1,642},
+	{{0x00000000,0x00000000,0x00000000},0x012c,1,66},
+	{{0x00000000,0x00000000,0x00000000},0x012d,1,66},
+	{{0x00000000,0x00000000,0x00000000},0x020a,1,422},
+	{{0x00000000,0x00000000,0x00000000},0x020b,1,422},
+	{{0x00000000,0x00000000,0x00000000},0x0399,1,717},
+	{{0x00000000,0x00000000,0x00000000},0x03b9,1,717},
+	{{0x00000000,0x00000000,0x00000000},0x1f76,1,2445},
+	{{0x00000000,0x00000000,0x00000000},0x1fda,1,2445},
+	{{0x00000000,0x00000000,0x00000000},0x1f77,1,2449},
+	{{0x00000000,0x00000000,0x00000000},0x1fdb,1,2449},
+	{{0x00000000,0x00000000,0x00000000},0x1fd0,1,2710},
+	{{0x00000000,0x00000000,0x00000000},0x1fd8,1,2710},
+	{{0x00000000,0x00000000,0x00000000},0x1f30,1,2279},
+	{{0x00000000,0x00000000,0x00000000},0x1f38,1,2279},
+	{{0x00000000,0x00000000,0x00000000},0x1f32,1,2287},
+	{{0x00000000,0x00000000,0x00000000},0x1f3a,1,2287},
+	{{0x00000000,0x00000000,0x00000000},0x1f34,1,2297},
+	{{0x00000000,0x00000000,0x00000000},0x1f3c,1,2297},
+	{{0x00000000,0x00000000,0x00000000},0x1f36,1,2307},
+	{{0x00000000,0x00000000,0x00000000},0x1f3e,1,2307},
+	{{0x00000000,0x00000000,0x00000000},0x1fd1,1,2714},
+	{{0x00000000,0x00000000,0x00000000},0x1fd9,1,2714},
+	{{0x00000000,0x00000000,0x00000000},0x1fd2,1,2718},
+	{{0x00000000,0x00000000,0x00000000},0x1fd3,1,2723},
+	{{0x00000000,0x00000000,0x00000000},0x1fd7,1,2732},
+	{{0x00000000,0x00000000,0x00000000},0x1f31,1,2283},
+	{{0x00000000,0x00000000,0x00000000},0x1f39,1,2283},
+	{{0x00000000,0x00000000,0x00000000},0x1f33,1,2292},
+	{{0x00000000,0x00000000,0x00000000},0x1f3b,1,2292},
+	{{0x00000000,0x00000000,0x00000000},0x1f35,1,2302},
+	{{0x00000000,0x00000000,0x00000000},0x1f3d,1,2302},
+	{{0x00000000,0x00000000,0x00000000},0x1f37,1,2312},
+	{{0x00000000,0x00000000,0x00000000},0x1f3f,1,2312},
+	{{0x00000000,0x00000000,0x00000000},0x1fd6,1,2728},
+	{{0x00000000,0x00000000,0x00000000},0x063a,1,1504},
+	{{0x00000000,0x00000000,0x00000000},0xfecf,1,7279},
+	{{0x00000000,0x00000000,0x00000000},0xfecd,1,7271},
+	{{0x00000000,0x00000000,0x00000000},0xfece,1,7275},
+	{{0x00000000,0x00000000,0x00000000},0xfed0,1,7283},
+	{{0x00000000,0x00000000,0x00000000},0x012a,1,63},
+	{{0x00000000,0x00000000,0x00000000},0x012b,1,63},
+	{{0x00000000,0x00000000,0x00000000},0x1eca,1,2081},
+	{{0x00000000,0x00000000,0x00000000},0x1ecb,1,2081},
+	{{0x00000000,0x00000000,0x00000000},0x1e2c,1,1806},
+	{{0x00000000,0x00000000,0x00000000},0x1e2d,1,1806},
+	{{0x00000000,0x00000000,0x00000000},0x0130,1,72},
+	{{0x00000000,0x00000000,0x00000000},0x0131,1,72},
+	{{0x00000000,0x00000000,0x00000000},0x1ec8,1,2078},
+	{{0x00000000,0x00000000,0x00000000},0x1ec9,1,2078},
+	{{0x00000000,0x00000000,0x00000000},0x0390,1,662},
+	{{0x00000000,0x00000000,0x00000000},0x3127,1,6870},
+	{{0x00000000,0x00000000,0x00000000},0x3043,1,6546},
+	{{0x00000000,0x00000000,0x00000000},0x3044,1,6546},
+	{{0x00000000,0x00000000,0x00000000},0x30a3,1,6738},
+	{{0x00000000,0x00000000,0x00000000},0x30a4,1,6738},
+	{{0x00000000,0x00000000,0x00000000},0x1e2e,1,1810},
+	{{0x00000000,0x00000000,0x00000000},0x1e2f,1,1810},
+	{{0x00000000,0x00000000,0x00000000},0x012e,1,69},
+	{{0x00000000,0x00000000,0x00000000},0x012f,1,69},
+	{{0x00000000,0x00000000,0x00000000},0x01cf,1,318},
+	{{0x00000000,0x00000000,0x00000000},0x01d0,1,318},
+	{{0x00000000,0x00000000,0x00000000},0x0418,1,986},
+	{{0x00000000,0x00000000,0x00000000},0x0438,1,986},
+	{{0x00000000,0x00000000,0x00000000},0x0128,1,60},
+	{{0x00000000,0x00000000,0x00000000},0x0129,1,60},
+	{{0x00000000,0x00000000,0x00000000},0x25d9,1,6005},
+	{{0x00000000,0x04000000,0x00000000},0x2261,1,4511},
+	{{0x00000000,0x00000000,0x00000000},0x0404,1,892},
+	{{0x00000000,0x00000000,0x00000000},0x0454,1,892},
+	{{0x00010003,0x00000000,0x00000000},0x0415,1,892},
+	{{0x00010005,0x00000000,0x00000000},0x0435,1,892},
+	{{0x00010003,0x00000000,0x40000000},0x0404,1,892},
+	{{0x00010005,0x00000000,0x40000000},0x0454,1,892},
+	{{0x00000000,0x00000000,0x00000000},0x0406,1,902},
+	{{0x00000000,0x00000000,0x00000000},0x0456,1,902},
+	{{0x00000000,0x00000000,0x00000000},0x0132,1,85},
+	{{0x00000000,0x00000000,0x00000000},0x0133,1,85},
+	{{0x00000002,0x00000040,0x00000100},0x0132,1,85},
+	{{0x00000004,0x00000040,0x00000100},0x0133,1,85},
+	{{0x00000000,0x00000000,0x00000000},0x2321,1,4764},
+	{{0x00000000,0x04000000,0x00011001},0x2253,1,4485},
+	{{0x00000000,0x00000000,0x00000000},0x222b,0,1804},
+	{{0x00000000,0x00000000,0x00000000},0x2206,1,4088},
+	{{0x00000000,0x00000000,0x00000000},0x221e,1,4275},
+	{{0x00000000,0x00000000,0x00000000},0x222b,1,4344},
+	{{0x00100000,0x00000000,0x00000000},0x222c,1,4344},
+	{{0x00000000,0x00000000,0x00000000},0x2229,1,4319},
+	{{0x00000000,0x00000000,0x00000000},0x25d8,1,5975},
+	{{0x00000000,0x80000000,0x00000000},0x25d9,1,5990},
+	{{0x00000000,0x00000000,0x00000000},0x0401,1,875},
+	{{0x00000000,0x00000000,0x00000000},0x0451,1,875},
+	{{0x00000000,0x00000000,0x00000000},0x222e,1,875},
+	{{0x00010003,0x00000000,0x00000000},0x0401,1,875},
+	{{0x00010005,0x00000000,0x00000000},0x0451,1,875},
+	{{0x00000000,0x00000000,0x00000000},0x3000,1,6341},
+	{{0x00000000,0x00000800,0x00000800},0x3005,1,6399},
+	{{0x40000000,0x00000800,0x00000000},0x309d,1,6399},
+	{{0x00000000,0x00000820,0x00000000},0x30fd,1,6399},
+	{{0x00000000,0x00000000,0x00000000},0x2320,1,4745},
+	{{0x00000201,0x00000000,0x00000000},0x3129,1,4745},
+	{{0x00010003,0x00000000,0x00000000},0x0474,1,1143},
+	{{0x00010005,0x00000000,0x00000000},0x0475,1,1143},
+	{{0x00000201,0x00000000,0x00000000},0x3110,0,1564},
+	{{0x00008003,0x00000040,0x00000000},0x0134,0,1564},
+	{{0x00008005,0x00000040,0x00000000},0x0135,0,1564},
+	{{0x00001005,0x00000040,0x00000000},0x01f0,0,1564},
+	{{0x00000005,0x00040040,0x00000000},0x24a5,0,1564},
+	{{0x00004003,0x00000040,0x00000000},0x24bf,0,1564},
+	{{0x00004005,0x00000040,0x00000000},0x24d9,0,1564},
+	{{0x00000000,0x00000000,0x00000000},0x24bf,1,5349},
+	{{0x00000000,0x00000000,0x00000000},0x24d9,1,5349},
+	{{0x00000000,0x00000000,0x00000000},0x0408,1,911},
+	{{0x00000000,0x00000000,0x00000000},0x0458,1,911},
+	{{0x00000000,0x00000000,0x00000000},0x03aa,1,809},
+	{{0x00000000,0x00000000,0x00000000},0x03ca,1,809},
+	{{0x00000000,0x00000000,0x00000000},0x05d9,1,1228},
+	{{0x00000000,0x00000000,0x00000000},0x0649,1,1228},
+	{{0x00000000,0x00000000,0x00000000},0xfeef,1,7407},
+	{{0x00000000,0x00000000,0x00000000},0xfef0,1,7411},
+	{{0x00000000,0x00000000,0x00000000},0x037a,1,589},
+	{{0x00000000,0x00000000,0x00000000},0x1fbe,1,589},
+	{{0x00000000,0x00000000,0x00000000},0x3110,1,6820},
+	{{0x00000000,0x00000000,0x00000000},0x01f0,1,382},
+	{{0x00000000,0x00000000,0x00000000},0x0419,1,989},
+	{{0x00000000,0x00000000,0x00000000},0x0439,1,989},
+	{{0x00000000,0x00000000,0x00000000},0x0134,1,88},
+	{{0x00000000,0x00000000,0x00000000},0x0135,1,88},
+	{{0x00000000,0x00000000,0x00000000},0x042f,1,1112},
+	{{0x00000000,0x00000000,0x00000000},0x044f,1,1112},
+	{{0x00000000,0x00000000,0x00000000},0x3004,1,6359},
+	{{0x00000000,0x00000000,0x00000000},0x042d,1,908},
+	{{0x00000000,0x00000000,0x00000000},0x044d,1,908},
+	{{0x00010003,0x00000000,0x00000000},0x0408,1,908},
+	{{0x00010005,0x00000000,0x00000000},0x0458,1,908},
+	{{0x00000081,0x00000000,0x00000000},0x062c,1,1417},
+	{{0x00000081,0x00000010,0x00000000},0xfe9d,1,1417},
+	{{0x01000081,0x00000000,0x00000000},0xfe9e,1,1417},
+	{{0x00000081,0x00000004,0x00000000},0xfe9f,1,1417},
+	{{0x00000081,0x00001000,0x00000000},0xfea0,1,1417},
+	{{0x00000081,0x00000000,0x00000000},0x0698,1,1710},
+	{{0x00000000,0x00000000,0x00000000},0x3004,1,6395},
+	{{0x00000000,0x00000000,0x00000000},0x042e,1,1106},
+	{{0x00000000,0x00000000,0x00000000},0x044e,1,1106},
+	{{0x00000201,0x00000000,0x00000000},0x310e,0,1566},
+	{{0x00002003,0x00000040,0x00000000},0x0136,0,1566},
+	{{0x00002005,0x00000040,0x00000000},0x0137,0,1566},
+	{{0x80000003,0x00000040,0x00000000},0x0198,0,1566},
+	{{0x80000005,0x00000040,0x00000000},0x0199,0,1566},
+	{{0x00001003,0x00000040,0x00000000},0x01e8,0,1566},
+	{{0x00001005,0x00000040,0x00000000},0x01e9,0,1566},
+	{{0x00000013,0x00000040,0x00000000},0x1e30,0,1566},
+	{{0x00000015,0x00000040,0x00000000},0x1e31,0,1566},
+	{{0x00000005,0x00040040,0x00000000},0x24a6,0,1566},
+	{{0x00004003,0x00000040,0x00000000},0x24c0,0,1566},
+	{{0x00004005,0x00000040,0x00000000},0x24da,0,1566},
+	{{0x00080103,0x00000040,0x00000000},0x1e32,0,1566},
+	{{0x00080105,0x00000040,0x00000000},0x1e33,0,1566},
+	{{0x00000103,0x00000240,0x00000000},0x1e34,0,1566},
+	{{0x00000105,0x00000240,0x00000000},0x1e35,0,1566},
+	{{0x00000000,0x00000000,0x00000000},0x24c0,1,5353},
+	{{0x00000000,0x00000000,0x00000000},0x24da,1,5353},
+	{{0x00000000,0x00000000,0x00000000},0x05da,1,1235},
+	{{0x00000000,0x00000000,0x00000000},0x1e30,1,1814},
+	{{0x00000000,0x00000000,0x00000000},0x1e31,1,1814},
+	{{0x00000000,0x00000000,0x00000000},0x039a,1,726},
+	{{0x00000000,0x00000000,0x00000000},0x03ba,1,726},
+	{{0x00000000,0x00000000,0x00000000},0x05db,1,1238},
+	{{0x00000000,0x00000000,0x00000000},0x0643,1,1238},
+	{{0x00000000,0x00000000,0x00000000},0xfedb,1,7327},
+	{{0x00000000,0x00000000,0x00000000},0xfed9,1,7319},
+	{{0x00000000,0x00000000,0x00000000},0xfeda,1,7323},
+	{{0x00000000,0x00000000,0x00000000},0xfedc,1,7331},
+	{{0x00000000,0x00000000,0x00000000},0x0136,1,91},
+	{{0x00000000,0x00000000,0x00000000},0x0137,1,91},
+	{{0x00000000,0x00000000,0x00000000},0x1e32,1,1817},
+	{{0x00000000,0x00000000,0x00000000},0x1e33,1,1817},
+	{{0x00000000,0x00000000,0x00000000},0x0198,1,257},
+	{{0x00000000,0x00000000,0x00000000},0x0199,1,257},
+	{{0x00000000,0x00000000,0x00000000},0x03de,1,863},
+	{{0x00000000,0x00000000,0x00000000},0x310e,1,6814},
+	{{0x00000000,0x00000000,0x00000000},0x01e8,1,370},
+	{{0x00000000,0x00000000,0x00000000},0x01e9,1,370},
+	{{0x00000000,0x00000000,0x00000000},0x041a,1,995},
+	{{0x00000000,0x00000000,0x00000000},0x043a,1,995},
+	{{0x00000000,0x00000000,0x00000000},0x1e34,1,1821},
+	{{0x00000000,0x00000000,0x00000000},0x1e35,1,1821},
+	{{0x40000001,0x00000000,0x00000000},0x304b,1,992},
+	{{0x00000001,0x00000020,0x00000000},0x30ab,1,992},
+	{{0x00010003,0x00000000,0x00000000},0x041a,1,992},
+	{{0x00010005,0x00000000,0x00000000},0x043a,1,992},
+	{{0x00000005,0x00000020,0x00000000},0x30f5,1,992},
+	{{0x20000001,0x00000000,0x00000000},0x05db,1,1231},
+	{{0x00000081,0x00000000,0x00000000},0x0643,1,1231},
+	{{0x21000001,0x00000000,0x00000000},0x05da,1,1231},
+	{{0x00000081,0x00000010,0x00000000},0xfed9,1,1231},
+	{{0x01000081,0x00000000,0x00000000},0xfeda,1,1231},
+	{{0x00000081,0x00000004,0x00000000},0xfedb,1,1231},
+	{{0x00000081,0x00001000,0x00000000},0xfedc,1,1231},
+	{{0x08000003,0x00000000,0x00000000},0x039a,1,720},
+	{{0x08000005,0x00000000,0x00000000},0x03ba,1,720},
+	{{0x00000080,0x00000000,0x00000000},0x0650,1,1620},
+	{{0x00000080,0x00000000,0x00000000},0x064d,1,1590},
+	{{0x40000001,0x00000000,0x00000000},0x3051,1,6573},
+	{{0x00000001,0x00000020,0x00000000},0x30b1,1,6573},
+	{{0x00000005,0x00000020,0x00000000},0x30f6,1,6573},
+	{{0x00000081,0x00000000,0x00000000},0x062e,1,1429},
+	{{0x00000081,0x00000010,0x00000000},0xfea5,1,1429},
+	{{0x01000081,0x00000000,0x00000000},0xfea6,1,1429},
+	{{0x00000081,0x00000004,0x00000000},0xfea7,1,1429},
+	{{0x00000081,0x00001000,0x00000000},0xfea8,1,1429},
+	{{0x40000001,0x00000000,0x00000000},0x304d,1,6561},
+	{{0x00000001,0x00000020,0x00000000},0x30ad,1,6561},
+	{{0x00000000,0x00000000,0x00000000},0x040c,1,931},
+	{{0x00000000,0x00000000,0x00000000},0x045c,1,931},
+	{{0x00010003,0x00000000,0x00000000},0x040c,1,927},
+	{{0x00010005,0x00000000,0x00000000},0x045c,1,927},
+	{{0x00000000,0x00000000,0x00000000},0x0138,1,98},
+	{{0x40000001,0x00000000,0x00000000},0x3053,1,6579},
+	{{0x00000001,0x00000020,0x00000000},0x30b3,1,6579},
+	{{0x08000001,0x00000000,0x00000000},0x03de,1,857},
+	{{0x00010003,0x00000000,0x00000000},0x0480,1,857},
+	{{0x00010005,0x00000000,0x00000000},0x0481,1,857},
+	{{0x00000000,0x00000000,0x00000000},0x327f,1,6933},
+	{{0x08000000,0x00000000,0x00000000},0x1fbd,1,2653},
+	{{0x00000005,0x00000040,0x00000000},0x0138,1,94},
+	{{0x00000000,0x00000000,0x00000000},0x327f,1,6956},
+	{{0x40000001,0x00000000,0x00000000},0x304f,1,6567},
+	{{0x00000001,0x00000020,0x00000000},0x30af,1,6567},
+	{{0x00000201,0x00000000,0x00000000},0x310c,0,1568},
+	{{0x00000013,0x00000040,0x00000000},0x0139,0,1568},
+	{{0x00000015,0x00000040,0x00000000},0x013a,0,1568},
+	{{0x00002003,0x00000040,0x00000000},0x013b,0,1568},
+	{{0x00002005,0x00000040,0x00000000},0x013c,0,1568},
+	{{0x00001003,0x00000040,0x00000000},0x013d,0,1568},
+	{{0x00001005,0x00000040,0x00000000},0x013e,0,1568},
+	{{0x00000003,0x00000040,0x10000000},0x0141,0,1568},
+	{{0x00000005,0x00000040,0x10000000},0x0142,0,1568},
+	{{0x00000005,0x00040040,0x00000000},0x24a7,0,1568},
+	{{0x00004003,0x00000040,0x00000000},0x24c1,0,1568},
+	{{0x00004005,0x00000040,0x00000000},0x24db,0,1568},
+	{{0x00080003,0x00000040,0x01000000},0x013f,0,1568},
+	{{0x00080005,0x00000040,0x01000000},0x0140,0,1568},
+	{{0x00080103,0x00000040,0x00000000},0x1e36,0,1568},
+	{{0x00080105,0x00000040,0x00000000},0x1e37,0,1568},
+	{{0x00000103,0x00000240,0x00000000},0x1e3a,0,1568},
+	{{0x00000105,0x00000240,0x00000000},0x1e3b,0,1568},
+	{{0x00008103,0x00000040,0x00000000},0x1e3c,0,1568},
+	{{0x00008105,0x00000040,0x00000000},0x1e3d,0,1568},
+	{{0x00080103,0x00000440,0x00000000},0x1e38,0,1568},
+	{{0x00080105,0x00000440,0x00000000},0x1e39,0,1568},
+	{{0x00000007,0x00000040,0x00000000},0x01c8,1,300},
+	{{0x00000000,0x00000000,0x00000000},0x24c1,1,5357},
+	{{0x00000000,0x00000000,0x00000000},0x24db,1,5357},
+	{{0x00000000,0x00000000,0x00000000},0x0139,1,101},
+	{{0x00000000,0x00000000,0x00000000},0x013a,1,101},
+	{{0x00000000,0x00000000,0x00000000},0x039b,1,735},
+	{{0x00000000,0x00000000,0x00000000},0x03bb,1,735},
+	{{0x00000000,0x00000000,0x00000000},0x05dc,1,1247},
+	{{0x00000000,0x00000000,0x00000000},0x0644,1,1247},
+	{{0x00000000,0x00000000,0x00000000},0xfedf,1,7343},
+	{{0x00000000,0x00000000,0x00000000},0xfedd,1,7335},
+	{{0x00000000,0x00000000,0x00000000},0xfede,1,7339},
+	{{0x00000000,0x00000000,0x00000000},0xfee0,1,7347},
+	{{0x00000000,0x00000000,0x00000000},0x013b,1,104},
+	{{0x00000000,0x00000000,0x00000000},0x013c,1,104},
+	{{0x00000000,0x00000000,0x00000000},0x1e38,1,1828},
+	{{0x00000000,0x00000000,0x00000000},0x1e39,1,1828},
+	{{0x00000000,0x00000000,0x00000000},0x1e36,1,1824},
+	{{0x00000000,0x00000000,0x00000000},0x1e37,1,1824},
+	{{0x00000000,0x00000000,0x00000000},0x1e3c,1,1836},
+	{{0x00000000,0x00000000,0x00000000},0x1e3d,1,1836},
+	{{0x00000000,0x00000000,0x00000000},0x013f,1,110},
+	{{0x00000000,0x00000000,0x00000000},0x0140,1,110},
+	{{0x00000000,0x00000000,0x00000000},0x0141,1,113},
+	{{0x00000000,0x00000000,0x00000000},0x0142,1,113},
+	{{0x00000000,0x00000000,0x00000000},0x310c,1,6808},
+	{{0x00000000,0x00000000,0x00000000},0x013d,1,107},
+	{{0x00000000,0x00000000,0x00000000},0x013e,1,107},
+	{{0x00000000,0x00000000,0x00000000},0x041b,1,1001},
+	{{0x00000000,0x00000000,0x00000000},0x043b,1,1001},
+	{{0x00000000,0x00000000,0x00000000},0x1e3a,1,1833},
+	{{0x00000000,0x00000000,0x00000000},0x1e3b,1,1833},
+	{{0x00000000,0x00000000,0x00000000},0xfefb,1,7467},
+	{{0x00000000,0x00000000,0x00000000},0xfefc,1,7471},
+	{{0x00000081,0x00000000,0x00000000},0x0644,1,1529},
+	{{0x00000081,0x00000010,0x00000000},0xfedd,1,1529},
+	{{0x01000081,0x00000000,0x00000000},0xfede,1,1529},
+	{{0x00000081,0x00000004,0x00000000},0xfedf,1,1529},
+	{{0x00000081,0x00001000,0x00000000},0xfee0,1,1529},
+	{{0x000000a1,0x00000010,0x00000100},0xfefb,1,1529},
+	{{0x010000a1,0x00000000,0x00000100},0xfefc,1,1529},
+	{{0x000000a9,0x00000010,0x00000100},0xfef7,1,7449},
+	{{0x010000a9,0x00000000,0x00000100},0xfef8,1,7449},
+	{{0x000001a1,0x00000010,0x00000100},0xfef9,1,7449},
+	{{0x010001a1,0x00000000,0x00000100},0xfefa,1,7449},
+	{{0x000000a9,0x00000010,0x00000100},0xfef5,1,7431},
+	{{0x010000a9,0x00000000,0x00000100},0xfef6,1,7431},
+	{{0x08000003,0x00000000,0x00000000},0x039b,1,729},
+	{{0x08000005,0x00000000,0x00000000},0x03bb,1,729},
+	{{0x20000001,0x00000000,0x00000000},0x05dc,1,1241},
+	{{0x00000000,0x00000000,0x00000000},0x25ef,1,6028},
+	{{0x00000000,0x00000000,0x00800000},0x223e,1,4423},
+	{{0x00000000,0x00000000,0x00000000},0x2584,1,5683},
+	{{0x00000000,0x00000000,0x00000000},0x258c,1,5683},
+	{{0x00000000,0x00000000,0x00000000},0x2557,1,5622},
+	{{0x00000000,0x00000000,0x00000000},0x2513,1,5512},
+	{{0x00000000,0x00000000,0x00002000},0x2190,1,3857},
+	{{0x00100000,0x00000000,0x00002000},0x21d0,1,3857},
+	{{0x00000000,0x00000080,0x00020004},0x3010,1,6451},
+	{{0x00000000,0x00400000,0x00020004},0x3011,1,6451},
+	{{0x00000000,0x80000080,0x00020000},0x3016,1,6451},
+	{{0x00000000,0x80400000,0x00020000},0x3017,1,6451},
+	{{0x00000000,0x04000000,0x00015000},0x2264,0,1497},
+	{{0x00000000,0x00000000,0x00000000},0xfef7,1,7459},
+	{{0x00000000,0x00000000,0x00000000},0xfef9,1,7459},
+	{{0x00000000,0x00000000,0x00000000},0xfef8,1,7463},
+	{{0x00000000,0x00000000,0x00000000},0xfefa,1,7463},
+	{{0x00000000,0x00000000,0x00000000},0x2028,1,3087},
+	{{0x00000001,0x00000000,0x00000000},0x20a4,1,3328},
+	{{0x00000000,0x00000000,0x00000000},0x0409,1,293},
+	{{0x00000000,0x00000000,0x00000000},0x0459,1,293},
+	{{0x00000003,0x00000040,0x00000000},0x01c7,1,293},
+	{{0x00000005,0x00000040,0x00000000},0x01c9,1,293},
+	{{0x00000000,0x00000000,0x00000000},0x01c7,1,296},
+	{{0x00000000,0x00000000,0x00000000},0x01c8,1,296},
+	{{0x00000000,0x00000000,0x00000000},0x01c9,1,296},
+	{{0x00010003,0x00000000,0x00000000},0x0409,1,914},
+	{{0x00010005,0x00000000,0x00000000},0x0459,1,914},
+	{{0x00000000,0x00000000,0x00000000},0xfef5,1,7441},
+	{{0x00000000,0x00000000,0x00000000},0xfef6,1,7445},
+	{{0x00000001,0x00000000,0x00000000},0x2227,1,4308},
+	{{0x00000000,0x00000000,0x00010000},0x2228,1,4308},
+	{{0x00000005,0x00000040,0x00000000},0x017f,1,235},
+	{{0x00000004,0x00000040,0x00000100},0xfb05,1,6974},
+	{{0x00100000,0x00000200,0x00000000},0x2017,0,1641},
+	{{0x00000000,0x01000800,0x00000000},0x201a,1,2929},
+	{{0x00100000,0x00000800,0x00000000},0x201e,1,2929},
+	{{0x08000001,0x00004000,0x00000000},0x0375,1,566},
+	{{0x00000000,0x00000000,0x00080000},0x2584,1,5671},
+	{{0x00000000,0x00400000,0x00000004},0x25e2,1,6008},
+	{{0x00000000,0x00000080,0x00000004},0x25e3,1,6008},
+	{{0x00000000,0x00000000,0x00000000},0x25ca,1,5936},
+	{{0x00000000,0x00000000,0x00000000},0x200e,1,2886},
+	{{0x00000000,0x00000000,0x00000000},0x25ca,1,5944},
+	{{0x00000201,0x00000000,0x00000000},0x3107,0,1570},
+	{{0x00000013,0x00000040,0x00000000},0x1e3e,0,1570},
+	{{0x00000015,0x00000040,0x00000000},0x1e3f,0,1570},
+	{{0x00000005,0x00040040,0x00000000},0x24a8,0,1570},
+	{{0x00004003,0x00000040,0x00000000},0x24c2,0,1570},
+	{{0x00004005,0x00000040,0x00000000},0x24dc,0,1570},
+	{{0x0008000b,0x00000040,0x00000000},0x1e40,0,1570},
+	{{0x0008000d,0x00000040,0x00000000},0x1e41,0,1570},
+	{{0x00080103,0x00000040,0x00000000},0x1e42,0,1570},
+	{{0x00080105,0x00000040,0x00000000},0x1e43,0,1570},
+	{{0x00000000,0x00000000,0x00000000},0x24c2,1,5361},
+	{{0x00000000,0x00000000,0x00000000},0x24dc,1,5361},
+	{{0x00000000,0x00000000,0x00000000},0x05dd,1,1254},
+	{{0x00000000,0x00000000,0x00000000},0x1e3e,1,1840},
+	{{0x00000000,0x00000000,0x00000000},0x1e3f,1,1840},
+	{{0x00000000,0x00000000,0x00000000},0x039c,1,741},
+	{{0x00000000,0x00000000,0x00000000},0x03bc,1,741},
+	{{0x00000000,0x00000000,0x00000000},0x05de,1,1257},
+	{{0x00000000,0x00000000,0x00000000},0x0645,1,1257},
+	{{0x00000000,0x00000000,0x00000000},0xfee3,1,7359},
+	{{0x00000000,0x00000000,0x00000000},0xfee1,1,7351},
+	{{0x00000000,0x00000000,0x00000000},0xfee2,1,7355},
+	{{0x00000000,0x00000000,0x00000000},0xfee4,1,7363},
+	{{0x00000000,0x00000000,0x00000000},0x1e42,1,1846},
+	{{0x00000000,0x00000000,0x00000000},0x1e43,1,1846},
+	{{0x00000000,0x00000000,0x00000000},0x1e40,1,1843},
+	{{0x00000000,0x00000000,0x00000000},0x1e41,1,1843},
+	{{0x00000000,0x00000000,0x00000000},0x266c,1,6256},
+	{{0x00000000,0x00000000,0x00000000},0x266b,1,6230},
+	{{0x00000000,0x00000000,0x00000000},0x03dc,1,854},
+	{{0x00000000,0x00000000,0x00000000},0x3107,1,6796},
+	{{0x00000000,0x00000000,0x00000000},0x266a,1,6203},
+	{{0x00000000,0x00000000,0x00000000},0x041c,1,1004},
+	{{0x00000000,0x00000000,0x00000000},0x043c,1,1004},
+	{{0x40000001,0x00000000,0x00000000},0x307e,1,6633},
+	{{0x00000001,0x00000020,0x00000000},0x30de,1,6633},
+	{{0x000000a9,0x00000000,0x00000000},0x0622,1,1348},
+	{{0x000000a9,0x00000010,0x00000000},0xfe81,1,1348},
+	{{0x010000a9,0x00000000,0x00000000},0xfe82,1,1348},
+	{{0x000000a1,0x00000000,0x00000000},0x0649,1,1551},
+	{{0x000000a1,0x00000010,0x00000000},0xfeef,1,1551},
+	{{0x010000a1,0x00000000,0x00000000},0xfef0,1,1551},
+	{{0x00000001,0x00000000,0x00000000},0x2642,1,6125},
+	{{0x00000000,0x00000000,0x00000000},0x2720,1,6324},
+	{{0x00000000,0x00000000,0x00000000},0x266d,1,6271},
+	{{0x00000000,0x00000000,0x00000000},0x2669,1,6188},
+	{{0x40000001,0x00000000,0x00000000},0x3081,1,6639},
+	{{0x00000001,0x00000020,0x00000000},0x30e1,1,6639},
+	{{0x00000000,0x00000000,0x00000000},0x2592,1,5707},
+	{{0x00000081,0x00000000,0x00000000},0x0645,1,1533},
+	{{0x00000081,0x00000010,0x00000000},0xfee1,1,1533},
+	{{0x01000081,0x00000000,0x00000000},0xfee2,1,1533},
+	{{0x00000081,0x00000004,0x00000000},0xfee3,1,1533},
+	{{0x00000081,0x00001000,0x00000000},0xfee4,1,1533},
+	{{0x20000001,0x00000000,0x00000000},0x05de,1,1250},
+	{{0x21000001,0x00000000,0x00000000},0x05dd,1,1250},
+	{{0x40000001,0x00000000,0x00000000},0x307f,1,6636},
+	{{0x00000001,0x00000020,0x00000000},0x30df,1,6636},
+	{{0x00000001,0x00000000,0x00000000},0x2212,1,3297},
+	{{0x00000000,0x00000000,0x00000020},0x207b,1,3297},
+	{{0x00000000,0x00000000,0x00000040},0x208b,1,3297},
+	{{0x00000001,0x00000000,0x00010000},0x2213,1,4185},
+	{{0x00000000,0x00000000,0x00000000},0x2642,1,6130},
+	{{0x40000001,0x00000000,0x00000000},0x3082,1,6642},
+	{{0x00000001,0x00000020,0x00000000},0x30e2,1,6642},
+	{{0x00000001,0x00000400,0x00000000},0x02c9,1,507},
+	{{0x00008001,0x00000000,0x00000000},0x02c6,1,485},
+	{{0x04000001,0x00000000,0x00000000},0x02cb,1,485},
+	{{0x00000001,0x00000000,0x00000000},0x02bb,1,460},
+	{{0x40000001,0x00000000,0x00000000},0x3080,1,738},
+	{{0x00000001,0x00000020,0x00000000},0x30e0,1,738},
+	{{0x08000003,0x00000000,0x00000000},0x039c,1,738},
+	{{0x08000005,0x00000000,0x00000000},0x03bc,1,738},
+	{{0x00000000,0x00000000,0x00004000},0x226b,1,4543},
+	{{0x00000000,0x00000000,0x00004000},0x226a,1,4530},
+	{{0x00000001,0x00000000,0x00000000},0x266d,1,6260},
+	{{0x00000001,0x00000000,0x00000000},0x266e,1,6274},
+	{{0x00000001,0x00000000,0x00000000},0x266f,1,6291},
+	{{0x00000000,0x00000000,0x00000000},0x266e,1,6288},
+	{{0x00000000,0x00000000,0x00000000},0x266f,1,6288},
+	{{0x40000001,0x00000000,0x00000000},0x3093,0,1572},
+	{{0x00000001,0x00000020,0x00000000},0x30f3,0,1572},
+	{{0x00000201,0x00000000,0x00000000},0x310b,0,1572},
+	{{0x00000013,0x00000040,0x00000000},0x0143,0,1572},
+	{{0x00000015,0x00000040,0x00000000},0x0144,0,1572},
+	{{0x00002003,0x00000040,0x00000000},0x0145,0,1572},
+	{{0x00002005,0x00000040,0x00000000},0x0146,0,1572},
+	{{0x00001003,0x00000040,0x00000000},0x0147,0,1572},
+	{{0x00001005,0x00000040,0x00000000},0x0148,0,1572},
+	{{0x00000005,0x00000040,0x00000020},0x207f,0,1572},
+	{{0x00000005,0x00040040,0x00000000},0x24a9,0,1572},
+	{{0x00004003,0x00000040,0x00000000},0x24c3,0,1572},
+	{{0x00004005,0x00000040,0x00000000},0x24dd,0,1572},
+	{{0x0008000b,0x00000040,0x00000000},0x1e44,0,1572},
+	{{0x0008000d,0x00000040,0x00000000},0x1e45,0,1572},
+	{{0x00080103,0x00000040,0x00000000},0x1e46,0,1572},
+	{{0x00080105,0x00000040,0x00000000},0x1e47,0,1572},
+	{{0x00000103,0x00000240,0x00000000},0x1e48,0,1572},
+	{{0x00000105,0x00000240,0x00000000},0x1e49,0,1572},
+	{{0x00008103,0x00000040,0x00000000},0x1e4a,0,1572},
+	{{0x00008105,0x00000040,0x00000000},0x1e4b,0,1572},
+	{{0x00000000,0x00000000,0x00000000},0x220f,1,4146},
+	{{0x00000000,0x00000000,0x00000000},0x2211,1,4163},
+	{{0x00000007,0x00000040,0x00000000},0x01cb,1,311},
+	{{0x00000000,0x00000000,0x00000000},0x24c3,1,5365},
+	{{0x00000000,0x00000000,0x00000000},0x24dd,1,5365},
+	{{0x00000005,0x00000040,0x00000000},0x0149,1,125},
+	{{0x00000000,0x00000000,0x00000000},0x05df,1,1264},
+	{{0x00000000,0x00000000,0x00000000},0x0143,1,116},
+	{{0x00000000,0x00000000,0x00000000},0x0144,1,116},
+	{{0x00000000,0x00000000,0x00000000},0x039d,1,744},
+	{{0x00000000,0x00000000,0x00000000},0x03bd,1,744},
+	{{0x00000000,0x00000000,0x00000000},0x05e0,1,1267},
+	{{0x00000000,0x00000000,0x00000000},0x0646,1,1267},
+	{{0x00000000,0x00000000,0x00000000},0xfee7,1,7375},
+	{{0x00000000,0x00000000,0x00000000},0xfee5,1,7367},
+	{{0x00000000,0x00000000,0x00000000},0xfee6,1,7371},
+	{{0x00000000,0x00000000,0x00000000},0xfee8,1,7379},
+	{{0x00000000,0x00000000,0x00000000},0x0145,1,119},
+	{{0x00000000,0x00000000,0x00000000},0x0146,1,119},
+	{{0x00000000,0x00000000,0x00000000},0x1e46,1,1853},
+	{{0x00000000,0x00000000,0x00000000},0x1e47,1,1853},
+	{{0x00000000,0x00000000,0x00000000},0x1e4a,1,1860},
+	{{0x00000000,0x00000000,0x00000000},0x1e4b,1,1860},
+	{{0x00000000,0x00000000,0x00000000},0x1e44,1,1850},
+	{{0x00000000,0x00000000,0x00000000},0x1e45,1,1850},
+	{{0x00000000,0x00000000,0x00000000},0x2116,1,3418},
+	{{0x00000000,0x00000000,0x00000000},0x310b,1,6805},
+	{{0x00000000,0x00000000,0x00000000},0x3093,1,6669},
+	{{0x00000000,0x00000000,0x00000000},0x30f3,1,6750},
+	{{0x00000000,0x00000000,0x00000000},0x0147,1,122},
+	{{0x00000000,0x00000000,0x00000000},0x0148,1,122},
+	{{0x00000000,0x00000000,0x00000000},0x041d,1,1010},
+	{{0x00000000,0x00000000,0x00000000},0x043d,1,1010},
+	{{0x00000000,0x00000000,0x00000000},0x1e48,1,1857},
+	{{0x00000000,0x00000000,0x00000000},0x1e49,1,1857},
+	{{0x40000001,0x00000000,0x00000000},0x306a,1,6612},
+	{{0x00000001,0x00000020,0x00000000},0x30ca,1,6612},
+	{{0x00000000,0x00000000,0x00000000},0x2207,1,4098},
+	{{0x00000000,0x00000000,0x00000000},0x2207,0,1314},
+	{{0x40000001,0x00000000,0x00000000},0x306d,1,6615},
+	{{0x00000001,0x00000020,0x00000000},0x30cd,1,6615},
+	{{0x00000000,0x00000000,0x00000000},0x014a,1,157},
+	{{0x00000000,0x00000000,0x00000000},0x014b,1,157},
+	{{0x00000201,0x00000000,0x00000000},0x312b,1,157},
+	{{0x00000000,0x00000000,0x00000000},0x2310,1,4682},
+	{{0x40000001,0x00000000,0x00000000},0x306b,1,4682},
+	{{0x00000001,0x00000020,0x00000000},0x30cb,1,4682},
+	{{0x00000000,0x00000000,0x00000020},0x2079,0,1476},
+	{{0x00000000,0x00000000,0x00000040},0x2089,0,1476},
+	{{0x00004001,0x00000000,0x00000000},0x2468,0,1476},
+	{{0x00000001,0x00040000,0x00000000},0x247c,0,1476},
+	{{0x00000081,0x00000000,0x00000400},0x0669,0,1476},
+	{{0x00000000,0x00804000,0x00000000},0x2168,0,1476},
+	{{0x02000001,0x00000000,0x00000002},0x2490,0,1476},
+	{{0x00000000,0x00040000,0x00000800},0x3228,0,1476},
+	{{0x00000004,0x00804000,0x00000000},0x2178,0,1476},
+	{{0x00004000,0x00002000,0x00000000},0x2472,1,5021},
+	{{0x00000000,0x00042000,0x00000000},0x2486,1,5021},
+	{{0x02000000,0x00002000,0x00000002},0x249a,1,5021},
+	{{0x00000000,0x00000000,0x00000000},0x040a,1,304},
+	{{0x00000000,0x00000000,0x00000000},0x045a,1,304},
+	{{0x00000003,0x00000040,0x00000000},0x01ca,1,304},
+	{{0x00000005,0x00000040,0x00000000},0x01cc,1,304},
+	{{0x00000000,0x00000000,0x00000000},0x01ca,1,307},
+	{{0x00000000,0x00000000,0x00000000},0x01cb,1,307},
+	{{0x00000000,0x00000000,0x00000000},0x01cc,1,307},
+	{{0x00010003,0x00000000,0x00000000},0x040a,1,918},
+	{{0x00010005,0x00000000,0x00000000},0x045a,1,918},
+	{{0x40000001,0x00000000,0x00000000},0x306e,0,2642},
+	{{0x00000001,0x00000020,0x00000000},0x30ce,0,2642},
+	{{0x00000081,0x00000000,0x00000000},0x0646,1,1538},
+	{{0x00000081,0x00000010,0x00000000},0xfee5,1,1538},
+	{{0x01000081,0x00000000,0x00000000},0xfee6,1,1538},
+	{{0x00000081,0x00000004,0x00000000},0xfee7,1,1538},
+	{{0x00000081,0x00001000,0x00000000},0xfee8,1,1538},
+	{{0x00000000,0x00000000,0x00002000},0x2197,1,3929},
+	{{0x00000000,0x00000000,0x00002000},0x2196,1,3914},
+	{{0x00000000,0x04000000,0x00001000},0x2260,0,2638},
+	{{0x00000000,0x00000000,0x00004000},0x226f,1,4571},
+	{{0x00000000,0x00000000,0x00004000},0x226e,1,4559},
+	{{0x00000000,0x00000000,0x00000000},0x207f,0,2485},
+	{{0x40000001,0x00000000,0x00000000},0x306c,0,707},
+	{{0x00000001,0x00000020,0x00000000},0x30cc,0,707},
+	{{0x08000003,0x00000000,0x00000000},0x039d,0,707},
+	{{0x08000005,0x00000000,0x00000000},0x03bd,0,707},
+	{{0x00000001,0x00000000,0x00000000},0x2116,1,3411},
+	{{0x20000001,0x00000000,0x00000000},0x05e0,1,1260},
+	{{0x21000001,0x00000000,0x00000000},0x05df,1,1260},
+	{{0x40000001,0x00000000,0x00000000},0x304a,0,1574},
+	{{0x00000001,0x00000020,0x00000000},0x30aa,0,1574},
+	{{0x00000201,0x00000000,0x00000000},0x311b,0,1574},
+	{{0x00010003,0x00000000,0x00000000},0x041e,0,1574},
+	{{0x00010005,0x00000000,0x00000000},0x043e,0,1574},
+	{{0x40000005,0x00000000,0x00000000},0x3049,0,1574},
+	{{0x00000005,0x00000020,0x00000000},0x30a9,0,1574},
+	{{0x00000003,0x00000440,0x00000000},0x014c,0,1574},
+	{{0x00000005,0x00000440,0x00000000},0x014d,0,1574},
+	{{0x00000803,0x00000040,0x00000000},0x014e,0,1574},
+	{{0x00000805,0x00000040,0x00000000},0x014f,0,1574},
+	{{0x00000003,0x00000042,0x00000000},0x01a0,0,1574},
+	{{0x00000005,0x00000042,0x00000000},0x01a1,0,1574},
+	{{0x00001003,0x00000040,0x00000000},0x01d1,0,1574},
+	{{0x00001005,0x00000040,0x00000000},0x01d2,0,1574},
+	{{0x00000003,0x00000040,0x02000000},0x01ea,0,1574},
+	{{0x00000005,0x00000040,0x02000000},0x01eb,0,1574},
+	{{0x00000005,0x00040040,0x00000000},0x24aa,0,1574},
+	{{0x00004003,0x00000040,0x00000000},0x24c4,0,1574},
+	{{0x00004005,0x00000040,0x00000000},0x24de,0,1574},
+	{{0x00100013,0x00000040,0x00000000},0x0150,0,1574},
+	{{0x00100015,0x00000040,0x00000000},0x0151,0,1574},
+	{{0x00000003,0x00000440,0x02000000},0x01ec,0,1574},
+	{{0x00000005,0x00000440,0x02000000},0x01ed,0,1574},
+	{{0x00000013,0x00000040,0x10000000},0x01fe,0,1574},
+	{{0x00000015,0x00000040,0x10000000},0x01ff,0,1574},
+	{{0x04100003,0x00000040,0x00000000},0x020c,0,1574},
+	{{0x04100005,0x00000040,0x00000000},0x020d,0,1574},
+	{{0x00000803,0x00000040,0x00800000},0x020e,0,1574},
+	{{0x00000805,0x00000040,0x00800000},0x020f,0,1574},
+	{{0x00000013,0x02000040,0x00000000},0x1e4c,0,1574},
+	{{0x00000015,0x02000040,0x00000000},0x1e4d,0,1574},
+	{{0x00040003,0x02000040,0x00000000},0x1e4e,0,1574},
+	{{0x00040005,0x02000040,0x00000000},0x1e4f,0,1574},
+	{{0x04000003,0x00000440,0x00000000},0x1e50,0,1574},
+	{{0x04000005,0x00000440,0x00000000},0x1e51,0,1574},
+	{{0x00000013,0x00000440,0x00000000},0x1e52,0,1574},
+	{{0x00000015,0x00000440,0x00000000},0x1e53,0,1574},
+	{{0x00080103,0x00000040,0x00000000},0x1ecc,0,1574},
+	{{0x00080105,0x00000040,0x00000000},0x1ecd,0,1574},
+	{{0x8000000b,0x00000040,0x00000000},0x1ece,0,1574},
+	{{0x8000000d,0x00000040,0x00000000},0x1ecf,0,1574},
+	{{0x00008013,0x00000040,0x00000000},0x1ed0,0,1574},
+	{{0x00008015,0x00000040,0x00000000},0x1ed1,0,1574},
+	{{0x04008003,0x00000040,0x00000000},0x1ed2,0,1574},
+	{{0x04008005,0x00000040,0x00000000},0x1ed3,0,1574},
+	{{0x00008003,0x02000040,0x00000000},0x1ed6,0,1574},
+	{{0x00008005,0x02000040,0x00000000},0x1ed7,0,1574},
+	{{0x00000013,0x00000042,0x00000000},0x1eda,0,1574},
+	{{0x00000015,0x00000042,0x00000000},0x1edb,0,1574},
+	{{0x04000003,0x00000042,0x00000000},0x1edc,0,1574},
+	{{0x04000005,0x00000042,0x00000000},0x1edd,0,1574},
+	{{0x00000003,0x02000042,0x00000000},0x1ee0,0,1574},
+	{{0x00000005,0x02000042,0x00000000},0x1ee1,0,1574},
+	{{0x8000800b,0x00000040,0x00000000},0x1ed4,0,1574},
+	{{0x8000800d,0x00000040,0x00000000},0x1ed5,0,1574},
+	{{0x00088103,0x00000040,0x00000000},0x1ed8,0,1574},
+	{{0x00088105,0x00000040,0x00000000},0x1ed9,0,1574},
+	{{0x8000000b,0x00000042,0x00000000},0x1ede,0,1574},
+	{{0x8000000d,0x00000042,0x00000000},0x1edf,0,1574},
+	{{0x00080103,0x00000042,0x00000000},0x1ee2,0,1574},
+	{{0x00080105,0x00000042,0x00000000},0x1ee3,0,1574},
+	{{0x00000000,0x00000000,0x00000000},0x24c4,1,5369},
+	{{0x00000000,0x00000000,0x00000000},0x24de,1,5369},
+	{{0x00000000,0x00000000,0x00000000},0x020c,1,425},
+	{{0x00000000,0x00000000,0x00000000},0x020d,1,425},
+	{{0x00000000,0x00000000,0x00000000},0x0150,1,166},
+	{{0x00000000,0x00000000,0x00000000},0x0151,1,166},
+	{{0x00000000,0x00000000,0x00000000},0x038c,1,653},
+	{{0x00000000,0x00000000,0x00000000},0x03cc,1,653},
+	{{0x00000000,0x00000000,0x00000000},0x014e,1,163},
+	{{0x00000000,0x00000000,0x00000000},0x014f,1,163},
+	{{0x00000000,0x00000000,0x00000000},0x020e,1,429},
+	{{0x00000000,0x00000000,0x00000000},0x020f,1,429},
+	{{0x00000000,0x00000000,0x00000000},0x039f,1,753},
+	{{0x00000000,0x00000000,0x00000000},0x03bf,1,753},
+	{{0x00000000,0x00000000,0x00000000},0x1f78,1,2453},
+	{{0x00000000,0x00000000,0x00000000},0x1ff8,1,2453},
+	{{0x00000000,0x00000000,0x00000000},0x1f79,1,2457},
+	{{0x00000000,0x00000000,0x00000000},0x1ff9,1,2457},
+	{{0x00000000,0x00000000,0x00000000},0x1f40,1,2317},
+	{{0x00000000,0x00000000,0x00000000},0x1f48,1,2317},
+	{{0x00000000,0x00000000,0x00000000},0x1f42,1,2325},
+	{{0x00000000,0x00000000,0x00000000},0x1f4a,1,2325},
+	{{0x00000000,0x00000000,0x00000000},0x1f44,1,2335},
+	{{0x00000000,0x00000000,0x00000000},0x1f4c,1,2335},
+	{{0x00000000,0x00000000,0x00000000},0x1f41,1,2321},
+	{{0x00000000,0x00000000,0x00000000},0x1f49,1,2321},
+	{{0x00000000,0x00000000,0x00000000},0x1f43,1,2330},
+	{{0x00000000,0x00000000,0x00000000},0x1f4b,1,2330},
+	{{0x00000000,0x00000000,0x00000000},0x1f45,1,2340},
+	{{0x00000000,0x00000000,0x00000000},0x1f4d,1,2340},
+	{{0x00000000,0x00000000,0x00000000},0x014c,1,160},
+	{{0x00000000,0x00000000,0x00000000},0x014d,1,160},
+	{{0x00000000,0x00000000,0x00000000},0x1e50,1,1872},
+	{{0x00000000,0x00000000,0x00000000},0x1e51,1,1872},
+	{{0x00000000,0x00000000,0x00000000},0x1e52,1,1876},
+	{{0x00000000,0x00000000,0x00000000},0x1e53,1,1876},
+	{{0x00000000,0x00000000,0x00000000},0x1ecc,1,2085},
+	{{0x00000000,0x00000000,0x00000000},0x1ecd,1,2085},
+	{{0x00000000,0x00000000,0x00000000},0x01fe,1,400},
+	{{0x00000000,0x00000000,0x00000000},0x01ff,1,400},
+	{{0x00000000,0x00000000,0x00000000},0x01ec,1,376},
+	{{0x00000000,0x00000000,0x00000000},0x01ed,1,376},
+	{{0x00000000,0x00000000,0x00000000},0x1ece,1,2089},
+	{{0x00000000,0x00000000,0x00000000},0x1ecf,1,2089},
+	{{0x00000000,0x00000000,0x00000000},0x046a,1,1132},
+	{{0x00000000,0x00000000,0x00000000},0x046b,1,1132},
+	{{0x00000000,0x00000000,0x00000000},0x311b,1,6844},
+	{{0x00000000,0x00000000,0x00000000},0x3049,1,6555},
+	{{0x00000000,0x00000000,0x00000000},0x304a,1,6555},
+	{{0x00000000,0x00000000,0x00000000},0x30a9,1,6747},
+	{{0x00000000,0x00000000,0x00000000},0x30aa,1,6747},
+	{{0x00000000,0x00000000,0x00000000},0x01a0,1,260},
+	{{0x00000000,0x00000000,0x00000000},0x01a1,1,260},
+	{{0x00000000,0x00000000,0x00000000},0x1edc,1,2117},
+	{{0x00000000,0x00000000,0x00000000},0x1edd,1,2117},
+	{{0x00000000,0x00000000,0x00000000},0x1eda,1,2113},
+	{{0x00000000,0x00000000,0x00000000},0x1edb,1,2113},
+	{{0x00000000,0x00000000,0x00000000},0x1ee2,1,2129},
+	{{0x00000000,0x00000000,0x00000000},0x1ee3,1,2129},
+	{{0x00000000,0x00000000,0x00000000},0x1ede,1,2121},
+	{{0x00000000,0x00000000,0x00000000},0x1edf,1,2121},
+	{{0x00000000,0x00000000,0x00000000},0x1ee0,1,2125},
+	{{0x00000000,0x00000000,0x00000000},0x1ee1,1,2125},
+	{{0x00000000,0x00000000,0x00000000},0x01ea,1,373},
+	{{0x00000000,0x00000000,0x00000000},0x01eb,1,373},
+	{{0x00000000,0x00000000,0x00000000},0x01d1,1,321},
+	{{0x00000000,0x00000000,0x00000000},0x01d2,1,321},
+	{{0x00000000,0x00000000,0x00000000},0x041e,1,1013},
+	{{0x00000000,0x00000000,0x00000000},0x043e,1,1013},
+	{{0x00000000,0x00000000,0x00000000},0x1ed2,1,2096},
+	{{0x00000000,0x00000000,0x00000000},0x1ed3,1,2096},
+	{{0x00000000,0x00000000,0x00000000},0x1ed0,1,2092},
+	{{0x00000000,0x00000000,0x00000000},0x1ed1,1,2092},
+	{{0x00000000,0x00000000,0x00000000},0x1ed8,1,2108},
+	{{0x00000000,0x00000000,0x00000000},0x1ed9,1,2108},
+	{{0x00000000,0x00000000,0x00000000},0x1ed4,1,2100},
+	{{0x00000000,0x00000000,0x00000000},0x1ed5,1,2100},
+	{{0x00000000,0x00000000,0x00000000},0x1ed6,1,2104},
+	{{0x00000000,0x00000000,0x00000000},0x1ed7,1,2104},
+	{{0x00000000,0x00000000,0x00000000},0x1e4c,1,1864},
+	{{0x00000000,0x00000000,0x00000000},0x1e4d,1,1864},
+	{{0x00000000,0x00000000,0x00000000},0x1e4e,1,1868},
+	{{0x00000000,0x00000000,0x00000000},0x1e4f,1,1868},
+	{{0x00000000,0x00000000,0x00000000},0x2218,1,4232},
+	{{0x00000000,0x00000000,0x00000000},0x2103,0,2415},
+	{{0x00000000,0x00000000,0x00000000},0x0152,1,169},
+	{{0x00000000,0x00000000,0x00000000},0x0153,1,169},
+	{{0x00000002,0x00000040,0x00000100},0x0152,1,169},
+	{{0x00000004,0x00000040,0x00000100},0x0153,1,169},
+	{{0x00000001,0x00000000,0x00000000},0x2126,1,3488},
+	{{0x00000000,0x00000000,0x00000000},0x01a2,1,263},
+	{{0x00000000,0x00000000,0x00000000},0x01a3,1,263},
+	{{0x00000003,0x00000040,0x00000000},0x01a2,1,263},
+	{{0x00000005,0x00000040,0x00000000},0x01a3,1,263},
+	{{0x00000000,0x00000000,0x00000000},0x2713,1,6309},
+	{{0x00000000,0x00000000,0x00000000},0x2126,1,3492},
+	{{0x08000003,0x00000000,0x00000000},0x039f,1,645},
+	{{0x08000005,0x00000000,0x00000000},0x03bf,1,645},
+	{{0x08000003,0x00000000,0x20000000},0x038c,1,645},
+	{{0x08000005,0x00000000,0x20000000},0x03cc,1,645},
+	{{0x08000005,0x00200000,0x00000000},0x1f40,1,645},
+	{{0x08020005,0x00000000,0x00000000},0x1f41,1,645},
+	{{0x08000003,0x00200000,0x00000000},0x1f48,1,645},
+	{{0x08020003,0x00000000,0x00000000},0x1f49,1,645},
+	{{0x08000005,0x20000000,0x00000000},0x1f78,1,645},
+	{{0x08000005,0x00020000,0x00000000},0x1f79,1,645},
+	{{0x08000003,0x20000000,0x00000000},0x1ff8,1,645},
+	{{0x08000003,0x00020000,0x00000000},0x1ff9,1,645},
+	{{0x08000005,0x20200000,0x00000000},0x1f42,1,645},
+	{{0x08020005,0x20000000,0x00000000},0x1f43,1,645},
+	{{0x08000005,0x00220000,0x00000000},0x1f44,1,645},
+	{{0x08020005,0x00020000,0x00000000},0x1f45,1,645},
+	{{0x08000003,0x20200000,0x00000000},0x1f4a,1,645},
+	{{0x08020003,0x20000000,0x00000000},0x1f4b,1,645},
+	{{0x08000003,0x00220000,0x00000000},0x1f4c,1,645},
+	{{0x08020003,0x00020000,0x00000000},0x1f4d,1,645},
+	{{0x00000400,0x00000000,0x00000000},0x2423,1,4788},
+	{{0x00000000,0x00000000,0x04000000},0x2218,1,4223},
+	{{0x00000000,0x02000000,0x00000000},0x223c,1,4223},
+	{{0x00080000,0x00000000,0x00000000},0x22c5,1,4223},
+	{{0x00084000,0x00000000,0x00000000},0x2299,1,4223},
+	{{0x00004000,0x00000000,0x04000000},0x229a,1,4223},
+	{{0x00000001,0x00000000,0x00000080},0x25a6,1,5784},
+	{{0x00000000,0x00000000,0x00000000},0x25a1,1,5737},
+	{{0x00000201,0x00000000,0x00000000},0x3121,1,6863},
+	{{0x00000000,0x00000000,0x00000000},0x203e,1,3241},
+	{{0x00000201,0x00000000,0x00000000},0x3106,0,1576},
+	{{0x00000013,0x00000040,0x00000000},0x1e54,0,1576},
+	{{0x00000015,0x00000040,0x00000000},0x1e55,0,1576},
+	{{0x00000005,0x00040040,0x00000000},0x24ab,0,1576},
+	{{0x00004003,0x00000040,0x00000000},0x24c5,0,1576},
+	{{0x00004005,0x00000040,0x00000000},0x24df,0,1576},
+	{{0x0008000b,0x00000040,0x00000000},0x1e56,0,1576},
+	{{0x0008000d,0x00000040,0x00000000},0x1e57,0,1576},
+	{{0x00000000,0x00000000,0x00000000},0x24c5,1,5373},
+	{{0x00000000,0x00000000,0x00000000},0x24df,1,5373},
+	{{0x00000000,0x00000000,0x00000000},0x05e3,1,1288},
+	{{0x00000000,0x00000000,0x00000000},0x1e54,1,1880},
+	{{0x00000000,0x00000000,0x00000000},0x1e55,1,1880},
+	{{0x00000000,0x00000000,0x00000000},0x03a0,1,756},
+	{{0x00000000,0x00000000,0x00000000},0x03c0,1,756},
+	{{0x00000000,0x00000000,0x00000000},0x05e4,1,1291},
+	{{0x00000000,0x00000000,0x00000000},0x067e,1,1291},
+	{{0x00000000,0x00000000,0x00000000},0x1e56,1,1883},
+	{{0x00000000,0x00000000,0x00000000},0x1e57,1,1883},
+	{{0x00000000,0x00000000,0x00000000},0x03e0,1,872},
+	{{0x00000000,0x00000000,0x00000000},0x3106,1,6793},
+	{{0x00000000,0x00000000,0x00000000},0x041f,1,1019},
+	{{0x00000000,0x00000000,0x00000000},0x043f,1,1019},
+	{{0x40000001,0x00000000,0x00000000},0x3071,0,1717},
+	{{0x00000001,0x00000020,0x00000000},0x30d1,0,1717},
+	{{0x00000000,0x00000000,0x00000000},0x2029,1,3095},
+	{{0x00000000,0x04000000,0x00000000},0x2225,1,4296},
+	{{0x00000000,0x00000080,0x00000020},0x207d,0,1362},
+	{{0x00000000,0x00400000,0x00000020},0x207e,0,1362},
+	{{0x00000000,0x00000080,0x00000040},0x208d,0,1362},
+	{{0x00000000,0x00400000,0x00000040},0x208e,0,1362},
+	{{0x00000000,0x00000000,0x00000000},0x2029,1,3115},
+	{{0x00000000,0x00000000,0x00000000},0x2202,1,4038},
+	{{0x20000001,0x00000000,0x00000000},0x05e4,1,1016},
+	{{0x40000001,0x00000000,0x00000000},0x307a,1,1016},
+	{{0x00000001,0x00000020,0x00000000},0x30da,1,1016},
+	{{0x00010003,0x00000000,0x00000000},0x041f,1,1016},
+	{{0x00010005,0x00000000,0x00000000},0x043f,1,1016},
+	{{0x21000001,0x00000000,0x00000000},0x05e3,1,1016},
+	{{0x00000081,0x00000000,0x00000000},0x067e,1,1684},
+	{{0x00000001,0x00000000,0x00000000},0x2030,1,3122},
+	{{0x00000081,0x00000000,0x00000000},0x066a,0,1333},
+	{{0x00000001,0x00000000,0x00000000},0x20a7,1,3333},
+	{{0x08000003,0x00000000,0x00000000},0x03a6,1,785},
+	{{0x08000005,0x00000000,0x00000000},0x03c6,1,785},
+	{{0x40000001,0x00000000,0x00000000},0x3074,0,2727},
+	{{0x00000001,0x00000020,0x00000000},0x30d4,0,2727},
+	{{0x08000003,0x00000000,0x00000000},0x03a0,0,2727},
+	{{0x08000005,0x00000000,0x00000000},0x03c0,0,2727},
+	{{0x00000000,0x00000000,0x00000000},0x25c4,1,5919},
+	{{0x00000001,0x00000000,0x00000001},0x2318,1,4714},
+	{{0x00000001,0x00000000,0x00000020},0x207a,0,1383},
+	{{0x00000001,0x00000000,0x00000040},0x208a,0,1383},
+	{{0x00080000,0x00000000,0x00000000},0x2214,0,1383},
+	{{0x00000000,0x00000000,0x00000080},0x33d8,0,2438},
+	{{0x00000000,0x00000000,0x00000000},0x2117,1,3447},
+	{{0x40000001,0x00000000,0x00000000},0x307d,1,3447},
+	{{0x00000001,0x00000020,0x00000000},0x30dd,1,3447},
+	{{0x00000000,0x00000080,0x00020000},0x2329,1,4767},
+	{{0x00000000,0x00400000,0x00020000},0x232a,1,4767},
+	{{0x00000000,0x01000880,0x00000000},0x2039,0,2610},
+	{{0x00000000,0x01400800,0x00000000},0x203a,0,2610},
+	{{0x00000000,0x80000080,0x00000000},0x261c,1,6066},
+	{{0x00000000,0x80400000,0x00000000},0x261e,1,6066},
+	{{0x00000000,0x00400000,0x00000004},0x25ba,1,5896},
+	{{0x00000000,0x00000080,0x00000004},0x25c4,1,5896},
+	{{0x00000000,0x08000000,0x00000004},0x25b2,1,5875},
+	{{0x00000000,0x88000000,0x00000000},0x25b3,1,5875},
+	{{0x00000000,0x80400000,0x00000000},0x25b7,1,5875},
+	{{0x00200000,0x00000000,0x00000004},0x25bc,1,5875},
+	{{0x00200000,0x80000000,0x00000000},0x25bd,1,5875},
+	{{0x00000000,0x80000080,0x00000000},0x25c1,1,5875},
+	{{0x00000000,0x00000800,0x00000000},0x3012,1,6468},
+	{{0x00000000,0x00000800,0x00000000},0x3020,1,6526},
+	{{0x00000000,0x00000000,0x00000000},0x2225,1,4305},
+	{{0x00000000,0x00000000,0x00000000},0x25ba,1,5913},
+	{{0x00000000,0x00000000,0x00000000},0x211e,1,3450},
+	{{0x00000000,0x00000000,0x00000000},0x2032,1,3135},
+	{{0x00100000,0x00000000,0x00000000},0x2033,1,3135},
+	{{0x40000000,0x00000820,0x00000000},0x30fc,1,6765},
+	{{0x00000000,0x00000000,0x00100001},0x220e,1,4137},
+	{{0x00000000,0x00000000,0x00000000},0x2237,1,4406},
+	{{0x00000000,0x04000000,0x00000000},0x221d,1,4259},
+	{{0x08000003,0x00000000,0x00000000},0x03a8,1,799},
+	{{0x08000005,0x00000000,0x00000000},0x03c8,1,799},
+	{{0x40000001,0x00000000,0x00000000},0x3077,0,2007},
+	{{0x00000001,0x00000020,0x00000000},0x30d7,0,2007},
+	{{0x00000201,0x00000000,0x00000000},0x3111,0,1578},
+	{{0x00000005,0x00040040,0x00000000},0x24ac,0,1578},
+	{{0x00004003,0x00000040,0x00000000},0x24c6,0,1578},
+	{{0x00004005,0x00000040,0x00000000},0x24e0,0,1578},
+	{{0x00000000,0x00000000,0x00000000},0x24c6,1,5377},
+	{{0x00000000,0x00000000,0x00000000},0x24e0,1,5377},
+	{{0x00000000,0x00000000,0x00000000},0x03a8,1,803},
+	{{0x00000000,0x00000000,0x00000000},0x03c8,1,803},
+	{{0x00000000,0x00000000,0x00000000},0x05e7,1,1307},
+	{{0x00000000,0x00000000,0x00000000},0x0642,1,1307},
+	{{0x00000000,0x00000000,0x00000000},0xfed7,1,7311},
+	{{0x00000000,0x00000000,0x00000000},0xfed5,1,7303},
+	{{0x00000000,0x00000000,0x00000000},0xfed6,1,7307},
+	{{0x00000000,0x00000000,0x00000000},0xfed8,1,7315},
+	{{0x00000000,0x00000000,0x00000000},0x3111,1,6823},
+	{{0x00000081,0x00000000,0x00000000},0x0642,1,1525},
+	{{0x00000081,0x00000010,0x00000000},0xfed5,1,1525},
+	{{0x01000081,0x00000000,0x00000000},0xfed6,1,1525},
+	{{0x00000081,0x00000004,0x00000000},0xfed7,1,1525},
+	{{0x00000081,0x00001000,0x00000000},0xfed8,1,1525},
+	{{0x20000001,0x00000000,0x00000000},0x05e7,1,1303},
+	{{0x00400400,0x00000101,0x00000000},0x2508,1,5465},
+	{{0x10400400,0x00000001,0x00000000},0x2509,1,5465},
+	{{0x00400400,0x40000100,0x00000000},0x250a,1,5465},
+	{{0x10400400,0x40000000,0x00000000},0x250b,1,5465},
+	{{0x00000000,0x00000000,0x00000000},0x2669,1,6175},
+	{{0x08000000,0x00000800,0x00000000},0x037e,0,1517},
+	{{0x00000080,0x00000800,0x00000000},0x061f,0,1517},
+	{{0x00000000,0x01000880,0x00000000},0x2018,0,1304},
+	{{0x00000000,0x01400800,0x00000000},0x2019,0,1304},
+	{{0x00100000,0x00000880,0x00000000},0x201c,0,1304},
+	{{0x00100000,0x00400800,0x00000000},0x201d,0,1304},
+	{{0x00000201,0x00000000,0x00000000},0x3116,0,1580},
+	{{0x00000013,0x00000040,0x00000000},0x0154,0,1580},
+	{{0x00000015,0x00000040,0x00000000},0x0155,0,1580},
+	{{0x00002003,0x00000040,0x00000000},0x0156,0,1580},
+	{{0x00002005,0x00000040,0x00000000},0x0157,0,1580},
+	{{0x00001003,0x00000040,0x00000000},0x0158,0,1580},
+	{{0x00001005,0x00000040,0x00000000},0x0159,0,1580},
+	{{0x00000005,0x00040040,0x00000000},0x24ad,0,1580},
+	{{0x00004003,0x00000040,0x00000000},0x24c7,0,1580},
+	{{0x00004005,0x00000040,0x00000000},0x24e1,0,1580},
+	{{0x04100003,0x00000040,0x00000000},0x0210,0,1580},
+	{{0x04100005,0x00000040,0x00000000},0x0211,0,1580},
+	{{0x00000803,0x00000040,0x00800000},0x0212,0,1580},
+	{{0x00000805,0x00000040,0x00800000},0x0213,0,1580},
+	{{0x0008000b,0x00000040,0x00000000},0x1e58,0,1580},
+	{{0x0008000d,0x00000040,0x00000000},0x1e59,0,1580},
+	{{0x00080103,0x00000040,0x00000000},0x1e5a,0,1580},
+	{{0x00080105,0x00000040,0x00000000},0x1e5b,0,1580},
+	{{0x00000103,0x00000240,0x00000000},0x1e5e,0,1580},
+	{{0x00000105,0x00000240,0x00000000},0x1e5f,0,1580},
+	{{0x00080103,0x00000440,0x00000000},0x1e5c,0,1580},
+	{{0x00080105,0x00000440,0x00000000},0x1e5d,0,1580},
+	{{0x00000005,0x00000040,0x00000000},0x027c,1,446},
+	{{0x00000000,0x00000000,0x00000000},0x24c7,1,5381},
+	{{0x00000000,0x00000000,0x00000000},0x24e1,1,5381},
+	{{0x00000000,0x00000000,0x00000000},0x0210,1,432},
+	{{0x00000000,0x00000000,0x00000000},0x0211,1,432},
+	{{0x00000000,0x00000000,0x00000000},0x0154,1,172},
+	{{0x00000000,0x00000000,0x00000000},0x0155,1,172},
+	{{0x00000000,0x00000000,0x00000000},0x0212,1,436},
+	{{0x00000000,0x00000000,0x00000000},0x0213,1,436},
+	{{0x00000000,0x00000000,0x00000000},0x03a1,1,763},
+	{{0x00000000,0x00000000,0x00000000},0x03c1,1,763},
+	{{0x00000000,0x00000000,0x00000000},0x1fe4,1,2764},
+	{{0x00000000,0x00000000,0x00000000},0x1fe5,1,2768},
+	{{0x00000000,0x00000000,0x00000000},0x1fec,1,2768},
+	{{0x00000000,0x00000000,0x00000000},0x05e8,1,1315},
+	{{0x00000000,0x00000000,0x00000000},0x0631,1,1315},
+	{{0x00000000,0x00000000,0x00000000},0xfead,1,7143},
+	{{0x00000000,0x00000000,0x00000000},0xfeae,1,7147},
+	{{0x00000000,0x00000000,0x00000000},0x0156,1,175},
+	{{0x00000000,0x00000000,0x00000000},0x0157,1,175},
+	{{0x00000000,0x00000000,0x00000000},0x1e5c,1,1893},
+	{{0x00000000,0x00000000,0x00000000},0x1e5d,1,1893},
+	{{0x00000000,0x00000000,0x00000000},0x1e5a,1,1889},
+	{{0x00000000,0x00000000,0x00000000},0x1e5b,1,1889},
+	{{0x00000000,0x00000000,0x00000000},0x1e58,1,1886},
+	{{0x00000000,0x00000000,0x00000000},0x1e59,1,1886},
+	{{0x00000000,0x00000000,0x00000000},0x027c,1,457},
+	{{0x00000000,0x00000000,0x00000000},0x3116,1,6829},
+	{{0x00000000,0x00000000,0x00000000},0x0158,1,178},
+	{{0x00000000,0x00000000,0x00000000},0x0159,1,178},
+	{{0x00000000,0x00000000,0x00000000},0x0420,1,1025},
+	{{0x00000000,0x00000000,0x00000000},0x0440,1,1025},
+	{{0x00000000,0x00000000,0x00000000},0x1e5e,1,1898},
+	{{0x00000000,0x00000000,0x00000000},0x1e5f,1,1898},
+	{{0x40000001,0x00000000,0x00000000},0x3089,1,6648},
+	{{0x00000001,0x00000020,0x00000000},0x30e9,1,6648},
+	{{0x00000000,0x00000000,0x00000000},0x2236,1,4397},
+	{{0x00000000,0x00000000,0x00000000},0x2590,1,5695},
+	{{0x40000001,0x00000000,0x00000000},0x308c,1,6654},
+	{{0x00000001,0x00000020,0x00000000},0x30ec,1,6654},
+	{{0x00000000,0x00000000,0x00000004},0x25ac,1,5862},
+	{{0x00000000,0x80000000,0x00000000},0x25ad,1,5862},
+	{{0x00000000,0x00000800,0x00000000},0x203b,1,3224},
+	{{0x00000081,0x00000000,0x00000000},0x0631,1,1446},
+	{{0x00000081,0x00000010,0x00000000},0xfead,1,1446},
+	{{0x01000081,0x00000000,0x00000000},0xfeae,1,1446},
+	{{0x20000001,0x00000000,0x00000000},0x05e8,1,1310},
+	{{0x00000001,0x00000000,0x00000000},0x2310,1,4669},
+	{{0x00000000,0x00000000,0x00000000},0x2035,1,3163},
+	{{0x00100000,0x00000000,0x00000000},0x2036,1,3163},
+	{{0x00000000,0x00000000,0x00000000},0x2037,1,3184},
+	{{0x00000000,0x00000000,0x00000000},0x25a4,1,5778},
+	{{0x00000000,0x00000000,0x00000000},0x25a6,1,5811},
+	{{0x08000003,0x00000000,0x00000000},0x03a1,1,759},
+	{{0x08000005,0x00000000,0x00000000},0x03c1,1,759},
+	{{0x08000005,0x00200000,0x00000000},0x1fe4,1,759},
+	{{0x08020005,0x00000000,0x00000000},0x1fe5,1,759},
+	{{0x08020003,0x00000000,0x00000000},0x1fec,1,759},
+	{{0x40000001,0x00000000,0x00000000},0x308a,0,2027},
+	{{0x00000001,0x00000020,0x00000000},0x30ea,0,2027},
+	{{0x00000000,0x00000000,0x00002000},0x2192,1,3881},
+	{{0x00100000,0x00000000,0x00002000},0x21d2,1,3881},
+	{{0x00000001,0x00000000,0x00000000},0x21c0,1,3983},
+	{{0x00000000,0x00000000,0x00000000},0x25a8,1,5834},
+	{{0x00000000,0x00000000,0x00000000},0x200f,1,2889},
+	{{0x00000000,0x00000000,0x00000000},0x25a2,1,5756},
+	{{0x40000001,0x00000000,0x00000000},0x308d,1,5756},
+	{{0x00000001,0x00000020,0x00000000},0x30ed,1,5756},
+	{{0x00000000,0x00000000,0x00000080},0x221a,1,4251},
+	{{0x00000001,0x80000000,0x00000080},0x25a2,1,5740},
+	{{0x00000000,0x00000000,0x00000000},0x25a3,1,5770},
+	{{0x00000000,0x00000000,0x00000000},0x221a,1,4256},
+	{{0x40000001,0x00000000,0x00000000},0x308b,1,6651},
+	{{0x00000001,0x00000020,0x00000000},0x30eb,1,6651},
+	{{0x00000000,0x00000000,0x00000000},0x211e,1,3468},
+	{{0x00000000,0x00000000,0x00000000},0x25a9,1,3468},
+	{{0x00000000,0x00000000,0x00000000},0x25a5,1,5781},
+	{{0x00000000,0x00000000,0x00000000},0x25a7,1,5831},
+	{{0x00000201,0x00000000,0x00000000},0x3119,0,1582},
+	{{0x00000013,0x00000040,0x00000000},0x015a,0,1582},
+	{{0x00000015,0x00000040,0x00000000},0x015b,0,1582},
+	{{0x00008003,0x00000040,0x00000000},0x015c,0,1582},
+	{{0x00008005,0x00000040,0x00000000},0x015d,0,1582},
+	{{0x00002003,0x00000040,0x00000000},0x015e,0,1582},
+	{{0x00002005,0x00000040,0x00000000},0x015f,0,1582},
+	{{0x00001003,0x00000040,0x00000000},0x0160,0,1582},
+	{{0x00001005,0x00000040,0x00000000},0x0161,0,1582},
+	{{0x00000005,0x00040040,0x00000000},0x24ae,0,1582},
+	{{0x00004003,0x00000040,0x00000000},0x24c8,0,1582},
+	{{0x00004005,0x00000040,0x00000000},0x24e2,0,1582},
+	{{0x0008000b,0x00000040,0x00000000},0x1e60,0,1582},
+	{{0x0008000d,0x00000040,0x00000000},0x1e61,0,1582},
+	{{0x00080103,0x00000040,0x00000000},0x1e62,0,1582},
+	{{0x00080105,0x00000040,0x00000000},0x1e63,0,1582},
+	{{0x0008001b,0x00000040,0x00000000},0x1e64,0,1582},
+	{{0x0008001d,0x00000040,0x00000000},0x1e65,0,1582},
+	{{0x0008100b,0x00000040,0x00000000},0x1e66,0,1582},
+	{{0x0008100d,0x00000040,0x00000000},0x1e67,0,1582},
+	{{0x0008010b,0x00000040,0x00000000},0x1e68,0,1582},
+	{{0x0008010d,0x00000040,0x00000000},0x1e69,0,1582},
+	{{0x00000000,0x00000000,0x00000000},0x24c8,1,5385},
+	{{0x00000000,0x00000000,0x00000000},0x24e2,1,5385},
+	{{0x00000000,0x00000000,0x00000000},0x0428,1,1070},
+	{{0x00000000,0x00000000,0x00000000},0x0448,1,1070},
+	{{0x00000000,0x00000000,0x00000000},0x015a,1,181},
+	{{0x00000000,0x00000000,0x00000000},0x015b,1,181},
+	{{0x00000000,0x00000000,0x00000000},0x1e64,1,1908},
+	{{0x00000000,0x00000000,0x00000000},0x1e65,1,1908},
+	{{0x00000000,0x00000000,0x00000000},0x03a3,1,772},
+	{{0x00000000,0x00000000,0x00000000},0x03c3,1,772},
+	{{0x00000000,0x00000000,0x00000000},0x05e1,1,1277},
+	{{0x00000000,0x00000000,0x00000000},0x0633,1,1277},
+	{{0x00000000,0x00000000,0x00000000},0xfeb3,1,7167},
+	{{0x00000000,0x00000000,0x00000000},0xfeb1,1,7159},
+	{{0x00000000,0x00000000,0x00000000},0xfeb2,1,7163},
+	{{0x00000000,0x00000000,0x00000000},0xfeb4,1,7171},
+	{{0x00000000,0x00000000,0x00000000},0x015e,1,187},
+	{{0x00000000,0x00000000,0x00000000},0x015f,1,187},
+	{{0x00000000,0x00000000,0x00000000},0x1e62,1,1904},
+	{{0x00000000,0x00000000,0x00000000},0x1e63,1,1904},
+	{{0x00000000,0x00000000,0x00000000},0x1e60,1,1901},
+	{{0x00000000,0x00000000,0x00000000},0x1e61,1,1901},
+	{{0x00000000,0x00000000,0x00000000},0x1e68,1,1916},
+	{{0x00000000,0x00000000,0x00000000},0x1e69,1,1916},
+	{{0x00000000,0x00000000,0x00000000},0x017f,1,242},
+	{{0x00000000,0x00000000,0x00000000},0x3119,1,6838},
+	{{0x00000000,0x00000000,0x00000000},0x0160,1,190},
+	{{0x00000000,0x00000000,0x00000000},0x0161,1,190},
+	{{0x00000000,0x00000000,0x00000000},0x1e66,1,1912},
+	{{0x00000000,0x00000000,0x00000000},0x1e67,1,1912},
+	{{0x00000000,0x00000000,0x00000000},0x0421,1,1028},
+	{{0x00000000,0x00000000,0x00000000},0x0441,1,1028},
+	{{0x00000000,0x00000000,0x00000000},0x015c,1,184},
+	{{0x00000000,0x00000000,0x00000000},0x015d,1,184},
+	{{0x40000001,0x00000000,0x00000000},0x3055,0,1843},
+	{{0x00000001,0x00000020,0x00000000},0x30b5,0,1843},
+	{{0x00000081,0x00000000,0x00000000},0x0635,1,1469},
+	{{0x00000081,0x00000010,0x00000000},0xfeb9,1,1469},
+	{{0x01000081,0x00000000,0x00000000},0xfeba,1,1469},
+	{{0x00000081,0x00000004,0x00000000},0xfebb,1,1469},
+	{{0x00000081,0x00001000,0x00000000},0xfebc,1,1469},
+	{{0x20000001,0x00000000,0x00000000},0x05e1,1,1270},
+	{{0x08000001,0x00000000,0x00000000},0x03e0,1,866},
+	{{0x00000000,0x00000000,0x00000000},0x2022,0,1170},
+	{{0x00000000,0x00000000,0x00000000},0x2219,0,1170},
+	{{0x00000000,0x00000000,0x00000000},0x25aa,0,1170},
+	{{0x00000000,0x00000000,0x00000000},0x0429,0,2327},
+	{{0x00000000,0x00000000,0x00000000},0x0449,0,2327},
+	{{0x40000001,0x00000000,0x00000000},0x305b,0,2561},
+	{{0x00000001,0x00000020,0x00000000},0x30bb,0,2561},
+	{{0x00000081,0x00000000,0x00000000},0x0633,1,1455},
+	{{0x00000081,0x00000010,0x00000000},0xfeb1,1,1455},
+	{{0x01000081,0x00000000,0x00000000},0xfeb2,1,1455},
+	{{0x00000081,0x00000004,0x00000000},0xfeb3,1,1455},
+	{{0x00000081,0x00001000,0x00000000},0xfeb4,1,1455},
+	{{0x40000000,0x00000820,0x00000000},0x309c,1,6691},
+	{{0x00000080,0x00000000,0x00000000},0x061b,0,1487},
+	{{0x00000000,0x00000200,0x00000000},0x2028,1,3077},
+	{{0x00000000,0x00000800,0x00000000},0x2120,1,3471},
+	{{0x00000000,0x00000000,0x00000020},0x2077,0,1464},
+	{{0x00000000,0x00000000,0x00000040},0x2087,0,1464},
+	{{0x00004001,0x00000000,0x00000000},0x2466,0,1464},
+	{{0x00000001,0x00040000,0x00000000},0x247a,0,1464},
+	{{0x00000081,0x00000000,0x00000400},0x0667,0,1464},
+	{{0x00000000,0x00804000,0x00000000},0x2166,0,1464},
+	{{0x02000001,0x00000000,0x00000002},0x248e,0,1464},
+	{{0x00000000,0x00040000,0x00000800},0x3226,0,1464},
+	{{0x00000004,0x00804000,0x00000000},0x2176,0,1464},
+	{{0x00000000,0x00000000,0x00000018},0x215e,1,3672},
+	{{0x00004000,0x00002000,0x00000000},0x2470,1,4992},
+	{{0x00000000,0x00042000,0x00000000},0x2484,1,4992},
+	{{0x02000000,0x00002000,0x00000002},0x2498,1,4992},
+	{{0x00000000,0x00000000,0x00000000},0x05e9,0,728},
+	{{0x00000201,0x00000000,0x00000000},0x3115,0,728},
+	{{0x00010003,0x00000000,0x00000000},0x0428,1,1066},
+	{{0x00010005,0x00000000,0x00000000},0x0448,1,1066},
+	{{0x00000080,0x00000000,0x00000000},0x0651,1,1629},
+	{{0x00000081,0x00001000,0x00000000},0xfe7d,1,1629},
+	{{0x00000000,0x00000100,0x00000000},0x2591,1,5698},
+	{{0x00010003,0x00000000,0x00000000},0x0429,1,1073},
+	{{0x00010005,0x00000000,0x00000000},0x0449,1,1073},
+	{{0x00000081,0x00000000,0x00000000},0x0634,1,1460},
+	{{0x00000081,0x00000010,0x00000000},0xfeb5,1,1460},
+	{{0x01000081,0x00000000,0x00000000},0xfeb6,1,1460},
+	{{0x00000081,0x00000004,0x00000000},0xfeb7,1,1460},
+	{{0x00000081,0x00001000,0x00000000},0xfeb8,1,1460},
+	{{0x20000001,0x00000000,0x00000000},0x05e9,1,1318},
+	{{0x40000001,0x00000000,0x00000000},0x3057,0,927},
+	{{0x00000001,0x00000020,0x00000000},0x30b7,0,927},
+	{{0x08000003,0x00000000,0x00000000},0x03a3,1,766},
+	{{0x08000005,0x00000000,0x00000000},0x03c3,1,766},
+	{{0x09000005,0x00000000,0x00000000},0x03c2,1,766},
+	{{0x00000000,0x00000000,0x00000020},0x2076,0,1460},
+	{{0x00000000,0x00000000,0x00000040},0x2086,0,1460},
+	{{0x00004001,0x00000000,0x00000000},0x2465,0,1460},
+	{{0x00000001,0x00040000,0x00000000},0x2479,0,1460},
+	{{0x00000081,0x00000000,0x00000400},0x0666,0,1460},
+	{{0x00000000,0x00804000,0x00000000},0x2165,0,1460},
+	{{0x02000001,0x00000000,0x00000002},0x248d,0,1460},
+	{{0x00000000,0x00040000,0x00000800},0x3225,0,1460},
+	{{0x00000004,0x00804000,0x00000000},0x2175,0,1460},
+	{{0x00000000,0x00000000,0x00000200},0x2006,1,2856},
+	{{0x00004000,0x00002000,0x00000000},0x246f,1,4979},
+	{{0x00000000,0x00042000,0x00000000},0x2483,1,4979},
+	{{0x02000000,0x00002000,0x00000002},0x2497,1,4979},
+	{{0x00000000,0x00010000,0x00000018},0x2159,1,3605},
+	{{0x00000000,0x00000000,0x00000008},0x2044,0,1429},
+	{{0x00000000,0x00000000,0x00000000},0x2120,1,3479},
+	{{0x00000000,0x80000000,0x00000000},0x263a,1,6087},
+	{{0x00000000,0x00000000,0x00000004},0x263b,1,6087},
+	{{0x00000000,0x00000000,0x00000000},0x0634,1,1466},
+	{{0x00000000,0x00000000,0x00000000},0x25d8,1,1466},
+	{{0x00000000,0x00000000,0x00000000},0xfeb7,1,7183},
+	{{0x00000000,0x00000000,0x00000000},0xfeb5,1,7175},
+	{{0x00000000,0x00000000,0x00000000},0xfeb6,1,7179},
+	{{0x00000000,0x00000000,0x00000000},0xfeb8,1,7187},
+	{{0x40000001,0x00000000,0x00000000},0x305d,0,915},
+	{{0x00000001,0x00000020,0x00000000},0x30bd,0,915},
+	{{0x00010003,0x00000000,0x00000000},0x042c,1,1095},
+	{{0x00010005,0x00000000,0x00000000},0x044c,1,1095},
+	{{0x00000000,0x00000000,0x00000000},0x2117,1,3421},
+	{{0x00000000,0x00000000,0x00002000},0x2198,1,3944},
+	{{0x00000000,0x00000000,0x00002000},0x2199,1,3959},
+	{{0x00000000,0x00000000,0x00008004},0x2660,1,6133},
+	{{0x00000000,0x80000000,0x00008000},0x2664,1,6133},
+	{{0x00000000,0x00000000,0x00000000},0x25ac,1,5872},
+	{{0x00000000,0x00000000,0x00000000},0xfb05,0,2387},
+	{{0x00000000,0x00000000,0x00000000},0xfb06,0,2387},
+	{{0x00000004,0x00000040,0x00000100},0xfb06,0,2387},
+	{{0x00000000,0x00000000,0x00000004},0x2605,1,6041},
+	{{0x00000000,0x80000000,0x00000000},0x2606,1,6041},
+	{{0x08000001,0x00000000,0x00000000},0x03da,1,836},
+	{{0x00000000,0x00000000,0x00000000},0x263c,1,6112},
+	{{0x40000001,0x00000000,0x00000000},0x3059,1,6112},
+	{{0x00000001,0x00000020,0x00000000},0x30b9,1,6112},
+	{{0x00000000,0x00000000,0x00000001},0x2282,1,4586},
+	{{0x00000000,0x04000000,0x00011001},0x2286,1,4586},
+	{{0x00000080,0x00000000,0x00000000},0x0652,1,1639},
+	{{0x00000001,0x80000000,0x00000000},0x263c,1,6103},
+	{{0x00000000,0x00000000,0x00000001},0x2283,1,4596},
+	{{0x00000000,0x04000000,0x00011001},0x2287,1,4596},
+	{{0x00000201,0x00000000,0x00000000},0x310a,0,1584},
+	{{0x00002003,0x00000040,0x00000000},0x0162,0,1584},
+	{{0x00002005,0x00000040,0x00000000},0x0163,0,1584},
+	{{0x00001003,0x00000040,0x00000000},0x0164,0,1584},
+	{{0x00001005,0x00000040,0x00000000},0x0165,0,1584},
+	{{0x00000003,0x00000040,0x10000000},0x0166,0,1584},
+	{{0x00000005,0x00000040,0x10000000},0x0167,0,1584},
+	{{0x00000005,0x00040040,0x00000000},0x24af,0,1584},
+	{{0x00004003,0x00000040,0x00000000},0x24c9,0,1584},
+	{{0x00004005,0x00000040,0x00000000},0x24e3,0,1584},
+	{{0x0008000b,0x00000040,0x00000000},0x1e6a,0,1584},
+	{{0x0008000d,0x00000040,0x00000000},0x1e6b,0,1584},
+	{{0x00080103,0x00000040,0x00000000},0x1e6c,0,1584},
+	{{0x00080105,0x00000040,0x00000000},0x1e6d,0,1584},
+	{{0x00000103,0x00000240,0x00000000},0x1e6e,0,1584},
+	{{0x00000105,0x00000240,0x00000000},0x1e6f,0,1584},
+	{{0x00008103,0x00000040,0x00000000},0x1e70,0,1584},
+	{{0x00008105,0x00000040,0x00000000},0x1e71,0,1584},
+	{{0x00000000,0x00000000,0x00000000},0x24c9,1,5389},
+	{{0x00000000,0x00000000,0x00000000},0x24e3,1,5389},
+	{{0x00000000,0x00000000,0x00000000},0x03a4,1,779},
+	{{0x00000000,0x00000000,0x00000000},0x03c4,1,779},
+	{{0x00000000,0x00000000,0x00000000},0x05ea,1,1327},
+	{{0x00000000,0x00000000,0x00000000},0x062a,1,1327},
+	{{0x00000000,0x00000000,0x00000000},0xfe97,1,7055},
+	{{0x00000000,0x00000000,0x00000000},0xfe95,1,7047},
+	{{0x00000000,0x00000000,0x00000000},0xfe96,1,7051},
+	{{0x00000000,0x00000000,0x00000000},0xfe98,1,7059},
+	{{0x00000000,0x00000000,0x00000000},0x0162,1,193},
+	{{0x00000000,0x00000000,0x00000000},0x0163,1,193},
+	{{0x00000000,0x00000000,0x00000000},0x1e6c,1,1924},
+	{{0x00000000,0x00000000,0x00000000},0x1e6d,1,1924},
+	{{0x00000000,0x00000000,0x00000000},0x1e70,1,1931},
+	{{0x00000000,0x00000000,0x00000000},0x1e71,1,1931},
+	{{0x00000000,0x00000000,0x00000000},0x1e6a,1,1921},
+	{{0x00000000,0x00000000,0x00000000},0x1e6b,1,1921},
+	{{0x00000000,0x00000000,0x00000000},0x0166,1,199},
+	{{0x00000000,0x00000000,0x00000000},0x0167,1,199},
+	{{0x00000000,0x00000000,0x00000000},0x03da,1,843},
+	{{0x00000000,0x00000000,0x00000000},0x310a,1,6802},
+	{{0x00000000,0x00000000,0x00000000},0x0164,1,196},
+	{{0x00000000,0x00000000,0x00000000},0x0165,1,196},
+	{{0x00000000,0x00000000,0x00000000},0x0422,1,1034},
+	{{0x00000000,0x00000000,0x00000000},0x0442,1,1034},
+	{{0x00000000,0x00000000,0x00000000},0x1e6e,1,1928},
+	{{0x00000000,0x00000000,0x00000000},0x1e6f,1,1928},
+	{{0x40000001,0x00000000,0x00000000},0x305f,1,6597},
+	{{0x00000001,0x00000020,0x00000000},0x30bf,1,6597},
+	{{0x00000000,0x08000000,0x00000000},0x22a5,1,4620},
+	{{0x00000081,0x00000000,0x00000000},0x0637,1,1483},
+	{{0x00000081,0x00000010,0x00000000},0xfec1,1,1483},
+	{{0x01000081,0x00000000,0x00000000},0xfec2,1,1483},
+	{{0x00000081,0x00000004,0x00000000},0xfec3,1,1483},
+	{{0x00000081,0x00001000,0x00000000},0xfec4,1,1483},
+	{{0x00000080,0x00000000,0x00000000},0x0640,1,1507},
+	{{0x08000003,0x00000000,0x00000000},0x03a4,1,775},
+	{{0x08000005,0x00000000,0x00000000},0x03c4,1,775},
+	{{0x20000001,0x00000000,0x00000000},0x05ea,1,1323},
+	{{0x00000000,0x00000000,0x00000000},0x2580,1,5668},
+	{{0x00000000,0x00000000,0x00000000},0x0686,1,1707},
+	{{0x00000081,0x00000000,0x00000000},0x0686,1,1701},
+	{{0x00000000,0x00000000,0x00000000},0x2203,1,1031},
+	{{0x40000001,0x00000000,0x00000000},0x3066,1,1031},
+	{{0x00000001,0x00000020,0x00000000},0x30c6,1,1031},
+	{{0x00010003,0x00000000,0x00000000},0x0422,1,1031},
+	{{0x00010005,0x00000000,0x00000000},0x0442,1,1031},
+	{{0x00000081,0x00000000,0x00000000},0x062a,1,1405},
+	{{0x00000081,0x00000010,0x00000000},0xfe95,1,1405},
+	{{0x01000081,0x00000000,0x00000000},0xfe96,1,1405},
+	{{0x00000081,0x00000004,0x00000000},0xfe97,1,1405},
+	{{0x00000081,0x00001000,0x00000000},0xfe98,1,1405},
+	{{0x00000081,0x00000000,0x00000000},0x0629,1,1390},
+	{{0x00000081,0x00000010,0x00000000},0xfe93,1,1390},
+	{{0x01000081,0x00000000,0x00000000},0xfe94,1,1390},
+	{{0x00000000,0x00000000,0x00000000},0x260e,1,6062},
+	{{0x00000000,0x00000000,0x00000000},0x260f,1,6062},
+	{{0x00000000,0x00000000,0x00000004},0x260e,1,6052},
+	{{0x00000000,0x80000000,0x00000000},0x260f,1,6052},
+	{{0x00000000,0x00000000,0x00000000},0x2315,1,4692},
+	{{0x00000000,0x00804000,0x00000000},0x2169,1,3716},
+	{{0x00004000,0x00002000,0x00000000},0x2469,1,3716},
+	{{0x00000000,0x00042000,0x00000000},0x247d,1,3716},
+	{{0x00000000,0x00040000,0x00000800},0x3229,1,3716},
+	{{0x00000004,0x00804000,0x00000000},0x2179,1,3716},
+	{{0x02000000,0x00002000,0x00000002},0x2491,1,3716},
+	{{0x00000000,0x00804000,0x00000000},0x2182,1,3837},
+	{{0x20000001,0x00000000,0x00000000},0x05d8,1,1217},
+	{{0x00000081,0x00000000,0x00000000},0x0630,1,1438},
+	{{0x00000081,0x00000010,0x00000000},0xfeab,1,1438},
+	{{0x01000081,0x00000000,0x00000000},0xfeac,1,1438},
+	{{0x00000081,0x00000000,0x00000000},0x062b,1,1409},
+	{{0x00000081,0x00000010,0x00000000},0xfe99,1,1409},
+	{{0x01000081,0x00000000,0x00000000},0xfe9a,1,1409},
+	{{0x00000081,0x00000004,0x00000000},0xfe9b,1,1409},
+	{{0x00000081,0x00001000,0x00000000},0xfe9c,1,1409},
+	{{0x00000000,0x00000000,0x00000000},0x2203,1,4062},
+	{{0x00000000,0x00000000,0x00000000},0x2234,1,4373},
+	{{0x08000003,0x00000000,0x00000000},0x0398,1,708},
+	{{0x08000005,0x00000000,0x00000000},0x03b8,1,708},
+	{{0x00000000,0x00000000,0x00000200},0x2009,1,2870},
+	{{0x00000000,0x00010000,0x00000018},0x2153,1,3528},
+	{{0x00004000,0x00002000,0x00000000},0x246c,1,4938},
+	{{0x00000000,0x00042000,0x00000000},0x2480,1,4938},
+	{{0x02000000,0x00002000,0x00000002},0x2494,1,4938},
+	{{0x00000000,0x00814000,0x00000000},0x216f,1,3781},
+	{{0x00000004,0x00814000,0x00000000},0x217f,1,3781},
+	{{0x00000000,0x00814000,0x00000000},0x2180,1,3796},
+	{{0x00000000,0x00000000,0x00000040},0x2083,0,1444},
+	{{0x00004001,0x00000000,0x00000000},0x2462,0,1444},
+	{{0x00000001,0x00040000,0x00000000},0x2476,0,1444},
+	{{0x00000081,0x00000000,0x00000400},0x0663,0,1444},
+	{{0x00000000,0x00804000,0x00000000},0x2162,0,1444},
+	{{0x02000001,0x00000000,0x00000002},0x248a,0,1444},
+	{{0x00000000,0x00040000,0x00000800},0x3222,0,1444},
+	{{0x00000004,0x00804000,0x00000000},0x2172,0,1444},
+	{{0x00000000,0x00000000,0x00000018},0x215c,1,3639},
+	{{0x00000000,0x00000000,0x00000018},0x2157,1,3574},
+	{{0x00000000,0x00000000,0x00000200},0x2004,1,2825},
+	{{0x40000001,0x00000000,0x00000000},0x3061,1,6603},
+	{{0x00000001,0x00000020,0x00000000},0x30c1,1,6603},
+	{{0x00000000,0x00000000,0x00000000},0x05d8,1,1221},
+	{{0x00000000,0x00000000,0x00000000},0x0637,1,1221},
+	{{0x00000000,0x00000000,0x00000000},0xfec3,1,7231},
+	{{0x00000000,0x00000000,0x00000000},0xfec1,1,7223},
+	{{0x00000000,0x00000000,0x00000000},0xfec2,1,7227},
+	{{0x00000000,0x00000000,0x00000000},0xfec4,1,7235},
+	{{0x00000000,0x00000000,0x00000000},0x062b,1,1414},
+	{{0x00000000,0x00000000,0x00000000},0xfe9b,1,7071},
+	{{0x00000000,0x00000000,0x00000000},0xfe99,1,7063},
+	{{0x00000000,0x00000000,0x00000000},0xfe9a,1,7067},
+	{{0x00000000,0x00000000,0x00000000},0xfe9c,1,7075},
+	{{0x00000000,0x00000000,0x00000000},0x25c1,1,5916},
+	{{0x00000000,0x00000000,0x00000000},0x0629,1,1402},
+	{{0x00000000,0x00000000,0x00000000},0x2122,1,1402},
+	{{0x00000000,0x00000000,0x00000000},0xfe93,1,7039},
+	{{0x00000000,0x00000000,0x00000000},0xfe94,1,7043},
+	{{0x00000000,0x00000000,0x00080000},0x2320,1,4732},
+	{{0x00000000,0x00000080,0x00020000},0x3014,1,6486},
+	{{0x00000000,0x00400000,0x00020000},0x3015,1,6486},
+	{{0x00000000,0x00000000,0x00000000},0x2315,1,4711},
+	{{0x00000000,0x00000000,0x00000000},0x25b7,1,4711},
+	{{0x00000001,0x00000800,0x00000000},0x2122,1,3482},
+	{{0x00000000,0x00000000,0x00000000},0x2023,1,3009},
+	{{0x00400400,0x00000101,0x00000000},0x2504,1,5441},
+	{{0x10400400,0x00000001,0x00000000},0x2505,1,5441},
+	{{0x00400400,0x40000100,0x00000000},0x2506,1,5441},
+	{{0x10400400,0x40000000,0x00000000},0x2507,1,5441},
+	{{0x00000000,0x00000000,0x00000000},0x2034,1,3147},
+	{{0x00000000,0x00000000,0x00000000},0x040b,0,2156},
+	{{0x00000000,0x00000000,0x00000000},0x045b,0,2156},
+	{{0x20000001,0x00000000,0x00000000},0x05e6,1,1294},
+	{{0x21000001,0x00000000,0x00000000},0x05e5,1,1294},
+	{{0x00010003,0x00000000,0x00000000},0x0426,1,1052},
+	{{0x00010005,0x00000000,0x00000000},0x0446,1,1052},
+	{{0x00010003,0x00000000,0x00000000},0x040b,1,922},
+	{{0x00010005,0x00000000,0x00000000},0x045b,1,922},
+	{{0x40000001,0x00000000,0x00000000},0x3064,1,6606},
+	{{0x00000001,0x00000020,0x00000000},0x30c4,1,6606},
+	{{0x40000005,0x00000000,0x00000000},0x3063,1,6606},
+	{{0x00000005,0x00000020,0x00000000},0x30c3,1,6606},
+	{{0x00000005,0x00000040,0x00000000},0x01dd,1,343},
+	{{0x00000000,0x00804000,0x00000000},0x216b,1,3733},
+	{{0x00004000,0x00002000,0x00000000},0x246b,1,3733},
+	{{0x00000000,0x00042000,0x00000000},0x247f,1,3733},
+	{{0x00000004,0x00804000,0x00000000},0x217b,1,3733},
+	{{0x02000000,0x00002000,0x00000002},0x2493,1,3733},
+	{{0x00004000,0x00002000,0x00000000},0x2473,1,5035},
+	{{0x00000000,0x00042000,0x00000000},0x2487,1,5035},
+	{{0x02000000,0x00002000,0x00000002},0x249b,1,5035},
+	{{0x00000000,0x00000000,0x00000040},0x2082,0,1440},
+	{{0x00004001,0x00000000,0x00000000},0x2461,0,1440},
+	{{0x00000001,0x00040000,0x00000000},0x2475,0,1440},
+	{{0x00000081,0x00000000,0x00000400},0x0662,0,1440},
+	{{0x00000000,0x00804000,0x00000000},0x2161,0,1440},
+	{{0x02000001,0x00000000,0x00000002},0x2489,0,1440},
+	{{0x00000000,0x00040000,0x00000800},0x3221,0,1440},
+	{{0x00000004,0x00804000,0x00000000},0x2171,0,1440},
+	{{0x00000000,0x00000000,0x00000018},0x2156,1,3560},
+	{{0x00080000,0x00000000,0x00000000},0x2025,1,3030},
+	{{0x00000000,0x00000000,0x00000018},0x2154,1,3537},
+	{{0x40000001,0x00000000,0x00000000},0x3046,0,1586},
+	{{0x00000001,0x00000020,0x00000000},0x30a6,0,1586},
+	{{0x00000201,0x00000000,0x00000000},0x3128,0,1586},
+	{{0x00010003,0x00000000,0x00000000},0x0423,0,1586},
+	{{0x00010005,0x00000000,0x00000000},0x0443,0,1586},
+	{{0x40000005,0x00000000,0x00000000},0x3045,0,1586},
+	{{0x00000005,0x00000020,0x00000000},0x30a5,0,1586},
+	{{0x00000003,0x02000040,0x00000000},0x0168,0,1586},
+	{{0x00000005,0x02000040,0x00000000},0x0169,0,1586},
+	{{0x00000003,0x00000440,0x00000000},0x016a,0,1586},
+	{{0x00000005,0x00000440,0x00000000},0x016b,0,1586},
+	{{0x00000803,0x00000040,0x00000000},0x016c,0,1586},
+	{{0x00000805,0x00000040,0x00000000},0x016d,0,1586},
+	{{0x00000003,0x00000040,0x02000000},0x0172,0,1586},
+	{{0x00000005,0x00000040,0x02000000},0x0173,0,1586},
+	{{0x00000003,0x00000042,0x00000000},0x01af,0,1586},
+	{{0x00000005,0x00000042,0x00000000},0x01b0,0,1586},
+	{{0x00001003,0x00000040,0x00000000},0x01d3,0,1586},
+	{{0x00001005,0x00000040,0x00000000},0x01d4,0,1586},
+	{{0x00010003,0x00000000,0x08000000},0x040e,0,1586},
+	{{0x00010005,0x00000000,0x08000000},0x045e,0,1586},
+	{{0x00000005,0x00040040,0x00000000},0x24b0,0,1586},
+	{{0x00004003,0x00000040,0x00000000},0x24ca,0,1586},
+	{{0x00004005,0x00000040,0x00000000},0x24e4,0,1586},
+	{{0x0000000b,0x00000040,0x04000000},0x016e,0,1586},
+	{{0x0000000d,0x00000040,0x04000000},0x016f,0,1586},
+	{{0x00100013,0x00000040,0x00000000},0x0170,0,1586},
+	{{0x00100015,0x00000040,0x00000000},0x0171,0,1586},
+	{{0x00040003,0x00000440,0x00000000},0x01d5,0,1586},
+	{{0x00040005,0x00000440,0x00000000},0x01d6,0,1586},
+	{{0x00040013,0x00000040,0x00000000},0x01d7,0,1586},
+	{{0x00040015,0x00000040,0x00000000},0x01d8,0,1586},
+	{{0x00041003,0x00000040,0x00000000},0x01d9,0,1586},
+	{{0x00041005,0x00000040,0x00000000},0x01da,0,1586},
+	{{0x04040003,0x00000040,0x00000000},0x01db,0,1586},
+	{{0x04040005,0x00000040,0x00000000},0x01dc,0,1586},
+	{{0x04100003,0x00000040,0x00000000},0x0214,0,1586},
+	{{0x04100005,0x00000040,0x00000000},0x0215,0,1586},
+	{{0x00000803,0x00000040,0x00800000},0x0216,0,1586},
+	{{0x00000805,0x00000040,0x00800000},0x0217,0,1586},
+	{{0x00040103,0x00000040,0x00000000},0x1e72,0,1586},
+	{{0x00040105,0x00000040,0x00000000},0x1e73,0,1586},
+	{{0x00000103,0x02000040,0x00000000},0x1e74,0,1586},
+	{{0x00000105,0x02000040,0x00000000},0x1e75,0,1586},
+	{{0x00008103,0x00000040,0x00000000},0x1e76,0,1586},
+	{{0x00008105,0x00000040,0x00000000},0x1e77,0,1586},
+	{{0x00000013,0x02000040,0x00000000},0x1e78,0,1586},
+	{{0x00000015,0x02000040,0x00000000},0x1e79,0,1586},
+	{{0x00040003,0x00000440,0x00000000},0x1e7a,0,1586},
+	{{0x00040005,0x00000440,0x00000000},0x1e7b,0,1586},
+	{{0x00080103,0x00000040,0x00000000},0x1ee4,0,1586},
+	{{0x00080105,0x00000040,0x00000000},0x1ee5,0,1586},
+	{{0x8000000b,0x00000040,0x00000000},0x1ee6,0,1586},
+	{{0x8000000d,0x00000040,0x00000000},0x1ee7,0,1586},
+	{{0x00000013,0x00000042,0x00000000},0x1ee8,0,1586},
+	{{0x00000015,0x00000042,0x00000000},0x1ee9,0,1586},
+	{{0x04000003,0x00000042,0x00000000},0x1eea,0,1586},
+	{{0x04000005,0x00000042,0x00000000},0x1eeb,0,1586},
+	{{0x00000003,0x02000042,0x00000000},0x1eee,0,1586},
+	{{0x00000005,0x02000042,0x00000000},0x1eef,0,1586},
+	{{0x8000000b,0x00000042,0x00000000},0x1eec,0,1586},
+	{{0x8000000d,0x00000042,0x00000000},0x1eed,0,1586},
+	{{0x00080103,0x00000042,0x00000000},0x1ef0,0,1586},
+	{{0x00080105,0x00000042,0x00000000},0x1ef1,0,1586},
+	{{0x00000000,0x00000000,0x00000000},0x24ca,1,5393},
+	{{0x00000000,0x00000000,0x00000000},0x24e4,1,5393},
+	{{0x00000000,0x00000000,0x00000000},0x0214,1,439},
+	{{0x00000000,0x00000000,0x00000000},0x0215,1,439},
+	{{0x00000000,0x00000000,0x00000000},0x0170,1,214},
+	{{0x00000000,0x00000000,0x00000000},0x0171,1,214},
+	{{0x00000000,0x00000000,0x00000000},0x038e,1,656},
+	{{0x00000000,0x00000000,0x00000000},0x03cd,1,656},
+	{{0x00000000,0x00000000,0x00000000},0x016c,1,208},
+	{{0x00000000,0x00000000,0x00000000},0x016d,1,208},
+	{{0x00000000,0x00000000,0x00000000},0x0216,1,443},
+	{{0x00000000,0x00000000,0x00000000},0x0217,1,443},
+	{{0x00000000,0x00000000,0x00000000},0x03a5,1,782},
+	{{0x00000000,0x00000000,0x00000000},0x03c5,1,782},
+	{{0x00000000,0x00000000,0x00000000},0x1f7a,1,2461},
+	{{0x00000000,0x00000000,0x00000000},0x1fea,1,2461},
+	{{0x00000000,0x00000000,0x00000000},0x1f7b,1,2465},
+	{{0x00000000,0x00000000,0x00000000},0x1feb,1,2465},
+	{{0x00000000,0x00000000,0x00000000},0x1fe0,1,2746},
+	{{0x00000000,0x00000000,0x00000000},0x1fe8,1,2746},
+	{{0x00000000,0x00000000,0x00000000},0x1f50,1,2345},
+	{{0x00000000,0x00000000,0x00000000},0x1f52,1,2353},
+	{{0x00000000,0x00000000,0x00000000},0x1f54,1,2363},
+	{{0x00000000,0x00000000,0x00000000},0x1f56,1,2373},
+	{{0x00000000,0x00000000,0x00000000},0x1fe1,1,2750},
+	{{0x00000000,0x00000000,0x00000000},0x1fe9,1,2750},
+	{{0x00000000,0x00000000,0x00000000},0x1fe2,1,2754},
+	{{0x00000000,0x00000000,0x00000000},0x1fe3,1,2759},
+	{{0x00000000,0x00000000,0x00000000},0x1fe7,1,2776},
+	{{0x00000000,0x00000000,0x00000000},0x1f51,1,2349},
+	{{0x00000000,0x00000000,0x00000000},0x1f59,1,2349},
+	{{0x00000000,0x00000000,0x00000000},0x1f53,1,2358},
+	{{0x00000000,0x00000000,0x00000000},0x1f5b,1,2358},
+	{{0x00000000,0x00000000,0x00000000},0x1f55,1,2368},
+	{{0x00000000,0x00000000,0x00000000},0x1f5d,1,2368},
+	{{0x00000000,0x00000000,0x00000000},0x1f57,1,2378},
+	{{0x00000000,0x00000000,0x00000000},0x1f5f,1,2378},
+	{{0x00000000,0x00000000,0x00000000},0x1fe6,1,2772},
+	{{0x00000000,0x00000000,0x00000000},0x016a,1,205},
+	{{0x00000000,0x00000000,0x00000000},0x016b,1,205},
+	{{0x00000000,0x00000000,0x00000000},0x1e72,1,1935},
+	{{0x00000000,0x00000000,0x00000000},0x1e73,1,1935},
+	{{0x00000000,0x00000000,0x00000000},0x1ee4,1,2134},
+	{{0x00000000,0x00000000,0x00000000},0x1ee5,1,2134},
+	{{0x00000000,0x00000000,0x00000000},0x1e7a,1,1952},
+	{{0x00000000,0x00000000,0x00000000},0x1e7b,1,1952},
+	{{0x00000000,0x00000000,0x00000000},0x1e76,1,1944},
+	{{0x00000000,0x00000000,0x00000000},0x1e77,1,1944},
+	{{0x00000000,0x00000000,0x00000000},0x1e74,1,1940},
+	{{0x00000000,0x00000000,0x00000000},0x1e75,1,1940},
+	{{0x00000000,0x00000000,0x00000000},0x016e,1,211},
+	{{0x00000000,0x00000000,0x00000000},0x016f,1,211},
+	{{0x00000000,0x00000000,0x00000000},0x1ee6,1,2138},
+	{{0x00000000,0x00000000,0x00000000},0x1ee7,1,2138},
+	{{0x00000000,0x00000000,0x00000000},0x03b0,1,815},
+	{{0x00000000,0x00000000,0x00000000},0x3128,1,6873},
+	{{0x00000000,0x00000000,0x00000000},0x3045,1,6549},
+	{{0x00000000,0x00000000,0x00000000},0x3046,1,6549},
+	{{0x00000000,0x00000000,0x00000000},0x30a5,1,6741},
+	{{0x00000000,0x00000000,0x00000000},0x30a6,1,6741},
+	{{0x00000000,0x00000000,0x00000000},0x01af,1,269},
+	{{0x00000000,0x00000000,0x00000000},0x01b0,1,269},
+	{{0x00000000,0x00000000,0x00000000},0x1eea,1,2145},
+	{{0x00000000,0x00000000,0x00000000},0x1eeb,1,2145},
+	{{0x00000000,0x00000000,0x00000000},0x1ee8,1,2141},
+	{{0x00000000,0x00000000,0x00000000},0x1ee9,1,2141},
+	{{0x00000000,0x00000000,0x00000000},0x1ef0,1,2157},
+	{{0x00000000,0x00000000,0x00000000},0x1ef1,1,2157},
+	{{0x00000000,0x00000000,0x00000000},0x1eec,1,2149},
+	{{0x00000000,0x00000000,0x00000000},0x1eed,1,2149},
+	{{0x00000000,0x00000000,0x00000000},0x1eee,1,2153},
+	{{0x00000000,0x00000000,0x00000000},0x1eef,1,2153},
+	{{0x00000000,0x00000000,0x00000000},0x01db,1,339},
+	{{0x00000000,0x00000000,0x00000000},0x01dc,1,339},
+	{{0x00000000,0x00000000,0x00000000},0x01d7,1,331},
+	{{0x00000000,0x00000000,0x00000000},0x01d8,1,331},
+	{{0x00000000,0x00000000,0x00000000},0x01d5,1,327},
+	{{0x00000000,0x00000000,0x00000000},0x01d6,1,327},
+	{{0x00000000,0x00000000,0x00000000},0x01d9,1,335},
+	{{0x00000000,0x00000000,0x00000000},0x01da,1,335},
+	{{0x00000000,0x00000000,0x00000000},0x0172,1,217},
+	{{0x00000000,0x00000000,0x00000000},0x0173,1,217},
+	{{0x00000000,0x00000000,0x00000000},0x01d3,1,324},
+	{{0x00000000,0x00000000,0x00000000},0x01d4,1,324},
+	{{0x00000000,0x00000000,0x00000000},0x0423,1,1037},
+	{{0x00000000,0x00000000,0x00000000},0x0443,1,1037},
+	{{0x00000000,0x00000000,0x00000000},0x0168,1,202},
+	{{0x00000000,0x00000000,0x00000000},0x0169,1,202},
+	{{0x00000000,0x00000000,0x00000000},0x1e78,1,1948},
+	{{0x00000000,0x00000000,0x00000000},0x1e79,1,1948},
+	{{0x00000000,0x00000000,0x00000000},0x2195,1,3911},
+	{{0x00000000,0x00000000,0x00000000},0x21a8,1,3979},
+	{{0x00000000,0x00000000,0x00000000},0x2540,1,5613},
+	{{0x00000000,0x00000000,0x00000000},0x2541,1,5613},
+	{{0x00000000,0x00000000,0x00000000},0x2547,1,5613},
+	{{0x00000000,0x00000000,0x00000000},0x2548,1,5613},
+	{{0x00000000,0x00000000,0x00000000},0x2526,1,5564},
+	{{0x00000000,0x00000000,0x00000000},0x2527,1,5564},
+	{{0x00000000,0x00000000,0x00000000},0x2529,1,5564},
+	{{0x00000000,0x00000000,0x00000000},0x252a,1,5564},
+	{{0x00000000,0x00000000,0x00000000},0x2543,1,5617},
+	{{0x00000000,0x00000000,0x00000000},0x2544,1,5617},
+	{{0x00000000,0x00000000,0x00000000},0x2545,1,5617},
+	{{0x00000000,0x00000000,0x00000000},0x2546,1,5617},
+	{{0x00000000,0x00000000,0x00000000},0x251e,1,5549},
+	{{0x00000000,0x00000000,0x00000000},0x251f,1,5549},
+	{{0x00000000,0x00000000,0x00000000},0x2521,1,5549},
+	{{0x00000000,0x00000000,0x00000000},0x2522,1,5549},
+	{{0x00000000,0x00000000,0x00000000},0x2534,1,5583},
+	{{0x00000000,0x00000000,0x00000000},0x2567,1,5583},
+	{{0x00000000,0x00000000,0x00000000},0x2568,1,5583},
+	{{0x00000000,0x00000000,0x00000000},0x2569,1,5583},
+	{{0x00000000,0x00000000,0x00000000},0x2537,1,5594},
+	{{0x00000000,0x00000000,0x00000000},0x2538,1,5594},
+	{{0x00000000,0x00000000,0x00000000},0x253b,1,5594},
+	{{0x00000000,0x00000000,0x00000000},0x2518,1,5527},
+	{{0x00000000,0x00000000,0x00000000},0x255b,1,5527},
+	{{0x00000000,0x00000000,0x00000000},0x255c,1,5527},
+	{{0x00000000,0x00000000,0x00000000},0x255d,1,5527},
+	{{0x00000000,0x00000000,0x00000000},0x2519,1,5534},
+	{{0x00000000,0x00000000,0x00000000},0x251a,1,5534},
+	{{0x00000000,0x00000000,0x00000000},0x251b,1,5534},
+	{{0x00000000,0x00000000,0x00000000},0x2535,1,5590},
+	{{0x00000000,0x00000000,0x00000000},0x2536,1,5590},
+	{{0x00000000,0x00000000,0x00000000},0x2539,1,5590},
+	{{0x00000000,0x00000000,0x00000000},0x253a,1,5590},
+	{{0x00000000,0x00000000,0x00000000},0x222a,1,4335},
+	{{0x00000000,0x00000000,0x00080000},0x2580,1,5656},
+	{{0x00000001,0x04400080,0x00000080},0x25a7,1,5814},
+	{{0x00000001,0x04400080,0x00000080},0x25a8,1,5814},
+	{{0x00000000,0x00000000,0x00002000},0x2191,1,3870},
+	{{0x00000000,0x00000000,0x00000000},0x2514,1,5516},
+	{{0x00000000,0x00000000,0x00000000},0x2558,1,5516},
+	{{0x00000000,0x00000000,0x00000000},0x2559,1,5516},
+	{{0x00000000,0x00000000,0x00000000},0x255a,1,5516},
+	{{0x00000000,0x00000000,0x00000000},0x2515,1,5523},
+	{{0x00000000,0x00000000,0x00000000},0x2516,1,5523},
+	{{0x00000000,0x00000000,0x00000000},0x2517,1,5523},
+	{{0x00000000,0x00000000,0x00000000},0x25b2,1,5893},
+	{{0x00000000,0x00000000,0x00000000},0x25b3,1,5893},
+	{{0x00000201,0x00000000,0x00000000},0x312a,0,1588},
+	{{0x00000003,0x02000040,0x00000000},0x1e7c,0,1588},
+	{{0x00000005,0x02000040,0x00000000},0x1e7d,0,1588},
+	{{0x00000005,0x00040040,0x00000000},0x24b1,0,1588},
+	{{0x00004003,0x00000040,0x00000000},0x24cb,0,1588},
+	{{0x00004005,0x00000040,0x00000000},0x24e5,0,1588},
+	{{0x00080103,0x00000040,0x00000000},0x1e7e,0,1588},
+	{{0x00080105,0x00000040,0x00000000},0x1e7f,0,1588},
+	{{0x00000000,0x00000000,0x00000000},0x24cb,1,5397},
+	{{0x00000000,0x00000000,0x00000000},0x24e5,1,5397},
+	{{0x00000000,0x00000000,0x00000000},0x040e,1,934},
+	{{0x00000000,0x00000000,0x00000000},0x045e,1,934},
+	{{0x00000000,0x00000000,0x00000000},0x03ab,1,812},
+	{{0x00000000,0x00000000,0x00000000},0x03cb,1,812},
+	{{0x00000000,0x00000000,0x00000000},0x06a4,1,1718},
+	{{0x00000000,0x00000000,0x00000000},0x1e7e,1,1959},
+	{{0x00000000,0x00000000,0x00000000},0x1e7f,1,1959},
+	{{0x00000000,0x00000000,0x00000000},0x0474,1,1151},
+	{{0x00000000,0x00000000,0x00000000},0x0475,1,1151},
+	{{0x00000000,0x00000000,0x00000000},0x312a,1,6876},
+	{{0x00000000,0x00000000,0x00000000},0x0412,1,954},
+	{{0x00000000,0x00000000,0x00000000},0x0432,1,954},
+	{{0x00000000,0x00000000,0x00000000},0x1e7c,1,1956},
+	{{0x00000000,0x00000000,0x00000000},0x1e7d,1,1956},
+	{{0x00000001,0x00000020,0x00000000},0x30f7,1,6753},
+	{{0x20000001,0x00000000,0x00000000},0x05d5,1,1194},
+	{{0x00000001,0x00000020,0x00000000},0x30f9,1,951},
+	{{0x00010003,0x00000000,0x00000000},0x0412,1,951},
+	{{0x00010005,0x00000000,0x00000000},0x0432,1,951},
+	{{0x00000081,0x00000000,0x00000000},0x06a4,1,1714},
+	{{0x00000000,0x00000000,0x00000000},0x253c,1,5598},
+	{{0x00000000,0x00000000,0x00000000},0x256a,1,5598},
+	{{0x00000000,0x00000000,0x00000000},0x256b,1,5598},
+	{{0x00000000,0x00000000,0x00000000},0x256c,1,5598},
+	{{0x00000000,0x00000000,0x00000000},0x253f,1,5609},
+	{{0x00000000,0x00000000,0x00000000},0x2542,1,5609},
+	{{0x00000000,0x00000000,0x00000000},0x254b,1,5609},
+	{{0x00000001,0x00000020,0x00000000},0x30f8,1,6756},
+	{{0x00000000,0x00000000,0x00000000},0x2524,1,5553},
+	{{0x00000000,0x00000000,0x00000000},0x2561,1,5553},
+	{{0x00000000,0x00000000,0x00000000},0x2562,1,5553},
+	{{0x00000000,0x00000000,0x00000000},0x2563,1,5553},
+	{{0x00000000,0x00000000,0x00000000},0x2525,1,5560},
+	{{0x00000000,0x00000000,0x00000000},0x2528,1,5560},
+	{{0x00000000,0x00000000,0x00000000},0x252b,1,5560},
+	{{0x00000000,0x00000000,0x00000000},0x253d,1,5605},
+	{{0x00000000,0x00000000,0x00000000},0x253e,1,5605},
+	{{0x00000000,0x00000000,0x00000000},0x2549,1,5605},
+	{{0x00000000,0x00000000,0x00000000},0x254a,1,5605},
+	{{0x00000001,0x00000020,0x00000000},0x30fa,1,6759},
+	{{0x40000000,0x00000800,0x00000000},0x309e,1,6715},
+	{{0x00000000,0x00000820,0x00000000},0x30fe,1,6715},
+	{{0x40000000,0x00000820,0x00000000},0x309b,1,6675},
+	{{0x00000000,0x00000000,0x00000000},0x251c,1,5538},
+	{{0x00000000,0x00000000,0x00000000},0x255e,1,5538},
+	{{0x00000000,0x00000000,0x00000000},0x255f,1,5538},
+	{{0x00000000,0x00000000,0x00000000},0x2560,1,5538},
+	{{0x00000000,0x00000000,0x00000000},0x251d,1,5545},
+	{{0x00000000,0x00000000,0x00000000},0x2520,1,5545},
+	{{0x00000000,0x00000000,0x00000000},0x2523,1,5545},
+	{{0x08000045,0x00000000,0x00000000},0x1fb0,1,2615},
+	{{0x08000043,0x00000000,0x00000000},0x1fb8,1,2615},
+	{{0x08000005,0x00000008,0x00000000},0x1fd0,1,2615},
+	{{0x08000003,0x00000008,0x00000000},0x1fd8,1,2615},
+	{{0x08000005,0x10000000,0x00000000},0x1fe0,1,2615},
+	{{0x08000003,0x10000000,0x00000000},0x1fe8,1,2615},
+	{{0x00000000,0x00000000,0x00000000},0x2423,0,1960},
+	{{0x40000001,0x00000000,0x00000000},0x3094,1,6672},
+	{{0x00000001,0x00000020,0x00000000},0x30f4,1,6672},
+	{{0x00000000,0x00000000,0x00000000},0x2502,1,5431},
+	{{0x00000000,0x00000000,0x00000000},0x2551,1,5431},
+	{{0x00000000,0x00000000,0x00000000},0x2503,1,5437},
+	{{0x00008003,0x00000040,0x00000000},0x0174,0,1590},
+	{{0x00008005,0x00000040,0x00000000},0x0175,0,1590},
+	{{0x04000003,0x00000040,0x00000000},0x1e80,0,1590},
+	{{0x04000005,0x00000040,0x00000000},0x1e81,0,1590},
+	{{0x00000013,0x00000040,0x00000000},0x1e82,0,1590},
+	{{0x00000015,0x00000040,0x00000000},0x1e83,0,1590},
+	{{0x00040003,0x00000040,0x00000000},0x1e84,0,1590},
+	{{0x00040005,0x00000040,0x00000000},0x1e85,0,1590},
+	{{0x00000005,0x00040040,0x00000000},0x24b2,0,1590},
+	{{0x00004003,0x00000040,0x00000000},0x24cc,0,1590},
+	{{0x00004005,0x00000040,0x00000000},0x24e6,0,1590},
+	{{0x0008000b,0x00000040,0x00000000},0x1e86,0,1590},
+	{{0x0008000d,0x00000040,0x00000000},0x1e87,0,1590},
+	{{0x00080103,0x00000040,0x00000000},0x1e88,0,1590},
+	{{0x00080105,0x00000040,0x00000000},0x1e89,0,1590},
+	{{0x00000000,0x00000000,0x00000000},0x24cc,1,5401},
+	{{0x00000000,0x00000000,0x00000000},0x24e6,1,5401},
+	{{0x00000000,0x00000000,0x00000000},0x1e80,1,1963},
+	{{0x00000000,0x00000000,0x00000000},0x1e81,1,1963},
+	{{0x00000000,0x00000000,0x00000000},0x038f,1,659},
+	{{0x00000000,0x00000000,0x00000000},0x03ce,1,659},
+	{{0x00000000,0x00000000,0x00000000},0x1e82,1,1966},
+	{{0x00000000,0x00000000,0x00000000},0x1e83,1,1966},
+	{{0x00000000,0x00000000,0x00000000},0x03a9,1,806},
+	{{0x00000000,0x00000000,0x00000000},0x03c9,1,806},
+	{{0x00000000,0x00000000,0x00000000},0x1f7c,1,2469},
+	{{0x00000000,0x00000000,0x00000000},0x1ffa,1,2469},
+	{{0x00000000,0x00000000,0x00000000},0x1ff2,1,2790},
+	{{0x00000000,0x00000000,0x00000000},0x1f7d,1,2473},
+	{{0x00000000,0x00000000,0x00000000},0x1ffb,1,2473},
+	{{0x00000000,0x00000000,0x00000000},0x1ff4,1,2799},
+	{{0x00000000,0x00000000,0x00000000},0x1f60,1,2383},
+	{{0x00000000,0x00000000,0x00000000},0x1f68,1,2383},
+	{{0x00000000,0x00000000,0x00000000},0x1f62,1,2391},
+	{{0x00000000,0x00000000,0x00000000},0x1f6a,1,2391},
+	{{0x00000000,0x00000000,0x00000000},0x1fa2,1,2579},
+	{{0x00000000,0x00000000,0x00000000},0x1faa,1,2579},
+	{{0x00000000,0x00000000,0x00000000},0x1f64,1,2401},
+	{{0x00000000,0x00000000,0x00000000},0x1f6c,1,2401},
+	{{0x00000000,0x00000000,0x00000000},0x1fa4,1,2591},
+	{{0x00000000,0x00000000,0x00000000},0x1fac,1,2591},
+	{{0x00000000,0x00000000,0x00000000},0x1f66,1,2411},
+	{{0x00000000,0x00000000,0x00000000},0x1f6e,1,2411},
+	{{0x00000000,0x00000000,0x00000000},0x1fa6,1,2603},
+	{{0x00000000,0x00000000,0x00000000},0x1fae,1,2603},
+	{{0x00000000,0x00000000,0x00000000},0x1fa0,1,2569},
+	{{0x00000000,0x00000000,0x00000000},0x1fa8,1,2569},
+	{{0x00000000,0x00000000,0x00000000},0x1f61,1,2387},
+	{{0x00000000,0x00000000,0x00000000},0x1f69,1,2387},
+	{{0x00000000,0x00000000,0x00000000},0x1f63,1,2396},
+	{{0x00000000,0x00000000,0x00000000},0x1f6b,1,2396},
+	{{0x00000000,0x00000000,0x00000000},0x1fa3,1,2585},
+	{{0x00000000,0x00000000,0x00000000},0x1fab,1,2585},
+	{{0x00000000,0x00000000,0x00000000},0x1f65,1,2406},
+	{{0x00000000,0x00000000,0x00000000},0x1f6d,1,2406},
+	{{0x00000000,0x00000000,0x00000000},0x1fa5,1,2597},
+	{{0x00000000,0x00000000,0x00000000},0x1fad,1,2597},
+	{{0x00000000,0x00000000,0x00000000},0x1f67,1,2416},
+	{{0x00000000,0x00000000,0x00000000},0x1f6f,1,2416},
+	{{0x00000000,0x00000000,0x00000000},0x1fa7,1,2609},
+	{{0x00000000,0x00000000,0x00000000},0x1faf,1,2609},
+	{{0x00000000,0x00000000,0x00000000},0x1fa1,1,2574},
+	{{0x00000000,0x00000000,0x00000000},0x1fa9,1,2574},
+	{{0x00000000,0x00000000,0x00000000},0x1ff6,1,2804},
+	{{0x00000000,0x00000000,0x00000000},0x1ff7,1,2808},
+	{{0x00000000,0x00000000,0x00000000},0x1ff3,1,2795},
+	{{0x00000000,0x00000000,0x00000000},0x1ffc,1,2795},
+	{{0x00000000,0x00000000,0x00000000},0x05d5,1,1198},
+	{{0x00000000,0x00000000,0x00000000},0x0648,1,1198},
+	{{0x00000000,0x00000000,0x00000000},0xfeed,1,7399},
+	{{0x00000000,0x00000000,0x00000000},0xfeee,1,7403},
+	{{0x00000000,0x00000000,0x00000000},0x1e88,1,1975},
+	{{0x00000000,0x00000000,0x00000000},0x1e89,1,1975},
+	{{0x00000000,0x00000000,0x00000000},0x1e86,1,1972},
+	{{0x00000000,0x00000000,0x00000000},0x1e87,1,1972},
+	{{0x00000000,0x00000000,0x00000000},0x1e84,1,1969},
+	{{0x00000000,0x00000000,0x00000000},0x1e85,1,1969},
+	{{0x00000000,0x00000000,0x00000000},0x20a9,1,3344},
+	{{0x00000000,0x00000000,0x00000000},0x0174,1,220},
+	{{0x00000000,0x00000000,0x00000000},0x0175,1,220},
+	{{0x40000001,0x00000000,0x00000000},0x308f,1,6657},
+	{{0x00000001,0x00000020,0x00000000},0x30ef,1,6657},
+	{{0x40000005,0x00000000,0x00000000},0x308e,1,6657},
+	{{0x00000005,0x00000020,0x00000000},0x30ee,1,6657},
+	{{0x00000000,0x00000000,0x00000000},0x301c,1,6513},
+	{{0x00000081,0x00000000,0x00000000},0x0648,1,1547},
+	{{0x00000081,0x00000010,0x00000000},0xfeed,1,1547},
+	{{0x01000081,0x00000000,0x00000000},0xfeee,1,1547},
+	{{0x00000089,0x00000000,0x00000000},0x0624,1,1360},
+	{{0x00000089,0x00000010,0x00000000},0xfe85,1,1360},
+	{{0x40000001,0x00000000,0x00000000},0x3091,1,6663},
+	{{0x00000001,0x00000020,0x00000000},0x30f1,1,6663},
+	{{0x00000000,0x00000000,0x00000000},0x0624,1,1370},
+	{{0x00000000,0x00000000,0x00000000},0xfe85,1,7007},
+	{{0x40000001,0x00000000,0x00000000},0x3090,1,6660},
+	{{0x00000001,0x00000020,0x00000000},0x30f0,1,6660},
+	{{0x40000001,0x00000000,0x00000000},0x3092,1,6666},
+	{{0x00000001,0x00000020,0x00000000},0x30f2,1,6666},
+	{{0x00000001,0x00000000,0x00000000},0x20a9,1,3340},
+	{{0x00000201,0x00000000,0x00000000},0x3112,0,1592},
+	{{0x00040003,0x00000040,0x00000000},0x1e8c,0,1592},
+	{{0x00040005,0x00000040,0x00000000},0x1e8d,0,1592},
+	{{0x00000005,0x00040040,0x00000000},0x24b3,0,1592},
+	{{0x00004003,0x00000040,0x00000000},0x24cd,0,1592},
+	{{0x00004005,0x00000040,0x00000000},0x24e7,0,1592},
+	{{0x0008000b,0x00000040,0x00000000},0x1e8a,0,1592},
+	{{0x0008000d,0x00000040,0x00000000},0x1e8b,0,1592},
+	{{0x00000000,0x00000000,0x00000000},0x24cd,1,5405},
+	{{0x00000000,0x00000000,0x00000000},0x24e7,1,5405},
+	{{0x00000000,0x00000000,0x00000000},0x03a7,1,796},
+	{{0x00000000,0x00000000,0x00000000},0x03c7,1,796},
+	{{0x00000000,0x00000000,0x00000000},0x05d7,1,1214},
+	{{0x00000000,0x00000000,0x00000000},0x062e,1,1214},
+	{{0x00000000,0x00000000,0x00000000},0xfea7,1,7119},
+	{{0x00000000,0x00000000,0x00000000},0xfea5,1,7111},
+	{{0x00000000,0x00000000,0x00000000},0xfea6,1,7115},
+	{{0x00000000,0x00000000,0x00000000},0xfea8,1,7123},
+	{{0x00000000,0x00000000,0x00000000},0x1e8a,1,1979},
+	{{0x00000000,0x00000000,0x00000000},0x1e8b,1,1979},
+	{{0x00000000,0x00000000,0x00000000},0x3112,1,6826},
+	{{0x00000000,0x00000000,0x00000000},0x1e8c,1,1982},
+	{{0x00000000,0x00000000,0x00000000},0x1e8d,1,1982},
+	{{0x08000003,0x00000000,0x00000000},0x039e,1,747},
+	{{0x08000005,0x00000000,0x00000000},0x03be,1,747},
+	{{0x00000000,0x00000000,0x00000000},0x2717,1,6321},
+	{{0x00008003,0x00000040,0x00000000},0x0176,0,1594},
+	{{0x00008005,0x00000040,0x00000000},0x0177,0,1594},
+	{{0x00040003,0x00000040,0x00000000},0x0178,0,1594},
+	{{0x04000003,0x00000040,0x00000000},0x1ef2,0,1594},
+	{{0x04000005,0x00000040,0x00000000},0x1ef3,0,1594},
+	{{0x00000003,0x02000040,0x00000000},0x1ef8,0,1594},
+	{{0x00000005,0x02000040,0x00000000},0x1ef9,0,1594},
+	{{0x00000005,0x00040040,0x00000000},0x24b4,0,1594},
+	{{0x00004003,0x00000040,0x00000000},0x24ce,0,1594},
+	{{0x00004005,0x00000040,0x00000000},0x24e8,0,1594},
+	{{0x0008000b,0x00000040,0x00000000},0x1e8e,0,1594},
+	{{0x0008000d,0x00000040,0x00000000},0x1e8f,0,1594},
+	{{0x00080103,0x00000040,0x00000000},0x1ef4,0,1594},
+	{{0x00080105,0x00000040,0x00000000},0x1ef5,0,1594},
+	{{0x8000000b,0x00000040,0x00000000},0x1ef6,0,1594},
+	{{0x8000000d,0x00000040,0x00000000},0x1ef7,0,1594},
+	{{0x00000000,0x00000000,0x00000000},0x24ce,1,5409},
+	{{0x00000000,0x00000000,0x00000000},0x24e8,1,5409},
+	{{0x00000000,0x00000000,0x00000000},0x1ef2,1,2162},
+	{{0x00000000,0x00000000,0x00000000},0x1ef3,1,2162},
+	{{0x00000000,0x00000000,0x00000000},0x0389,1,639},
+	{{0x00000000,0x00000000,0x00000000},0x03ae,1,639},
+	{{0x00000000,0x00000000,0x00000000},0x0397,1,705},
+	{{0x00000000,0x00000000,0x00000000},0x03b7,1,705},
+	{{0x00000000,0x00000000,0x00000000},0x1f74,1,2437},
+	{{0x00000000,0x00000000,0x00000000},0x1fca,1,2437},
+	{{0x00000000,0x00000000,0x00000000},0x1fc2,1,2673},
+	{{0x00000000,0x00000000,0x00000000},0x1f75,1,2441},
+	{{0x00000000,0x00000000,0x00000000},0x1fcb,1,2441},
+	{{0x00000000,0x00000000,0x00000000},0x1fc4,1,2682},
+	{{0x00000000,0x00000000,0x00000000},0x1f20,1,2241},
+	{{0x00000000,0x00000000,0x00000000},0x1f28,1,2241},
+	{{0x00000000,0x00000000,0x00000000},0x1f22,1,2249},
+	{{0x00000000,0x00000000,0x00000000},0x1f2a,1,2249},
+	{{0x00000000,0x00000000,0x00000000},0x1f92,1,2533},
+	{{0x00000000,0x00000000,0x00000000},0x1f9a,1,2533},
+	{{0x00000000,0x00000000,0x00000000},0x1f24,1,2259},
+	{{0x00000000,0x00000000,0x00000000},0x1f2c,1,2259},
+	{{0x00000000,0x00000000,0x00000000},0x1f94,1,2545},
+	{{0x00000000,0x00000000,0x00000000},0x1f9c,1,2545},
+	{{0x00000000,0x00000000,0x00000000},0x1f26,1,2269},
+	{{0x00000000,0x00000000,0x00000000},0x1f2e,1,2269},
+	{{0x00000000,0x00000000,0x00000000},0x1f96,1,2557},
+	{{0x00000000,0x00000000,0x00000000},0x1f9e,1,2557},
+	{{0x00000000,0x00000000,0x00000000},0x1f90,1,2523},
+	{{0x00000000,0x00000000,0x00000000},0x1f98,1,2523},
+	{{0x00000000,0x00000000,0x00000000},0x1f21,1,2245},
+	{{0x00000000,0x00000000,0x00000000},0x1f29,1,2245},
+	{{0x00000000,0x00000000,0x00000000},0x1f23,1,2254},
+	{{0x00000000,0x00000000,0x00000000},0x1f2b,1,2254},
+	{{0x00000000,0x00000000,0x00000000},0x1f93,1,2539},
+	{{0x00000000,0x00000000,0x00000000},0x1f9b,1,2539},
+	{{0x00000000,0x00000000,0x00000000},0x1f25,1,2264},
+	{{0x00000000,0x00000000,0x00000000},0x1f2d,1,2264},
+	{{0x00000000,0x00000000,0x00000000},0x1f95,1,2551},
+	{{0x00000000,0x00000000,0x00000000},0x1f9d,1,2551},
+	{{0x00000000,0x00000000,0x00000000},0x1f27,1,2274},
+	{{0x00000000,0x00000000,0x00000000},0x1f2f,1,2274},
+	{{0x00000000,0x00000000,0x00000000},0x1f97,1,2563},
+	{{0x00000000,0x00000000,0x00000000},0x1f9f,1,2563},
+	{{0x00000000,0x00000000,0x00000000},0x1f91,1,2528},
+	{{0x00000000,0x00000000,0x00000000},0x1f99,1,2528},
+	{{0x00000000,0x00000000,0x00000000},0x1fc6,1,2687},
+	{{0x00000000,0x00000000,0x00000000},0x1fc7,1,2691},
+	{{0x00000000,0x00000000,0x00000000},0x1fc3,1,2678},
+	{{0x00000000,0x00000000,0x00000000},0x1fcc,1,2678},
+	{{0x00000000,0x00000000,0x00000000},0x064a,1,1563},
+	{{0x00000000,0x00000000,0x00000000},0xfef3,1,7423},
+	{{0x00000000,0x00000000,0x00000000},0xfef1,1,7415},
+	{{0x00000000,0x00000000,0x00000000},0xfef2,1,7419},
+	{{0x00000000,0x00000000,0x00000000},0xfef4,1,7427},
+	{{0x00000000,0x00000000,0x00000000},0x1ef4,1,2165},
+	{{0x00000000,0x00000000,0x00000000},0x1ef5,1,2165},
+	{{0x00000000,0x00000000,0x00000000},0x1e8e,1,1985},
+	{{0x00000000,0x00000000,0x00000000},0x1e8f,1,1985},
+	{{0x00000000,0x00000000,0x00000000},0x1ef6,1,2169},
+	{{0x00000000,0x00000000,0x00000000},0x1ef7,1,2169},
+	{{0x00000000,0x00000000,0x00000000},0x0462,1,1125},
+	{{0x00000000,0x00000000,0x00000000},0x0463,1,1125},
+	{{0x00000000,0x00000000,0x00000000},0x0178,0,2952},
+	{{0x00000000,0x00000000,0x00000000},0x042b,1,1092},
+	{{0x00000000,0x00000000,0x00000000},0x044b,1,1092},
+	{{0x00000000,0x00000000,0x00000000},0x0176,1,223},
+	{{0x00000000,0x00000000,0x00000000},0x0177,1,223},
+	{{0x00000000,0x00000000,0x00000000},0x1ef8,1,2172},
+	{{0x00000000,0x00000000,0x00000000},0x1ef9,1,2172},
+	{{0x40000001,0x00000000,0x00000000},0x3084,1,1109},
+	{{0x00000001,0x00000020,0x00000000},0x30e4,1,1109},
+	{{0x00010003,0x00000000,0x00000000},0x042f,1,1109},
+	{{0x00010005,0x00000000,0x00000000},0x044f,1,1109},
+	{{0x40000005,0x00000000,0x00000000},0x3083,1,1109},
+	{{0x00000005,0x00000020,0x00000000},0x30e3,1,1109},
+	{{0x00010003,0x00000000,0x00000000},0x0462,1,1121},
+	{{0x00010005,0x00000000,0x00000000},0x0463,1,1121},
+	{{0x00000081,0x00000000,0x00000000},0x064a,1,1559},
+	{{0x00000081,0x00000010,0x00000000},0xfef1,1,1559},
+	{{0x01000081,0x00000000,0x00000000},0xfef2,1,1559},
+	{{0x00000081,0x00000004,0x00000000},0xfef3,1,1559},
+	{{0x00000081,0x00001000,0x00000000},0xfef4,1,1559},
+	{{0x00000089,0x00000000,0x00000000},0x0626,1,1373},
+	{{0x00000089,0x00000004,0x00000000},0xfe8b,1,1373},
+	{{0x00010003,0x00000000,0x00000000},0x042b,1,1087},
+	{{0x00010005,0x00000000,0x00000000},0x044b,1,1087},
+	{{0x00000000,0x00000000,0x00000000},0x0626,1,1383},
+	{{0x00000000,0x00000000,0x00000000},0xfe8b,1,7011},
+	{{0x00000000,0x00000000,0x00000000},0x0407,1,905},
+	{{0x00000000,0x00000000,0x00000000},0x0457,1,905},
+	{{0x00010003,0x00000000,0x00000000},0x0407,1,905},
+	{{0x00010005,0x00000000,0x00000000},0x0457,1,905},
+	{{0x40000001,0x00000000,0x00000000},0x3088,1,6645},
+	{{0x00000001,0x00000020,0x00000000},0x30e8,1,6645},
+	{{0x40000005,0x00000000,0x00000000},0x3087,1,6645},
+	{{0x00000005,0x00000020,0x00000000},0x30e7,1,6645},
+	{{0x20000001,0x00000000,0x00000000},0x05d9,1,1224},
+	{{0x08000000,0x00000000,0x00000000},0x037a,1,575},
+	{{0x08000045,0x00000000,0x00000000},0x1fb3,1,575},
+	{{0x08800005,0x00000000,0x00000000},0x1fc3,1,575},
+	{{0x08000005,0x00008000,0x00000000},0x1ff3,1,575},
+	{{0x08000045,0x00200000,0x00000000},0x1f80,1,575},
+	{{0x08020045,0x00000000,0x00000000},0x1f81,1,575},
+	{{0x08800005,0x00200000,0x00000000},0x1f90,1,575},
+	{{0x08820005,0x00000000,0x00000000},0x1f91,1,575},
+	{{0x08000005,0x00208000,0x00000000},0x1fa0,1,575},
+	{{0x08020005,0x00008000,0x00000000},0x1fa1,1,575},
+	{{0x08000045,0x20000000,0x00000000},0x1fb2,1,575},
+	{{0x08000045,0x00020000,0x00000000},0x1fb4,1,575},
+	{{0x08000045,0x00080000,0x00000000},0x1fb7,1,575},
+	{{0x08800005,0x20000000,0x00000000},0x1fc2,1,575},
+	{{0x08800005,0x00020000,0x00000000},0x1fc4,1,575},
+	{{0x08800005,0x00080000,0x00000000},0x1fc7,1,575},
+	{{0x08000005,0x20008000,0x00000000},0x1ff2,1,575},
+	{{0x08000005,0x00028000,0x00000000},0x1ff4,1,575},
+	{{0x08000005,0x00088000,0x00000000},0x1ff7,1,575},
+	{{0x08000045,0x20200000,0x00000000},0x1f82,1,575},
+	{{0x08020045,0x20000000,0x00000000},0x1f83,1,575},
+	{{0x08000045,0x00220000,0x00000000},0x1f84,1,575},
+	{{0x08020045,0x00020000,0x00000000},0x1f85,1,575},
+	{{0x08000045,0x00280000,0x00000000},0x1f86,1,575},
+	{{0x08020045,0x00080000,0x00000000},0x1f87,1,575},
+	{{0x08800005,0x20200000,0x00000000},0x1f92,1,575},
+	{{0x08820005,0x20000000,0x00000000},0x1f93,1,575},
+	{{0x08800005,0x00220000,0x00000000},0x1f94,1,575},
+	{{0x08820005,0x00020000,0x00000000},0x1f95,1,575},
+	{{0x08800005,0x00280000,0x00000000},0x1f96,1,575},
+	{{0x08820005,0x00080000,0x00000000},0x1f97,1,575},
+	{{0x08000005,0x20208000,0x00000000},0x1fa2,1,575},
+	{{0x08020005,0x20008000,0x00000000},0x1fa3,1,575},
+	{{0x08000005,0x00228000,0x00000000},0x1fa4,1,575},
+	{{0x08020005,0x00028000,0x00000000},0x1fa5,1,575},
+	{{0x08000005,0x00288000,0x00000000},0x1fa6,1,575},
+	{{0x08020005,0x00088000,0x00000000},0x1fa7,1,575},
+	{{0x00000000,0x00000000,0x00000000},0x01a6,1,266},
+	{{0x00000001,0x00000040,0x00000000},0x01a6,1,266},
+	{{0x40000001,0x00000000,0x00000000},0x3086,1,1103},
+	{{0x00000001,0x00000020,0x00000000},0x30e6,1,1103},
+	{{0x00010003,0x00000000,0x00000000},0x042e,1,1103},
+	{{0x00010005,0x00000000,0x00000000},0x044e,1,1103},
+	{{0x40000005,0x00000000,0x00000000},0x3085,1,1103},
+	{{0x00000005,0x00000020,0x00000000},0x30e5,1,1103},
+	{{0x00010003,0x00000000,0x00200000},0x046a,1,1128},
+	{{0x00010005,0x00000000,0x00200000},0x046b,1,1128},
+	{{0x00000201,0x00000000,0x00000000},0x3117,0,1596},
+	{{0x00000013,0x00000040,0x00000000},0x0179,0,1596},
+	{{0x00000015,0x00000040,0x00000000},0x017a,0,1596},
+	{{0x00001003,0x00000040,0x00000000},0x017d,0,1596},
+	{{0x00001005,0x00000040,0x00000000},0x017e,0,1596},
+	{{0x00000003,0x00000040,0x10000000},0x01b5,0,1596},
+	{{0x00000005,0x00000040,0x10000000},0x01b6,0,1596},
+	{{0x00008003,0x00000040,0x00000000},0x1e90,0,1596},
+	{{0x00008005,0x00000040,0x00000000},0x1e91,0,1596},
+	{{0x00000005,0x00040040,0x00000000},0x24b5,0,1596},
+	{{0x00004003,0x00000040,0x00000000},0x24cf,0,1596},
+	{{0x00004005,0x00000040,0x00000000},0x24e9,0,1596},
+	{{0x0008000b,0x00000040,0x00000000},0x017b,0,1596},
+	{{0x0008000d,0x00000040,0x00000000},0x017c,0,1596},
+	{{0x00080103,0x00000040,0x00000000},0x1e92,0,1596},
+	{{0x00080105,0x00000040,0x00000000},0x1e93,0,1596},
+	{{0x00000103,0x00000240,0x00000000},0x1e94,0,1596},
+	{{0x00000105,0x00000240,0x00000000},0x1e95,0,1596},
+	{{0x00000000,0x00000000,0x00000000},0x24cf,1,5413},
+	{{0x00000000,0x00000000,0x00000000},0x24e9,1,5413},
+	{{0x00000000,0x00000000,0x00000000},0x0416,1,977},
+	{{0x00000000,0x00000000,0x00000000},0x0436,1,977},
+	{{0x00000000,0x00000000,0x00000000},0x0179,1,226},
+	{{0x00000000,0x00000000,0x00000000},0x017a,1,226},
+	{{0x00000000,0x00000000,0x00000000},0x0396,1,702},
+	{{0x00000000,0x00000000,0x00000000},0x03b6,1,702},
+	{{0x00000000,0x00000000,0x00000000},0x05d6,1,1207},
+	{{0x00000000,0x00000000,0x00000000},0x0632,1,1207},
+	{{0x00000000,0x00000000,0x00000000},0xfeaf,1,7151},
+	{{0x00000000,0x00000000,0x00000000},0xfeb0,1,7155},
+	{{0x00000000,0x00000000,0x00000000},0x1e92,1,1991},
+	{{0x00000000,0x00000000,0x00000000},0x1e93,1,1991},
+	{{0x00000000,0x00000000,0x00000000},0x017b,1,229},
+	{{0x00000000,0x00000000,0x00000000},0x017c,1,229},
+	{{0x00000000,0x00000000,0x00000000},0x01b5,1,272},
+	{{0x00000000,0x00000000,0x00000000},0x01b6,1,272},
+	{{0x00000000,0x00000000,0x00000000},0x3117,1,6832},
+	{{0x00000000,0x00000000,0x00000000},0x017d,1,232},
+	{{0x00000000,0x00000000,0x00000000},0x017e,1,232},
+	{{0x00000000,0x00000000,0x00000000},0x0417,1,983},
+	{{0x00000000,0x00000000,0x00000000},0x0437,1,983},
+	{{0x00000000,0x00000000,0x00000000},0x1e90,1,1988},
+	{{0x00000000,0x00000000,0x00000000},0x1e91,1,1988},
+	{{0x00000000,0x00000000,0x00000000},0x1e94,1,1995},
+	{{0x00000000,0x00000000,0x00000000},0x1e95,1,1995},
+	{{0x40000001,0x00000000,0x00000000},0x3056,1,6585},
+	{{0x00000001,0x00000020,0x00000000},0x30b6,1,6585},
+	{{0x00000081,0x00000000,0x00000000},0x0638,1,1487},
+	{{0x00000081,0x00000010,0x00000000},0xfec5,1,1487},
+	{{0x01000081,0x00000000,0x00000000},0xfec6,1,1487},
+	{{0x00000081,0x00000004,0x00000000},0xfec7,1,1487},
+	{{0x00000081,0x00001000,0x00000000},0xfec8,1,1487},
+	{{0x00000081,0x00000000,0x00000000},0x0632,1,1450},
+	{{0x00000081,0x00000010,0x00000000},0xfeaf,1,1450},
+	{{0x01000081,0x00000000,0x00000000},0xfeb0,1,1450},
+	{{0x20000001,0x00000000,0x00000000},0x05d6,1,1201},
+	{{0x40000001,0x00000000,0x00000000},0x305c,1,980},
+	{{0x00000001,0x00000020,0x00000000},0x30bc,1,980},
+	{{0x00010003,0x00000000,0x00000000},0x0417,1,980},
+	{{0x00010005,0x00000000,0x00000000},0x0437,1,980},
+	{{0x00000000,0x00000000,0x00000020},0x2070,0,1435},
+	{{0x00000000,0x00000000,0x00000040},0x2080,0,1435},
+	{{0x00004001,0x00000000,0x00000000},0x24ea,0,1435},
+	{{0x00000081,0x00000000,0x00000400},0x0660,0,1435},
+	{{0x00000000,0x00002000,0x00000800},0x3007,0,1435},
+	{{0x08000003,0x00000000,0x00000000},0x0396,1,697},
+	{{0x08000005,0x00000000,0x00000000},0x03b6,1,697},
+	{{0x00000000,0x00000000,0x00000000},0x0638,1,1491},
+	{{0x00000201,0x00000000,0x00000000},0x3113,1,1491},
+	{{0x00000000,0x00000000,0x00000000},0xfec7,1,7247},
+	{{0x00000000,0x00000000,0x00000000},0xfec5,1,7239},
+	{{0x00000000,0x00000000,0x00000000},0xfec6,1,7243},
+	{{0x00000000,0x00000000,0x00000000},0xfec8,1,7251},
+	{{0x00010003,0x00000000,0x00000000},0x0416,1,973},
+	{{0x00010005,0x00000000,0x00000000},0x0436,1,973},
+	{{0x40000001,0x00000000,0x00000000},0x3058,1,6588},
+	{{0x00000001,0x00000020,0x00000000},0x30b8,1,6588},
+	{{0x00000000,0x00000000,0x00000000},0x05e5,1,1300},
+	{{0x00000000,0x00000000,0x00000000},0x05e6,1,1300},
+	{{0x00000000,0x00000000,0x00000000},0x0698,1,1300},
+	{{0x40000001,0x00000000,0x00000000},0x305e,1,6594},
+	{{0x00000001,0x00000020,0x00000000},0x30be,1,6594},
+	{{0x40000001,0x00000000,0x00000000},0x305a,1,6591},
+	{{0x00000001,0x00000020,0x00000000},0x30ba,1,6591},
+#endif /* UCS_BYTE */
+};