const uint8_t *buf_start;
int re_flags;
BOOL is_unicode;
+ BOOL unicode_sets; /* if set, is_unicode is also set */
BOOL ignore_case;
BOOL dotall;
int capture_count;
};
#define RE_HEADER_FLAGS 0
-#define RE_HEADER_CAPTURE_COUNT 1
-#define RE_HEADER_STACK_SIZE 2
-#define RE_HEADER_BYTECODE_LEN 3
+#define RE_HEADER_CAPTURE_COUNT 2
+#define RE_HEADER_STACK_SIZE 3
+#define RE_HEADER_BYTECODE_LEN 4
-#define RE_HEADER_LEN 7
+#define RE_HEADER_LEN 8
static inline int is_digit(int c) {
return c >= '0' && c <= '9';
return 0;
}
+typedef struct REString {
+ struct REString *next;
+ uint32_t hash;
+ uint32_t len;
+ uint32_t buf[];
+} REString;
+
+typedef struct {
+ /* the string list is the union of 'char_range' and of the strings
+ in hash_table[]. The strings in hash_table[] have a length !=
+ 1. */
+ CharRange cr;
+ uint32_t n_strings;
+ uint32_t hash_size;
+ int hash_bits;
+ REString **hash_table;
+} REStringList;
+
+static uint32_t re_string_hash(int len, const uint32_t *buf)
+{
+ int i;
+ uint32_t h;
+ h = 1;
+ for(i = 0; i < len; i++)
+ h = h * 263 + buf[i];
+ return h * 0x61C88647;
+}
+
+static void re_string_list_init(REParseState *s1, REStringList *s)
+{
+ cr_init(&s->cr, s1->opaque, lre_realloc);
+ s->n_strings = 0;
+ s->hash_size = 0;
+ s->hash_bits = 0;
+ s->hash_table = NULL;
+}
+
+static void re_string_list_free(REStringList *s)
+{
+ REString *p, *p_next;
+ int i;
+ for(i = 0; i < s->hash_size; i++) {
+ for(p = s->hash_table[i]; p != NULL; p = p_next) {
+ p_next = p->next;
+ lre_realloc(s->cr.mem_opaque, p, 0);
+ }
+ }
+ lre_realloc(s->cr.mem_opaque, s->hash_table, 0);
+
+ cr_free(&s->cr);
+}
+
+static void lre_print_char(int c, BOOL is_range)
+{
+ if (c == '\'' || c == '\\' ||
+ (is_range && (c == '-' || c == ']'))) {
+ printf("\\%c", c);
+ } else if (c >= ' ' && c <= 126) {
+ printf("%c", c);
+ } else {
+ printf("\\u{%04x}", c);
+ }
+}
+
+static __maybe_unused void re_string_list_dump(const char *str, const REStringList *s)
+{
+ REString *p;
+ const CharRange *cr;
+ int i, j, k;
+
+ printf("%s:\n", str);
+ printf(" ranges: [");
+ cr = &s->cr;
+ for(i = 0; i < cr->len; i += 2) {
+ lre_print_char(cr->points[i], TRUE);
+ if (cr->points[i] != cr->points[i + 1] - 1) {
+ printf("-");
+ lre_print_char(cr->points[i + 1] - 1, TRUE);
+ }
+ }
+ printf("]\n");
+
+ j = 0;
+ for(i = 0; i < s->hash_size; i++) {
+ for(p = s->hash_table[i]; p != NULL; p = p->next) {
+ printf(" %d/%d: '", j, s->n_strings);
+ for(k = 0; k < p->len; k++) {
+ lre_print_char(p->buf[k], FALSE);
+ }
+ printf("'\n");
+ j++;
+ }
+ }
+}
+
+static int re_string_find2(REStringList *s, int len, const uint32_t *buf,
+ uint32_t h0, BOOL add_flag)
+{
+ uint32_t h = 0; /* avoid warning */
+ REString *p;
+ if (s->n_strings != 0) {
+ h = h0 >> (32 - s->hash_bits);
+ for(p = s->hash_table[h]; p != NULL; p = p->next) {
+ if (p->hash == h0 && p->len == len &&
+ !memcmp(p->buf, buf, len * sizeof(buf[0]))) {
+ return 1;
+ }
+ }
+ }
+ /* not found */
+ if (!add_flag)
+ return 0;
+ /* increase the size of the hash table if needed */
+ if (unlikely((s->n_strings + 1) > s->hash_size)) {
+ REString **new_hash_table, *p_next;
+ int new_hash_bits, i;
+ uint32_t new_hash_size;
+ new_hash_bits = max_int(s->hash_bits + 1, 4);
+ new_hash_size = 1 << new_hash_bits;
+ new_hash_table = lre_realloc(s->cr.mem_opaque, NULL,
+ sizeof(new_hash_table[0]) * new_hash_size);
+ if (!new_hash_table)
+ return -1;
+ memset(new_hash_table, 0, sizeof(new_hash_table[0]) * new_hash_size);
+ for(i = 0; i < s->hash_size; i++) {
+ for(p = s->hash_table[i]; p != NULL; p = p_next) {
+ p_next = p->next;
+ h = p->hash >> (32 - new_hash_bits);
+ p->next = new_hash_table[h];
+ new_hash_table[h] = p;
+ }
+ }
+ lre_realloc(s->cr.mem_opaque, s->hash_table, 0);
+ s->hash_bits = new_hash_bits;
+ s->hash_size = new_hash_size;
+ s->hash_table = new_hash_table;
+ h = h0 >> (32 - s->hash_bits);
+ }
+
+ p = lre_realloc(s->cr.mem_opaque, NULL, sizeof(REString) + len * sizeof(buf[0]));
+ if (!p)
+ return -1;
+ p->next = s->hash_table[h];
+ s->hash_table[h] = p;
+ s->n_strings++;
+ p->hash = h0;
+ p->len = len;
+ memcpy(p->buf, buf, sizeof(buf[0]) * len);
+ return 1;
+}
+
+static int re_string_find(REStringList *s, int len, const uint32_t *buf,
+ BOOL add_flag)
+{
+ uint32_t h0;
+ h0 = re_string_hash(len, buf);
+ return re_string_find2(s, len, buf, h0, add_flag);
+}
+
+/* return -1 if memory error, 0 if OK */
+static int re_string_add(REStringList *s, int len, const uint32_t *buf)
+{
+ if (len == 1) {
+ return cr_union_interval(&s->cr, buf[0], buf[0]);
+ }
+ if (re_string_find(s, len, buf, TRUE) < 0)
+ return -1;
+ return 0;
+}
+
+/* a = a op b */
+static int re_string_list_op(REStringList *a, REStringList *b, int op)
+{
+ int i, ret;
+ REString *p, **pp;
+
+ if (cr_op1(&a->cr, b->cr.points, b->cr.len, op))
+ return -1;
+
+ switch(op) {
+ case CR_OP_UNION:
+ if (b->n_strings != 0) {
+ for(i = 0; i < b->hash_size; i++) {
+ for(p = b->hash_table[i]; p != NULL; p = p->next) {
+ if (re_string_find2(a, p->len, p->buf, p->hash, TRUE) < 0)
+ return -1;
+ }
+ }
+ }
+ break;
+ case CR_OP_INTER:
+ case CR_OP_SUB:
+ for(i = 0; i < a->hash_size; i++) {
+ pp = &a->hash_table[i];
+ for(;;) {
+ p = *pp;
+ if (p == NULL)
+ break;
+ ret = re_string_find2(b, p->len, p->buf, p->hash, FALSE);
+ if (op == CR_OP_SUB)
+ ret = !ret;
+ if (!ret) {
+ /* remove it */
+ *pp = p->next;
+ a->n_strings--;
+ lre_realloc(a->cr.mem_opaque, p, 0);
+ } else {
+ /* keep it */
+ pp = &p->next;
+ }
+ }
+ }
+ break;
+ default:
+ abort();
+ }
+ return 0;
+}
+
+static int re_string_list_canonicalize(REParseState *s1,
+ REStringList *s, BOOL is_unicode)
+{
+ if (cr_regexp_canonicalize(&s->cr, is_unicode))
+ return -1;
+ if (s->n_strings != 0) {
+ REStringList a_s, *a = &a_s;
+ int i, j;
+ REString *p;
+
+ /* XXX: simplify */
+ re_string_list_init(s1, a);
+
+ a->n_strings = s->n_strings;
+ a->hash_size = s->hash_size;
+ a->hash_bits = s->hash_bits;
+ a->hash_table = s->hash_table;
+
+ s->n_strings = 0;
+ s->hash_size = 0;
+ s->hash_bits = 0;
+ s->hash_table = NULL;
+
+ for(i = 0; i < a->hash_size; i++) {
+ for(p = a->hash_table[i]; p != NULL; p = p->next) {
+ for(j = 0; j < p->len; j++) {
+ p->buf[j] = lre_canonicalize(p->buf[j], is_unicode);
+ }
+ if (re_string_add(s, p->len, p->buf)) {
+ re_string_list_free(a);
+ return -1;
+ }
+ }
+ }
+ re_string_list_free(a);
+ }
+ return 0;
+}
+
static const uint16_t char_range_d[] = {
1,
0x0030, 0x0039 + 1,
char_range_w,
};
-static int cr_init_char_range(REParseState *s, CharRange *cr, uint32_t c)
+static int cr_init_char_range(REParseState *s, REStringList *cr, uint32_t c)
{
BOOL invert;
const uint16_t *c_pt;
invert = c & 1;
c_pt = char_range_table[c >> 1];
len = *c_pt++;
- cr_init(cr, s->opaque, lre_realloc);
+ re_string_list_init(s, cr);
for(i = 0; i < len * 2; i++) {
- if (cr_add_point(cr, c_pt[i]))
+ if (cr_add_point(&cr->cr, c_pt[i]))
goto fail;
}
if (invert) {
- if (cr_invert(cr))
+ if (cr_invert(&cr->cr))
goto fail;
}
return 0;
fail:
- cr_free(cr);
+ re_string_list_free(cr);
return -1;
}
(c == '_'));
}
-static int parse_unicode_property(REParseState *s, CharRange *cr,
- const uint8_t **pp, BOOL is_inv)
+/* XXX: memory error test */
+static void seq_prop_cb(void *opaque, const uint32_t *seq, int seq_len)
+{
+ REStringList *sl = opaque;
+ re_string_add(sl, seq_len, seq);
+}
+
+static int parse_unicode_property(REParseState *s, REStringList *cr,
+ const uint8_t **pp, BOOL is_inv,
+ BOOL allow_sequence_prop)
{
const uint8_t *p;
char name[64], value[64];
} else if (!strcmp(name, "Script_Extensions") || !strcmp(name, "scx")) {
script_ext = TRUE;
do_script:
- cr_init(cr, s->opaque, lre_realloc);
- ret = unicode_script(cr, value, script_ext);
+ re_string_list_init(s, cr);
+ ret = unicode_script(&cr->cr, value, script_ext);
if (ret) {
- cr_free(cr);
+ re_string_list_free(cr);
if (ret == -2)
return re_parse_error(s, "unknown unicode script");
else
goto out_of_memory;
}
} else if (!strcmp(name, "General_Category") || !strcmp(name, "gc")) {
- cr_init(cr, s->opaque, lre_realloc);
- ret = unicode_general_category(cr, value);
+ re_string_list_init(s, cr);
+ ret = unicode_general_category(&cr->cr, value);
if (ret) {
- cr_free(cr);
+ re_string_list_free(cr);
if (ret == -2)
return re_parse_error(s, "unknown unicode general category");
else
goto out_of_memory;
}
} else if (value[0] == '\0') {
- cr_init(cr, s->opaque, lre_realloc);
- ret = unicode_general_category(cr, name);
+ re_string_list_init(s, cr);
+ ret = unicode_general_category(&cr->cr, name);
if (ret == -1) {
- cr_free(cr);
+ re_string_list_free(cr);
goto out_of_memory;
}
if (ret < 0) {
- ret = unicode_prop(cr, name);
- if (ret) {
- cr_free(cr);
- if (ret == -2)
- goto unknown_property_name;
- else
- goto out_of_memory;
+ ret = unicode_prop(&cr->cr, name);
+ if (ret == -1) {
+ re_string_list_free(cr);
+ goto out_of_memory;
}
}
+ if (ret < 0 && !is_inv && allow_sequence_prop) {
+ CharRange cr_tmp;
+ cr_init(&cr_tmp, s->opaque, lre_realloc);
+ ret = unicode_sequence_prop(name, seq_prop_cb, cr, &cr_tmp);
+ cr_free(&cr_tmp);
+ if (ret == -1) {
+ re_string_list_free(cr);
+ goto out_of_memory;
+ }
+ }
+ if (ret < 0)
+ goto unknown_property_name;
} else {
unknown_property_name:
return re_parse_error(s, "unknown unicode property name");
}
+ /* the ordering of case folding and inversion differs with
+ unicode_sets. 'unicode_sets' ordering is more consistent */
+ /* XXX: the spec seems incorrect, we do it as the other engines
+ seem to do it. */
+ if (s->ignore_case && s->unicode_sets) {
+ if (re_string_list_canonicalize(s, cr, s->is_unicode)) {
+ re_string_list_free(cr);
+ goto out_of_memory;
+ }
+ }
if (is_inv) {
- if (cr_invert(cr)) {
- cr_free(cr);
- return -1;
+ if (cr_invert(&cr->cr)) {
+ re_string_list_free(cr);
+ goto out_of_memory;
+ }
+ }
+ if (s->ignore_case && !s->unicode_sets) {
+ if (re_string_list_canonicalize(s, cr, s->is_unicode)) {
+ re_string_list_free(cr);
+ goto out_of_memory;
}
}
*pp = p;
}
#endif /* CONFIG_ALL_UNICODE */
+static int get_class_atom(REParseState *s, REStringList *cr,
+ const uint8_t **pp, BOOL inclass);
+
+static int parse_class_string_disjunction(REParseState *s, REStringList *cr,
+ const uint8_t **pp)
+{
+ const uint8_t *p;
+ DynBuf str;
+ int c;
+
+ p = *pp;
+ if (*p != '{')
+ return re_parse_error(s, "expecting '{' after \\q");
+
+ dbuf_init2(&str, s->opaque, lre_realloc);
+ re_string_list_init(s, cr);
+
+ p++;
+ for(;;) {
+ str.size = 0;
+ while (*p != '}' && *p != '|') {
+ c = get_class_atom(s, NULL, &p, FALSE);
+ if (c < 0)
+ goto fail;
+ if (dbuf_put_u32(&str, c)) {
+ re_parse_out_of_memory(s);
+ goto fail;
+ }
+ }
+ if (re_string_add(cr, str.size / 4, (uint32_t *)str.buf)) {
+ re_parse_out_of_memory(s);
+ goto fail;
+ }
+ if (*p == '}')
+ break;
+ p++;
+ }
+ if (s->ignore_case) {
+ if (re_string_list_canonicalize(s, cr, TRUE))
+ goto fail;
+ }
+ p++; /* skip the '}' */
+ dbuf_free(&str);
+ *pp = p;
+ return 0;
+ fail:
+ dbuf_free(&str);
+ re_string_list_free(cr);
+ return -1;
+}
+
/* return -1 if error otherwise the character or a class range
- (CLASS_RANGE_BASE). In case of class range, 'cr' is
+ (CLASS_RANGE_BASE) if cr != NULL. In case of class range, 'cr' is
initialized. Otherwise, it is ignored. */
-static int get_class_atom(REParseState *s, CharRange *cr,
+static int get_class_atom(REParseState *s, REStringList *cr,
const uint8_t **pp, BOOL inclass)
{
const uint8_t *p;
case 'W':
c = CHAR_RANGE_W;
class_range:
+ if (!cr)
+ goto default_escape;
if (cr_init_char_range(s, cr, c))
return -1;
c = CLASS_RANGE_BASE;
if (!inclass && s->is_unicode)
goto invalid_escape;
break;
+ case '^':
+ case '$':
+ case '\\':
+ case '.':
+ case '*':
+ case '+':
+ case '?':
+ case '(':
+ case ')':
+ case '[':
+ case ']':
+ case '{':
+ case '}':
+ case '|':
+ case '/':
+ /* always valid to escape these characters */
+ break;
#ifdef CONFIG_ALL_UNICODE
case 'p':
case 'P':
- if (s->is_unicode) {
- if (parse_unicode_property(s, cr, &p, (c == 'P')))
+ if (s->is_unicode && cr) {
+ if (parse_unicode_property(s, cr, &p, (c == 'P'), s->unicode_sets))
return -1;
c = CLASS_RANGE_BASE;
break;
}
- /* fall thru */
+ goto default_escape;
#endif
+ case 'q':
+ if (s->unicode_sets && cr && inclass) {
+ if (parse_class_string_disjunction(s, cr, &p))
+ return -1;
+ c = CLASS_RANGE_BASE;
+ break;
+ }
+ goto default_escape;
default:
+ default_escape:
p--;
ret = lre_parse_escape(&p, s->is_unicode * 2);
if (ret >= 0) {
c = ret;
} else {
- if (ret == -2 && *p != '\0' && strchr("^$\\.*+?()[]{}|/", *p)) {
- /* always valid to escape these characters */
- goto normal_char;
- } else if (s->is_unicode) {
+ if (s->is_unicode) {
invalid_escape:
return re_parse_error(s, "invalid escape sequence in regular expression");
} else {
return re_parse_error(s, "unexpected end");
}
/* fall thru */
+ goto normal_char;
+
+ case '&':
+ case '!':
+ case '#':
+ case '$':
+ case '%':
+ case '*':
+ case '+':
+ case ',':
+ case '.':
+ case ':':
+ case ';':
+ case '<':
+ case '=':
+ case '>':
+ case '?':
+ case '@':
+ case '^':
+ case '`':
+ case '~':
+ if (s->unicode_sets && p[1] == c) {
+ /* forbidden double characters */
+ return re_parse_error(s, "invalid class set operation in regular expression");
+ }
+ goto normal_char;
+
+ case '(':
+ case ')':
+ case '[':
+ case ']':
+ case '{':
+ case '}':
+ case '/':
+ case '-':
+ case '|':
+ if (s->unicode_sets) {
+ /* invalid characters in unicode sets */
+ return re_parse_error(s, "invalid character in class in regular expression");
+ }
+ goto normal_char;
+
default:
normal_char:
/* normal char */
if (len >= 65535)
return re_parse_error(s, "too many ranges");
if (len == 0) {
- /* not sure it can really happen. Emit a match that is always
- false */
re_emit_op_u32(s, REOP_char32, -1);
} else {
high = cr->points[cr->len - 1];
return 0;
}
-static int re_parse_char_class(REParseState *s, const uint8_t **pp)
+static int re_string_cmp_len(const void *a, const void *b, void *arg)
+{
+ REString *p1 = *(REString **)a;
+ REString *p2 = *(REString **)b;
+ return (p1->len < p2->len) - (p1->len > p2->len);
+}
+
+static int re_emit_string_list(REParseState *s, const REStringList *sl)
+{
+ REString **tab, *p;
+ int i, j, c, split_pos, last_match_pos, n;
+ BOOL has_empty_string, is_last;
+
+ // re_string_list_dump("sl", sl);
+ if (sl->n_strings == 0) {
+ /* simple case: only characters */
+ if (re_emit_range(s, &sl->cr))
+ return -1;
+ } else {
+ /* at least one string list is present : match the longest ones first */
+ /* XXX: add a new op_switch opcode to compile as a trie */
+ tab = lre_realloc(s->opaque, NULL, sizeof(tab[0]) * sl->n_strings);
+ if (!tab) {
+ re_parse_out_of_memory(s);
+ return -1;
+ }
+ has_empty_string = FALSE;
+ n = 0;
+ for(i = 0; i < sl->hash_size; i++) {
+ for(p = sl->hash_table[i]; p != NULL; p = p->next) {
+ if (p->len == 0) {
+ has_empty_string = TRUE;
+ } else {
+ tab[n++] = p;
+ }
+ }
+ }
+ assert(n <= sl->n_strings);
+
+ rqsort(tab, n, sizeof(tab[0]), re_string_cmp_len, NULL);
+
+ last_match_pos = -1;
+ for(i = 0; i < n; i++) {
+ p = tab[i];
+ is_last = !has_empty_string && sl->cr.len == 0 && i == (n - 1);
+ if (!is_last)
+ split_pos = re_emit_op_u32(s, REOP_split_next_first, 0);
+ else
+ split_pos = 0;
+ for(j = 0; j < p->len; j++) {
+ c = p->buf[j];
+ if (c <= 0xffff)
+ re_emit_op_u16(s, REOP_char, c);
+ else
+ re_emit_op_u32(s, REOP_char32, c);
+ }
+ if (!is_last) {
+ last_match_pos = re_emit_op_u32(s, REOP_goto, last_match_pos);
+ put_u32(s->byte_code.buf + split_pos, s->byte_code.size - (split_pos + 4));
+ }
+ }
+
+ if (sl->cr.len != 0) {
+ /* char range */
+ is_last = !has_empty_string;
+ if (!is_last)
+ split_pos = re_emit_op_u32(s, REOP_split_next_first, 0);
+ else
+ split_pos = 0; /* not used */
+ if (re_emit_range(s, &sl->cr)) {
+ lre_realloc(s->opaque, tab, 0);
+ return -1;
+ }
+ if (!is_last)
+ put_u32(s->byte_code.buf + split_pos, s->byte_code.size - (split_pos + 4));
+ }
+
+ /* patch the 'goto match' */
+ while (last_match_pos != -1) {
+ int next_pos = get_u32(s->byte_code.buf + last_match_pos);
+ put_u32(s->byte_code.buf + last_match_pos, s->byte_code.size - (last_match_pos + 4));
+ last_match_pos = next_pos;
+ }
+
+ lre_realloc(s->opaque, tab, 0);
+ }
+ return 0;
+}
+
+static int re_parse_nested_class(REParseState *s, REStringList *cr, const uint8_t **pp);
+
+static int re_parse_class_set_operand(REParseState *s, REStringList *cr, const uint8_t **pp)
+{
+ int c1;
+ const uint8_t *p = *pp;
+
+ if (*p == '[') {
+ if (re_parse_nested_class(s, cr, pp))
+ return -1;
+ } else {
+ c1 = get_class_atom(s, cr, pp, TRUE);
+ if (c1 < 0)
+ return -1;
+ if (c1 < CLASS_RANGE_BASE) {
+ /* create a range with a single character */
+ re_string_list_init(s, cr);
+ if (s->ignore_case)
+ c1 = lre_canonicalize(c1, s->is_unicode);
+ if (cr_union_interval(&cr->cr, c1, c1)) {
+ re_string_list_free(cr);
+ return -1;
+ }
+ }
+ }
+ return 0;
+}
+
+static int re_parse_nested_class(REParseState *s, REStringList *cr, const uint8_t **pp)
{
const uint8_t *p;
uint32_t c1, c2;
- CharRange cr_s, *cr = &cr_s;
- CharRange cr1_s, *cr1 = &cr1_s;
- BOOL invert;
+ int ret;
+ REStringList cr1_s, *cr1 = &cr1_s;
+ BOOL invert, is_first;
+
+ if (lre_check_stack_overflow(s->opaque, 0))
+ return re_parse_error(s, "stack overflow");
- cr_init(cr, s->opaque, lre_realloc);
+ re_string_list_init(s, cr);
p = *pp;
p++; /* skip '[' */
p++;
invert = TRUE;
}
-
+
+ /* handle unions */
+ is_first = TRUE;
for(;;) {
if (*p == ']')
break;
- c1 = get_class_atom(s, cr1, &p, TRUE);
- if ((int)c1 < 0)
- goto fail;
- if (*p == '-' && p[1] != ']') {
- const uint8_t *p0 = p + 1;
- if (c1 >= CLASS_RANGE_BASE) {
- if (s->is_unicode) {
- cr_free(cr1);
- goto invalid_class_range;
- }
- /* Annex B: match '-' character */
- goto class_atom;
- }
- c2 = get_class_atom(s, cr1, &p0, TRUE);
- if ((int)c2 < 0)
- goto fail;
- if (c2 >= CLASS_RANGE_BASE) {
- cr_free(cr1);
- if (s->is_unicode) {
- goto invalid_class_range;
- }
- /* Annex B: match '-' character */
- goto class_atom;
- }
- p = p0;
- if (c2 < c1) {
- invalid_class_range:
- re_parse_error(s, "invalid class range");
+ if (*p == '[' && s->unicode_sets) {
+ if (re_parse_nested_class(s, cr1, &p))
goto fail;
- }
- if (cr_union_interval(cr, c1, c2))
- goto memory_error;
+ goto class_union;
} else {
- class_atom:
- if (c1 >= CLASS_RANGE_BASE) {
- int ret;
- ret = cr_union1(cr, cr1->points, cr1->len);
- cr_free(cr1);
- if (ret)
- goto memory_error;
+ c1 = get_class_atom(s, cr1, &p, TRUE);
+ if ((int)c1 < 0)
+ goto fail;
+ if (*p == '-' && p[1] != ']') {
+ const uint8_t *p0 = p + 1;
+ if (p[1] == '-' && s->unicode_sets && is_first)
+ goto class_atom; /* first character class followed by '--' */
+ if (c1 >= CLASS_RANGE_BASE) {
+ if (s->is_unicode) {
+ re_string_list_free(cr1);
+ goto invalid_class_range;
+ }
+ /* Annex B: match '-' character */
+ goto class_atom;
+ }
+ c2 = get_class_atom(s, cr1, &p0, TRUE);
+ if ((int)c2 < 0)
+ goto fail;
+ if (c2 >= CLASS_RANGE_BASE) {
+ re_string_list_free(cr1);
+ if (s->is_unicode) {
+ goto invalid_class_range;
+ }
+ /* Annex B: match '-' character */
+ goto class_atom;
+ }
+ p = p0;
+ if (c2 < c1) {
+ invalid_class_range:
+ re_parse_error(s, "invalid class range");
+ goto fail;
+ }
+ if (s->ignore_case) {
+ CharRange cr2_s, *cr2 = &cr2_s;
+ cr_init(cr2, s->opaque, lre_realloc);
+ if (cr_add_interval(cr2, c1, c2 + 1) ||
+ cr_regexp_canonicalize(cr2, s->is_unicode) ||
+ cr_op1(&cr->cr, cr2->points, cr2->len, CR_OP_UNION)) {
+ cr_free(cr2);
+ goto memory_error;
+ }
+ cr_free(cr2);
+ } else {
+ if (cr_union_interval(&cr->cr, c1, c2))
+ goto memory_error;
+ }
+ is_first = FALSE; /* union operation */
} else {
- if (cr_union_interval(cr, c1, c1))
- goto memory_error;
+ class_atom:
+ if (c1 >= CLASS_RANGE_BASE) {
+ class_union:
+ ret = re_string_list_op(cr, cr1, CR_OP_UNION);
+ re_string_list_free(cr1);
+ if (ret)
+ goto memory_error;
+ } else {
+ if (s->ignore_case)
+ c1 = lre_canonicalize(c1, s->is_unicode);
+ if (cr_union_interval(&cr->cr, c1, c1))
+ goto memory_error;
+ }
}
}
+ if (s->unicode_sets && is_first) {
+ if (*p == '&' && p[1] == '&' && p[2] != '&') {
+ /* handle '&&' */
+ for(;;) {
+ if (*p == ']') {
+ break;
+ } else if (*p == '&' && p[1] == '&' && p[2] != '&') {
+ p += 2;
+ } else {
+ goto invalid_operation;
+ }
+ if (re_parse_class_set_operand(s, cr1, &p))
+ goto fail;
+ ret = re_string_list_op(cr, cr1, CR_OP_INTER);
+ re_string_list_free(cr1);
+ if (ret)
+ goto memory_error;
+ }
+ } else if (*p == '-' && p[1] == '-') {
+ /* handle '--' */
+ for(;;) {
+ if (*p == ']') {
+ break;
+ } else if (*p == '-' && p[1] == '-') {
+ p += 2;
+ } else {
+ invalid_operation:
+ re_parse_error(s, "invalid operation in regular expression");
+ goto fail;
+ }
+ if (re_parse_class_set_operand(s, cr1, &p))
+ goto fail;
+ ret = re_string_list_op(cr, cr1, CR_OP_SUB);
+ re_string_list_free(cr1);
+ if (ret)
+ goto memory_error;
+ }
+ }
+ }
+ is_first = FALSE;
}
- if (s->ignore_case) {
- if (cr_regexp_canonicalize(cr, s->is_unicode))
- goto memory_error;
- }
+
+ p++; /* skip ']' */
+ *pp = p;
if (invert) {
- if (cr_invert(cr))
+ /* XXX: add may_contain_string syntax check to be fully
+ compliant. The test here accepts more input than the
+ spec. */
+ if (cr->n_strings != 0) {
+ re_parse_error(s, "negated character class with strings in regular expression debugger eval code");
+ goto fail;
+ }
+ if (cr_invert(&cr->cr))
goto memory_error;
}
- if (re_emit_range(s, cr))
- goto fail;
- cr_free(cr);
- p++; /* skip ']' */
- *pp = p;
return 0;
memory_error:
re_parse_out_of_memory(s);
fail:
- cr_free(cr);
+ re_string_list_free(cr);
+ return -1;
+}
+
+static int re_parse_char_class(REParseState *s, const uint8_t **pp)
+{
+ REStringList cr_s, *cr = &cr_s;
+
+ if (re_parse_nested_class(s, cr, pp))
+ return -1;
+ if (re_emit_string_list(s, cr))
+ goto fail;
+ re_string_list_free(cr);
+ return 0;
+ fail:
+ re_string_list_free(cr);
return -1;
}
const uint8_t *p;
int c, last_atom_start, quant_min, quant_max, last_capture_count;
BOOL greedy, add_zero_advance_check, is_neg, is_backward_lookahead;
- CharRange cr_s, *cr = &cr_s;
+ REStringList cr_s, *cr = &cr_s;
last_atom_start = -1;
last_capture_count = 0;
re_emit_op(s, REOP_prev);
if (c >= CLASS_RANGE_BASE) {
int ret;
- /* Note: canonicalization is not needed */
- ret = re_emit_range(s, cr);
- cr_free(cr);
+ ret = re_emit_string_list(s, cr);
+ re_string_list_free(cr);
if (ret)
return -1;
} else {
s->buf_end = s->buf_ptr + buf_len;
s->buf_start = s->buf_ptr;
s->re_flags = re_flags;
- s->is_unicode = ((re_flags & LRE_FLAG_UNICODE) != 0);
+ s->is_unicode = ((re_flags & (LRE_FLAG_UNICODE | LRE_FLAG_UNICODE_SETS)) != 0);
is_sticky = ((re_flags & LRE_FLAG_STICKY) != 0);
s->ignore_case = ((re_flags & LRE_FLAG_IGNORECASE) != 0);
s->dotall = ((re_flags & LRE_FLAG_DOTALL) != 0);
+ s->unicode_sets = ((re_flags & LRE_FLAG_UNICODE_SETS) != 0);
s->capture_count = 1;
s->total_capture_count = -1;
s->has_named_captures = -1;
dbuf_init2(&s->byte_code, opaque, lre_realloc);
dbuf_init2(&s->group_names, opaque, lre_realloc);
- dbuf_putc(&s->byte_code, re_flags); /* first element is the flags */
+ dbuf_put_u16(&s->byte_code, re_flags); /* first element is the flags */
dbuf_putc(&s->byte_code, 0); /* second element is the number of captures */
dbuf_putc(&s->byte_code, 0); /* stack size */
dbuf_put_u32(&s->byte_code, 0); /* bytecode length */
/* add the named groups if needed */
if (s->group_names.size > (s->capture_count - 1)) {
dbuf_put(&s->byte_code, s->group_names.buf, s->group_names.size);
- s->byte_code.buf[RE_HEADER_FLAGS] |= LRE_FLAG_NAMED_GROUPS;
+ put_u16(s->byte_code.buf + RE_HEADER_FLAGS,
+ lre_get_flags(s->byte_code.buf) | LRE_FLAG_NAMED_GROUPS);
}
dbuf_free(&s->group_names);
v1 = FALSE;
} else {
PEEK_PREV_CHAR(c, cptr, s->cbuf, cbuf_type);
+ if (s->ignore_case)
+ c = lre_canonicalize(c, s->is_unicode);
v1 = is_word_char(c);
}
/* current char */
v2 = FALSE;
} else {
PEEK_CHAR(c, cptr, cbuf_end, cbuf_type);
+ if (s->ignore_case)
+ c = lre_canonicalize(c, s->is_unicode);
v2 = is_word_char(c);
}
if (v1 ^ v2 ^ (REOP_not_word_boundary - opcode))
re_flags = lre_get_flags(bc_buf);
s->multi_line = (re_flags & LRE_FLAG_MULTILINE) != 0;
s->ignore_case = (re_flags & LRE_FLAG_IGNORECASE) != 0;
- s->is_unicode = (re_flags & LRE_FLAG_UNICODE) != 0;
+ s->is_unicode = (re_flags & (LRE_FLAG_UNICODE | LRE_FLAG_UNICODE_SETS)) != 0;
s->capture_count = bc_buf[RE_HEADER_CAPTURE_COUNT];
s->stack_size_max = bc_buf[RE_HEADER_STACK_SIZE];
s->cbuf = cbuf;
int lre_get_flags(const uint8_t *bc_buf)
{
- return bc_buf[RE_HEADER_FLAGS];
+ return get_u16(bc_buf + RE_HEADER_FLAGS);
}
/* Return NULL if no group names. Otherwise, return a pointer to
0x4f, 0xff,
};
+static const uint8_t unicode_prop_Basic_Emoji1_table[143] = {
+ 0x60, 0x23, 0x19, 0x81, 0x40, 0xcc, 0x1a, 0x01,
+ 0x80, 0x42, 0x08, 0x81, 0x94, 0x81, 0xb1, 0x8b,
+ 0xaa, 0x80, 0x92, 0x80, 0x8c, 0x07, 0x81, 0x90,
+ 0x0c, 0x0f, 0x04, 0x80, 0x94, 0x06, 0x08, 0x03,
+ 0x01, 0x06, 0x03, 0x81, 0x9b, 0x80, 0xa2, 0x00,
+ 0x03, 0x10, 0x80, 0xbc, 0x82, 0x97, 0x80, 0x8d,
+ 0x80, 0x43, 0x5a, 0x81, 0xb2, 0x03, 0x80, 0x61,
+ 0xc4, 0xad, 0x80, 0x40, 0xc9, 0x80, 0x40, 0xbd,
+ 0x01, 0x89, 0xe5, 0x80, 0x97, 0x80, 0x93, 0x01,
+ 0x20, 0x82, 0x94, 0x81, 0x40, 0xad, 0xa0, 0x8b,
+ 0x88, 0x80, 0xc5, 0x80, 0x95, 0x8b, 0xaa, 0x1c,
+ 0x8b, 0x90, 0x10, 0x82, 0xc6, 0x00, 0x80, 0x40,
+ 0xba, 0x81, 0xbe, 0x8c, 0x18, 0x97, 0x91, 0x80,
+ 0x99, 0x81, 0x8c, 0x80, 0xd5, 0xd4, 0xaf, 0xc5,
+ 0x28, 0x12, 0x0a, 0x1b, 0x8a, 0x0e, 0x88, 0x40,
+ 0xe2, 0x8b, 0x18, 0x41, 0x1a, 0xae, 0x80, 0x89,
+ 0x80, 0x40, 0xb8, 0xef, 0x8c, 0x82, 0x89, 0x84,
+ 0xb7, 0x86, 0x8e, 0x81, 0x8a, 0x85, 0x88,
+};
+
+static const uint8_t unicode_prop_Basic_Emoji2_table[183] = {
+ 0x40, 0xa8, 0x03, 0x80, 0x5f, 0x8c, 0x80, 0x8b,
+ 0x80, 0x40, 0xd7, 0x80, 0x95, 0x80, 0xd9, 0x85,
+ 0x8e, 0x81, 0x41, 0x7c, 0x80, 0x40, 0xa5, 0x80,
+ 0x9c, 0x10, 0x0c, 0x82, 0x40, 0xc6, 0x80, 0x40,
+ 0xe6, 0x81, 0x89, 0x80, 0x88, 0x80, 0xb9, 0x0a,
+ 0x84, 0x88, 0x01, 0x05, 0x03, 0x01, 0x00, 0x09,
+ 0x02, 0x02, 0x0f, 0x14, 0x00, 0x80, 0x9b, 0x09,
+ 0x00, 0x08, 0x80, 0x91, 0x01, 0x80, 0x92, 0x00,
+ 0x18, 0x00, 0x0a, 0x05, 0x07, 0x81, 0x95, 0x05,
+ 0x00, 0x00, 0x80, 0x94, 0x05, 0x09, 0x01, 0x17,
+ 0x04, 0x09, 0x08, 0x01, 0x00, 0x00, 0x05, 0x02,
+ 0x80, 0x90, 0x81, 0x8e, 0x01, 0x80, 0x9a, 0x81,
+ 0xbb, 0x80, 0x41, 0x91, 0x81, 0x41, 0xce, 0x82,
+ 0x45, 0x27, 0x80, 0x8b, 0x80, 0x42, 0x58, 0x00,
+ 0x80, 0x61, 0xbe, 0xd5, 0x81, 0x8b, 0x81, 0x40,
+ 0x81, 0x80, 0xb3, 0x80, 0x40, 0xe8, 0x01, 0x88,
+ 0x88, 0x80, 0xc5, 0x80, 0x97, 0x08, 0x11, 0x81,
+ 0xaa, 0x1c, 0x8b, 0x92, 0x00, 0x00, 0x80, 0xc6,
+ 0x00, 0x80, 0x40, 0xba, 0x80, 0xca, 0x81, 0xa3,
+ 0x09, 0x86, 0x8c, 0x01, 0x19, 0x80, 0x93, 0x01,
+ 0x07, 0x81, 0x88, 0x04, 0x82, 0x8b, 0x17, 0x11,
+ 0x00, 0x03, 0x05, 0x02, 0x05, 0x80, 0x40, 0xcf,
+ 0x00, 0x82, 0x8f, 0x2a, 0x05, 0x01, 0x80,
+};
+
+static const uint8_t unicode_prop_RGI_Emoji_Modifier_Sequence_table[73] = {
+ 0x60, 0x26, 0x1c, 0x80, 0x40, 0xda, 0x80, 0x8f,
+ 0x83, 0x61, 0xcc, 0x76, 0x80, 0xbb, 0x11, 0x01,
+ 0x82, 0xf4, 0x09, 0x8a, 0x94, 0x18, 0x18, 0x88,
+ 0x10, 0x1a, 0x02, 0x30, 0x00, 0x97, 0x80, 0x40,
+ 0xc8, 0x0b, 0x80, 0x94, 0x03, 0x81, 0x40, 0xad,
+ 0x12, 0x84, 0xd2, 0x80, 0x8f, 0x82, 0x88, 0x80,
+ 0x8a, 0x80, 0x42, 0x3e, 0x01, 0x07, 0x3d, 0x80,
+ 0x88, 0x89, 0x11, 0xb7, 0x80, 0xbc, 0x08, 0x08,
+ 0x80, 0x90, 0x10, 0x8c, 0x40, 0xe4, 0x82, 0xa9,
+ 0x88,
+};
+
+static const uint8_t unicode_prop_RGI_Emoji_Flag_Sequence_table[128] = {
+ 0x0c, 0x00, 0x09, 0x00, 0x04, 0x01, 0x02, 0x06,
+ 0x03, 0x03, 0x01, 0x02, 0x01, 0x03, 0x07, 0x0d,
+ 0x18, 0x00, 0x09, 0x00, 0x00, 0x89, 0x08, 0x00,
+ 0x00, 0x81, 0x88, 0x83, 0x8c, 0x10, 0x00, 0x01,
+ 0x07, 0x08, 0x29, 0x10, 0x28, 0x00, 0x80, 0x8a,
+ 0x00, 0x0a, 0x00, 0x0e, 0x15, 0x18, 0x83, 0x89,
+ 0x06, 0x00, 0x81, 0x8d, 0x00, 0x12, 0x08, 0x00,
+ 0x03, 0x00, 0x24, 0x00, 0x05, 0x21, 0x00, 0x00,
+ 0x29, 0x90, 0x00, 0x02, 0x00, 0x08, 0x09, 0x00,
+ 0x08, 0x18, 0x8b, 0x80, 0x8c, 0x02, 0x19, 0x1a,
+ 0x11, 0x00, 0x00, 0x80, 0x9c, 0x80, 0x88, 0x02,
+ 0x00, 0x00, 0x02, 0x20, 0x88, 0x0a, 0x00, 0x03,
+ 0x01, 0x02, 0x05, 0x08, 0x00, 0x01, 0x09, 0x20,
+ 0x21, 0x18, 0x22, 0x00, 0x00, 0x00, 0x00, 0x18,
+ 0x28, 0x89, 0x80, 0x8b, 0x80, 0x90, 0x80, 0x92,
+ 0x80, 0x8d, 0x05, 0x80, 0x8a, 0x80, 0x88, 0x80,
+};
+
+static const uint8_t unicode_prop_Emoji_Keycap_Sequence_table[4] = {
+ 0xa2, 0x05, 0x04, 0x89,
+};
+
static const uint8_t unicode_prop_ASCII_Hex_Digit_table[5] = {
0xaf, 0x89, 0x35, 0x99, 0x85,
};
UNICODE_PROP_Changes_When_Titlecased1,
UNICODE_PROP_Changes_When_Casefolded1,
UNICODE_PROP_Changes_When_NFKC_Casefolded1,
+ UNICODE_PROP_Basic_Emoji1,
+ UNICODE_PROP_Basic_Emoji2,
+ UNICODE_PROP_RGI_Emoji_Modifier_Sequence,
+ UNICODE_PROP_RGI_Emoji_Flag_Sequence,
+ UNICODE_PROP_Emoji_Keycap_Sequence,
UNICODE_PROP_ASCII_Hex_Digit,
UNICODE_PROP_Bidi_Control,
UNICODE_PROP_Dash,
unicode_prop_Changes_When_Titlecased1_table,
unicode_prop_Changes_When_Casefolded1_table,
unicode_prop_Changes_When_NFKC_Casefolded1_table,
+ unicode_prop_Basic_Emoji1_table,
+ unicode_prop_Basic_Emoji2_table,
+ unicode_prop_RGI_Emoji_Modifier_Sequence_table,
+ unicode_prop_RGI_Emoji_Flag_Sequence_table,
+ unicode_prop_Emoji_Keycap_Sequence_table,
unicode_prop_ASCII_Hex_Digit_table,
unicode_prop_Bidi_Control_table,
unicode_prop_Dash_table,
countof(unicode_prop_Changes_When_Titlecased1_table),
countof(unicode_prop_Changes_When_Casefolded1_table),
countof(unicode_prop_Changes_When_NFKC_Casefolded1_table),
+ countof(unicode_prop_Basic_Emoji1_table),
+ countof(unicode_prop_Basic_Emoji2_table),
+ countof(unicode_prop_RGI_Emoji_Modifier_Sequence_table),
+ countof(unicode_prop_RGI_Emoji_Flag_Sequence_table),
+ countof(unicode_prop_Emoji_Keycap_Sequence_table),
countof(unicode_prop_ASCII_Hex_Digit_table),
countof(unicode_prop_Bidi_Control_table),
countof(unicode_prop_Dash_table),
countof(unicode_prop_Case_Ignorable_table),
};
+typedef enum {
+ UNICODE_SEQUENCE_PROP_Basic_Emoji,
+ UNICODE_SEQUENCE_PROP_Emoji_Keycap_Sequence,
+ UNICODE_SEQUENCE_PROP_RGI_Emoji_Modifier_Sequence,
+ UNICODE_SEQUENCE_PROP_RGI_Emoji_Flag_Sequence,
+ UNICODE_SEQUENCE_PROP_RGI_Emoji_Tag_Sequence,
+ UNICODE_SEQUENCE_PROP_RGI_Emoji_ZWJ_Sequence,
+ UNICODE_SEQUENCE_PROP_RGI_Emoji,
+ UNICODE_SEQUENCE_PROP_COUNT,
+} UnicodeSequencePropertyEnum;
+
+static const char unicode_sequence_prop_name_table[] =
+ "Basic_Emoji" "\0"
+ "Emoji_Keycap_Sequence" "\0"
+ "RGI_Emoji_Modifier_Sequence" "\0"
+ "RGI_Emoji_Flag_Sequence" "\0"
+ "RGI_Emoji_Tag_Sequence" "\0"
+ "RGI_Emoji_ZWJ_Sequence" "\0"
+ "RGI_Emoji" "\0"
+;
+
+static const uint8_t unicode_rgi_emoji_tag_sequence[18] = {
+ 0x67, 0x62, 0x65, 0x6e, 0x67, 0x00, 0x67, 0x62,
+ 0x73, 0x63, 0x74, 0x00, 0x67, 0x62, 0x77, 0x6c,
+ 0x73, 0x00,
+};
+
+static const uint8_t unicode_rgi_emoji_zwj_sequence[2320] = {
+ 0x02, 0xb8, 0x19, 0x40, 0x86, 0x02, 0xd1, 0x39,
+ 0xb0, 0x19, 0x02, 0x26, 0x39, 0x42, 0x86, 0x02,
+ 0xb4, 0x36, 0x42, 0x86, 0x03, 0x68, 0x54, 0x64,
+ 0x87, 0x68, 0x54, 0x02, 0xdc, 0x39, 0x42, 0x86,
+ 0x02, 0xd1, 0x39, 0x73, 0x13, 0x02, 0x39, 0x39,
+ 0x40, 0x86, 0x02, 0x69, 0x34, 0xbd, 0x19, 0x03,
+ 0xb6, 0x36, 0x40, 0x86, 0xa1, 0x87, 0x03, 0x68,
+ 0x74, 0x1d, 0x19, 0x68, 0x74, 0x03, 0x68, 0x34,
+ 0xbd, 0x19, 0xa1, 0x87, 0x02, 0xf1, 0x7a, 0xf2,
+ 0x7a, 0x02, 0xca, 0x33, 0x42, 0x86, 0x02, 0x69,
+ 0x34, 0xb0, 0x19, 0x04, 0x68, 0x14, 0x68, 0x14,
+ 0x67, 0x14, 0x66, 0x14, 0x02, 0xf9, 0x26, 0x42,
+ 0x86, 0x03, 0x69, 0x74, 0x1d, 0x19, 0x69, 0x74,
+ 0x03, 0xd1, 0x19, 0xbc, 0x19, 0xa1, 0x87, 0x02,
+ 0x3c, 0x19, 0x40, 0x86, 0x02, 0x68, 0x34, 0xeb,
+ 0x13, 0x02, 0xc3, 0x33, 0xa1, 0x87, 0x02, 0x70,
+ 0x34, 0x40, 0x86, 0x02, 0xd4, 0x39, 0x42, 0x86,
+ 0x02, 0xcf, 0x39, 0x42, 0x86, 0x02, 0x47, 0x36,
+ 0x40, 0x86, 0x02, 0x39, 0x39, 0x42, 0x86, 0x04,
+ 0xd1, 0x79, 0x64, 0x87, 0x8b, 0x14, 0xd1, 0x79,
+ 0x02, 0xd1, 0x39, 0x95, 0x86, 0x02, 0x68, 0x34,
+ 0x93, 0x13, 0x02, 0x69, 0x34, 0xed, 0x13, 0x02,
+ 0xda, 0x39, 0x40, 0x86, 0x03, 0x69, 0x34, 0xaf,
+ 0x19, 0xa1, 0x87, 0x02, 0xd1, 0x39, 0x93, 0x13,
+ 0x03, 0xce, 0x39, 0x42, 0x86, 0xa1, 0x87, 0x03,
+ 0xd1, 0x79, 0x64, 0x87, 0xd1, 0x79, 0x03, 0xc3,
+ 0x33, 0x42, 0x86, 0xa1, 0x87, 0x03, 0x69, 0x74,
+ 0x1d, 0x19, 0x68, 0x74, 0x02, 0x69, 0x34, 0x92,
+ 0x16, 0x02, 0xd1, 0x39, 0x96, 0x86, 0x04, 0x69,
+ 0x14, 0x64, 0x87, 0x8b, 0x14, 0x68, 0x14, 0x02,
+ 0x68, 0x34, 0x7c, 0x13, 0x02, 0x47, 0x36, 0x42,
+ 0x86, 0x02, 0x86, 0x34, 0x42, 0x86, 0x02, 0xd1,
+ 0x39, 0x7c, 0x13, 0x02, 0x69, 0x14, 0xa4, 0x13,
+ 0x02, 0xda, 0x39, 0x42, 0x86, 0x02, 0x37, 0x39,
+ 0x40, 0x86, 0x02, 0xd1, 0x39, 0x08, 0x87, 0x04,
+ 0x68, 0x54, 0x64, 0x87, 0x8b, 0x14, 0x68, 0x54,
+ 0x02, 0x4d, 0x36, 0x40, 0x86, 0x02, 0x68, 0x34,
+ 0x2c, 0x15, 0x02, 0x69, 0x34, 0xaf, 0x19, 0x02,
+ 0x6e, 0x34, 0x40, 0x86, 0x02, 0xcd, 0x39, 0x42,
+ 0x86, 0x02, 0xd1, 0x39, 0x2c, 0x15, 0x02, 0x6f,
+ 0x14, 0x40, 0x86, 0x03, 0xd1, 0x39, 0xbc, 0x19,
+ 0xa1, 0x87, 0x02, 0x68, 0x34, 0xa8, 0x13, 0x02,
+ 0x69, 0x34, 0x73, 0x13, 0x04, 0x69, 0x54, 0x64,
+ 0x87, 0x8b, 0x14, 0x68, 0x54, 0x02, 0x71, 0x34,
+ 0x42, 0x86, 0x02, 0xd1, 0x39, 0xa8, 0x13, 0x02,
+ 0x45, 0x36, 0x40, 0x86, 0x03, 0x69, 0x54, 0x64,
+ 0x87, 0x68, 0x54, 0x03, 0x69, 0x54, 0x64, 0x87,
+ 0x69, 0x54, 0x03, 0xce, 0x39, 0x40, 0x86, 0xa1,
+ 0x87, 0x02, 0xd8, 0x39, 0x40, 0x86, 0x03, 0xc3,
+ 0x33, 0x40, 0x86, 0xa1, 0x87, 0x02, 0x4d, 0x36,
+ 0x42, 0x86, 0x02, 0xd1, 0x19, 0x92, 0x16, 0x02,
+ 0xd1, 0x39, 0xeb, 0x13, 0x02, 0x68, 0x34, 0xbc,
+ 0x14, 0x02, 0xd1, 0x39, 0xbc, 0x14, 0x02, 0x3d,
+ 0x39, 0x40, 0x86, 0x02, 0xb8, 0x39, 0x42, 0x86,
+ 0x02, 0xa3, 0x36, 0x40, 0x86, 0x02, 0x75, 0x35,
+ 0x40, 0x86, 0x02, 0xd8, 0x39, 0x42, 0x86, 0x02,
+ 0x69, 0x34, 0x93, 0x13, 0x02, 0x35, 0x39, 0x40,
+ 0x86, 0x02, 0x4b, 0x36, 0x40, 0x86, 0x02, 0x3d,
+ 0x39, 0x42, 0x86, 0x02, 0x38, 0x39, 0x42, 0x86,
+ 0x02, 0xa3, 0x36, 0x42, 0x86, 0x03, 0x69, 0x14,
+ 0x67, 0x14, 0x67, 0x14, 0x02, 0xb6, 0x36, 0x40,
+ 0x86, 0x02, 0x69, 0x34, 0x7c, 0x13, 0x02, 0x75,
+ 0x35, 0x42, 0x86, 0x02, 0xcc, 0x93, 0x40, 0x86,
+ 0x02, 0xcc, 0x33, 0x40, 0x86, 0x03, 0xd1, 0x39,
+ 0xbd, 0x19, 0xa1, 0x87, 0x02, 0x82, 0x34, 0x40,
+ 0x86, 0x02, 0x87, 0x34, 0x40, 0x86, 0x02, 0x69,
+ 0x14, 0x3e, 0x13, 0x02, 0xd6, 0x39, 0x40, 0x86,
+ 0x02, 0x68, 0x14, 0xbd, 0x19, 0x02, 0x46, 0x36,
+ 0x42, 0x86, 0x02, 0x4b, 0x36, 0x42, 0x86, 0x02,
+ 0x69, 0x34, 0x2c, 0x15, 0x03, 0xb6, 0x36, 0x42,
+ 0x86, 0xa1, 0x87, 0x02, 0xc4, 0x33, 0x40, 0x86,
+ 0x02, 0x26, 0x19, 0x40, 0x86, 0x02, 0x69, 0x14,
+ 0xb0, 0x19, 0x02, 0xde, 0x19, 0x42, 0x86, 0x02,
+ 0x69, 0x34, 0xa8, 0x13, 0x02, 0xcc, 0x33, 0x42,
+ 0x86, 0x02, 0x82, 0x34, 0x42, 0x86, 0x02, 0xd1,
+ 0x19, 0x93, 0x13, 0x02, 0x81, 0x14, 0x42, 0x86,
+ 0x02, 0x69, 0x34, 0x95, 0x86, 0x02, 0x68, 0x34,
+ 0xbb, 0x14, 0x02, 0xd1, 0x39, 0xbb, 0x14, 0x02,
+ 0x69, 0x34, 0xeb, 0x13, 0x02, 0xd1, 0x39, 0x84,
+ 0x13, 0x02, 0x69, 0x34, 0xbc, 0x14, 0x04, 0x69,
+ 0x54, 0x64, 0x87, 0x8b, 0x14, 0x69, 0x54, 0x02,
+ 0x26, 0x39, 0x40, 0x86, 0x02, 0xb4, 0x36, 0x40,
+ 0x86, 0x02, 0x47, 0x16, 0x42, 0x86, 0x02, 0xdc,
+ 0x39, 0x40, 0x86, 0x02, 0xca, 0x33, 0x40, 0x86,
+ 0x02, 0xf9, 0x26, 0x40, 0x86, 0x02, 0x69, 0x34,
+ 0x08, 0x87, 0x03, 0x69, 0x14, 0x69, 0x14, 0x66,
+ 0x14, 0x03, 0xd1, 0x59, 0x1d, 0x19, 0xd1, 0x59,
+ 0x02, 0xd4, 0x39, 0x40, 0x86, 0x02, 0xcf, 0x39,
+ 0x40, 0x86, 0x02, 0x68, 0x34, 0xa4, 0x13, 0x02,
+ 0xd1, 0x39, 0xa4, 0x13, 0x02, 0xd1, 0x19, 0xa8,
+ 0x13, 0x02, 0xd7, 0x39, 0x42, 0x86, 0x03, 0x69,
+ 0x34, 0xbc, 0x19, 0xa1, 0x87, 0x02, 0x68, 0x14,
+ 0xb0, 0x19, 0x02, 0x68, 0x14, 0x73, 0x13, 0x04,
+ 0x69, 0x14, 0x69, 0x14, 0x66, 0x14, 0x66, 0x14,
+ 0x03, 0x68, 0x34, 0xaf, 0x19, 0xa1, 0x87, 0x02,
+ 0x68, 0x34, 0x80, 0x16, 0x02, 0x73, 0x34, 0x42,
+ 0x86, 0x02, 0xd1, 0x39, 0x80, 0x16, 0x02, 0x68,
+ 0x34, 0xb0, 0x19, 0x02, 0x86, 0x34, 0x40, 0x86,
+ 0x02, 0x38, 0x19, 0x42, 0x86, 0x02, 0x69, 0x34,
+ 0xbb, 0x14, 0x02, 0xb5, 0x36, 0x42, 0x86, 0x02,
+ 0xcd, 0x39, 0x40, 0x86, 0x02, 0x68, 0x34, 0x95,
+ 0x86, 0x02, 0x68, 0x34, 0x27, 0x15, 0x03, 0x68,
+ 0x14, 0x68, 0x14, 0x66, 0x14, 0x02, 0x71, 0x34,
+ 0x40, 0x86, 0x02, 0xd1, 0x39, 0x27, 0x15, 0x02,
+ 0x2e, 0x16, 0xa8, 0x14, 0x02, 0xc3, 0x33, 0x42,
+ 0x86, 0x02, 0x69, 0x14, 0x66, 0x14, 0x02, 0x68,
+ 0x34, 0x96, 0x86, 0x02, 0x69, 0x34, 0xa4, 0x13,
+ 0x03, 0x69, 0x14, 0x64, 0x87, 0x68, 0x14, 0x02,
+ 0xb8, 0x39, 0x40, 0x86, 0x02, 0x68, 0x34, 0x3e,
+ 0x13, 0x03, 0xd1, 0x19, 0xaf, 0x19, 0xa1, 0x87,
+ 0x02, 0xd1, 0x39, 0x3e, 0x13, 0x02, 0x68, 0x34,
+ 0xbd, 0x19, 0x02, 0xd1, 0x19, 0xbb, 0x14, 0x02,
+ 0xd1, 0x19, 0x95, 0x86, 0x02, 0xdb, 0x39, 0x42,
+ 0x86, 0x02, 0x38, 0x39, 0x40, 0x86, 0x02, 0x69,
+ 0x34, 0x80, 0x16, 0x02, 0x69, 0x14, 0xeb, 0x13,
+ 0x04, 0x68, 0x14, 0x69, 0x14, 0x67, 0x14, 0x67,
+ 0x14, 0x02, 0x77, 0x34, 0x42, 0x86, 0x02, 0x46,
+ 0x36, 0x40, 0x86, 0x02, 0x68, 0x34, 0x92, 0x16,
+ 0x02, 0x4e, 0x36, 0x42, 0x86, 0x03, 0x69, 0x14,
+ 0xbd, 0x19, 0xa1, 0x87, 0x02, 0xde, 0x19, 0x40,
+ 0x86, 0x02, 0x69, 0x34, 0x27, 0x15, 0x03, 0xc3,
+ 0x13, 0x40, 0x86, 0xa1, 0x87, 0x02, 0x81, 0x14,
+ 0x40, 0x86, 0x03, 0xd1, 0x39, 0xaf, 0x19, 0xa1,
+ 0x87, 0x02, 0x68, 0x34, 0xbc, 0x19, 0x02, 0xd1,
+ 0x19, 0x80, 0x16, 0x02, 0xd9, 0x39, 0x42, 0x86,
+ 0x02, 0xd1, 0x39, 0xbc, 0x19, 0x02, 0xdc, 0x19,
+ 0x42, 0x86, 0x02, 0x68, 0x34, 0x73, 0x13, 0x02,
+ 0x69, 0x34, 0x3e, 0x13, 0x02, 0x47, 0x16, 0x40,
+ 0x86, 0x02, 0xd1, 0x39, 0xbd, 0x19, 0x02, 0x3e,
+ 0x39, 0x42, 0x86, 0x02, 0x69, 0x14, 0x95, 0x86,
+ 0x02, 0x68, 0x14, 0x96, 0x86, 0x03, 0x69, 0x34,
+ 0xbd, 0x19, 0xa1, 0x87, 0x02, 0xd7, 0x39, 0x40,
+ 0x86, 0x02, 0x45, 0x16, 0x42, 0x86, 0x02, 0x68,
+ 0x34, 0xed, 0x13, 0x03, 0x68, 0x34, 0xbc, 0x19,
+ 0xa1, 0x87, 0x02, 0xd1, 0x39, 0xed, 0x13, 0x02,
+ 0xd1, 0x39, 0x92, 0x16, 0x02, 0x73, 0x34, 0x40,
+ 0x86, 0x02, 0x38, 0x19, 0x40, 0x86, 0x02, 0xb5,
+ 0x36, 0x40, 0x86, 0x02, 0x68, 0x34, 0xaf, 0x19,
+ 0x02, 0xd1, 0x39, 0xaf, 0x19, 0x02, 0x69, 0x34,
+ 0xbc, 0x19, 0x02, 0xb6, 0x16, 0x42, 0x86, 0x02,
+ 0x26, 0x14, 0x25, 0x15, 0x02, 0xc3, 0x33, 0x40,
+ 0x86, 0x02, 0xdd, 0x39, 0x42, 0x86, 0x02, 0xcb,
+ 0x93, 0x42, 0x86, 0x02, 0xcb, 0x33, 0x42, 0x86,
+ 0x02, 0x81, 0x34, 0x42, 0x86, 0x02, 0xce, 0x39,
+ 0xa1, 0x87, 0x02, 0xdb, 0x39, 0x40, 0x86, 0x02,
+ 0x68, 0x34, 0x08, 0x87, 0x02, 0xd1, 0x19, 0xb0,
+ 0x19, 0x02, 0x77, 0x34, 0x40, 0x86, 0x02, 0x4e,
+ 0x36, 0x40, 0x86, 0x02, 0xce, 0x39, 0x42, 0x86,
+ 0x02, 0x4e, 0x16, 0x42, 0x86, 0x02, 0xd9, 0x39,
+ 0x40, 0x86, 0x02, 0xdc, 0x19, 0x40, 0x86, 0x02,
+ 0x3e, 0x39, 0x40, 0x86, 0x02, 0xb9, 0x39, 0x42,
+ 0x86, 0x02, 0xda, 0x19, 0x42, 0x86, 0x02, 0x42,
+ 0x16, 0x94, 0x81, 0x02, 0x45, 0x16, 0x40, 0x86,
+ 0x02, 0x69, 0x14, 0xbd, 0x19, 0x02, 0x70, 0x34,
+ 0x42, 0x86, 0x02, 0xce, 0x19, 0xa1, 0x87, 0x02,
+ 0xc3, 0x13, 0x42, 0x86, 0x02, 0x68, 0x14, 0x08,
+ 0x87, 0x02, 0xd1, 0x19, 0x7c, 0x13, 0x02, 0x68,
+ 0x14, 0x92, 0x16, 0x02, 0xb6, 0x16, 0x40, 0x86,
+ 0x02, 0x37, 0x39, 0x42, 0x86, 0x03, 0xce, 0x19,
+ 0x42, 0x86, 0xa1, 0x87, 0x03, 0x68, 0x14, 0x67,
+ 0x14, 0x67, 0x14, 0x02, 0xdd, 0x39, 0x40, 0x86,
+ 0x02, 0xcf, 0x19, 0x42, 0x86, 0x02, 0xd1, 0x19,
+ 0x2c, 0x15, 0x02, 0x4b, 0x13, 0xe9, 0x17, 0x02,
+ 0x68, 0x14, 0x67, 0x14, 0x02, 0xcb, 0x93, 0x40,
+ 0x86, 0x02, 0x6e, 0x34, 0x42, 0x86, 0x02, 0xcb,
+ 0x33, 0x40, 0x86, 0x02, 0x81, 0x34, 0x40, 0x86,
+ 0x02, 0xb6, 0x36, 0xa1, 0x87, 0x02, 0x45, 0x36,
+ 0x42, 0x86, 0x02, 0xb4, 0x16, 0x42, 0x86, 0x02,
+ 0x69, 0x14, 0x73, 0x13, 0x04, 0x69, 0x14, 0x69,
+ 0x14, 0x67, 0x14, 0x66, 0x14, 0x02, 0x35, 0x39,
+ 0x42, 0x86, 0x02, 0x68, 0x14, 0x93, 0x13, 0x02,
+ 0xb6, 0x36, 0x42, 0x86, 0x03, 0x68, 0x14, 0x69,
+ 0x14, 0x66, 0x14, 0x02, 0xce, 0x39, 0x40, 0x86,
+ 0x02, 0x4e, 0x16, 0x40, 0x86, 0x02, 0x87, 0x34,
+ 0x42, 0x86, 0x02, 0x86, 0x14, 0x42, 0x86, 0x02,
+ 0xd6, 0x39, 0x42, 0x86, 0x02, 0xc4, 0x33, 0x42,
+ 0x86, 0x02, 0x69, 0x34, 0x96, 0x86, 0x02, 0xb9,
+ 0x39, 0x40, 0x86, 0x02, 0x68, 0x14, 0xa8, 0x13,
+ 0x02, 0xd1, 0x19, 0x84, 0x13, 0x02, 0xda, 0x19,
+ 0x40, 0x86, 0x02, 0xd8, 0x19, 0x42, 0x86, 0x02,
+ 0xc3, 0x13, 0x40, 0x86, 0x02, 0xb9, 0x19, 0x42,
+ 0x86, 0x02, 0x3d, 0x19, 0x42, 0x86, 0x02, 0xcf,
+ 0x19, 0x40, 0x86, 0x04, 0x68, 0x14, 0x68, 0x14,
+ 0x67, 0x14, 0x67, 0x14, 0x03, 0xd1, 0x19, 0xd1,
+ 0x19, 0xd2, 0x19, 0x02, 0x68, 0x14, 0xbb, 0x14,
+ 0x02, 0x3b, 0x14, 0x44, 0x87, 0x02, 0xd1, 0x19,
+ 0x27, 0x15, 0x02, 0xb4, 0x16, 0x40, 0x86, 0x02,
+ 0xcd, 0x19, 0x42, 0x86, 0x02, 0xd3, 0x86, 0xa5,
+ 0x14, 0x02, 0x70, 0x14, 0x42, 0x86, 0x03, 0xb6,
+ 0x16, 0x42, 0x86, 0xa1, 0x87, 0x04, 0x69, 0x14,
+ 0x64, 0x87, 0x8b, 0x14, 0x69, 0x14, 0x02, 0x36,
+ 0x16, 0x2b, 0x93, 0x02, 0x68, 0x14, 0x80, 0x16,
+ 0x02, 0x86, 0x14, 0x40, 0x86, 0x02, 0x08, 0x14,
+ 0x1b, 0x0b, 0x02, 0xd1, 0x19, 0xbc, 0x19, 0x02,
+ 0xca, 0x13, 0x42, 0x86, 0x02, 0x41, 0x94, 0xe8,
+ 0x95, 0x02, 0xd8, 0x19, 0x40, 0x86, 0x02, 0xb9,
+ 0x19, 0x40, 0x86, 0x02, 0xd1, 0x19, 0xed, 0x13,
+ 0x02, 0xf9, 0x86, 0x42, 0x86, 0x03, 0xd1, 0x19,
+ 0xbd, 0x19, 0xa1, 0x87, 0x02, 0x3d, 0x19, 0x40,
+ 0x86, 0x02, 0xd6, 0x19, 0x42, 0x86, 0x03, 0x69,
+ 0x14, 0x66, 0x14, 0x66, 0x14, 0x02, 0xd1, 0x19,
+ 0xaf, 0x19, 0x03, 0x69, 0x14, 0x69, 0x14, 0x67,
+ 0x14, 0x02, 0xcd, 0x19, 0x40, 0x86, 0x02, 0x70,
+ 0x14, 0x40, 0x86, 0x03, 0x68, 0x14, 0xbc, 0x19,
+ 0xa1, 0x87, 0x02, 0x6e, 0x14, 0x42, 0x86, 0x02,
+ 0x69, 0x14, 0x92, 0x16, 0x03, 0x68, 0x14, 0x68,
+ 0x14, 0x67, 0x14, 0x02, 0x69, 0x14, 0x67, 0x14,
+ 0x02, 0x75, 0x95, 0x42, 0x86, 0x03, 0x69, 0x14,
+ 0x64, 0x87, 0x69, 0x14, 0x02, 0xd1, 0x19, 0xbc,
+ 0x14, 0x02, 0xdf, 0x19, 0x42, 0x86, 0x02, 0xca,
+ 0x13, 0x40, 0x86, 0x02, 0x82, 0x14, 0x42, 0x86,
+ 0x02, 0x69, 0x14, 0x93, 0x13, 0x02, 0x68, 0x14,
+ 0x7c, 0x13, 0x02, 0xf9, 0x86, 0x40, 0x86, 0x02,
+ 0xd6, 0x19, 0x40, 0x86, 0x02, 0x68, 0x14, 0x2c,
+ 0x15, 0x02, 0x69, 0x14, 0xa8, 0x13, 0x02, 0xd4,
+ 0x19, 0x42, 0x86, 0x04, 0x68, 0x14, 0x69, 0x14,
+ 0x66, 0x14, 0x66, 0x14, 0x02, 0x77, 0x14, 0x42,
+ 0x86, 0x02, 0x39, 0x19, 0x42, 0x86, 0x02, 0xd1,
+ 0x19, 0xa4, 0x13, 0x02, 0x6e, 0x14, 0x40, 0x86,
+ 0x03, 0xd1, 0x19, 0xd2, 0x19, 0xd2, 0x19, 0x02,
+ 0x69, 0x14, 0xbb, 0x14, 0x02, 0xd1, 0x19, 0x96,
+ 0x86, 0x02, 0x75, 0x95, 0x40, 0x86, 0x04, 0x68,
+ 0x14, 0x64, 0x87, 0x8b, 0x14, 0x68, 0x14, 0x02,
+ 0xd1, 0x19, 0x3e, 0x13, 0x02, 0xdf, 0x19, 0x40,
+ 0x86, 0x02, 0x82, 0x14, 0x40, 0x86, 0x02, 0x44,
+ 0x13, 0xeb, 0x17, 0x02, 0xdd, 0x19, 0x42, 0x86,
+ 0x02, 0x69, 0x14, 0x80, 0x16, 0x03, 0x68, 0x14,
+ 0xaf, 0x19, 0xa1, 0x87, 0x02, 0xa3, 0x16, 0x42,
+ 0x86, 0x02, 0x69, 0x14, 0x96, 0x86, 0x02, 0x46,
+ 0x16, 0x42, 0x86, 0x02, 0xb6, 0x16, 0xa1, 0x87,
+ 0x02, 0x68, 0x14, 0x27, 0x15, 0x02, 0x26, 0x14,
+ 0x1b, 0x0b, 0x02, 0xd4, 0x19, 0x40, 0x86, 0x02,
+ 0x77, 0x14, 0x40, 0x86, 0x02, 0x39, 0x19, 0x40,
+ 0x86, 0x02, 0x37, 0x19, 0x42, 0x86, 0x03, 0x69,
+ 0x14, 0x67, 0x14, 0x66, 0x14, 0x03, 0xc3, 0x13,
+ 0x42, 0x86, 0xa1, 0x87, 0x02, 0x68, 0x14, 0xbc,
+ 0x19, 0x02, 0xd1, 0x19, 0xeb, 0x13, 0x04, 0x69,
+ 0x14, 0x69, 0x14, 0x67, 0x14, 0x67, 0x14, 0x02,
+ 0xd1, 0x19, 0x08, 0x87, 0x02, 0x68, 0x14, 0xed,
+ 0x13, 0x03, 0x69, 0x14, 0xbc, 0x19, 0xa1, 0x87,
+ 0x02, 0xdd, 0x19, 0x40, 0x86, 0x02, 0xc3, 0x13,
+ 0xa1, 0x87, 0x03, 0x68, 0x14, 0x66, 0x14, 0x66,
+ 0x14, 0x03, 0x68, 0x14, 0x69, 0x14, 0x67, 0x14,
+ 0x02, 0xa3, 0x16, 0x40, 0x86, 0x02, 0xdb, 0x19,
+ 0x42, 0x86, 0x02, 0x68, 0x14, 0xaf, 0x19, 0x02,
+ 0x46, 0x16, 0x40, 0x86, 0x02, 0x35, 0x16, 0xab,
+ 0x14, 0x02, 0x68, 0x14, 0x95, 0x86, 0x02, 0x42,
+ 0x16, 0x95, 0x81, 0x02, 0xc4, 0x13, 0x42, 0x86,
+ 0x02, 0x15, 0x14, 0xba, 0x19, 0x02, 0x69, 0x14,
+ 0x08, 0x87, 0x03, 0xd1, 0x19, 0x1d, 0x19, 0xd1,
+ 0x19, 0x02, 0x69, 0x14, 0x7c, 0x13, 0x02, 0x37,
+ 0x19, 0x40, 0x86, 0x02, 0x73, 0x14, 0x42, 0x86,
+ 0x02, 0x69, 0x14, 0x2c, 0x15, 0x02, 0xb5, 0x16,
+ 0x42, 0x86, 0x02, 0x35, 0x19, 0x42, 0x86, 0x04,
+ 0x68, 0x14, 0x69, 0x14, 0x67, 0x14, 0x66, 0x14,
+ 0x02, 0x64, 0x87, 0x25, 0x15, 0x02, 0x64, 0x87,
+ 0x79, 0x1a, 0x02, 0x68, 0x14, 0xbc, 0x14, 0x03,
+ 0xce, 0x19, 0x40, 0x86, 0xa1, 0x87, 0x02, 0x87,
+ 0x14, 0x42, 0x86, 0x02, 0x4d, 0x16, 0x42, 0x86,
+ 0x04, 0x68, 0x14, 0x68, 0x14, 0x66, 0x14, 0x66,
+ 0x14, 0x02, 0xdb, 0x19, 0x40, 0x86, 0x02, 0xd9,
+ 0x19, 0x42, 0x86, 0x02, 0xc4, 0x13, 0x40, 0x86,
+ 0x02, 0xd1, 0x19, 0xbd, 0x19, 0x02, 0x68, 0x14,
+ 0xa4, 0x13, 0x02, 0x3e, 0x19, 0x42, 0x86, 0x02,
+ 0xf3, 0x93, 0xa7, 0x86, 0x03, 0x69, 0x14, 0xaf,
+ 0x19, 0xa1, 0x87, 0x02, 0xf3, 0x93, 0x08, 0x13,
+ 0x02, 0xd1, 0x19, 0xd2, 0x19, 0x02, 0x73, 0x14,
+ 0x40, 0x86, 0x02, 0xb5, 0x16, 0x40, 0x86, 0x02,
+ 0x35, 0x19, 0x40, 0x86, 0x02, 0x69, 0x14, 0x27,
+ 0x15, 0x02, 0xce, 0x19, 0x42, 0x86, 0x02, 0x71,
+ 0x14, 0x42, 0x86, 0x02, 0xd1, 0x19, 0x73, 0x13,
+ 0x02, 0x68, 0x14, 0x3e, 0x13, 0x02, 0xf4, 0x13,
+ 0x20, 0x86, 0x02, 0x87, 0x14, 0x40, 0x86, 0x03,
+ 0xb6, 0x16, 0x40, 0x86, 0xa1, 0x87, 0x02, 0x4d,
+ 0x16, 0x40, 0x86, 0x02, 0x69, 0x14, 0xbc, 0x19,
+ 0x02, 0x4b, 0x16, 0x42, 0x86, 0x02, 0xd9, 0x19,
+ 0x40, 0x86, 0x02, 0x3e, 0x19, 0x40, 0x86, 0x02,
+ 0x69, 0x14, 0xed, 0x13, 0x02, 0xd7, 0x19, 0x42,
+ 0x86, 0x02, 0xb8, 0x19, 0x42, 0x86, 0x03, 0x68,
+ 0x14, 0x67, 0x14, 0x66, 0x14, 0x02, 0x3c, 0x19,
+ 0x42, 0x86, 0x02, 0x68, 0x14, 0x66, 0x14, 0x03,
+ 0x68, 0x14, 0x64, 0x87, 0x68, 0x14, 0x02, 0x69,
+ 0x14, 0xaf, 0x19, 0x02, 0xce, 0x19, 0x40, 0x86,
+ 0x02, 0x71, 0x14, 0x40, 0x86, 0x02, 0x68, 0x14,
+ 0xeb, 0x13, 0x03, 0x68, 0x14, 0xbd, 0x19, 0xa1,
+ 0x87, 0x02, 0x6f, 0x14, 0x42, 0x86, 0x04, 0xd1,
+ 0x19, 0xd1, 0x19, 0xd2, 0x19, 0xd2, 0x19, 0x02,
+ 0x69, 0x14, 0xbc, 0x14, 0x02, 0xcc, 0x93, 0x42,
+ 0x86, 0x02, 0x4b, 0x16, 0x40, 0x86, 0x02, 0x26,
+ 0x19, 0x42, 0x86, 0x02, 0xd7, 0x19, 0x40, 0x86,
+};
+
#endif /* CONFIG_ALL_UNICODE */
-/* 64 tables / 33442 bytes, 5 index / 351 bytes */
+/* 71 tables / 36311 bytes, 5 index / 351 bytes */
projects / quickjs.git / commitdiff