diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -21,8 +21,8 @@ uses, and less than a tenth the memory that [pandoc] uses. - **Robustness:** cmark can handle whatever is thrown at it, - without the exponential blowups in parsing time one can sometimes - get with other libraries. (The input `bench/full-sample.md`, + without the exponential blowups in parsing time that sometimes afflict + other libraries. (The input `bench/full-sample.md`, for example, causes both [pandoc] and [markdown] to grind to a halt.) - **Accuracy:** cmark passes the CommonMark spec's suite of over diff --git a/cbits/bench.h b/cbits/bench.h new file mode 100644 --- /dev/null +++ b/cbits/bench.h @@ -0,0 +1,27 @@ +#ifndef CMARK_BENCH_H +#define CMARK_BENCH_H + +#include +#include + +#ifdef TIMER +float _cmark_start_time; +float _cmark_end_time; +float _cmark_save_time; + +#define start_timer() \ + _cmark_save_time = _cmark_start_time; \ + _cmark_start_time = (float)clock()/CLOCKS_PER_SEC + +#define end_timer(M) \ + _cmark_end_time = (float)clock()/CLOCKS_PER_SEC; \ + fprintf(stderr, "[TIME] (%s:%d) %4.f ns " M "\n", __FILE__, \ + __LINE__, (_cmark_end_time - _cmark_start_time) * 1000000); \ + _cmark_start_time = _cmark_save_time; + +#else +#define start_timer() +#define end_timer(M) +#endif + +#endif diff --git a/cbits/blocks.c b/cbits/blocks.c new file mode 100644 --- /dev/null +++ b/cbits/blocks.c @@ -0,0 +1,887 @@ +#include +#include +#include + +#include "cmark_ctype.h" +#include "config.h" +#include "parser.h" +#include "cmark.h" +#include "node.h" +#include "references.h" +#include "utf8.h" +#include "scanners.h" +#include "inlines.h" +#include "houdini.h" +#include "buffer.h" +#include "debug.h" + +#define CODE_INDENT 4 +#define peek_at(i, n) (i)->data[n] + +static void +S_parser_feed(cmark_parser *parser, const unsigned char *buffer, size_t len, + bool eof); + +static void +S_process_line(cmark_parser *parser, const unsigned char *buffer, + size_t bytes); + +static cmark_node* make_block(cmark_node_type tag, int start_line, int start_column) +{ + cmark_node* e; + + e = (cmark_node *)calloc(1, sizeof(*e)); + if(e != NULL) { + e->type = tag; + e->open = true; + e->start_line = start_line; + e->start_column = start_column; + e->end_line = start_line; + cmark_strbuf_init(&e->string_content, 32); + } + + return e; +} + +// Create a root document node. +static cmark_node* make_document() +{ + cmark_node *e = make_block(NODE_DOCUMENT, 1, 1); + return e; +} + +cmark_parser *cmark_parser_new(int options) +{ + cmark_parser *parser = (cmark_parser*)malloc(sizeof(cmark_parser)); + cmark_node *document = make_document(); + cmark_strbuf *line = (cmark_strbuf*)malloc(sizeof(cmark_strbuf)); + cmark_strbuf *buf = (cmark_strbuf*)malloc(sizeof(cmark_strbuf)); + cmark_strbuf_init(line, 256); + cmark_strbuf_init(buf, 0); + + parser->refmap = cmark_reference_map_new(); + parser->root = document; + parser->current = document; + parser->line_number = 0; + parser->curline = line; + parser->last_line_length = 0; + parser->linebuf = buf; + parser->options = options; + + return parser; +} + +void cmark_parser_free(cmark_parser *parser) +{ + cmark_strbuf_free(parser->curline); + free(parser->curline); + cmark_strbuf_free(parser->linebuf); + free(parser->linebuf); + cmark_reference_map_free(parser->refmap); + free(parser); +} + +static cmark_node* +finalize(cmark_parser *parser, cmark_node* b); + +// Returns true if line has only space characters, else false. +static bool is_blank(cmark_strbuf *s, int offset) +{ + while (offset < s->size) { + switch (s->ptr[offset]) { + case '\n': + return true; + case ' ': + offset++; + break; + default: + return false; + } + } + + return true; +} + +static inline bool can_contain(cmark_node_type parent_type, cmark_node_type child_type) +{ + return ( parent_type == NODE_DOCUMENT || + parent_type == NODE_BLOCK_QUOTE || + parent_type == NODE_ITEM || + (parent_type == NODE_LIST && child_type == NODE_ITEM) ); +} + +static inline bool accepts_lines(cmark_node_type block_type) +{ + return (block_type == NODE_PARAGRAPH || + block_type == NODE_HEADER || + block_type == NODE_CODE_BLOCK); +} + +static void add_line(cmark_node* node, cmark_chunk *ch, int offset) +{ + assert(node->open); + cmark_strbuf_put(&node->string_content, ch->data + offset, ch->len - offset); +} + +static void remove_trailing_blank_lines(cmark_strbuf *ln) +{ + int i; + + for (i = ln->size - 1; i >= 0; --i) { + unsigned char c = ln->ptr[i]; + + if (c != ' ' && c != '\t' && c != '\r' && c != '\n') + break; + } + + if (i < 0) { + cmark_strbuf_clear(ln); + return; + } + + i = cmark_strbuf_strchr(ln, '\n', i); + if (i >= 0) + cmark_strbuf_truncate(ln, i); +} + +// Check to see if a node ends with a blank line, descending +// if needed into lists and sublists. +static bool ends_with_blank_line(cmark_node* node) +{ + cmark_node *cur = node; + while (cur != NULL) { + if (cur->last_line_blank) { + return true; + } + if (cur->type == NODE_LIST || cur->type == NODE_ITEM) { + cur = cur->last_child; + } else { + cur = NULL; + } + } + return false; +} + +// Break out of all containing lists +static int break_out_of_lists(cmark_parser *parser, cmark_node ** bptr) +{ + cmark_node *container = *bptr; + cmark_node *b = parser->root; + // find first containing NODE_LIST: + while (b && b->type != NODE_LIST) { + b = b->last_child; + } + if (b) { + while (container && container != b) { + container = finalize(parser, container); + } + finalize(parser, b); + *bptr = b->parent; + } + return 0; +} + + +static cmark_node* +finalize(cmark_parser *parser, cmark_node* b) +{ + int firstlinelen; + int pos; + cmark_node* item; + cmark_node* subitem; + cmark_node* parent; + + parent = b->parent; + + assert(b->open); // shouldn't call finalize on closed blocks + b->open = false; + + if (parser->curline->size == 0) { + // end of input - line number has not been incremented + b->end_line = parser->line_number; + b->end_column = parser->last_line_length; + } else if (b->type == NODE_DOCUMENT || + (b->type == NODE_CODE_BLOCK && b->as.code.fenced) || + (b->type == NODE_HEADER && b->as.header.setext)) { + b->end_line = parser->line_number; + b->end_column = parser->curline->size - + (parser->curline->ptr[parser->curline->size - 1] == '\n' ? + 1 : 0); + } else { + b->end_line = parser->line_number - 1; + b->end_column = parser->last_line_length; + } + + switch (b->type) { + case NODE_PARAGRAPH: + while (cmark_strbuf_at(&b->string_content, 0) == '[' && + (pos = cmark_parse_reference_inline(&b->string_content, parser->refmap))) { + + cmark_strbuf_drop(&b->string_content, pos); + } + if (is_blank(&b->string_content, 0)) { + // remove blank node (former reference def) + cmark_node_free(b); + } + break; + + case NODE_CODE_BLOCK: + if (!b->as.code.fenced) { // indented code + remove_trailing_blank_lines(&b->string_content); + cmark_strbuf_putc(&b->string_content, '\n'); + } else { + + // first line of contents becomes info + firstlinelen = cmark_strbuf_strchr(&b->string_content, '\n', 0); + + cmark_strbuf tmp = GH_BUF_INIT; + houdini_unescape_html_f( + &tmp, + b->string_content.ptr, + firstlinelen + ); + cmark_strbuf_trim(&tmp); + cmark_strbuf_unescape(&tmp); + b->as.code.info = cmark_chunk_buf_detach(&tmp); + + cmark_strbuf_drop(&b->string_content, firstlinelen + 1); + } + b->as.code.literal = cmark_chunk_buf_detach(&b->string_content); + break; + + case NODE_HTML: + b->as.literal = cmark_chunk_buf_detach(&b->string_content); + break; + + case NODE_LIST: // determine tight/loose status + b->as.list.tight = true; // tight by default + item = b->first_child; + + while (item) { + // check for non-final non-empty list item ending with blank line: + if (item->last_line_blank && item->next) { + b->as.list.tight = false; + break; + } + // recurse into children of list item, to see if there are + // spaces between them: + subitem = item->first_child; + while (subitem) { + if (ends_with_blank_line(subitem) && + (item->next || subitem->next)) { + b->as.list.tight = false; + break; + } + subitem = subitem->next; + } + if (!(b->as.list.tight)) { + break; + } + item = item->next; + } + + break; + + default: + break; + } + return parent; +} + +// Add a node as child of another. Return pointer to child. +static cmark_node* add_child(cmark_parser *parser, cmark_node* parent, + cmark_node_type block_type, int start_column) +{ + assert(parent); + + // if 'parent' isn't the kind of node that can accept this child, + // then back up til we hit a node that can. + while (!can_contain(parent->type, block_type)) { + parent = finalize(parser, parent); + } + + cmark_node* child = make_block(block_type, parser->line_number, start_column); + child->parent = parent; + + if (parent->last_child) { + parent->last_child->next = child; + child->prev = parent->last_child; + } else { + parent->first_child = child; + child->prev = NULL; + } + parent->last_child = child; + return child; +} + + +// Walk through node and all children, recursively, parsing +// string content into inline content where appropriate. +static void process_inlines(cmark_node* root, cmark_reference_map *refmap, int options) +{ + cmark_iter *iter = cmark_iter_new(root); + cmark_node *cur; + cmark_event_type ev_type; + + while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { + cur = cmark_iter_get_node(iter); + if (ev_type == CMARK_EVENT_ENTER) { + if (cur->type == NODE_PARAGRAPH || + cur->type == NODE_HEADER) { + cmark_parse_inlines(cur, refmap, options); + } + } + } + + cmark_iter_free(iter); +} + +// Attempts to parse a list item marker (bullet or enumerated). +// On success, returns length of the marker, and populates +// data with the details. On failure, returns 0. +static int parse_list_marker(cmark_chunk *input, int pos, cmark_list **dataptr) +{ + unsigned char c; + int startpos; + cmark_list *data; + + startpos = pos; + c = peek_at(input, pos); + + if ((c == '*' || c == '-' || c == '+') && !scan_hrule(input, pos)) { + pos++; + if (!cmark_isspace(peek_at(input, pos))) { + return 0; + } + data = (cmark_list *)calloc(1, sizeof(*data)); + if(data == NULL) { + return 0; + } else { + data->marker_offset = 0; // will be adjusted later + data->list_type = CMARK_BULLET_LIST; + data->bullet_char = c; + data->start = 1; + data->delimiter = CMARK_PERIOD_DELIM; + data->tight = false; + } + } else if (cmark_isdigit(c)) { + int start = 0; + + do { + start = (10 * start) + (peek_at(input, pos) - '0'); + pos++; + } while (cmark_isdigit(peek_at(input, pos))); + + c = peek_at(input, pos); + if (c == '.' || c == ')') { + pos++; + if (!cmark_isspace(peek_at(input, pos))) { + return 0; + } + data = (cmark_list *)calloc(1, sizeof(*data)); + if(data == NULL) { + return 0; + } else { + data->marker_offset = 0; // will be adjusted later + data->list_type = CMARK_ORDERED_LIST; + data->bullet_char = 0; + data->start = start; + data->delimiter = (c == '.' ? CMARK_PERIOD_DELIM : CMARK_PAREN_DELIM); + data->tight = false; + } + } else { + return 0; + } + + } else { + return 0; + } + + *dataptr = data; + return (pos - startpos); +} + +// Return 1 if list item belongs in list, else 0. +static int lists_match(cmark_list *list_data, cmark_list *item_data) +{ + return (list_data->list_type == item_data->list_type && + list_data->delimiter == item_data->delimiter && + // list_data->marker_offset == item_data.marker_offset && + list_data->bullet_char == item_data->bullet_char); +} + +static cmark_node *finalize_document(cmark_parser *parser) +{ + while (parser->current != parser->root) { + parser->current = finalize(parser, parser->current); + } + + finalize(parser, parser->root); + process_inlines(parser->root, parser->refmap, parser->options); + + return parser->root; +} + +cmark_node *cmark_parse_file(FILE *f, int options) +{ + unsigned char buffer[4096]; + cmark_parser *parser = cmark_parser_new(options); + size_t bytes; + cmark_node *document; + + while ((bytes = fread(buffer, 1, sizeof(buffer), f)) > 0) { + bool eof = bytes < sizeof(buffer); + S_parser_feed(parser, buffer, bytes, eof); + if (eof) { + break; + } + } + + document = cmark_parser_finish(parser); + cmark_parser_free(parser); + return document; +} + +cmark_node *cmark_parse_document(const char *buffer, size_t len, int options) +{ + cmark_parser *parser = cmark_parser_new(options); + cmark_node *document; + + S_parser_feed(parser, (const unsigned char *)buffer, len, true); + + document = cmark_parser_finish(parser); + cmark_parser_free(parser); + return document; +} + +void +cmark_parser_feed(cmark_parser *parser, const char *buffer, size_t len) +{ + S_parser_feed(parser, (const unsigned char *)buffer, len, false); +} + +static void +S_parser_feed(cmark_parser *parser, const unsigned char *buffer, size_t len, + bool eof) +{ + const unsigned char *end = buffer + len; + + while (buffer < end) { + const unsigned char *eol + = (const unsigned char *)memchr(buffer, '\n', + end - buffer); + size_t line_len; + + if (eol) { + line_len = eol + 1 - buffer; + } else if (eof) { + line_len = end - buffer; + } else { + cmark_strbuf_put(parser->linebuf, buffer, end - buffer); + break; + } + + if (parser->linebuf->size > 0) { + cmark_strbuf_put(parser->linebuf, buffer, line_len); + S_process_line(parser, parser->linebuf->ptr, + parser->linebuf->size); + cmark_strbuf_clear(parser->linebuf); + } else { + S_process_line(parser, buffer, line_len); + } + + buffer += line_len; + } +} + +static void chop_trailing_hashtags(cmark_chunk *ch) +{ + int n, orig_n; + + cmark_chunk_rtrim(ch); + orig_n = n = ch->len - 1; + + // if string ends in space followed by #s, remove these: + while (n >= 0 && peek_at(ch, n) == '#') + n--; + + // Check for a be a space before the final #s: + if (n != orig_n && n >= 0 && peek_at(ch, n) == ' ') { + ch->len = n; + cmark_chunk_rtrim(ch); + } +} + +static void +S_process_line(cmark_parser *parser, const unsigned char *buffer, size_t bytes) +{ + cmark_node* last_matched_container; + int offset = 0; + int matched = 0; + int lev = 0; + int i; + cmark_list *data = NULL; + bool all_matched = true; + cmark_node* container; + bool blank = false; + int first_nonspace; + int indent; + cmark_chunk input; + bool maybe_lazy; + + utf8proc_detab(parser->curline, buffer, bytes); + + // Add a newline to the end if not present: + // TODO this breaks abstraction: + if (parser->curline->ptr[parser->curline->size - 1] != '\n') { + cmark_strbuf_putc(parser->curline, '\n'); + } + input.data = parser->curline->ptr; + input.len = parser->curline->size; + + // container starts at the document root. + container = parser->root; + + parser->line_number++; + + // for each containing node, try to parse the associated line start. + // bail out on failure: container will point to the last matching node. + + while (container->last_child && container->last_child->open) { + container = container->last_child; + + first_nonspace = offset; + while (peek_at(&input, first_nonspace) == ' ') { + first_nonspace++; + } + + indent = first_nonspace - offset; + blank = peek_at(&input, first_nonspace) == '\n'; + + if (container->type == NODE_BLOCK_QUOTE) { + matched = indent <= 3 && peek_at(&input, first_nonspace) == '>'; + if (matched) { + offset = first_nonspace + 1; + if (peek_at(&input, offset) == ' ') + offset++; + } else { + all_matched = false; + } + + } else if (container->type == NODE_ITEM) { + + if (indent >= container->as.list.marker_offset + + container->as.list.padding) { + offset += container->as.list.marker_offset + + container->as.list.padding; + } else if (blank) { + offset = first_nonspace; + } else { + all_matched = false; + } + + } else if (container->type == NODE_CODE_BLOCK) { + + if (!container->as.code.fenced) { // indented + if (indent >= CODE_INDENT) { + offset += CODE_INDENT; + } else if (blank) { + offset = first_nonspace; + } else { + all_matched = false; + } + } else { // fenced + matched = 0; + if (indent <= 3 && + (peek_at(&input, first_nonspace) == + container->as.code.fence_char)) { + matched = scan_close_code_fence(&input, + first_nonspace); + } + if (matched >= container->as.code.fence_length) { + // closing fence - and since we're at + // the end of a line, we can return: + all_matched = false; + offset += matched; + parser->current = finalize(parser, container); + goto finished; + } else { + // skip opt. spaces of fence offset + i = container->as.code.fence_offset; + while (i > 0 && + peek_at(&input, offset) == ' ') { + offset++; + i--; + } + } + } + } else if (container->type == NODE_HEADER) { + + // a header can never contain more than one line + all_matched = false; + + } else if (container->type == NODE_HTML) { + + if (blank) { + all_matched = false; + } + + } else if (container->type == NODE_PARAGRAPH) { + + if (blank) { + all_matched = false; + } + + } + + if (!all_matched) { + container = container->parent; // back up to last matching node + break; + } + } + + last_matched_container = container; + + // check to see if we've hit 2nd blank line, break out of list: + if (blank && container->last_line_blank) { + break_out_of_lists(parser, &container); + } + + maybe_lazy = parser->current->type == NODE_PARAGRAPH; + // try new container starts: + while (container->type != NODE_CODE_BLOCK && + container->type != NODE_HTML) { + + first_nonspace = offset; + while (peek_at(&input, first_nonspace) == ' ') + first_nonspace++; + + indent = first_nonspace - offset; + blank = peek_at(&input, first_nonspace) == '\n'; + + if (indent >= CODE_INDENT) { + if (!maybe_lazy && !blank) { + offset += CODE_INDENT; + container = add_child(parser, container, NODE_CODE_BLOCK, offset + 1); + container->as.code.fenced = false; + container->as.code.fence_char = 0; + container->as.code.fence_length = 0; + container->as.code.fence_offset = 0; + container->as.code.info = cmark_chunk_literal(""); + } else { // indent > 4 in lazy line + break; + } + + } else if (peek_at(&input, first_nonspace) == '>') { + + offset = first_nonspace + 1; + // optional following character + if (peek_at(&input, offset) == ' ') + offset++; + container = add_child(parser, container, NODE_BLOCK_QUOTE, offset + 1); + + } else if ((matched = scan_atx_header_start(&input, first_nonspace))) { + + offset = first_nonspace + matched; + container = add_child(parser, container, NODE_HEADER, offset + 1); + + int hashpos = cmark_chunk_strchr(&input, '#', first_nonspace); + int level = 0; + + while (peek_at(&input, hashpos) == '#') { + level++; + hashpos++; + } + container->as.header.level = level; + container->as.header.setext = false; + + } else if ((matched = scan_open_code_fence(&input, first_nonspace))) { + + container = add_child(parser, container, NODE_CODE_BLOCK, first_nonspace + 1); + container->as.code.fenced = true; + container->as.code.fence_char = peek_at(&input, first_nonspace); + container->as.code.fence_length = matched; + container->as.code.fence_offset = first_nonspace - offset; + container->as.code.info = cmark_chunk_literal(""); + offset = first_nonspace + matched; + + } else if ((matched = scan_html_block_tag(&input, first_nonspace))) { + + container = add_child(parser, container, NODE_HTML, first_nonspace + 1); + // note, we don't adjust offset because the tag is part of the text + + } else if (container->type == NODE_PARAGRAPH && + (lev = scan_setext_header_line(&input, first_nonspace)) && + // check that there is only one line in the paragraph: + cmark_strbuf_strrchr(&container->string_content, '\n', + cmark_strbuf_len(&container->string_content) - 2) < 0) { + + container->type = NODE_HEADER; + container->as.header.level = lev; + container->as.header.setext = true; + offset = input.len - 1; + + } else if (!(container->type == NODE_PARAGRAPH && !all_matched) && + (matched = scan_hrule(&input, first_nonspace))) { + + // it's only now that we know the line is not part of a setext header: + container = add_child(parser, container, NODE_HRULE, first_nonspace + 1); + container = finalize(parser, container); + offset = input.len - 1; + + } else if ((matched = parse_list_marker(&input, first_nonspace, &data))) { + + // compute padding: + offset = first_nonspace + matched; + i = 0; + while (i <= 5 && peek_at(&input, offset + i) == ' ') { + i++; + } + // i = number of spaces after marker, up to 5 + if (i >= 5 || i < 1 || peek_at(&input, offset) == '\n') { + data->padding = matched + 1; + if (i > 0) { + offset += 1; + } + } else { + data->padding = matched + i; + offset += i; + } + + // check container; if it's a list, see if this list item + // can continue the list; otherwise, create a list container. + + data->marker_offset = indent; + + if (container->type != NODE_LIST || + !lists_match(&container->as.list, data)) { + container = add_child(parser, container, NODE_LIST, + first_nonspace + 1); + + memcpy(&container->as.list, data, sizeof(*data)); + } + + // add the list item + container = add_child(parser, container, NODE_ITEM, + first_nonspace + 1); + /* TODO: static */ + memcpy(&container->as.list, data, sizeof(*data)); + free(data); + } else { + break; + } + + if (accepts_lines(container->type)) { + // if it's a line container, it can't contain other containers + break; + } + maybe_lazy = false; + } + + // what remains at offset is a text line. add the text to the + // appropriate container. + + first_nonspace = offset; + while (peek_at(&input, first_nonspace) == ' ') + first_nonspace++; + + indent = first_nonspace - offset; + blank = peek_at(&input, first_nonspace) == '\n'; + + if (blank && container->last_child) { + container->last_child->last_line_blank = true; + } + + // block quote lines are never blank as they start with > + // and we don't count blanks in fenced code for purposes of tight/loose + // lists or breaking out of lists. we also don't set last_line_blank + // on an empty list item. + container->last_line_blank = (blank && + container->type != NODE_BLOCK_QUOTE && + container->type != NODE_HEADER && + !(container->type == NODE_CODE_BLOCK && + container->as.code.fenced) && + !(container->type == NODE_ITEM && + container->first_child == NULL && + container->start_line == parser->line_number)); + + cmark_node *cont = container; + while (cont->parent) { + cont->parent->last_line_blank = false; + cont = cont->parent; + } + + if (parser->current != last_matched_container && + container == last_matched_container && + !blank && + parser->current->type == NODE_PARAGRAPH && + cmark_strbuf_len(&parser->current->string_content) > 0) { + + add_line(parser->current, &input, offset); + + } else { // not a lazy continuation + + // finalize any blocks that were not matched and set cur to container: + while (parser->current != last_matched_container) { + parser->current = finalize(parser, parser->current); + assert(parser->current != NULL); + } + + if (container->type == NODE_CODE_BLOCK || + container->type == NODE_HTML) { + + add_line(container, &input, offset); + + } else if (blank) { + + // ??? do nothing + + } else if (accepts_lines(container->type)) { + + if (container->type == NODE_HEADER && + container->as.header.setext == false) { + chop_trailing_hashtags(&input); + } + add_line(container, &input, first_nonspace); + + } else { + // create paragraph container for line + container = add_child(parser, container, NODE_PARAGRAPH, first_nonspace + 1); + add_line(container, &input, first_nonspace); + + } + + parser->current = container; + } +finished: + parser->last_line_length = parser->curline->size - + (parser->curline->ptr[parser->curline->size - 1] == '\n' ? + 1 : 0); + ; + cmark_strbuf_clear(parser->curline); + +} + +cmark_node *cmark_parser_finish(cmark_parser *parser) +{ + if (parser->linebuf->size) { + S_process_line(parser, parser->linebuf->ptr, + parser->linebuf->size); + cmark_strbuf_clear(parser->linebuf); + } + + finalize_document(parser); + + if (parser->options & CMARK_OPT_NORMALIZE) { + cmark_consolidate_text_nodes(parser->root); + } + + cmark_strbuf_free(parser->curline); + +#if CMARK_DEBUG_NODES + if (cmark_node_check(parser->root, stderr)) { + abort(); + } +#endif + return parser->root; +} diff --git a/cbits/buffer.c b/cbits/buffer.c new file mode 100644 --- /dev/null +++ b/cbits/buffer.c @@ -0,0 +1,381 @@ +#include +#include +#include +#include +#include +#include + +#include "config.h" +#include "cmark_ctype.h" +#include "buffer.h" + +/* Used as default value for cmark_strbuf->ptr so that people can always + * assume ptr is non-NULL and zero terminated even for new cmark_strbufs. + */ +unsigned char cmark_strbuf__initbuf[1]; +unsigned char cmark_strbuf__oom[1]; + +#define ENSURE_SIZE(b, d) \ + if ((d) > buf->asize && cmark_strbuf_grow(b, (d)) < 0) \ + return -1; + +#ifndef MIN +#define MIN(x,y) ((xasize = 0; + buf->size = 0; + buf->ptr = cmark_strbuf__initbuf; + + if (initial_size) + cmark_strbuf_grow(buf, initial_size); +} + +int cmark_strbuf_try_grow(cmark_strbuf *buf, int target_size, bool mark_oom) +{ + unsigned char *new_ptr; + int new_size; + + if (buf->ptr == cmark_strbuf__oom) + return -1; + + if (target_size <= buf->asize) + return 0; + + if (buf->asize == 0) { + new_size = target_size; + new_ptr = NULL; + } else { + new_size = buf->asize; + new_ptr = buf->ptr; + } + + /* grow the buffer size by 1.5, until it's big enough + * to fit our target size */ + while (new_size < target_size) + new_size = (new_size << 1) - (new_size >> 1); + + /* round allocation up to multiple of 8 */ + new_size = (new_size + 7) & ~7; + + new_ptr = (unsigned char *)realloc(new_ptr, new_size); + + if (!new_ptr) { + if (mark_oom) + buf->ptr = cmark_strbuf__oom; + return -1; + } + + buf->asize = new_size; + buf->ptr = new_ptr; + + /* truncate the existing buffer size if necessary */ + if (buf->size >= buf->asize) + buf->size = buf->asize - 1; + buf->ptr[buf->size] = '\0'; + + return 0; +} + +int cmark_strbuf_grow(cmark_strbuf *buf, int target_size) +{ + return cmark_strbuf_try_grow(buf, target_size, true); +} + +bool cmark_strbuf_oom(const cmark_strbuf *buf) +{ + return (buf->ptr == cmark_strbuf__oom); +} + +size_t cmark_strbuf_len(const cmark_strbuf *buf) +{ + return buf->size; +} + +void cmark_strbuf_free(cmark_strbuf *buf) +{ + if (!buf) return; + + if (buf->ptr != cmark_strbuf__initbuf && buf->ptr != cmark_strbuf__oom) + free(buf->ptr); + + cmark_strbuf_init(buf, 0); +} + +void cmark_strbuf_clear(cmark_strbuf *buf) +{ + buf->size = 0; + + if (buf->asize > 0) + buf->ptr[0] = '\0'; +} + +int cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data, int len) +{ + if (len <= 0 || data == NULL) { + cmark_strbuf_clear(buf); + } else { + if (data != buf->ptr) { + ENSURE_SIZE(buf, len + 1); + memmove(buf->ptr, data, len); + } + buf->size = len; + buf->ptr[buf->size] = '\0'; + } + return 0; +} + +int cmark_strbuf_sets(cmark_strbuf *buf, const char *string) +{ + return cmark_strbuf_set(buf, + (const unsigned char *)string, + string ? strlen(string) : 0); +} + +int cmark_strbuf_putc(cmark_strbuf *buf, int c) +{ + ENSURE_SIZE(buf, buf->size + 2); + buf->ptr[buf->size++] = c; + buf->ptr[buf->size] = '\0'; + return 0; +} + +int cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data, int len) +{ + if (len <= 0) + return 0; + + ENSURE_SIZE(buf, buf->size + len + 1); + memmove(buf->ptr + buf->size, data, len); + buf->size += len; + buf->ptr[buf->size] = '\0'; + return 0; +} + +int cmark_strbuf_puts(cmark_strbuf *buf, const char *string) +{ + return cmark_strbuf_put(buf, (const unsigned char *)string, strlen(string)); +} + +int cmark_strbuf_vprintf(cmark_strbuf *buf, const char *format, va_list ap) +{ + const int expected_size = buf->size + (strlen(format) * 2); + int len; + + ENSURE_SIZE(buf, expected_size); + + while (1) { + va_list args; + va_copy(args, ap); + + len = vsnprintf( + (char *)buf->ptr + buf->size, + buf->asize - buf->size, + format, args + ); + + va_end(args); + + if (len < 0) { + free(buf->ptr); + buf->ptr = cmark_strbuf__oom; + return -1; + } + + if (len + 1 <= buf->asize - buf->size) { + buf->size += len; + break; + } + + ENSURE_SIZE(buf, buf->size + len + 1); + } + + return 0; +} + +int cmark_strbuf_printf(cmark_strbuf *buf, const char *format, ...) +{ + int r; + va_list ap; + + va_start(ap, format); + r = cmark_strbuf_vprintf(buf, format, ap); + va_end(ap); + + return r; +} + +void cmark_strbuf_copy_cstr(char *data, int datasize, const cmark_strbuf *buf) +{ + int copylen; + + assert(data && datasize && buf); + + data[0] = '\0'; + + if (buf->size == 0 || buf->asize <= 0) + return; + + copylen = buf->size; + if (copylen > datasize - 1) + copylen = datasize - 1; + memmove(data, buf->ptr, copylen); + data[copylen] = '\0'; +} + +void cmark_strbuf_swap(cmark_strbuf *buf_a, cmark_strbuf *buf_b) +{ + cmark_strbuf t = *buf_a; + *buf_a = *buf_b; + *buf_b = t; +} + +unsigned char *cmark_strbuf_detach(cmark_strbuf *buf) +{ + unsigned char *data = buf->ptr; + + if (buf->asize == 0 || buf->ptr == cmark_strbuf__oom) { + /* return an empty string */ + return (unsigned char *)calloc(1, 1); + } + + cmark_strbuf_init(buf, 0); + return data; +} + +void cmark_strbuf_attach(cmark_strbuf *buf, unsigned char *ptr, int asize) +{ + cmark_strbuf_free(buf); + + if (ptr) { + buf->ptr = ptr; + buf->size = strlen((char *)ptr); + if (asize) + buf->asize = (asize < buf->size) ? buf->size + 1 : asize; + else /* pass 0 to fall back on strlen + 1 */ + buf->asize = buf->size + 1; + } else { + cmark_strbuf_grow(buf, asize); + } +} + +int cmark_strbuf_cmp(const cmark_strbuf *a, const cmark_strbuf *b) +{ + int result = memcmp(a->ptr, b->ptr, MIN(a->size, b->size)); + return (result != 0) ? result : + (a->size < b->size) ? -1 : (a->size > b->size) ? 1 : 0; +} + +int cmark_strbuf_strchr(const cmark_strbuf *buf, int c, int pos) +{ + const unsigned char *p = (unsigned char *)memchr(buf->ptr + pos, c, buf->size - pos); + if (!p) + return -1; + + return (int)(p - (const unsigned char *)buf->ptr); +} + +int cmark_strbuf_strrchr(const cmark_strbuf *buf, int c, int pos) +{ + int i; + + for (i = pos; i >= 0; i--) { + if (buf->ptr[i] == (unsigned char) c) + return i; + } + + return -1; +} + +void cmark_strbuf_truncate(cmark_strbuf *buf, int len) +{ + if (len < buf->size) { + buf->size = len; + buf->ptr[buf->size] = '\0'; + } +} + +void cmark_strbuf_drop(cmark_strbuf *buf, int n) +{ + if (n > 0) { + buf->size = buf->size - n; + if (buf->size) + memmove(buf->ptr, buf->ptr + n, buf->size); + + buf->ptr[buf->size] = '\0'; + } +} + +void cmark_strbuf_rtrim(cmark_strbuf *buf) +{ + if (!buf->size) + return; + + while (buf->size > 0) { + if (!cmark_isspace(buf->ptr[buf->size - 1])) + break; + + buf->size--; + } + + buf->ptr[buf->size] = '\0'; +} + +void cmark_strbuf_trim(cmark_strbuf *buf) +{ + int i = 0; + + if (!buf->size) + return; + + while (i < buf->size && cmark_isspace(buf->ptr[i])) + i++; + + cmark_strbuf_drop(buf, i); + + cmark_strbuf_rtrim(buf); +} + +// Destructively modify string, collapsing consecutive +// space and newline characters into a single space. +void cmark_strbuf_normalize_whitespace(cmark_strbuf *s) +{ + bool last_char_was_space = false; + int r, w; + + for (r = 0, w = 0; r < s->size; ++r) { + switch (s->ptr[r]) { + case ' ': + case '\n': + if (last_char_was_space) + break; + + s->ptr[w++] = ' '; + last_char_was_space = true; + break; + + default: + s->ptr[w++] = s->ptr[r]; + last_char_was_space = false; + } + } + + cmark_strbuf_truncate(s, w); +} + +// Destructively unescape a string: remove backslashes before punctuation chars. +extern void cmark_strbuf_unescape(cmark_strbuf *buf) +{ + int r, w; + + for (r = 0, w = 0; r < buf->size; ++r) { + if (buf->ptr[r] == '\\' && cmark_ispunct(buf->ptr[r + 1])) + continue; + + buf->ptr[w++] = buf->ptr[r]; + } + + cmark_strbuf_truncate(buf, w); +} diff --git a/cbits/buffer.h b/cbits/buffer.h new file mode 100644 --- /dev/null +++ b/cbits/buffer.h @@ -0,0 +1,113 @@ +#ifndef CMARK_BUFFER_H +#define CMARK_BUFFER_H + +#include +#include +#include "config.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + unsigned char *ptr; + int asize, size; +} cmark_strbuf; + +extern unsigned char cmark_strbuf__initbuf[]; + +extern unsigned char cmark_strbuf__oom[]; + +#define GH_BUF_INIT { cmark_strbuf__initbuf, 0, 0 } + +/** + * Initialize a cmark_strbuf structure. + * + * For the cases where GH_BUF_INIT cannot be used to do static + * initialization. + */ +void cmark_strbuf_init(cmark_strbuf *buf, int initial_size); + +/** + * Attempt to grow the buffer to hold at least `target_size` bytes. + * + * If the allocation fails, this will return an error. If mark_oom is true, + * this will mark the buffer as invalid for future operations; if false, + * existing buffer content will be preserved, but calling code must handle + * that buffer was not expanded. + */ +int cmark_strbuf_try_grow(cmark_strbuf *buf, int target_size, bool mark_oom); + +/** + * Grow the buffer to hold at least `target_size` bytes. + * + * If the allocation fails, this will return an error and the buffer will be + * marked as invalid for future operations, invaliding contents. + * + * @return 0 on success or -1 on failure + */ +int cmark_strbuf_grow(cmark_strbuf *buf, int target_size); + +void cmark_strbuf_free(cmark_strbuf *buf); +void cmark_strbuf_swap(cmark_strbuf *buf_a, cmark_strbuf *buf_b); + +/** + * Test if there have been any reallocation failures with this cmark_strbuf. + * + * Any function that writes to a cmark_strbuf can fail due to memory allocation + * issues. If one fails, the cmark_strbuf will be marked with an OOM error and + * further calls to modify the buffer will fail. Check cmark_strbuf_oom() at the + * end of your sequence and it will be true if you ran out of memory at any + * point with that buffer. + * + * @return false if no error, true if allocation error + */ +bool cmark_strbuf_oom(const cmark_strbuf *buf); + +size_t cmark_strbuf_len(const cmark_strbuf *buf); + +int cmark_strbuf_cmp(const cmark_strbuf *a, const cmark_strbuf *b); + +void cmark_strbuf_attach(cmark_strbuf *buf, unsigned char *ptr, int asize); +unsigned char *cmark_strbuf_detach(cmark_strbuf *buf); +void cmark_strbuf_copy_cstr(char *data, int datasize, const cmark_strbuf *buf); + +static inline const char *cmark_strbuf_cstr(const cmark_strbuf *buf) +{ + return (char *)buf->ptr; +} + +#define cmark_strbuf_at(buf, n) ((buf)->ptr[n]) + +/* + * Functions below that return int value error codes will return 0 on + * success or -1 on failure (which generally means an allocation failed). + * Using a cmark_strbuf where the allocation has failed with result in -1 from + * all further calls using that buffer. As a result, you can ignore the + * return code of these functions and call them in a series then just call + * cmark_strbuf_oom at the end. + */ +int cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data, int len); +int cmark_strbuf_sets(cmark_strbuf *buf, const char *string); +int cmark_strbuf_putc(cmark_strbuf *buf, int c); +int cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data, int len); +int cmark_strbuf_puts(cmark_strbuf *buf, const char *string); +int cmark_strbuf_printf(cmark_strbuf *buf, const char *format, ...) +CMARK_ATTRIBUTE((format (printf, 2, 3))); +int cmark_strbuf_vprintf(cmark_strbuf *buf, const char *format, va_list ap); +void cmark_strbuf_clear(cmark_strbuf *buf); + +int cmark_strbuf_strchr(const cmark_strbuf *buf, int c, int pos); +int cmark_strbuf_strrchr(const cmark_strbuf *buf, int c, int pos); +void cmark_strbuf_drop(cmark_strbuf *buf, int n); +void cmark_strbuf_truncate(cmark_strbuf *buf, int len); +void cmark_strbuf_rtrim(cmark_strbuf *buf); +void cmark_strbuf_trim(cmark_strbuf *buf); +void cmark_strbuf_normalize_whitespace(cmark_strbuf *s); +void cmark_strbuf_unescape(cmark_strbuf *s); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/cbits/case_fold_switch.inc b/cbits/case_fold_switch.inc new file mode 100644 --- /dev/null +++ b/cbits/case_fold_switch.inc @@ -0,0 +1,2637 @@ + switch (c) { + case 0x0041: + bufpush(0x0061); + break; + case 0x0042: + bufpush(0x0062); + break; + case 0x0043: + bufpush(0x0063); + break; + case 0x0044: + bufpush(0x0064); + break; + case 0x0045: + bufpush(0x0065); + break; + case 0x0046: + bufpush(0x0066); + break; + case 0x0047: + bufpush(0x0067); + break; + case 0x0048: + bufpush(0x0068); + break; + case 0x0049: + bufpush(0x0069); + break; + case 0x004A: + bufpush(0x006A); + break; + case 0x004B: + bufpush(0x006B); + break; + case 0x004C: + bufpush(0x006C); + break; + case 0x004D: + bufpush(0x006D); + break; + case 0x004E: + bufpush(0x006E); + break; + case 0x004F: + bufpush(0x006F); + break; + case 0x0050: + bufpush(0x0070); + break; + case 0x0051: + bufpush(0x0071); + break; + case 0x0052: + bufpush(0x0072); + break; + case 0x0053: + bufpush(0x0073); + break; + case 0x0054: + bufpush(0x0074); + break; + case 0x0055: + bufpush(0x0075); + break; + case 0x0056: + bufpush(0x0076); + break; + case 0x0057: + bufpush(0x0077); + break; + case 0x0058: + bufpush(0x0078); + break; + case 0x0059: + bufpush(0x0079); + break; + case 0x005A: + bufpush(0x007A); + break; + case 0x00B5: + bufpush(0x03BC); + break; + case 0x00C0: + bufpush(0x00E0); + break; + case 0x00C1: + bufpush(0x00E1); + break; + case 0x00C2: + bufpush(0x00E2); + break; + case 0x00C3: + bufpush(0x00E3); + break; + case 0x00C4: + bufpush(0x00E4); + break; + case 0x00C5: + bufpush(0x00E5); + break; + case 0x00C6: + bufpush(0x00E6); + break; + case 0x00C7: + bufpush(0x00E7); + break; + case 0x00C8: + bufpush(0x00E8); + break; + case 0x00C9: + bufpush(0x00E9); + break; + case 0x00CA: + bufpush(0x00EA); + break; + case 0x00CB: + bufpush(0x00EB); + break; + case 0x00CC: + bufpush(0x00EC); + break; + case 0x00CD: + bufpush(0x00ED); + break; + case 0x00CE: + bufpush(0x00EE); + break; + case 0x00CF: + bufpush(0x00EF); + break; + case 0x00D0: + bufpush(0x00F0); + break; + case 0x00D1: + bufpush(0x00F1); + break; + case 0x00D2: + bufpush(0x00F2); + break; + case 0x00D3: + bufpush(0x00F3); + break; + case 0x00D4: + bufpush(0x00F4); + break; + case 0x00D5: + bufpush(0x00F5); + break; + case 0x00D6: + bufpush(0x00F6); + break; + case 0x00D8: + bufpush(0x00F8); + break; + case 0x00D9: + bufpush(0x00F9); + break; + case 0x00DA: + bufpush(0x00FA); + break; + case 0x00DB: + bufpush(0x00FB); + break; + case 0x00DC: + bufpush(0x00FC); + break; + case 0x00DD: + bufpush(0x00FD); + break; + case 0x00DE: + bufpush(0x00FE); + break; + case 0x00DF: + bufpush(0x0073); + bufpush(0x0073); + break; + case 0x0100: + bufpush(0x0101); + break; + case 0x0102: + bufpush(0x0103); + break; + case 0x0104: + bufpush(0x0105); + break; + case 0x0106: + bufpush(0x0107); + break; + case 0x0108: + bufpush(0x0109); + break; + case 0x010A: + bufpush(0x010B); + break; + case 0x010C: + bufpush(0x010D); + break; + case 0x010E: + bufpush(0x010F); + break; + case 0x0110: + bufpush(0x0111); + break; + case 0x0112: + bufpush(0x0113); + break; + case 0x0114: + bufpush(0x0115); + break; + case 0x0116: + bufpush(0x0117); + break; + case 0x0118: + bufpush(0x0119); + break; + case 0x011A: + bufpush(0x011B); + break; + case 0x011C: + bufpush(0x011D); + break; + case 0x011E: + bufpush(0x011F); + break; + case 0x0120: + bufpush(0x0121); + break; + case 0x0122: + bufpush(0x0123); + break; + case 0x0124: + bufpush(0x0125); + break; + case 0x0126: + bufpush(0x0127); + break; + case 0x0128: + bufpush(0x0129); + break; + case 0x012A: + bufpush(0x012B); + break; + case 0x012C: + bufpush(0x012D); + break; + case 0x012E: + bufpush(0x012F); + break; + case 0x0130: + bufpush(0x0069); + bufpush(0x0307); + break; + case 0x0132: + bufpush(0x0133); + break; + case 0x0134: + bufpush(0x0135); + break; + case 0x0136: + bufpush(0x0137); + break; + case 0x0139: + bufpush(0x013A); + break; + case 0x013B: + bufpush(0x013C); + break; + case 0x013D: + bufpush(0x013E); + break; + case 0x013F: + bufpush(0x0140); + break; + case 0x0141: + bufpush(0x0142); + break; + case 0x0143: + bufpush(0x0144); + break; + case 0x0145: + bufpush(0x0146); + break; + case 0x0147: + bufpush(0x0148); + break; + case 0x0149: + bufpush(0x02BC); + bufpush(0x006E); + break; + case 0x014A: + bufpush(0x014B); + break; + case 0x014C: + bufpush(0x014D); + break; + case 0x014E: + bufpush(0x014F); + break; + case 0x0150: + bufpush(0x0151); + break; + case 0x0152: + bufpush(0x0153); + break; + case 0x0154: + bufpush(0x0155); + break; + case 0x0156: + bufpush(0x0157); + break; + case 0x0158: + bufpush(0x0159); + break; + case 0x015A: + bufpush(0x015B); + break; + case 0x015C: + bufpush(0x015D); + break; + case 0x015E: + bufpush(0x015F); + break; + case 0x0160: + bufpush(0x0161); + break; + case 0x0162: + bufpush(0x0163); + break; + case 0x0164: + bufpush(0x0165); + break; + case 0x0166: + bufpush(0x0167); + break; + case 0x0168: + bufpush(0x0169); + break; + case 0x016A: + bufpush(0x016B); + break; + case 0x016C: + bufpush(0x016D); + break; + case 0x016E: + bufpush(0x016F); + break; + case 0x0170: + bufpush(0x0171); + break; + case 0x0172: + bufpush(0x0173); + break; + case 0x0174: + bufpush(0x0175); + break; + case 0x0176: + bufpush(0x0177); + break; + case 0x0178: + bufpush(0x00FF); + break; + case 0x0179: + bufpush(0x017A); + break; + case 0x017B: + bufpush(0x017C); + break; + case 0x017D: + bufpush(0x017E); + break; + case 0x017F: + bufpush(0x0073); + break; + case 0x0181: + bufpush(0x0253); + break; + case 0x0182: + bufpush(0x0183); + break; + case 0x0184: + bufpush(0x0185); + break; + case 0x0186: + bufpush(0x0254); + break; + case 0x0187: + bufpush(0x0188); + break; + case 0x0189: + bufpush(0x0256); + break; + case 0x018A: + bufpush(0x0257); + break; + case 0x018B: + bufpush(0x018C); + break; + case 0x018E: + bufpush(0x01DD); + break; + case 0x018F: + bufpush(0x0259); + break; + case 0x0190: + bufpush(0x025B); + break; + case 0x0191: + bufpush(0x0192); + break; + case 0x0193: + bufpush(0x0260); + break; + case 0x0194: + bufpush(0x0263); + break; + case 0x0196: + bufpush(0x0269); + break; + case 0x0197: + bufpush(0x0268); + break; + case 0x0198: + bufpush(0x0199); + break; + case 0x019C: + bufpush(0x026F); + break; + case 0x019D: + bufpush(0x0272); + break; + case 0x019F: + bufpush(0x0275); + break; + case 0x01A0: + bufpush(0x01A1); + break; + case 0x01A2: + bufpush(0x01A3); + break; + case 0x01A4: + bufpush(0x01A5); + break; + case 0x01A6: + bufpush(0x0280); + break; + case 0x01A7: + bufpush(0x01A8); + break; + case 0x01A9: + bufpush(0x0283); + break; + case 0x01AC: + bufpush(0x01AD); + break; + case 0x01AE: + bufpush(0x0288); + break; + case 0x01AF: + bufpush(0x01B0); + break; + case 0x01B1: + bufpush(0x028A); + break; + case 0x01B2: + bufpush(0x028B); + break; + case 0x01B3: + bufpush(0x01B4); + break; + case 0x01B5: + bufpush(0x01B6); + break; + case 0x01B7: + bufpush(0x0292); + break; + case 0x01B8: + bufpush(0x01B9); + break; + case 0x01BC: + bufpush(0x01BD); + break; + case 0x01C4: + bufpush(0x01C6); + break; + case 0x01C5: + bufpush(0x01C6); + break; + case 0x01C7: + bufpush(0x01C9); + break; + case 0x01C8: + bufpush(0x01C9); + break; + case 0x01CA: + bufpush(0x01CC); + break; + case 0x01CB: + bufpush(0x01CC); + break; + case 0x01CD: + bufpush(0x01CE); + break; + case 0x01CF: + bufpush(0x01D0); + break; + case 0x01D1: + bufpush(0x01D2); + break; + case 0x01D3: + bufpush(0x01D4); + break; + case 0x01D5: + bufpush(0x01D6); + break; + case 0x01D7: + bufpush(0x01D8); + break; + case 0x01D9: + bufpush(0x01DA); + break; + case 0x01DB: + bufpush(0x01DC); + break; + case 0x01DE: + bufpush(0x01DF); + break; + case 0x01E0: + bufpush(0x01E1); + break; + case 0x01E2: + bufpush(0x01E3); + break; + case 0x01E4: + bufpush(0x01E5); + break; + case 0x01E6: + bufpush(0x01E7); + break; + case 0x01E8: + bufpush(0x01E9); + break; + case 0x01EA: + bufpush(0x01EB); + break; + case 0x01EC: + bufpush(0x01ED); + break; + case 0x01EE: + bufpush(0x01EF); + break; + case 0x01F0: + bufpush(0x006A); + bufpush(0x030C); + break; + case 0x01F1: + bufpush(0x01F3); + break; + case 0x01F2: + bufpush(0x01F3); + break; + case 0x01F4: + bufpush(0x01F5); + break; + case 0x01F6: + bufpush(0x0195); + break; + case 0x01F7: + bufpush(0x01BF); + break; + case 0x01F8: + bufpush(0x01F9); + break; + case 0x01FA: + bufpush(0x01FB); + break; + case 0x01FC: + bufpush(0x01FD); + break; + case 0x01FE: + bufpush(0x01FF); + break; + case 0x0200: + bufpush(0x0201); + break; + case 0x0202: + bufpush(0x0203); + break; + case 0x0204: + bufpush(0x0205); + break; + case 0x0206: + bufpush(0x0207); + break; + case 0x0208: + bufpush(0x0209); + break; + case 0x020A: + bufpush(0x020B); + break; + case 0x020C: + bufpush(0x020D); + break; + case 0x020E: + bufpush(0x020F); + break; + case 0x0210: + bufpush(0x0211); + break; + case 0x0212: + bufpush(0x0213); + break; + case 0x0214: + bufpush(0x0215); + break; + case 0x0216: + bufpush(0x0217); + break; + case 0x0218: + bufpush(0x0219); + break; + case 0x021A: + bufpush(0x021B); + break; + case 0x021C: + bufpush(0x021D); + break; + case 0x021E: + bufpush(0x021F); + break; + case 0x0220: + bufpush(0x019E); + break; + case 0x0222: + bufpush(0x0223); + break; + case 0x0224: + bufpush(0x0225); + break; + case 0x0226: + bufpush(0x0227); + break; + case 0x0228: + bufpush(0x0229); + break; + case 0x022A: + bufpush(0x022B); + break; + case 0x022C: + bufpush(0x022D); + break; + case 0x022E: + bufpush(0x022F); + break; + case 0x0230: + bufpush(0x0231); + break; + case 0x0232: + bufpush(0x0233); + break; + case 0x0345: + bufpush(0x03B9); + break; + case 0x0386: + bufpush(0x03AC); + break; + case 0x0388: + bufpush(0x03AD); + break; + case 0x0389: + bufpush(0x03AE); + break; + case 0x038A: + bufpush(0x03AF); + break; + case 0x038C: + bufpush(0x03CC); + break; + case 0x038E: + bufpush(0x03CD); + break; + case 0x038F: + bufpush(0x03CE); + break; + case 0x0390: + bufpush(0x03B9); + bufpush(0x0308); + bufpush(0x0301); + break; + case 0x0391: + bufpush(0x03B1); + break; + case 0x0392: + bufpush(0x03B2); + break; + case 0x0393: + bufpush(0x03B3); + break; + case 0x0394: + bufpush(0x03B4); + break; + case 0x0395: + bufpush(0x03B5); + break; + case 0x0396: + bufpush(0x03B6); + break; + case 0x0397: + bufpush(0x03B7); + break; + case 0x0398: + bufpush(0x03B8); + break; + case 0x0399: + bufpush(0x03B9); + break; + case 0x039A: + bufpush(0x03BA); + break; + case 0x039B: + bufpush(0x03BB); + break; + case 0x039C: + bufpush(0x03BC); + break; + case 0x039D: + bufpush(0x03BD); + break; + case 0x039E: + bufpush(0x03BE); + break; + case 0x039F: + bufpush(0x03BF); + break; + case 0x03A0: + bufpush(0x03C0); + break; + case 0x03A1: + bufpush(0x03C1); + break; + case 0x03A3: + bufpush(0x03C3); + break; + case 0x03A4: + bufpush(0x03C4); + break; + case 0x03A5: + bufpush(0x03C5); + break; + case 0x03A6: + bufpush(0x03C6); + break; + case 0x03A7: + bufpush(0x03C7); + break; + case 0x03A8: + bufpush(0x03C8); + break; + case 0x03A9: + bufpush(0x03C9); + break; + case 0x03AA: + bufpush(0x03CA); + break; + case 0x03AB: + bufpush(0x03CB); + break; + case 0x03B0: + bufpush(0x03C5); + bufpush(0x0308); + bufpush(0x0301); + break; + case 0x03C2: + bufpush(0x03C3); + break; + case 0x03D0: + bufpush(0x03B2); + break; + case 0x03D1: + bufpush(0x03B8); + break; + case 0x03D5: + bufpush(0x03C6); + break; + case 0x03D6: + bufpush(0x03C0); + break; + case 0x03D8: + bufpush(0x03D9); + break; + case 0x03DA: + bufpush(0x03DB); + break; + case 0x03DC: + bufpush(0x03DD); + break; + case 0x03DE: + bufpush(0x03DF); + break; + case 0x03E0: + bufpush(0x03E1); + break; + case 0x03E2: + bufpush(0x03E3); + break; + case 0x03E4: + bufpush(0x03E5); + break; + case 0x03E6: + bufpush(0x03E7); + break; + case 0x03E8: + bufpush(0x03E9); + break; + case 0x03EA: + bufpush(0x03EB); + break; + case 0x03EC: + bufpush(0x03ED); + break; + case 0x03EE: + bufpush(0x03EF); + break; + case 0x03F0: + bufpush(0x03BA); + break; + case 0x03F1: + bufpush(0x03C1); + break; + case 0x03F2: + bufpush(0x03C3); + break; + case 0x03F4: + bufpush(0x03B8); + break; + case 0x03F5: + bufpush(0x03B5); + break; + case 0x0400: + bufpush(0x0450); + break; + case 0x0401: + bufpush(0x0451); + break; + case 0x0402: + bufpush(0x0452); + break; + case 0x0403: + bufpush(0x0453); + break; + case 0x0404: + bufpush(0x0454); + break; + case 0x0405: + bufpush(0x0455); + break; + case 0x0406: + bufpush(0x0456); + break; + case 0x0407: + bufpush(0x0457); + break; + case 0x0408: + bufpush(0x0458); + break; + case 0x0409: + bufpush(0x0459); + break; + case 0x040A: + bufpush(0x045A); + break; + case 0x040B: + bufpush(0x045B); + break; + case 0x040C: + bufpush(0x045C); + break; + case 0x040D: + bufpush(0x045D); + break; + case 0x040E: + bufpush(0x045E); + break; + case 0x040F: + bufpush(0x045F); + break; + case 0x0410: + bufpush(0x0430); + break; + case 0x0411: + bufpush(0x0431); + break; + case 0x0412: + bufpush(0x0432); + break; + case 0x0413: + bufpush(0x0433); + break; + case 0x0414: + bufpush(0x0434); + break; + case 0x0415: + bufpush(0x0435); + break; + case 0x0416: + bufpush(0x0436); + break; + case 0x0417: + bufpush(0x0437); + break; + case 0x0418: + bufpush(0x0438); + break; + case 0x0419: + bufpush(0x0439); + break; + case 0x041A: + bufpush(0x043A); + break; + case 0x041B: + bufpush(0x043B); + break; + case 0x041C: + bufpush(0x043C); + break; + case 0x041D: + bufpush(0x043D); + break; + case 0x041E: + bufpush(0x043E); + break; + case 0x041F: + bufpush(0x043F); + break; + case 0x0420: + bufpush(0x0440); + break; + case 0x0421: + bufpush(0x0441); + break; + case 0x0422: + bufpush(0x0442); + break; + case 0x0423: + bufpush(0x0443); + break; + case 0x0424: + bufpush(0x0444); + break; + case 0x0425: + bufpush(0x0445); + break; + case 0x0426: + bufpush(0x0446); + break; + case 0x0427: + bufpush(0x0447); + break; + case 0x0428: + bufpush(0x0448); + break; + case 0x0429: + bufpush(0x0449); + break; + case 0x042A: + bufpush(0x044A); + break; + case 0x042B: + bufpush(0x044B); + break; + case 0x042C: + bufpush(0x044C); + break; + case 0x042D: + bufpush(0x044D); + break; + case 0x042E: + bufpush(0x044E); + break; + case 0x042F: + bufpush(0x044F); + break; + case 0x0460: + bufpush(0x0461); + break; + case 0x0462: + bufpush(0x0463); + break; + case 0x0464: + bufpush(0x0465); + break; + case 0x0466: + bufpush(0x0467); + break; + case 0x0468: + bufpush(0x0469); + break; + case 0x046A: + bufpush(0x046B); + break; + case 0x046C: + bufpush(0x046D); + break; + case 0x046E: + bufpush(0x046F); + break; + case 0x0470: + bufpush(0x0471); + break; + case 0x0472: + bufpush(0x0473); + break; + case 0x0474: + bufpush(0x0475); + break; + case 0x0476: + bufpush(0x0477); + break; + case 0x0478: + bufpush(0x0479); + break; + case 0x047A: + bufpush(0x047B); + break; + case 0x047C: + bufpush(0x047D); + break; + case 0x047E: + bufpush(0x047F); + break; + case 0x0480: + bufpush(0x0481); + break; + case 0x048A: + bufpush(0x048B); + break; + case 0x048C: + bufpush(0x048D); + break; + case 0x048E: + bufpush(0x048F); + break; + case 0x0490: + bufpush(0x0491); + break; + case 0x0492: + bufpush(0x0493); + break; + case 0x0494: + bufpush(0x0495); + break; + case 0x0496: + bufpush(0x0497); + break; + case 0x0498: + bufpush(0x0499); + break; + case 0x049A: + bufpush(0x049B); + break; + case 0x049C: + bufpush(0x049D); + break; + case 0x049E: + bufpush(0x049F); + break; + case 0x04A0: + bufpush(0x04A1); + break; + case 0x04A2: + bufpush(0x04A3); + break; + case 0x04A4: + bufpush(0x04A5); + break; + case 0x04A6: + bufpush(0x04A7); + break; + case 0x04A8: + bufpush(0x04A9); + break; + case 0x04AA: + bufpush(0x04AB); + break; + case 0x04AC: + bufpush(0x04AD); + break; + case 0x04AE: + bufpush(0x04AF); + break; + case 0x04B0: + bufpush(0x04B1); + break; + case 0x04B2: + bufpush(0x04B3); + break; + case 0x04B4: + bufpush(0x04B5); + break; + case 0x04B6: + bufpush(0x04B7); + break; + case 0x04B8: + bufpush(0x04B9); + break; + case 0x04BA: + bufpush(0x04BB); + break; + case 0x04BC: + bufpush(0x04BD); + break; + case 0x04BE: + bufpush(0x04BF); + break; + case 0x04C1: + bufpush(0x04C2); + break; + case 0x04C3: + bufpush(0x04C4); + break; + case 0x04C5: + bufpush(0x04C6); + break; + case 0x04C7: + bufpush(0x04C8); + break; + case 0x04C9: + bufpush(0x04CA); + break; + case 0x04CB: + bufpush(0x04CC); + break; + case 0x04CD: + bufpush(0x04CE); + break; + case 0x04D0: + bufpush(0x04D1); + break; + case 0x04D2: + bufpush(0x04D3); + break; + case 0x04D4: + bufpush(0x04D5); + break; + case 0x04D6: + bufpush(0x04D7); + break; + case 0x04D8: + bufpush(0x04D9); + break; + case 0x04DA: + bufpush(0x04DB); + break; + case 0x04DC: + bufpush(0x04DD); + break; + case 0x04DE: + bufpush(0x04DF); + break; + case 0x04E0: + bufpush(0x04E1); + break; + case 0x04E2: + bufpush(0x04E3); + break; + case 0x04E4: + bufpush(0x04E5); + break; + case 0x04E6: + bufpush(0x04E7); + break; + case 0x04E8: + bufpush(0x04E9); + break; + case 0x04EA: + bufpush(0x04EB); + break; + case 0x04EC: + bufpush(0x04ED); + break; + case 0x04EE: + bufpush(0x04EF); + break; + case 0x04F0: + bufpush(0x04F1); + break; + case 0x04F2: + bufpush(0x04F3); + break; + case 0x04F4: + bufpush(0x04F5); + break; + case 0x04F8: + bufpush(0x04F9); + break; + case 0x0500: + bufpush(0x0501); + break; + case 0x0502: + bufpush(0x0503); + break; + case 0x0504: + bufpush(0x0505); + break; + case 0x0506: + bufpush(0x0507); + break; + case 0x0508: + bufpush(0x0509); + break; + case 0x050A: + bufpush(0x050B); + break; + case 0x050C: + bufpush(0x050D); + break; + case 0x050E: + bufpush(0x050F); + break; + case 0x0531: + bufpush(0x0561); + break; + case 0x0532: + bufpush(0x0562); + break; + case 0x0533: + bufpush(0x0563); + break; + case 0x0534: + bufpush(0x0564); + break; + case 0x0535: + bufpush(0x0565); + break; + case 0x0536: + bufpush(0x0566); + break; + case 0x0537: + bufpush(0x0567); + break; + case 0x0538: + bufpush(0x0568); + break; + case 0x0539: + bufpush(0x0569); + break; + case 0x053A: + bufpush(0x056A); + break; + case 0x053B: + bufpush(0x056B); + break; + case 0x053C: + bufpush(0x056C); + break; + case 0x053D: + bufpush(0x056D); + break; + case 0x053E: + bufpush(0x056E); + break; + case 0x053F: + bufpush(0x056F); + break; + case 0x0540: + bufpush(0x0570); + break; + case 0x0541: + bufpush(0x0571); + break; + case 0x0542: + bufpush(0x0572); + break; + case 0x0543: + bufpush(0x0573); + break; + case 0x0544: + bufpush(0x0574); + break; + case 0x0545: + bufpush(0x0575); + break; + case 0x0546: + bufpush(0x0576); + break; + case 0x0547: + bufpush(0x0577); + break; + case 0x0548: + bufpush(0x0578); + break; + case 0x0549: + bufpush(0x0579); + break; + case 0x054A: + bufpush(0x057A); + break; + case 0x054B: + bufpush(0x057B); + break; + case 0x054C: + bufpush(0x057C); + break; + case 0x054D: + bufpush(0x057D); + break; + case 0x054E: + bufpush(0x057E); + break; + case 0x054F: + bufpush(0x057F); + break; + case 0x0550: + bufpush(0x0580); + break; + case 0x0551: + bufpush(0x0581); + break; + case 0x0552: + bufpush(0x0582); + break; + case 0x0553: + bufpush(0x0583); + break; + case 0x0554: + bufpush(0x0584); + break; + case 0x0555: + bufpush(0x0585); + break; + case 0x0556: + bufpush(0x0586); + break; + case 0x0587: + bufpush(0x0565); + bufpush(0x0582); + break; + case 0x1E00: + bufpush(0x1E01); + break; + case 0x1E02: + bufpush(0x1E03); + break; + case 0x1E04: + bufpush(0x1E05); + break; + case 0x1E06: + bufpush(0x1E07); + break; + case 0x1E08: + bufpush(0x1E09); + break; + case 0x1E0A: + bufpush(0x1E0B); + break; + case 0x1E0C: + bufpush(0x1E0D); + break; + case 0x1E0E: + bufpush(0x1E0F); + break; + case 0x1E10: + bufpush(0x1E11); + break; + case 0x1E12: + bufpush(0x1E13); + break; + case 0x1E14: + bufpush(0x1E15); + break; + case 0x1E16: + bufpush(0x1E17); + break; + case 0x1E18: + bufpush(0x1E19); + break; + case 0x1E1A: + bufpush(0x1E1B); + break; + case 0x1E1C: + bufpush(0x1E1D); + break; + case 0x1E1E: + bufpush(0x1E1F); + break; + case 0x1E20: + bufpush(0x1E21); + break; + case 0x1E22: + bufpush(0x1E23); + break; + case 0x1E24: + bufpush(0x1E25); + break; + case 0x1E26: + bufpush(0x1E27); + break; + case 0x1E28: + bufpush(0x1E29); + break; + case 0x1E2A: + bufpush(0x1E2B); + break; + case 0x1E2C: + bufpush(0x1E2D); + break; + case 0x1E2E: + bufpush(0x1E2F); + break; + case 0x1E30: + bufpush(0x1E31); + break; + case 0x1E32: + bufpush(0x1E33); + break; + case 0x1E34: + bufpush(0x1E35); + break; + case 0x1E36: + bufpush(0x1E37); + break; + case 0x1E38: + bufpush(0x1E39); + break; + case 0x1E3A: + bufpush(0x1E3B); + break; + case 0x1E3C: + bufpush(0x1E3D); + break; + case 0x1E3E: + bufpush(0x1E3F); + break; + case 0x1E40: + bufpush(0x1E41); + break; + case 0x1E42: + bufpush(0x1E43); + break; + case 0x1E44: + bufpush(0x1E45); + break; + case 0x1E46: + bufpush(0x1E47); + break; + case 0x1E48: + bufpush(0x1E49); + break; + case 0x1E4A: + bufpush(0x1E4B); + break; + case 0x1E4C: + bufpush(0x1E4D); + break; + case 0x1E4E: + bufpush(0x1E4F); + break; + case 0x1E50: + bufpush(0x1E51); + break; + case 0x1E52: + bufpush(0x1E53); + break; + case 0x1E54: + bufpush(0x1E55); + break; + case 0x1E56: + bufpush(0x1E57); + break; + case 0x1E58: + bufpush(0x1E59); + break; + case 0x1E5A: + bufpush(0x1E5B); + break; + case 0x1E5C: + bufpush(0x1E5D); + break; + case 0x1E5E: + bufpush(0x1E5F); + break; + case 0x1E60: + bufpush(0x1E61); + break; + case 0x1E62: + bufpush(0x1E63); + break; + case 0x1E64: + bufpush(0x1E65); + break; + case 0x1E66: + bufpush(0x1E67); + break; + case 0x1E68: + bufpush(0x1E69); + break; + case 0x1E6A: + bufpush(0x1E6B); + break; + case 0x1E6C: + bufpush(0x1E6D); + break; + case 0x1E6E: + bufpush(0x1E6F); + break; + case 0x1E70: + bufpush(0x1E71); + break; + case 0x1E72: + bufpush(0x1E73); + break; + case 0x1E74: + bufpush(0x1E75); + break; + case 0x1E76: + bufpush(0x1E77); + break; + case 0x1E78: + bufpush(0x1E79); + break; + case 0x1E7A: + bufpush(0x1E7B); + break; + case 0x1E7C: + bufpush(0x1E7D); + break; + case 0x1E7E: + bufpush(0x1E7F); + break; + case 0x1E80: + bufpush(0x1E81); + break; + case 0x1E82: + bufpush(0x1E83); + break; + case 0x1E84: + bufpush(0x1E85); + break; + case 0x1E86: + bufpush(0x1E87); + break; + case 0x1E88: + bufpush(0x1E89); + break; + case 0x1E8A: + bufpush(0x1E8B); + break; + case 0x1E8C: + bufpush(0x1E8D); + break; + case 0x1E8E: + bufpush(0x1E8F); + break; + case 0x1E90: + bufpush(0x1E91); + break; + case 0x1E92: + bufpush(0x1E93); + break; + case 0x1E94: + bufpush(0x1E95); + break; + case 0x1E96: + bufpush(0x0068); + bufpush(0x0331); + break; + case 0x1E97: + bufpush(0x0074); + bufpush(0x0308); + break; + case 0x1E98: + bufpush(0x0077); + bufpush(0x030A); + break; + case 0x1E99: + bufpush(0x0079); + bufpush(0x030A); + break; + case 0x1E9A: + bufpush(0x0061); + bufpush(0x02BE); + break; + case 0x1E9B: + bufpush(0x1E61); + break; + case 0x1EA0: + bufpush(0x1EA1); + break; + case 0x1EA2: + bufpush(0x1EA3); + break; + case 0x1EA4: + bufpush(0x1EA5); + break; + case 0x1EA6: + bufpush(0x1EA7); + break; + case 0x1EA8: + bufpush(0x1EA9); + break; + case 0x1EAA: + bufpush(0x1EAB); + break; + case 0x1EAC: + bufpush(0x1EAD); + break; + case 0x1EAE: + bufpush(0x1EAF); + break; + case 0x1EB0: + bufpush(0x1EB1); + break; + case 0x1EB2: + bufpush(0x1EB3); + break; + case 0x1EB4: + bufpush(0x1EB5); + break; + case 0x1EB6: + bufpush(0x1EB7); + break; + case 0x1EB8: + bufpush(0x1EB9); + break; + case 0x1EBA: + bufpush(0x1EBB); + break; + case 0x1EBC: + bufpush(0x1EBD); + break; + case 0x1EBE: + bufpush(0x1EBF); + break; + case 0x1EC0: + bufpush(0x1EC1); + break; + case 0x1EC2: + bufpush(0x1EC3); + break; + case 0x1EC4: + bufpush(0x1EC5); + break; + case 0x1EC6: + bufpush(0x1EC7); + break; + case 0x1EC8: + bufpush(0x1EC9); + break; + case 0x1ECA: + bufpush(0x1ECB); + break; + case 0x1ECC: + bufpush(0x1ECD); + break; + case 0x1ECE: + bufpush(0x1ECF); + break; + case 0x1ED0: + bufpush(0x1ED1); + break; + case 0x1ED2: + bufpush(0x1ED3); + break; + case 0x1ED4: + bufpush(0x1ED5); + break; + case 0x1ED6: + bufpush(0x1ED7); + break; + case 0x1ED8: + bufpush(0x1ED9); + break; + case 0x1EDA: + bufpush(0x1EDB); + break; + case 0x1EDC: + bufpush(0x1EDD); + break; + case 0x1EDE: + bufpush(0x1EDF); + break; + case 0x1EE0: + bufpush(0x1EE1); + break; + case 0x1EE2: + bufpush(0x1EE3); + break; + case 0x1EE4: + bufpush(0x1EE5); + break; + case 0x1EE6: + bufpush(0x1EE7); + break; + case 0x1EE8: + bufpush(0x1EE9); + break; + case 0x1EEA: + bufpush(0x1EEB); + break; + case 0x1EEC: + bufpush(0x1EED); + break; + case 0x1EEE: + bufpush(0x1EEF); + break; + case 0x1EF0: + bufpush(0x1EF1); + break; + case 0x1EF2: + bufpush(0x1EF3); + break; + case 0x1EF4: + bufpush(0x1EF5); + break; + case 0x1EF6: + bufpush(0x1EF7); + break; + case 0x1EF8: + bufpush(0x1EF9); + break; + case 0x1F08: + bufpush(0x1F00); + break; + case 0x1F09: + bufpush(0x1F01); + break; + case 0x1F0A: + bufpush(0x1F02); + break; + case 0x1F0B: + bufpush(0x1F03); + break; + case 0x1F0C: + bufpush(0x1F04); + break; + case 0x1F0D: + bufpush(0x1F05); + break; + case 0x1F0E: + bufpush(0x1F06); + break; + case 0x1F0F: + bufpush(0x1F07); + break; + case 0x1F18: + bufpush(0x1F10); + break; + case 0x1F19: + bufpush(0x1F11); + break; + case 0x1F1A: + bufpush(0x1F12); + break; + case 0x1F1B: + bufpush(0x1F13); + break; + case 0x1F1C: + bufpush(0x1F14); + break; + case 0x1F1D: + bufpush(0x1F15); + break; + case 0x1F28: + bufpush(0x1F20); + break; + case 0x1F29: + bufpush(0x1F21); + break; + case 0x1F2A: + bufpush(0x1F22); + break; + case 0x1F2B: + bufpush(0x1F23); + break; + case 0x1F2C: + bufpush(0x1F24); + break; + case 0x1F2D: + bufpush(0x1F25); + break; + case 0x1F2E: + bufpush(0x1F26); + break; + case 0x1F2F: + bufpush(0x1F27); + break; + case 0x1F38: + bufpush(0x1F30); + break; + case 0x1F39: + bufpush(0x1F31); + break; + case 0x1F3A: + bufpush(0x1F32); + break; + case 0x1F3B: + bufpush(0x1F33); + break; + case 0x1F3C: + bufpush(0x1F34); + break; + case 0x1F3D: + bufpush(0x1F35); + break; + case 0x1F3E: + bufpush(0x1F36); + break; + case 0x1F3F: + bufpush(0x1F37); + break; + case 0x1F48: + bufpush(0x1F40); + break; + case 0x1F49: + bufpush(0x1F41); + break; + case 0x1F4A: + bufpush(0x1F42); + break; + case 0x1F4B: + bufpush(0x1F43); + break; + case 0x1F4C: + bufpush(0x1F44); + break; + case 0x1F4D: + bufpush(0x1F45); + break; + case 0x1F50: + bufpush(0x03C5); + bufpush(0x0313); + break; + case 0x1F52: + bufpush(0x03C5); + bufpush(0x0313); + bufpush(0x0300); + break; + case 0x1F54: + bufpush(0x03C5); + bufpush(0x0313); + bufpush(0x0301); + break; + case 0x1F56: + bufpush(0x03C5); + bufpush(0x0313); + bufpush(0x0342); + break; + case 0x1F59: + bufpush(0x1F51); + break; + case 0x1F5B: + bufpush(0x1F53); + break; + case 0x1F5D: + bufpush(0x1F55); + break; + case 0x1F5F: + bufpush(0x1F57); + break; + case 0x1F68: + bufpush(0x1F60); + break; + case 0x1F69: + bufpush(0x1F61); + break; + case 0x1F6A: + bufpush(0x1F62); + break; + case 0x1F6B: + bufpush(0x1F63); + break; + case 0x1F6C: + bufpush(0x1F64); + break; + case 0x1F6D: + bufpush(0x1F65); + break; + case 0x1F6E: + bufpush(0x1F66); + break; + case 0x1F6F: + bufpush(0x1F67); + break; + case 0x1F80: + bufpush(0x1F00); + bufpush(0x03B9); + break; + case 0x1F81: + bufpush(0x1F01); + bufpush(0x03B9); + break; + case 0x1F82: + bufpush(0x1F02); + bufpush(0x03B9); + break; + case 0x1F83: + bufpush(0x1F03); + bufpush(0x03B9); + break; + case 0x1F84: + bufpush(0x1F04); + bufpush(0x03B9); + break; + case 0x1F85: + bufpush(0x1F05); + bufpush(0x03B9); + break; + case 0x1F86: + bufpush(0x1F06); + bufpush(0x03B9); + break; + case 0x1F87: + bufpush(0x1F07); + bufpush(0x03B9); + break; + case 0x1F88: + bufpush(0x1F00); + bufpush(0x03B9); + break; + case 0x1F89: + bufpush(0x1F01); + bufpush(0x03B9); + break; + case 0x1F8A: + bufpush(0x1F02); + bufpush(0x03B9); + break; + case 0x1F8B: + bufpush(0x1F03); + bufpush(0x03B9); + break; + case 0x1F8C: + bufpush(0x1F04); + bufpush(0x03B9); + break; + case 0x1F8D: + bufpush(0x1F05); + bufpush(0x03B9); + break; + case 0x1F8E: + bufpush(0x1F06); + bufpush(0x03B9); + break; + case 0x1F8F: + bufpush(0x1F07); + bufpush(0x03B9); + break; + case 0x1F90: + bufpush(0x1F20); + bufpush(0x03B9); + break; + case 0x1F91: + bufpush(0x1F21); + bufpush(0x03B9); + break; + case 0x1F92: + bufpush(0x1F22); + bufpush(0x03B9); + break; + case 0x1F93: + bufpush(0x1F23); + bufpush(0x03B9); + break; + case 0x1F94: + bufpush(0x1F24); + bufpush(0x03B9); + break; + case 0x1F95: + bufpush(0x1F25); + bufpush(0x03B9); + break; + case 0x1F96: + bufpush(0x1F26); + bufpush(0x03B9); + break; + case 0x1F97: + bufpush(0x1F27); + bufpush(0x03B9); + break; + case 0x1F98: + bufpush(0x1F20); + bufpush(0x03B9); + break; + case 0x1F99: + bufpush(0x1F21); + bufpush(0x03B9); + break; + case 0x1F9A: + bufpush(0x1F22); + bufpush(0x03B9); + break; + case 0x1F9B: + bufpush(0x1F23); + bufpush(0x03B9); + break; + case 0x1F9C: + bufpush(0x1F24); + bufpush(0x03B9); + break; + case 0x1F9D: + bufpush(0x1F25); + bufpush(0x03B9); + break; + case 0x1F9E: + bufpush(0x1F26); + bufpush(0x03B9); + break; + case 0x1F9F: + bufpush(0x1F27); + bufpush(0x03B9); + break; + case 0x1FA0: + bufpush(0x1F60); + bufpush(0x03B9); + break; + case 0x1FA1: + bufpush(0x1F61); + bufpush(0x03B9); + break; + case 0x1FA2: + bufpush(0x1F62); + bufpush(0x03B9); + break; + case 0x1FA3: + bufpush(0x1F63); + bufpush(0x03B9); + break; + case 0x1FA4: + bufpush(0x1F64); + bufpush(0x03B9); + break; + case 0x1FA5: + bufpush(0x1F65); + bufpush(0x03B9); + break; + case 0x1FA6: + bufpush(0x1F66); + bufpush(0x03B9); + break; + case 0x1FA7: + bufpush(0x1F67); + bufpush(0x03B9); + break; + case 0x1FA8: + bufpush(0x1F60); + bufpush(0x03B9); + break; + case 0x1FA9: + bufpush(0x1F61); + bufpush(0x03B9); + break; + case 0x1FAA: + bufpush(0x1F62); + bufpush(0x03B9); + break; + case 0x1FAB: + bufpush(0x1F63); + bufpush(0x03B9); + break; + case 0x1FAC: + bufpush(0x1F64); + bufpush(0x03B9); + break; + case 0x1FAD: + bufpush(0x1F65); + bufpush(0x03B9); + break; + case 0x1FAE: + bufpush(0x1F66); + bufpush(0x03B9); + break; + case 0x1FAF: + bufpush(0x1F67); + bufpush(0x03B9); + break; + case 0x1FB2: + bufpush(0x1F70); + bufpush(0x03B9); + break; + case 0x1FB3: + bufpush(0x03B1); + bufpush(0x03B9); + break; + case 0x1FB4: + bufpush(0x03AC); + bufpush(0x03B9); + break; + case 0x1FB6: + bufpush(0x03B1); + bufpush(0x0342); + break; + case 0x1FB7: + bufpush(0x03B1); + bufpush(0x0342); + bufpush(0x03B9); + break; + case 0x1FB8: + bufpush(0x1FB0); + break; + case 0x1FB9: + bufpush(0x1FB1); + break; + case 0x1FBA: + bufpush(0x1F70); + break; + case 0x1FBB: + bufpush(0x1F71); + break; + case 0x1FBC: + bufpush(0x03B1); + bufpush(0x03B9); + break; + case 0x1FBE: + bufpush(0x03B9); + break; + case 0x1FC2: + bufpush(0x1F74); + bufpush(0x03B9); + break; + case 0x1FC3: + bufpush(0x03B7); + bufpush(0x03B9); + break; + case 0x1FC4: + bufpush(0x03AE); + bufpush(0x03B9); + break; + case 0x1FC6: + bufpush(0x03B7); + bufpush(0x0342); + break; + case 0x1FC7: + bufpush(0x03B7); + bufpush(0x0342); + bufpush(0x03B9); + break; + case 0x1FC8: + bufpush(0x1F72); + break; + case 0x1FC9: + bufpush(0x1F73); + break; + case 0x1FCA: + bufpush(0x1F74); + break; + case 0x1FCB: + bufpush(0x1F75); + break; + case 0x1FCC: + bufpush(0x03B7); + bufpush(0x03B9); + break; + case 0x1FD2: + bufpush(0x03B9); + bufpush(0x0308); + bufpush(0x0300); + break; + case 0x1FD3: + bufpush(0x03B9); + bufpush(0x0308); + bufpush(0x0301); + break; + case 0x1FD6: + bufpush(0x03B9); + bufpush(0x0342); + break; + case 0x1FD7: + bufpush(0x03B9); + bufpush(0x0308); + bufpush(0x0342); + break; + case 0x1FD8: + bufpush(0x1FD0); + break; + case 0x1FD9: + bufpush(0x1FD1); + break; + case 0x1FDA: + bufpush(0x1F76); + break; + case 0x1FDB: + bufpush(0x1F77); + break; + case 0x1FE2: + bufpush(0x03C5); + bufpush(0x0308); + bufpush(0x0300); + break; + case 0x1FE3: + bufpush(0x03C5); + bufpush(0x0308); + bufpush(0x0301); + break; + case 0x1FE4: + bufpush(0x03C1); + bufpush(0x0313); + break; + case 0x1FE6: + bufpush(0x03C5); + bufpush(0x0342); + break; + case 0x1FE7: + bufpush(0x03C5); + bufpush(0x0308); + bufpush(0x0342); + break; + case 0x1FE8: + bufpush(0x1FE0); + break; + case 0x1FE9: + bufpush(0x1FE1); + break; + case 0x1FEA: + bufpush(0x1F7A); + break; + case 0x1FEB: + bufpush(0x1F7B); + break; + case 0x1FEC: + bufpush(0x1FE5); + break; + case 0x1FF2: + bufpush(0x1F7C); + bufpush(0x03B9); + break; + case 0x1FF3: + bufpush(0x03C9); + bufpush(0x03B9); + break; + case 0x1FF4: + bufpush(0x03CE); + bufpush(0x03B9); + break; + case 0x1FF6: + bufpush(0x03C9); + bufpush(0x0342); + break; + case 0x1FF7: + bufpush(0x03C9); + bufpush(0x0342); + bufpush(0x03B9); + break; + case 0x1FF8: + bufpush(0x1F78); + break; + case 0x1FF9: + bufpush(0x1F79); + break; + case 0x1FFA: + bufpush(0x1F7C); + break; + case 0x1FFB: + bufpush(0x1F7D); + break; + case 0x1FFC: + bufpush(0x03C9); + bufpush(0x03B9); + break; + case 0x2126: + bufpush(0x03C9); + break; + case 0x212A: + bufpush(0x006B); + break; + case 0x212B: + bufpush(0x00E5); + break; + case 0x2160: + bufpush(0x2170); + break; + case 0x2161: + bufpush(0x2171); + break; + case 0x2162: + bufpush(0x2172); + break; + case 0x2163: + bufpush(0x2173); + break; + case 0x2164: + bufpush(0x2174); + break; + case 0x2165: + bufpush(0x2175); + break; + case 0x2166: + bufpush(0x2176); + break; + case 0x2167: + bufpush(0x2177); + break; + case 0x2168: + bufpush(0x2178); + break; + case 0x2169: + bufpush(0x2179); + break; + case 0x216A: + bufpush(0x217A); + break; + case 0x216B: + bufpush(0x217B); + break; + case 0x216C: + bufpush(0x217C); + break; + case 0x216D: + bufpush(0x217D); + break; + case 0x216E: + bufpush(0x217E); + break; + case 0x216F: + bufpush(0x217F); + break; + case 0x24B6: + bufpush(0x24D0); + break; + case 0x24B7: + bufpush(0x24D1); + break; + case 0x24B8: + bufpush(0x24D2); + break; + case 0x24B9: + bufpush(0x24D3); + break; + case 0x24BA: + bufpush(0x24D4); + break; + case 0x24BB: + bufpush(0x24D5); + break; + case 0x24BC: + bufpush(0x24D6); + break; + case 0x24BD: + bufpush(0x24D7); + break; + case 0x24BE: + bufpush(0x24D8); + break; + case 0x24BF: + bufpush(0x24D9); + break; + case 0x24C0: + bufpush(0x24DA); + break; + case 0x24C1: + bufpush(0x24DB); + break; + case 0x24C2: + bufpush(0x24DC); + break; + case 0x24C3: + bufpush(0x24DD); + break; + case 0x24C4: + bufpush(0x24DE); + break; + case 0x24C5: + bufpush(0x24DF); + break; + case 0x24C6: + bufpush(0x24E0); + break; + case 0x24C7: + bufpush(0x24E1); + break; + case 0x24C8: + bufpush(0x24E2); + break; + case 0x24C9: + bufpush(0x24E3); + break; + case 0x24CA: + bufpush(0x24E4); + break; + case 0x24CB: + bufpush(0x24E5); + break; + case 0x24CC: + bufpush(0x24E6); + break; + case 0x24CD: + bufpush(0x24E7); + break; + case 0x24CE: + bufpush(0x24E8); + break; + case 0x24CF: + bufpush(0x24E9); + break; + case 0xFB00: + bufpush(0x0066); + bufpush(0x0066); + break; + case 0xFB01: + bufpush(0x0066); + bufpush(0x0069); + break; + case 0xFB02: + bufpush(0x0066); + bufpush(0x006C); + break; + case 0xFB03: + bufpush(0x0066); + bufpush(0x0066); + bufpush(0x0069); + break; + case 0xFB04: + bufpush(0x0066); + bufpush(0x0066); + bufpush(0x006C); + break; + case 0xFB05: + bufpush(0x0073); + bufpush(0x0074); + break; + case 0xFB06: + bufpush(0x0073); + bufpush(0x0074); + break; + case 0xFB13: + bufpush(0x0574); + bufpush(0x0576); + break; + case 0xFB14: + bufpush(0x0574); + bufpush(0x0565); + break; + case 0xFB15: + bufpush(0x0574); + bufpush(0x056B); + break; + case 0xFB16: + bufpush(0x057E); + bufpush(0x0576); + break; + case 0xFB17: + bufpush(0x0574); + bufpush(0x056D); + break; + case 0xFF21: + bufpush(0xFF41); + break; + case 0xFF22: + bufpush(0xFF42); + break; + case 0xFF23: + bufpush(0xFF43); + break; + case 0xFF24: + bufpush(0xFF44); + break; + case 0xFF25: + bufpush(0xFF45); + break; + case 0xFF26: + bufpush(0xFF46); + break; + case 0xFF27: + bufpush(0xFF47); + break; + case 0xFF28: + bufpush(0xFF48); + break; + case 0xFF29: + bufpush(0xFF49); + break; + case 0xFF2A: + bufpush(0xFF4A); + break; + case 0xFF2B: + bufpush(0xFF4B); + break; + case 0xFF2C: + bufpush(0xFF4C); + break; + case 0xFF2D: + bufpush(0xFF4D); + break; + case 0xFF2E: + bufpush(0xFF4E); + break; + case 0xFF2F: + bufpush(0xFF4F); + break; + case 0xFF30: + bufpush(0xFF50); + break; + case 0xFF31: + bufpush(0xFF51); + break; + case 0xFF32: + bufpush(0xFF52); + break; + case 0xFF33: + bufpush(0xFF53); + break; + case 0xFF34: + bufpush(0xFF54); + break; + case 0xFF35: + bufpush(0xFF55); + break; + case 0xFF36: + bufpush(0xFF56); + break; + case 0xFF37: + bufpush(0xFF57); + break; + case 0xFF38: + bufpush(0xFF58); + break; + case 0xFF39: + bufpush(0xFF59); + break; + case 0xFF3A: + bufpush(0xFF5A); + break; + case 0x10400: + bufpush(0x10428); + break; + case 0x10401: + bufpush(0x10429); + break; + case 0x10402: + bufpush(0x1042A); + break; + case 0x10403: + bufpush(0x1042B); + break; + case 0x10404: + bufpush(0x1042C); + break; + case 0x10405: + bufpush(0x1042D); + break; + case 0x10406: + bufpush(0x1042E); + break; + case 0x10407: + bufpush(0x1042F); + break; + case 0x10408: + bufpush(0x10430); + break; + case 0x10409: + bufpush(0x10431); + break; + case 0x1040A: + bufpush(0x10432); + break; + case 0x1040B: + bufpush(0x10433); + break; + case 0x1040C: + bufpush(0x10434); + break; + case 0x1040D: + bufpush(0x10435); + break; + case 0x1040E: + bufpush(0x10436); + break; + case 0x1040F: + bufpush(0x10437); + break; + case 0x10410: + bufpush(0x10438); + break; + case 0x10411: + bufpush(0x10439); + break; + case 0x10412: + bufpush(0x1043A); + break; + case 0x10413: + bufpush(0x1043B); + break; + case 0x10414: + bufpush(0x1043C); + break; + case 0x10415: + bufpush(0x1043D); + break; + case 0x10416: + bufpush(0x1043E); + break; + case 0x10417: + bufpush(0x1043F); + break; + case 0x10418: + bufpush(0x10440); + break; + case 0x10419: + bufpush(0x10441); + break; + case 0x1041A: + bufpush(0x10442); + break; + case 0x1041B: + bufpush(0x10443); + break; + case 0x1041C: + bufpush(0x10444); + break; + case 0x1041D: + bufpush(0x10445); + break; + case 0x1041E: + bufpush(0x10446); + break; + case 0x1041F: + bufpush(0x10447); + break; + case 0x10420: + bufpush(0x10448); + break; + case 0x10421: + bufpush(0x10449); + break; + case 0x10422: + bufpush(0x1044A); + break; + case 0x10423: + bufpush(0x1044B); + break; + case 0x10424: + bufpush(0x1044C); + break; + case 0x10425: + bufpush(0x1044D); + break; + default: + bufpush(c); + } diff --git a/cbits/chunk.h b/cbits/chunk.h new file mode 100644 --- /dev/null +++ b/cbits/chunk.h @@ -0,0 +1,110 @@ +#ifndef CMARK_CHUNK_H +#define CMARK_CHUNK_H + +#include +#include +#include +#include "cmark_ctype.h" +#include "buffer.h" + +typedef struct { + unsigned char *data; + int len; + int alloc; // also implies a NULL-terminated string +} cmark_chunk; + +static inline void cmark_chunk_free(cmark_chunk *c) +{ + if (c->alloc) + free(c->data); + + c->data = NULL; + c->alloc = 0; + c->len = 0; +} + +static inline void cmark_chunk_ltrim(cmark_chunk *c) +{ + assert(!c->alloc); + + while (c->len && cmark_isspace(c->data[0])) { + c->data++; + c->len--; + } +} + +static inline void cmark_chunk_rtrim(cmark_chunk *c) +{ + while (c->len > 0) { + if (!cmark_isspace(c->data[c->len - 1])) + break; + + c->len--; + } +} + +static inline void cmark_chunk_trim(cmark_chunk *c) +{ + cmark_chunk_ltrim(c); + cmark_chunk_rtrim(c); +} + +static inline int cmark_chunk_strchr(cmark_chunk *ch, int c, int offset) +{ + const unsigned char *p = (unsigned char *)memchr(ch->data + offset, c, ch->len - offset); + return p ? (int)(p - ch->data) : ch->len; +} + +static inline const char *cmark_chunk_to_cstr(cmark_chunk *c) +{ + unsigned char *str; + + if (c->alloc) { + return (char *)c->data; + } + str = (unsigned char *)malloc(c->len + 1); + if(str != NULL) { + memcpy(str, c->data, c->len); + str[c->len] = 0; + } + c->data = str; + c->alloc = 1; + + return (char *)str; +} + +static inline void cmark_chunk_set_cstr(cmark_chunk *c, const char *str) +{ + if (c->alloc) { + free(c->data); + } + c->len = strlen(str); + c->data = (unsigned char *)malloc(c->len + 1); + c->alloc = 1; + memcpy(c->data, str, c->len + 1); +} + +static inline cmark_chunk cmark_chunk_literal(const char *data) +{ + cmark_chunk c = {(unsigned char *)data, data ? strlen(data) : 0, 0}; + return c; +} + +static inline cmark_chunk cmark_chunk_dup(const cmark_chunk *ch, int pos, int len) +{ + cmark_chunk c = {ch->data + pos, len, 0}; + return c; +} + +static inline cmark_chunk cmark_chunk_buf_detach(cmark_strbuf *buf) +{ + cmark_chunk c; + + c.len = buf->size; + c.data = cmark_strbuf_detach(buf); + c.alloc = 1; + + return c; +} + +#endif diff --git a/cbits/cmark.c b/cbits/cmark.c new file mode 100644 --- /dev/null +++ b/cbits/cmark.c @@ -0,0 +1,24 @@ +#include +#include +#include +#include "node.h" +#include "houdini.h" +#include "cmark.h" +#include "buffer.h" + +const int cmark_version = CMARK_VERSION; +const char cmark_version_string[] = CMARK_VERSION_STRING; + +char *cmark_markdown_to_html(const char *text, int len, int options) +{ + cmark_node *doc; + char *result; + + doc = cmark_parse_document(text, len, options); + + result = cmark_render_html(doc, options); + cmark_node_free(doc); + + return result; +} + diff --git a/cbits/cmark.h b/cbits/cmark.h new file mode 100644 --- /dev/null +++ b/cbits/cmark.h @@ -0,0 +1,560 @@ +#ifndef CMARK_H +#define CMARK_H + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** # NAME + * + * **cmark** - CommonMark parsing, manipulating, and rendering + */ + +/** # DESCRIPTION + * + * ## Simple Interface + */ + +/** Convert 'text' (assumed to be a UTF-8 encoded string with length + * 'len' from CommonMark Markdown to HTML, returning a null-terminated, + * UTF-8-encoded string. + */ +CMARK_EXPORT +char *cmark_markdown_to_html(const char *text, int len, int options); + +/** ## Node Structure + */ + +typedef enum { + /* Error status */ + CMARK_NODE_NONE, + + /* Block */ + CMARK_NODE_DOCUMENT, + CMARK_NODE_BLOCK_QUOTE, + CMARK_NODE_LIST, + CMARK_NODE_ITEM, + CMARK_NODE_CODE_BLOCK, + CMARK_NODE_HTML, + CMARK_NODE_PARAGRAPH, + CMARK_NODE_HEADER, + CMARK_NODE_HRULE, + + CMARK_NODE_FIRST_BLOCK = CMARK_NODE_DOCUMENT, + CMARK_NODE_LAST_BLOCK = CMARK_NODE_HRULE, + + /* Inline */ + CMARK_NODE_TEXT, + CMARK_NODE_SOFTBREAK, + CMARK_NODE_LINEBREAK, + CMARK_NODE_CODE, + CMARK_NODE_INLINE_HTML, + CMARK_NODE_EMPH, + CMARK_NODE_STRONG, + CMARK_NODE_LINK, + CMARK_NODE_IMAGE, + + CMARK_NODE_FIRST_INLINE = CMARK_NODE_TEXT, + CMARK_NODE_LAST_INLINE = CMARK_NODE_IMAGE, +} cmark_node_type; + + +typedef enum { + CMARK_NO_LIST, + CMARK_BULLET_LIST, + CMARK_ORDERED_LIST +} cmark_list_type; + +typedef enum { + CMARK_NO_DELIM, + CMARK_PERIOD_DELIM, + CMARK_PAREN_DELIM +} cmark_delim_type; + +typedef struct cmark_node cmark_node; +typedef struct cmark_parser cmark_parser; +typedef struct cmark_iter cmark_iter; + +typedef enum { + CMARK_EVENT_NONE, + CMARK_EVENT_DONE, + CMARK_EVENT_ENTER, + CMARK_EVENT_EXIT +} cmark_event_type; + +/** + * ## Creating and Destroying Nodes + */ + +/** Creates a new node of type 'type'. Note that the node may have + * other required properties, which it is the caller's responsibility + * to assign. + */ +CMARK_EXPORT cmark_node* +cmark_node_new(cmark_node_type type); + +/** Frees the memory allocated for a node. + */ +CMARK_EXPORT void +cmark_node_free(cmark_node *node); + +/** + * ## Tree Traversal + */ + +/** Returns the next node in the sequence after 'node', or NULL if + * there is none. + */ +CMARK_EXPORT cmark_node* +cmark_node_next(cmark_node *node); + +/** Returns the previous node in the sequence after 'node', or NULL if + * there is none. + */ +CMARK_EXPORT cmark_node* +cmark_node_previous(cmark_node *node); + +/** Returns the parent of 'node', or NULL if there is none. + */ +CMARK_EXPORT cmark_node* +cmark_node_parent(cmark_node *node); + +/** Returns the first child of 'node', or NULL if 'node' has no children. + */ +CMARK_EXPORT cmark_node* +cmark_node_first_child(cmark_node *node); + +/** Returns the last child of 'node', or NULL if 'node' has no children. + */ +CMARK_EXPORT cmark_node* +cmark_node_last_child(cmark_node *node); + +/** + * ## Iterator + * + * An iterator will walk through a tree of nodes, starting from a root + * node, returning one node at a time, together with information about + * whether the node is being entered or exited. The iterator will + * first descend to a child node, if there is one. When there is no + * child, the iterator will go to the next sibling. When there is no + * next sibling, the iterator will return to the parent (but with + * a 'cmark_event_type' of `CMARK_EVENT_EXIT`). The iterator will + * return `CMARK_EVENT_DONE` when it reaches the root node again. + * One natural application is an HTML renderer, where an `ENTER` event + * outputs an open tag and an `EXIT` event outputs a close tag. + * An iterator might also be used to transform an AST in some systematic + * way, for example, turning all level-3 headers into regular paragraphs. + * + * void + * usage_example(cmark_node *root) { + * cmark_event_type ev_type; + * cmark_iter *iter = cmark_iter_new(root); + * + * while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { + * cmark_node *cur = cmark_iter_get_node(iter); + * // Do something with `cur` and `ev_type` + * } + * + * cmark_iter_free(iter); + * } + * + * Iterators will never return `EXIT` events for leaf nodes, which are nodes + * of type: + * + * * CMARK_NODE_HTML + * * CMARK_NODE_HRULE + * * CMARK_NODE_CODE_BLOCK + * * CMARK_NODE_TEXT + * * CMARK_NODE_SOFTBREAK + * * CMARK_NODE_LINEBREAK + * * CMARK_NODE_CODE + * * CMARK_NODE_INLINE_HTML + * + * Nodes must only be modified after an `EXIT` event, or an `ENTER` event for + * leaf nodes. + */ + +/** Creates a new iterator starting at 'root'. The current node and event + * type are undefined until `cmark_iter_next` is called for the first time. + */ +CMARK_EXPORT +cmark_iter* +cmark_iter_new(cmark_node *root); + +/** Frees the memory allocated for an iterator. + */ +CMARK_EXPORT +void +cmark_iter_free(cmark_iter *iter); + +/** Advances to the next node and returns the event type (`CMARK_EVENT_ENTER`, + * `CMARK_EVENT_EXIT` or `CMARK_EVENT_DONE`). + */ +CMARK_EXPORT +cmark_event_type +cmark_iter_next(cmark_iter *iter); + +/** Returns the current node. + */ +CMARK_EXPORT +cmark_node* +cmark_iter_get_node(cmark_iter *iter); + +/** Returns the current event type. + */ +CMARK_EXPORT +cmark_event_type +cmark_iter_get_event_type(cmark_iter *iter); + +/** Returns the root node. + */ +CMARK_EXPORT +cmark_node* +cmark_iter_get_root(cmark_iter *iter); + +/** Resets the iterator so that the current node is 'current' and + * the event type is 'event_type'. The new current node must be a + * descendant of the root node or the root node itself. + */ +CMARK_EXPORT +void +cmark_iter_reset(cmark_iter *iter, cmark_node *current, + cmark_event_type event_type); + +/** + * ## Accessors + */ + +/** Returns the user data of 'node'. + */ +CMARK_EXPORT void* +cmark_node_get_user_data(cmark_node *node); + +/** Sets arbitrary user data for 'node'. Returns 1 on success, + * 0 on failure. + */ +CMARK_EXPORT int +cmark_node_set_user_data(cmark_node *node, void *user_data); + +/** Returns the type of 'node', or `CMARK_NODE_NONE` on error. + */ +CMARK_EXPORT cmark_node_type +cmark_node_get_type(cmark_node *node); + +/** Like 'cmark_node_get_type', but returns a string representation + of the type, or `""`. + */ +CMARK_EXPORT +const char* +cmark_node_get_type_string(cmark_node *node); + +/** Returns the string contents of 'node', or NULL if none. + */ +CMARK_EXPORT const char* +cmark_node_get_literal(cmark_node *node); + +/** Sets the string contents of 'node'. Returns 1 on success, + * 0 on failure. + */ +CMARK_EXPORT int +cmark_node_set_literal(cmark_node *node, const char *content); + +/** Returns the header level of 'node', or 0 if 'node' is not a header. + */ +CMARK_EXPORT int +cmark_node_get_header_level(cmark_node *node); + +/** Sets the header level of 'node', returning 1 on success and 0 on error. + */ +CMARK_EXPORT int +cmark_node_set_header_level(cmark_node *node, int level); + +/** Returns the list type of 'node', or `CMARK_NO_LIST` if 'node' + * is not a list. + */ +CMARK_EXPORT cmark_list_type +cmark_node_get_list_type(cmark_node *node); + +/** Sets the list type of 'node', returning 1 on success and 0 on error. + */ +CMARK_EXPORT int +cmark_node_set_list_type(cmark_node *node, cmark_list_type type); + +/** Returns the list delimiter type of 'node', or `CMARK_NO_DELIM` if 'node' + * is not a list. + */ +CMARK_EXPORT cmark_delim_type +cmark_node_get_list_delim(cmark_node *node); + +/** Sets the list delimiter type of 'node', returning 1 on success and 0 + * on error. + */ +CMARK_EXPORT int +cmark_node_set_list_delim(cmark_node *node, cmark_delim_type delim); + +/** Returns starting number of 'node', if it is an ordered list, otherwise 0. + */ +CMARK_EXPORT int +cmark_node_get_list_start(cmark_node *node); + +/** Sets starting number of 'node', if it is an ordered list. Returns 1 + * on success, 0 on failure. + */ +CMARK_EXPORT int +cmark_node_set_list_start(cmark_node *node, int start); + +/** Returns 1 if 'node' is a tight list, 0 otherwise. + */ +CMARK_EXPORT int +cmark_node_get_list_tight(cmark_node *node); + +/** Sets the "tightness" of a list. Returns 1 on success, 0 on failure. + */ +CMARK_EXPORT int +cmark_node_set_list_tight(cmark_node *node, int tight); + +/** Returns the info string from a fenced code block, or NULL if none. + */ +CMARK_EXPORT const char* +cmark_node_get_fence_info(cmark_node *node); + +/** Sets the info string in a fenced code block, returning 1 on + * success and 0 on failure. + */ +CMARK_EXPORT int +cmark_node_set_fence_info(cmark_node *node, const char *info); + +/** Gets the URL of a link or image 'node', or NULL if none. + */ +CMARK_EXPORT const char* +cmark_node_get_url(cmark_node *node); + +/** Sets the URL of a link or image 'node'. Returns 1 on success, + * 0 on failure. + */ +CMARK_EXPORT int +cmark_node_set_url(cmark_node *node, const char *url); + +/** Gets the title of a link or image 'node', or NULL if none. + */ +CMARK_EXPORT const char* +cmark_node_get_title(cmark_node *node); + +/** Sets the title of a link or image 'node'. Returns 1 on success, + * 0 on failure. + */ +CMARK_EXPORT int +cmark_node_set_title(cmark_node *node, const char *title); + +/** Returns the line on which 'node' begins. + */ +CMARK_EXPORT int +cmark_node_get_start_line(cmark_node *node); + +/** Returns the column at which 'node' begins. + */ +CMARK_EXPORT int +cmark_node_get_start_column(cmark_node *node); + +/** Returns the line on which 'node' ends. + */ +CMARK_EXPORT int +cmark_node_get_end_line(cmark_node *node); + +/** Returns the column at which 'node' ends. + */ +CMARK_EXPORT int +cmark_node_get_end_column(cmark_node *node); + +/** + * ## Tree Manipulation + */ + +/** Unlinks a 'node', removing it from the tree, but not freeing its + * memory. (Use 'cmark_node_free' for that.) + */ +CMARK_EXPORT void +cmark_node_unlink(cmark_node *node); + +/** Inserts 'sibling' before 'node'. Returns 1 on success, 0 on failure. + */ +CMARK_EXPORT int +cmark_node_insert_before(cmark_node *node, cmark_node *sibling); + +/** Inserts 'sibling' after 'node'. Returns 1 on success, 0 on failure. + */ +CMARK_EXPORT int +cmark_node_insert_after(cmark_node *node, cmark_node *sibling); + +/** Adds 'child' to the beginning of the children of 'node'. + * Returns 1 on success, 0 on failure. + */ +CMARK_EXPORT int +cmark_node_prepend_child(cmark_node *node, cmark_node *child); + +/** Adds 'child' to the end of the children of 'node'. + * Returns 1 on success, 0 on failure. + */ +CMARK_EXPORT int +cmark_node_append_child(cmark_node *node, cmark_node *child); + +/** Consolidates adjacent text nodes. + */ +CMARK_EXPORT void +cmark_consolidate_text_nodes(cmark_node *root); + +/** + * ## Parsing + * + * Simple interface: + * + * cmark_node *document = cmark_parse_document("Hello *world*", 12, + * CMARK_OPT_DEFAULT); + * + * Streaming interface: + * + * cmark_parser *parser = cmark_parser_new(CMARK_OPT_DEFAULT); + * FILE *fp = fopen("myfile.md", "r"); + * while ((bytes = fread(buffer, 1, sizeof(buffer), fp)) > 0) { + * cmark_parser_feed(parser, buffer, bytes); + * if (bytes < sizeof(buffer)) { + * break; + * } + * } + * document = cmark_parser_finish(parser); + * cmark_parser_free(parser); + */ + +/** Creates a new parser object. + */ +CMARK_EXPORT +cmark_parser *cmark_parser_new(int options); + +/** Frees memory allocated for a parser object. + */ +CMARK_EXPORT +void cmark_parser_free(cmark_parser *parser); + +/** Feeds a string of length 'len' to 'parser'. + */ +CMARK_EXPORT +void cmark_parser_feed(cmark_parser *parser, const char *buffer, size_t len); + +/** Finish parsing and return a pointer to a tree of nodes. + */ +CMARK_EXPORT +cmark_node *cmark_parser_finish(cmark_parser *parser); + +/** Parse a CommonMark document in 'buffer' of length 'len'. + * Returns a pointer to a tree of nodes. + */ +CMARK_EXPORT +cmark_node *cmark_parse_document(const char *buffer, size_t len, int options); + +/** Parse a CommonMark document in file 'f', returning a pointer to + * a tree of nodes. + */ +CMARK_EXPORT +cmark_node *cmark_parse_file(FILE *f, int options); + +/** + * ## Rendering + */ + +/** Render a 'node' tree as XML. + */ +CMARK_EXPORT +char *cmark_render_xml(cmark_node *root, int options); + +/** Render a 'node' tree as an HTML fragment. It is up to the user + * to add an appropriate header and footer. + */ +CMARK_EXPORT +char *cmark_render_html(cmark_node *root, int options); + +/** Render a 'node' tree as a groff man page, without the header. + */ +CMARK_EXPORT +char *cmark_render_man(cmark_node *root, int options); + +/** Default writer options. + */ +#define CMARK_OPT_DEFAULT 0 + +/** Include a `data-sourcepos` attribute on all block elements. + */ +#define CMARK_OPT_SOURCEPOS 1 + +/** Render `softbreak` elements as hard line breaks. + */ +#define CMARK_OPT_HARDBREAKS 2 + +/** Normalize tree by consolidating adjacent text nodes. + */ +#define CMARK_OPT_NORMALIZE 4 + +/** Convert straight quotes to curly, --- to em dashes, -- to en dashes. + */ +#define CMARK_OPT_SMART 8 + +/** + * ## Version information + */ + +/** The library version as integer for runtime checks. Also available as + * macro CMARK_VERSION for compile time checks. + * + * * Bits 16-23 contain the major version. + * * Bits 8-15 contain the minor version. + * * Bits 0-7 contain the patchlevel. + * + * In hexadecimal format, the number 0x010203 represents version 1.2.3. + */ +CMARK_EXPORT +extern const int cmark_version; + +/** The library version string for runtime checks. Also available as + * macro CMARK_VERSION_STRING for compile time checks. + */ +CMARK_EXPORT +extern const char cmark_version_string[]; + +/** # AUTHORS + * + * John MacFarlane, Vicent Marti, Kārlis Gaņģis, Nick Wellnhofer. + */ + +#ifndef CMARK_NO_SHORT_NAMES +#define NODE_DOCUMENT CMARK_NODE_DOCUMENT +#define NODE_BLOCK_QUOTE CMARK_NODE_BLOCK_QUOTE +#define NODE_LIST CMARK_NODE_LIST +#define NODE_ITEM CMARK_NODE_ITEM +#define NODE_CODE_BLOCK CMARK_NODE_CODE_BLOCK +#define NODE_HTML CMARK_NODE_HTML +#define NODE_PARAGRAPH CMARK_NODE_PARAGRAPH +#define NODE_HEADER CMARK_NODE_HEADER +#define NODE_HRULE CMARK_NODE_HRULE +#define NODE_TEXT CMARK_NODE_TEXT +#define NODE_SOFTBREAK CMARK_NODE_SOFTBREAK +#define NODE_LINEBREAK CMARK_NODE_LINEBREAK +#define NODE_CODE CMARK_NODE_CODE +#define NODE_INLINE_HTML CMARK_NODE_INLINE_HTML +#define NODE_EMPH CMARK_NODE_EMPH +#define NODE_STRONG CMARK_NODE_STRONG +#define NODE_LINK CMARK_NODE_LINK +#define NODE_IMAGE CMARK_NODE_IMAGE +#define BULLET_LIST CMARK_BULLET_LIST +#define ORDERED_LIST CMARK_ORDERED_LIST +#define PERIOD_DELIM CMARK_PERIOD_DELIM +#define PAREN_DELIM CMARK_PAREN_DELIM +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/cbits/cmark_ctype.c b/cbits/cmark_ctype.c new file mode 100644 --- /dev/null +++ b/cbits/cmark_ctype.c @@ -0,0 +1,53 @@ +#include + +#include "cmark_ctype.h" + +/** 1 = space, 2 = punct, 3 = digit, 4 = alpha, 0 = other + */ +static const int8_t cmark_ctype_class[256] = { + /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ + /* 0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, + /* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* 2 */ 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + /* 3 */ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, + /* 4 */ 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + /* 5 */ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, + /* 6 */ 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + /* 7 */ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 0, + /* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* c */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* d */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* e */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* f */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +/** + * Returns 1 if c is a "whitespace" character as defined by the spec. + */ +int cmark_isspace(char c) +{ + return cmark_ctype_class[(int8_t)c] == 1; +} + +/** + * Returns 1 if c is an ascii punctuation character. + */ +int cmark_ispunct(char c) +{ + return cmark_ctype_class[(int8_t)c] == 2; +} + +int cmark_isalnum(char c) +{ + int8_t result; + result = cmark_ctype_class[(int8_t)c]; + return (result == 3 || result == 4); +} + +int cmark_isdigit(char c) +{ + return cmark_ctype_class[(int8_t)c] == 3; +} diff --git a/cbits/cmark_ctype.h b/cbits/cmark_ctype.h new file mode 100644 --- /dev/null +++ b/cbits/cmark_ctype.h @@ -0,0 +1,24 @@ +#ifndef CMARK_CMARK_CTYPE_H +#define CMARK_CMARK_CTYPE_H + +#ifdef __cplusplus +extern "C" { +#endif + +/** Locale-independent versions of functions from ctype.h. + * We want cmark to behave the same no matter what the system locale. + */ + +int cmark_isspace(char c); + +int cmark_ispunct(char c); + +int cmark_isalnum(char c); + +int cmark_isdigit(char c); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/cbits/cmark_export.h b/cbits/cmark_export.h new file mode 100644 --- /dev/null +++ b/cbits/cmark_export.h @@ -0,0 +1,35 @@ + +#ifndef CMARK_EXPORT_H +#define CMARK_EXPORT_H + +#ifdef CMARK_STATIC_DEFINE +# define CMARK_EXPORT +# define CMARK_NO_EXPORT +#else +# ifndef CMARK_EXPORT +# ifdef libcmark_EXPORTS + /* We are building this library */ +# define CMARK_EXPORT __attribute__((visibility("default"))) +# else + /* We are using this library */ +# define CMARK_EXPORT __attribute__((visibility("default"))) +# endif +# endif + +# ifndef CMARK_NO_EXPORT +# define CMARK_NO_EXPORT __attribute__((visibility("hidden"))) +# endif +#endif + +#ifndef CMARK_DEPRECATED +# define CMARK_DEPRECATED __attribute__ ((__deprecated__)) +# define CMARK_DEPRECATED_EXPORT CMARK_EXPORT __attribute__ ((__deprecated__)) +# define CMARK_DEPRECATED_NO_EXPORT CMARK_NO_EXPORT __attribute__ ((__deprecated__)) +#endif + +#define DEFINE_NO_DEPRECATED 0 +#if DEFINE_NO_DEPRECATED +# define CMARK_NO_DEPRECATED +#endif + +#endif diff --git a/cbits/cmark_version.h b/cbits/cmark_version.h new file mode 100644 --- /dev/null +++ b/cbits/cmark_version.h @@ -0,0 +1,7 @@ +#ifndef CMARK_VERSION_H +#define CMARK_VERSION_H + +#define CMARK_VERSION ((0 << 16) | (18 << 8) | 1) +#define CMARK_VERSION_STRING "0.18.1" + +#endif diff --git a/cbits/config.h b/cbits/config.h new file mode 100644 --- /dev/null +++ b/cbits/config.h @@ -0,0 +1,23 @@ +#define HAVE_STDBOOL_H + +#ifdef HAVE_STDBOOL_H + #include +#elif !defined(__cplusplus) + typedef char bool; +#endif + +/* #undef HAVE___BUILTIN_EXPECT */ + +#define HAVE___ATTRIBUTE__ + +#ifdef HAVE___ATTRIBUTE__ + #define CMARK_ATTRIBUTE(list) __attribute__ (list) +#else + #define CMARK_ATTRIBUTE(list) +#endif + +#define HAVE_VA_COPY + +#ifndef HAVE_VA_COPY + #define va_copy(dest, src) ((dest) = (src)) +#endif diff --git a/cbits/debug.h b/cbits/debug.h new file mode 100644 --- /dev/null +++ b/cbits/debug.h @@ -0,0 +1,36 @@ +#ifndef CMARK_DEBUG_H +#define CMARK_DEBUG_H +#include +#include +#include + +#ifdef NDEBUG +#define debug(M, ...) +#else +#define debug(M, ...) \ + fprintf(stderr, "DEBUG %s:%d: " M "\n", __FILE__, __LINE__, ##__VA_ARGS__) +#endif + +#define clean_errno() (errno == 0 ? "None" : strerror(errno)) + +#define log_err(M, ...) \ + fprintf(stderr, "[ERROR] (%s:%d: errno: %s) " M "\n", __FILE__, __LINE__, \ + clean_errno(), ##__VA_ARGS__) + +#define log_warn(M, ...) \ + fprintf(stderr, "[WARN] (%s:%d: errno: %s) " M "\n", __FILE__, __LINE__, \ + clean_errno(), ##__VA_ARGS__) + +#define log_info(M, ...) fprintf(stderr, "[INFO] (%s:%d) " M "\n", __FILE__, \ + __LINE__, ##__VA_ARGS__) + +#define check(A, M, ...) \ + if(!(A)) { log_err(M, ##__VA_ARGS__); errno=0; goto error; } + +#define sentinel(M, ...) \ + { log_err(M, ##__VA_ARGS__); errno=0; goto error; } + +#define check_debug(A, M, ...) \ + if(!(A)) { debug(M, ##__VA_ARGS__); errno=0; goto error; } + +#endif diff --git a/cbits/houdini.h b/cbits/houdini.h new file mode 100644 --- /dev/null +++ b/cbits/houdini.h @@ -0,0 +1,52 @@ +#ifndef CMARK_HOUDINI_H +#define CMARK_HOUDINI_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include "config.h" +#include "buffer.h" + +#ifdef HAVE___BUILTIN_EXPECT +# define likely(x) __builtin_expect((x),1) +# define unlikely(x) __builtin_expect((x),0) +#else +# define likely(x) (x) +# define unlikely(x) (x) +#endif + +#ifdef HOUDINI_USE_LOCALE +# define _isxdigit(c) isxdigit(c) +# define _isdigit(c) isdigit(c) +#else +/* + * Helper _isdigit methods -- do not trust the current locale + * */ +# define _isxdigit(c) (strchr("0123456789ABCDEFabcdef", (c)) != NULL) +# define _isdigit(c) ((c) >= '0' && (c) <= '9') +#endif + +#define HOUDINI_ESCAPED_SIZE(x) (((x) * 12) / 10) +#define HOUDINI_UNESCAPED_SIZE(x) (x) + +extern size_t houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src, size_t size); +extern int houdini_escape_html(cmark_strbuf *ob, const uint8_t *src, size_t size); +extern int houdini_escape_html0(cmark_strbuf *ob, const uint8_t *src, size_t size, int secure); +extern int houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src, size_t size); +extern void houdini_unescape_html_f(cmark_strbuf *ob, const uint8_t *src, size_t size); +extern int houdini_escape_xml(cmark_strbuf *ob, const uint8_t *src, size_t size); +extern int houdini_escape_uri(cmark_strbuf *ob, const uint8_t *src, size_t size); +extern int houdini_escape_url(cmark_strbuf *ob, const uint8_t *src, size_t size); +extern int houdini_escape_href(cmark_strbuf *ob, const uint8_t *src, size_t size); +extern int houdini_unescape_uri(cmark_strbuf *ob, const uint8_t *src, size_t size); +extern int houdini_unescape_url(cmark_strbuf *ob, const uint8_t *src, size_t size); +extern int houdini_escape_js(cmark_strbuf *ob, const uint8_t *src, size_t size); +extern int houdini_unescape_js(cmark_strbuf *ob, const uint8_t *src, size_t size); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/cbits/houdini_href_e.c b/cbits/houdini_href_e.c new file mode 100644 --- /dev/null +++ b/cbits/houdini_href_e.c @@ -0,0 +1,107 @@ +#include +#include +#include + +#include "houdini.h" + +/* + * The following characters will not be escaped: + * + * -_.+!*'(),%#@?=;:/,+&$ alphanum + * + * Note that this character set is the addition of: + * + * - The characters which are safe to be in an URL + * - The characters which are *not* safe to be in + * an URL because they are RESERVED characters. + * + * We asume (lazily) that any RESERVED char that + * appears inside an URL is actually meant to + * have its native function (i.e. as an URL + * component/separator) and hence needs no escaping. + * + * There are two exceptions: the chacters & (amp) + * and ' (single quote) do not appear in the table. + * They are meant to appear in the URL as components, + * yet they require special HTML-entity escaping + * to generate valid HTML markup. + * + * All other characters will be escaped to %XX. + * + */ +static const char HREF_SAFE[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +}; + +int +houdini_escape_href(cmark_strbuf *ob, const uint8_t *src, size_t size) +{ + static const uint8_t hex_chars[] = "0123456789ABCDEF"; + size_t i = 0, org; + uint8_t hex_str[3]; + + hex_str[0] = '%'; + + while (i < size) { + org = i; + while (i < size && HREF_SAFE[src[i]] != 0) + i++; + + if (likely(i > org)) + cmark_strbuf_put(ob, src + org, i - org); + + /* escaping */ + if (i >= size) + break; + + switch (src[i]) { + /* amp appears all the time in URLs, but needs + * HTML-entity escaping to be inside an href */ + case '&': + cmark_strbuf_puts(ob, "&"); + break; + + /* the single quote is a valid URL character + * according to the standard; it needs HTML + * entity escaping too */ + case '\'': + cmark_strbuf_puts(ob, "'"); + break; + + /* the space can be escaped to %20 or a plus + * sign. we're going with the generic escape + * for now. the plus thing is more commonly seen + * when building GET strings */ +#if 0 + case ' ': + cmark_strbuf_putc(ob, '+'); + break; +#endif + + /* every other character goes with a %XX escaping */ + default: + hex_str[1] = hex_chars[(src[i] >> 4) & 0xF]; + hex_str[2] = hex_chars[src[i] & 0xF]; + cmark_strbuf_put(ob, hex_str, 3); + } + + i++; + } + + return 1; +} diff --git a/cbits/houdini_html_e.c b/cbits/houdini_html_e.c new file mode 100644 --- /dev/null +++ b/cbits/houdini_html_e.c @@ -0,0 +1,81 @@ +#include +#include +#include + +#include "houdini.h" + +/** + * According to the OWASP rules: + * + * & --> & + * < --> < + * > --> > + * " --> " + * ' --> ' ' is not recommended + * / --> / forward slash is included as it helps end an HTML entity + * + */ +static const char HTML_ESCAPE_TABLE[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 2, 3, 0, 0, 0, 0, 0, 0, 0, 4, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 6, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +}; + +static const char *HTML_ESCAPES[] = { + "", + """, + "&", + "'", + "/", + "<", + ">" +}; + +int +houdini_escape_html0(cmark_strbuf *ob, const uint8_t *src, size_t size, int secure) +{ + size_t i = 0, org, esc = 0; + + while (i < size) { + org = i; + while (i < size && (esc = HTML_ESCAPE_TABLE[src[i]]) == 0) + i++; + + if (i > org) + cmark_strbuf_put(ob, src + org, i - org); + + /* escaping */ + if (unlikely(i >= size)) + break; + + /* The forward slash is only escaped in secure mode */ + if ((src[i] == '/' || src[i] == '\'') && !secure) { + cmark_strbuf_putc(ob, src[i]); + } else { + cmark_strbuf_puts(ob, HTML_ESCAPES[esc]); + } + + i++; + } + + return 1; +} + +int +houdini_escape_html(cmark_strbuf *ob, const uint8_t *src, size_t size) +{ + return houdini_escape_html0(ob, src, size, 1); +} diff --git a/cbits/houdini_html_u.c b/cbits/houdini_html_u.c new file mode 100644 --- /dev/null +++ b/cbits/houdini_html_u.c @@ -0,0 +1,116 @@ +#include +#include +#include + +#include "buffer.h" +#include "houdini.h" +#include "utf8.h" +#include "html_unescape.h" + +size_t +houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src, size_t size) +{ + size_t i = 0; + + if (size > 3 && src[0] == '#') { + int codepoint = 0; + + if (_isdigit(src[1])) { + for (i = 1; i < size && _isdigit(src[i]); ++i) { + int cp = (codepoint * 10) + (src[i] - '0'); + + if (cp < codepoint) + return 0; + + codepoint = cp; + } + } + + else if (src[1] == 'x' || src[1] == 'X') { + for (i = 2; i < size && _isxdigit(src[i]); ++i) { + int cp = (codepoint * 16) + ((src[i] | 32) % 39 - 9); + + if (cp < codepoint) + return 0; + + codepoint = cp; + } + } + + if (i < size && src[i] == ';' && codepoint) { + utf8proc_encode_char(codepoint, ob); + return i + 1; + } + } + + else { + if (size > MAX_WORD_LENGTH) + size = MAX_WORD_LENGTH; + + for (i = MIN_WORD_LENGTH; i < size; ++i) { + if (src[i] == ' ') + break; + + if (src[i] == ';') { + const struct html_ent *entity = find_entity((char *)src, i); + + if (entity != NULL) { + int len = 0; + while (len < 4 && entity->utf8[len] != '\0') { + ++len; + } + cmark_strbuf_put(ob, entity->utf8, len); + return i + 1; + } + + break; + } + } + } + + return 0; +} + +int +houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src, size_t size) +{ + size_t i = 0, org, ent; + + while (i < size) { + org = i; + while (i < size && src[i] != '&') + i++; + + if (likely(i > org)) { + if (unlikely(org == 0)) { + if (i >= size) + return 0; + + cmark_strbuf_grow(ob, HOUDINI_UNESCAPED_SIZE(size)); + } + + cmark_strbuf_put(ob, src + org, i - org); + } + + /* escaping */ + if (i >= size) + break; + + i++; + + ent = houdini_unescape_ent(ob, src + i, size - i); + i += ent; + + /* not really an entity */ + if (ent == 0) + cmark_strbuf_putc(ob, '&'); + } + + return 1; +} + +void houdini_unescape_html_f(cmark_strbuf *ob, const uint8_t *src, size_t size) +{ + if (!houdini_unescape_html(ob, src, size)) + cmark_strbuf_put(ob, src, size); +} diff --git a/cbits/html.c b/cbits/html.c new file mode 100644 --- /dev/null +++ b/cbits/html.c @@ -0,0 +1,322 @@ +#include +#include +#include +#include + +#include "config.h" +#include "cmark.h" +#include "node.h" +#include "buffer.h" +#include "houdini.h" + +// Functions to convert cmark_nodes to HTML strings. + +static void escape_html(cmark_strbuf *dest, const unsigned char *source, int length) +{ + if (length < 0) + length = strlen((char *)source); + + houdini_escape_html0(dest, source, (size_t)length, 0); +} + +static void escape_href(cmark_strbuf *dest, const unsigned char *source, int length) +{ + if (length < 0) + length = strlen((char *)source); + + houdini_escape_href(dest, source, (size_t)length); +} + +static inline void cr(cmark_strbuf *html) +{ + if (html->size && html->ptr[html->size - 1] != '\n') + cmark_strbuf_putc(html, '\n'); +} + +struct render_state { + cmark_strbuf* html; + cmark_node *plain; +}; + +static void +S_render_sourcepos(cmark_node *node, cmark_strbuf *html, int options) +{ + if (CMARK_OPT_SOURCEPOS & options) { + cmark_strbuf_printf(html, " data-sourcepos=\"%d:%d-%d:%d\"", + cmark_node_get_start_line(node), + cmark_node_get_start_column(node), + cmark_node_get_end_line(node), + cmark_node_get_end_column(node)); + } +} + +static int +S_render_node(cmark_node *node, cmark_event_type ev_type, + struct render_state *state, int options) +{ + cmark_node *parent; + cmark_node *grandparent; + cmark_strbuf *html = state->html; + char start_header[] = "plain == node) { // back at original node + state->plain = NULL; + } + + if (state->plain != NULL) { + switch(node->type) { + case CMARK_NODE_TEXT: + case CMARK_NODE_CODE: + case CMARK_NODE_INLINE_HTML: + escape_html(html, node->as.literal.data, + node->as.literal.len); + break; + + case CMARK_NODE_LINEBREAK: + case CMARK_NODE_SOFTBREAK: + cmark_strbuf_putc(html, ' '); + break; + + default: + break; + } + return 1; + } + + switch (node->type) { + case CMARK_NODE_DOCUMENT: + break; + + case CMARK_NODE_BLOCK_QUOTE: + if (entering) { + cr(html); + cmark_strbuf_puts(html, "\n"); + } else { + cr(html); + cmark_strbuf_puts(html, "\n"); + } + break; + + case CMARK_NODE_LIST: { + cmark_list_type list_type = node->as.list.list_type; + int start = node->as.list.start; + + if (entering) { + cr(html); + if (list_type == CMARK_BULLET_LIST) { + cmark_strbuf_puts(html, "\n"); + } else if (start == 1) { + cmark_strbuf_puts(html, "\n"); + } else { + cmark_strbuf_printf(html, + "
    \n"); + } + } else { + cmark_strbuf_puts(html, + list_type == CMARK_BULLET_LIST ? + "\n" : "
\n"); + } + break; + } + + case CMARK_NODE_ITEM: + if (entering) { + cr(html); + cmark_strbuf_puts(html, "'); + } else { + cmark_strbuf_puts(html, "\n"); + } + break; + + case CMARK_NODE_HEADER: + if (entering) { + cr(html); + start_header[2] = '0' + node->as.header.level; + cmark_strbuf_puts(html, start_header); + S_render_sourcepos(node, html, options); + cmark_strbuf_putc(html, '>'); + } else { + end_header[3] = '0' + node->as.header.level; + cmark_strbuf_puts(html, end_header); + cmark_strbuf_puts(html, ">\n"); + } + break; + + case CMARK_NODE_CODE_BLOCK: + cr(html); + + if (!node->as.code.fenced || node->as.code.info.len == 0) { + cmark_strbuf_puts(html, ""); + } else { + int first_tag = 0; + while (first_tag < node->as.code.info.len && + node->as.code.info.data[first_tag] != ' ') { + first_tag += 1; + } + + cmark_strbuf_puts(html, "as.code.info.data, first_tag); + cmark_strbuf_puts(html, "\">"); + } + + escape_html(html, node->as.code.literal.data, + node->as.code.literal.len); + cmark_strbuf_puts(html, "\n"); + break; + + case CMARK_NODE_HTML: + cr(html); + cmark_strbuf_put(html, node->as.literal.data, node->as.literal.len); + break; + + case CMARK_NODE_HRULE: + cr(html); + cmark_strbuf_puts(html, "\n"); + break; + + case CMARK_NODE_PARAGRAPH: + parent = cmark_node_parent(node); + grandparent = cmark_node_parent(parent); + if (grandparent != NULL && + grandparent->type == CMARK_NODE_LIST) { + tight = grandparent->as.list.tight; + } else { + tight = false; + } + if (!tight) { + if (entering) { + cr(html); + cmark_strbuf_puts(html, "'); + } else { + cmark_strbuf_puts(html, "

\n"); + } + } + break; + + case CMARK_NODE_TEXT: + escape_html(html, node->as.literal.data, node->as.literal.len); + break; + + case CMARK_NODE_LINEBREAK: + cmark_strbuf_puts(html, "
\n"); + break; + + case CMARK_NODE_SOFTBREAK: + if (options & CMARK_OPT_HARDBREAKS) { + cmark_strbuf_puts(html, "
\n"); + } else { + cmark_strbuf_putc(html, '\n'); + } + break; + + case CMARK_NODE_CODE: + cmark_strbuf_puts(html, ""); + escape_html(html, node->as.literal.data, node->as.literal.len); + cmark_strbuf_puts(html, ""); + break; + + case CMARK_NODE_INLINE_HTML: + cmark_strbuf_put(html, node->as.literal.data, node->as.literal.len); + break; + + case CMARK_NODE_STRONG: + if (entering) { + cmark_strbuf_puts(html, ""); + } else { + cmark_strbuf_puts(html, ""); + } + break; + + case CMARK_NODE_EMPH: + if (entering) { + cmark_strbuf_puts(html, ""); + } else { + cmark_strbuf_puts(html, ""); + } + break; + + case CMARK_NODE_LINK: + if (entering) { + cmark_strbuf_puts(html, "as.link.url) + escape_href(html, node->as.link.url, -1); + + if (node->as.link.title) { + cmark_strbuf_puts(html, "\" title=\""); + escape_html(html, node->as.link.title, -1); + } + + cmark_strbuf_puts(html, "\">"); + } else { + cmark_strbuf_puts(html, ""); + } + break; + + case CMARK_NODE_IMAGE: + if (entering) { + cmark_strbuf_puts(html, "as.link.url) + escape_href(html, node->as.link.url, -1); + + cmark_strbuf_puts(html, "\" alt=\""); + state->plain = node; + } else { + if (node->as.link.title) { + cmark_strbuf_puts(html, "\" title=\""); + escape_html(html, node->as.link.title, -1); + } + + cmark_strbuf_puts(html, "\" />"); + } + break; + + default: + assert(false); + break; + } + + // cmark_strbuf_putc(html, 'x'); + return 1; +} + +char *cmark_render_html(cmark_node *root, int options) +{ + char *result; + cmark_strbuf html = GH_BUF_INIT; + cmark_event_type ev_type; + cmark_node *cur; + struct render_state state = { &html, NULL }; + cmark_iter *iter = cmark_iter_new(root); + + while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { + cur = cmark_iter_get_node(iter); + S_render_node(cur, ev_type, &state, options); + } + result = (char *)cmark_strbuf_detach(&html); + + cmark_iter_free(iter); + return result; +} diff --git a/cbits/html_unescape.h b/cbits/html_unescape.h new file mode 100644 --- /dev/null +++ b/cbits/html_unescape.h @@ -0,0 +1,13375 @@ +/* ANSI-C code produced by gperf version 3.0.3 */ +/* Command-line: /Library/Developer/CommandLineTools/usr/bin/gperf -L ANSI-C -I -t -N find_entity -H hash_entity -K entity -C -l -F ',{0}' --null-strings -m5 -P -Q entity_pool src/html_unescape.gperf */ +/* Computed positions: -k'1-7,10,12,$' */ + +#if !((' ' == 32) && ('!' == 33) && ('"' == 34) && ('#' == 35) \ + && ('%' == 37) && ('&' == 38) && ('\'' == 39) && ('(' == 40) \ + && (')' == 41) && ('*' == 42) && ('+' == 43) && (',' == 44) \ + && ('-' == 45) && ('.' == 46) && ('/' == 47) && ('0' == 48) \ + && ('1' == 49) && ('2' == 50) && ('3' == 51) && ('4' == 52) \ + && ('5' == 53) && ('6' == 54) && ('7' == 55) && ('8' == 56) \ + && ('9' == 57) && (':' == 58) && (';' == 59) && ('<' == 60) \ + && ('=' == 61) && ('>' == 62) && ('?' == 63) && ('A' == 65) \ + && ('B' == 66) && ('C' == 67) && ('D' == 68) && ('E' == 69) \ + && ('F' == 70) && ('G' == 71) && ('H' == 72) && ('I' == 73) \ + && ('J' == 74) && ('K' == 75) && ('L' == 76) && ('M' == 77) \ + && ('N' == 78) && ('O' == 79) && ('P' == 80) && ('Q' == 81) \ + && ('R' == 82) && ('S' == 83) && ('T' == 84) && ('U' == 85) \ + && ('V' == 86) && ('W' == 87) && ('X' == 88) && ('Y' == 89) \ + && ('Z' == 90) && ('[' == 91) && ('\\' == 92) && (']' == 93) \ + && ('^' == 94) && ('_' == 95) && ('a' == 97) && ('b' == 98) \ + && ('c' == 99) && ('d' == 100) && ('e' == 101) && ('f' == 102) \ + && ('g' == 103) && ('h' == 104) && ('i' == 105) && ('j' == 106) \ + && ('k' == 107) && ('l' == 108) && ('m' == 109) && ('n' == 110) \ + && ('o' == 111) && ('p' == 112) && ('q' == 113) && ('r' == 114) \ + && ('s' == 115) && ('t' == 116) && ('u' == 117) && ('v' == 118) \ + && ('w' == 119) && ('x' == 120) && ('y' == 121) && ('z' == 122) \ + && ('{' == 123) && ('|' == 124) && ('}' == 125) && ('~' == 126)) +/* The character set is not based on ISO-646. */ +#error "gperf generated tables don't work with this execution character set. Please report a bug to ." +#endif + +#line 1 "src/html_unescape.gperf" +struct html_ent { + int entity; + unsigned char utf8[4]; +}; +#include +#include + +#define TOTAL_KEYWORDS 2125 +#define MIN_WORD_LENGTH 2 +#define MAX_WORD_LENGTH 31 +#define MIN_HASH_VALUE 39 +#define MAX_HASH_VALUE 16000 +/* maximum key range = 15962, duplicates = 0 */ + +#ifdef __GNUC__ +__inline +#else +#ifdef __cplusplus +inline +#endif +#endif +static unsigned int +hash_entity (register const char *str, register unsigned int len) +{ + static const unsigned short asso_values[] = + { + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 2, + 3, 7, 2, 4, 8, 16001, 10, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 1890, 1538, 220, 165, 1045, + 535, 1971, 1187, 1262, 35, 126, 201, 133, 350, 1487, + 1965, 3, 478, 134, 8, 147, 73, 41, 23, 212, + 9, 16001, 2, 16001, 2, 16001, 16001, 4154, 29, 3168, + 429, 10, 146, 1925, 2307, 280, 1313, 1924, 4, 651, + 27, 1031, 65, 176, 2, 6, 17, 15, 107, 482, + 3207, 3865, 757, 131, 178, 4, 4, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001 + }; + register unsigned int hval = len; + + switch (hval) + { + default: + hval += asso_values[(unsigned char)str[11]]; + /*FALLTHROUGH*/ + case 11: + case 10: + hval += asso_values[(unsigned char)str[9]]; + /*FALLTHROUGH*/ + case 9: + case 8: + case 7: + hval += asso_values[(unsigned char)str[6]]; + /*FALLTHROUGH*/ + case 6: + hval += asso_values[(unsigned char)str[5]]; + /*FALLTHROUGH*/ + case 5: + hval += asso_values[(unsigned char)str[4]+1]; + /*FALLTHROUGH*/ + case 4: + hval += asso_values[(unsigned char)str[3]+3]; + /*FALLTHROUGH*/ + case 3: + hval += asso_values[(unsigned char)str[2]+1]; + /*FALLTHROUGH*/ + case 2: + hval += asso_values[(unsigned char)str[1]+4]; + /*FALLTHROUGH*/ + case 1: + hval += asso_values[(unsigned char)str[0]]; + break; + } + return hval + asso_values[(unsigned char)str[len - 1]]; +} + +struct entity_pool_t + { + char entity_pool_str39[sizeof("rarr")]; + char entity_pool_str41[sizeof("larr")]; + char entity_pool_str49[sizeof("lat")]; + char entity_pool_str52[sizeof("uarr")]; + char entity_pool_str55[sizeof("npr")]; + char entity_pool_str62[sizeof("rarrtl")]; + char entity_pool_str64[sizeof("larrtl")]; + char entity_pool_str65[sizeof("roarr")]; + char entity_pool_str67[sizeof("loarr")]; + char entity_pool_str68[sizeof("not")]; + char entity_pool_str69[sizeof("rpar")]; + char entity_pool_str70[sizeof("bot")]; + char entity_pool_str71[sizeof("lpar")]; + char entity_pool_str73[sizeof("spar")]; + char entity_pool_str75[sizeof("ll")]; + char entity_pool_str76[sizeof("uharr")]; + char entity_pool_str77[sizeof("epar")]; + char entity_pool_str81[sizeof("el")]; + char entity_pool_str83[sizeof("rotimes")]; + char entity_pool_str85[sizeof("lotimes")]; + char entity_pool_str86[sizeof("par")]; + char entity_pool_str88[sizeof("nharr")]; + char entity_pool_str94[sizeof("npar")]; + char entity_pool_str97[sizeof("tprime")]; + char entity_pool_str101[sizeof("els")]; + char entity_pool_str102[sizeof("eparsl")]; + char entity_pool_str104[sizeof("ensp")]; + char entity_pool_str109[sizeof("bprime")]; + char entity_pool_str110[sizeof("lnap")]; + char entity_pool_str111[sizeof("blk14")]; + char entity_pool_str115[sizeof("blk12")]; + char entity_pool_str117[sizeof("blk34")]; + char entity_pool_str119[sizeof("nparsl")]; + char entity_pool_str123[sizeof("nldr")]; + char entity_pool_str124[sizeof("rlarr")]; + char entity_pool_str125[sizeof("npart")]; + char entity_pool_str126[sizeof("llarr")]; + char entity_pool_str127[sizeof("nlt")]; + char entity_pool_str128[sizeof("slarr")]; + char entity_pool_str138[sizeof("nparallel")]; + char entity_pool_str143[sizeof("Tau")]; + char entity_pool_str144[sizeof("varr")]; + char entity_pool_str146[sizeof("squ")]; + char entity_pool_str149[sizeof("nlarr")]; + char entity_pool_str152[sizeof("tau")]; + char entity_pool_str165[sizeof("lne")]; + char entity_pool_str166[sizeof("rrarr")]; + char entity_pool_str168[sizeof("lrarr")]; + char entity_pool_str170[sizeof("srarr")]; + char entity_pool_str171[sizeof("rharul")]; + char entity_pool_str173[sizeof("lharul")]; + char entity_pool_str174[sizeof("erarr")]; + char entity_pool_str176[sizeof("pr")]; + char entity_pool_str177[sizeof("rharu")]; + char entity_pool_str179[sizeof("lharu")]; + char entity_pool_str184[sizeof("Uarr")]; + char entity_pool_str188[sizeof("nGt")]; + char entity_pool_str190[sizeof("bne")]; + char entity_pool_str191[sizeof("nrarr")]; + char entity_pool_str194[sizeof("swarr")]; + char entity_pool_str198[sizeof("rarrap")]; + char entity_pool_str200[sizeof("upuparrows")]; + char entity_pool_str202[sizeof("Darr")]; + char entity_pool_str205[sizeof("rbarr")]; + char entity_pool_str206[sizeof("Dot")]; + char entity_pool_str207[sizeof("lbarr")]; + char entity_pool_str215[sizeof("nwarr")]; + char entity_pool_str217[sizeof("smt")]; + char entity_pool_str222[sizeof("emsp14")]; + char entity_pool_str223[sizeof("rarrpl")]; + char entity_pool_str225[sizeof("larrpl")]; + char entity_pool_str230[sizeof("phmmat")]; + char entity_pool_str232[sizeof("emsp13")]; + char entity_pool_str234[sizeof("LT")]; + char entity_pool_str238[sizeof("Larr")]; + char entity_pool_str239[sizeof("rbrkslu")]; + char entity_pool_str241[sizeof("lbrkslu")]; + char entity_pool_str243[sizeof("napos")]; + char entity_pool_str251[sizeof("nle")]; + char entity_pool_str253[sizeof("rHar")]; + char entity_pool_str255[sizeof("lHar")]; + char entity_pool_str256[sizeof("qprime")]; + char entity_pool_str258[sizeof("lap")]; + char entity_pool_str265[sizeof("nbsp")]; + char entity_pool_str266[sizeof("uHar")]; + char entity_pool_str267[sizeof("top")]; + char entity_pool_str269[sizeof("Vbar")]; + char entity_pool_str272[sizeof("Ll")]; + char entity_pool_str276[sizeof("prap")]; + char entity_pool_str278[sizeof("emsp")]; + char entity_pool_str281[sizeof("nap")]; + char entity_pool_str294[sizeof("looparrowleft")]; + char entity_pool_str296[sizeof("le")]; + char entity_pool_str300[sizeof("sharp")]; + char entity_pool_str302[sizeof("ee")]; + char entity_pool_str310[sizeof("les")]; + char entity_pool_str311[sizeof("in")]; + char entity_pool_str312[sizeof("prop")]; + char entity_pool_str314[sizeof("topbot")]; + char entity_pool_str317[sizeof("int")]; + char entity_pool_str319[sizeof("ne")]; + char entity_pool_str329[sizeof("nprcue")]; + char entity_pool_str331[sizeof("pre")]; + char entity_pool_str332[sizeof("epsi")]; + char entity_pool_str337[sizeof("upsi")]; + char entity_pool_str338[sizeof("there4")]; + char entity_pool_str342[sizeof("rbrke")]; + char entity_pool_str343[sizeof("searr")]; + char entity_pool_str344[sizeof("lbrke")]; + char entity_pool_str346[sizeof("blacktriangle")]; + char entity_pool_str349[sizeof("lneq")]; + char entity_pool_str352[sizeof("lneqq")]; + char entity_pool_str354[sizeof("plus")]; + char entity_pool_str355[sizeof("nles")]; + char entity_pool_str356[sizeof("nedot")]; + char entity_pool_str357[sizeof("blacktriangleleft")]; + char entity_pool_str358[sizeof("blacktriangleright")]; + char entity_pool_str364[sizeof("nearr")]; + char entity_pool_str367[sizeof("blacktriangledown")]; + char entity_pool_str373[sizeof("nless")]; + char entity_pool_str374[sizeof("emacr")]; + char entity_pool_str378[sizeof("vprop")]; + char entity_pool_str379[sizeof("umacr")]; + char entity_pool_str383[sizeof("smeparsl")]; + char entity_pool_str387[sizeof("Map")]; + char entity_pool_str390[sizeof("plusdu")]; + char entity_pool_str391[sizeof("Not")]; + char entity_pool_str408[sizeof("Verbar")]; + char entity_pool_str426[sizeof("perp")]; + char entity_pool_str430[sizeof("fltns")]; + char entity_pool_str431[sizeof("plusmn")]; + char entity_pool_str435[sizeof("nleq")]; + char entity_pool_str438[sizeof("nleqq")]; + char entity_pool_str440[sizeof("frac34")]; + char entity_pool_str441[sizeof("frac14")]; + char entity_pool_str442[sizeof("verbar")]; + char entity_pool_str443[sizeof("frac12")]; + char entity_pool_str444[sizeof("frac35")]; + char entity_pool_str445[sizeof("frac15")]; + char entity_pool_str446[sizeof("frac45")]; + char entity_pool_str449[sizeof("frac25")]; + char entity_pool_str451[sizeof("frac13")]; + char entity_pool_str453[sizeof("frac16")]; + char entity_pool_str454[sizeof("prurel")]; + char entity_pool_str455[sizeof("frac23")]; + char entity_pool_str456[sizeof("frac38")]; + char entity_pool_str457[sizeof("frac18")]; + char entity_pool_str458[sizeof("frac56")]; + char entity_pool_str462[sizeof("frac58")]; + char entity_pool_str464[sizeof("frac78")]; + char entity_pool_str465[sizeof("leq")]; + char entity_pool_str466[sizeof("darr")]; + char entity_pool_str469[sizeof("Upsi")]; + char entity_pool_str470[sizeof("dot")]; + char entity_pool_str471[sizeof("phone")]; + char entity_pool_str474[sizeof("Cap")]; + char entity_pool_str478[sizeof("blacksquare")]; + char entity_pool_str479[sizeof("rnmid")]; + char entity_pool_str483[sizeof("leqq")]; + char entity_pool_str486[sizeof("intcal")]; + char entity_pool_str490[sizeof("dharr")]; + char entity_pool_str494[sizeof("rhard")]; + char entity_pool_str496[sizeof("lhard")]; + char entity_pool_str505[sizeof("pluse")]; + char entity_pool_str511[sizeof("Umacr")]; + char entity_pool_str512[sizeof("Vee")]; + char entity_pool_str515[sizeof("Rarr")]; + char entity_pool_str527[sizeof("Cross")]; + char entity_pool_str529[sizeof("rsqb")]; + char entity_pool_str531[sizeof("lsqb")]; + char entity_pool_str538[sizeof("Rarrtl")]; + char entity_pool_str541[sizeof("esdot")]; + char entity_pool_str546[sizeof("vee")]; + char entity_pool_str547[sizeof("nbumpe")]; + char entity_pool_str553[sizeof("llcorner")]; + char entity_pool_str554[sizeof("fpartint")]; + char entity_pool_str558[sizeof("squf")]; + char entity_pool_str559[sizeof("plankv")]; + char entity_pool_str562[sizeof("eqvparsl")]; + char entity_pool_str564[sizeof("ulcorner")]; + char entity_pool_str566[sizeof("wp")]; + char entity_pool_str571[sizeof("lozf")]; + char entity_pool_str575[sizeof("COPY")]; + char entity_pool_str577[sizeof("ulcorn")]; + char entity_pool_str582[sizeof("veebar")]; + char entity_pool_str584[sizeof("part")]; + char entity_pool_str589[sizeof("square")]; + char entity_pool_str591[sizeof("nbump")]; + char entity_pool_str592[sizeof("bernou")]; + char entity_pool_str593[sizeof("wr")]; + char entity_pool_str594[sizeof("rBarr")]; + char entity_pool_str595[sizeof("lrcorner")]; + char entity_pool_str596[sizeof("lBarr")]; + char entity_pool_str599[sizeof("bnot")]; + char entity_pool_str601[sizeof("semi")]; + char entity_pool_str606[sizeof("urcorner")]; + char entity_pool_str612[sizeof("NotSubset")]; + char entity_pool_str614[sizeof("ropf")]; + char entity_pool_str615[sizeof("Qopf")]; + char entity_pool_str616[sizeof("lopf")]; + char entity_pool_str618[sizeof("sopf")]; + char entity_pool_str619[sizeof("urcorn")]; + char entity_pool_str620[sizeof("Topf")]; + char entity_pool_str621[sizeof("Zopf")]; + char entity_pool_str622[sizeof("eopf")]; + char entity_pool_str626[sizeof("ropar")]; + char entity_pool_str627[sizeof("uopf")]; + char entity_pool_str628[sizeof("lopar")]; + char entity_pool_str629[sizeof("topf")]; + char entity_pool_str635[sizeof("Xopf")]; + char entity_pool_str639[sizeof("nopf")]; + char entity_pool_str641[sizeof("bopf")]; + char entity_pool_str642[sizeof("epsiv")]; + char entity_pool_str643[sizeof("fnof")]; + char entity_pool_str644[sizeof("imacr")]; + char entity_pool_str647[sizeof("Jopf")]; + char entity_pool_str649[sizeof("nhpar")]; + char entity_pool_str653[sizeof("Wopf")]; + char entity_pool_str658[sizeof("Sqrt")]; + char entity_pool_str659[sizeof("nsub")]; + char entity_pool_str661[sizeof("napid")]; + char entity_pool_str664[sizeof("NotSuperset")]; + char entity_pool_str667[sizeof("brvbar")]; + char entity_pool_str670[sizeof("sol")]; + char entity_pool_str675[sizeof("easter")]; + char entity_pool_str677[sizeof("popf")]; + char entity_pool_str680[sizeof("dHar")]; + char entity_pool_str685[sizeof("Vopf")]; + char entity_pool_str690[sizeof("nsupset")]; + char entity_pool_str691[sizeof("nsup")]; + char entity_pool_str692[sizeof("vBar")]; + char entity_pool_str694[sizeof("nsubset")]; + char entity_pool_str700[sizeof("thkap")]; + char entity_pool_str704[sizeof("nis")]; + char entity_pool_str705[sizeof("profsurf")]; + char entity_pool_str706[sizeof("solb")]; + char entity_pool_str710[sizeof("lnsim")]; + char entity_pool_str712[sizeof("solbar")]; + char entity_pool_str717[sizeof("Square")]; + char entity_pool_str719[sizeof("vopf")]; + char entity_pool_str723[sizeof("uharl")]; + char entity_pool_str725[sizeof("ulcrop")]; + char entity_pool_str729[sizeof("eqsim")]; + char entity_pool_str730[sizeof("equiv")]; + char entity_pool_str733[sizeof("ell")]; + char entity_pool_str734[sizeof("smashp")]; + char entity_pool_str735[sizeof("mp")]; + char entity_pool_str738[sizeof("Kopf")]; + char entity_pool_str741[sizeof("simrarr")]; + char entity_pool_str743[sizeof("flat")]; + char entity_pool_str745[sizeof("Mopf")]; + char entity_pool_str746[sizeof("Sopf")]; + char entity_pool_str747[sizeof("mldr")]; + char entity_pool_str748[sizeof("rlm")]; + char entity_pool_str749[sizeof("iprod")]; + char entity_pool_str756[sizeof("lparlt")]; + char entity_pool_str758[sizeof("fopf")]; + char entity_pool_str759[sizeof("Uopf")]; + char entity_pool_str763[sizeof("varsubsetneq")]; + char entity_pool_str764[sizeof("varsubsetneqq")]; + char entity_pool_str767[sizeof("urcrop")]; + char entity_pool_str768[sizeof("LessLess")]; + char entity_pool_str770[sizeof("Re")]; + char entity_pool_str773[sizeof("NotNestedLessLess")]; + char entity_pool_str777[sizeof("Dopf")]; + char entity_pool_str779[sizeof("forkv")]; + char entity_pool_str781[sizeof("nsqsube")]; + char entity_pool_str783[sizeof("nsupe")]; + char entity_pool_str787[sizeof("nsube")]; + char entity_pool_str788[sizeof("qopf")]; + char entity_pool_str789[sizeof("rlhar")]; + char entity_pool_str792[sizeof("lrm")]; + char entity_pool_str796[sizeof("nlsim")]; + char entity_pool_str798[sizeof("pound")]; + char entity_pool_str799[sizeof("varsupsetneq")]; + char entity_pool_str800[sizeof("varsupsetneqq")]; + char entity_pool_str802[sizeof("bnequiv")]; + char entity_pool_str813[sizeof("Lopf")]; + char entity_pool_str817[sizeof("nsqsupe")]; + char entity_pool_str820[sizeof("rarrlp")]; + char entity_pool_str821[sizeof("wedbar")]; + char entity_pool_str822[sizeof("larrlp")]; + char entity_pool_str824[sizeof("Yopf")]; + char entity_pool_str829[sizeof("NotReverseElement")]; + char entity_pool_str832[sizeof("Copf")]; + char entity_pool_str833[sizeof("lrhar")]; + char entity_pool_str848[sizeof("parsl")]; + char entity_pool_str849[sizeof("uml")]; + char entity_pool_str850[sizeof("marker")]; + char entity_pool_str851[sizeof("nsupseteq")]; + char entity_pool_str855[sizeof("nsubseteq")]; + char entity_pool_str861[sizeof("squarf")]; + char entity_pool_str862[sizeof("Vert")]; + char entity_pool_str874[sizeof("SquareSupersetEqual")]; + char entity_pool_str876[sizeof("prsim")]; + char entity_pool_str879[sizeof("SquareSubsetEqual")]; + char entity_pool_str882[sizeof("SquareSuperset")]; + char entity_pool_str887[sizeof("SquareSubset")]; + char entity_pool_str888[sizeof("nvap")]; + char entity_pool_str892[sizeof("iopf")]; + char entity_pool_str894[sizeof("pm")]; + char entity_pool_str896[sizeof("vert")]; + char entity_pool_str898[sizeof("thetav")]; + char entity_pool_str901[sizeof("loz")]; + char entity_pool_str905[sizeof("map")]; + char entity_pool_str920[sizeof("lesseqqgtr")]; + char entity_pool_str934[sizeof("rscr")]; + char entity_pool_str935[sizeof("Qscr")]; + char entity_pool_str936[sizeof("lscr")]; + char entity_pool_str938[sizeof("sscr")]; + char entity_pool_str940[sizeof("Tscr")]; + char entity_pool_str941[sizeof("Zscr")]; + char entity_pool_str942[sizeof("escr")]; + char entity_pool_str947[sizeof("uscr")]; + char entity_pool_str949[sizeof("tscr")]; + char entity_pool_str951[sizeof("imof")]; + char entity_pool_str952[sizeof("Coproduct")]; + char entity_pool_str955[sizeof("Xscr")]; + char entity_pool_str956[sizeof("Xi")]; + char entity_pool_str959[sizeof("nscr")]; + char entity_pool_str960[sizeof("ni")]; + char entity_pool_str961[sizeof("bscr")]; + char entity_pool_str962[sizeof("Nopf")]; + char entity_pool_str967[sizeof("Jscr")]; + char entity_pool_str968[sizeof("preceq")]; + char entity_pool_str971[sizeof("nvrArr")]; + char entity_pool_str972[sizeof("backprime")]; + char entity_pool_str973[sizeof("Wscr")]; + char entity_pool_str975[sizeof("varphi")]; + char entity_pool_str984[sizeof("nsmid")]; + char entity_pool_str991[sizeof("dlcorn")]; + char entity_pool_str997[sizeof("pscr")]; + char entity_pool_str998[sizeof("pi")]; + char entity_pool_str1005[sizeof("Vscr")]; + char entity_pool_str1011[sizeof("nesim")]; + char entity_pool_str1021[sizeof("simne")]; + char entity_pool_str1028[sizeof("nsupseteqq")]; + char entity_pool_str1032[sizeof("nsubseteqq")]; + char entity_pool_str1033[sizeof("drcorn")]; + char entity_pool_str1038[sizeof("rbrace")]; + char entity_pool_str1039[sizeof("vscr")]; + char entity_pool_str1040[sizeof("lbrace")]; + char entity_pool_str1041[sizeof("dopf")]; + char entity_pool_str1049[sizeof("frasl")]; + char entity_pool_str1055[sizeof("LessTilde")]; + char entity_pool_str1058[sizeof("Kscr")]; + char entity_pool_str1064[sizeof("pluscir")]; + char entity_pool_str1065[sizeof("Mscr")]; + char entity_pool_str1066[sizeof("Sscr")]; + char entity_pool_str1067[sizeof("rbrksld")]; + char entity_pool_str1069[sizeof("lbrksld")]; + char entity_pool_str1070[sizeof("RBarr")]; + char entity_pool_str1073[sizeof("sqcaps")]; + char entity_pool_str1074[sizeof("rArr")]; + char entity_pool_str1075[sizeof("bNot")]; + char entity_pool_str1076[sizeof("lArr")]; + char entity_pool_str1078[sizeof("fscr")]; + char entity_pool_str1079[sizeof("Uscr")]; + char entity_pool_str1087[sizeof("uArr")]; + char entity_pool_str1090[sizeof("Ropf")]; + char entity_pool_str1094[sizeof("wopf")]; + char entity_pool_str1097[sizeof("Dscr")]; + char entity_pool_str1098[sizeof("opar")]; + char entity_pool_str1099[sizeof("seswar")]; + char entity_pool_str1103[sizeof("Del")]; + char entity_pool_str1104[sizeof("rAarr")]; + char entity_pool_str1105[sizeof("rho")]; + char entity_pool_str1106[sizeof("lAarr")]; + char entity_pool_str1107[sizeof("preccurlyeq")]; + char entity_pool_str1108[sizeof("qscr")]; + char entity_pool_str1111[sizeof("macr")]; + char entity_pool_str1115[sizeof("notin")]; + char entity_pool_str1120[sizeof("equivDD")]; + char entity_pool_str1125[sizeof("sqcap")]; + char entity_pool_str1127[sizeof("nspar")]; + char entity_pool_str1131[sizeof("olt")]; + char entity_pool_str1132[sizeof("ratio")]; + char entity_pool_str1133[sizeof("Lscr")]; + char entity_pool_str1137[sizeof("dharl")]; + char entity_pool_str1139[sizeof("dlcrop")]; + char entity_pool_str1140[sizeof("DoubleDot")]; + char entity_pool_str1141[sizeof("dotplus")]; + char entity_pool_str1142[sizeof("or")]; + char entity_pool_str1144[sizeof("Yscr")]; + char entity_pool_str1147[sizeof("Fopf")]; + char entity_pool_str1152[sizeof("Cscr")]; + char entity_pool_str1153[sizeof("olarr")]; + char entity_pool_str1154[sizeof("nrarrw")]; + char entity_pool_str1159[sizeof("lvertneqq")]; + char entity_pool_str1160[sizeof("eqslantgtr")]; + char entity_pool_str1164[sizeof("thorn")]; + char entity_pool_str1169[sizeof("eqslantless")]; + char entity_pool_str1172[sizeof("incare")]; + char entity_pool_str1179[sizeof("vArr")]; + char entity_pool_str1180[sizeof("rppolint")]; + char entity_pool_str1181[sizeof("drcrop")]; + char entity_pool_str1187[sizeof("parallel")]; + char entity_pool_str1195[sizeof("orarr")]; + char entity_pool_str1196[sizeof("ssmile")]; + char entity_pool_str1200[sizeof("DoubleLeftTee")]; + char entity_pool_str1201[sizeof("erDot")]; + char entity_pool_str1202[sizeof("diams")]; + char entity_pool_str1203[sizeof("ssetmn")]; + char entity_pool_str1208[sizeof("oS")]; + char entity_pool_str1212[sizeof("iscr")]; + char entity_pool_str1213[sizeof("ii")]; + char entity_pool_str1214[sizeof("rect")]; + char entity_pool_str1217[sizeof("nsccue")]; + char entity_pool_str1218[sizeof("sect")]; + char entity_pool_str1220[sizeof("mlcp")]; + char entity_pool_str1224[sizeof("oror")]; + char entity_pool_str1226[sizeof("DoubleContourIntegral")]; + char entity_pool_str1230[sizeof("equals")]; + char entity_pool_str1232[sizeof("Hat")]; + char entity_pool_str1236[sizeof("sstarf")]; + char entity_pool_str1237[sizeof("mstpos")]; + char entity_pool_str1239[sizeof("die")]; + char entity_pool_str1240[sizeof("measuredangle")]; + char entity_pool_str1252[sizeof("forall")]; + char entity_pool_str1255[sizeof("notinvb")]; + char entity_pool_str1263[sizeof("mopf")]; + char entity_pool_str1270[sizeof("niv")]; + char entity_pool_str1280[sizeof("vBarv")]; + char entity_pool_str1282[sizeof("Nscr")]; + char entity_pool_str1284[sizeof("period")]; + char entity_pool_str1292[sizeof("becaus")]; + char entity_pool_str1298[sizeof("between")]; + char entity_pool_str1299[sizeof("Int")]; + char entity_pool_str1307[sizeof("because")]; + char entity_pool_str1308[sizeof("piv")]; + char entity_pool_str1326[sizeof("rfr")]; + char entity_pool_str1327[sizeof("Qfr")]; + char entity_pool_str1328[sizeof("lfr")]; + char entity_pool_str1330[sizeof("sfr")]; + char entity_pool_str1331[sizeof("nleftrightarrow")]; + char entity_pool_str1332[sizeof("Tfr")]; + char entity_pool_str1333[sizeof("Zfr")]; + char entity_pool_str1334[sizeof("efr")]; + char entity_pool_str1338[sizeof("sim")]; + char entity_pool_str1339[sizeof("ufr")]; + char entity_pool_str1340[sizeof("roplus")]; + char entity_pool_str1341[sizeof("tfr")]; + char entity_pool_str1342[sizeof("loplus")]; + char entity_pool_str1347[sizeof("Xfr")]; + char entity_pool_str1350[sizeof("real")]; + char entity_pool_str1351[sizeof("nfr")]; + char entity_pool_str1353[sizeof("bfr")]; + char entity_pool_str1355[sizeof("NotHumpEqual")]; + char entity_pool_str1359[sizeof("Jfr")]; + char entity_pool_str1361[sizeof("dscr")]; + char entity_pool_str1365[sizeof("Wfr")]; + char entity_pool_str1367[sizeof("blacklozenge")]; + char entity_pool_str1369[sizeof("zopf")]; + char entity_pool_str1370[sizeof("reals")]; + char entity_pool_str1372[sizeof("NotCupCap")]; + char entity_pool_str1375[sizeof("simplus")]; + char entity_pool_str1377[sizeof("ForAll")]; + char entity_pool_str1389[sizeof("pfr")]; + char entity_pool_str1395[sizeof("omacr")]; + char entity_pool_str1397[sizeof("Vfr")]; + char entity_pool_str1409[sizeof("Emacr")]; + char entity_pool_str1410[sizeof("Rscr")]; + char entity_pool_str1414[sizeof("wscr")]; + char entity_pool_str1423[sizeof("ShortUpArrow")]; + char entity_pool_str1429[sizeof("setmn")]; + char entity_pool_str1431[sizeof("vfr")]; + char entity_pool_str1450[sizeof("Kfr")]; + char entity_pool_str1455[sizeof("operp")]; + char entity_pool_str1457[sizeof("Mfr")]; + char entity_pool_str1458[sizeof("Sfr")]; + char entity_pool_str1461[sizeof("nltrie")]; + char entity_pool_str1467[sizeof("Fscr")]; + char entity_pool_str1470[sizeof("ffr")]; + char entity_pool_str1471[sizeof("Ufr")]; + char entity_pool_str1473[sizeof("shortmid")]; + char entity_pool_str1488[sizeof("nvsim")]; + char entity_pool_str1489[sizeof("Dfr")]; + char entity_pool_str1490[sizeof("lessdot")]; + char entity_pool_str1493[sizeof("profline")]; + char entity_pool_str1500[sizeof("qfr")]; + char entity_pool_str1501[sizeof("dArr")]; + char entity_pool_str1503[sizeof("nrtrie")]; + char entity_pool_str1507[sizeof("ShortRightArrow")]; + char entity_pool_str1515[sizeof("Therefore")]; + char entity_pool_str1519[sizeof("DD")]; + char entity_pool_str1524[sizeof("therefore")]; + char entity_pool_str1525[sizeof("Lfr")]; + char entity_pool_str1532[sizeof("target")]; + char entity_pool_str1535[sizeof("Element")]; + char entity_pool_str1536[sizeof("Yfr")]; + char entity_pool_str1537[sizeof("ClockwiseContourIntegral")]; + char entity_pool_str1542[sizeof("olcir")]; + char entity_pool_str1544[sizeof("Cfr")]; + char entity_pool_str1559[sizeof("female")]; + char entity_pool_str1560[sizeof("nsucceq")]; + char entity_pool_str1561[sizeof("oast")]; + char entity_pool_str1568[sizeof("percnt")]; + char entity_pool_str1578[sizeof("ordf")]; + char entity_pool_str1580[sizeof("ord")]; + char entity_pool_str1581[sizeof("Rho")]; + char entity_pool_str1583[sizeof("mscr")]; + char entity_pool_str1585[sizeof("nvrtrie")]; + char entity_pool_str1589[sizeof("lnE")]; + char entity_pool_str1597[sizeof("nhArr")]; + char entity_pool_str1598[sizeof("Or")]; + char entity_pool_str1602[sizeof("divide")]; + char entity_pool_str1604[sizeof("ifr")]; + char entity_pool_str1605[sizeof("elinters")]; + char entity_pool_str1615[sizeof("bsol")]; + char entity_pool_str1616[sizeof("nvlArr")]; + char entity_pool_str1626[sizeof("Imacr")]; + char entity_pool_str1628[sizeof("backsimeq")]; + char entity_pool_str1629[sizeof("twixt")]; + char entity_pool_str1630[sizeof("olcross")]; + char entity_pool_str1639[sizeof("rarrsim")]; + char entity_pool_str1640[sizeof("DoubleDownArrow")]; + char entity_pool_str1641[sizeof("larrsim")]; + char entity_pool_str1642[sizeof("emptyset")]; + char entity_pool_str1643[sizeof("oopf")]; + char entity_pool_str1645[sizeof("exist")]; + char entity_pool_str1648[sizeof("llhard")]; + char entity_pool_str1656[sizeof("excl")]; + char entity_pool_str1657[sizeof("Eopf")]; + char entity_pool_str1658[sizeof("nlArr")]; + char entity_pool_str1663[sizeof("thinsp")]; + char entity_pool_str1664[sizeof("NotSubsetEqual")]; + char entity_pool_str1665[sizeof("phi")]; + char entity_pool_str1666[sizeof("DoubleLeftArrow")]; + char entity_pool_str1668[sizeof("topcir")]; + char entity_pool_str1672[sizeof("div")]; + char entity_pool_str1674[sizeof("Nfr")]; + char entity_pool_str1675[sizeof("nlE")]; + char entity_pool_str1689[sizeof("zscr")]; + char entity_pool_str1690[sizeof("lrhard")]; + char entity_pool_str1697[sizeof("lltri")]; + char entity_pool_str1700[sizeof("nrArr")]; + char entity_pool_str1701[sizeof("NotSupersetEqual")]; + char entity_pool_str1703[sizeof("swArr")]; + char entity_pool_str1704[sizeof("ThickSpace")]; + char entity_pool_str1708[sizeof("ultri")]; + char entity_pool_str1709[sizeof("notnivb")]; + char entity_pool_str1711[sizeof("prime")]; + char entity_pool_str1714[sizeof("primes")]; + char entity_pool_str1716[sizeof("ohm")]; + char entity_pool_str1719[sizeof("CircleTimes")]; + char entity_pool_str1720[sizeof("nltri")]; + char entity_pool_str1723[sizeof("siml")]; + char entity_pool_str1724[sizeof("nwArr")]; + char entity_pool_str1727[sizeof("varpi")]; + char entity_pool_str1730[sizeof("orv")]; + char entity_pool_str1735[sizeof("setminus")]; + char entity_pool_str1739[sizeof("lrtri")]; + char entity_pool_str1743[sizeof("permil")]; + char entity_pool_str1744[sizeof("mid")]; + char entity_pool_str1750[sizeof("urtri")]; + char entity_pool_str1753[sizeof("dfr")]; + char entity_pool_str1754[sizeof("mho")]; + char entity_pool_str1755[sizeof("prE")]; + char entity_pool_str1759[sizeof("vsupne")]; + char entity_pool_str1762[sizeof("nrtri")]; + char entity_pool_str1763[sizeof("vsubne")]; + char entity_pool_str1765[sizeof("eDot")]; + char entity_pool_str1778[sizeof("lesges")]; + char entity_pool_str1781[sizeof("backepsilon")]; + char entity_pool_str1783[sizeof("ratail")]; + char entity_pool_str1785[sizeof("latail")]; + char entity_pool_str1788[sizeof("UpEquilibrium")]; + char entity_pool_str1791[sizeof("epsilon")]; + char entity_pool_str1796[sizeof("upsilon")]; + char entity_pool_str1798[sizeof("midast")]; + char entity_pool_str1799[sizeof("Hopf")]; + char entity_pool_str1800[sizeof("vltri")]; + char entity_pool_str1802[sizeof("Rfr")]; + char entity_pool_str1805[sizeof("Wedge")]; + char entity_pool_str1806[sizeof("wfr")]; + char entity_pool_str1812[sizeof("barwed")]; + char entity_pool_str1815[sizeof("malt")]; + char entity_pool_str1820[sizeof("Chi")]; + char entity_pool_str1821[sizeof("emptyv")]; + char entity_pool_str1822[sizeof("notni")]; + char entity_pool_str1827[sizeof("LessGreater")]; + char entity_pool_str1829[sizeof("diam")]; + char entity_pool_str1842[sizeof("vrtri")]; + char entity_pool_str1849[sizeof("CircleMinus")]; + char entity_pool_str1851[sizeof("Omacr")]; + char entity_pool_str1852[sizeof("seArr")]; + char entity_pool_str1859[sizeof("Ffr")]; + char entity_pool_str1865[sizeof("precneqq")]; + char entity_pool_str1867[sizeof("Diamond")]; + char entity_pool_str1868[sizeof("ordm")]; + char entity_pool_str1873[sizeof("neArr")]; + char entity_pool_str1874[sizeof("Iopf")]; + char entity_pool_str1875[sizeof("CircleDot")]; + char entity_pool_str1878[sizeof("prnap")]; + char entity_pool_str1884[sizeof("dotminus")]; + char entity_pool_str1903[sizeof("nshortmid")]; + char entity_pool_str1905[sizeof("bottom")]; + char entity_pool_str1907[sizeof("pointint")]; + char entity_pool_str1917[sizeof("SquareUnion")]; + char entity_pool_str1925[sizeof("jopf")]; + char entity_pool_str1928[sizeof("Upsilon")]; + char entity_pool_str1936[sizeof("Colone")]; + char entity_pool_str1938[sizeof("nvlt")]; + char entity_pool_str1941[sizeof("NestedLessLess")]; + char entity_pool_str1942[sizeof("Colon")]; + char entity_pool_str1945[sizeof("bsolhsub")]; + char entity_pool_str1949[sizeof("DoubleLeftRightArrow")]; + char entity_pool_str1950[sizeof("plussim")]; + char entity_pool_str1959[sizeof("image")]; + char entity_pool_str1960[sizeof("egs")]; + char entity_pool_str1963[sizeof("oscr")]; + char entity_pool_str1964[sizeof("swnwar")]; + char entity_pool_str1969[sizeof("zeetrf")]; + char entity_pool_str1973[sizeof("maltese")]; + char entity_pool_str1975[sizeof("mfr")]; + char entity_pool_str1976[sizeof("rarrfs")]; + char entity_pool_str1977[sizeof("Escr")]; + char entity_pool_str1978[sizeof("larrfs")]; + char entity_pool_str1985[sizeof("mnplus")]; + char entity_pool_str1986[sizeof("ngt")]; + char entity_pool_str1987[sizeof("ngtr")]; + char entity_pool_str1996[sizeof("gl")]; + char entity_pool_str2003[sizeof("diamondsuit")]; + char entity_pool_str2004[sizeof("GT")]; + char entity_pool_str2014[sizeof("lesssim")]; + char entity_pool_str2015[sizeof("dsol")]; + char entity_pool_str2023[sizeof("upharpoonleft")]; + char entity_pool_str2024[sizeof("SquareIntersection")]; + char entity_pool_str2025[sizeof("lsime")]; + char entity_pool_str2027[sizeof("nLt")]; + char entity_pool_str2029[sizeof("NotLess")]; + char entity_pool_str2031[sizeof("gnap")]; + char entity_pool_str2035[sizeof("scap")]; + char entity_pool_str2038[sizeof("mapstoleft")]; + char entity_pool_str2039[sizeof("NotLessLess")]; + char entity_pool_str2043[sizeof("rfloor")]; + char entity_pool_str2045[sizeof("lfloor")]; + char entity_pool_str2048[sizeof("nsime")]; + char entity_pool_str2050[sizeof("bsime")]; + char entity_pool_str2051[sizeof("NotLessEqual")]; + char entity_pool_str2052[sizeof("NotLessTilde")]; + char entity_pool_str2056[sizeof("ncap")]; + char entity_pool_str2059[sizeof("NotLessGreater")]; + char entity_pool_str2070[sizeof("precsim")]; + char entity_pool_str2072[sizeof("looparrowright")]; + char entity_pool_str2076[sizeof("Pr")]; + char entity_pool_str2077[sizeof("rcub")]; + char entity_pool_str2078[sizeof("mapstoup")]; + char entity_pool_str2079[sizeof("lcub")]; + char entity_pool_str2081[sizeof("zfr")]; + char entity_pool_str2084[sizeof("uparrow")]; + char entity_pool_str2086[sizeof("gne")]; + char entity_pool_str2090[sizeof("sce")]; + char entity_pool_str2091[sizeof("Im")]; + char entity_pool_str2096[sizeof("rcaron")]; + char entity_pool_str2098[sizeof("lcaron")]; + char entity_pool_str2099[sizeof("Oopf")]; + char entity_pool_str2100[sizeof("scaron")]; + char entity_pool_str2101[sizeof("backsim")]; + char entity_pool_str2102[sizeof("Tcaron")]; + char entity_pool_str2103[sizeof("Zcaron")]; + char entity_pool_str2104[sizeof("ecaron")]; + char entity_pool_str2106[sizeof("Bernoullis")]; + char entity_pool_str2110[sizeof("nge")]; + char entity_pool_str2111[sizeof("tcaron")]; + char entity_pool_str2113[sizeof("fork")]; + char entity_pool_str2119[sizeof("Hscr")]; + char entity_pool_str2121[sizeof("ncaron")]; + char entity_pool_str2122[sizeof("elsdot")]; + char entity_pool_str2124[sizeof("tbrk")]; + char entity_pool_str2128[sizeof("triplus")]; + char entity_pool_str2131[sizeof("diamond")]; + char entity_pool_str2134[sizeof("ncup")]; + char entity_pool_str2136[sizeof("bbrk")]; + char entity_pool_str2138[sizeof("frown")]; + char entity_pool_str2139[sizeof("bkarow")]; + char entity_pool_str2141[sizeof("spades")]; + char entity_pool_str2143[sizeof("psi")]; + char entity_pool_str2150[sizeof("Bopf")]; + char entity_pool_str2156[sizeof("dollar")]; + char entity_pool_str2164[sizeof("disin")]; + char entity_pool_str2170[sizeof("spadesuit")]; + char entity_pool_str2176[sizeof("NotTilde")]; + char entity_pool_str2177[sizeof("doublebarwedge")]; + char entity_pool_str2179[sizeof("gap")]; + char entity_pool_str2186[sizeof("bbrktbrk")]; + char entity_pool_str2189[sizeof("swarrow")]; + char entity_pool_str2190[sizeof("bepsi")]; + char entity_pool_str2194[sizeof("Iscr")]; + char entity_pool_str2198[sizeof("NotTildeFullEqual")]; + char entity_pool_str2199[sizeof("eqcolon")]; + char entity_pool_str2202[sizeof("tint")]; + char entity_pool_str2205[sizeof("intprod")]; + char entity_pool_str2207[sizeof("nsupE")]; + char entity_pool_str2210[sizeof("nwarrow")]; + char entity_pool_str2211[sizeof("nsubE")]; + char entity_pool_str2214[sizeof("nges")]; + char entity_pool_str2216[sizeof("Uparrow")]; + char entity_pool_str2217[sizeof("ge")]; + char entity_pool_str2218[sizeof("OpenCurlyDoubleQuote")]; + char entity_pool_str2223[sizeof("smallsetminus")]; + char entity_pool_str2228[sizeof("Scaron")]; + char entity_pool_str2230[sizeof("nvltrie")]; + char entity_pool_str2231[sizeof("ges")]; + char entity_pool_str2232[sizeof("blank")]; + char entity_pool_str2233[sizeof("QUOT")]; + char entity_pool_str2238[sizeof("block")]; + char entity_pool_str2239[sizeof("trade")]; + char entity_pool_str2245[sizeof("jscr")]; + char entity_pool_str2246[sizeof("wedge")]; + char entity_pool_str2254[sizeof("Amacr")]; + char entity_pool_str2256[sizeof("Equal")]; + char entity_pool_str2259[sizeof("Dcaron")]; + char entity_pool_str2262[sizeof("DotDot")]; + char entity_pool_str2270[sizeof("gneq")]; + char entity_pool_str2271[sizeof("varpropto")]; + char entity_pool_str2273[sizeof("gneqq")]; + char entity_pool_str2274[sizeof("Proportional")]; + char entity_pool_str2279[sizeof("isins")]; + char entity_pool_str2281[sizeof("eDDot")]; + char entity_pool_str2282[sizeof("isin")]; + char entity_pool_str2286[sizeof("TripleDot")]; + char entity_pool_str2290[sizeof("Fouriertrf")]; + char entity_pool_str2291[sizeof("Proportion")]; + char entity_pool_str2294[sizeof("ngeq")]; + char entity_pool_str2295[sizeof("Lcaron")]; + char entity_pool_str2297[sizeof("ngeqq")]; + char entity_pool_str2313[sizeof("lE")]; + char entity_pool_str2314[sizeof("Ccaron")]; + char entity_pool_str2320[sizeof("bsemi")]; + char entity_pool_str2326[sizeof("propto")]; + char entity_pool_str2331[sizeof("lesdot")]; + char entity_pool_str2332[sizeof("Conint")]; + char entity_pool_str2334[sizeof("And")]; + char entity_pool_str2338[sizeof("searrow")]; + char entity_pool_str2343[sizeof("orslope")]; + char entity_pool_str2344[sizeof("harr")]; + char entity_pool_str2350[sizeof("late")]; + char entity_pool_str2352[sizeof("CenterDot")]; + char entity_pool_str2355[sizeof("ofr")]; + char entity_pool_str2359[sizeof("nearrow")]; + char entity_pool_str2361[sizeof("qint")]; + char entity_pool_str2364[sizeof("lates")]; + char entity_pool_str2365[sizeof("kappav")]; + char entity_pool_str2368[sizeof("horbar")]; + char entity_pool_str2369[sizeof("Efr")]; + char entity_pool_str2370[sizeof("hoarr")]; + char entity_pool_str2371[sizeof("npre")]; + char entity_pool_str2377[sizeof("inodot")]; + char entity_pool_str2379[sizeof("udarr")]; + char entity_pool_str2386[sizeof("geq")]; + char entity_pool_str2391[sizeof("nsimeq")]; + char entity_pool_str2404[sizeof("geqq")]; + char entity_pool_str2407[sizeof("efDot")]; + char entity_pool_str2410[sizeof("rpargt")]; + char entity_pool_str2419[sizeof("Oscr")]; + char entity_pool_str2422[sizeof("plusdo")]; + char entity_pool_str2425[sizeof("lagran")]; + char entity_pool_str2429[sizeof("thicksim")]; + char entity_pool_str2440[sizeof("precnsim")]; + char entity_pool_str2444[sizeof("Ncaron")]; + char entity_pool_str2449[sizeof("napE")]; + char entity_pool_str2457[sizeof("iiint")]; + char entity_pool_str2470[sizeof("Bscr")]; + char entity_pool_str2483[sizeof("mapstodown")]; + char entity_pool_str2486[sizeof("varrho")]; + char entity_pool_str2488[sizeof("isinsv")]; + char entity_pool_str2491[sizeof("nvHarr")]; + char entity_pool_str2494[sizeof("NotLeftTriangleBar")]; + char entity_pool_str2496[sizeof("equest")]; + char entity_pool_str2498[sizeof("NotLeftTriangleEqual")]; + char entity_pool_str2499[sizeof("NotLeftTriangle")]; + char entity_pool_str2502[sizeof("Aopf")]; + char entity_pool_str2503[sizeof("hbar")]; + char entity_pool_str2507[sizeof("vangrt")]; + char entity_pool_str2511[sizeof("Hfr")]; + char entity_pool_str2517[sizeof("range")]; + char entity_pool_str2518[sizeof("smte")]; + char entity_pool_str2519[sizeof("lsim")]; + char entity_pool_str2521[sizeof("npolint")]; + char entity_pool_str2523[sizeof("dcaron")]; + char entity_pool_str2525[sizeof("esim")]; + char entity_pool_str2527[sizeof("Union")]; + char entity_pool_str2532[sizeof("smtes")]; + char entity_pool_str2536[sizeof("kopf")]; + char entity_pool_str2537[sizeof("gopf")]; + char entity_pool_str2542[sizeof("nsim")]; + char entity_pool_str2544[sizeof("bsim")]; + char entity_pool_str2546[sizeof("SmallCircle")]; + char entity_pool_str2548[sizeof("NotDoubleVerticalBar")]; + char entity_pool_str2549[sizeof("NotNestedGreaterGreater")]; + char entity_pool_str2565[sizeof("EqualTilde")]; + char entity_pool_str2568[sizeof("notindot")]; + char entity_pool_str2572[sizeof("Rcaron")]; + char entity_pool_str2577[sizeof("Popf")]; + char entity_pool_str2583[sizeof("Gopf")]; + char entity_pool_str2586[sizeof("Ifr")]; + char entity_pool_str2589[sizeof("wedgeq")]; + char entity_pool_str2595[sizeof("prod")]; + char entity_pool_str2617[sizeof("osol")]; + char entity_pool_str2624[sizeof("DoubleUpArrow")]; + char entity_pool_str2627[sizeof("Congruent")]; + char entity_pool_str2631[sizeof("gnsim")]; + char entity_pool_str2635[sizeof("scsim")]; + char entity_pool_str2637[sizeof("jfr")]; + char entity_pool_str2645[sizeof("upsih")]; + char entity_pool_str2650[sizeof("nLl")]; + char entity_pool_str2653[sizeof("DoubleUpDownArrow")]; + char entity_pool_str2655[sizeof("ngsim")]; + char entity_pool_str2664[sizeof("hearts")]; + char entity_pool_str2666[sizeof("lesseqgtr")]; + char entity_pool_str2670[sizeof("nesear")]; + char entity_pool_str2676[sizeof("Exists")]; + char entity_pool_str2687[sizeof("smile")]; + char entity_pool_str2689[sizeof("uwangle")]; + char entity_pool_str2693[sizeof("heartsuit")]; + char entity_pool_str2700[sizeof("HorizontalLine")]; + char entity_pool_str2703[sizeof("GreaterLess")]; + char entity_pool_str2705[sizeof("rsaquo")]; + char entity_pool_str2707[sizeof("lsaquo")]; + char entity_pool_str2709[sizeof("realine")]; + char entity_pool_str2710[sizeof("Dashv")]; + char entity_pool_str2714[sizeof("simdot")]; + char entity_pool_str2715[sizeof("GreaterEqual")]; + char entity_pool_str2716[sizeof("GreaterTilde")]; + char entity_pool_str2721[sizeof("GreaterEqualLess")]; + char entity_pool_str2723[sizeof("GreaterGreater")]; + char entity_pool_str2737[sizeof("rceil")]; + char entity_pool_str2739[sizeof("lceil")]; + char entity_pool_str2743[sizeof("lessgtr")]; + char entity_pool_str2746[sizeof("oline")]; + char entity_pool_str2753[sizeof("thksim")]; + char entity_pool_str2755[sizeof("InvisibleTimes")]; + char entity_pool_str2762[sizeof("race")]; + char entity_pool_str2766[sizeof("iquest")]; + char entity_pool_str2774[sizeof("imagline")]; + char entity_pool_str2779[sizeof("UpTee")]; + char entity_pool_str2781[sizeof("midcir")]; + char entity_pool_str2790[sizeof("ofcir")]; + char entity_pool_str2793[sizeof("ddarr")]; + char entity_pool_str2800[sizeof("rangd")]; + char entity_pool_str2802[sizeof("langd")]; + char entity_pool_str2808[sizeof("Equilibrium")]; + char entity_pool_str2809[sizeof("parsim")]; + char entity_pool_str2810[sizeof("Vdashl")]; + char entity_pool_str2811[sizeof("Ofr")]; + char entity_pool_str2816[sizeof("Because")]; + char entity_pool_str2818[sizeof("rAtail")]; + char entity_pool_str2820[sizeof("lAtail")]; + char entity_pool_str2821[sizeof("ominus")]; + char entity_pool_str2822[sizeof("Ascr")]; + char entity_pool_str2826[sizeof("Epsilon")]; + char entity_pool_str2832[sizeof("ShortLeftArrow")]; + char entity_pool_str2845[sizeof("isinv")]; + char entity_pool_str2847[sizeof("micro")]; + char entity_pool_str2851[sizeof("zcaron")]; + char entity_pool_str2856[sizeof("kscr")]; + char entity_pool_str2857[sizeof("gscr")]; + char entity_pool_str2862[sizeof("Bfr")]; + char entity_pool_str2863[sizeof("gel")]; + char entity_pool_str2864[sizeof("hercon")]; + char entity_pool_str2871[sizeof("triminus")]; + char entity_pool_str2877[sizeof("egrave")]; + char entity_pool_str2881[sizeof("sdot")]; + char entity_pool_str2882[sizeof("ugrave")]; + char entity_pool_str2884[sizeof("Zdot")]; + char entity_pool_str2885[sizeof("edot")]; + char entity_pool_str2890[sizeof("NotTildeTilde")]; + char entity_pool_str2892[sizeof("tdot")]; + char entity_pool_str2897[sizeof("Pscr")]; + char entity_pool_str2898[sizeof("Pi")]; + char entity_pool_str2903[sizeof("Gscr")]; + char entity_pool_str2910[sizeof("plustwo")]; + char entity_pool_str2914[sizeof("NotElement")]; + char entity_pool_str2916[sizeof("PlusMinus")]; + char entity_pool_str2919[sizeof("hopf")]; + char entity_pool_str2920[sizeof("gammad")]; + char entity_pool_str2922[sizeof("mDDot")]; + char entity_pool_str2926[sizeof("divideontimes")]; + char entity_pool_str2940[sizeof("doteq")]; + char entity_pool_str2956[sizeof("varepsilon")]; + char entity_pool_str2963[sizeof("Precedes")]; + char entity_pool_str2966[sizeof("Gammad")]; + char entity_pool_str2974[sizeof("dashv")]; + char entity_pool_str2979[sizeof("NotCongruent")]; + char entity_pool_str2982[sizeof("ubreve")]; + char entity_pool_str2990[sizeof("ogt")]; + char entity_pool_str2994[sizeof("RoundImplies")]; + char entity_pool_str3002[sizeof("PrecedesSlantEqual")]; + char entity_pool_str3005[sizeof("sime")]; + char entity_pool_str3014[sizeof("Ugrave")]; + char entity_pool_str3016[sizeof("dbkarow")]; + char entity_pool_str3021[sizeof("sdote")]; + char entity_pool_str3023[sizeof("veeeq")]; + char entity_pool_str3027[sizeof("mapsto")]; + char entity_pool_str3030[sizeof("times")]; + char entity_pool_str3033[sizeof("rangle")]; + char entity_pool_str3035[sizeof("langle")]; + char entity_pool_str3038[sizeof("leftarrowtail")]; + char entity_pool_str3039[sizeof("hamilt")]; + char entity_pool_str3044[sizeof("udhar")]; + char entity_pool_str3053[sizeof("nisd")]; + char entity_pool_str3055[sizeof("rfisht")]; + char entity_pool_str3057[sizeof("lfisht")]; + char entity_pool_str3058[sizeof("harrcir")]; + char entity_pool_str3066[sizeof("OpenCurlyQuote")]; + char entity_pool_str3068[sizeof("ufisht")]; + char entity_pool_str3069[sizeof("NotHumpDownHump")]; + char entity_pool_str3072[sizeof("LeftTee")]; + char entity_pool_str3074[sizeof("rsh")]; + char entity_pool_str3076[sizeof("lsh")]; + char entity_pool_str3080[sizeof("gvertneqq")]; + char entity_pool_str3083[sizeof("timesb")]; + char entity_pool_str3092[sizeof("scpolint")]; + char entity_pool_str3095[sizeof("Cdot")]; + char entity_pool_str3103[sizeof("dwangle")]; + char entity_pool_str3114[sizeof("Ubreve")]; + char entity_pool_str3132[sizeof("LeftUpVector")]; + char entity_pool_str3135[sizeof("LeftUpVectorBar")]; + char entity_pool_str3139[sizeof("Ecaron")]; + char entity_pool_str3142[sizeof("homtht")]; + char entity_pool_str3147[sizeof("igrave")]; + char entity_pool_str3155[sizeof("npreceq")]; + char entity_pool_str3156[sizeof("ecolon")]; + char entity_pool_str3167[sizeof("dd")]; + char entity_pool_str3174[sizeof("simeq")]; + char entity_pool_str3179[sizeof("notinE")]; + char entity_pool_str3198[sizeof("bigoplus")]; + char entity_pool_str3214[sizeof("Afr")]; + char entity_pool_str3215[sizeof("leftarrow")]; + char entity_pool_str3216[sizeof("oint")]; + char entity_pool_str3218[sizeof("Tab")]; + char entity_pool_str3227[sizeof("ogon")]; + char entity_pool_str3230[sizeof("lt")]; + char entity_pool_str3231[sizeof("nLeftrightarrow")]; + char entity_pool_str3235[sizeof("rarrb")]; + char entity_pool_str3237[sizeof("larrb")]; + char entity_pool_str3239[sizeof("hscr")]; + char entity_pool_str3246[sizeof("LeftUpDownVector")]; + char entity_pool_str3248[sizeof("kfr")]; + char entity_pool_str3249[sizeof("gfr")]; + char entity_pool_str3250[sizeof("UpArrowBar")]; + char entity_pool_str3259[sizeof("nsce")]; + char entity_pool_str3260[sizeof("ltdot")]; + char entity_pool_str3261[sizeof("gesl")]; + char entity_pool_str3262[sizeof("xodot")]; + char entity_pool_str3263[sizeof("star")]; + char entity_pool_str3266[sizeof("lowbar")]; + char entity_pool_str3268[sizeof("xharr")]; + char entity_pool_str3269[sizeof("ecir")]; + char entity_pool_str3271[sizeof("utdot")]; + char entity_pool_str3272[sizeof("natur")]; + char entity_pool_str3273[sizeof("Lsh")]; + char entity_pool_str3274[sizeof("infin")]; + char entity_pool_str3276[sizeof("comp")]; + char entity_pool_str3278[sizeof("sigmav")]; + char entity_pool_str3285[sizeof("xotime")]; + char entity_pool_str3289[sizeof("Pfr")]; + char entity_pool_str3295[sizeof("Gfr")]; + char entity_pool_str3298[sizeof("bigcap")]; + char entity_pool_str3300[sizeof("simlE")]; + char entity_pool_str3319[sizeof("iiiint")]; + char entity_pool_str3320[sizeof("barwedge")]; + char entity_pool_str3321[sizeof("Barwed")]; + char entity_pool_str3329[sizeof("xlarr")]; + char entity_pool_str3330[sizeof("LessEqualGreater")]; + char entity_pool_str3332[sizeof("crarr")]; + char entity_pool_str3333[sizeof("isindot")]; + char entity_pool_str3335[sizeof("commat")]; + char entity_pool_str3342[sizeof("middot")]; + char entity_pool_str3349[sizeof("lesdotor")]; + char entity_pool_str3356[sizeof("sigmaf")]; + char entity_pool_str3366[sizeof("rarrbfs")]; + char entity_pool_str3368[sizeof("larrbfs")]; + char entity_pool_str3371[sizeof("xrarr")]; + char entity_pool_str3376[sizeof("bigcup")]; + char entity_pool_str3378[sizeof("clubs")]; + char entity_pool_str3379[sizeof("hArr")]; + char entity_pool_str3380[sizeof("rtrie")]; + char entity_pool_str3382[sizeof("ltrie")]; + char entity_pool_str3383[sizeof("imped")]; + char entity_pool_str3388[sizeof("eogon")]; + char entity_pool_str3389[sizeof("rx")]; + char entity_pool_str3390[sizeof("ltrPar")]; + char entity_pool_str3391[sizeof("Star")]; + char entity_pool_str3393[sizeof("uogon")]; + char entity_pool_str3396[sizeof("Tilde")]; + char entity_pool_str3398[sizeof("half")]; + char entity_pool_str3405[sizeof("tilde")]; + char entity_pool_str3412[sizeof("Leftarrow")]; + char entity_pool_str3417[sizeof("gesles")]; + char entity_pool_str3422[sizeof("cap")]; + char entity_pool_str3423[sizeof("strns")]; + char entity_pool_str3427[sizeof("Lt")]; + char entity_pool_str3439[sizeof("prnE")]; + char entity_pool_str3447[sizeof("sqsupe")]; + char entity_pool_str3462[sizeof("sqsupset")]; + char entity_pool_str3467[sizeof("tridot")]; + char entity_pool_str3468[sizeof("order")]; + char entity_pool_str3471[sizeof("caps")]; + char entity_pool_str3475[sizeof("cross")]; + char entity_pool_str3482[sizeof("dfisht")]; + char entity_pool_str3487[sizeof("xmap")]; + char entity_pool_str3491[sizeof("sqsup")]; + char entity_pool_str3503[sizeof("rtri")]; + char entity_pool_str3505[sizeof("ltri")]; + char entity_pool_str3506[sizeof("it")]; + char entity_pool_str3507[sizeof("rmoust")]; + char entity_pool_str3509[sizeof("lmoust")]; + char entity_pool_str3510[sizeof("gnE")]; + char entity_pool_str3511[sizeof("lgE")]; + char entity_pool_str3514[sizeof("scE")]; + char entity_pool_str3516[sizeof("utri")]; + char entity_pool_str3518[sizeof("vellip")]; + char entity_pool_str3520[sizeof("ETH")]; + char entity_pool_str3523[sizeof("lmidot")]; + char entity_pool_str3525[sizeof("Uogon")]; + char entity_pool_str3526[sizeof("CounterClockwiseContourIntegral")]; + char entity_pool_str3534[sizeof("ngE")]; + char entity_pool_str3535[sizeof("nwnear")]; + char entity_pool_str3543[sizeof("lesg")]; + char entity_pool_str3546[sizeof("plusb")]; + char entity_pool_str3550[sizeof("Rsh")]; + char entity_pool_str3555[sizeof("copysr")]; + char entity_pool_str3557[sizeof("infintie")]; + char entity_pool_str3559[sizeof("imath")]; + char entity_pool_str3560[sizeof("Esim")]; + char entity_pool_str3565[sizeof("Phi")]; + char entity_pool_str3573[sizeof("glE")]; + char entity_pool_str3579[sizeof("vnsup")]; + char entity_pool_str3582[sizeof("simgE")]; + char entity_pool_str3586[sizeof("DoubleLongLeftArrow")]; + char entity_pool_str3591[sizeof("DoubleLongLeftRightArrow")]; + char entity_pool_str3594[sizeof("nvgt")]; + char entity_pool_str3607[sizeof("Mellintrf")]; + char entity_pool_str3611[sizeof("Prime")]; + char entity_pool_str3615[sizeof("iinfin")]; + char entity_pool_str3620[sizeof("ReverseElement")]; + char entity_pool_str3627[sizeof("EmptySmallSquare")]; + char entity_pool_str3628[sizeof("radic")]; + char entity_pool_str3631[sizeof("hfr")]; + char entity_pool_str3632[sizeof("zdot")]; + char entity_pool_str3633[sizeof("male")]; + char entity_pool_str3635[sizeof("rarrc")]; + char entity_pool_str3636[sizeof("prec")]; + char entity_pool_str3637[sizeof("scnap")]; + char entity_pool_str3641[sizeof("DifferentialD")]; + char entity_pool_str3643[sizeof("models")]; + char entity_pool_str3657[sizeof("ltcir")]; + char entity_pool_str3658[sizeof("iogon")]; + char entity_pool_str3665[sizeof("capcap")]; + char entity_pool_str3667[sizeof("iff")]; + char entity_pool_str3669[sizeof("ddotseq")]; + char entity_pool_str3671[sizeof("CirclePlus")]; + char entity_pool_str3676[sizeof("rthree")]; + char entity_pool_str3678[sizeof("lthree")]; + char entity_pool_str3681[sizeof("PrecedesTilde")]; + char entity_pool_str3685[sizeof("dtdot")]; + char entity_pool_str3687[sizeof("clubsuit")]; + char entity_pool_str3689[sizeof("racute")]; + char entity_pool_str3691[sizeof("lacute")]; + char entity_pool_str3692[sizeof("trpezium")]; + char entity_pool_str3693[sizeof("sacute")]; + char entity_pool_str3696[sizeof("Zacute")]; + char entity_pool_str3697[sizeof("eacute")]; + char entity_pool_str3699[sizeof("TildeTilde")]; + char entity_pool_str3701[sizeof("Uarrocir")]; + char entity_pool_str3702[sizeof("uacute")]; + char entity_pool_str3703[sizeof("lowast")]; + char entity_pool_str3714[sizeof("nacute")]; + char entity_pool_str3716[sizeof("NotPrecedes")]; + char entity_pool_str3720[sizeof("Lmidot")]; + char entity_pool_str3725[sizeof("UpArrow")]; + char entity_pool_str3727[sizeof("rarrw")]; + char entity_pool_str3738[sizeof("DownTee")]; + char entity_pool_str3742[sizeof("FilledSmallSquare")]; + char entity_pool_str3743[sizeof("capcup")]; + char entity_pool_str3749[sizeof("GreaterFullEqual")]; + char entity_pool_str3756[sizeof("nvle")]; + char entity_pool_str3758[sizeof("trie")]; + char entity_pool_str3764[sizeof("omicron")]; + char entity_pool_str3766[sizeof("DoubleRightTee")]; + char entity_pool_str3767[sizeof("Cconint")]; + char entity_pool_str3768[sizeof("rsquor")]; + char entity_pool_str3770[sizeof("lsquor")]; + char entity_pool_str3772[sizeof("zigrarr")]; + char entity_pool_str3780[sizeof("copf")]; + char entity_pool_str3782[sizeof("ContourIntegral")]; + char entity_pool_str3798[sizeof("hairsp")]; + char entity_pool_str3799[sizeof("sqsupseteq")]; + char entity_pool_str3800[sizeof("csub")]; + char entity_pool_str3801[sizeof("upharpoonright")]; + char entity_pool_str3805[sizeof("DownBreve")]; + char entity_pool_str3817[sizeof("ShortDownArrow")]; + char entity_pool_str3819[sizeof("xopf")]; + char entity_pool_str3821[sizeof("Sacute")]; + char entity_pool_str3829[sizeof("vsupnE")]; + char entity_pool_str3830[sizeof("cir")]; + char entity_pool_str3831[sizeof("plusacir")]; + char entity_pool_str3832[sizeof("csup")]; + char entity_pool_str3833[sizeof("vsubnE")]; + char entity_pool_str3834[sizeof("Uacute")]; + char entity_pool_str3836[sizeof("isinE")]; + char entity_pool_str3845[sizeof("gEl")]; + char entity_pool_str3851[sizeof("sqcups")]; + char entity_pool_str3853[sizeof("smid")]; + char entity_pool_str3855[sizeof("lg")]; + char entity_pool_str3857[sizeof("DoubleLongRightArrow")]; + char entity_pool_str3858[sizeof("NotPrecedesSlantEqual")]; + char entity_pool_str3861[sizeof("eg")]; + char entity_pool_str3864[sizeof("AMP")]; + char entity_pool_str3874[sizeof("nmid")]; + char entity_pool_str3883[sizeof("timesd")]; + char entity_pool_str3886[sizeof("DownLeftVector")]; + char entity_pool_str3887[sizeof("zwnj")]; + char entity_pool_str3888[sizeof("Lacute")]; + char entity_pool_str3889[sizeof("DownLeftVectorBar")]; + char entity_pool_str3898[sizeof("ograve")]; + char entity_pool_str3899[sizeof("Yacute")]; + char entity_pool_str3903[sizeof("sqcup")]; + char entity_pool_str3906[sizeof("odot")]; + char entity_pool_str3907[sizeof("Cacute")]; + char entity_pool_str3909[sizeof("nu")]; + char entity_pool_str3910[sizeof("tritime")]; + char entity_pool_str3912[sizeof("Egrave")]; + char entity_pool_str3913[sizeof("eplus")]; + char entity_pool_str3915[sizeof("backcong")]; + char entity_pool_str3918[sizeof("uplus")]; + char entity_pool_str3920[sizeof("Edot")]; + char entity_pool_str3924[sizeof("csupe")]; + char entity_pool_str3926[sizeof("simg")]; + char entity_pool_str3927[sizeof("UpperRightArrow")]; + char entity_pool_str3928[sizeof("csube")]; + char entity_pool_str3930[sizeof("dtri")]; + char entity_pool_str3931[sizeof("prnsim")]; + char entity_pool_str3936[sizeof("boxUr")]; + char entity_pool_str3937[sizeof("uuarr")]; + char entity_pool_str3945[sizeof("DownLeftTeeVector")]; + char entity_pool_str3946[sizeof("gsime")]; + char entity_pool_str3950[sizeof("bigotimes")]; + char entity_pool_str3951[sizeof("Dagger")]; + char entity_pool_str3954[sizeof("Intersection")]; + char entity_pool_str3967[sizeof("iacute")]; + char entity_pool_str3969[sizeof("prcue")]; + char entity_pool_str3981[sizeof("egsdot")]; + char entity_pool_str3987[sizeof("Implies")]; + char entity_pool_str3988[sizeof("VDash")]; + char entity_pool_str3996[sizeof("bump")]; + char entity_pool_str4015[sizeof("Mu")]; + char entity_pool_str4022[sizeof("vDash")]; + char entity_pool_str4028[sizeof("lvnE")]; + char entity_pool_str4033[sizeof("LeftTeeArrow")]; + char entity_pool_str4037[sizeof("Nacute")]; + char entity_pool_str4042[sizeof("UnderBrace")]; + char entity_pool_str4043[sizeof("Psi")]; + char entity_pool_str4047[sizeof("rhov")]; + char entity_pool_str4049[sizeof("lescc")]; + char entity_pool_str4055[sizeof("sup1")]; + char entity_pool_str4058[sizeof("sup2")]; + char entity_pool_str4066[sizeof("sup3")]; + char entity_pool_str4071[sizeof("bigodot")]; + char entity_pool_str4078[sizeof("Downarrow")]; + char entity_pool_str4080[sizeof("xsqcup")]; + char entity_pool_str4082[sizeof("barvee")]; + char entity_pool_str4087[sizeof("NegativeMediumSpace")]; + char entity_pool_str4088[sizeof("bumpe")]; + char entity_pool_str4100[sizeof("cscr")]; + char entity_pool_str4109[sizeof("nsc")]; + char entity_pool_str4115[sizeof("sup")]; + char entity_pool_str4122[sizeof("cedil")]; + char entity_pool_str4125[sizeof("boxVr")]; + char entity_pool_str4127[sizeof("origof")]; + char entity_pool_str4128[sizeof("zwj")]; + char entity_pool_str4129[sizeof("Igrave")]; + char entity_pool_str4137[sizeof("Idot")]; + char entity_pool_str4139[sizeof("xscr")]; + char entity_pool_str4140[sizeof("xi")]; + char entity_pool_str4144[sizeof("nGtv")]; + char entity_pool_str4153[sizeof("boxHu")]; + char entity_pool_str4163[sizeof("THORN")]; + char entity_pool_str4165[sizeof("Racute")]; + char entity_pool_str4167[sizeof("rarrhk")]; + char entity_pool_str4169[sizeof("larrhk")]; + char entity_pool_str4177[sizeof("rtriltri")]; + char entity_pool_str4189[sizeof("boxV")]; + char entity_pool_str4215[sizeof("dagger")]; + char entity_pool_str4220[sizeof("Omicron")]; + char entity_pool_str4226[sizeof("DoubleVerticalBar")]; + char entity_pool_str4229[sizeof("nexists")]; + char entity_pool_str4232[sizeof("Nu")]; + char entity_pool_str4233[sizeof("nexist")]; + char entity_pool_str4234[sizeof("gE")]; + char entity_pool_str4238[sizeof("ap")]; + char entity_pool_str4243[sizeof("Sup")]; + char entity_pool_str4244[sizeof("doteqdot")]; + char entity_pool_str4247[sizeof("eng")]; + char entity_pool_str4249[sizeof("caron")]; + char entity_pool_str4251[sizeof("boxHU")]; + char entity_pool_str4252[sizeof("gesdot")]; + char entity_pool_str4257[sizeof("ReverseEquilibrium")]; + char entity_pool_str4262[sizeof("boxUL")]; + char entity_pool_str4264[sizeof("supmult")]; + char entity_pool_str4267[sizeof("pitchfork")]; + char entity_pool_str4272[sizeof("numsp")]; + char entity_pool_str4285[sizeof("rang")]; + char entity_pool_str4287[sizeof("lang")]; + char entity_pool_str4290[sizeof("ocir")]; + char entity_pool_str4292[sizeof("rationals")]; + char entity_pool_str4294[sizeof("coprod")]; + char entity_pool_str4307[sizeof("ltlarr")]; + char entity_pool_str4308[sizeof("breve")]; + char entity_pool_str4310[sizeof("nang")]; + char entity_pool_str4315[sizeof("swarhk")]; + char entity_pool_str4322[sizeof("raquo")]; + char entity_pool_str4324[sizeof("laquo")]; + char entity_pool_str4325[sizeof("supsub")]; + char entity_pool_str4329[sizeof("Cup")]; + char entity_pool_str4330[sizeof("ape")]; + char entity_pool_str4331[sizeof("quest")]; + char entity_pool_str4336[sizeof("nwarhk")]; + char entity_pool_str4340[sizeof("supset")]; + char entity_pool_str4342[sizeof("downarrow")]; + char entity_pool_str4351[sizeof("duarr")]; + char entity_pool_str4353[sizeof("apos")]; + char entity_pool_str4354[sizeof("Ograve")]; + char entity_pool_str4355[sizeof("shortparallel")]; + char entity_pool_str4364[sizeof("nsucc")]; + char entity_pool_str4368[sizeof("LongLeftArrow")]; + char entity_pool_str4377[sizeof("lesdoto")]; + char entity_pool_str4384[sizeof("supne")]; + char entity_pool_str4388[sizeof("nGg")]; + char entity_pool_str4396[sizeof("raemptyv")]; + char entity_pool_str4397[sizeof("supsup")]; + char entity_pool_str4398[sizeof("laemptyv")]; + char entity_pool_str4401[sizeof("topfork")]; + char entity_pool_str4423[sizeof("Eogon")]; + char entity_pool_str4429[sizeof("risingdotseq")]; + char entity_pool_str4431[sizeof("bumpeq")]; + char entity_pool_str4435[sizeof("lstrok")]; + char entity_pool_str4439[sizeof("Tstrok")]; + char entity_pool_str4440[sizeof("gsim")]; + char entity_pool_str4443[sizeof("bemptyv")]; + char entity_pool_str4444[sizeof("zacute")]; + char entity_pool_str4445[sizeof("gsiml")]; + char entity_pool_str4448[sizeof("tstrok")]; + char entity_pool_str4450[sizeof("roang")]; + char entity_pool_str4451[sizeof("boxVL")]; + char entity_pool_str4452[sizeof("loang")]; + char entity_pool_str4456[sizeof("nleqslant")]; + char entity_pool_str4462[sizeof("sbquo")]; + char entity_pool_str4464[sizeof("searhk")]; + char entity_pool_str4465[sizeof("lnapprox")]; + char entity_pool_str4468[sizeof("Supset")]; + char entity_pool_str4470[sizeof("boxHd")]; + char entity_pool_str4471[sizeof("varkappa")]; + char entity_pool_str4475[sizeof("circeq")]; + char entity_pool_str4477[sizeof("yopf")]; + char entity_pool_str4479[sizeof("UnionPlus")]; + char entity_pool_str4484[sizeof("Lang")]; + char entity_pool_str4485[sizeof("nearhk")]; + char entity_pool_str4486[sizeof("shcy")]; + char entity_pool_str4492[sizeof("cfr")]; + char entity_pool_str4506[sizeof("Kappa")]; + char entity_pool_str4507[sizeof("ljcy")]; + char entity_pool_str4508[sizeof("MediumSpace")]; + char entity_pool_str4511[sizeof("supseteq")]; + char entity_pool_str4512[sizeof("supseteqq")]; + char entity_pool_str4517[sizeof("reg")]; + char entity_pool_str4518[sizeof("amacr")]; + char entity_pool_str4519[sizeof("leg")]; + char entity_pool_str4524[sizeof("weierp")]; + char entity_pool_str4525[sizeof("TScy")]; + char entity_pool_str4529[sizeof("supsetneq")]; + char entity_pool_str4530[sizeof("njcy")]; + char entity_pool_str4531[sizeof("xfr")]; + char entity_pool_str4533[sizeof("mu")]; + char entity_pool_str4539[sizeof("nvinfin")]; + char entity_pool_str4540[sizeof("boxUR")]; + char entity_pool_str4545[sizeof("xoplus")]; + char entity_pool_str4551[sizeof("leftleftarrows")]; + char entity_pool_str4552[sizeof("sum")]; + char entity_pool_str4559[sizeof("beth")]; + char entity_pool_str4563[sizeof("complement")]; + char entity_pool_str4573[sizeof("num")]; + char entity_pool_str4574[sizeof("amp")]; + char entity_pool_str4583[sizeof("boxUl")]; + char entity_pool_str4590[sizeof("NotGreater")]; + char entity_pool_str4591[sizeof("boxplus")]; + char entity_pool_str4592[sizeof("jmath")]; + char entity_pool_str4594[sizeof("sfrown")]; + char entity_pool_str4596[sizeof("Dstrok")]; + char entity_pool_str4598[sizeof("and")]; + char entity_pool_str4599[sizeof("NotGreaterGreater")]; + char entity_pool_str4606[sizeof("NotGreaterSlantEqual")]; + char entity_pool_str4608[sizeof("NotGreaterLess")]; + char entity_pool_str4609[sizeof("quot")]; + char entity_pool_str4616[sizeof("NotGreaterFullEqual")]; + char entity_pool_str4617[sizeof("hyphen")]; + char entity_pool_str4618[sizeof("planck")]; + char entity_pool_str4620[sizeof("TildeEqual")]; + char entity_pool_str4627[sizeof("tosa")]; + char entity_pool_str4632[sizeof("Lstrok")]; + char entity_pool_str4635[sizeof("shy")]; + char entity_pool_str4639[sizeof("xnis")]; + char entity_pool_str4640[sizeof("Iogon")]; + char entity_pool_str4643[sizeof("DZcy")]; + char entity_pool_str4645[sizeof("ohbar")]; + char entity_pool_str4652[sizeof("cirscir")]; + char entity_pool_str4654[sizeof("sext")]; + char entity_pool_str4668[sizeof("para")]; + char entity_pool_str4671[sizeof("ast")]; + char entity_pool_str4678[sizeof("questeq")]; + char entity_pool_str4680[sizeof("Sum")]; + char entity_pool_str4682[sizeof("DScy")]; + char entity_pool_str4684[sizeof("ENG")]; + char entity_pool_str4686[sizeof("ZHcy")]; + char entity_pool_str4689[sizeof("longleftarrow")]; + char entity_pool_str4691[sizeof("dash")]; + char entity_pool_str4699[sizeof("DownTeeArrow")]; + char entity_pool_str4706[sizeof("supsetneqq")]; + char entity_pool_str4714[sizeof("profalar")]; + char entity_pool_str4718[sizeof("oacute")]; + char entity_pool_str4729[sizeof("boxVR")]; + char entity_pool_str4732[sizeof("Eacute")]; + char entity_pool_str4738[sizeof("supplus")]; + char entity_pool_str4740[sizeof("hookleftarrow")]; + char entity_pool_str4743[sizeof("CloseCurlyQuote")]; + char entity_pool_str4746[sizeof("trisb")]; + char entity_pool_str4747[sizeof("dotsquare")]; + char entity_pool_str4751[sizeof("rtimes")]; + char entity_pool_str4753[sizeof("ltimes")]; + char entity_pool_str4756[sizeof("toea")]; + char entity_pool_str4757[sizeof("Agrave")]; + char entity_pool_str4760[sizeof("Assign")]; + char entity_pool_str4761[sizeof("Rang")]; + char entity_pool_str4762[sizeof("iocy")]; + char entity_pool_str4764[sizeof("NotPrecedesEqual")]; + char entity_pool_str4766[sizeof("aopf")]; + char entity_pool_str4768[sizeof("chi")]; + char entity_pool_str4771[sizeof("quaternions")]; + char entity_pool_str4772[sizeof("boxVl")]; + char entity_pool_str4773[sizeof("NotGreaterEqual")]; + char entity_pool_str4777[sizeof("xhArr")]; + char entity_pool_str4791[sizeof("orderof")]; + char entity_pool_str4794[sizeof("rsquo")]; + char entity_pool_str4796[sizeof("lsquo")]; + char entity_pool_str4797[sizeof("yscr")]; + char entity_pool_str4800[sizeof("gdot")]; + char entity_pool_str4802[sizeof("NotSquareSubsetEqual")]; + char entity_pool_str4803[sizeof("KHcy")]; + char entity_pool_str4809[sizeof("bsolb")]; + char entity_pool_str4810[sizeof("NotSquareSubset")]; + char entity_pool_str4811[sizeof("SHcy")]; + char entity_pool_str4821[sizeof("YIcy")]; + char entity_pool_str4825[sizeof("cwint")]; + char entity_pool_str4828[sizeof("Theta")]; + char entity_pool_str4837[sizeof("theta")]; + char entity_pool_str4838[sizeof("xlArr")]; + char entity_pool_str4840[sizeof("NotSquareSupersetEqual")]; + char entity_pool_str4843[sizeof("demptyv")]; + char entity_pool_str4844[sizeof("triangle")]; + char entity_pool_str4846[sizeof("Gdot")]; + char entity_pool_str4848[sizeof("NotSquareSuperset")]; + char entity_pool_str4857[sizeof("Abreve")]; + char entity_pool_str4860[sizeof("dstrok")]; + char entity_pool_str4861[sizeof("pertenk")]; + char entity_pool_str4866[sizeof("rbrack")]; + char entity_pool_str4868[sizeof("lbrack")]; + char entity_pool_str4872[sizeof("odsold")]; + char entity_pool_str4878[sizeof("omid")]; + char entity_pool_str4880[sizeof("xrArr")]; + char entity_pool_str4882[sizeof("triangleleft")]; + char entity_pool_str4883[sizeof("NotGreaterTilde")]; + char entity_pool_str4884[sizeof("colone")]; + char entity_pool_str4886[sizeof("Longleftarrow")]; + char entity_pool_str4888[sizeof("iota")]; + char entity_pool_str4890[sizeof("colon")]; + char entity_pool_str4891[sizeof("Zeta")]; + char entity_pool_str4892[sizeof("gbreve")]; + char entity_pool_str4897[sizeof("CHcy")]; + char entity_pool_str4900[sizeof("YUcy")]; + char entity_pool_str4901[sizeof("REG")]; + char entity_pool_str4902[sizeof("szlig")]; + char entity_pool_str4909[sizeof("dzcy")]; + char entity_pool_str4911[sizeof("beta")]; + char entity_pool_str4918[sizeof("euro")]; + char entity_pool_str4921[sizeof("LeftArrow")]; + char entity_pool_str4924[sizeof("CapitalDifferentialD")]; + char entity_pool_str4926[sizeof("ring")]; + char entity_pool_str4927[sizeof("Laplacetrf")]; + char entity_pool_str4932[sizeof("djcy")]; + char entity_pool_str4934[sizeof("oplus")]; + char entity_pool_str4937[sizeof("integers")]; + char entity_pool_str4938[sizeof("Gbreve")]; + char entity_pool_str4940[sizeof("ubrcy")]; + char entity_pool_str4941[sizeof("euml")]; + char entity_pool_str4944[sizeof("deg")]; + char entity_pool_str4946[sizeof("uuml")]; + char entity_pool_str4949[sizeof("Iacute")]; + char entity_pool_str4950[sizeof("succeq")]; + char entity_pool_str4952[sizeof("KJcy")]; + char entity_pool_str4961[sizeof("CupCap")]; + char entity_pool_str4975[sizeof("tscy")]; + char entity_pool_str4982[sizeof("cent")]; + char entity_pool_str4991[sizeof("DJcy")]; + char entity_pool_str5009[sizeof("TildeFullEqual")]; + char entity_pool_str5011[sizeof("triangleq")]; + char entity_pool_str5016[sizeof("duhar")]; + char entity_pool_str5025[sizeof("LeftDoubleBracket")]; + char entity_pool_str5027[sizeof("LJcy")]; + char entity_pool_str5036[sizeof("iecy")]; + char entity_pool_str5043[sizeof("trianglelefteq")]; + char entity_pool_str5049[sizeof("nequiv")]; + char entity_pool_str5055[sizeof("nshortparallel")]; + char entity_pool_str5062[sizeof("ndash")]; + char entity_pool_str5063[sizeof("bowtie")]; + char entity_pool_str5065[sizeof("fjlig")]; + char entity_pool_str5072[sizeof("Ubrcy")]; + char entity_pool_str5074[sizeof("vartheta")]; + char entity_pool_str5078[sizeof("Uuml")]; + char entity_pool_str5084[sizeof("vartriangleright")]; + char entity_pool_str5085[sizeof("vartriangleleft")]; + char entity_pool_str5086[sizeof("ascr")]; + char entity_pool_str5089[sizeof("succcurlyeq")]; + char entity_pool_str5093[sizeof("cwconint")]; + char entity_pool_str5101[sizeof("sc")]; + char entity_pool_str5103[sizeof("fllig")]; + char entity_pool_str5105[sizeof("circledast")]; + char entity_pool_str5108[sizeof("Vdash")]; + char entity_pool_str5112[sizeof("nVdash")]; + char entity_pool_str5120[sizeof("suplarr")]; + char entity_pool_str5124[sizeof("robrk")]; + char entity_pool_str5126[sizeof("lobrk")]; + char entity_pool_str5142[sizeof("vdash")]; + char entity_pool_str5143[sizeof("Yuml")]; + char entity_pool_str5151[sizeof("gt")]; + char entity_pool_str5156[sizeof("ccaps")]; + char entity_pool_str5173[sizeof("Succeeds")]; + char entity_pool_str5174[sizeof("Oacute")]; + char entity_pool_str5175[sizeof("TRADE")]; + char entity_pool_str5176[sizeof("NJcy")]; + char entity_pool_str5181[sizeof("gtdot")]; + char entity_pool_str5189[sizeof("yfr")]; + char entity_pool_str5192[sizeof("compfn")]; + char entity_pool_str5197[sizeof("Gt")]; + char entity_pool_str5198[sizeof("scnE")]; + char entity_pool_str5199[sizeof("ijlig")]; + char entity_pool_str5203[sizeof("circledS")]; + char entity_pool_str5206[sizeof("yen")]; + char entity_pool_str5208[sizeof("thetasym")]; + char entity_pool_str5211[sizeof("iuml")]; + char entity_pool_str5212[sizeof("SucceedsSlantEqual")]; + char entity_pool_str5217[sizeof("boxH")]; + char entity_pool_str5218[sizeof("mumap")]; + char entity_pool_str5222[sizeof("rightrightarrows")]; + char entity_pool_str5227[sizeof("coloneq")]; + char entity_pool_str5229[sizeof("Sc")]; + char entity_pool_str5230[sizeof("glj")]; + char entity_pool_str5231[sizeof("iexcl")]; + char entity_pool_str5234[sizeof("ccups")]; + char entity_pool_str5236[sizeof("xcap")]; + char entity_pool_str5237[sizeof("zhcy")]; + char entity_pool_str5241[sizeof("boxHD")]; + char entity_pool_str5250[sizeof("leqslant")]; + char entity_pool_str5252[sizeof("UpperLeftArrow")]; + char entity_pool_str5257[sizeof("dblac")]; + char entity_pool_str5260[sizeof("puncsp")]; + char entity_pool_str5262[sizeof("ccaron")]; + char entity_pool_str5264[sizeof("rbbrk")]; + char entity_pool_str5266[sizeof("lbbrk")]; + char entity_pool_str5268[sizeof("Aogon")]; + char entity_pool_str5269[sizeof("LeftTriangleBar")]; + char entity_pool_str5272[sizeof("gesdotol")]; + char entity_pool_str5273[sizeof("LeftTriangleEqual")]; + char entity_pool_str5274[sizeof("LeftTriangle")]; + char entity_pool_str5280[sizeof("conint")]; + char entity_pool_str5283[sizeof("drbkarow")]; + char entity_pool_str5295[sizeof("rtrif")]; + char entity_pool_str5297[sizeof("ltrif")]; + char entity_pool_str5300[sizeof("ReverseUpEquilibrium")]; + char entity_pool_str5306[sizeof("LeftCeiling")]; + char entity_pool_str5308[sizeof("utrif")]; + char entity_pool_str5314[sizeof("xcup")]; + char entity_pool_str5319[sizeof("fallingdotseq")]; + char entity_pool_str5325[sizeof("rcedil")]; + char entity_pool_str5327[sizeof("lcedil")]; + char entity_pool_str5329[sizeof("scedil")]; + char entity_pool_str5331[sizeof("Tcedil")]; + char entity_pool_str5333[sizeof("starf")]; + char entity_pool_str5334[sizeof("boxminus")]; + char entity_pool_str5340[sizeof("tcedil")]; + char entity_pool_str5341[sizeof("ZeroWidthSpace")]; + char entity_pool_str5350[sizeof("ncedil")]; + char entity_pool_str5358[sizeof("phiv")]; + char entity_pool_str5375[sizeof("ic")]; + char entity_pool_str5384[sizeof("capdot")]; + char entity_pool_str5387[sizeof("dscy")]; + char entity_pool_str5397[sizeof("check")]; + char entity_pool_str5398[sizeof("ovbar")]; + char entity_pool_str5405[sizeof("ntriangleleft")]; + char entity_pool_str5411[sizeof("RightTee")]; + char entity_pool_str5412[sizeof("nvge")]; + char entity_pool_str5424[sizeof("leftrightsquigarrow")]; + char entity_pool_str5431[sizeof("lozenge")]; + char entity_pool_str5434[sizeof("RightTriangleBar")]; + char entity_pool_str5436[sizeof("RightTeeVector")]; + char entity_pool_str5438[sizeof("RightTriangleEqual")]; + char entity_pool_str5439[sizeof("RightTriangle")]; + char entity_pool_str5449[sizeof("Kcedil")]; + char entity_pool_str5457[sizeof("Scedil")]; + char entity_pool_str5468[sizeof("cirfnint")]; + char entity_pool_str5471[sizeof("empty")]; + char entity_pool_str5478[sizeof("afr")]; + char entity_pool_str5482[sizeof("DiacriticalTilde")]; + char entity_pool_str5489[sizeof("LeftDownVector")]; + char entity_pool_str5492[sizeof("LeftDownVectorBar")]; + char entity_pool_str5501[sizeof("lEg")]; + char entity_pool_str5509[sizeof("ApplyFunction")]; + char entity_pool_str5512[sizeof("bumpE")]; + char entity_pool_str5524[sizeof("Lcedil")]; + char entity_pool_str5528[sizeof("caret")]; + char entity_pool_str5530[sizeof("Barv")]; + char entity_pool_str5543[sizeof("Ccedil")]; + char entity_pool_str5547[sizeof("circledR")]; + char entity_pool_str5548[sizeof("LeftDownTeeVector")]; + char entity_pool_str5552[sizeof("tshcy")]; + char entity_pool_str5556[sizeof("DotEqual")]; + char entity_pool_str5564[sizeof("centerdot")]; + char entity_pool_str5566[sizeof("ntrianglelefteq")]; + char entity_pool_str5568[sizeof("minus")]; + char entity_pool_str5570[sizeof("gimel")]; + char entity_pool_str5577[sizeof("Aacute")]; + char entity_pool_str5578[sizeof("gtcir")]; + char entity_pool_str5583[sizeof("gtrarr")]; + char entity_pool_str5584[sizeof("bull")]; + char entity_pool_str5587[sizeof("DownArrow")]; + char entity_pool_str5593[sizeof("rdquor")]; + char entity_pool_str5595[sizeof("ldquor")]; + char entity_pool_str5598[sizeof("intlarhk")]; + char entity_pool_str5602[sizeof("utilde")]; + char entity_pool_str5612[sizeof("gacute")]; + char entity_pool_str5614[sizeof("ntilde")]; + char entity_pool_str5615[sizeof("af")]; + char entity_pool_str5618[sizeof("Hstrok")]; + char entity_pool_str5620[sizeof("exponentiale")]; + char entity_pool_str5621[sizeof("minusb")]; + char entity_pool_str5625[sizeof("RightUpTeeVector")]; + char entity_pool_str5630[sizeof("UpTeeArrow")]; + char entity_pool_str5639[sizeof("zeta")]; + char entity_pool_str5644[sizeof("DiacriticalDot")]; + char entity_pool_str5645[sizeof("DiacriticalDoubleAcute")]; + char entity_pool_str5663[sizeof("nleftarrow")]; + char entity_pool_str5664[sizeof("hkswarow")]; + char entity_pool_str5666[sizeof("iiota")]; + char entity_pool_str5669[sizeof("apacir")]; + char entity_pool_str5673[sizeof("Ncedil")]; + char entity_pool_str5678[sizeof("capand")]; + char entity_pool_str5686[sizeof("mdash")]; + char entity_pool_str5689[sizeof("filig")]; + char entity_pool_str5690[sizeof("scnsim")]; + char entity_pool_str5699[sizeof("realpart")]; + char entity_pool_str5703[sizeof("leftthreetimes")]; + char entity_pool_str5704[sizeof("asymp")]; + char entity_pool_str5718[sizeof("hellip")]; + char entity_pool_str5722[sizeof("dtrif")]; + char entity_pool_str5724[sizeof("NotExists")]; + char entity_pool_str5728[sizeof("sccue")]; + char entity_pool_str5733[sizeof("YAcy")]; + char entity_pool_str5734[sizeof("Utilde")]; + char entity_pool_str5741[sizeof("NotEqual")]; + char entity_pool_str5747[sizeof("ThinSpace")]; + char entity_pool_str5754[sizeof("apE")]; + char entity_pool_str5762[sizeof("bullet")]; + char entity_pool_str5765[sizeof("CloseCurlyDoubleQuote")]; + char entity_pool_str5766[sizeof("Delta")]; + char entity_pool_str5776[sizeof("gg")]; + char entity_pool_str5780[sizeof("otimes")]; + char entity_pool_str5799[sizeof("wreath")]; + char entity_pool_str5801[sizeof("Rcedil")]; + char entity_pool_str5807[sizeof("eth")]; + char entity_pool_str5808[sizeof("supnE")]; + char entity_pool_str5811[sizeof("awint")]; + char entity_pool_str5817[sizeof("Breve")]; + char entity_pool_str5822[sizeof("Gg")]; + char entity_pool_str5824[sizeof("HumpEqual")]; + char entity_pool_str5837[sizeof("Lleftarrow")]; + char entity_pool_str5838[sizeof("boxdr")]; + char entity_pool_str5847[sizeof("succneqq")]; + char entity_pool_str5848[sizeof("uring")]; + char entity_pool_str5849[sizeof("LessSlantEqual")]; + char entity_pool_str5860[sizeof("nvdash")]; + char entity_pool_str5866[sizeof("Hacek")]; + char entity_pool_str5867[sizeof("itilde")]; + char entity_pool_str5870[sizeof("Iota")]; + char entity_pool_str5872[sizeof("IOcy")]; + char entity_pool_str5884[sizeof("boxDr")]; + char entity_pool_str5891[sizeof("SucceedsTilde")]; + char entity_pool_str5905[sizeof("LeftFloor")]; + char entity_pool_str5906[sizeof("Vvdash")]; + char entity_pool_str5923[sizeof("triangledown")]; + char entity_pool_str5927[sizeof("LongLeftRightArrow")]; + char entity_pool_str5928[sizeof("RightFloor")]; + char entity_pool_str5931[sizeof("DownRightTeeVector")]; + char entity_pool_str5933[sizeof("quatint")]; + char entity_pool_str5937[sizeof("Ntilde")]; + char entity_pool_str5940[sizeof("Bumpeq")]; + char entity_pool_str5949[sizeof("gvnE")]; + char entity_pool_str5951[sizeof("boxhu")]; + char entity_pool_str5956[sizeof("gtlPar")]; + char entity_pool_str5959[sizeof("nprec")]; + char entity_pool_str5962[sizeof("ouml")]; + char entity_pool_str5970[sizeof("gescc")]; + char entity_pool_str5976[sizeof("Euml")]; + char entity_pool_str5980[sizeof("Uring")]; + char entity_pool_str5982[sizeof("UnderBracket")]; + char entity_pool_str5983[sizeof("nLtv")]; + char entity_pool_str5984[sizeof("LeftArrowBar")]; + char entity_pool_str5985[sizeof("ncongdot")]; + char entity_pool_str6003[sizeof("asympeq")]; + char entity_pool_str6023[sizeof("minusdu")]; + char entity_pool_str6030[sizeof("delta")]; + char entity_pool_str6032[sizeof("harrw")]; + char entity_pool_str6038[sizeof("andslope")]; + char entity_pool_str6043[sizeof("cdot")]; + char entity_pool_str6048[sizeof("Cayleys")]; + char entity_pool_str6049[sizeof("boxhU")]; + char entity_pool_str6052[sizeof("succsim")]; + char entity_pool_str6061[sizeof("cirE")]; + char entity_pool_str6062[sizeof("sdotb")]; + char entity_pool_str6066[sizeof("odash")]; + char entity_pool_str6067[sizeof("cirmid")]; + char entity_pool_str6068[sizeof("suphsub")]; + char entity_pool_str6069[sizeof("supdsub")]; + char entity_pool_str6077[sizeof("supdot")]; + char entity_pool_str6079[sizeof("awconint")]; + char entity_pool_str6084[sizeof("TSHcy")]; + char entity_pool_str6087[sizeof("grave")]; + char entity_pool_str6101[sizeof("lsimg")]; + char entity_pool_str6106[sizeof("UpArrowDownArrow")]; + char entity_pool_str6121[sizeof("LeftVector")]; + char entity_pool_str6122[sizeof("DoubleRightArrow")]; + char entity_pool_str6129[sizeof("NegativeThinSpace")]; + char entity_pool_str6140[sizeof("lhblk")]; + char entity_pool_str6146[sizeof("cire")]; + char entity_pool_str6147[sizeof("nVDash")]; + char entity_pool_str6151[sizeof("uhblk")]; + char entity_pool_str6155[sizeof("imagpart")]; + char entity_pool_str6161[sizeof("RightUpDownVector")]; + char entity_pool_str6164[sizeof("boxdL")]; + char entity_pool_str6176[sizeof("gla")]; + char entity_pool_str6193[sizeof("Iuml")]; + char entity_pool_str6203[sizeof("oelig")]; + char entity_pool_str6208[sizeof("NotLessSlantEqual")]; + char entity_pool_str6210[sizeof("boxDL")]; + char entity_pool_str6215[sizeof("gamma")]; + char entity_pool_str6236[sizeof("Otimes")]; + char entity_pool_str6248[sizeof("longleftrightarrow")]; + char entity_pool_str6261[sizeof("Gamma")]; + char entity_pool_str6262[sizeof("bigwedge")]; + char entity_pool_str6268[sizeof("boxhd")]; + char entity_pool_str6283[sizeof("supE")]; + char entity_pool_str6292[sizeof("LeftUpTeeVector")]; + char entity_pool_str6298[sizeof("gesdoto")]; + char entity_pool_str6304[sizeof("kappa")]; + char entity_pool_str6315[sizeof("ngeqslant")]; + char entity_pool_str6340[sizeof("gtrless")]; + char entity_pool_str6351[sizeof("fflig")]; + char entity_pool_str6352[sizeof("bigsqcup")]; + char entity_pool_str6367[sizeof("kgreen")]; + char entity_pool_str6368[sizeof("supe")]; + char entity_pool_str6370[sizeof("boxtimes")]; + char entity_pool_str6386[sizeof("gnapprox")]; + char entity_pool_str6394[sizeof("downdownarrows")]; + char entity_pool_str6403[sizeof("biguplus")]; + char entity_pool_str6404[sizeof("khcy")]; + char entity_pool_str6406[sizeof("ddagger")]; + char entity_pool_str6418[sizeof("Ouml")]; + char entity_pool_str6420[sizeof("Beta")]; + char entity_pool_str6421[sizeof("minusd")]; + char entity_pool_str6422[sizeof("succnsim")]; + char entity_pool_str6424[sizeof("ctdot")]; + char entity_pool_str6427[sizeof("kjcy")]; + char entity_pool_str6428[sizeof("gjcy")]; + char entity_pool_str6430[sizeof("ncong")]; + char entity_pool_str6431[sizeof("xvee")]; + char entity_pool_str6432[sizeof("bcong")]; + char entity_pool_str6439[sizeof("sqsube")]; + char entity_pool_str6442[sizeof("boxdR")]; + char entity_pool_str6445[sizeof("Longleftrightarrow")]; + char entity_pool_str6447[sizeof("sqsub")]; + char entity_pool_str6451[sizeof("DownLeftRightVector")]; + char entity_pool_str6454[sizeof("sqsubset")]; + char entity_pool_str6456[sizeof("NotVerticalBar")]; + char entity_pool_str6461[sizeof("NotEqualTilde")]; + char entity_pool_str6485[sizeof("boxdl")]; + char entity_pool_str6488[sizeof("boxDR")]; + char entity_pool_str6490[sizeof("andand")]; + char entity_pool_str6502[sizeof("RightVector")]; + char entity_pool_str6504[sizeof("IJlig")]; + char entity_pool_str6505[sizeof("NotTildeEqual")]; + char entity_pool_str6509[sizeof("angzarr")]; + char entity_pool_str6515[sizeof("angrt")]; + char entity_pool_str6521[sizeof("acd")]; + char entity_pool_str6524[sizeof("andd")]; + char entity_pool_str6526[sizeof("nrarrc")]; + char entity_pool_str6527[sizeof("VeryThinSpace")]; + char entity_pool_str6529[sizeof("Superset")]; + char entity_pool_str6531[sizeof("boxDl")]; + char entity_pool_str6535[sizeof("vnsub")]; + char entity_pool_str6538[sizeof("ccupssm")]; + char entity_pool_str6548[sizeof("varnothing")]; + char entity_pool_str6552[sizeof("rcy")]; + char entity_pool_str6554[sizeof("lcy")]; + char entity_pool_str6556[sizeof("scy")]; + char entity_pool_str6558[sizeof("Tcy")]; + char entity_pool_str6559[sizeof("Zcy")]; + char entity_pool_str6560[sizeof("ecy")]; + char entity_pool_str6561[sizeof("rdsh")]; + char entity_pool_str6563[sizeof("ldsh")]; + char entity_pool_str6565[sizeof("ucy")]; + char entity_pool_str6566[sizeof("boxVH")]; + char entity_pool_str6567[sizeof("tcy")]; + char entity_pool_str6577[sizeof("ncy")]; + char entity_pool_str6579[sizeof("bcy")]; + char entity_pool_str6580[sizeof("ntgl")]; + char entity_pool_str6585[sizeof("Jcy")]; + char entity_pool_str6600[sizeof("congdot")]; + char entity_pool_str6607[sizeof("angst")]; + char entity_pool_str6609[sizeof("RightDownTeeVector")]; + char entity_pool_str6612[sizeof("OverParenthesis")]; + char entity_pool_str6613[sizeof("ltquest")]; + char entity_pool_str6615[sizeof("pcy")]; + char entity_pool_str6618[sizeof("otilde")]; + char entity_pool_str6619[sizeof("rdquo")]; + char entity_pool_str6621[sizeof("ldquo")]; + char entity_pool_str6623[sizeof("Vcy")]; + char entity_pool_str6626[sizeof("capbrcup")]; + char entity_pool_str6646[sizeof("bdquo")]; + char entity_pool_str6650[sizeof("DownArrowBar")]; + char entity_pool_str6657[sizeof("vcy")]; + char entity_pool_str6665[sizeof("angrtvb")]; + char entity_pool_str6676[sizeof("Kcy")]; + char entity_pool_str6683[sizeof("Mcy")]; + char entity_pool_str6684[sizeof("Scy")]; + char entity_pool_str6691[sizeof("NewLine")]; + char entity_pool_str6696[sizeof("fcy")]; + char entity_pool_str6697[sizeof("Ucy")]; + char entity_pool_str6704[sizeof("boxVh")]; + char entity_pool_str6715[sizeof("Dcy")]; + char entity_pool_str6738[sizeof("hstrok")]; + char entity_pool_str6751[sizeof("Lcy")]; + char entity_pool_str6762[sizeof("Ycy")]; + char entity_pool_str6775[sizeof("supsim")]; + char entity_pool_str6789[sizeof("NonBreakingSpace")]; + char entity_pool_str6790[sizeof("OverBar")]; + char entity_pool_str6791[sizeof("sqsubseteq")]; + char entity_pool_str6797[sizeof("GJcy")]; + char entity_pool_str6800[sizeof("OverBrace")]; + char entity_pool_str6806[sizeof("eqcirc")]; + char entity_pool_str6819[sizeof("OverBracket")]; + char entity_pool_str6821[sizeof("Auml")]; + char entity_pool_str6829[sizeof("acute")]; + char entity_pool_str6830[sizeof("icy")]; + char entity_pool_str6849[sizeof("Itilde")]; + char entity_pool_str6850[sizeof("HilbertSpace")]; + char entity_pool_str6854[sizeof("omega")]; + char entity_pool_str6855[sizeof("cacute")]; + char entity_pool_str6861[sizeof("scirc")]; + char entity_pool_str6865[sizeof("ecirc")]; + char entity_pool_str6870[sizeof("ucirc")]; + char entity_pool_str6872[sizeof("GreaterSlantEqual")]; + char entity_pool_str6890[sizeof("Jcirc")]; + char entity_pool_str6895[sizeof("nvDash")]; + char entity_pool_str6896[sizeof("Wcirc")]; + char entity_pool_str6900[sizeof("Ncy")]; + char entity_pool_str6921[sizeof("RightTeeArrow")]; + char entity_pool_str6942[sizeof("LessFullEqual")]; + char entity_pool_str6958[sizeof("ltcc")]; + char entity_pool_str6963[sizeof("aleph")]; + char entity_pool_str6979[sizeof("dcy")]; + char entity_pool_str6989[sizeof("Scirc")]; + char entity_pool_str6991[sizeof("lessapprox")]; + char entity_pool_str7000[sizeof("IEcy")]; + char entity_pool_str7001[sizeof("LowerRightArrow")]; + char entity_pool_str7002[sizeof("Ucirc")]; + char entity_pool_str7021[sizeof("agrave")]; + char entity_pool_str7023[sizeof("MinusPlus")]; + char entity_pool_str7024[sizeof("bigvee")]; + char entity_pool_str7028[sizeof("Rcy")]; + char entity_pool_str7034[sizeof("suphsol")]; + char entity_pool_str7037[sizeof("EmptyVerySmallSquare")]; + char entity_pool_str7039[sizeof("boxhD")]; + char entity_pool_str7047[sizeof("precapprox")]; + char entity_pool_str7066[sizeof("angrtvbd")]; + char entity_pool_str7067[sizeof("Ycirc")]; + char entity_pool_str7071[sizeof("sub")]; + char entity_pool_str7074[sizeof("Otilde")]; + char entity_pool_str7075[sizeof("Ccirc")]; + char entity_pool_str7085[sizeof("Fcy")]; + char entity_pool_str7090[sizeof("complexes")]; + char entity_pool_str7096[sizeof("subrarr")]; + char entity_pool_str7115[sizeof("InvisibleComma")]; + char entity_pool_str7120[sizeof("boxur")]; + char entity_pool_str7121[sizeof("abreve")]; + char entity_pool_str7127[sizeof("ntlg")]; + char entity_pool_str7135[sizeof("icirc")]; + char entity_pool_str7142[sizeof("xdtri")]; + char entity_pool_str7143[sizeof("circ")]; + char entity_pool_str7168[sizeof("gtrdot")]; + char entity_pool_str7171[sizeof("geqslant")]; + char entity_pool_str7183[sizeof("ntriangleright")]; + char entity_pool_str7198[sizeof("cuepr")]; + char entity_pool_str7199[sizeof("Sub")]; + char entity_pool_str7201[sizeof("mcy")]; + char entity_pool_str7212[sizeof("timesbar")]; + char entity_pool_str7214[sizeof("hksearow")]; + char entity_pool_str7217[sizeof("sigma")]; + char entity_pool_str7224[sizeof("cupor")]; + char entity_pool_str7230[sizeof("oslash")]; + char entity_pool_str7231[sizeof("dzigrarr")]; + char entity_pool_str7234[sizeof("leftrightharpoons")]; + char entity_pool_str7245[sizeof("rightleftharpoons")]; + char entity_pool_str7247[sizeof("kcedil")]; + char entity_pool_str7256[sizeof("submult")]; + char entity_pool_str7260[sizeof("curren")]; + char entity_pool_str7269[sizeof("LeftTeeVector")]; + char entity_pool_str7274[sizeof("bigstar")]; + char entity_pool_str7277[sizeof("cup")]; + char entity_pool_str7278[sizeof("LongRightArrow")]; + char entity_pool_str7294[sizeof("Gcedil")]; + char entity_pool_str7296[sizeof("PrecedesEqual")]; + char entity_pool_str7307[sizeof("zcy")]; + char entity_pool_str7309[sizeof("planckh")]; + char entity_pool_str7310[sizeof("Omega")]; + char entity_pool_str7317[sizeof("subsub")]; + char entity_pool_str7325[sizeof("rdca")]; + char entity_pool_str7326[sizeof("cups")]; + char entity_pool_str7327[sizeof("ldca")]; + char entity_pool_str7332[sizeof("subset")]; + char entity_pool_str7333[sizeof("NotSucceeds")]; + char entity_pool_str7334[sizeof("LeftArrowRightArrow")]; + char entity_pool_str7337[sizeof("wcirc")]; + char entity_pool_str7338[sizeof("RightAngleBracket")]; + char entity_pool_str7344[sizeof("ntrianglerighteq")]; + char entity_pool_str7345[sizeof("Sigma")]; + char entity_pool_str7350[sizeof("NotSucceedsTilde")]; + char entity_pool_str7364[sizeof("DiacriticalAcute")]; + char entity_pool_str7376[sizeof("subne")]; + char entity_pool_str7378[sizeof("Product")]; + char entity_pool_str7385[sizeof("circleddash")]; + char entity_pool_str7389[sizeof("subsup")]; + char entity_pool_str7397[sizeof("copy")]; + char entity_pool_str7403[sizeof("eta")]; + char entity_pool_str7409[sizeof("angmsd")]; + char entity_pool_str7434[sizeof("natural")]; + char entity_pool_str7436[sizeof("supedot")]; + char entity_pool_str7437[sizeof("naturals")]; + char entity_pool_str7443[sizeof("triangleright")]; + char entity_pool_str7445[sizeof("DiacriticalGrave")]; + char entity_pool_str7446[sizeof("boxuL")]; + char entity_pool_str7447[sizeof("cong")]; + char entity_pool_str7451[sizeof("telrec")]; + char entity_pool_str7454[sizeof("comma")]; + char entity_pool_str7460[sizeof("Subset")]; + char entity_pool_str7475[sizeof("NotSucceedsSlantEqual")]; + char entity_pool_str7476[sizeof("gtreqless")]; + char entity_pool_str7477[sizeof("Atilde")]; + char entity_pool_str7484[sizeof("curarr")]; + char entity_pool_str7491[sizeof("cudarrr")]; + char entity_pool_str7495[sizeof("cudarrl")]; + char entity_pool_str7503[sizeof("subseteq")]; + char entity_pool_str7504[sizeof("subseteqq")]; + char entity_pool_str7505[sizeof("rightsquigarrow")]; + char entity_pool_str7520[sizeof("cupcap")]; + char entity_pool_str7521[sizeof("subsetneq")]; + char entity_pool_str7532[sizeof("aogon")]; + char entity_pool_str7533[sizeof("notinvc")]; + char entity_pool_str7534[sizeof("rightthreetimes")]; + char entity_pool_str7552[sizeof("yacute")]; + char entity_pool_str7563[sizeof("nLeftarrow")]; + char entity_pool_str7581[sizeof("ocy")]; + char entity_pool_str7582[sizeof("cemptyv")]; + char entity_pool_str7595[sizeof("Ecy")]; + char entity_pool_str7598[sizeof("cupcup")]; + char entity_pool_str7604[sizeof("trianglerighteq")]; + char entity_pool_str7615[sizeof("LeftRightArrow")]; + char entity_pool_str7618[sizeof("succ")]; + char entity_pool_str7631[sizeof("DownArrowUpArrow")]; + char entity_pool_str7641[sizeof("OElig")]; + char entity_pool_str7648[sizeof("chcy")]; + char entity_pool_str7649[sizeof("gtreqqless")]; + char entity_pool_str7655[sizeof("angle")]; + char entity_pool_str7662[sizeof("acE")]; + char entity_pool_str7668[sizeof("rmoustache")]; + char entity_pool_str7670[sizeof("lmoustache")]; + char entity_pool_str7674[sizeof("NegativeVeryThinSpace")]; + char entity_pool_str7677[sizeof("napprox")]; + char entity_pool_str7686[sizeof("Oslash")]; + char entity_pool_str7698[sizeof("subsetneqq")]; + char entity_pool_str7723[sizeof("Aring")]; + char entity_pool_str7724[sizeof("boxuR")]; + char entity_pool_str7730[sizeof("subplus")]; + char entity_pool_str7742[sizeof("xwedge")]; + char entity_pool_str7767[sizeof("boxul")]; + char entity_pool_str7778[sizeof("boxvr")]; + char entity_pool_str7800[sizeof("HumpDownHump")]; + char entity_pool_str7812[sizeof("Icy")]; + char entity_pool_str7828[sizeof("approxeq")]; + char entity_pool_str7841[sizeof("aacute")]; + char entity_pool_str7842[sizeof("apid")]; + char entity_pool_str7859[sizeof("UpDownArrow")]; + char entity_pool_str7861[sizeof("NestedGreaterGreater")]; + char entity_pool_str7863[sizeof("jcy")]; + char entity_pool_str7866[sizeof("gtrsim")]; + char entity_pool_str7876[sizeof("boxv")]; + char entity_pool_str7886[sizeof("ocirc")]; + char entity_pool_str7900[sizeof("Ecirc")]; + char entity_pool_str7987[sizeof("notnivc")]; + char entity_pool_str8006[sizeof("bigtriangleup")]; + char entity_pool_str8032[sizeof("daleth")]; + char entity_pool_str8037[sizeof("Ocy")]; + char entity_pool_str8042[sizeof("Hcirc")]; + char entity_pool_str8043[sizeof("RightVectorBar")]; + char entity_pool_str8044[sizeof("AElig")]; + char entity_pool_str8063[sizeof("FilledVerySmallSquare")]; + char entity_pool_str8084[sizeof("ggg")]; + char entity_pool_str8088[sizeof("Bcy")]; + char entity_pool_str8099[sizeof("Poincareplane")]; + char entity_pool_str8104[sizeof("boxvL")]; + char entity_pool_str8107[sizeof("PartialD")]; + char entity_pool_str8117[sizeof("Icirc")]; + char entity_pool_str8129[sizeof("cularr")]; + char entity_pool_str8135[sizeof("boxh")]; + char entity_pool_str8142[sizeof("andv")]; + char entity_pool_str8144[sizeof("sung")]; + char entity_pool_str8148[sizeof("RightDoubleBracket")]; + char entity_pool_str8168[sizeof("jcirc")]; + char entity_pool_str8174[sizeof("UnderBar")]; + char entity_pool_str8241[sizeof("RightArrow")]; + char entity_pool_str8242[sizeof("circledcirc")]; + char entity_pool_str8243[sizeof("Alpha")]; + char entity_pool_str8251[sizeof("leftharpoonup")]; + char entity_pool_str8258[sizeof("cularrp")]; + char entity_pool_str8260[sizeof("RightArrowLeftArrow")]; + char entity_pool_str8281[sizeof("varsigma")]; + char entity_pool_str8300[sizeof("numero")]; + char entity_pool_str8310[sizeof("ffllig")]; + char entity_pool_str8326[sizeof("LowerLeftArrow")]; + char entity_pool_str8340[sizeof("expectation")]; + char entity_pool_str8342[sizeof("Ocirc")]; + char entity_pool_str8351[sizeof("yacy")]; + char entity_pool_str8375[sizeof("lambda")]; + char entity_pool_str8381[sizeof("NotSucceedsEqual")]; + char entity_pool_str8382[sizeof("boxvR")]; + char entity_pool_str8384[sizeof("bigtriangledown")]; + char entity_pool_str8391[sizeof("ang")]; + char entity_pool_str8404[sizeof("xuplus")]; + char entity_pool_str8424[sizeof("nabla")]; + char entity_pool_str8425[sizeof("boxvl")]; + char entity_pool_str8438[sizeof("Eta")]; + char entity_pool_str8440[sizeof("Acy")]; + char entity_pool_str8474[sizeof("kcy")]; + char entity_pool_str8475[sizeof("gcy")]; + char entity_pool_str8485[sizeof("LeftRightVector")]; + char entity_pool_str8491[sizeof("ccedil")]; + char entity_pool_str8495[sizeof("Backslash")]; + char entity_pool_str8506[sizeof("hslash")]; + char entity_pool_str8515[sizeof("Pcy")]; + char entity_pool_str8521[sizeof("Gcy")]; + char entity_pool_str8534[sizeof("gtquest")]; + char entity_pool_str8572[sizeof("Lambda")]; + char entity_pool_str8627[sizeof("odiv")]; + char entity_pool_str8629[sizeof("leftharpoondown")]; + char entity_pool_str8672[sizeof("longmapsto")]; + char entity_pool_str8677[sizeof("Jukcy")]; + char entity_pool_str8687[sizeof("ldrdhar")]; + char entity_pool_str8700[sizeof("xutri")]; + char entity_pool_str8701[sizeof("nRightarrow")]; + char entity_pool_str8725[sizeof("ExponentialE")]; + char entity_pool_str8735[sizeof("nrightarrow")]; + char entity_pool_str8745[sizeof("Acirc")]; + char entity_pool_str8746[sizeof("NoBreak")]; + char entity_pool_str8780[sizeof("gcirc")]; + char entity_pool_str8784[sizeof("ange")]; + char entity_pool_str8785[sizeof("curarrm")]; + char entity_pool_str8791[sizeof("SHCHcy")]; + char entity_pool_str8796[sizeof("yuml")]; + char entity_pool_str8800[sizeof("subnE")]; + char entity_pool_str8803[sizeof("DDotrahd")]; + char entity_pool_str8810[sizeof("RuleDelayed")]; + char entity_pool_str8826[sizeof("Gcirc")]; + char entity_pool_str8843[sizeof("Jsercy")]; + char entity_pool_str8879[sizeof("gtcc")]; + char entity_pool_str8922[sizeof("iukcy")]; + char entity_pool_str8956[sizeof("updownarrow")]; + char entity_pool_str8962[sizeof("curlyvee")]; + char entity_pool_str8972[sizeof("ffilig")]; + char entity_pool_str8992[sizeof("yicy")]; + char entity_pool_str9015[sizeof("divonx")]; + char entity_pool_str9026[sizeof("gtrapprox")]; + char entity_pool_str9069[sizeof("subdot")]; + char entity_pool_str9079[sizeof("leftrightarrows")]; + char entity_pool_str9085[sizeof("auml")]; + char entity_pool_str9088[sizeof("Updownarrow")]; + char entity_pool_str9090[sizeof("rightleftarrows")]; + char entity_pool_str9151[sizeof("DownRightVector")]; + char entity_pool_str9154[sizeof("DownRightVectorBar")]; + char entity_pool_str9162[sizeof("hcirc")]; + char entity_pool_str9186[sizeof("Rrightarrow")]; + char entity_pool_str9217[sizeof("longrightarrow")]; + char entity_pool_str9239[sizeof("cupdot")]; + char entity_pool_str9249[sizeof("ac")]; + char entity_pool_str9268[sizeof("hookrightarrow")]; + char entity_pool_str9271[sizeof("NegativeThickSpace")]; + char entity_pool_str9275[sizeof("subE")]; + char entity_pool_str9307[sizeof("twoheadrightarrow")]; + char entity_pool_str9320[sizeof("downharpoonright")]; + char entity_pool_str9321[sizeof("downharpoonleft")]; + char entity_pool_str9326[sizeof("aelig")]; + char entity_pool_str9330[sizeof("rdldhar")]; + char entity_pool_str9349[sizeof("curlywedge")]; + char entity_pool_str9351[sizeof("hybull")]; + char entity_pool_str9360[sizeof("sube")]; + char entity_pool_str9414[sizeof("Longrightarrow")]; + char entity_pool_str9484[sizeof("Cedilla")]; + char entity_pool_str9505[sizeof("notinva")]; + char entity_pool_str9506[sizeof("SucceedsEqual")]; + char entity_pool_str9554[sizeof("leftrightarrow")]; + char entity_pool_str9580[sizeof("straightepsilon")]; + char entity_pool_str9627[sizeof("amalg")]; + char entity_pool_str9741[sizeof("atilde")]; + char entity_pool_str9747[sizeof("RightCeiling")]; + char entity_pool_str9751[sizeof("Leftrightarrow")]; + char entity_pool_str9767[sizeof("subsim")]; + char entity_pool_str9788[sizeof("VerticalLine")]; + char entity_pool_str9801[sizeof("RightUpVector")]; + char entity_pool_str9804[sizeof("RightUpVectorBar")]; + char entity_pool_str9829[sizeof("RightDownVector")]; + char entity_pool_str9832[sizeof("RightDownVectorBar")]; + char entity_pool_str9836[sizeof("alefsym")]; + char entity_pool_str9852[sizeof("circlearrowright")]; + char entity_pool_str9853[sizeof("circlearrowleft")]; + char entity_pool_str9904[sizeof("Iukcy")]; + char entity_pool_str9936[sizeof("otimesas")]; + char entity_pool_str9944[sizeof("intercal")]; + char entity_pool_str9952[sizeof("thickapprox")]; + char entity_pool_str9955[sizeof("jukcy")]; + char entity_pool_str9959[sizeof("notniva")]; + char entity_pool_str9963[sizeof("precnapprox")]; + char entity_pool_str9983[sizeof("cuvee")]; + char entity_pool_str9987[sizeof("aring")]; + char entity_pool_str10023[sizeof("ccirc")]; + char entity_pool_str10029[sizeof("rightarrow")]; + char entity_pool_str10061[sizeof("Integral")]; + char entity_pool_str10062[sizeof("xcirc")]; + char entity_pool_str10121[sizeof("jsercy")]; + char entity_pool_str10206[sizeof("checkmark")]; + char entity_pool_str10208[sizeof("VerticalTilde")]; + char entity_pool_str10219[sizeof("boxvH")]; + char entity_pool_str10240[sizeof("NotRightTriangleBar")]; + char entity_pool_str10244[sizeof("NotRightTriangleEqual")]; + char entity_pool_str10245[sizeof("NotRightTriangle")]; + char entity_pool_str10278[sizeof("LeftVectorBar")]; + char entity_pool_str10357[sizeof("boxvh")]; + char entity_pool_str10395[sizeof("boxbox")]; + char entity_pool_str10415[sizeof("ycy")]; + char entity_pool_str10428[sizeof("subedot")]; + char entity_pool_str10445[sizeof("SOFTcy")]; + char entity_pool_str10505[sizeof("Rightarrow")]; + char entity_pool_str10507[sizeof("alpha")]; + char entity_pool_str10528[sizeof("shchcy")]; + char entity_pool_str10584[sizeof("softcy")]; + char entity_pool_str10704[sizeof("acy")]; + char entity_pool_str10720[sizeof("ycirc")]; + char entity_pool_str10791[sizeof("bigcirc")]; + char entity_pool_str10808[sizeof("ImaginaryI")]; + char entity_pool_str10847[sizeof("approx")]; + char entity_pool_str10851[sizeof("SupersetEqual")]; + char entity_pool_str10879[sizeof("vzigzag")]; + char entity_pool_str10888[sizeof("cuesc")]; + char entity_pool_str10947[sizeof("UnderParenthesis")]; + char entity_pool_str11009[sizeof("acirc")]; + char entity_pool_str11029[sizeof("succapprox")]; + char entity_pool_str11047[sizeof("mcomma")]; + char entity_pool_str11146[sizeof("angmsdae")]; + char entity_pool_str11165[sizeof("angmsdab")]; + char entity_pool_str11282[sizeof("angmsdaf")]; + char entity_pool_str11366[sizeof("angsph")]; + char entity_pool_str11527[sizeof("luruhar")]; + char entity_pool_str11565[sizeof("angmsdad")]; + char entity_pool_str11664[sizeof("twoheadleftarrow")]; + char entity_pool_str11720[sizeof("cylcty")]; + char entity_pool_str11791[sizeof("straightphi")]; + char entity_pool_str11840[sizeof("multimap")]; + char entity_pool_str11918[sizeof("RightArrowBar")]; + char entity_pool_str12012[sizeof("ldrushar")]; + char entity_pool_str12103[sizeof("LeftAngleBracket")]; + char entity_pool_str12170[sizeof("ruluhar")]; + char entity_pool_str12202[sizeof("curlyeqprec")]; + char entity_pool_str12206[sizeof("yucy")]; + char entity_pool_str12288[sizeof("lurdshar")]; + char entity_pool_str12413[sizeof("hardcy")]; + char entity_pool_str12461[sizeof("rightharpoondown")]; + char entity_pool_str12497[sizeof("rightharpoonup")]; + char entity_pool_str12502[sizeof("HARDcy")]; + char entity_pool_str12651[sizeof("SubsetEqual")]; + char entity_pool_str12809[sizeof("digamma")]; + char entity_pool_str12892[sizeof("udblac")]; + char entity_pool_str12985[sizeof("SuchThat")]; + char entity_pool_str12991[sizeof("cuwed")]; + char entity_pool_str13024[sizeof("Udblac")]; + char entity_pool_str13061[sizeof("angmsdag")]; + char entity_pool_str13443[sizeof("angmsdah")]; + char entity_pool_str13643[sizeof("VerticalBar")]; + char entity_pool_str13659[sizeof("VerticalSeparator")]; + char entity_pool_str13709[sizeof("rightarrowtail")]; + char entity_pool_str13908[sizeof("odblac")]; + char entity_pool_str13945[sizeof("succnapprox")]; + char entity_pool_str14304[sizeof("angmsdac")]; + char entity_pool_str14364[sizeof("Odblac")]; + char entity_pool_str14620[sizeof("cupbrcap")]; + char entity_pool_str15290[sizeof("angmsdaa")]; + char entity_pool_str15360[sizeof("curlyeqsucc")]; + char entity_pool_str15729[sizeof("curvearrowleft")]; + char entity_pool_str16000[sizeof("curvearrowright")]; + }; +static const struct entity_pool_t entity_pool_contents = + { + "rarr", + "larr", + "lat", + "uarr", + "npr", + "rarrtl", + "larrtl", + "roarr", + "loarr", + "not", + "rpar", + "bot", + "lpar", + "spar", + "ll", + "uharr", + "epar", + "el", + "rotimes", + "lotimes", + "par", + "nharr", + "npar", + "tprime", + "els", + "eparsl", + "ensp", + "bprime", + "lnap", + "blk14", + "blk12", + "blk34", + "nparsl", + "nldr", + "rlarr", + "npart", + "llarr", + "nlt", + "slarr", + "nparallel", + "Tau", + "varr", + "squ", + "nlarr", + "tau", + "lne", + "rrarr", + "lrarr", + "srarr", + "rharul", + "lharul", + "erarr", + "pr", + "rharu", + "lharu", + "Uarr", + "nGt", + "bne", + "nrarr", + "swarr", + "rarrap", + "upuparrows", + "Darr", + "rbarr", + "Dot", + "lbarr", + "nwarr", + "smt", + "emsp14", + "rarrpl", + "larrpl", + "phmmat", + "emsp13", + "LT", + "Larr", + "rbrkslu", + "lbrkslu", + "napos", + "nle", + "rHar", + "lHar", + "qprime", + "lap", + "nbsp", + "uHar", + "top", + "Vbar", + "Ll", + "prap", + "emsp", + "nap", + "looparrowleft", + "le", + "sharp", + "ee", + "les", + "in", + "prop", + "topbot", + "int", + "ne", + "nprcue", + "pre", + "epsi", + "upsi", + "there4", + "rbrke", + "searr", + "lbrke", + "blacktriangle", + "lneq", + "lneqq", + "plus", + "nles", + "nedot", + "blacktriangleleft", + "blacktriangleright", + "nearr", + "blacktriangledown", + "nless", + "emacr", + "vprop", + "umacr", + "smeparsl", + "Map", + "plusdu", + "Not", + "Verbar", + "perp", + "fltns", + "plusmn", + "nleq", + "nleqq", + "frac34", + "frac14", + "verbar", + "frac12", + "frac35", + "frac15", + "frac45", + "frac25", + "frac13", + "frac16", + "prurel", + "frac23", + "frac38", + "frac18", + "frac56", + "frac58", + "frac78", + "leq", + "darr", + "Upsi", + "dot", + "phone", + "Cap", + "blacksquare", + "rnmid", + "leqq", + "intcal", + "dharr", + "rhard", + "lhard", + "pluse", + "Umacr", + "Vee", + "Rarr", + "Cross", + "rsqb", + "lsqb", + "Rarrtl", + "esdot", + "vee", + "nbumpe", + "llcorner", + "fpartint", + "squf", + "plankv", + "eqvparsl", + "ulcorner", + "wp", + "lozf", + "COPY", + "ulcorn", + "veebar", + "part", + "square", + "nbump", + "bernou", + "wr", + "rBarr", + "lrcorner", + "lBarr", + "bnot", + "semi", + "urcorner", + "NotSubset", + "ropf", + "Qopf", + "lopf", + "sopf", + "urcorn", + "Topf", + "Zopf", + "eopf", + "ropar", + "uopf", + "lopar", + "topf", + "Xopf", + "nopf", + "bopf", + "epsiv", + "fnof", + "imacr", + "Jopf", + "nhpar", + "Wopf", + "Sqrt", + "nsub", + "napid", + "NotSuperset", + "brvbar", + "sol", + "easter", + "popf", + "dHar", + "Vopf", + "nsupset", + "nsup", + "vBar", + "nsubset", + "thkap", + "nis", + "profsurf", + "solb", + "lnsim", + "solbar", + "Square", + "vopf", + "uharl", + "ulcrop", + "eqsim", + "equiv", + "ell", + "smashp", + "mp", + "Kopf", + "simrarr", + "flat", + "Mopf", + "Sopf", + "mldr", + "rlm", + "iprod", + "lparlt", + "fopf", + "Uopf", + "varsubsetneq", + "varsubsetneqq", + "urcrop", + "LessLess", + "Re", + "NotNestedLessLess", + "Dopf", + "forkv", + "nsqsube", + "nsupe", + "nsube", + "qopf", + "rlhar", + "lrm", + "nlsim", + "pound", + "varsupsetneq", + "varsupsetneqq", + "bnequiv", + "Lopf", + "nsqsupe", + "rarrlp", + "wedbar", + "larrlp", + "Yopf", + "NotReverseElement", + "Copf", + "lrhar", + "parsl", + "uml", + "marker", + "nsupseteq", + "nsubseteq", + "squarf", + "Vert", + "SquareSupersetEqual", + "prsim", + "SquareSubsetEqual", + "SquareSuperset", + "SquareSubset", + "nvap", + "iopf", + "pm", + "vert", + "thetav", + "loz", + "map", + "lesseqqgtr", + "rscr", + "Qscr", + "lscr", + "sscr", + "Tscr", + "Zscr", + "escr", + "uscr", + "tscr", + "imof", + "Coproduct", + "Xscr", + "Xi", + "nscr", + "ni", + "bscr", + "Nopf", + "Jscr", + "preceq", + "nvrArr", + "backprime", + "Wscr", + "varphi", + "nsmid", + "dlcorn", + "pscr", + "pi", + "Vscr", + "nesim", + "simne", + "nsupseteqq", + "nsubseteqq", + "drcorn", + "rbrace", + "vscr", + "lbrace", + "dopf", + "frasl", + "LessTilde", + "Kscr", + "pluscir", + "Mscr", + "Sscr", + "rbrksld", + "lbrksld", + "RBarr", + "sqcaps", + "rArr", + "bNot", + "lArr", + "fscr", + "Uscr", + "uArr", + "Ropf", + "wopf", + "Dscr", + "opar", + "seswar", + "Del", + "rAarr", + "rho", + "lAarr", + "preccurlyeq", + "qscr", + "macr", + "notin", + "equivDD", + "sqcap", + "nspar", + "olt", + "ratio", + "Lscr", + "dharl", + "dlcrop", + "DoubleDot", + "dotplus", + "or", + "Yscr", + "Fopf", + "Cscr", + "olarr", + "nrarrw", + "lvertneqq", + "eqslantgtr", + "thorn", + "eqslantless", + "incare", + "vArr", + "rppolint", + "drcrop", + "parallel", + "orarr", + "ssmile", + "DoubleLeftTee", + "erDot", + "diams", + "ssetmn", + "oS", + "iscr", + "ii", + "rect", + "nsccue", + "sect", + "mlcp", + "oror", + "DoubleContourIntegral", + "equals", + "Hat", + "sstarf", + "mstpos", + "die", + "measuredangle", + "forall", + "notinvb", + "mopf", + "niv", + "vBarv", + "Nscr", + "period", + "becaus", + "between", + "Int", + "because", + "piv", + "rfr", + "Qfr", + "lfr", + "sfr", + "nleftrightarrow", + "Tfr", + "Zfr", + "efr", + "sim", + "ufr", + "roplus", + "tfr", + "loplus", + "Xfr", + "real", + "nfr", + "bfr", + "NotHumpEqual", + "Jfr", + "dscr", + "Wfr", + "blacklozenge", + "zopf", + "reals", + "NotCupCap", + "simplus", + "ForAll", + "pfr", + "omacr", + "Vfr", + "Emacr", + "Rscr", + "wscr", + "ShortUpArrow", + "setmn", + "vfr", + "Kfr", + "operp", + "Mfr", + "Sfr", + "nltrie", + "Fscr", + "ffr", + "Ufr", + "shortmid", + "nvsim", + "Dfr", + "lessdot", + "profline", + "qfr", + "dArr", + "nrtrie", + "ShortRightArrow", + "Therefore", + "DD", + "therefore", + "Lfr", + "target", + "Element", + "Yfr", + "ClockwiseContourIntegral", + "olcir", + "Cfr", + "female", + "nsucceq", + "oast", + "percnt", + "ordf", + "ord", + "Rho", + "mscr", + "nvrtrie", + "lnE", + "nhArr", + "Or", + "divide", + "ifr", + "elinters", + "bsol", + "nvlArr", + "Imacr", + "backsimeq", + "twixt", + "olcross", + "rarrsim", + "DoubleDownArrow", + "larrsim", + "emptyset", + "oopf", + "exist", + "llhard", + "excl", + "Eopf", + "nlArr", + "thinsp", + "NotSubsetEqual", + "phi", + "DoubleLeftArrow", + "topcir", + "div", + "Nfr", + "nlE", + "zscr", + "lrhard", + "lltri", + "nrArr", + "NotSupersetEqual", + "swArr", + "ThickSpace", + "ultri", + "notnivb", + "prime", + "primes", + "ohm", + "CircleTimes", + "nltri", + "siml", + "nwArr", + "varpi", + "orv", + "setminus", + "lrtri", + "permil", + "mid", + "urtri", + "dfr", + "mho", + "prE", + "vsupne", + "nrtri", + "vsubne", + "eDot", + "lesges", + "backepsilon", + "ratail", + "latail", + "UpEquilibrium", + "epsilon", + "upsilon", + "midast", + "Hopf", + "vltri", + "Rfr", + "Wedge", + "wfr", + "barwed", + "malt", + "Chi", + "emptyv", + "notni", + "LessGreater", + "diam", + "vrtri", + "CircleMinus", + "Omacr", + "seArr", + "Ffr", + "precneqq", + "Diamond", + "ordm", + "neArr", + "Iopf", + "CircleDot", + "prnap", + "dotminus", + "nshortmid", + "bottom", + "pointint", + "SquareUnion", + "jopf", + "Upsilon", + "Colone", + "nvlt", + "NestedLessLess", + "Colon", + "bsolhsub", + "DoubleLeftRightArrow", + "plussim", + "image", + "egs", + "oscr", + "swnwar", + "zeetrf", + "maltese", + "mfr", + "rarrfs", + "Escr", + "larrfs", + "mnplus", + "ngt", + "ngtr", + "gl", + "diamondsuit", + "GT", + "lesssim", + "dsol", + "upharpoonleft", + "SquareIntersection", + "lsime", + "nLt", + "NotLess", + "gnap", + "scap", + "mapstoleft", + "NotLessLess", + "rfloor", + "lfloor", + "nsime", + "bsime", + "NotLessEqual", + "NotLessTilde", + "ncap", + "NotLessGreater", + "precsim", + "looparrowright", + "Pr", + "rcub", + "mapstoup", + "lcub", + "zfr", + "uparrow", + "gne", + "sce", + "Im", + "rcaron", + "lcaron", + "Oopf", + "scaron", + "backsim", + "Tcaron", + "Zcaron", + "ecaron", + "Bernoullis", + "nge", + "tcaron", + "fork", + "Hscr", + "ncaron", + "elsdot", + "tbrk", + "triplus", + "diamond", + "ncup", + "bbrk", + "frown", + "bkarow", + "spades", + "psi", + "Bopf", + "dollar", + "disin", + "spadesuit", + "NotTilde", + "doublebarwedge", + "gap", + "bbrktbrk", + "swarrow", + "bepsi", + "Iscr", + "NotTildeFullEqual", + "eqcolon", + "tint", + "intprod", + "nsupE", + "nwarrow", + "nsubE", + "nges", + "Uparrow", + "ge", + "OpenCurlyDoubleQuote", + "smallsetminus", + "Scaron", + "nvltrie", + "ges", + "blank", + "QUOT", + "block", + "trade", + "jscr", + "wedge", + "Amacr", + "Equal", + "Dcaron", + "DotDot", + "gneq", + "varpropto", + "gneqq", + "Proportional", + "isins", + "eDDot", + "isin", + "TripleDot", + "Fouriertrf", + "Proportion", + "ngeq", + "Lcaron", + "ngeqq", + "lE", + "Ccaron", + "bsemi", + "propto", + "lesdot", + "Conint", + "And", + "searrow", + "orslope", + "harr", + "late", + "CenterDot", + "ofr", + "nearrow", + "qint", + "lates", + "kappav", + "horbar", + "Efr", + "hoarr", + "npre", + "inodot", + "udarr", + "geq", + "nsimeq", + "geqq", + "efDot", + "rpargt", + "Oscr", + "plusdo", + "lagran", + "thicksim", + "precnsim", + "Ncaron", + "napE", + "iiint", + "Bscr", + "mapstodown", + "varrho", + "isinsv", + "nvHarr", + "NotLeftTriangleBar", + "equest", + "NotLeftTriangleEqual", + "NotLeftTriangle", + "Aopf", + "hbar", + "vangrt", + "Hfr", + "range", + "smte", + "lsim", + "npolint", + "dcaron", + "esim", + "Union", + "smtes", + "kopf", + "gopf", + "nsim", + "bsim", + "SmallCircle", + "NotDoubleVerticalBar", + "NotNestedGreaterGreater", + "EqualTilde", + "notindot", + "Rcaron", + "Popf", + "Gopf", + "Ifr", + "wedgeq", + "prod", + "osol", + "DoubleUpArrow", + "Congruent", + "gnsim", + "scsim", + "jfr", + "upsih", + "nLl", + "DoubleUpDownArrow", + "ngsim", + "hearts", + "lesseqgtr", + "nesear", + "Exists", + "smile", + "uwangle", + "heartsuit", + "HorizontalLine", + "GreaterLess", + "rsaquo", + "lsaquo", + "realine", + "Dashv", + "simdot", + "GreaterEqual", + "GreaterTilde", + "GreaterEqualLess", + "GreaterGreater", + "rceil", + "lceil", + "lessgtr", + "oline", + "thksim", + "InvisibleTimes", + "race", + "iquest", + "imagline", + "UpTee", + "midcir", + "ofcir", + "ddarr", + "rangd", + "langd", + "Equilibrium", + "parsim", + "Vdashl", + "Ofr", + "Because", + "rAtail", + "lAtail", + "ominus", + "Ascr", + "Epsilon", + "ShortLeftArrow", + "isinv", + "micro", + "zcaron", + "kscr", + "gscr", + "Bfr", + "gel", + "hercon", + "triminus", + "egrave", + "sdot", + "ugrave", + "Zdot", + "edot", + "NotTildeTilde", + "tdot", + "Pscr", + "Pi", + "Gscr", + "plustwo", + "NotElement", + "PlusMinus", + "hopf", + "gammad", + "mDDot", + "divideontimes", + "doteq", + "varepsilon", + "Precedes", + "Gammad", + "dashv", + "NotCongruent", + "ubreve", + "ogt", + "RoundImplies", + "PrecedesSlantEqual", + "sime", + "Ugrave", + "dbkarow", + "sdote", + "veeeq", + "mapsto", + "times", + "rangle", + "langle", + "leftarrowtail", + "hamilt", + "udhar", + "nisd", + "rfisht", + "lfisht", + "harrcir", + "OpenCurlyQuote", + "ufisht", + "NotHumpDownHump", + "LeftTee", + "rsh", + "lsh", + "gvertneqq", + "timesb", + "scpolint", + "Cdot", + "dwangle", + "Ubreve", + "LeftUpVector", + "LeftUpVectorBar", + "Ecaron", + "homtht", + "igrave", + "npreceq", + "ecolon", + "dd", + "simeq", + "notinE", + "bigoplus", + "Afr", + "leftarrow", + "oint", + "Tab", + "ogon", + "lt", + "nLeftrightarrow", + "rarrb", + "larrb", + "hscr", + "LeftUpDownVector", + "kfr", + "gfr", + "UpArrowBar", + "nsce", + "ltdot", + "gesl", + "xodot", + "star", + "lowbar", + "xharr", + "ecir", + "utdot", + "natur", + "Lsh", + "infin", + "comp", + "sigmav", + "xotime", + "Pfr", + "Gfr", + "bigcap", + "simlE", + "iiiint", + "barwedge", + "Barwed", + "xlarr", + "LessEqualGreater", + "crarr", + "isindot", + "commat", + "middot", + "lesdotor", + "sigmaf", + "rarrbfs", + "larrbfs", + "xrarr", + "bigcup", + "clubs", + "hArr", + "rtrie", + "ltrie", + "imped", + "eogon", + "rx", + "ltrPar", + "Star", + "uogon", + "Tilde", + "half", + "tilde", + "Leftarrow", + "gesles", + "cap", + "strns", + "Lt", + "prnE", + "sqsupe", + "sqsupset", + "tridot", + "order", + "caps", + "cross", + "dfisht", + "xmap", + "sqsup", + "rtri", + "ltri", + "it", + "rmoust", + "lmoust", + "gnE", + "lgE", + "scE", + "utri", + "vellip", + "ETH", + "lmidot", + "Uogon", + "CounterClockwiseContourIntegral", + "ngE", + "nwnear", + "lesg", + "plusb", + "Rsh", + "copysr", + "infintie", + "imath", + "Esim", + "Phi", + "glE", + "vnsup", + "simgE", + "DoubleLongLeftArrow", + "DoubleLongLeftRightArrow", + "nvgt", + "Mellintrf", + "Prime", + "iinfin", + "ReverseElement", + "EmptySmallSquare", + "radic", + "hfr", + "zdot", + "male", + "rarrc", + "prec", + "scnap", + "DifferentialD", + "models", + "ltcir", + "iogon", + "capcap", + "iff", + "ddotseq", + "CirclePlus", + "rthree", + "lthree", + "PrecedesTilde", + "dtdot", + "clubsuit", + "racute", + "lacute", + "trpezium", + "sacute", + "Zacute", + "eacute", + "TildeTilde", + "Uarrocir", + "uacute", + "lowast", + "nacute", + "NotPrecedes", + "Lmidot", + "UpArrow", + "rarrw", + "DownTee", + "FilledSmallSquare", + "capcup", + "GreaterFullEqual", + "nvle", + "trie", + "omicron", + "DoubleRightTee", + "Cconint", + "rsquor", + "lsquor", + "zigrarr", + "copf", + "ContourIntegral", + "hairsp", + "sqsupseteq", + "csub", + "upharpoonright", + "DownBreve", + "ShortDownArrow", + "xopf", + "Sacute", + "vsupnE", + "cir", + "plusacir", + "csup", + "vsubnE", + "Uacute", + "isinE", + "gEl", + "sqcups", + "smid", + "lg", + "DoubleLongRightArrow", + "NotPrecedesSlantEqual", + "eg", + "AMP", + "nmid", + "timesd", + "DownLeftVector", + "zwnj", + "Lacute", + "DownLeftVectorBar", + "ograve", + "Yacute", + "sqcup", + "odot", + "Cacute", + "nu", + "tritime", + "Egrave", + "eplus", + "backcong", + "uplus", + "Edot", + "csupe", + "simg", + "UpperRightArrow", + "csube", + "dtri", + "prnsim", + "boxUr", + "uuarr", + "DownLeftTeeVector", + "gsime", + "bigotimes", + "Dagger", + "Intersection", + "iacute", + "prcue", + "egsdot", + "Implies", + "VDash", + "bump", + "Mu", + "vDash", + "lvnE", + "LeftTeeArrow", + "Nacute", + "UnderBrace", + "Psi", + "rhov", + "lescc", + "sup1", + "sup2", + "sup3", + "bigodot", + "Downarrow", + "xsqcup", + "barvee", + "NegativeMediumSpace", + "bumpe", + "cscr", + "nsc", + "sup", + "cedil", + "boxVr", + "origof", + "zwj", + "Igrave", + "Idot", + "xscr", + "xi", + "nGtv", + "boxHu", + "THORN", + "Racute", + "rarrhk", + "larrhk", + "rtriltri", + "boxV", + "dagger", + "Omicron", + "DoubleVerticalBar", + "nexists", + "Nu", + "nexist", + "gE", + "ap", + "Sup", + "doteqdot", + "eng", + "caron", + "boxHU", + "gesdot", + "ReverseEquilibrium", + "boxUL", + "supmult", + "pitchfork", + "numsp", + "rang", + "lang", + "ocir", + "rationals", + "coprod", + "ltlarr", + "breve", + "nang", + "swarhk", + "raquo", + "laquo", + "supsub", + "Cup", + "ape", + "quest", + "nwarhk", + "supset", + "downarrow", + "duarr", + "apos", + "Ograve", + "shortparallel", + "nsucc", + "LongLeftArrow", + "lesdoto", + "supne", + "nGg", + "raemptyv", + "supsup", + "laemptyv", + "topfork", + "Eogon", + "risingdotseq", + "bumpeq", + "lstrok", + "Tstrok", + "gsim", + "bemptyv", + "zacute", + "gsiml", + "tstrok", + "roang", + "boxVL", + "loang", + "nleqslant", + "sbquo", + "searhk", + "lnapprox", + "Supset", + "boxHd", + "varkappa", + "circeq", + "yopf", + "UnionPlus", + "Lang", + "nearhk", + "shcy", + "cfr", + "Kappa", + "ljcy", + "MediumSpace", + "supseteq", + "supseteqq", + "reg", + "amacr", + "leg", + "weierp", + "TScy", + "supsetneq", + "njcy", + "xfr", + "mu", + "nvinfin", + "boxUR", + "xoplus", + "leftleftarrows", + "sum", + "beth", + "complement", + "num", + "amp", + "boxUl", + "NotGreater", + "boxplus", + "jmath", + "sfrown", + "Dstrok", + "and", + "NotGreaterGreater", + "NotGreaterSlantEqual", + "NotGreaterLess", + "quot", + "NotGreaterFullEqual", + "hyphen", + "planck", + "TildeEqual", + "tosa", + "Lstrok", + "shy", + "xnis", + "Iogon", + "DZcy", + "ohbar", + "cirscir", + "sext", + "para", + "ast", + "questeq", + "Sum", + "DScy", + "ENG", + "ZHcy", + "longleftarrow", + "dash", + "DownTeeArrow", + "supsetneqq", + "profalar", + "oacute", + "boxVR", + "Eacute", + "supplus", + "hookleftarrow", + "CloseCurlyQuote", + "trisb", + "dotsquare", + "rtimes", + "ltimes", + "toea", + "Agrave", + "Assign", + "Rang", + "iocy", + "NotPrecedesEqual", + "aopf", + "chi", + "quaternions", + "boxVl", + "NotGreaterEqual", + "xhArr", + "orderof", + "rsquo", + "lsquo", + "yscr", + "gdot", + "NotSquareSubsetEqual", + "KHcy", + "bsolb", + "NotSquareSubset", + "SHcy", + "YIcy", + "cwint", + "Theta", + "theta", + "xlArr", + "NotSquareSupersetEqual", + "demptyv", + "triangle", + "Gdot", + "NotSquareSuperset", + "Abreve", + "dstrok", + "pertenk", + "rbrack", + "lbrack", + "odsold", + "omid", + "xrArr", + "triangleleft", + "NotGreaterTilde", + "colone", + "Longleftarrow", + "iota", + "colon", + "Zeta", + "gbreve", + "CHcy", + "YUcy", + "REG", + "szlig", + "dzcy", + "beta", + "euro", + "LeftArrow", + "CapitalDifferentialD", + "ring", + "Laplacetrf", + "djcy", + "oplus", + "integers", + "Gbreve", + "ubrcy", + "euml", + "deg", + "uuml", + "Iacute", + "succeq", + "KJcy", + "CupCap", + "tscy", + "cent", + "DJcy", + "TildeFullEqual", + "triangleq", + "duhar", + "LeftDoubleBracket", + "LJcy", + "iecy", + "trianglelefteq", + "nequiv", + "nshortparallel", + "ndash", + "bowtie", + "fjlig", + "Ubrcy", + "vartheta", + "Uuml", + "vartriangleright", + "vartriangleleft", + "ascr", + "succcurlyeq", + "cwconint", + "sc", + "fllig", + "circledast", + "Vdash", + "nVdash", + "suplarr", + "robrk", + "lobrk", + "vdash", + "Yuml", + "gt", + "ccaps", + "Succeeds", + "Oacute", + "TRADE", + "NJcy", + "gtdot", + "yfr", + "compfn", + "Gt", + "scnE", + "ijlig", + "circledS", + "yen", + "thetasym", + "iuml", + "SucceedsSlantEqual", + "boxH", + "mumap", + "rightrightarrows", + "coloneq", + "Sc", + "glj", + "iexcl", + "ccups", + "xcap", + "zhcy", + "boxHD", + "leqslant", + "UpperLeftArrow", + "dblac", + "puncsp", + "ccaron", + "rbbrk", + "lbbrk", + "Aogon", + "LeftTriangleBar", + "gesdotol", + "LeftTriangleEqual", + "LeftTriangle", + "conint", + "drbkarow", + "rtrif", + "ltrif", + "ReverseUpEquilibrium", + "LeftCeiling", + "utrif", + "xcup", + "fallingdotseq", + "rcedil", + "lcedil", + "scedil", + "Tcedil", + "starf", + "boxminus", + "tcedil", + "ZeroWidthSpace", + "ncedil", + "phiv", + "ic", + "capdot", + "dscy", + "check", + "ovbar", + "ntriangleleft", + "RightTee", + "nvge", + "leftrightsquigarrow", + "lozenge", + "RightTriangleBar", + "RightTeeVector", + "RightTriangleEqual", + "RightTriangle", + "Kcedil", + "Scedil", + "cirfnint", + "empty", + "afr", + "DiacriticalTilde", + "LeftDownVector", + "LeftDownVectorBar", + "lEg", + "ApplyFunction", + "bumpE", + "Lcedil", + "caret", + "Barv", + "Ccedil", + "circledR", + "LeftDownTeeVector", + "tshcy", + "DotEqual", + "centerdot", + "ntrianglelefteq", + "minus", + "gimel", + "Aacute", + "gtcir", + "gtrarr", + "bull", + "DownArrow", + "rdquor", + "ldquor", + "intlarhk", + "utilde", + "gacute", + "ntilde", + "af", + "Hstrok", + "exponentiale", + "minusb", + "RightUpTeeVector", + "UpTeeArrow", + "zeta", + "DiacriticalDot", + "DiacriticalDoubleAcute", + "nleftarrow", + "hkswarow", + "iiota", + "apacir", + "Ncedil", + "capand", + "mdash", + "filig", + "scnsim", + "realpart", + "leftthreetimes", + "asymp", + "hellip", + "dtrif", + "NotExists", + "sccue", + "YAcy", + "Utilde", + "NotEqual", + "ThinSpace", + "apE", + "bullet", + "CloseCurlyDoubleQuote", + "Delta", + "gg", + "otimes", + "wreath", + "Rcedil", + "eth", + "supnE", + "awint", + "Breve", + "Gg", + "HumpEqual", + "Lleftarrow", + "boxdr", + "succneqq", + "uring", + "LessSlantEqual", + "nvdash", + "Hacek", + "itilde", + "Iota", + "IOcy", + "boxDr", + "SucceedsTilde", + "LeftFloor", + "Vvdash", + "triangledown", + "LongLeftRightArrow", + "RightFloor", + "DownRightTeeVector", + "quatint", + "Ntilde", + "Bumpeq", + "gvnE", + "boxhu", + "gtlPar", + "nprec", + "ouml", + "gescc", + "Euml", + "Uring", + "UnderBracket", + "nLtv", + "LeftArrowBar", + "ncongdot", + "asympeq", + "minusdu", + "delta", + "harrw", + "andslope", + "cdot", + "Cayleys", + "boxhU", + "succsim", + "cirE", + "sdotb", + "odash", + "cirmid", + "suphsub", + "supdsub", + "supdot", + "awconint", + "TSHcy", + "grave", + "lsimg", + "UpArrowDownArrow", + "LeftVector", + "DoubleRightArrow", + "NegativeThinSpace", + "lhblk", + "cire", + "nVDash", + "uhblk", + "imagpart", + "RightUpDownVector", + "boxdL", + "gla", + "Iuml", + "oelig", + "NotLessSlantEqual", + "boxDL", + "gamma", + "Otimes", + "longleftrightarrow", + "Gamma", + "bigwedge", + "boxhd", + "supE", + "LeftUpTeeVector", + "gesdoto", + "kappa", + "ngeqslant", + "gtrless", + "fflig", + "bigsqcup", + "kgreen", + "supe", + "boxtimes", + "gnapprox", + "downdownarrows", + "biguplus", + "khcy", + "ddagger", + "Ouml", + "Beta", + "minusd", + "succnsim", + "ctdot", + "kjcy", + "gjcy", + "ncong", + "xvee", + "bcong", + "sqsube", + "boxdR", + "Longleftrightarrow", + "sqsub", + "DownLeftRightVector", + "sqsubset", + "NotVerticalBar", + "NotEqualTilde", + "boxdl", + "boxDR", + "andand", + "RightVector", + "IJlig", + "NotTildeEqual", + "angzarr", + "angrt", + "acd", + "andd", + "nrarrc", + "VeryThinSpace", + "Superset", + "boxDl", + "vnsub", + "ccupssm", + "varnothing", + "rcy", + "lcy", + "scy", + "Tcy", + "Zcy", + "ecy", + "rdsh", + "ldsh", + "ucy", + "boxVH", + "tcy", + "ncy", + "bcy", + "ntgl", + "Jcy", + "congdot", + "angst", + "RightDownTeeVector", + "OverParenthesis", + "ltquest", + "pcy", + "otilde", + "rdquo", + "ldquo", + "Vcy", + "capbrcup", + "bdquo", + "DownArrowBar", + "vcy", + "angrtvb", + "Kcy", + "Mcy", + "Scy", + "NewLine", + "fcy", + "Ucy", + "boxVh", + "Dcy", + "hstrok", + "Lcy", + "Ycy", + "supsim", + "NonBreakingSpace", + "OverBar", + "sqsubseteq", + "GJcy", + "OverBrace", + "eqcirc", + "OverBracket", + "Auml", + "acute", + "icy", + "Itilde", + "HilbertSpace", + "omega", + "cacute", + "scirc", + "ecirc", + "ucirc", + "GreaterSlantEqual", + "Jcirc", + "nvDash", + "Wcirc", + "Ncy", + "RightTeeArrow", + "LessFullEqual", + "ltcc", + "aleph", + "dcy", + "Scirc", + "lessapprox", + "IEcy", + "LowerRightArrow", + "Ucirc", + "agrave", + "MinusPlus", + "bigvee", + "Rcy", + "suphsol", + "EmptyVerySmallSquare", + "boxhD", + "precapprox", + "angrtvbd", + "Ycirc", + "sub", + "Otilde", + "Ccirc", + "Fcy", + "complexes", + "subrarr", + "InvisibleComma", + "boxur", + "abreve", + "ntlg", + "icirc", + "xdtri", + "circ", + "gtrdot", + "geqslant", + "ntriangleright", + "cuepr", + "Sub", + "mcy", + "timesbar", + "hksearow", + "sigma", + "cupor", + "oslash", + "dzigrarr", + "leftrightharpoons", + "rightleftharpoons", + "kcedil", + "submult", + "curren", + "LeftTeeVector", + "bigstar", + "cup", + "LongRightArrow", + "Gcedil", + "PrecedesEqual", + "zcy", + "planckh", + "Omega", + "subsub", + "rdca", + "cups", + "ldca", + "subset", + "NotSucceeds", + "LeftArrowRightArrow", + "wcirc", + "RightAngleBracket", + "ntrianglerighteq", + "Sigma", + "NotSucceedsTilde", + "DiacriticalAcute", + "subne", + "Product", + "circleddash", + "subsup", + "copy", + "eta", + "angmsd", + "natural", + "supedot", + "naturals", + "triangleright", + "DiacriticalGrave", + "boxuL", + "cong", + "telrec", + "comma", + "Subset", + "NotSucceedsSlantEqual", + "gtreqless", + "Atilde", + "curarr", + "cudarrr", + "cudarrl", + "subseteq", + "subseteqq", + "rightsquigarrow", + "cupcap", + "subsetneq", + "aogon", + "notinvc", + "rightthreetimes", + "yacute", + "nLeftarrow", + "ocy", + "cemptyv", + "Ecy", + "cupcup", + "trianglerighteq", + "LeftRightArrow", + "succ", + "DownArrowUpArrow", + "OElig", + "chcy", + "gtreqqless", + "angle", + "acE", + "rmoustache", + "lmoustache", + "NegativeVeryThinSpace", + "napprox", + "Oslash", + "subsetneqq", + "Aring", + "boxuR", + "subplus", + "xwedge", + "boxul", + "boxvr", + "HumpDownHump", + "Icy", + "approxeq", + "aacute", + "apid", + "UpDownArrow", + "NestedGreaterGreater", + "jcy", + "gtrsim", + "boxv", + "ocirc", + "Ecirc", + "notnivc", + "bigtriangleup", + "daleth", + "Ocy", + "Hcirc", + "RightVectorBar", + "AElig", + "FilledVerySmallSquare", + "ggg", + "Bcy", + "Poincareplane", + "boxvL", + "PartialD", + "Icirc", + "cularr", + "boxh", + "andv", + "sung", + "RightDoubleBracket", + "jcirc", + "UnderBar", + "RightArrow", + "circledcirc", + "Alpha", + "leftharpoonup", + "cularrp", + "RightArrowLeftArrow", + "varsigma", + "numero", + "ffllig", + "LowerLeftArrow", + "expectation", + "Ocirc", + "yacy", + "lambda", + "NotSucceedsEqual", + "boxvR", + "bigtriangledown", + "ang", + "xuplus", + "nabla", + "boxvl", + "Eta", + "Acy", + "kcy", + "gcy", + "LeftRightVector", + "ccedil", + "Backslash", + "hslash", + "Pcy", + "Gcy", + "gtquest", + "Lambda", + "odiv", + "leftharpoondown", + "longmapsto", + "Jukcy", + "ldrdhar", + "xutri", + "nRightarrow", + "ExponentialE", + "nrightarrow", + "Acirc", + "NoBreak", + "gcirc", + "ange", + "curarrm", + "SHCHcy", + "yuml", + "subnE", + "DDotrahd", + "RuleDelayed", + "Gcirc", + "Jsercy", + "gtcc", + "iukcy", + "updownarrow", + "curlyvee", + "ffilig", + "yicy", + "divonx", + "gtrapprox", + "subdot", + "leftrightarrows", + "auml", + "Updownarrow", + "rightleftarrows", + "DownRightVector", + "DownRightVectorBar", + "hcirc", + "Rrightarrow", + "longrightarrow", + "cupdot", + "ac", + "hookrightarrow", + "NegativeThickSpace", + "subE", + "twoheadrightarrow", + "downharpoonright", + "downharpoonleft", + "aelig", + "rdldhar", + "curlywedge", + "hybull", + "sube", + "Longrightarrow", + "Cedilla", + "notinva", + "SucceedsEqual", + "leftrightarrow", + "straightepsilon", + "amalg", + "atilde", + "RightCeiling", + "Leftrightarrow", + "subsim", + "VerticalLine", + "RightUpVector", + "RightUpVectorBar", + "RightDownVector", + "RightDownVectorBar", + "alefsym", + "circlearrowright", + "circlearrowleft", + "Iukcy", + "otimesas", + "intercal", + "thickapprox", + "jukcy", + "notniva", + "precnapprox", + "cuvee", + "aring", + "ccirc", + "rightarrow", + "Integral", + "xcirc", + "jsercy", + "checkmark", + "VerticalTilde", + "boxvH", + "NotRightTriangleBar", + "NotRightTriangleEqual", + "NotRightTriangle", + "LeftVectorBar", + "boxvh", + "boxbox", + "ycy", + "subedot", + "SOFTcy", + "Rightarrow", + "alpha", + "shchcy", + "softcy", + "acy", + "ycirc", + "bigcirc", + "ImaginaryI", + "approx", + "SupersetEqual", + "vzigzag", + "cuesc", + "UnderParenthesis", + "acirc", + "succapprox", + "mcomma", + "angmsdae", + "angmsdab", + "angmsdaf", + "angsph", + "luruhar", + "angmsdad", + "twoheadleftarrow", + "cylcty", + "straightphi", + "multimap", + "RightArrowBar", + "ldrushar", + "LeftAngleBracket", + "ruluhar", + "curlyeqprec", + "yucy", + "lurdshar", + "hardcy", + "rightharpoondown", + "rightharpoonup", + "HARDcy", + "SubsetEqual", + "digamma", + "udblac", + "SuchThat", + "cuwed", + "Udblac", + "angmsdag", + "angmsdah", + "VerticalBar", + "VerticalSeparator", + "rightarrowtail", + "odblac", + "succnapprox", + "angmsdac", + "Odblac", + "cupbrcap", + "angmsdaa", + "curlyeqsucc", + "curvearrowleft", + "curvearrowright" + }; +#define entity_pool ((const char *) &entity_pool_contents) +const struct html_ent * +find_entity (register const char *str, register unsigned int len) +{ + static const unsigned char lengthtable[] = + { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 4, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 0, 0, 3, + 0, 0, 0, 0, 0, 0, 6, 0, 6, 5, 0, 5, 3, 4, + 3, 4, 0, 4, 0, 2, 5, 4, 0, 0, 0, 2, 0, 7, + 0, 7, 3, 0, 5, 0, 0, 0, 0, 0, 4, 0, 0, 6, + 0, 0, 0, 3, 6, 0, 4, 0, 0, 0, 0, 6, 4, 5, + 0, 0, 0, 5, 0, 5, 0, 6, 0, 0, 0, 4, 5, 5, + 5, 3, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, + 0, 0, 0, 3, 4, 0, 3, 0, 0, 5, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 5, 0, + 5, 0, 5, 6, 0, 6, 5, 0, 2, 5, 0, 5, 0, 0, + 0, 0, 4, 0, 0, 0, 3, 0, 3, 5, 0, 0, 5, 0, + 0, 0, 6, 0, 10, 0, 4, 0, 0, 5, 3, 5, 0, 0, + 0, 0, 0, 0, 0, 5, 0, 3, 0, 0, 0, 0, 6, 6, + 0, 6, 0, 0, 0, 0, 6, 0, 6, 0, 2, 0, 0, 0, + 4, 7, 0, 7, 0, 5, 0, 0, 0, 0, 0, 0, 0, 3, + 0, 4, 0, 4, 6, 0, 3, 0, 0, 0, 0, 0, 0, 4, + 4, 3, 0, 4, 0, 0, 2, 0, 0, 0, 4, 0, 4, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 2, 0, 0, 0, 5, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 3, 2, 4, 0, 6, 0, 0, 3, 0, 2, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 6, 0, 3, 4, 0, 0, 0, + 0, 4, 6, 0, 0, 0, 5, 5, 5, 0, 13, 0, 0, 4, + 0, 0, 5, 0, 4, 4, 5, 17, 18, 0, 0, 0, 0, 0, + 5, 0, 0, 17, 0, 0, 0, 0, 0, 5, 5, 0, 0, 0, + 5, 5, 0, 0, 0, 8, 0, 0, 0, 3, 0, 0, 6, 3, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 5, 6, 0, 0, + 0, 4, 0, 0, 5, 0, 6, 6, 6, 6, 6, 6, 6, 0, + 0, 6, 0, 6, 0, 6, 6, 6, 6, 6, 6, 0, 0, 0, + 6, 0, 6, 3, 4, 0, 0, 4, 3, 5, 0, 0, 3, 0, + 0, 0, 11, 5, 0, 0, 0, 4, 0, 0, 6, 0, 0, 0, + 5, 0, 0, 0, 5, 0, 5, 0, 0, 0, 0, 0, 0, 0, + 0, 5, 0, 0, 0, 0, 0, 5, 3, 0, 0, 4, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 4, 0, 4, + 0, 0, 0, 0, 0, 0, 6, 0, 0, 5, 0, 0, 0, 0, + 3, 6, 0, 0, 0, 0, 0, 8, 8, 0, 0, 0, 4, 6, + 0, 0, 8, 0, 8, 0, 2, 0, 0, 0, 0, 4, 0, 0, + 0, 4, 0, 6, 0, 0, 0, 0, 6, 0, 4, 0, 0, 0, + 0, 6, 0, 5, 6, 2, 5, 8, 5, 0, 0, 4, 0, 4, + 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 9, 0, 4, 4, + 4, 0, 4, 6, 4, 4, 4, 0, 0, 0, 5, 4, 5, 4, + 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 4, 5, 4, + 5, 0, 0, 4, 0, 5, 0, 0, 0, 4, 0, 0, 0, 0, + 4, 4, 0, 5, 0, 0, 11, 0, 0, 6, 0, 0, 3, 0, + 0, 0, 0, 6, 0, 4, 0, 0, 4, 0, 0, 0, 0, 4, + 0, 0, 0, 0, 7, 4, 4, 0, 7, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 3, 8, 4, 0, 0, 0, 5, 0, 6, 0, + 0, 0, 0, 6, 0, 4, 0, 0, 0, 5, 0, 6, 0, 0, + 0, 5, 5, 0, 0, 3, 6, 2, 0, 0, 4, 0, 0, 7, + 0, 4, 0, 4, 4, 4, 3, 5, 0, 0, 0, 0, 0, 0, + 6, 0, 4, 4, 0, 0, 0, 12, 13, 0, 0, 6, 8, 0, + 2, 0, 0, 17, 0, 0, 0, 4, 0, 5, 0, 7, 0, 5, + 0, 0, 0, 5, 4, 5, 0, 0, 3, 0, 0, 0, 5, 0, + 5, 12, 13, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 4, 0, 0, 0, 7, 0, 0, 6, 6, 6, 0, 4, 0, + 0, 0, 0, 17, 0, 0, 4, 5, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 5, 3, 6, 9, 0, 0, + 0, 9, 0, 0, 0, 0, 0, 6, 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 19, 0, 5, 0, 0, 17, 0, 0, + 14, 0, 0, 0, 0, 12, 4, 0, 0, 0, 4, 0, 2, 0, + 4, 0, 6, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 0, + 4, 0, 4, 4, 4, 0, 0, 0, 0, 4, 0, 4, 0, 4, + 9, 0, 0, 4, 2, 0, 0, 4, 2, 4, 4, 0, 0, 0, + 0, 4, 6, 0, 0, 6, 9, 4, 0, 6, 0, 0, 0, 0, + 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 6, 0, 0, + 0, 0, 0, 4, 2, 0, 0, 0, 0, 0, 0, 4, 0, 0, + 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, + 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 10, 6, 0, 0, + 0, 0, 6, 4, 6, 4, 0, 0, 0, 0, 0, 0, 0, 5, + 0, 0, 0, 0, 0, 9, 0, 0, 4, 0, 0, 0, 0, 0, + 7, 4, 4, 7, 0, 7, 5, 0, 0, 6, 4, 4, 4, 0, + 4, 4, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 4, 0, + 0, 0, 4, 0, 0, 4, 4, 6, 0, 0, 0, 3, 5, 3, + 5, 11, 4, 0, 0, 4, 0, 0, 0, 5, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 5, 0, 5, 0, 0, 0, 3, 5, 4, + 0, 0, 0, 5, 0, 6, 9, 7, 2, 0, 4, 0, 0, 4, + 0, 0, 0, 0, 4, 5, 6, 0, 0, 0, 0, 9, 10, 0, + 0, 0, 5, 0, 0, 0, 0, 11, 0, 0, 6, 0, 0, 0, + 0, 0, 0, 4, 8, 6, 0, 0, 0, 0, 0, 8, 0, 0, + 0, 0, 0, 0, 0, 5, 6, 0, 0, 0, 13, 5, 5, 6, + 0, 0, 0, 0, 2, 0, 0, 0, 4, 2, 4, 0, 0, 6, + 4, 0, 4, 0, 0, 0, 4, 0, 21, 0, 0, 0, 6, 0, + 3, 0, 0, 0, 6, 6, 0, 3, 13, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 6, 0, 0, 7, 0, 0, 0, 0, + 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 5, 0, 4, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 7, 3, 0, 0, + 0, 0, 0, 0, 0, 7, 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, + 3, 15, 3, 3, 3, 0, 0, 0, 3, 3, 6, 3, 6, 0, + 0, 0, 0, 3, 0, 0, 4, 3, 0, 3, 0, 12, 0, 0, + 0, 3, 0, 4, 0, 0, 0, 3, 0, 12, 0, 4, 5, 0, + 9, 0, 0, 7, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 0, 0, 5, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 4, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, + 0, 5, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 5, + 0, 3, 3, 0, 0, 6, 0, 0, 0, 0, 0, 4, 0, 0, + 3, 3, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 5, 3, 7, 0, 0, 8, 0, 0, 0, 0, + 0, 0, 3, 4, 0, 6, 0, 0, 0, 15, 0, 0, 0, 0, + 0, 0, 0, 9, 0, 0, 0, 2, 0, 0, 0, 0, 9, 3, + 0, 0, 0, 0, 0, 0, 6, 0, 0, 7, 3, 24, 0, 0, + 0, 0, 5, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 6, 7, 4, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 3, 3, + 0, 4, 0, 7, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 5, 2, 0, 0, 0, 6, 0, 3, 8, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 4, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 5, 0, 9, 5, 7, 0, 0, 0, 0, 0, 0, 0, + 0, 7, 15, 7, 8, 4, 0, 5, 0, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 4, 4, 5, 0, 0, 0, 0, 6, 14, 3, + 15, 0, 6, 0, 0, 0, 3, 0, 3, 3, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 6, 0, 0, 0, + 0, 0, 0, 5, 0, 0, 5, 16, 0, 5, 10, 0, 0, 0, + 5, 7, 0, 5, 0, 0, 6, 0, 3, 0, 0, 11, 5, 0, + 0, 4, 5, 0, 0, 5, 0, 0, 3, 0, 0, 0, 0, 8, + 0, 0, 0, 5, 0, 0, 0, 6, 3, 0, 0, 0, 0, 0, + 5, 0, 0, 3, 3, 3, 0, 0, 0, 6, 0, 0, 5, 6, + 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 11, 0, 6, 0, 6, 0, 0, 13, 0, 0, 7, + 0, 0, 0, 0, 7, 0, 6, 4, 5, 0, 3, 0, 0, 5, + 3, 0, 0, 0, 0, 0, 6, 0, 0, 4, 0, 0, 0, 0, + 3, 6, 5, 0, 0, 0, 0, 11, 0, 4, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, + 0, 11, 0, 5, 5, 0, 0, 0, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 8, 0, 7, 4, 0, 0, 0, 0, 5, 4, 9, + 0, 0, 5, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, + 0, 6, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, + 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 6, 0, 4, 0, 0, 14, 5, 0, 0, 8, + 0, 0, 0, 20, 7, 0, 0, 0, 0, 0, 0, 0, 0, 5, + 3, 0, 0, 4, 6, 0, 0, 0, 0, 6, 0, 0, 0, 7, + 0, 3, 6, 4, 6, 0, 0, 0, 0, 0, 0, 6, 3, 4, + 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, + 0, 11, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 4, + 0, 0, 0, 0, 0, 0, 0, 13, 18, 5, 0, 3, 0, 7, + 0, 4, 0, 0, 0, 4, 0, 0, 10, 11, 0, 0, 0, 6, + 0, 6, 0, 0, 5, 0, 5, 12, 12, 0, 0, 0, 4, 0, + 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, + 14, 0, 0, 0, 2, 4, 8, 4, 0, 3, 0, 0, 7, 0, + 3, 0, 0, 0, 3, 2, 0, 0, 0, 0, 6, 0, 6, 4, + 6, 7, 6, 6, 6, 0, 10, 0, 0, 0, 3, 6, 0, 4, + 0, 0, 0, 0, 0, 4, 0, 6, 6, 0, 4, 0, 0, 0, + 7, 0, 0, 7, 0, 0, 4, 0, 4, 0, 5, 6, 0, 6, + 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 8, 14, 0, 3, 0, 0, 0, 0, + 0, 0, 8, 0, 0, 7, 5, 0, 0, 0, 4, 0, 0, 0, + 17, 7, 0, 0, 4, 0, 0, 7, 0, 5, 0, 0, 7, 5, + 0, 0, 4, 0, 7, 2, 20, 0, 0, 0, 0, 13, 0, 0, + 0, 0, 6, 0, 7, 3, 5, 4, 0, 0, 0, 0, 5, 5, + 0, 0, 0, 0, 0, 4, 5, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 5, 0, 0, 6, 0, 0, 6, 0, 0, 0, 0, 0, + 0, 0, 4, 9, 0, 5, 12, 0, 0, 0, 0, 5, 0, 5, + 4, 0, 0, 0, 9, 0, 0, 0, 10, 10, 0, 0, 4, 6, + 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2, 6, 0, 0, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 6, 0, 0, 0, 0, 6, 6, 0, 3, 0, 0, 0, + 7, 0, 0, 0, 0, 7, 4, 0, 0, 0, 0, 0, 4, 0, + 9, 0, 0, 3, 0, 0, 0, 7, 0, 4, 0, 0, 5, 6, + 0, 0, 6, 3, 5, 4, 0, 0, 0, 0, 0, 6, 0, 5, + 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 6, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 5, + 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, + 6, 0, 0, 6, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 8, 0, 0, 0, 6, 0, 0, 0, 0, 4, + 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 10, 0, 0, 6, 0, 6, 0, 0, 6, + 0, 0, 18, 0, 6, 0, 20, 15, 0, 0, 4, 4, 0, 0, + 0, 6, 0, 0, 0, 3, 0, 0, 0, 0, 0, 5, 4, 4, + 0, 7, 0, 6, 0, 4, 0, 5, 0, 0, 0, 0, 5, 0, + 0, 0, 4, 4, 0, 0, 0, 0, 4, 0, 4, 0, 11, 0, + 20, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 10, 0, 0, 8, 0, 0, 0, 6, 0, 0, 0, + 0, 4, 0, 0, 0, 0, 0, 4, 0, 0, 3, 0, 0, 6, + 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, + 0, 0, 0, 0, 0, 0, 13, 0, 0, 9, 0, 0, 0, 5, + 0, 0, 0, 5, 0, 3, 0, 0, 0, 0, 0, 0, 0, 5, + 0, 0, 0, 0, 3, 0, 0, 17, 0, 5, 0, 0, 0, 0, + 0, 0, 0, 0, 6, 0, 9, 0, 0, 0, 6, 0, 0, 0, + 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, + 0, 7, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 14, 0, + 0, 11, 0, 6, 0, 6, 0, 7, 5, 0, 0, 0, 6, 12, + 12, 0, 0, 0, 0, 16, 0, 14, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 5, 0, 5, 0, 0, 0, 7, + 0, 0, 5, 0, 0, 0, 0, 0, 0, 6, 0, 14, 0, 0, + 0, 0, 0, 0, 4, 0, 0, 0, 6, 0, 0, 0, 0, 0, + 0, 0, 8, 0, 0, 0, 0, 5, 0, 6, 0, 0, 0, 0, + 0, 0, 0, 0, 5, 0, 0, 5, 0, 0, 0, 0, 0, 0, + 5, 0, 5, 0, 0, 0, 0, 0, 11, 6, 6, 3, 0, 0, + 0, 0, 7, 0, 6, 0, 6, 6, 4, 0, 0, 0, 7, 0, + 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 5, 0, 5, 0, 0, 0, 6, 0, 0, 0, 0, + 4, 4, 0, 0, 0, 0, 3, 3, 6, 0, 0, 0, 0, 0, + 0, 8, 0, 0, 0, 0, 0, 6, 0, 0, 0, 4, 6, 0, + 4, 4, 0, 0, 0, 0, 13, 0, 4, 0, 0, 0, 0, 4, + 2, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 7, 0, + 0, 0, 10, 0, 9, 0, 0, 4, 6, 0, 5, 0, 0, 0, + 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 10, 0, 0, 0, 0, 0, 0, 8, 0, 0, 6, 0, + 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 12, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 12, 0, + 0, 0, 0, 0, 0, 0, 18, 0, 0, 4, 0, 0, 0, 0, + 0, 0, 0, 0, 6, 0, 7, 0, 0, 0, 0, 5, 0, 5, + 0, 0, 0, 6, 0, 0, 5, 0, 0, 6, 0, 6, 0, 0, + 13, 6, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, + 0, 4, 0, 6, 0, 6, 7, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 6, 15, 0, 0, 7, 0, 3, 0, 3, 0, 0, 0, + 9, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, + 0, 4, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 15, + 0, 0, 0, 6, 0, 0, 6, 0, 0, 0, 0, 6, 0, 0, + 0, 0, 0, 0, 0, 7, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, + 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 3, 9, 4, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 2, 15, 0, 0, + 0, 5, 0, 5, 0, 4, 0, 0, 0, 0, 0, 0, 16, 0, + 3, 3, 10, 0, 0, 0, 0, 0, 0, 0, 0, 4, 5, 4, + 5, 4, 0, 0, 6, 0, 5, 4, 0, 5, 5, 3, 5, 0, + 4, 0, 6, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 3, + 0, 0, 0, 0, 0, 3, 0, 0, 6, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 6, 8, 6, 0, 0, 0, 0, 0, 0, 0, 5, 16, 0, + 5, 7, 0, 6, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, + 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 7, 0, 7, 0, 0, 5, 0, 0, + 0, 0, 6, 0, 5, 4, 5, 0, 5, 5, 0, 0, 0, 0, + 5, 2, 6, 4, 0, 5, 0, 0, 5, 0, 4, 0, 0, 0, + 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, + 0, 6, 0, 0, 0, 0, 3, 5, 0, 0, 0, 2, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, + 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 8, 0, 0, 0, 0, 6, 5, 0, 0, 4, + 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, + 0, 4, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 4, 0, 4, 2, 6, 0, 6, 3, 3, 0, 0, + 3, 0, 4, 0, 6, 0, 3, 0, 0, 6, 0, 5, 31, 0, + 0, 0, 0, 0, 0, 0, 3, 6, 0, 0, 0, 0, 0, 0, + 0, 4, 0, 0, 5, 0, 0, 0, 3, 0, 0, 0, 0, 6, + 0, 8, 0, 5, 4, 0, 0, 0, 0, 3, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 0, 0, 5, 0, 0, 5, 0, + 0, 0, 19, 0, 0, 0, 0, 24, 0, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 5, + 0, 0, 0, 6, 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, + 0, 16, 5, 0, 0, 3, 4, 4, 0, 5, 4, 5, 0, 0, + 0, 13, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 5, 5, 0, 0, 0, 0, 0, 0, 6, 0, 3, + 0, 7, 0, 10, 0, 0, 0, 0, 6, 0, 6, 0, 0, 13, + 0, 0, 0, 5, 0, 8, 0, 6, 0, 6, 8, 6, 0, 0, + 6, 6, 0, 10, 0, 8, 6, 6, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 6, 0, 11, 0, 0, 0, 6, 0, 0, 0, + 0, 7, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 17, 6, 0, 0, 0, 0, 0, 16, 0, 0, + 0, 0, 0, 0, 4, 0, 4, 0, 0, 0, 0, 0, 7, 0, + 14, 7, 6, 0, 6, 0, 7, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 6, 10, 4, 14, 0, 0, 0, 9, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 0, 4, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 6, 3, 8, 4, 6, 6, 0, + 5, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, + 0, 6, 0, 4, 0, 2, 0, 20, 21, 0, 0, 2, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 6, 0, 0, 14, 4, 6, 17, 0, 0, + 0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 0, 5, 0, 0, + 4, 6, 0, 2, 7, 0, 6, 5, 0, 8, 0, 0, 5, 0, + 4, 0, 0, 0, 5, 0, 4, 15, 5, 0, 4, 6, 0, 0, + 0, 0, 5, 5, 0, 0, 0, 0, 0, 0, 0, 17, 5, 0, + 0, 0, 9, 6, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 6, 0, 5, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 7, 5, 0, + 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 4, 0, 0, 0, + 0, 12, 0, 0, 0, 6, 0, 0, 0, 0, 10, 3, 0, 0, + 0, 4, 0, 5, 0, 0, 0, 0, 0, 4, 0, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 7, 0, 0, + 0, 0, 0, 0, 9, 0, 6, 0, 6, 0, 0, 0, 0, 19, + 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 3, + 0, 0, 0, 0, 0, 0, 5, 0, 0, 5, 0, 6, 3, 6, + 0, 0, 0, 0, 0, 0, 0, 4, 0, 4, 2, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 5, 0, 6, 0, 6, 0, 6, 0, 0, + 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 6, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 17, 0, + 0, 7, 0, 0, 2, 6, 2, 0, 0, 0, 2, 0, 0, 0, + 0, 3, 8, 0, 0, 3, 0, 5, 0, 5, 6, 0, 0, 0, + 0, 18, 0, 0, 0, 0, 5, 0, 7, 0, 0, 9, 0, 0, + 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 4, 0, 4, 0, 0, 4, 0, 9, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 5, 0, 4, 0, + 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 5, 0, 5, 6, + 0, 0, 0, 3, 3, 5, 0, 0, 0, 0, 6, 0, 0, 0, + 6, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 4, + 6, 13, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, + 13, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, + 0, 0, 5, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, + 8, 6, 8, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, + 0, 0, 0, 0, 0, 12, 0, 6, 0, 0, 0, 6, 0, 0, + 0, 6, 4, 0, 0, 7, 6, 5, 0, 0, 6, 0, 5, 5, + 5, 0, 0, 0, 9, 0, 0, 0, 0, 0, 5, 0, 6, 8, + 0, 0, 6, 0, 5, 8, 0, 0, 0, 6, 0, 4, 0, 9, + 0, 0, 0, 0, 4, 6, 4, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 4, + 11, 0, 0, 8, 9, 0, 0, 0, 0, 3, 5, 3, 0, 0, + 0, 0, 6, 4, 0, 0, 0, 9, 4, 3, 0, 2, 0, 0, + 0, 0, 0, 7, 5, 0, 0, 0, 0, 6, 0, 0, 0, 0, + 0, 14, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 10, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 10, 7, + 5, 0, 6, 0, 6, 0, 3, 17, 0, 0, 0, 0, 0, 0, + 20, 0, 14, 4, 0, 0, 0, 0, 0, 0, 19, 6, 6, 0, + 10, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 6, 0, + 0, 3, 0, 0, 0, 4, 5, 0, 0, 4, 0, 5, 0, 0, + 0, 0, 0, 0, 7, 0, 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 4, 0, 0, 3, 0, 0, 0, 0, + 0, 0, 7, 0, 3, 0, 4, 0, 3, 0, 4, 0, 0, 13, + 0, 4, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, + 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, + 6, 0, 0, 0, 0, 0, 7, 0, 13, 0, 0, 15, 0, 0, + 5, 9, 0, 0, 0, 6, 0, 6, 0, 0, 4, 6, 0, 0, + 6, 4, 4, 0, 16, 0, 4, 0, 3, 0, 0, 11, 5, 15, + 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 7, 0, 0, 5, 0, 5, 4, 0, 0, 4, 0, + 20, 4, 0, 0, 0, 0, 0, 5, 15, 4, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 4, 0, 0, 0, 5, 0, 0, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 5, 5, 0, 22, 0, 0, 7, + 8, 0, 4, 0, 17, 0, 0, 0, 0, 0, 0, 0, 0, 6, + 0, 0, 6, 7, 0, 0, 0, 0, 6, 0, 6, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 4, 0, 5, 0, 12, 15, 6, 0, + 13, 0, 4, 0, 5, 4, 6, 0, 0, 0, 0, 4, 0, 0, + 4, 3, 5, 0, 0, 0, 0, 0, 0, 4, 0, 4, 0, 0, + 0, 0, 0, 0, 4, 0, 0, 9, 0, 0, 20, 0, 4, 10, + 0, 0, 0, 0, 4, 0, 5, 0, 0, 8, 6, 0, 5, 4, + 0, 0, 3, 0, 4, 0, 0, 6, 6, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 0, 9, + 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 17, + 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 0, 14, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, + 0, 14, 0, 0, 0, 0, 0, 0, 5, 6, 0, 5, 0, 0, + 0, 0, 0, 0, 5, 0, 8, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 16, 15, 4, 0, 0, 11, 0, 0, 0, 8, 0, 0, + 0, 0, 0, 0, 0, 2, 0, 5, 0, 10, 0, 0, 5, 0, + 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, + 5, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 5, 4, 0, 0, 0, 0, 0, 0, 0, 2, + 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 8, 6, 5, 4, 0, 0, 0, + 0, 5, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 6, 0, + 0, 0, 0, 2, 4, 5, 0, 0, 0, 8, 0, 0, 3, 0, + 8, 0, 0, 4, 18, 0, 0, 0, 0, 4, 5, 0, 0, 0, + 16, 0, 0, 0, 0, 7, 0, 2, 3, 5, 0, 0, 5, 0, + 4, 4, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 14, 0, 0, 0, 0, 5, 0, 0, 6, 0, 6, 0, + 5, 0, 5, 0, 5, 15, 0, 0, 8, 17, 12, 0, 0, 0, + 0, 0, 6, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 5, 0, 5, 0, 0, 20, 0, 0, 0, 0, 0, + 11, 0, 5, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 13, + 0, 0, 0, 0, 0, 6, 0, 6, 0, 6, 0, 6, 0, 5, + 8, 0, 0, 0, 0, 0, 6, 14, 0, 0, 0, 0, 0, 0, + 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 4, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 5, 5, 0, 0, 0, 0, 0, + 0, 13, 0, 0, 0, 0, 0, 8, 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 19, 0, 0, 0, 0, 0, 0, 7, + 0, 0, 16, 0, 14, 0, 18, 13, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 5, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 16, 0, 0, 0, 0, 0, + 0, 14, 0, 0, 17, 0, 0, 0, 0, 0, 0, 0, 0, 3, + 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 5, 0, + 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, + 0, 0, 0, 8, 17, 0, 0, 0, 5, 0, 0, 0, 8, 0, + 0, 0, 0, 0, 0, 0, 9, 0, 15, 0, 5, 0, 5, 0, + 0, 0, 0, 0, 0, 6, 5, 0, 0, 0, 0, 6, 4, 0, + 0, 9, 0, 0, 0, 0, 0, 6, 0, 6, 0, 0, 8, 0, + 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, + 6, 2, 0, 0, 6, 0, 12, 6, 0, 0, 0, 16, 0, 0, + 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, + 0, 0, 14, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 10, 8, 0, 5, 0, 0, 6, + 0, 0, 0, 6, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, + 0, 0, 5, 0, 0, 5, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 8, 0, 0, 0, 14, 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 5, 0, 9, 0, + 0, 0, 5, 0, 0, 0, 0, 4, 6, 0, 0, 0, 0, 0, + 0, 8, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 21, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 6, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 6, 0, 6, 0, 0, 0, 0, 0, 3, 5, 0, + 0, 5, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 2, 0, + 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, + 5, 0, 0, 0, 0, 0, 0, 0, 0, 8, 5, 14, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, + 5, 6, 0, 0, 4, 0, 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 13, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 6, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 12, 0, 0, 0, 18, 10, 0, 0, 18, 0, 7, 0, 0, + 0, 6, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 4, + 0, 5, 0, 0, 0, 0, 6, 0, 0, 5, 0, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 4, 0, + 0, 0, 5, 0, 12, 4, 12, 8, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 5, 0, 5, 0, + 0, 0, 0, 0, 8, 0, 0, 0, 0, 4, 0, 0, 0, 0, + 7, 5, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 4, + 5, 0, 0, 0, 5, 6, 7, 7, 0, 0, 0, 0, 0, 0, + 0, 6, 0, 8, 0, 0, 0, 0, 5, 0, 0, 5, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, + 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 10, 16, 0, 0, 0, 0, 0, 0, 17, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, + 4, 6, 0, 0, 0, 5, 0, 0, 0, 8, 0, 0, 0, 0, + 0, 17, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 5, 0, 0, 0, 0, 17, 0, 5, 0, 0, 0, 0, 5, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 5, 8, 0, 0, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, + 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0, 0, 7, 0, + 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 8, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 4, 0, + 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 14, 0, 0, 0, + 0, 0, 0, 0, 0, 8, 4, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 4, 0, 4, 6, 8, 0, 5, 0, + 0, 4, 4, 0, 5, 4, 5, 0, 0, 0, 0, 0, 0, 6, + 0, 0, 5, 0, 0, 18, 0, 5, 0, 0, 0, 19, 0, 0, + 8, 0, 14, 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 5, 0, 0, 5, 0, 6, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 11, 0, 5, 13, 0, 0, 0, 7, + 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 3, 0, 0, + 4, 0, 6, 13, 0, 8, 0, 5, 0, 0, 0, 5, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, + 3, 0, 3, 0, 3, 0, 3, 3, 3, 4, 0, 4, 0, 3, + 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, + 4, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 5, + 0, 18, 0, 0, 15, 7, 0, 3, 0, 0, 6, 5, 0, 5, + 0, 3, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 7, + 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, + 7, 10, 0, 0, 0, 0, 0, 4, 0, 0, 9, 0, 0, 0, + 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 11, 0, 4, 0, 0, 0, 0, 0, 0, 0, 5, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 6, 12, 0, 0, 0, 5, 6, 0, 0, 0, 0, + 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 5, 0, 17, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 5, 0, 0, 0, 0, 6, 5, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 5, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, + 4, 15, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 6, 0, 9, 6, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 7, 0, 0, 20, 0, 5, 0, 0, + 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 5, 0, 0, + 0, 3, 0, 0, 6, 5, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 7, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 14, 0, 0, 0, 0, 5, 6, 0, 0, 0, 0, + 0, 4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, + 0, 0, 5, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 5, 3, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 8, 0, 8, 0, 0, 5, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 6, 8, 0, 0, 17, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 17, 0, 6, 0, 0, 0, 0, + 0, 0, 0, 0, 7, 0, 0, 0, 6, 0, 0, 0, 0, 0, + 0, 0, 0, 13, 0, 0, 0, 0, 7, 0, 0, 3, 14, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, + 0, 7, 5, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, + 0, 0, 0, 4, 4, 4, 0, 0, 0, 0, 6, 11, 19, 0, + 0, 5, 17, 0, 0, 0, 0, 0, 16, 5, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, + 7, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 6, 0, 0, + 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 7, 8, 0, 0, 0, 0, 0, 13, 0, 16, 5, 4, + 0, 0, 0, 6, 0, 0, 5, 0, 0, 0, 0, 0, 6, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, + 9, 6, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, + 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 8, + 9, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 6, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 5, 7, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 6, 0, 0, 0, + 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, + 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, + 0, 0, 0, 0, 4, 10, 0, 0, 0, 0, 0, 5, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 10, 0, 10, 0, + 0, 0, 21, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 6, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 11, 0, 20, 0, 3, 0, 0, 6, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, + 0, 3, 0, 0, 0, 0, 5, 14, 5, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, 5, 0, + 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, + 0, 4, 0, 0, 0, 0, 0, 0, 4, 0, 4, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 8, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 11, 5, 0, 0, + 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 7, 0, + 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 6, 0, 0, 0, 0, 0, 16, 5, 0, 15, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 0, 0, 6, 0, 0, 0, 9, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 4, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 5, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 5, 11, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 5, 0, 0, 0, 4, 7, 0, 0, 0, 0, 0, 6, + 0, 0, 0, 0, 4, 0, 0, 0, 5, 0, 0, 8, 0, 0, + 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, + 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0, 0, 4, + 0, 0, 11, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 18, 0, + 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 18, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 15, 0, 0, + 0, 0, 5, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, + 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, + 0, 0, 0, 12, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 13, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 18, 0, 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 15, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, + 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 11, 0, + 0, 5, 0, 0, 0, 7, 0, 0, 0, 11, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, + 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 19, 0, 0, 0, 21, 16, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 10, 0, 5, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, + 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 5, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15 + }; + static const struct html_ent wordlist[] = + { + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1501 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str39), {226, 134, 146, 0}}, + {-1,{0}}, +#line 833 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str41), {226, 134, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 844 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str49), {226, 170, 171, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1903 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str52), {226, 134, 145, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1235 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str55), {226, 138, 128, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1510 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str62), {226, 134, 163, 0}}, + {-1,{0}}, +#line 841 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str64), {226, 134, 162, 0}}, +#line 1601 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str65), {226, 135, 190, 0}}, + {-1,{0}}, +#line 963 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str67), {226, 135, 189, 0}}, +#line 1168 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str68), {194, 172, 0}}, +#line 1609 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str69), {41, 0}}, +#line 146 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str70), {226, 138, 165, 0}}, +#line 989 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str71), {40, 0}}, + {-1,{0}}, +#line 1715 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str73), {226, 136, 165, 0}}, + {-1,{0}}, +#line 945 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str75), {226, 137, 170, 0}}, +#line 1926 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str76), {226, 134, 190, 0}}, +#line 505 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str77), {226, 139, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 482 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str81), {226, 170, 153, 0}}, + {-1,{0}}, +#line 1607 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str83), {226, 168, 181, 0}}, + {-1,{0}}, +#line 981 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str85), {226, 168, 180, 0}}, +#line 1388 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str86), {226, 136, 165, 0}}, + {-1,{0}}, +#line 1132 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str88), {226, 134, 174, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1231 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str94), {226, 136, 166, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1872 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str97), {226, 128, 180, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 486 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str101), {226, 170, 149, 0}}, +#line 506 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str102), {226, 167, 163, 0}}, + {-1,{0}}, +#line 500 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str104), {226, 128, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 193 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str109), {226, 128, 181, 0}}, +#line 955 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str110), {226, 170, 137, 0}}, +#line 137 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str111), {226, 150, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 136 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str115), {226, 150, 146, 0}}, + {-1,{0}}, +#line 138 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str117), {226, 150, 147, 0}}, + {-1,{0}}, +#line 1232 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str119), {226, 171, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1143 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str123), {226, 128, 165, 0}}, +#line 1594 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str124), {226, 135, 132, 0}}, +#line 1233 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str125), {226, 136, 130, 0}}, +#line 944 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str126), {226, 135, 135, 0}}, +#line 1158 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str127), {226, 137, 174, 0}}, +#line 1696 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str128), {226, 134, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1230 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str138), {226, 136, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1825 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str143), {206, 164, 0}}, +#line 1991 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str144), {226, 134, 149, 0}}, + {-1,{0}}, +#line 1738 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str146), {226, 150, 161, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1141 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str149), {226, 134, 154, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1826 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str152), {207, 132, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 957 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str165), {226, 170, 135, 0}}, +#line 1612 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str166), {226, 135, 137, 0}}, + {-1,{0}}, +#line 991 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str168), {226, 135, 134, 0}}, + {-1,{0}}, +#line 1740 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str170), {226, 134, 146, 0}}, +#line 1556 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str171), {226, 165, 172, 0}}, + {-1,{0}}, +#line 940 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str173), {226, 165, 170, 0}}, +#line 525 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str174), {226, 165, 177, 0}}, + {-1,{0}}, +#line 1433 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str176), {226, 137, 186, 0}}, +#line 1555 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str177), {226, 135, 128, 0}}, + {-1,{0}}, +#line 939 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str179), {226, 134, 188, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1904 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str184), {226, 134, 159, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1128 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str188), {226, 137, 171, 0}}, + {-1,{0}}, +#line 140 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str190), {61, 0}}, +#line 1241 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str191), {226, 134, 155, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1818 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str194), {226, 134, 153, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1497 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str198), {226, 165, 181, 0}}, + {-1,{0}}, +#line 1966 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str200), {226, 135, 136, 0}}, + {-1,{0}}, +#line 344 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str202), {226, 134, 161, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1516 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str205), {226, 164, 141, 0}}, +#line 397 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str206), {194, 168, 0}}, +#line 847 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str207), {226, 164, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1306 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str215), {226, 134, 150, 0}}, + {-1,{0}}, +#line 1703 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str217), {226, 170, 170, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 496 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str222), {226, 128, 133, 0}}, +#line 1507 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str223), {226, 165, 133, 0}}, + {-1,{0}}, +#line 839 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str225), {226, 164, 185, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1405 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str230), {226, 132, 179, 0}}, + {-1,{0}}, +#line 495 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str232), {226, 128, 132, 0}}, + {-1,{0}}, +#line 1013 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str234), {60, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 834 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str238), {226, 134, 158, 0}}, +#line 1524 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str239), {226, 166, 144, 0}}, + {-1,{0}}, +#line 854 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str241), {226, 166, 141, 0}}, + {-1,{0}}, +#line 1081 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str243), {197, 137, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1145 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str251), {226, 137, 176, 0}}, + {-1,{0}}, +#line 1553 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str253), {226, 165, 164, 0}}, + {-1,{0}}, +#line 937 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str255), {226, 165, 162, 0}}, +#line 1476 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str256), {226, 129, 151, 0}}, + {-1,{0}}, +#line 828 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str258), {226, 170, 133, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1086 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str265), {194, 160, 0}}, +#line 1924 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str266), {226, 165, 163, 0}}, +#line 1867 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str267), {226, 138, 164, 0}}, + {-1,{0}}, +#line 2003 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str269), {226, 171, 171, 0}}, + {-1,{0}}, {-1,{0}}, +#line 946 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str272), {226, 139, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1431 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str276), {226, 170, 183, 0}}, + {-1,{0}}, +#line 497 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str278), {226, 128, 131, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1078 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str281), {226, 137, 137, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 975 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str294), {226, 134, 171, 0}}, + {-1,{0}}, +#line 869 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str296), {226, 137, 164, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1669 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str300), {226, 153, 175, 0}}, + {-1,{0}}, +#line 473 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str302), {226, 133, 135, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 913 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str310), {226, 169, 189, 0}}, +#line 744 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str311), {226, 136, 136, 0}}, +#line 1460 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str312), {226, 136, 157, 0}}, + {-1,{0}}, +#line 1865 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str314), {226, 140, 182, 0}}, + {-1,{0}}, {-1,{0}}, +#line 749 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str317), {226, 136, 171, 0}}, + {-1,{0}}, +#line 1104 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str319), {226, 137, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1236 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str329), {226, 139, 160, 0}}, + {-1,{0}}, +#line 1446 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str331), {226, 170, 175, 0}}, +#line 508 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str332), {206, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1959 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str337), {207, 133, 0}}, +#line 1838 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str338), {226, 136, 180, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1522 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str342), {226, 166, 140, 0}}, +#line 1657 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str343), {226, 134, 152, 0}}, +#line 852 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str344), {226, 166, 139, 0}}, + {-1,{0}}, +#line 131 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str346), {226, 150, 180, 0}}, + {-1,{0}}, {-1,{0}}, +#line 959 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str349), {226, 170, 135, 0}}, + {-1,{0}}, {-1,{0}}, +#line 960 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str352), {226, 137, 168, 0}}, + {-1,{0}}, +#line 1417 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str354), {43, 0}}, +#line 1153 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str355), {226, 169, 189, 0}}, +#line 1105 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str356), {226, 137, 144, 0}}, +#line 133 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str357), {226, 151, 130, 0}}, +#line 134 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str358), {226, 150, 184, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1101 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str364), {226, 134, 151, 0}}, + {-1,{0}}, {-1,{0}}, +#line 132 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str367), {226, 150, 190, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1154 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str373), {226, 137, 174, 0}}, +#line 489 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str374), {196, 147, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2033 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str378), {226, 136, 157, 0}}, +#line 1933 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str379), {197, 171, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1700 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str383), {226, 167, 164, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1032 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str387), {226, 164, 133, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1419 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str390), {226, 168, 165, 0}}, +#line 1167 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str391), {226, 171, 172, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 2018 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str408), {226, 128, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1398 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str426), {226, 138, 165, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 560 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str430), {226, 150, 177, 0}}, +#line 1422 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str431), {194, 177, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1150 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str435), {226, 137, 176, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1151 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str438), {226, 137, 166, 0}}, + {-1,{0}}, +#line 578 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str440), {194, 190, 0}}, +#line 572 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str441), {194, 188, 0}}, +#line 2017 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str442), {124, 0}}, +#line 570 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str443), {194, 189, 0}}, +#line 579 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str444), {226, 133, 151, 0}}, +#line 573 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str445), {226, 133, 149, 0}}, +#line 581 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str446), {226, 133, 152, 0}}, + {-1,{0}}, {-1,{0}}, +#line 577 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str449), {226, 133, 150, 0}}, + {-1,{0}}, +#line 571 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str451), {226, 133, 147, 0}}, + {-1,{0}}, +#line 574 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str453), {226, 133, 153, 0}}, +#line 1465 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str454), {226, 138, 176, 0}}, +#line 576 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str455), {226, 133, 148, 0}}, +#line 580 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str456), {226, 133, 156, 0}}, +#line 575 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str457), {226, 133, 155, 0}}, +#line 582 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str458), {226, 133, 154, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 583 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str462), {226, 133, 157, 0}}, + {-1,{0}}, +#line 584 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str464), {226, 133, 158, 0}}, +#line 909 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str465), {226, 137, 164, 0}}, +#line 343 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str466), {226, 134, 147, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1960 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str469), {207, 146, 0}}, +#line 398 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str470), {203, 153, 0}}, +#line 1406 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str471), {226, 152, 142, 0}}, + {-1,{0}}, {-1,{0}}, +#line 218 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str474), {226, 139, 146, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 130 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str478), {226, 150, 170, 0}}, +#line 1599 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str479), {226, 171, 174, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 910 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str483), {226, 137, 166, 0}}, + {-1,{0}}, {-1,{0}}, +#line 748 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str486), {226, 138, 186, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 371 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str490), {226, 135, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1554 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str494), {226, 135, 129, 0}}, + {-1,{0}}, +#line 938 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str496), {226, 134, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1420 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str505), {226, 169, 178, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1932 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str511), {197, 170, 0}}, +#line 2014 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str512), {226, 139, 129, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1502 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str515), {226, 134, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 303 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str527), {226, 168, 175, 0}}, + {-1,{0}}, +#line 1619 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str529), {93, 0}}, + {-1,{0}}, +#line 1005 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str531), {91, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1509 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str538), {226, 164, 150, 0}}, + {-1,{0}}, {-1,{0}}, +#line 529 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str541), {226, 137, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2013 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str546), {226, 136, 168, 0}}, +#line 1088 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str547), {226, 137, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 947 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str553), {226, 140, 158, 0}}, +#line 569 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str554), {226, 168, 141, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1739 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str558), {226, 150, 170, 0}}, +#line 1413 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str559), {226, 132, 143, 0}}, + {-1,{0}}, {-1,{0}}, +#line 524 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str562), {226, 167, 165, 0}}, + {-1,{0}}, +#line 1929 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str564), {226, 140, 156, 0}}, + {-1,{0}}, +#line 2054 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str566), {226, 132, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 988 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str571), {226, 167, 171, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 298 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str575), {194, 169, 0}}, + {-1,{0}}, +#line 1928 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str577), {226, 140, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2012 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str582), {226, 138, 187, 0}}, + {-1,{0}}, +#line 1391 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str584), {226, 136, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1729 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str589), {226, 150, 161, 0}}, + {-1,{0}}, +#line 1087 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str591), {226, 137, 142, 0}}, +#line 107 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str592), {226, 132, 172, 0}}, +#line 2055 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str593), {226, 137, 128, 0}}, +#line 1517 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str594), {226, 164, 143, 0}}, +#line 992 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str595), {226, 140, 159, 0}}, +#line 848 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str596), {226, 164, 142, 0}}, + {-1,{0}}, {-1,{0}}, +#line 143 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str599), {226, 140, 144, 0}}, + {-1,{0}}, +#line 1661 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str601), {59, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1968 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str606), {226, 140, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1217 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str612), {226, 138, 130, 0}}, + {-1,{0}}, +#line 1604 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str614), {240, 157, 149, 163}}, +#line 1475 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str615), {226, 132, 154, 0}}, +#line 979 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str616), {240, 157, 149, 157}}, + {-1,{0}}, +#line 1712 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str618), {240, 157, 149, 164}}, +#line 1967 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str619), {226, 140, 157, 0}}, +#line 1868 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str620), {240, 157, 149, 139}}, +#line 2126 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str621), {226, 132, 164, 0}}, +#line 504 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str622), {240, 157, 149, 150}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1603 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str626), {226, 166, 134, 0}}, +#line 1944 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str627), {240, 157, 149, 166}}, +#line 977 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str628), {226, 166, 133, 0}}, +#line 1869 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str629), {240, 157, 149, 165}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2074 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str635), {240, 157, 149, 143}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1165 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str639), {240, 157, 149, 159}}, + {-1,{0}}, +#line 145 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str641), {240, 157, 149, 147}}, +#line 511 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str642), {207, 181, 0}}, +#line 561 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str643), {198, 146, 0}}, +#line 733 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str644), {196, 171, 0}}, + {-1,{0}}, {-1,{0}}, +#line 791 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str647), {240, 157, 149, 129}}, + {-1,{0}}, +#line 1134 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str649), {226, 171, 178, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2052 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str653), {240, 157, 149, 142}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1720 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str658), {226, 136, 154, 0}}, +#line 1262 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str659), {226, 138, 132, 0}}, + {-1,{0}}, +#line 1080 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str661), {226, 137, 139, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1223 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str664), {226, 138, 131, 0}}, + {-1,{0}}, {-1,{0}}, +#line 196 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str667), {194, 166, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1710 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str670), {47, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 460 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str675), {226, 169, 174, 0}}, + {-1,{0}}, +#line 1428 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str677), {240, 157, 149, 161}}, + {-1,{0}}, {-1,{0}}, +#line 369 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str680), {226, 165, 165, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2031 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str685), {240, 157, 149, 141}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1273 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str690), {226, 138, 131, 0}}, +#line 1270 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str691), {226, 138, 133, 0}}, +#line 2002 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str692), {226, 171, 168, 0}}, + {-1,{0}}, +#line 1265 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str694), {226, 138, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1850 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str700), {226, 137, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1136 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str704), {226, 139, 188, 0}}, +#line 1459 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str705), {226, 140, 147, 0}}, +#line 1709 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str706), {226, 167, 132, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 961 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str710), {226, 139, 166, 0}}, + {-1,{0}}, +#line 1708 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str712), {226, 140, 191, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1730 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str717), {226, 150, 161, 0}}, + {-1,{0}}, +#line 2032 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str719), {240, 157, 149, 167}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1925 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str723), {226, 134, 191, 0}}, + {-1,{0}}, +#line 1930 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str725), {226, 140, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 514 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str729), {226, 137, 130, 0}}, +#line 522 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str730), {226, 137, 161, 0}}, + {-1,{0}}, {-1,{0}}, +#line 485 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str733), {226, 132, 147, 0}}, +#line 1699 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str734), {226, 168, 179, 0}}, +#line 1066 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str735), {226, 136, 147, 0}}, + {-1,{0}}, {-1,{0}}, +#line 813 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str738), {240, 157, 149, 130}}, + {-1,{0}}, {-1,{0}}, +#line 1695 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str741), {226, 165, 178, 0}}, + {-1,{0}}, +#line 558 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str743), {226, 153, 173, 0}}, + {-1,{0}}, +#line 1064 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str745), {240, 157, 149, 132}}, +#line 1711 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str746), {240, 157, 149, 138}}, +#line 1061 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str747), {226, 128, 166, 0}}, +#line 1596 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str748), {226, 128, 143, 0}}, +#line 767 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str749), {226, 168, 188, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 990 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str756), {226, 166, 147, 0}}, + {-1,{0}}, +#line 563 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str758), {240, 157, 149, 151}}, +#line 1943 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str759), {240, 157, 149, 140}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1995 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str763), {226, 138, 138, 0}}, +#line 1996 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str764), {226, 171, 139, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1969 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str767), {226, 140, 142, 0}}, +#line 927 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str768), {226, 170, 161, 0}}, + {-1,{0}}, +#line 1542 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str770), {226, 132, 156, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1201 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str773), {226, 170, 161, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 395 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str777), {240, 157, 148, 187}}, + {-1,{0}}, +#line 567 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str779), {226, 171, 153, 0}}, + {-1,{0}}, +#line 1260 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str781), {226, 139, 162, 0}}, + {-1,{0}}, +#line 1272 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str783), {226, 138, 137, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1264 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str787), {226, 138, 136, 0}}, +#line 1474 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str788), {240, 157, 149, 162}}, +#line 1595 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str789), {226, 135, 140, 0}}, + {-1,{0}}, {-1,{0}}, +#line 995 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str792), {226, 128, 142, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1156 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str796), {226, 137, 180, 0}}, + {-1,{0}}, +#line 1430 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str798), {194, 163, 0}}, +#line 1997 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str799), {226, 138, 139, 0}}, +#line 1998 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str800), {226, 171, 140, 0}}, + {-1,{0}}, +#line 141 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str802), {226, 137, 161, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 978 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str813), {240, 157, 149, 131}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1261 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str817), {226, 139, 163, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1506 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str820), {226, 134, 172, 0}}, +#line 2045 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str821), {226, 169, 159, 0}}, +#line 838 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str822), {226, 134, 171, 0}}, + {-1,{0}}, +#line 2100 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str824), {240, 157, 149, 144}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1209 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str829), {226, 136, 140, 0}}, + {-1,{0}}, {-1,{0}}, +#line 294 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str832), {226, 132, 130, 0}}, +#line 993 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str833), {226, 135, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1390 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str848), {226, 171, 189, 0}}, +#line 1934 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str849), {194, 168, 0}}, +#line 1038 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str850), {226, 150, 174, 0}}, +#line 1274 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str851), {226, 138, 137, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1266 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str855), {226, 138, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1737 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str861), {226, 150, 170, 0}}, +#line 2020 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str862), {226, 128, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1735 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str874), {226, 138, 146, 0}}, + {-1,{0}}, +#line 1464 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str876), {226, 137, 190, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1733 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str879), {226, 138, 145, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1734 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str882), {226, 138, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1732 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str887), {226, 138, 143, 0}}, +#line 1289 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str888), {226, 137, 141, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 764 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str892), {240, 157, 149, 154}}, + {-1,{0}}, +#line 1425 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str894), {194, 177, 0}}, + {-1,{0}}, +#line 2019 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str896), {124, 0}}, + {-1,{0}}, +#line 1844 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str898), {207, 145, 0}}, + {-1,{0}}, {-1,{0}}, +#line 986 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str901), {226, 151, 138, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1033 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str905), {226, 134, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 922 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str920), {226, 170, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1615 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str934), {240, 157, 147, 135}}, +#line 1477 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str935), {240, 157, 146, 172}}, +#line 998 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str936), {240, 157, 147, 129}}, + {-1,{0}}, +#line 1742 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str938), {240, 157, 147, 136}}, + {-1,{0}}, +#line 1890 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str940), {240, 157, 146, 175}}, +#line 2127 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str941), {240, 157, 146, 181}}, +#line 527 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str942), {226, 132, 175, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1974 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str947), {240, 157, 147, 138}}, + {-1,{0}}, +#line 1891 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str949), {240, 157, 147, 137}}, + {-1,{0}}, +#line 740 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str951), {226, 138, 183, 0}}, +#line 296 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str952), {226, 136, 144, 0}}, + {-1,{0}}, {-1,{0}}, +#line 2080 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str955), {240, 157, 146, 179}}, +#line 2067 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str956), {206, 158, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1252 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str959), {240, 157, 147, 131}}, +#line 1135 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str960), {226, 136, 139, 0}}, +#line 197 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str961), {240, 157, 146, 183}}, +#line 1166 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str962), {226, 132, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 793 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str967), {240, 157, 146, 165}}, +#line 1442 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str968), {226, 170, 175, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1302 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str971), {226, 164, 131, 0}}, +#line 87 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str972), {226, 128, 181, 0}}, +#line 2057 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str973), {240, 157, 146, 178}}, + {-1,{0}}, +#line 1988 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str975), {207, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1258 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str984), {226, 136, 164, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 392 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str991), {226, 140, 158, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1467 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str997), {240, 157, 147, 133}}, +#line 1408 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str998), {207, 128, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 2035 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1005), {240, 157, 146, 177}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1112 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1011), {226, 137, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1693 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1021), {226, 137, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1275 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1028), {226, 171, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1267 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1032), {226, 171, 133, 0}}, +#line 440 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1033), {226, 140, 159, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1520 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1038), {125, 0}}, +#line 2036 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1039), {240, 157, 147, 139}}, +#line 850 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1040), {123, 0}}, +#line 396 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1041), {240, 157, 149, 149}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 585 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1049), {226, 129, 132, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 930 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1055), {226, 137, 178, 0}}, + {-1,{0}}, {-1,{0}}, +#line 815 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1058), {240, 157, 146, 166}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1416 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1064), {226, 168, 162, 0}}, +#line 1068 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1065), {226, 132, 179, 0}}, +#line 1741 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1066), {240, 157, 146, 174}}, +#line 1523 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1067), {226, 166, 142, 0}}, + {-1,{0}}, +#line 853 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1069), {226, 166, 143, 0}}, +#line 1518 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1070), {226, 164, 144, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1717 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1073), {226, 138, 147, 0}}, +#line 1503 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1074), {226, 135, 146, 0}}, +#line 142 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1075), {226, 171, 173, 0}}, +#line 835 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1076), {226, 135, 144, 0}}, + {-1,{0}}, +#line 587 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1078), {240, 157, 146, 187}}, +#line 1973 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1079), {240, 157, 146, 176}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1905 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1087), {226, 135, 145, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1605 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1090), {226, 132, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2053 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1094), {240, 157, 149, 168}}, + {-1,{0}}, {-1,{0}}, +#line 442 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1097), {240, 157, 146, 159}}, +#line 1351 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1098), {226, 166, 183, 0}}, +#line 1662 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1099), {226, 164, 169, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 362 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1103), {226, 136, 135, 0}}, +#line 1485 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1104), {226, 135, 155, 0}}, +#line 1558 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1105), {207, 129, 0}}, +#line 817 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1106), {226, 135, 154, 0}}, +#line 1437 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1107), {226, 137, 188, 0}}, +#line 1478 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1108), {240, 157, 147, 134}}, + {-1,{0}}, {-1,{0}}, +#line 1028 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1111), {194, 175, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1185 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1115), {226, 136, 137, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 523 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1120), {226, 169, 184, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1716 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1125), {226, 138, 147, 0}}, + {-1,{0}}, +#line 1259 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1127), {226, 136, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1340 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1131), {226, 167, 128, 0}}, +#line 1514 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1132), {226, 136, 182, 0}}, +#line 999 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1133), {226, 132, 146, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 370 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1137), {226, 135, 131, 0}}, + {-1,{0}}, +#line 393 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1139), {226, 140, 141, 0}}, +#line 408 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1140), {194, 168, 0}}, +#line 404 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1141), {226, 136, 148, 0}}, +#line 1358 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1142), {226, 136, 168, 0}}, + {-1,{0}}, +#line 2102 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1144), {240, 157, 146, 180}}, + {-1,{0}}, {-1,{0}}, +#line 562 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1147), {240, 157, 148, 189}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 304 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1152), {240, 157, 146, 158}}, +#line 1336 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1153), {226, 134, 186, 0}}, +#line 1243 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1154), {226, 134, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1026 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1159), {226, 137, 168, 0}}, +#line 515 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1160), {226, 170, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1853 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1164), {195, 190, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 516 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1169), {226, 170, 149, 0}}, + {-1,{0}}, {-1,{0}}, +#line 743 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1172), {226, 132, 133, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1992 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1179), {226, 135, 149, 0}}, +#line 1611 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1180), {226, 168, 146, 0}}, +#line 441 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1181), {226, 140, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1387 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1187), {226, 136, 165, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1356 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1195), {226, 134, 187, 0}}, +#line 1744 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1196), {226, 140, 163, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 412 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1200), {226, 171, 164, 0}}, +#line 526 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1201), {226, 137, 147, 0}}, +#line 381 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1202), {226, 153, 166, 0}}, +#line 1743 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1203), {226, 136, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1368 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1208), {226, 147, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 769 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1212), {240, 157, 146, 190}}, +#line 725 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1213), {226, 133, 136, 0}}, +#line 1543 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1214), {226, 150, 173, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1249 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1217), {226, 139, 161, 0}}, +#line 1660 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1218), {194, 167, 0}}, + {-1,{0}}, +#line 1060 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1220), {226, 171, 155, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1365 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1224), {226, 169, 150, 0}}, + {-1,{0}}, +#line 407 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1226), {226, 136, 175, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 518 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1230), {61, 0}}, + {-1,{0}}, +#line 679 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1232), {94, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1745 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1236), {226, 139, 134, 0}}, +#line 1069 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1237), {226, 136, 190, 0}}, + {-1,{0}}, +#line 382 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1239), {194, 168, 0}}, +#line 1044 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1240), {226, 136, 161, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 564 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1252), {226, 136, 128, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1189 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1255), {226, 139, 183, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1065 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1263), {240, 157, 149, 158}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1138 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1270), {226, 136, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2004 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1280), {226, 171, 169, 0}}, + {-1,{0}}, +#line 1251 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1282), {240, 157, 146, 169}}, + {-1,{0}}, +#line 1396 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1284), {46, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 102 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1292), {226, 136, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 112 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1298), {226, 137, 172, 0}}, +#line 750 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1299), {226, 136, 172, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 103 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1307), {226, 136, 181, 0}}, +#line 1410 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1308), {207, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1551 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1326), {240, 157, 148, 175}}, +#line 1471 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1327), {240, 157, 148, 148}}, +#line 934 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1328), {240, 157, 148, 169}}, + {-1,{0}}, +#line 1667 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1330), {240, 157, 148, 176}}, +#line 1148 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1331), {226, 134, 174, 0}}, +#line 1836 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1332), {240, 157, 148, 151}}, +#line 2121 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1333), {226, 132, 168, 0}}, +#line 476 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1334), {240, 157, 148, 162}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1685 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1338), {226, 136, 188, 0}}, +#line 1921 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1339), {240, 157, 148, 178}}, +#line 1606 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1340), {226, 168, 174, 0}}, +#line 1837 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1341), {240, 157, 148, 177}}, +#line 980 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1342), {226, 168, 173, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2063 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1347), {240, 157, 148, 155}}, + {-1,{0}}, {-1,{0}}, +#line 1538 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1350), {226, 132, 156, 0}}, +#line 1119 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1351), {240, 157, 148, 171}}, + {-1,{0}}, +#line 114 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1353), {240, 157, 148, 159}}, + {-1,{0}}, +#line 1184 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1355), {226, 137, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 788 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1359), {240, 157, 148, 141}}, + {-1,{0}}, +#line 443 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1361), {240, 157, 146, 185}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2050 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1365), {240, 157, 148, 154}}, + {-1,{0}}, +#line 129 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1367), {226, 167, 171, 0}}, + {-1,{0}}, +#line 2125 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1369), {240, 157, 149, 171}}, +#line 1541 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1370), {226, 132, 157, 0}}, + {-1,{0}}, +#line 1170 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1372), {226, 137, 173, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1694 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1375), {226, 168, 164, 0}}, + {-1,{0}}, +#line 565 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1377), {226, 136, 128, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1401 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1389), {240, 157, 148, 173}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1342 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1395), {197, 141, 0}}, + {-1,{0}}, +#line 2026 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1397), {240, 157, 148, 153}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 488 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1409), {196, 146, 0}}, +#line 1616 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1410), {226, 132, 155, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2058 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1414), {240, 157, 147, 140}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1679 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1423), {226, 134, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1664 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1429), {226, 136, 150, 0}}, + {-1,{0}}, +#line 2027 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1431), {240, 157, 148, 179}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 806 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1450), {240, 157, 148, 142}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1354 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1455), {226, 166, 185, 0}}, + {-1,{0}}, +#line 1047 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1457), {240, 157, 148, 144}}, +#line 1666 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1458), {240, 157, 148, 150}}, + {-1,{0}}, {-1,{0}}, +#line 1160 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1461), {226, 139, 172, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 588 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1467), {226, 132, 177, 0}}, + {-1,{0}}, {-1,{0}}, +#line 553 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1470), {240, 157, 148, 163}}, +#line 1920 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1471), {240, 157, 148, 152}}, + {-1,{0}}, +#line 1676 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1473), {226, 136, 163, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1304 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1488), {226, 136, 188, 0}}, +#line 367 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1489), {240, 157, 148, 135}}, +#line 920 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1490), {226, 139, 150, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1458 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1493), {226, 140, 146, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1472 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1500), {240, 157, 148, 174}}, +#line 345 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1501), {226, 135, 147, 0}}, + {-1,{0}}, +#line 1247 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1503), {226, 139, 173, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1678 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1507), {226, 134, 146, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1840 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1515), {226, 136, 180, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 357 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1519), {226, 133, 133, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1839 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1524), {226, 136, 180, 0}}, +#line 933 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1525), {240, 157, 148, 143}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1824 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1532), {226, 140, 150, 0}}, + {-1,{0}}, {-1,{0}}, +#line 483 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1535), {226, 136, 136, 0}}, +#line 2096 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1536), {240, 157, 148, 156}}, +#line 271 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1537), {226, 136, 178, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1337 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1542), {226, 166, 190, 0}}, + {-1,{0}}, +#line 245 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1544), {226, 132, 173, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 548 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1559), {226, 153, 128, 0}}, +#line 1269 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1560), {226, 170, 176, 0}}, +#line 1312 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1561), {226, 138, 155, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1395 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1568), {37, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1362 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1578), {194, 170, 0}}, + {-1,{0}}, +#line 1359 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1580), {226, 169, 157, 0}}, +#line 1557 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1581), {206, 161, 0}}, + {-1,{0}}, +#line 1067 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1583), {240, 157, 147, 130}}, + {-1,{0}}, +#line 1303 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1585), {226, 138, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 958 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1589), {226, 137, 168, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1133 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1597), {226, 135, 142, 0}}, +#line 1357 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1598), {226, 169, 148, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 387 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1602), {195, 183, 0}}, + {-1,{0}}, +#line 721 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1604), {240, 157, 148, 166}}, +#line 484 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1605), {226, 143, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 203 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1615), {92, 0}}, +#line 1298 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1616), {226, 164, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 732 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1626), {196, 170, 0}}, + {-1,{0}}, +#line 89 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1628), {226, 139, 141, 0}}, +#line 1898 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1629), {226, 137, 172, 0}}, +#line 1338 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1630), {226, 166, 187, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1508 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1639), {226, 165, 180, 0}}, +#line 409 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1640), {226, 135, 147, 0}}, +#line 840 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1641), {226, 165, 179, 0}}, +#line 491 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1642), {226, 136, 133, 0}}, +#line 1350 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1643), {240, 157, 149, 160}}, + {-1,{0}}, +#line 540 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1645), {226, 136, 131, 0}}, + {-1,{0}}, {-1,{0}}, +#line 949 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1648), {226, 165, 171, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 539 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1656), {33, 0}}, +#line 503 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1657), {240, 157, 148, 188}}, +#line 1142 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1658), {226, 135, 141, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1849 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1663), {226, 128, 137, 0}}, +#line 1218 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1664), {226, 138, 136, 0}}, +#line 1403 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1665), {207, 134, 0}}, +#line 410 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1666), {226, 135, 144, 0}}, + {-1,{0}}, +#line 1866 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1668), {226, 171, 177, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 386 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1672), {195, 183, 0}}, + {-1,{0}}, +#line 1118 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1674), {240, 157, 148, 145}}, +#line 1144 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1675), {226, 137, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2128 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1689), {240, 157, 147, 143}}, +#line 994 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1690), {226, 165, 173, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 950 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1697), {226, 151, 186, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1242 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1700), {226, 135, 143, 0}}, +#line 1224 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1701), {226, 138, 137, 0}}, + {-1,{0}}, +#line 1819 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1703), {226, 135, 153, 0}}, +#line 1847 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1704), {226, 129, 159, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1931 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1708), {226, 151, 184, 0}}, +#line 1204 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1709), {226, 139, 190, 0}}, + {-1,{0}}, +#line 1449 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1711), {226, 128, 178, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1451 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1714), {226, 132, 153, 0}}, + {-1,{0}}, +#line 1334 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1716), {206, 169, 0}}, + {-1,{0}}, {-1,{0}}, +#line 264 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1719), {226, 138, 151, 0}}, +#line 1159 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1720), {226, 139, 170, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1691 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1723), {226, 170, 157, 0}}, +#line 1307 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1724), {226, 135, 150, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1989 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1727), {207, 150, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1367 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1730), {226, 169, 155, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1663 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1735), {226, 136, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 996 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1739), {226, 138, 191, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1397 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1743), {226, 128, 176, 0}}, +#line 1053 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1744), {226, 136, 163, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1972 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1750), {226, 151, 185, 0}}, + {-1,{0}}, {-1,{0}}, +#line 368 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1753), {240, 157, 148, 161}}, +#line 1049 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1754), {226, 132, 167, 0}}, +#line 1447 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1755), {226, 170, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2040 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1759), {226, 138, 139, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1246 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1762), {226, 139, 171, 0}}, +#line 2038 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1763), {226, 138, 138, 0}}, + {-1,{0}}, +#line 472 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1765), {226, 137, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 918 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1778), {226, 170, 147, 0}}, + {-1,{0}}, {-1,{0}}, +#line 86 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1781), {207, 182, 0}}, + {-1,{0}}, +#line 1512 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1783), {226, 164, 154, 0}}, + {-1,{0}}, +#line 842 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1785), {226, 164, 153, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1953 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1788), {226, 165, 174, 0}}, + {-1,{0}}, {-1,{0}}, +#line 510 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1791), {206, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1963 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1796), {207, 133, 0}}, + {-1,{0}}, +#line 1051 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1798), {42, 0}}, +#line 697 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1799), {226, 132, 141, 0}}, +#line 2028 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1800), {226, 138, 178, 0}}, + {-1,{0}}, +#line 1552 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1802), {226, 132, 156, 0}}, + {-1,{0}}, {-1,{0}}, +#line 2047 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1805), {226, 139, 128, 0}}, +#line 2051 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1806), {240, 157, 148, 180}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 93 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1812), {226, 140, 133, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1030 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1815), {226, 156, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 250 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1820), {206, 167, 0}}, +#line 493 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1821), {226, 136, 133, 0}}, +#line 1202 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1822), {226, 136, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 925 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1827), {226, 137, 182, 0}}, + {-1,{0}}, +#line 377 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1829), {226, 139, 132, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 2034 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1842), {226, 138, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 262 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1849), {226, 138, 150, 0}}, + {-1,{0}}, +#line 1341 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1851), {197, 140, 0}}, +#line 1658 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1852), {226, 135, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 552 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1859), {240, 157, 148, 137}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1444 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1865), {226, 170, 181, 0}}, + {-1,{0}}, +#line 379 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1867), {226, 139, 132, 0}}, +#line 1363 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1868), {194, 186, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1102 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1873), {226, 135, 151, 0}}, +#line 763 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1874), {240, 157, 149, 128}}, +#line 259 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1875), {226, 138, 153, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1452 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1878), {226, 170, 185, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 403 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1884), {226, 136, 184, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1253 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1903), {226, 136, 164, 0}}, + {-1,{0}}, +#line 147 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1905), {226, 138, 165, 0}}, + {-1,{0}}, +#line 1427 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1907), {226, 168, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1736 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1917), {226, 138, 148, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 792 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1925), {240, 157, 149, 155}}, + {-1,{0}}, {-1,{0}}, +#line 1962 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1928), {206, 165, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 278 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1936), {226, 169, 180, 0}}, + {-1,{0}}, +#line 1300 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1938), {60, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1114 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1941), {226, 137, 170, 0}}, +#line 277 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1942), {226, 136, 183, 0}}, + {-1,{0}}, {-1,{0}}, +#line 204 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1945), {226, 159, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 411 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1949), {226, 135, 148, 0}}, +#line 1423 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1950), {226, 168, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 734 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1959), {226, 132, 145, 0}}, +#line 480 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1960), {226, 170, 150, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1370 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1963), {226, 132, 180, 0}}, +#line 1821 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1964), {226, 164, 170, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2116 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1969), {226, 132, 168, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1031 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1973), {226, 156, 160, 0}}, + {-1,{0}}, +#line 1048 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1975), {240, 157, 148, 170}}, +#line 1504 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1976), {226, 164, 158, 0}}, +#line 528 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1977), {226, 132, 176, 0}}, +#line 836 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1978), {226, 164, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1062 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1985), {226, 136, 147, 0}}, +#line 1129 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1986), {226, 137, 175, 0}}, +#line 1130 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1987), {226, 137, 175, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 627 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1996), {226, 137, 183, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 380 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2003), {226, 153, 166, 0}}, +#line 655 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2004), {62, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 928 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2014), {226, 137, 178, 0}}, +#line 446 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2015), {226, 167, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1954 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2023), {226, 134, 191, 0}}, +#line 1731 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2024), {226, 138, 147, 0}}, +#line 1003 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2025), {226, 170, 141, 0}}, + {-1,{0}}, +#line 1157 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2027), {226, 137, 170, 0}}, + {-1,{0}}, +#line 1194 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2029), {226, 137, 174, 0}}, + {-1,{0}}, +#line 630 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2031), {226, 170, 138, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1634 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2035), {226, 170, 184, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1036 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2038), {226, 134, 164, 0}}, +#line 1197 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2039), {226, 137, 170, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1550 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2043), {226, 140, 139, 0}}, + {-1,{0}}, +#line 932 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2045), {226, 140, 138, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1256 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2048), {226, 137, 132, 0}}, + {-1,{0}}, +#line 201 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2050), {226, 139, 141, 0}}, +#line 1195 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2051), {226, 137, 176, 0}}, +#line 1199 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2052), {226, 137, 180, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1089 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2056), {226, 169, 131, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1196 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2059), {226, 137, 184, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1448 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2070), {226, 137, 190, 0}}, + {-1,{0}}, +#line 976 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2072), {226, 134, 172, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1432 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2076), {226, 170, 187, 0}}, +#line 1530 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2077), {125, 0}}, +#line 1037 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2078), {226, 134, 165, 0}}, +#line 860 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2079), {123, 0}}, + {-1,{0}}, +#line 2120 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2081), {240, 157, 148, 183}}, + {-1,{0}}, {-1,{0}}, +#line 1946 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2084), {226, 134, 145, 0}}, + {-1,{0}}, +#line 632 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2086), {226, 170, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1640 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2090), {226, 170, 176, 0}}, +#line 739 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2091), {226, 132, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1526 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2096), {197, 153, 0}}, + {-1,{0}}, +#line 856 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2098), {196, 190, 0}}, +#line 1349 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2099), {240, 157, 149, 134}}, +#line 1636 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2100), {197, 161, 0}}, +#line 88 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2101), {226, 136, 189, 0}}, +#line 1828 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2102), {197, 164, 0}}, +#line 2110 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2103), {197, 189, 0}}, +#line 462 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2104), {196, 155, 0}}, + {-1,{0}}, +#line 108 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2106), {226, 132, 172, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1121 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2110), {226, 137, 177, 0}}, +#line 1829 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2111), {197, 165, 0}}, + {-1,{0}}, +#line 566 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2113), {226, 139, 148, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 701 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2119), {226, 132, 139, 0}}, + {-1,{0}}, +#line 1091 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2121), {197, 136, 0}}, +#line 487 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2122), {226, 170, 151, 0}}, + {-1,{0}}, +#line 1827 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2124), {226, 142, 180, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1886 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2128), {226, 168, 185, 0}}, + {-1,{0}}, {-1,{0}}, +#line 378 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2131), {226, 139, 132, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1096 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2134), {226, 169, 130, 0}}, + {-1,{0}}, +#line 96 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2136), {226, 142, 181, 0}}, + {-1,{0}}, +#line 586 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2138), {226, 140, 162, 0}}, +#line 128 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2139), {226, 164, 141, 0}}, + {-1,{0}}, +#line 1713 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2141), {226, 153, 160, 0}}, + {-1,{0}}, +#line 1469 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2143), {207, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 144 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2150), {240, 157, 148, 185}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 394 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2156), {36, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 385 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2164), {226, 139, 178, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1714 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2170), {226, 153, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1225 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2176), {226, 137, 129, 0}}, +#line 406 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2177), {226, 140, 134, 0}}, + {-1,{0}}, +#line 594 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2179), {226, 170, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 97 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2186), {226, 142, 182, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1820 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2189), {226, 134, 153, 0}}, +#line 106 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2190), {207, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 770 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2194), {226, 132, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1227 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2198), {226, 137, 135, 0}}, +#line 513 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2199), {226, 137, 149, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1863 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2202), {226, 136, 173, 0}}, + {-1,{0}}, {-1,{0}}, +#line 756 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2205), {226, 168, 188, 0}}, + {-1,{0}}, +#line 1271 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2207), {226, 171, 134, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1308 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2210), {226, 134, 150, 0}}, +#line 1263 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2211), {226, 171, 133, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1125 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2214), {226, 169, 190, 0}}, + {-1,{0}}, +#line 1948 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2216), {226, 135, 145, 0}}, +#line 604 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2217), {226, 137, 165, 0}}, +#line 1352 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2218), {226, 128, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1698 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2223), {226, 136, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1635 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2228), {197, 160, 0}}, + {-1,{0}}, +#line 1301 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2230), {226, 138, 180, 0}}, +#line 612 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2231), {226, 169, 190, 0}}, +#line 135 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2232), {226, 144, 163, 0}}, +#line 1484 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2233), {34, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 139 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2238), {226, 150, 136, 0}}, +#line 1873 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2239), {226, 132, 162, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 794 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2245), {240, 157, 146, 191}}, +#line 2046 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2246), {226, 136, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 29 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2254), {196, 128, 0}}, + {-1,{0}}, +#line 517 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2256), {226, 169, 181, 0}}, + {-1,{0}}, {-1,{0}}, +#line 351 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2259), {196, 142, 0}}, + {-1,{0}}, {-1,{0}}, +#line 399 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2262), {226, 131, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 634 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2270), {226, 170, 136, 0}}, +#line 1990 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2271), {226, 136, 157, 0}}, + {-1,{0}}, +#line 635 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2273), {226, 137, 169, 0}}, +#line 1461 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2274), {226, 136, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 774 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2279), {226, 139, 180, 0}}, + {-1,{0}}, +#line 469 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2281), {226, 169, 183, 0}}, +#line 771 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2282), {226, 136, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1885 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2286), {226, 131, 155, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 568 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2290), {226, 132, 177, 0}}, +#line 1462 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2291), {226, 136, 183, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1122 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2294), {226, 137, 177, 0}}, +#line 855 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2295), {196, 189, 0}}, + {-1,{0}}, +#line 1123 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2297), {226, 137, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 870 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2313), {226, 137, 166, 0}}, +#line 227 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2314), {196, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 199 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2320), {226, 129, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1463 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2326), {226, 136, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 914 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2331), {226, 169, 191, 0}}, +#line 291 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2332), {226, 136, 175, 0}}, + {-1,{0}}, +#line 35 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2334), {226, 169, 147, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1659 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2338), {226, 134, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1366 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2343), {226, 169, 151, 0}}, +#line 676 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2344), {226, 134, 148, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 845 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2350), {226, 170, 173, 0}}, + {-1,{0}}, +#line 243 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2352), {194, 183, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1328 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2355), {240, 157, 148, 172}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1103 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2359), {226, 134, 151, 0}}, + {-1,{0}}, +#line 1473 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2361), {226, 168, 140, 0}}, + {-1,{0}}, {-1,{0}}, +#line 846 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2364), {226, 170, 173, 0}}, +#line 801 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2365), {207, 176, 0}}, + {-1,{0}}, {-1,{0}}, +#line 698 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2368), {226, 128, 149, 0}}, +#line 475 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2369), {240, 157, 148, 136}}, +#line 692 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2370), {226, 135, 191, 0}}, +#line 1239 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2371), {226, 170, 175, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 747 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2377), {196, 177, 0}}, + {-1,{0}}, +#line 1915 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2379), {226, 135, 133, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 608 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2386), {226, 137, 165, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1257 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2391), {226, 137, 132, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 609 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2404), {226, 137, 167, 0}}, + {-1,{0}}, {-1,{0}}, +#line 474 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2407), {226, 137, 146, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1610 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2410), {226, 166, 148, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1369 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2419), {240, 157, 146, 170}}, + {-1,{0}}, {-1,{0}}, +#line 1418 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2422), {226, 136, 148, 0}}, + {-1,{0}}, {-1,{0}}, +#line 821 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2425), {226, 132, 146, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1846 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2429), {226, 136, 188, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1445 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2440), {226, 139, 168, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1090 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2444), {197, 135, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1079 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2449), {226, 169, 176, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 727 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2457), {226, 136, 173, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 198 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2470), {226, 132, 172, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1035 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2483), {226, 134, 167, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1993 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2486), {207, 177, 0}}, + {-1,{0}}, +#line 775 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2488), {226, 139, 179, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1296 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2491), {226, 164, 132, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1191 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2494), {226, 167, 143, 0}}, + {-1,{0}}, +#line 520 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2496), {226, 137, 159, 0}}, + {-1,{0}}, +#line 1193 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2498), {226, 139, 172, 0}}, +#line 1192 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2499), {226, 139, 170, 0}}, + {-1,{0}}, {-1,{0}}, +#line 60 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2502), {240, 157, 148, 184}}, +#line 680 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2503), {226, 132, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1984 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2507), {226, 166, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 688 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2511), {226, 132, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1494 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2517), {226, 166, 165, 0}}, +#line 1704 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2518), {226, 170, 172, 0}}, +#line 1002 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2519), {226, 137, 178, 0}}, + {-1,{0}}, +#line 1234 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2521), {226, 168, 148, 0}}, + {-1,{0}}, +#line 352 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2523), {196, 143, 0}}, + {-1,{0}}, +#line 531 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2525), {226, 137, 130, 0}}, + {-1,{0}}, +#line 1939 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2527), {226, 139, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1705 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2532), {226, 170, 172, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 814 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2536), {240, 157, 149, 156}}, +#line 638 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2537), {240, 157, 149, 152}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1255 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2542), {226, 137, 129, 0}}, + {-1,{0}}, +#line 200 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2544), {226, 136, 189, 0}}, + {-1,{0}}, +#line 1697 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2546), {226, 136, 152, 0}}, + {-1,{0}}, +#line 1171 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2548), {226, 136, 166, 0}}, +#line 1200 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2549), {226, 170, 162, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 519 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2565), {226, 137, 130, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1186 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2568), {226, 139, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1525 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2572), {197, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1429 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2577), {226, 132, 153, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 637 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2583), {240, 157, 148, 190}}, + {-1,{0}}, {-1,{0}}, +#line 722 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2586), {226, 132, 145, 0}}, + {-1,{0}}, {-1,{0}}, +#line 2048 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2589), {226, 137, 153, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1455 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2595), {226, 136, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1373 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2617), {226, 138, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 418 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2624), {226, 135, 145, 0}}, + {-1,{0}}, {-1,{0}}, +#line 289 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2627), {226, 137, 161, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 636 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2631), {226, 139, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1650 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2635), {226, 137, 191, 0}}, + {-1,{0}}, +#line 789 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2637), {240, 157, 148, 167}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1961 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2645), {207, 146, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1155 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2650), {226, 139, 152, 0}}, + {-1,{0}}, {-1,{0}}, +#line 419 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2653), {226, 135, 149, 0}}, + {-1,{0}}, +#line 1127 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2655), {226, 137, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 683 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2664), {226, 153, 165, 0}}, + {-1,{0}}, +#line 921 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2666), {226, 139, 154, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1111 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2670), {226, 164, 168, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 541 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2676), {226, 136, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1702 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2687), {226, 140, 163, 0}}, + {-1,{0}}, +#line 1983 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2689), {226, 166, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 684 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2693), {226, 153, 165, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 699 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2700), {226, 148, 128, 0}}, + {-1,{0}}, {-1,{0}}, +#line 644 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2703), {226, 137, 183, 0}}, + {-1,{0}}, +#line 1614 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2705), {226, 128, 186, 0}}, + {-1,{0}}, +#line 997 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2707), {226, 128, 185, 0}}, + {-1,{0}}, +#line 1539 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2709), {226, 132, 155, 0}}, +#line 347 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2710), {226, 171, 164, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1686 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2714), {226, 169, 170, 0}}, +#line 640 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2715), {226, 137, 165, 0}}, +#line 646 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2716), {226, 137, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 641 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2721), {226, 139, 155, 0}}, + {-1,{0}}, +#line 643 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2723), {226, 170, 162, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1529 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2737), {226, 140, 137, 0}}, + {-1,{0}}, +#line 859 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2739), {226, 140, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 926 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2743), {226, 137, 182, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1339 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2746), {226, 128, 190, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1851 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2753), {226, 136, 188, 0}}, + {-1,{0}}, +#line 758 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2755), {226, 129, 162, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1486 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2762), {226, 136, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 768 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2766), {194, 191, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 736 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2774), {226, 132, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1965 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2779), {226, 138, 165, 0}}, + {-1,{0}}, +#line 1052 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2781), {226, 171, 176, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1326 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2790), {226, 166, 191, 0}}, + {-1,{0}}, {-1,{0}}, +#line 356 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2793), {226, 135, 138, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1493 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2800), {226, 166, 146, 0}}, + {-1,{0}}, +#line 826 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2802), {226, 166, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 521 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2808), {226, 135, 140, 0}}, +#line 1389 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2809), {226, 171, 179, 0}}, +#line 2011 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2810), {226, 171, 166, 0}}, +#line 1327 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2811), {240, 157, 148, 146}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 104 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2816), {226, 136, 181, 0}}, + {-1,{0}}, +#line 1513 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2818), {226, 164, 156, 0}}, + {-1,{0}}, +#line 843 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2820), {226, 164, 155, 0}}, +#line 1348 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2821), {226, 138, 150, 0}}, +#line 73 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2822), {240, 157, 146, 156}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 509 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2826), {206, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1675 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2832), {226, 134, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 776 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2845), {226, 136, 136, 0}}, + {-1,{0}}, +#line 1050 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2847), {194, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2111 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2851), {197, 190, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 816 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2856), {240, 157, 147, 128}}, +#line 648 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2857), {226, 132, 138, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 113 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2862), {240, 157, 148, 133}}, +#line 607 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2863), {226, 139, 155, 0}}, +#line 686 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2864), {226, 138, 185, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1884 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2871), {226, 168, 186, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 479 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2877), {195, 168, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1654 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2881), {226, 139, 133, 0}}, +#line 1923 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2882), {195, 185, 0}}, + {-1,{0}}, +#line 2114 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2884), {197, 187, 0}}, +#line 471 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2885), {196, 151, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1228 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2890), {226, 137, 137, 0}}, + {-1,{0}}, +#line 1834 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2892), {226, 131, 155, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1466 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2897), {240, 157, 146, 171}}, +#line 1407 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2898), {206, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 647 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2903), {240, 157, 146, 162}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1424 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2910), {226, 168, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1172 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2914), {226, 136, 137, 0}}, + {-1,{0}}, +#line 1421 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2916), {194, 177, 0}}, + {-1,{0}}, {-1,{0}}, +#line 696 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2919), {240, 157, 149, 153}}, +#line 593 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2920), {207, 157, 0}}, + {-1,{0}}, +#line 1043 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2922), {226, 136, 186, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 388 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2926), {226, 139, 135, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 400 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2940), {226, 137, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1985 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2956), {207, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1438 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2963), {226, 137, 186, 0}}, + {-1,{0}}, {-1,{0}}, +#line 592 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2966), {207, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 348 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2974), {226, 138, 163, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1169 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2979), {226, 137, 162, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1910 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2982), {197, 173, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1332 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2990), {226, 167, 129, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1608 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2994), {226, 165, 176, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1440 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3002), {226, 137, 188, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1687 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3005), {226, 137, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1922 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3014), {195, 153, 0}}, + {-1,{0}}, +#line 349 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3016), {226, 164, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1655 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3021), {226, 169, 166, 0}}, + {-1,{0}}, +#line 2015 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3023), {226, 137, 154, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1034 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3027), {226, 134, 166, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1861 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3030), {195, 151, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1495 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3033), {226, 159, 169, 0}}, + {-1,{0}}, +#line 827 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3035), {226, 159, 168, 0}}, + {-1,{0}}, {-1,{0}}, +#line 877 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3038), {226, 134, 162, 0}}, +#line 672 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3039), {226, 132, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1918 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3044), {226, 165, 174, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1137 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3053), {226, 139, 186, 0}}, + {-1,{0}}, +#line 1549 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3055), {226, 165, 189, 0}}, + {-1,{0}}, +#line 931 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3057), {226, 165, 188, 0}}, +#line 675 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3058), {226, 165, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1353 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3066), {226, 128, 152, 0}}, + {-1,{0}}, +#line 1919 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3068), {226, 165, 190, 0}}, +#line 1183 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3069), {226, 137, 142, 0}}, + {-1,{0}}, {-1,{0}}, +#line 895 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3072), {226, 138, 163, 0}}, + {-1,{0}}, +#line 1617 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3074), {226, 134, 177, 0}}, + {-1,{0}}, +#line 1000 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3076), {226, 134, 176, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 667 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3080), {226, 137, 169, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1860 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3083), {226, 138, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1649 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3092), {226, 168, 147, 0}}, + {-1,{0}}, {-1,{0}}, +#line 236 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3095), {196, 138, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 454 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3103), {226, 166, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1909 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3114), {197, 172, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 904 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3132), {226, 134, 191, 0}}, + {-1,{0}}, {-1,{0}}, +#line 903 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3135), {226, 165, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 461 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3139), {196, 154, 0}}, + {-1,{0}}, {-1,{0}}, +#line 693 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3142), {226, 136, 187, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 724 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3147), {195, 172, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1238 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3155), {226, 170, 175, 0}}, +#line 466 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3156), {226, 137, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 358 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3167), {226, 133, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1688 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3174), {226, 137, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1187 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3179), {226, 139, 185, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 119 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3198), {226, 168, 129, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 21 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3214), {240, 157, 148, 132}}, +#line 873 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3215), {226, 134, 144, 0}}, +#line 1335 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3216), {226, 136, 174, 0}}, + {-1,{0}}, +#line 1823 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3218), {9, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1329 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3227), {203, 155, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1012 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3230), {60, 0}}, +#line 1149 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3231), {226, 135, 142, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1498 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3235), {226, 135, 165, 0}}, + {-1,{0}}, +#line 831 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3237), {226, 135, 164, 0}}, + {-1,{0}}, +#line 700 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3239), {240, 157, 146, 189}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 901 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3246), {226, 165, 145, 0}}, + {-1,{0}}, +#line 807 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3248), {240, 157, 148, 168}}, +#line 619 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3249), {240, 157, 148, 164}}, +#line 1945 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3250), {226, 164, 146, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1250 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3259), {226, 170, 176, 0}}, +#line 1015 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3260), {226, 139, 150, 0}}, +#line 616 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3261), {226, 139, 155, 0}}, +#line 2073 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3262), {226, 168, 128, 0}}, +#line 1747 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3263), {226, 152, 134, 0}}, + {-1,{0}}, {-1,{0}}, +#line 983 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3266), {95, 0}}, + {-1,{0}}, +#line 2065 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3268), {226, 159, 183, 0}}, +#line 465 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3269), {226, 137, 150, 0}}, + {-1,{0}}, +#line 1975 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3271), {226, 139, 176, 0}}, +#line 1085 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3272), {226, 153, 174, 0}}, +#line 1001 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3273), {226, 134, 176, 0}}, +#line 745 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3274), {226, 136, 158, 0}}, + {-1,{0}}, +#line 283 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3276), {226, 136, 129, 0}}, + {-1,{0}}, +#line 1684 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3278), {207, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 2077 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3285), {226, 168, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1400 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3289), {240, 157, 148, 147}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 618 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3295), {240, 157, 148, 138}}, + {-1,{0}}, {-1,{0}}, +#line 115 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3298), {226, 139, 130, 0}}, + {-1,{0}}, +#line 1692 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3300), {226, 170, 159, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 726 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3319), {226, 168, 140, 0}}, +#line 95 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3320), {226, 140, 133, 0}}, +#line 94 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3321), {226, 140, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 2069 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3329), {226, 159, 181, 0}}, +#line 923 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3330), {226, 139, 154, 0}}, + {-1,{0}}, +#line 301 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3332), {226, 134, 181, 0}}, +#line 772 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3333), {226, 139, 181, 0}}, + {-1,{0}}, +#line 282 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3335), {64, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1054 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3342), {194, 183, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 916 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3349), {226, 170, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1683 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3356), {207, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1499 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3366), {226, 164, 160, 0}}, + {-1,{0}}, +#line 832 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3368), {226, 164, 159, 0}}, + {-1,{0}}, {-1,{0}}, +#line 2078 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3371), {226, 159, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 117 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3376), {226, 139, 131, 0}}, + {-1,{0}}, +#line 274 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3378), {226, 153, 163, 0}}, +#line 677 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3379), {226, 135, 148, 0}}, +#line 1625 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3380), {226, 138, 181, 0}}, + {-1,{0}}, +#line 1021 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3382), {226, 138, 180, 0}}, +#line 741 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3383), {198, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 502 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3388), {196, 153, 0}}, +#line 1630 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3389), {226, 132, 158, 0}}, +#line 1023 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3390), {226, 166, 150, 0}}, +#line 1746 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3391), {226, 139, 134, 0}}, + {-1,{0}}, +#line 1942 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3393), {197, 179, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1855 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3396), {226, 136, 188, 0}}, + {-1,{0}}, +#line 671 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3398), {194, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1854 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3405), {203, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 875 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3412), {226, 135, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 617 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3417), {226, 170, 148, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 217 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3422), {226, 136, 169, 0}}, +#line 1751 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3423), {194, 175, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1014 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3427), {226, 137, 170, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1453 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3439), {226, 170, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1726 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3447), {226, 138, 146, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1727 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3462), {226, 138, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1882 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3467), {226, 151, 172, 0}}, +#line 1360 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3468), {226, 132, 180, 0}}, + {-1,{0}}, {-1,{0}}, +#line 222 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3471), {226, 136, 169, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 302 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3475), {226, 156, 151, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 366 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3482), {226, 165, 191, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2071 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3487), {226, 159, 188, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1725 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3491), {226, 138, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1624 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3503), {226, 150, 185, 0}}, + {-1,{0}}, +#line 1020 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3505), {226, 151, 131, 0}}, +#line 777 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3506), {226, 129, 162, 0}}, +#line 1598 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3507), {226, 142, 177, 0}}, + {-1,{0}}, +#line 954 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3509), {226, 142, 176, 0}}, +#line 633 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3510), {226, 137, 169, 0}}, +#line 936 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3511), {226, 170, 145, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1641 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3514), {226, 170, 180, 0}}, + {-1,{0}}, +#line 1978 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3516), {226, 150, 181, 0}}, + {-1,{0}}, +#line 2016 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3518), {226, 139, 174, 0}}, + {-1,{0}}, +#line 534 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3520), {195, 144, 0}}, + {-1,{0}}, {-1,{0}}, +#line 952 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3523), {197, 128, 0}}, + {-1,{0}}, +#line 1941 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3525), {197, 178, 0}}, +#line 300 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3526), {226, 136, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1120 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3534), {226, 137, 167, 0}}, +#line 1309 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3535), {226, 164, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 917 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3543), {226, 139, 154, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1415 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3546), {226, 138, 158, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1618 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3550), {226, 134, 177, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 299 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3555), {226, 132, 151, 0}}, + {-1,{0}}, +#line 746 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3557), {226, 167, 157, 0}}, + {-1,{0}}, +#line 738 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3559), {196, 177, 0}}, +#line 530 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3560), {226, 169, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1402 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3565), {206, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 628 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3573), {226, 170, 146, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2030 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3579), {226, 138, 131, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1690 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3582), {226, 170, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 413 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3586), {226, 159, 184, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 414 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3591), {226, 159, 186, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1295 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3594), {62, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1046 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3607), {226, 132, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1450 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3611), {226, 128, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 728 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3615), {226, 167, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1546 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3620), {226, 136, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 492 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3627), {226, 151, 187, 0}}, +#line 1489 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3628), {226, 136, 154, 0}}, + {-1,{0}}, {-1,{0}}, +#line 687 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3631), {240, 157, 148, 165}}, +#line 2115 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3632), {197, 188, 0}}, +#line 1029 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3633), {226, 153, 130, 0}}, + {-1,{0}}, +#line 1500 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3635), {226, 164, 179, 0}}, +#line 1436 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3636), {226, 137, 186, 0}}, +#line 1646 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3637), {226, 170, 186, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 383 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3641), {226, 133, 134, 0}}, + {-1,{0}}, +#line 1063 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3643), {226, 138, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1011 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3657), {226, 169, 185, 0}}, +#line 762 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3658), {196, 175, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 216 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3665), {226, 169, 139, 0}}, + {-1,{0}}, +#line 720 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3667), {226, 135, 148, 0}}, + {-1,{0}}, +#line 360 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3669), {226, 169, 183, 0}}, + {-1,{0}}, +#line 263 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3671), {226, 138, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1622 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3676), {226, 139, 140, 0}}, + {-1,{0}}, +#line 1016 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3678), {226, 139, 139, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1441 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3681), {226, 137, 190, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 449 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3685), {226, 139, 177, 0}}, + {-1,{0}}, +#line 275 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3687), {226, 153, 163, 0}}, + {-1,{0}}, +#line 1488 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3689), {197, 149, 0}}, + {-1,{0}}, +#line 819 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3691), {196, 186, 0}}, +#line 1889 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3692), {226, 143, 162, 0}}, +#line 1632 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3693), {197, 155, 0}}, + {-1,{0}}, {-1,{0}}, +#line 2108 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3696), {197, 185, 0}}, +#line 459 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3697), {195, 169, 0}}, + {-1,{0}}, +#line 1858 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3699), {226, 137, 136, 0}}, + {-1,{0}}, +#line 1906 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3701), {226, 165, 137, 0}}, +#line 1902 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3702), {195, 186, 0}}, +#line 982 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3703), {226, 136, 151, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1076 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3714), {197, 132, 0}}, + {-1,{0}}, +#line 1206 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3716), {226, 138, 128, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 951 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3720), {196, 191, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1947 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3725), {226, 134, 145, 0}}, + {-1,{0}}, +#line 1511 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3727), {226, 134, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 438 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3738), {226, 138, 164, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 555 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3742), {226, 151, 188, 0}}, +#line 219 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3743), {226, 169, 135, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 642 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3749), {226, 137, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1299 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3756), {226, 137, 164, 0}}, + {-1,{0}}, +#line 1883 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3758), {226, 137, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1346 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3764), {206, 191, 0}}, + {-1,{0}}, +#line 417 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3766), {226, 138, 168, 0}}, +#line 233 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3767), {226, 136, 176, 0}}, +#line 1621 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3768), {226, 128, 153, 0}}, + {-1,{0}}, +#line 1007 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3770), {226, 128, 154, 0}}, + {-1,{0}}, +#line 2124 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3772), {226, 135, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 293 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3780), {240, 157, 149, 148}}, + {-1,{0}}, +#line 292 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3782), {226, 136, 174, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 670 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3798), {226, 128, 138, 0}}, +#line 1728 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3799), {226, 138, 146, 0}}, +#line 306 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3800), {226, 171, 143, 0}}, +#line 1955 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3801), {226, 134, 190, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 426 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3805), {204, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1674 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3817), {226, 134, 147, 0}}, + {-1,{0}}, +#line 2075 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3819), {240, 157, 149, 169}}, + {-1,{0}}, +#line 1631 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3821), {197, 154, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 2039 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3829), {226, 171, 140, 0}}, +#line 265 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3830), {226, 151, 139, 0}}, +#line 1414 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3831), {226, 168, 163, 0}}, +#line 308 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3832), {226, 171, 144, 0}}, +#line 2037 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3833), {226, 171, 139, 0}}, +#line 1901 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3834), {195, 154, 0}}, + {-1,{0}}, +#line 773 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3836), {226, 139, 185, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 606 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3845), {226, 170, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1719 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3851), {226, 138, 148, 0}}, + {-1,{0}}, +#line 1701 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3853), {226, 136, 163, 0}}, + {-1,{0}}, +#line 935 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3855), {226, 137, 182, 0}}, + {-1,{0}}, +#line 415 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3857), {226, 159, 185, 0}}, +#line 1208 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3858), {226, 139, 160, 0}}, + {-1,{0}}, {-1,{0}}, +#line 477 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3861), {226, 170, 154, 0}}, + {-1,{0}}, {-1,{0}}, +#line 33 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3864), {38, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1162 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3874), {226, 136, 164, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1862 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3883), {226, 168, 176, 0}}, + {-1,{0}}, {-1,{0}}, +#line 433 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3886), {226, 134, 189, 0}}, +#line 2130 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3887), {226, 128, 140, 0}}, +#line 818 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3888), {196, 185, 0}}, +#line 432 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3889), {226, 165, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1331 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3898), {195, 178, 0}}, +#line 2087 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3899), {195, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1718 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3903), {226, 138, 148, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1322 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3906), {226, 138, 153, 0}}, +#line 212 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3907), {196, 134, 0}}, + {-1,{0}}, +#line 1285 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3909), {206, 189, 0}}, +#line 1888 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3910), {226, 168, 187, 0}}, + {-1,{0}}, +#line 478 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3912), {195, 136, 0}}, +#line 507 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3913), {226, 169, 177, 0}}, + {-1,{0}}, +#line 85 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3915), {226, 137, 140, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1956 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3918), {226, 138, 142, 0}}, + {-1,{0}}, +#line 470 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3920), {196, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 309 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3924), {226, 171, 146, 0}}, + {-1,{0}}, +#line 1689 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3926), {226, 170, 158, 0}}, +#line 1958 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3927), {226, 134, 151, 0}}, +#line 307 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3928), {226, 171, 145, 0}}, + {-1,{0}}, +#line 450 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3930), {226, 150, 191, 0}}, +#line 1454 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3931), {226, 139, 168, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 177 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3936), {226, 149, 153, 0}}, +#line 1980 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3937), {226, 135, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 431 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3945), {226, 165, 158, 0}}, +#line 650 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3946), {226, 170, 142, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 120 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3950), {226, 168, 130, 0}}, +#line 341 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3951), {226, 128, 161, 0}}, + {-1,{0}}, {-1,{0}}, +#line 754 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3954), {226, 139, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 710 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3967), {195, 173, 0}}, + {-1,{0}}, +#line 1434 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3969), {226, 137, 188, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 481 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3981), {226, 170, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 742 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3987), {226, 135, 146, 0}}, +#line 2010 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3988), {226, 138, 171, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 207 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3996), {226, 137, 142, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1070 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4015), {206, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 2008 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4022), {226, 138, 168, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1027 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4028), {226, 137, 168, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 894 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4033), {226, 134, 164, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1075 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4037), {197, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1936 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4042), {226, 143, 159, 0}}, +#line 1468 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4043), {206, 168, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1559 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4047), {207, 177, 0}}, + {-1,{0}}, +#line 912 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4049), {226, 170, 168, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1789 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4055), {194, 185, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1790 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4058), {194, 178, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1791 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4066), {194, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 118 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4071), {226, 168, 128, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 424 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4078), {226, 135, 147, 0}}, + {-1,{0}}, +#line 2082 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4080), {226, 168, 134, 0}}, + {-1,{0}}, +#line 92 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4082), {226, 138, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1106 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4087), {226, 128, 139, 0}}, +#line 209 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4088), {226, 137, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 305 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4100), {240, 157, 146, 184}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1248 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4109), {226, 138, 129, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1792 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4115), {226, 138, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 238 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4122), {194, 184, 0}}, + {-1,{0}}, {-1,{0}}, +#line 191 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4125), {226, 149, 159, 0}}, + {-1,{0}}, +#line 1364 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4127), {226, 138, 182, 0}}, +#line 2129 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4128), {226, 128, 141, 0}}, +#line 723 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4129), {195, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 716 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4137), {196, 176, 0}}, + {-1,{0}}, +#line 2081 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4139), {240, 157, 147, 141}}, +#line 2068 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4140), {206, 190, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1131 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4144), {226, 137, 171, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 165 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4153), {226, 149, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1852 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4163), {195, 158, 0}}, + {-1,{0}}, +#line 1487 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4165), {197, 148, 0}}, + {-1,{0}}, +#line 1505 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4167), {226, 134, 170, 0}}, + {-1,{0}}, +#line 837 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4169), {226, 134, 169, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1627 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4177), {226, 167, 142, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 180 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4189), {226, 149, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 340 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4215), {226, 128, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1345 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4220), {206, 159, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 420 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4226), {226, 136, 165, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1117 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4229), {226, 136, 132, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1284 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4232), {206, 157, 0}}, +#line 1116 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4233), {226, 136, 132, 0}}, +#line 605 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4234), {226, 137, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 63 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4238), {226, 137, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1793 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4243), {226, 139, 145, 0}}, +#line 401 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4244), {226, 137, 145, 0}}, + {-1,{0}}, {-1,{0}}, +#line 499 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4247), {197, 139, 0}}, + {-1,{0}}, +#line 224 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4249), {203, 135, 0}}, + {-1,{0}}, +#line 167 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4251), {226, 149, 169, 0}}, +#line 613 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4252), {226, 170, 128, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1547 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4257), {226, 135, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 174 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4262), {226, 149, 157, 0}}, + {-1,{0}}, +#line 1804 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4264), {226, 171, 130, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1409 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4267), {226, 139, 148, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1288 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4272), {226, 128, 135, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1491 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4285), {226, 159, 169, 0}}, + {-1,{0}}, +#line 824 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4287), {226, 159, 168, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1315 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4290), {226, 138, 154, 0}}, + {-1,{0}}, +#line 1515 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4292), {226, 132, 154, 0}}, + {-1,{0}}, +#line 295 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4294), {226, 136, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1018 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4307), {226, 165, 182, 0}}, +#line 194 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4308), {203, 152, 0}}, + {-1,{0}}, +#line 1077 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4310), {226, 136, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1817 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4315), {226, 164, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1496 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4322), {194, 187, 0}}, + {-1,{0}}, +#line 830 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4324), {194, 171, 0}}, +#line 1815 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4325), {226, 171, 148, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 321 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4329), {226, 139, 147, 0}}, +#line 65 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4330), {226, 137, 138, 0}}, +#line 1481 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4331), {63, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1305 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4336), {226, 164, 163, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1808 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4340), {226, 138, 131, 0}}, + {-1,{0}}, +#line 422 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4342), {226, 134, 147, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 452 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4351), {226, 135, 181, 0}}, + {-1,{0}}, +#line 67 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4353), {39, 0}}, +#line 1330 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4354), {195, 146, 0}}, +#line 1677 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4355), {226, 136, 165, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1268 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4364), {226, 138, 129, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 966 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4368), {226, 159, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 915 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4377), {226, 170, 129, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1806 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4384), {226, 138, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1126 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4388), {226, 139, 153, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1490 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4396), {226, 166, 179, 0}}, +#line 1816 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4397), {226, 171, 150, 0}}, +#line 820 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4398), {226, 166, 180, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1870 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4401), {226, 171, 154, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 501 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4423), {196, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1593 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4429), {226, 137, 147, 0}}, + {-1,{0}}, +#line 211 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4431), {226, 137, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1009 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4435), {197, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1896 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4439), {197, 166, 0}}, +#line 649 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4440), {226, 137, 179, 0}}, + {-1,{0}}, {-1,{0}}, +#line 105 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4443), {226, 166, 176, 0}}, +#line 2109 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4444), {197, 186, 0}}, +#line 651 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4445), {226, 170, 144, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1897 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4448), {197, 167, 0}}, + {-1,{0}}, +#line 1600 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4450), {226, 159, 173, 0}}, +#line 188 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4451), {226, 149, 163, 0}}, +#line 962 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4452), {226, 159, 172, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1152 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4456), {226, 169, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1633 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4462), {226, 128, 154, 0}}, + {-1,{0}}, +#line 1656 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4464), {226, 164, 165, 0}}, +#line 956 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4465), {226, 170, 137, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1809 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4468), {226, 139, 145, 0}}, + {-1,{0}}, +#line 161 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4470), {226, 149, 164, 0}}, +#line 1986 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4471), {207, 176, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 253 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4475), {226, 137, 151, 0}}, + {-1,{0}}, +#line 2101 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4477), {240, 157, 149, 170}}, + {-1,{0}}, +#line 1940 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4479), {226, 138, 142, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 825 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4484), {226, 159, 170, 0}}, +#line 1100 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4485), {226, 164, 164, 0}}, +#line 1673 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4486), {209, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 244 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4492), {240, 157, 148, 160}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 799 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4506), {206, 154, 0}}, +#line 943 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4507), {209, 153, 0}}, +#line 1045 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4508), {226, 129, 159, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1810 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4511), {226, 138, 135, 0}}, +#line 1811 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4512), {226, 171, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1544 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4517), {194, 174, 0}}, +#line 30 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4518), {196, 129, 0}}, +#line 908 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4519), {226, 139, 154, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2049 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4524), {226, 132, 152, 0}}, +#line 1892 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4525), {208, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1812 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4529), {226, 138, 139, 0}}, +#line 1140 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4530), {209, 154, 0}}, +#line 2064 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4531), {240, 157, 148, 181}}, + {-1,{0}}, +#line 1071 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4533), {206, 188, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1297 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4539), {226, 167, 158, 0}}, +#line 178 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4540), {226, 149, 154, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2076 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4545), {226, 168, 129, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 886 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4551), {226, 135, 135, 0}}, +#line 1786 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4552), {226, 136, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 111 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4559), {226, 132, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 285 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4563), {226, 136, 129, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1286 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4573), {35, 0}}, +#line 32 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4574), {38, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 173 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4583), {226, 149, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1176 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4590), {226, 137, 175, 0}}, +#line 169 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4591), {226, 138, 158, 0}}, +#line 790 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4592), {200, 183, 0}}, + {-1,{0}}, +#line 1668 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4594), {226, 140, 162, 0}}, + {-1,{0}}, +#line 447 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4596), {196, 144, 0}}, + {-1,{0}}, +#line 36 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4598), {226, 136, 167, 0}}, +#line 1179 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4599), {226, 137, 171, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1181 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4606), {226, 169, 190, 0}}, + {-1,{0}}, +#line 1180 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4608), {226, 137, 185, 0}}, +#line 1483 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4609), {34, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1178 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4616), {226, 137, 167, 0}}, +#line 708 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4617), {226, 128, 144, 0}}, +#line 1411 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4618), {226, 132, 143, 0}}, + {-1,{0}}, +#line 1856 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4620), {226, 137, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1871 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4627), {226, 164, 169, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1008 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4632), {197, 129, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1680 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4635), {194, 173, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2072 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4639), {226, 139, 187, 0}}, +#line 761 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4640), {196, 174, 0}}, + {-1,{0}}, {-1,{0}}, +#line 455 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4643), {208, 143, 0}}, + {-1,{0}}, +#line 1333 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4645), {226, 166, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 270 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4652), {226, 167, 130, 0}}, + {-1,{0}}, +#line 1665 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4654), {226, 156, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1386 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4668), {194, 182, 0}}, + {-1,{0}}, {-1,{0}}, +#line 76 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4671), {42, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1482 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4678), {226, 137, 159, 0}}, + {-1,{0}}, +#line 1787 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4680), {226, 136, 145, 0}}, + {-1,{0}}, +#line 444 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4682), {208, 133, 0}}, + {-1,{0}}, +#line 498 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4684), {197, 138, 0}}, + {-1,{0}}, +#line 2122 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4686), {208, 150, 0}}, + {-1,{0}}, {-1,{0}}, +#line 965 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4689), {226, 159, 181, 0}}, + {-1,{0}}, +#line 346 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4691), {226, 128, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 437 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4699), {226, 134, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1813 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4706), {226, 171, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1457 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4714), {226, 140, 174, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1311 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4718), {195, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 192 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4729), {226, 149, 160, 0}}, + {-1,{0}}, {-1,{0}}, +#line 458 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4732), {195, 137, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1807 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4738), {226, 171, 128, 0}}, + {-1,{0}}, +#line 694 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4740), {226, 134, 169, 0}}, + {-1,{0}}, {-1,{0}}, +#line 273 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4743), {226, 128, 153, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1887 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4746), {226, 167, 141, 0}}, +#line 405 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4747), {226, 138, 161, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1623 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4751), {226, 139, 138, 0}}, + {-1,{0}}, +#line 1017 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4753), {226, 139, 137, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1864 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4756), {226, 164, 168, 0}}, +#line 23 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4757), {195, 128, 0}}, + {-1,{0}}, {-1,{0}}, +#line 75 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4760), {226, 137, 148, 0}}, +#line 1492 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4761), {226, 159, 171, 0}}, +#line 760 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4762), {209, 145, 0}}, + {-1,{0}}, +#line 1207 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4764), {226, 170, 175, 0}}, + {-1,{0}}, +#line 61 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4766), {240, 157, 149, 146}}, + {-1,{0}}, +#line 251 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4768), {207, 135, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1479 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4771), {226, 132, 141, 0}}, +#line 187 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4772), {226, 149, 162, 0}}, +#line 1177 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4773), {226, 137, 177, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2066 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4777), {226, 159, 186, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1361 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4791), {226, 132, 180, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1620 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4794), {226, 128, 153, 0}}, + {-1,{0}}, +#line 1006 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4796), {226, 128, 152, 0}}, +#line 2103 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4797), {240, 157, 147, 142}}, + {-1,{0}}, {-1,{0}}, +#line 603 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4800), {196, 161, 0}}, + {-1,{0}}, +#line 1214 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4802), {226, 139, 162, 0}}, +#line 809 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4803), {208, 165, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 202 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4809), {226, 167, 133, 0}}, +#line 1213 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4810), {226, 138, 143, 0}}, +#line 1672 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4811), {208, 168, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2098 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4821), {208, 135, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 338 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4825), {226, 136, 177, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1841 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4828), {206, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1842 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4837), {206, 184, 0}}, +#line 2070 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4838), {226, 159, 184, 0}}, + {-1,{0}}, +#line 1216 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4840), {226, 139, 163, 0}}, + {-1,{0}}, {-1,{0}}, +#line 365 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4843), {226, 166, 177, 0}}, +#line 1875 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4844), {226, 150, 181, 0}}, + {-1,{0}}, +#line 602 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4846), {196, 160, 0}}, + {-1,{0}}, +#line 1215 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4848), {226, 138, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 8 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4857), {196, 130, 0}}, + {-1,{0}}, {-1,{0}}, +#line 448 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4860), {196, 145, 0}}, +#line 1399 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4861), {226, 128, 177, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1521 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4866), {93, 0}}, + {-1,{0}}, +#line 851 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4868), {91, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1323 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4872), {226, 166, 188, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1347 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4878), {226, 166, 182, 0}}, + {-1,{0}}, +#line 2079 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4880), {226, 159, 185, 0}}, + {-1,{0}}, +#line 1877 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4882), {226, 151, 131, 0}}, +#line 1182 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4883), {226, 137, 181, 0}}, +#line 279 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4884), {226, 137, 148, 0}}, + {-1,{0}}, +#line 967 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4886), {226, 159, 184, 0}}, + {-1,{0}}, +#line 766 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4888), {206, 185, 0}}, + {-1,{0}}, +#line 276 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4890), {58, 0}}, +#line 2118 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4891), {206, 150, 0}}, +#line 596 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4892), {196, 159, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 246 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4897), {208, 167, 0}}, + {-1,{0}}, {-1,{0}}, +#line 2104 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4900), {208, 174, 0}}, +#line 1545 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4901), {194, 174, 0}}, +#line 1822 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4902), {195, 159, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 456 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4909), {209, 159, 0}}, + {-1,{0}}, +#line 110 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4911), {206, 178, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 538 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4918), {226, 130, 172, 0}}, + {-1,{0}}, {-1,{0}}, +#line 874 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4921), {226, 134, 144, 0}}, + {-1,{0}}, {-1,{0}}, +#line 221 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4924), {226, 133, 133, 0}}, + {-1,{0}}, +#line 1592 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4926), {203, 154, 0}}, +#line 829 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4927), {226, 132, 146, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 391 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4932), {209, 146, 0}}, + {-1,{0}}, +#line 1355 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4934), {226, 138, 149, 0}}, + {-1,{0}}, {-1,{0}}, +#line 751 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4937), {226, 132, 164, 0}}, +#line 595 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4938), {196, 158, 0}}, + {-1,{0}}, +#line 1908 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4940), {209, 158, 0}}, +#line 537 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4941), {195, 171, 0}}, + {-1,{0}}, {-1,{0}}, +#line 361 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4944), {194, 176, 0}}, + {-1,{0}}, +#line 1982 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4946), {195, 188, 0}}, + {-1,{0}}, {-1,{0}}, +#line 709 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4949), {195, 141, 0}}, +#line 1780 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4950), {226, 170, 176, 0}}, + {-1,{0}}, +#line 811 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4952), {208, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 319 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4961), {226, 137, 141, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1893 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4975), {209, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 241 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4982), {194, 162, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 390 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4991), {208, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1857 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5009), {226, 137, 133, 0}}, + {-1,{0}}, +#line 1879 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5011), {226, 137, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 453 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5016), {226, 165, 175, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 879 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5025), {226, 159, 166, 0}}, + {-1,{0}}, +#line 942 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5027), {208, 137, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 718 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5036), {208, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1878 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5043), {226, 138, 180, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1110 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5049), {226, 137, 162, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1254 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5055), {226, 136, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1099 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5062), {226, 128, 147, 0}}, +#line 148 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5063), {226, 139, 136, 0}}, + {-1,{0}}, +#line 557 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5065), {102, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1907 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5072), {208, 142, 0}}, + {-1,{0}}, +#line 1999 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5074), {207, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1981 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5078), {195, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2001 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5084), {226, 138, 179, 0}}, +#line 2000 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5085), {226, 138, 178, 0}}, +#line 74 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5086), {240, 157, 146, 182}}, + {-1,{0}}, {-1,{0}}, +#line 1775 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5089), {226, 137, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 337 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5093), {226, 136, 178, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1638 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5101), {226, 137, 187, 0}}, + {-1,{0}}, +#line 559 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5103), {239, 172, 130, 0}}, + {-1,{0}}, +#line 256 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5105), {226, 138, 155, 0}}, + {-1,{0}}, {-1,{0}}, +#line 2009 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5108), {226, 138, 169, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1292 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5112), {226, 138, 174, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1803 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5120), {226, 165, 187, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1602 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5124), {226, 159, 167, 0}}, + {-1,{0}}, +#line 964 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5126), {226, 159, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2007 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5142), {226, 138, 162, 0}}, +#line 2107 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5143), {197, 184, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 654 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5151), {62, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 226 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5156), {226, 169, 141, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1776 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5173), {226, 137, 187, 0}}, +#line 1310 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5174), {195, 147, 0}}, +#line 1874 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5175), {226, 132, 162, 0}}, +#line 1139 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5176), {208, 138, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 657 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5181), {226, 139, 151, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 2097 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5189), {240, 157, 148, 182}}, + {-1,{0}}, {-1,{0}}, +#line 284 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5192), {226, 136, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 656 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5197), {226, 137, 171, 0}}, +#line 1647 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5198), {226, 170, 182, 0}}, +#line 731 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5199), {196, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 261 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5203), {226, 147, 136, 0}}, + {-1,{0}}, {-1,{0}}, +#line 2095 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5206), {194, 165, 0}}, + {-1,{0}}, +#line 1843 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5208), {207, 145, 0}}, + {-1,{0}}, {-1,{0}}, +#line 783 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5211), {195, 175, 0}}, +#line 1778 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5212), {226, 137, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 159 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5217), {226, 149, 144, 0}}, +#line 1073 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5218), {226, 138, 184, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1577 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5222), {226, 135, 137, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 280 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5227), {226, 137, 148, 0}}, + {-1,{0}}, +#line 1637 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5229), {226, 170, 188, 0}}, +#line 629 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5230), {226, 170, 164, 0}}, +#line 719 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5231), {194, 161, 0}}, + {-1,{0}}, {-1,{0}}, +#line 234 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5234), {226, 169, 140, 0}}, + {-1,{0}}, +#line 2059 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5236), {226, 139, 130, 0}}, +#line 2123 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5237), {208, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 163 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5241), {226, 149, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 911 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5250), {226, 169, 189, 0}}, + {-1,{0}}, +#line 1957 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5252), {226, 134, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 350 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5257), {203, 157, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1470 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5260), {226, 128, 136, 0}}, + {-1,{0}}, +#line 228 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5262), {196, 141, 0}}, + {-1,{0}}, +#line 1519 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5264), {226, 157, 179, 0}}, + {-1,{0}}, +#line 849 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5266), {226, 157, 178, 0}}, + {-1,{0}}, +#line 58 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5268), {196, 132, 0}}, +#line 898 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5269), {226, 167, 143, 0}}, + {-1,{0}}, {-1,{0}}, +#line 615 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5272), {226, 170, 132, 0}}, +#line 900 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5273), {226, 138, 180, 0}}, +#line 899 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5274), {226, 138, 178, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 290 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5280), {226, 136, 174, 0}}, + {-1,{0}}, {-1,{0}}, +#line 439 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5283), {226, 164, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1626 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5295), {226, 150, 184, 0}}, + {-1,{0}}, +#line 1022 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5297), {226, 151, 130, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1548 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5300), {226, 165, 175, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 878 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5306), {226, 140, 136, 0}}, + {-1,{0}}, +#line 1979 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5308), {226, 150, 180, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2061 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5314), {226, 139, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 545 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5319), {226, 137, 146, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1528 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5325), {197, 151, 0}}, + {-1,{0}}, +#line 858 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5327), {196, 188, 0}}, + {-1,{0}}, +#line 1643 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5329), {197, 159, 0}}, + {-1,{0}}, +#line 1830 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5331), {197, 162, 0}}, + {-1,{0}}, +#line 1748 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5333), {226, 152, 133, 0}}, +#line 168 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5334), {226, 138, 159, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1831 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5340), {197, 163, 0}}, +#line 2117 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5341), {226, 128, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1093 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5350), {197, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1404 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5358), {207, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 711 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5375), {226, 129, 163, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 220 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5384), {226, 169, 128, 0}}, + {-1,{0}}, {-1,{0}}, +#line 445 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5387), {209, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 248 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5397), {226, 156, 147, 0}}, +#line 1381 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5398), {226, 140, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1280 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5405), {226, 139, 170, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1580 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5411), {226, 138, 162, 0}}, +#line 1294 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5412), {226, 137, 165, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 892 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5424), {226, 134, 173, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 987 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5431), {226, 151, 138, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1583 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5434), {226, 167, 144, 0}}, + {-1,{0}}, +#line 1581 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5436), {226, 165, 155, 0}}, + {-1,{0}}, +#line 1585 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5438), {226, 138, 181, 0}}, +#line 1584 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5439), {226, 138, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 802 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5449), {196, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1642 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5457), {197, 158, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 268 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5468), {226, 168, 144, 0}}, + {-1,{0}}, {-1,{0}}, +#line 490 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5471), {226, 136, 133, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 22 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5478), {240, 157, 148, 158}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 376 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5482), {203, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 882 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5489), {226, 135, 131, 0}}, + {-1,{0}}, {-1,{0}}, +#line 881 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5492), {226, 165, 153, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 907 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5501), {226, 170, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 68 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5509), {226, 129, 161, 0}}, + {-1,{0}}, {-1,{0}}, +#line 208 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5512), {226, 170, 174, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 857 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5524), {196, 187, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 223 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5528), {226, 129, 129, 0}}, + {-1,{0}}, +#line 91 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5530), {226, 171, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 229 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5543), {195, 135, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 260 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5547), {194, 174, 0}}, +#line 880 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5548), {226, 165, 161, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1895 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5552), {209, 155, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 402 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5556), {226, 137, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 242 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5564), {194, 183, 0}}, + {-1,{0}}, +#line 1281 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5566), {226, 139, 172, 0}}, + {-1,{0}}, +#line 1056 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5568), {226, 136, 146, 0}}, + {-1,{0}}, +#line 623 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5570), {226, 132, 183, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 6 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5577), {195, 129, 0}}, +#line 653 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5578), {226, 169, 186, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 661 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5583), {226, 165, 184, 0}}, +#line 205 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5584), {226, 128, 162, 0}}, + {-1,{0}}, {-1,{0}}, +#line 423 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5587), {226, 134, 147, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1536 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5593), {226, 128, 157, 0}}, + {-1,{0}}, +#line 865 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5595), {226, 128, 158, 0}}, + {-1,{0}}, {-1,{0}}, +#line 755 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5598), {226, 168, 151, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1977 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5602), {197, 169, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 589 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5612), {199, 181, 0}}, + {-1,{0}}, +#line 1278 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5614), {195, 177, 0}}, +#line 20 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5615), {226, 129, 161, 0}}, + {-1,{0}}, {-1,{0}}, +#line 703 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5618), {196, 166, 0}}, + {-1,{0}}, +#line 543 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5620), {226, 133, 135, 0}}, +#line 1055 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5621), {226, 138, 159, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1587 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5625), {226, 165, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1964 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5630), {226, 134, 165, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2119 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5639), {206, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 373 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5644), {203, 153, 0}}, +#line 374 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5645), {203, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1146 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5663), {226, 134, 154, 0}}, +#line 691 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5664), {226, 164, 166, 0}}, + {-1,{0}}, +#line 729 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5666), {226, 132, 169, 0}}, + {-1,{0}}, {-1,{0}}, +#line 62 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5669), {226, 169, 175, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1092 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5673), {197, 133, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 214 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5678), {226, 169, 132, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1042 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5686), {226, 128, 148, 0}}, + {-1,{0}}, {-1,{0}}, +#line 554 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5689), {239, 172, 129, 0}}, +#line 1648 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5690), {226, 139, 169, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1540 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5699), {226, 132, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 897 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5703), {226, 139, 139, 0}}, +#line 77 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5704), {226, 137, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 685 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5718), {226, 128, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 451 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5722), {226, 150, 190, 0}}, + {-1,{0}}, +#line 1175 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5724), {226, 136, 132, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1639 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5728), {226, 137, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2089 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5733), {208, 175, 0}}, +#line 1976 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5734), {197, 168, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1173 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5741), {226, 137, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1848 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5747), {226, 128, 137, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 64 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5754), {226, 169, 176, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 206 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5762), {226, 128, 162, 0}}, + {-1,{0}}, {-1,{0}}, +#line 272 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5765), {226, 128, 157, 0}}, +#line 363 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5766), {206, 148, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 620 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5776), {226, 137, 171, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1378 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5780), {226, 138, 151, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2056 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5799), {226, 137, 128, 0}}, + {-1,{0}}, +#line 1527 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5801), {197, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 535 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5807), {195, 176, 0}}, +#line 1805 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5808), {226, 171, 140, 0}}, + {-1,{0}}, {-1,{0}}, +#line 84 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5811), {226, 168, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 195 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5817), {203, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 621 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5822), {226, 139, 153, 0}}, + {-1,{0}}, +#line 706 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5824), {226, 137, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 948 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5837), {226, 135, 154, 0}}, +#line 154 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5838), {226, 148, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1782 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5847), {226, 170, 182, 0}}, +#line 1971 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5848), {197, 175, 0}}, +#line 929 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5849), {226, 169, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1290 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5860), {226, 138, 172, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 669 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5866), {203, 135, 0}}, +#line 779 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5867), {196, 169, 0}}, + {-1,{0}}, {-1,{0}}, +#line 765 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5870), {206, 153, 0}}, + {-1,{0}}, +#line 759 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5872), {208, 129, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 156 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5884), {226, 149, 147, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1779 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5891), {226, 137, 191, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 883 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5905), {226, 140, 138, 0}}, +#line 2041 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5906), {226, 138, 170, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1876 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5923), {226, 150, 191, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 969 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5927), {226, 159, 183, 0}}, +#line 1572 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5928), {226, 140, 139, 0}}, + {-1,{0}}, {-1,{0}}, +#line 434 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5931), {226, 165, 159, 0}}, + {-1,{0}}, +#line 1480 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5933), {226, 168, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1277 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5937), {195, 145, 0}}, + {-1,{0}}, {-1,{0}}, +#line 210 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5940), {226, 137, 142, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 668 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5949), {226, 137, 169, 0}}, + {-1,{0}}, +#line 164 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5951), {226, 148, 180, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 658 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5956), {226, 166, 149, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1237 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5959), {226, 138, 128, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1380 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5962), {195, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 611 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5970), {226, 170, 169, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 536 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5976), {195, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1970 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5980), {197, 174, 0}}, + {-1,{0}}, +#line 1937 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5982), {226, 142, 181, 0}}, +#line 1161 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5983), {226, 137, 170, 0}}, +#line 872 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5984), {226, 135, 164, 0}}, +#line 1095 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5985), {226, 169, 173, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 78 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6003), {226, 137, 141, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1058 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6023), {226, 168, 170, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 364 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6030), {206, 180, 0}}, + {-1,{0}}, +#line 678 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6032), {226, 134, 173, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 38 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6038), {226, 169, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 237 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6043), {196, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 225 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6048), {226, 132, 173, 0}}, +#line 166 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6049), {226, 149, 168, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1784 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6052), {226, 137, 191, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 266 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6061), {226, 167, 131, 0}}, +#line 1653 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6062), {226, 138, 161, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1318 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6066), {226, 138, 157, 0}}, +#line 269 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6067), {226, 171, 175, 0}}, +#line 1802 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6068), {226, 171, 151, 0}}, +#line 1795 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6069), {226, 171, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1794 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6077), {226, 170, 190, 0}}, + {-1,{0}}, +#line 83 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6079), {226, 136, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1894 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6084), {208, 139, 0}}, + {-1,{0}}, {-1,{0}}, +#line 639 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6087), {96, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1004 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6101), {226, 170, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1949 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6106), {226, 135, 133, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 906 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6121), {226, 134, 188, 0}}, +#line 416 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6122), {226, 135, 146, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1108 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6129), {226, 128, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 941 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6140), {226, 150, 132, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 267 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6146), {226, 137, 151, 0}}, +#line 1293 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6147), {226, 138, 175, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1927 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6151), {226, 150, 128, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 737 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6155), {226, 132, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1586 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6161), {226, 165, 143, 0}}, + {-1,{0}}, {-1,{0}}, +#line 151 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6164), {226, 149, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 626 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6176), {226, 170, 165, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 782 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6193), {195, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1325 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6203), {197, 147, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1198 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6208), {226, 169, 189, 0}}, + {-1,{0}}, +#line 153 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6210), {226, 149, 151, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 591 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6215), {206, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1377 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6236), {226, 168, 183, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 968 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6248), {226, 159, 183, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 590 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6261), {206, 147, 0}}, +#line 127 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6262), {226, 139, 128, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 160 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6268), {226, 148, 172, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1796 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6283), {226, 171, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 902 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6292), {226, 165, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 614 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6298), {226, 170, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 800 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6304), {206, 186, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1124 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6315), {226, 169, 190, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 665 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6340), {226, 137, 183, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 550 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6351), {239, 172, 128, 0}}, +#line 121 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6352), {226, 168, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 808 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6367), {196, 184, 0}}, +#line 1797 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6368), {226, 138, 135, 0}}, + {-1,{0}}, +#line 170 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6370), {226, 138, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 631 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6386), {226, 170, 138, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 427 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6394), {226, 135, 138, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 125 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6403), {226, 168, 132, 0}}, +#line 810 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6404), {209, 133, 0}}, + {-1,{0}}, +#line 355 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6406), {226, 128, 161, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1379 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6418), {195, 150, 0}}, + {-1,{0}}, +#line 109 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6420), {206, 146, 0}}, +#line 1057 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6421), {226, 136, 184, 0}}, +#line 1783 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6422), {226, 139, 169, 0}}, + {-1,{0}}, +#line 310 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6424), {226, 139, 175, 0}}, + {-1,{0}}, {-1,{0}}, +#line 812 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6427), {209, 156, 0}}, +#line 625 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6428), {209, 147, 0}}, + {-1,{0}}, +#line 1094 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6430), {226, 137, 135, 0}}, +#line 2085 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6431), {226, 139, 129, 0}}, +#line 98 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6432), {226, 137, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1722 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6439), {226, 138, 145, 0}}, + {-1,{0}}, {-1,{0}}, +#line 155 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6442), {226, 149, 146, 0}}, + {-1,{0}}, {-1,{0}}, +#line 970 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6445), {226, 159, 186, 0}}, + {-1,{0}}, +#line 1721 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6447), {226, 138, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 430 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6451), {226, 165, 144, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1723 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6454), {226, 138, 143, 0}}, + {-1,{0}}, +#line 1229 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6456), {226, 136, 164, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1174 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6461), {226, 137, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 150 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6485), {226, 148, 144, 0}}, + {-1,{0}}, {-1,{0}}, +#line 157 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6488), {226, 149, 148, 0}}, + {-1,{0}}, +#line 34 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6490), {226, 169, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1591 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6502), {226, 135, 128, 0}}, + {-1,{0}}, +#line 730 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6504), {196, 178, 0}}, +#line 1226 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6505), {226, 137, 132, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 57 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6509), {226, 141, 188, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 52 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6515), {226, 136, 159, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 11 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6521), {226, 136, 191, 0}}, + {-1,{0}}, {-1,{0}}, +#line 37 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6524), {226, 169, 156, 0}}, + {-1,{0}}, +#line 1240 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6526), {226, 164, 179, 0}}, +#line 2025 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6527), {226, 128, 138, 0}}, + {-1,{0}}, +#line 1799 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6529), {226, 138, 131, 0}}, + {-1,{0}}, +#line 152 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6531), {226, 149, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2029 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6535), {226, 138, 130, 0}}, + {-1,{0}}, {-1,{0}}, +#line 235 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6538), {226, 169, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1987 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6548), {226, 136, 133, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1532 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6552), {209, 128, 0}}, + {-1,{0}}, +#line 862 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6554), {208, 187, 0}}, + {-1,{0}}, +#line 1652 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6556), {209, 129, 0}}, + {-1,{0}}, +#line 1832 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6558), {208, 162, 0}}, +#line 2112 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6559), {208, 151, 0}}, +#line 468 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6560), {209, 141, 0}}, +#line 1537 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6561), {226, 134, 179, 0}}, + {-1,{0}}, +#line 868 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6563), {226, 134, 178, 0}}, + {-1,{0}}, +#line 1914 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6565), {209, 131, 0}}, +#line 184 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6566), {226, 149, 172, 0}}, +#line 1833 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6567), {209, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1098 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6577), {208, 189, 0}}, + {-1,{0}}, +#line 100 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6579), {208, 177, 0}}, +#line 1276 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6580), {226, 137, 185, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 786 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6585), {208, 153, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 288 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6600), {226, 169, 173, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 56 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6607), {195, 133, 0}}, + {-1,{0}}, +#line 1569 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6609), {226, 165, 157, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1385 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6612), {226, 143, 156, 0}}, +#line 1019 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6613), {226, 169, 187, 0}}, + {-1,{0}}, +#line 1394 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6615), {208, 191, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1375 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6618), {195, 181, 0}}, +#line 1535 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6619), {226, 128, 157, 0}}, + {-1,{0}}, +#line 864 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6621), {226, 128, 156, 0}}, + {-1,{0}}, +#line 2005 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6623), {208, 146, 0}}, + {-1,{0}}, {-1,{0}}, +#line 215 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6626), {226, 169, 137, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 101 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6646), {226, 128, 158, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 421 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6650), {226, 164, 147, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 2006 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6657), {208, 178, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 53 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6665), {226, 138, 190, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 804 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6676), {208, 154, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1040 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6683), {208, 156, 0}}, +#line 1651 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6684), {208, 161, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1115 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6691), {10, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 547 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6696), {209, 132, 0}}, +#line 1913 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6697), {208, 163, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 183 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6704), {226, 149, 171, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 353 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6715), {208, 148, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 704 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6738), {196, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 861 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6751), {208, 155, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2093 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6762), {208, 171, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1814 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6775), {226, 171, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1164 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6789), {194, 160, 0}}, +#line 1382 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6790), {226, 128, 190, 0}}, +#line 1724 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6791), {226, 138, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 624 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6797), {208, 131, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1383 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6800), {226, 143, 158, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 512 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6806), {226, 137, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1384 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6819), {226, 142, 180, 0}}, + {-1,{0}}, +#line 81 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6821), {195, 132, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 15 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6829), {194, 180, 0}}, +#line 715 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6830), {208, 184, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 778 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6849), {196, 168, 0}}, +#line 689 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6850), {226, 132, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1344 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6854), {207, 137, 0}}, +#line 213 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6855), {196, 135, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1645 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6861), {197, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 464 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6865), {195, 170, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1912 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6870), {195, 187, 0}}, + {-1,{0}}, +#line 645 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6872), {226, 169, 190, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 784 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6890), {196, 180, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1291 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6895), {226, 138, 173, 0}}, +#line 2043 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6896), {197, 180, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1097 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6900), {208, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1579 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6921), {226, 134, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 924 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6942), {226, 137, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1010 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6958), {226, 170, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 26 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6963), {226, 132, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 354 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6979), {208, 180, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1644 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6989), {197, 156, 0}}, + {-1,{0}}, +#line 919 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6991), {226, 170, 133, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 717 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7000), {208, 149, 0}}, +#line 985 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7001), {226, 134, 152, 0}}, +#line 1911 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7002), {195, 155, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 24 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7021), {195, 160, 0}}, + {-1,{0}}, +#line 1059 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7023), {226, 136, 147, 0}}, +#line 126 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7024), {226, 139, 129, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1531 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7028), {208, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1801 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7034), {226, 159, 137, 0}}, + {-1,{0}}, {-1,{0}}, +#line 494 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7037), {226, 150, 171, 0}}, + {-1,{0}}, +#line 162 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7039), {226, 149, 165, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1435 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7047), {226, 170, 183, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 54 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7066), {226, 166, 157, 0}}, +#line 2091 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7067), {197, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1752 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7071), {226, 138, 130, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1374 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7074), {195, 149, 0}}, +#line 231 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7075), {196, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 546 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7085), {208, 164, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 286 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7090), {226, 132, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1762 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7096), {226, 165, 185, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 757 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7115), {226, 129, 163, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 175 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7120), {226, 148, 148, 0}}, +#line 9 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7121), {196, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1279 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7127), {226, 137, 184, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 713 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7135), {195, 174, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 2062 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7142), {226, 150, 189, 0}}, +#line 252 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7143), {203, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 662 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7168), {226, 139, 151, 0}}, + {-1,{0}}, {-1,{0}}, +#line 610 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7171), {226, 169, 190, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1282 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7183), {226, 139, 171, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 313 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7198), {226, 139, 158, 0}}, +#line 1753 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7199), {226, 139, 144, 0}}, + {-1,{0}}, +#line 1041 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7201), {208, 188, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1859 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7212), {226, 168, 177, 0}}, + {-1,{0}}, +#line 690 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7214), {226, 164, 165, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1682 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7217), {207, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 324 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7224), {226, 169, 133, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1372 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7230), {195, 184, 0}}, +#line 457 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7231), {226, 159, 191, 0}}, + {-1,{0}}, {-1,{0}}, +#line 891 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7234), {226, 135, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1576 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7245), {226, 135, 140, 0}}, + {-1,{0}}, +#line 803 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7247), {196, 183, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1758 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7256), {226, 171, 129, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 332 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7260), {194, 164, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 896 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7269), {226, 165, 154, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 122 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7274), {226, 152, 133, 0}}, + {-1,{0}}, {-1,{0}}, +#line 320 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7277), {226, 136, 170, 0}}, +#line 973 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7278), {226, 159, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 597 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7294), {196, 162, 0}}, + {-1,{0}}, +#line 1439 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7296), {226, 170, 175, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2113 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7307), {208, 183, 0}}, + {-1,{0}}, +#line 1412 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7309), {226, 132, 142, 0}}, +#line 1343 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7310), {206, 169, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1771 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7317), {226, 171, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1533 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7325), {226, 164, 183, 0}}, +#line 325 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7326), {226, 136, 170, 0}}, +#line 863 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7327), {226, 164, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1763 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7332), {226, 138, 130, 0}}, +#line 1219 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7333), {226, 138, 129, 0}}, +#line 876 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7334), {226, 135, 134, 0}}, + {-1,{0}}, {-1,{0}}, +#line 2044 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7337), {197, 181, 0}}, +#line 1560 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7338), {226, 159, 169, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1283 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7344), {226, 139, 173, 0}}, +#line 1681 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7345), {206, 163, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1222 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7350), {226, 137, 191, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 372 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7364), {194, 180, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1760 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7376), {226, 138, 138, 0}}, + {-1,{0}}, +#line 1456 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7378), {226, 136, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 258 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7385), {226, 138, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1772 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7389), {226, 171, 147, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 297 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7397), {194, 169, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 533 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7403), {206, 183, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 51 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7409), {226, 136, 161, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1083 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7434), {226, 153, 174, 0}}, + {-1,{0}}, +#line 1798 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7436), {226, 171, 132, 0}}, +#line 1084 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7437), {226, 132, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1880 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7443), {226, 150, 185, 0}}, + {-1,{0}}, +#line 375 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7445), {96, 0}}, +#line 172 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7446), {226, 149, 155, 0}}, +#line 287 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7447), {226, 137, 133, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1835 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7451), {226, 140, 149, 0}}, + {-1,{0}}, {-1,{0}}, +#line 281 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7454), {44, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1764 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7460), {226, 139, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1221 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7475), {226, 139, 161, 0}}, +#line 663 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7476), {226, 139, 155, 0}}, +#line 79 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7477), {195, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 326 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7484), {226, 134, 183, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 312 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7491), {226, 164, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 311 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7495), {226, 164, 184, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1765 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7503), {226, 138, 134, 0}}, +#line 1766 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7504), {226, 171, 133, 0}}, +#line 1578 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7505), {226, 134, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 318 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7520), {226, 169, 134, 0}}, +#line 1768 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7521), {226, 138, 138, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 59 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7532), {196, 133, 0}}, +#line 1190 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7533), {226, 139, 182, 0}}, +#line 1582 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7534), {226, 139, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 2088 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7552), {195, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1147 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7563), {226, 135, 141, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1317 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7581), {208, 190, 0}}, +#line 240 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7582), {226, 166, 178, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 467 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7595), {208, 173, 0}}, + {-1,{0}}, {-1,{0}}, +#line 322 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7598), {226, 169, 138, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1881 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7604), {226, 138, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 888 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7615), {226, 134, 148, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1774 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7618), {226, 137, 187, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 425 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7631), {226, 135, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1324 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7641), {197, 146, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 247 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7648), {209, 135, 0}}, +#line 664 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7649), {226, 170, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 42 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7655), {226, 136, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 12 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7662), {226, 136, 190, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1597 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7668), {226, 142, 177, 0}}, + {-1,{0}}, +#line 953 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7670), {226, 142, 176, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1109 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7674), {226, 128, 139, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1082 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7677), {226, 137, 137, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1371 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7686), {195, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1769 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7698), {226, 171, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 71 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7723), {195, 133, 0}}, +#line 176 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7724), {226, 149, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1761 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7730), {226, 170, 191, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 2086 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7742), {226, 139, 128, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 171 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7767), {226, 148, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 189 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7778), {226, 148, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 705 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7800), {226, 137, 142, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 714 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7812), {208, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 70 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7828), {226, 137, 138, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 7 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7841), {195, 161, 0}}, +#line 66 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7842), {226, 137, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1951 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7859), {226, 134, 149, 0}}, + {-1,{0}}, +#line 1113 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7861), {226, 137, 171, 0}}, + {-1,{0}}, +#line 787 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7863), {208, 185, 0}}, + {-1,{0}}, {-1,{0}}, +#line 666 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7866), {226, 137, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 179 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7876), {226, 148, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1314 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7886), {195, 180, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 463 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7900), {195, 138, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1205 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7987), {226, 139, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 124 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8006), {226, 150, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 342 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8032), {226, 132, 184, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1316 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8037), {208, 158, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 681 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8042), {196, 164, 0}}, +#line 1590 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8043), {226, 165, 147, 0}}, +#line 18 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8044), {195, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 556 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8063), {226, 150, 170, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 622 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8084), {226, 139, 153, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 99 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8088), {208, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1426 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8099), {226, 132, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 186 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8104), {226, 149, 161, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1392 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8107), {226, 136, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 712 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8117), {195, 142, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 315 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8129), {226, 134, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 158 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8135), {226, 148, 128, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 39 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8142), {226, 169, 154, 0}}, + {-1,{0}}, +#line 1788 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8144), {226, 153, 170, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1568 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8148), {226, 159, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 785 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8168), {196, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1935 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8174), {95, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1563 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8241), {226, 134, 146, 0}}, +#line 257 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8242), {226, 138, 154, 0}}, +#line 27 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8243), {206, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 885 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8251), {226, 134, 188, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 316 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8258), {226, 164, 189, 0}}, + {-1,{0}}, +#line 1565 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8260), {226, 135, 132, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1994 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8281), {207, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1287 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8300), {226, 132, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 551 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8310), {239, 172, 132, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 984 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8326), {226, 134, 153, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 542 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8340), {226, 132, 176, 0}}, + {-1,{0}}, +#line 1313 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8342), {195, 148, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2090 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8351), {209, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 823 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8375), {206, 187, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1220 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8381), {226, 170, 176, 0}}, +#line 190 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8382), {226, 149, 158, 0}}, + {-1,{0}}, +#line 123 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8384), {226, 150, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 40 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8391), {226, 136, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 2083 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8404), {226, 168, 132, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1074 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8424), {226, 136, 135, 0}}, +#line 185 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8425), {226, 148, 164, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 532 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8438), {206, 151, 0}}, + {-1,{0}}, +#line 16 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8440), {208, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 805 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8474), {208, 186, 0}}, +#line 601 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8475), {208, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 893 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8485), {226, 165, 142, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 230 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8491), {195, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 90 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8495), {226, 136, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 702 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8506), {226, 132, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1393 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8515), {208, 159, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 600 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8521), {208, 147, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 659 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8534), {226, 169, 188, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 822 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8572), {206, 155, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1321 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8627), {226, 168, 184, 0}}, + {-1,{0}}, +#line 884 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8629), {226, 134, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 971 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8672), {226, 159, 188, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 797 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8677), {208, 132, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 866 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8687), {226, 165, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 2084 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8700), {226, 150, 179, 0}}, +#line 1245 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8701), {226, 135, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 544 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8725), {226, 133, 135, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1244 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8735), {226, 134, 155, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 13 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8745), {195, 130, 0}}, +#line 1163 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8746), {226, 129, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 599 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8780), {196, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 41 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8784), {226, 166, 164, 0}}, +#line 327 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8785), {226, 164, 188, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1670 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8791), {208, 169, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2106 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8796), {195, 191, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1759 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8800), {226, 171, 139, 0}}, + {-1,{0}}, {-1,{0}}, +#line 359 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8803), {226, 164, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1628 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8810), {226, 167, 180, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 598 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8826), {196, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 795 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8843), {208, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 652 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8879), {226, 170, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 781 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8922), {209, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1950 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8956), {226, 134, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 330 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8962), {226, 139, 142, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 549 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8972), {239, 172, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2099 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8992), {209, 151, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 389 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9015), {226, 139, 135, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 660 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9026), {226, 170, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1754 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9069), {226, 170, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 890 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9079), {226, 135, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 82 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9085), {195, 164, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1952 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9088), {226, 135, 149, 0}}, + {-1,{0}}, +#line 1575 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9090), {226, 135, 132, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 436 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9151), {226, 135, 129, 0}}, + {-1,{0}}, {-1,{0}}, +#line 435 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9154), {226, 165, 151, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 682 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9162), {196, 165, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1613 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9186), {226, 135, 155, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 972 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9217), {226, 159, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 323 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9239), {226, 138, 141, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 10 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9249), {226, 136, 190, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 695 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9268), {226, 134, 170, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1107 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9271), {226, 128, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1755 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9275), {226, 171, 133, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1900 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9307), {226, 134, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 429 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9320), {226, 135, 130, 0}}, +#line 428 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9321), {226, 135, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 19 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9326), {195, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1534 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9330), {226, 165, 169, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 331 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9349), {226, 139, 143, 0}}, + {-1,{0}}, +#line 707 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9351), {226, 129, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1756 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9360), {226, 138, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 974 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9414), {226, 159, 185, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 239 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9484), {194, 184, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1188 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9505), {226, 136, 137, 0}}, +#line 1777 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9506), {226, 170, 176, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 887 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9554), {226, 134, 148, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1749 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9580), {207, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 31 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9627), {226, 168, 191, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 80 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9741), {195, 163, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1567 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9747), {226, 140, 137, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 889 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9751), {226, 135, 148, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1770 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9767), {226, 171, 135, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2022 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9788), {124, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1589 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9801), {226, 134, 190, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1588 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9804), {226, 165, 148, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1571 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9829), {226, 135, 130, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1570 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9832), {226, 165, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 25 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9836), {226, 132, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 255 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9852), {226, 134, 187, 0}}, +#line 254 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9853), {226, 134, 186, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 780 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9904), {208, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1376 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9936), {226, 168, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 753 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9944), {226, 138, 186, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1845 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9952), {226, 137, 136, 0}}, + {-1,{0}}, {-1,{0}}, +#line 798 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9955), {209, 148, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1203 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9959), {226, 136, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1443 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9963), {226, 170, 185, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 335 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9983), {226, 139, 142, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 72 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9987), {195, 165, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 232 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10023), {196, 137, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1562 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10029), {226, 134, 146, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 752 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10061), {226, 136, 171, 0}}, +#line 2060 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10062), {226, 151, 175, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 796 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10121), {209, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 249 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10206), {226, 156, 147, 0}}, + {-1,{0}}, +#line 2024 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10208), {226, 137, 128, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 182 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10219), {226, 149, 170, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1210 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10240), {226, 167, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1212 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10244), {226, 139, 173, 0}}, +#line 1211 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10245), {226, 139, 171, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 905 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10278), {226, 165, 146, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 181 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10357), {226, 148, 188, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 149 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10395), {226, 167, 137, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2094 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10415), {209, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1757 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10428), {226, 171, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1706 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10445), {208, 172, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1564 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10505), {226, 135, 146, 0}}, + {-1,{0}}, +#line 28 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10507), {206, 177, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1671 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10528), {209, 137, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1707 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10584), {209, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 17 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10704), {208, 176, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2092 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10720), {197, 183, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 116 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10791), {226, 151, 175, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 735 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10808), {226, 133, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 69 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10847), {226, 137, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1800 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10851), {226, 138, 135, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 2042 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10879), {226, 166, 154, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 314 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10888), {226, 139, 159, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1938 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10947), {226, 143, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 14 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str11009), {195, 162, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1773 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str11029), {226, 170, 184, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1039 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str11047), {226, 168, 169, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 47 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str11146), {226, 166, 172, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 44 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str11165), {226, 166, 169, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 48 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str11282), {226, 166, 173, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 55 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str11366), {226, 136, 162, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1025 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str11527), {226, 165, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 46 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str11565), {226, 166, 171, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1899 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str11664), {226, 134, 158, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 339 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str11720), {226, 140, 173, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1750 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str11791), {207, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1072 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str11840), {226, 138, 184, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1561 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str11918), {226, 135, 165, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 867 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str12012), {226, 165, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 871 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str12103), {226, 159, 168, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1629 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str12170), {226, 165, 168, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 328 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str12202), {226, 139, 158, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2105 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str12206), {209, 142, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1024 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str12288), {226, 165, 138, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 674 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str12413), {209, 138, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1573 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str12461), {226, 135, 129, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1574 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str12497), {226, 135, 128, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 673 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str12502), {208, 170, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1767 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str12651), {226, 138, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 384 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str12809), {207, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1917 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str12892), {197, 177, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1785 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str12985), {226, 136, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 336 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str12991), {226, 139, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1916 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str13024), {197, 176, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 49 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str13061), {226, 166, 174, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 50 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str13443), {226, 166, 175, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2021 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str13643), {226, 136, 163, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2023 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str13659), {226, 157, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1566 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str13709), {226, 134, 163, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1320 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str13908), {197, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1781 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str13945), {226, 170, 186, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 45 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str14304), {226, 166, 170, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1319 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str14364), {197, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 317 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str14620), {226, 169, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 43 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str15290), {226, 166, 168, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 329 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str15360), {226, 139, 159, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 333 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str15729), {226, 134, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 334 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str16000), {226, 134, 183, 0}} + }; + + if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH) + { + unsigned int key = hash_entity (str, len); + + if (key <= MAX_HASH_VALUE) + if (len == lengthtable[key]) + { + register const char *s = wordlist[key].entity + entity_pool; + + if (*str == *s && !memcmp (str + 1, s + 1, len - 1)) + return &wordlist[key]; + } + } + return 0; +} diff --git a/cbits/inlines.c b/cbits/inlines.c new file mode 100644 --- /dev/null +++ b/cbits/inlines.c @@ -0,0 +1,1145 @@ +#include +#include +#include + +#include "cmark_ctype.h" +#include "config.h" +#include "node.h" +#include "parser.h" +#include "references.h" +#include "cmark.h" +#include "houdini.h" +#include "utf8.h" +#include "scanners.h" +#include "inlines.h" + + +static const char *EMDASH = "\xE2\x80\x94"; +static const char *ENDASH = "\xE2\x80\x93"; +static const char *ELLIPSES = "\xE2\x80\xA6"; +static const char *LEFTDOUBLEQUOTE = "\xE2\x80\x9C"; +static const char *RIGHTDOUBLEQUOTE = "\xE2\x80\x9D"; +static const char *LEFTSINGLEQUOTE = "\xE2\x80\x98"; +static const char *RIGHTSINGLEQUOTE = "\xE2\x80\x99"; + + +// Macros for creating various kinds of simple. +#define make_str(s) make_literal(CMARK_NODE_TEXT, s) +#define make_code(s) make_literal(CMARK_NODE_CODE, s) +#define make_raw_html(s) make_literal(CMARK_NODE_INLINE_HTML, s) +#define make_linebreak() make_simple(CMARK_NODE_LINEBREAK) +#define make_softbreak() make_simple(CMARK_NODE_SOFTBREAK) +#define make_emph() make_simple(CMARK_NODE_EMPH) +#define make_strong() make_simple(CMARK_NODE_STRONG) + +typedef struct delimiter { + struct delimiter *previous; + struct delimiter *next; + cmark_node *inl_text; + int position; + unsigned char delim_char; + bool can_open; + bool can_close; + bool active; +} delimiter; + +typedef struct { + cmark_chunk input; + int pos; + cmark_reference_map *refmap; + delimiter *last_delim; +} subject; + +static delimiter* +S_insert_emph(subject *subj, delimiter *opener, delimiter *closer); + +static int parse_inline(subject* subj, cmark_node * parent, int options); + +static void subject_from_buf(subject *e, cmark_strbuf *buffer, + cmark_reference_map *refmap); +static int subject_find_special_char(subject *subj, int options); + +static unsigned char *cmark_clean_autolink(cmark_chunk *url, int is_email) +{ + cmark_strbuf buf = GH_BUF_INIT; + + cmark_chunk_trim(url); + + if (url->len == 0) + return NULL; + + if (is_email) + cmark_strbuf_puts(&buf, "mailto:"); + + houdini_unescape_html_f(&buf, url->data, url->len); + return cmark_strbuf_detach(&buf); +} + +static inline cmark_node *make_link(cmark_node *label, unsigned char *url, unsigned char *title) +{ + cmark_node* e = (cmark_node *)calloc(1, sizeof(*e)); + if(e != NULL) { + e->type = CMARK_NODE_LINK; + e->first_child = label; + e->last_child = label; + e->as.link.url = url; + e->as.link.title = title; + e->next = NULL; + label->parent = e; + } + return e; +} + +static inline cmark_node* make_autolink(cmark_node* label, cmark_chunk url, int is_email) +{ + return make_link(label, cmark_clean_autolink(&url, is_email), NULL); +} + +// Create an inline with a literal string value. +static inline cmark_node* make_literal(cmark_node_type t, cmark_chunk s) +{ + cmark_node * e = (cmark_node *)calloc(1, sizeof(*e)); + if(e != NULL) { + e->type = t; + e->as.literal = s; + e->next = NULL; + e->prev = NULL; + e->parent = NULL; + e->first_child = NULL; + e->last_child = NULL; + // These fields aren't used for inlines: + e->start_line = 0; + e->start_column = 0; + e->end_line = 0; + } + return e; +} + +// Create an inline with no value. +static inline cmark_node* make_simple(cmark_node_type t) +{ + cmark_node* e = (cmark_node *)calloc(1, sizeof(*e)); + if(e != NULL) { + e->type = t; + e->next = NULL; + e->prev = NULL; + e->parent = NULL; + e->first_child = NULL; + e->last_child = NULL; + // These fields aren't used for inlines: + e->start_line = 0; + e->start_column = 0; + e->end_line = 0; + } + return e; +} + +static unsigned char *bufdup(const unsigned char *buf) +{ + unsigned char *new_buf = NULL; + + if (buf) { + int len = strlen((char *)buf); + new_buf = (unsigned char *)calloc(len + 1, sizeof(*new_buf)); + if(new_buf != NULL) { + memcpy(new_buf, buf, len + 1); + } + } + + return new_buf; +} + +static void subject_from_buf(subject *e, cmark_strbuf *buffer, + cmark_reference_map *refmap) +{ + e->input.data = buffer->ptr; + e->input.len = buffer->size; + e->input.alloc = 0; + e->pos = 0; + e->refmap = refmap; + e->last_delim = NULL; + + cmark_chunk_rtrim(&e->input); +} + +static inline int isbacktick(int c) +{ + return (c == '`'); +} + +static inline unsigned char peek_char(subject *subj) +{ + return (subj->pos < subj->input.len) ? subj->input.data[subj->pos] : 0; +} + +static inline unsigned char peek_at(subject *subj, int pos) +{ + return subj->input.data[pos]; +} + +// Return true if there are more characters in the subject. +static inline int is_eof(subject* subj) +{ + return (subj->pos >= subj->input.len); +} + +// Advance the subject. Doesn't check for eof. +#define advance(subj) (subj)->pos += 1 + +// Take characters while a predicate holds, and return a string. +static inline cmark_chunk take_while(subject* subj, int (*f)(int)) +{ + unsigned char c; + int startpos = subj->pos; + int len = 0; + + while ((c = peek_char(subj)) && (*f)(c)) { + advance(subj); + len++; + } + + return cmark_chunk_dup(&subj->input, startpos, len); +} + +// Try to process a backtick code span that began with a +// span of ticks of length openticklength length (already +// parsed). Return 0 if you don't find matching closing +// backticks, otherwise return the position in the subject +// after the closing backticks. +static int scan_to_closing_backticks(subject* subj, int openticklength) +{ + // read non backticks + unsigned char c; + while ((c = peek_char(subj)) && c != '`') { + advance(subj); + } + if (is_eof(subj)) { + return 0; // did not find closing ticks, return 0 + } + int numticks = 0; + while (peek_char(subj) == '`') { + advance(subj); + numticks++; + } + if (numticks != openticklength) { + return(scan_to_closing_backticks(subj, openticklength)); + } + return (subj->pos); +} + +// Parse backtick code section or raw backticks, return an inline. +// Assumes that the subject has a backtick at the current position. +static cmark_node* handle_backticks(subject *subj) +{ + cmark_chunk openticks = take_while(subj, isbacktick); + int startpos = subj->pos; + int endpos = scan_to_closing_backticks(subj, openticks.len); + + if (endpos == 0) { // not found + subj->pos = startpos; // rewind + return make_str(openticks); + } else { + cmark_strbuf buf = GH_BUF_INIT; + + cmark_strbuf_set(&buf, subj->input.data + startpos, endpos - startpos - openticks.len); + cmark_strbuf_trim(&buf); + cmark_strbuf_normalize_whitespace(&buf); + + return make_code(cmark_chunk_buf_detach(&buf)); + } +} + +// Scan ***, **, or * and return number scanned, or 0. +// Advances position. +static int +scan_delims(subject* subj, unsigned char c, bool * can_open, bool * can_close) +{ + int numdelims = 0; + int before_char_pos; + int32_t after_char = 0; + int32_t before_char = 0; + int len; + bool left_flanking, right_flanking; + + if (subj->pos == 0) { + before_char = 10; + } else { + before_char_pos = subj->pos - 1; + // walk back to the beginning of the UTF_8 sequence: + while (peek_at(subj, before_char_pos) >> 6 == 2 && + before_char_pos > 0) { + before_char_pos -= 1; + } + len = utf8proc_iterate(subj->input.data + before_char_pos, + subj->pos - before_char_pos, &before_char); + if (len == -1) { + before_char = 10; + } + } + + if (c == '\'' || c == '"') { + numdelims++; + advance(subj); // limit to 1 delim for quotes + } else { + while (peek_char(subj) == c) { + numdelims++; + advance(subj); + } + } + + len = utf8proc_iterate(subj->input.data + subj->pos, + subj->input.len - subj->pos, &after_char); + if (len == -1) { + after_char = 10; + } + left_flanking = numdelims > 0 && !utf8proc_is_space(after_char) && + !(utf8proc_is_punctuation(after_char) && + !utf8proc_is_space(before_char) && + !utf8proc_is_punctuation(before_char)); + right_flanking = numdelims > 0 && !utf8proc_is_space(before_char) && + !(utf8proc_is_punctuation(before_char) && + !utf8proc_is_space(after_char) && + !utf8proc_is_punctuation(after_char)); + if (c == '_') { + *can_open = left_flanking && !right_flanking; + *can_close = right_flanking && !left_flanking; + } else if (c == '\'' || c == '"') { + *can_open = left_flanking && !right_flanking; + *can_close = right_flanking; + } else { + *can_open = left_flanking; + *can_close = right_flanking; + } + return numdelims; +} + +/* +static void print_delimiters(subject *subj) +{ + delimiter *delim; + delim = subj->last_delim; + while (delim != NULL) { + printf("Item at %p: %d %d %d next(%p) prev(%p)\n", + delim, delim->delim_char, + delim->can_open, delim->can_close, + delim->next, delim->previous); + delim = delim->previous; + } +} +*/ + +static void remove_delimiter(subject *subj, delimiter *delim) +{ + if (delim == NULL) return; + if (delim->next == NULL) { + // end of list: + assert(delim == subj->last_delim); + subj->last_delim = delim->previous; + } else { + delim->next->previous = delim->previous; + } + if (delim->previous != NULL) { + delim->previous->next = delim->next; + } + free(delim); +} + +static void push_delimiter(subject *subj, unsigned char c, bool can_open, + bool can_close, cmark_node *inl_text) +{ + delimiter *delim = + (delimiter*)malloc(sizeof(delimiter)); + if (delim == NULL) { + return; + } + delim->delim_char = c; + delim->can_open = can_open; + delim->can_close = can_close; + delim->inl_text = inl_text; + delim->previous = subj->last_delim; + delim->next = NULL; + if (delim->previous != NULL) { + delim->previous->next = delim; + } + delim->position = subj->pos; + delim->active = true; + subj->last_delim = delim; +} + +// Assumes the subject has a c at the current position. +static cmark_node* handle_delim(subject* subj, unsigned char c, bool smart) +{ + int numdelims; + cmark_node * inl_text; + bool can_open, can_close; + cmark_chunk contents; + + numdelims = scan_delims(subj, c, &can_open, &can_close); + + if (c == '\'' && smart) { + contents = cmark_chunk_literal(RIGHTSINGLEQUOTE); + } else if (c == '"' && smart) { + contents = cmark_chunk_literal(can_close ? RIGHTDOUBLEQUOTE : LEFTDOUBLEQUOTE); + } else { + contents = cmark_chunk_dup(&subj->input, subj->pos - numdelims, numdelims); + } + + inl_text = make_str(contents); + + if ((can_open || can_close) && + (!(c == '\'' || c == '"') || smart)) { + push_delimiter(subj, c, can_open, can_close, inl_text); + } + + return inl_text; +} + +// Assumes we have a hyphen at the current position. +static cmark_node* handle_hyphen(subject* subj, bool smart) +{ + advance(subj); + if (smart && peek_char(subj) == '-') { + advance(subj); + if (peek_char(subj) == '-') { + advance(subj); + return make_str(cmark_chunk_literal(EMDASH)); + } else { + return make_str(cmark_chunk_literal(ENDASH)); + } + } else { + return make_str(cmark_chunk_literal("-")); + } +} + +// Assumes we have a period at the current position. +static cmark_node* handle_period(subject* subj, bool smart) +{ + advance(subj); + if (smart && peek_char(subj) == '.') { + advance(subj); + if (peek_char(subj) == '.') { + advance(subj); + return make_str(cmark_chunk_literal(ELLIPSES)); + } else { + return make_str(cmark_chunk_literal("..")); + } + } else { + return make_str(cmark_chunk_literal(".")); + } +} + +static void process_emphasis(subject *subj, delimiter *start_delim) +{ + delimiter *closer = subj->last_delim; + delimiter *opener; + + // move back to first relevant delim. + while (closer != NULL && closer->previous != start_delim) { + closer = closer->previous; + } + + // now move forward, looking for closers, and handling each + while (closer != NULL) { + if (closer->can_close && + (closer->delim_char == '*' || closer->delim_char == '_' || + closer->delim_char == '"' || closer->delim_char == '\'')) { + // Now look backwards for first matching opener: + opener = closer->previous; + while (opener != NULL && opener != start_delim) { + if (opener->delim_char == closer->delim_char && + opener->can_open) { + break; + } + opener = opener->previous; + } + if (closer->delim_char == '*' || closer->delim_char == '_') { + if (opener != NULL && opener != start_delim) { + closer = S_insert_emph(subj, opener, closer); + } else { + closer = closer->next; + } + } else if (closer->delim_char == '\'') { + cmark_chunk_free(&closer->inl_text->as.literal); + closer->inl_text->as.literal = + cmark_chunk_literal(RIGHTSINGLEQUOTE); + if (opener != NULL && opener != start_delim) { + cmark_chunk_free(&opener->inl_text->as.literal); + opener->inl_text->as.literal = + cmark_chunk_literal(LEFTSINGLEQUOTE); + } + closer = closer->next; + } else if (closer->delim_char == '"') { + cmark_chunk_free(&closer->inl_text->as.literal); + closer->inl_text->as.literal = + cmark_chunk_literal(RIGHTDOUBLEQUOTE); + if (opener != NULL && opener != start_delim) { + cmark_chunk_free(&opener->inl_text->as.literal); + opener->inl_text->as.literal = + cmark_chunk_literal(LEFTDOUBLEQUOTE); + } + closer = closer->next; + } + } else { + closer = closer->next; + } + } + // free all delimiters in list until start_delim: + while (subj->last_delim != start_delim) { + remove_delimiter(subj, subj->last_delim); + } +} + +static delimiter* +S_insert_emph(subject *subj, delimiter *opener, delimiter *closer) +{ + delimiter *delim, *tmp_delim; + int use_delims; + cmark_node *opener_inl = opener->inl_text; + cmark_node *closer_inl = closer->inl_text; + int opener_num_chars = opener_inl->as.literal.len; + int closer_num_chars = closer_inl->as.literal.len; + cmark_node *tmp, *emph, *first_child, *last_child; + + // calculate the actual number of characters used from this closer + if (closer_num_chars < 3 || opener_num_chars < 3) { + use_delims = closer_num_chars <= opener_num_chars ? + closer_num_chars : opener_num_chars; + } else { // closer and opener both have >= 3 characters + use_delims = closer_num_chars % 2 == 0 ? 2 : 1; + } + + // remove used characters from associated inlines. + opener_num_chars -= use_delims; + closer_num_chars -= use_delims; + opener_inl->as.literal.len = opener_num_chars; + closer_inl->as.literal.len = closer_num_chars; + + // free delimiters between opener and closer + delim = closer->previous; + while (delim != NULL && delim != opener) { + tmp_delim = delim->previous; + remove_delimiter(subj, delim); + delim = tmp_delim; + } + + first_child = opener_inl->next; + last_child = closer_inl->prev; + + // if opener has 0 characters, remove it and its associated inline + if (opener_num_chars == 0) { + // replace empty opener inline with emph + cmark_chunk_free(&(opener_inl->as.literal)); + emph = opener_inl; + emph->type = use_delims == 1 ? NODE_EMPH : NODE_STRONG; + // remove opener from list + remove_delimiter(subj, opener); + } else { + // create new emph or strong, and splice it in to our inlines + // between the opener and closer + emph = use_delims == 1 ? make_emph() : make_strong(); + emph->parent = opener_inl->parent; + emph->prev = opener_inl; + opener_inl->next = emph; + } + + // push children below emph + emph->next = closer_inl; + closer_inl->prev = emph; + emph->first_child = first_child; + emph->last_child = last_child; + + // fix children pointers + first_child->prev = NULL; + last_child->next = NULL; + for (tmp = first_child; tmp != NULL; tmp = tmp->next) { + tmp->parent = emph; + } + + // if closer has 0 characters, remove it and its associated inline + if (closer_num_chars == 0) { + // remove empty closer inline + cmark_node_free(closer_inl); + // remove closer from list + tmp_delim = closer->next; + remove_delimiter(subj, closer); + closer = tmp_delim; + } + + return closer; +} + +// Parse backslash-escape or just a backslash, returning an inline. +static cmark_node* handle_backslash(subject *subj) +{ + advance(subj); + unsigned char nextchar = peek_char(subj); + if (cmark_ispunct(nextchar)) { // only ascii symbols and newline can be escaped + advance(subj); + return make_str(cmark_chunk_dup(&subj->input, subj->pos - 1, 1)); + } else if (nextchar == '\n') { + advance(subj); + return make_linebreak(); + } else { + return make_str(cmark_chunk_literal("\\")); + } +} + +// Parse an entity or a regular "&" string. +// Assumes the subject has an '&' character at the current position. +static cmark_node* handle_entity(subject* subj) +{ + cmark_strbuf ent = GH_BUF_INIT; + size_t len; + + advance(subj); + + len = houdini_unescape_ent(&ent, + subj->input.data + subj->pos, + subj->input.len - subj->pos + ); + + if (len == 0) + return make_str(cmark_chunk_literal("&")); + + subj->pos += len; + return make_str(cmark_chunk_buf_detach(&ent)); +} + +// Like make_str, but parses entities. +// Returns an inline sequence consisting of str and entity elements. +static cmark_node *make_str_with_entities(cmark_chunk *content) +{ + cmark_strbuf unescaped = GH_BUF_INIT; + + if (houdini_unescape_html(&unescaped, content->data, (size_t)content->len)) { + return make_str(cmark_chunk_buf_detach(&unescaped)); + } else { + return make_str(*content); + } +} + +// Clean a URL: remove surrounding whitespace and surrounding <>, +// and remove \ that escape punctuation. +unsigned char *cmark_clean_url(cmark_chunk *url) +{ + cmark_strbuf buf = GH_BUF_INIT; + + cmark_chunk_trim(url); + + if (url->len == 0) + return NULL; + + if (url->data[0] == '<' && url->data[url->len - 1] == '>') { + houdini_unescape_html_f(&buf, url->data + 1, url->len - 2); + } else { + houdini_unescape_html_f(&buf, url->data, url->len); + } + + cmark_strbuf_unescape(&buf); + return cmark_strbuf_detach(&buf); +} + +unsigned char *cmark_clean_title(cmark_chunk *title) +{ + cmark_strbuf buf = GH_BUF_INIT; + unsigned char first, last; + + if (title->len == 0) + return NULL; + + first = title->data[0]; + last = title->data[title->len - 1]; + + // remove surrounding quotes if any: + if ((first == '\'' && last == '\'') || + (first == '(' && last == ')') || + (first == '"' && last == '"')) { + houdini_unescape_html_f(&buf, title->data + 1, title->len - 2); + } else { + houdini_unescape_html_f(&buf, title->data, title->len); + } + + cmark_strbuf_unescape(&buf); + return cmark_strbuf_detach(&buf); +} + +// Parse an autolink or HTML tag. +// Assumes the subject has a '<' character at the current position. +static cmark_node* handle_pointy_brace(subject* subj) +{ + int matchlen = 0; + cmark_chunk contents; + + advance(subj); // advance past first < + + // first try to match a URL autolink + matchlen = scan_autolink_uri(&subj->input, subj->pos); + if (matchlen > 0) { + contents = cmark_chunk_dup(&subj->input, subj->pos, matchlen - 1); + subj->pos += matchlen; + + return make_autolink( + make_str_with_entities(&contents), + contents, 0 + ); + } + + // next try to match an email autolink + matchlen = scan_autolink_email(&subj->input, subj->pos); + if (matchlen > 0) { + contents = cmark_chunk_dup(&subj->input, subj->pos, matchlen - 1); + subj->pos += matchlen; + + return make_autolink( + make_str_with_entities(&contents), + contents, 1 + ); + } + + // finally, try to match an html tag + matchlen = scan_html_tag(&subj->input, subj->pos); + if (matchlen > 0) { + contents = cmark_chunk_dup(&subj->input, subj->pos - 1, matchlen + 1); + subj->pos += matchlen; + return make_raw_html(contents); + } + + // if nothing matches, just return the opening <: + return make_str(cmark_chunk_literal("<")); +} + +// Parse a link label. Returns 1 if successful. +// Note: unescaped brackets are not allowed in labels. +// The label begins with `[` and ends with the first `]` character +// encountered. Backticks in labels do not start code spans. +static int link_label(subject* subj, cmark_chunk *raw_label) +{ + int startpos = subj->pos; + int length = 0; + unsigned char c; + + // advance past [ + if (peek_char(subj) == '[') { + advance(subj); + } else { + return 0; + } + + while ((c = peek_char(subj)) && c != '[' && c != ']') { + if (c == '\\') { + advance(subj); + length++; + if (cmark_ispunct(peek_char(subj))) { + advance(subj); + length++; + } + } else { + advance(subj); + length++; + } + if (length > MAX_LINK_LABEL_LENGTH) { + goto noMatch; + } + } + + if (c == ']') { // match found + *raw_label = cmark_chunk_dup(&subj->input, startpos + 1, subj->pos - (startpos + 1)); + advance(subj); // advance past ] + return 1; + } + +noMatch: + subj->pos = startpos; // rewind + return 0; + +} + +// Return a link, an image, or a literal close bracket. +static cmark_node* handle_close_bracket(subject* subj, cmark_node *parent) +{ + int initial_pos; + int starturl, endurl, starttitle, endtitle, endall; + int n; + int sps; + cmark_reference *ref; + bool is_image = false; + cmark_chunk url_chunk, title_chunk; + unsigned char *url, *title; + delimiter *opener; + cmark_node *link_text; + cmark_node *inl; + cmark_chunk raw_label; + int found_label; + + advance(subj); // advance past ] + initial_pos = subj->pos; + + // look through list of delimiters for a [ or ! + opener = subj->last_delim; + while (opener) { + if (opener->delim_char == '[' || opener->delim_char == '!') { + break; + } + opener = opener->previous; + } + + if (opener == NULL) { + return make_str(cmark_chunk_literal("]")); + } + + if (!opener->active) { + // take delimiter off stack + remove_delimiter(subj, opener); + return make_str(cmark_chunk_literal("]")); + } + + // If we got here, we matched a potential link/image text. + is_image = opener->delim_char == '!'; + link_text = opener->inl_text->next; + + // Now we check to see if it's a link/image. + + // First, look for an inline link. + if (peek_char(subj) == '(' && + ((sps = scan_spacechars(&subj->input, subj->pos + 1)) > -1) && + ((n = scan_link_url(&subj->input, subj->pos + 1 + sps)) > -1)) { + + // try to parse an explicit link: + starturl = subj->pos + 1 + sps; // after ( + endurl = starturl + n; + starttitle = endurl + scan_spacechars(&subj->input, endurl); + + // ensure there are spaces btw url and title + endtitle = (starttitle == endurl) ? starttitle : + starttitle + scan_link_title(&subj->input, starttitle); + + endall = endtitle + scan_spacechars(&subj->input, endtitle); + + if (peek_at(subj, endall) == ')') { + subj->pos = endall + 1; + + url_chunk = cmark_chunk_dup(&subj->input, starturl, endurl - starturl); + title_chunk = cmark_chunk_dup(&subj->input, starttitle, endtitle - starttitle); + url = cmark_clean_url(&url_chunk); + title = cmark_clean_title(&title_chunk); + cmark_chunk_free(&url_chunk); + cmark_chunk_free(&title_chunk); + goto match; + + } else { + goto noMatch; + } + } + + // Next, look for a following [link label] that matches in refmap. + // skip spaces + subj->pos = subj->pos + scan_spacechars(&subj->input, subj->pos); + raw_label = cmark_chunk_literal(""); + found_label = link_label(subj, &raw_label); + if (!found_label || raw_label.len == 0) { + cmark_chunk_free(&raw_label); + raw_label = cmark_chunk_dup(&subj->input, opener->position, + initial_pos - opener->position - 1); + } + + if (!found_label) { + // If we have a shortcut reference link, back up + // to before the spacse we skipped. + subj->pos = initial_pos; + } + + ref = cmark_reference_lookup(subj->refmap, &raw_label); + cmark_chunk_free(&raw_label); + + if (ref != NULL) { // found + url = bufdup(ref->url); + title = bufdup(ref->title); + goto match; + } else { + goto noMatch; + } + +noMatch: + // If we fall through to here, it means we didn't match a link: + remove_delimiter(subj, opener); // remove this opener from delimiter list + subj->pos = initial_pos; + return make_str(cmark_chunk_literal("]")); + +match: + inl = opener->inl_text; + inl->type = is_image ? NODE_IMAGE : NODE_LINK; + cmark_chunk_free(&inl->as.literal); + inl->first_child = link_text; + process_emphasis(subj, opener->previous); + inl->as.link.url = url; + inl->as.link.title = title; + inl->next = NULL; + if (link_text) { + cmark_node *tmp; + link_text->prev = NULL; + for (tmp = link_text; tmp->next != NULL; tmp = tmp->next) { + tmp->parent = inl; + } + tmp->parent = inl; + inl->last_child = tmp; + } + parent->last_child = inl; + + // process_emphasis will remove this delimiter and all later ones. + // Now, if we have a link, we also want to deactivate earlier link + // delimiters. (This code can be removed if we decide to allow links + // inside links.) + if (!is_image) { + opener = subj->last_delim; + while (opener != NULL) { + if (opener->delim_char == '[') { + if (!opener->active) { + break; + } else { + opener->active = false; + } + } + opener = opener->previous; + } + } + + return NULL; +} + +// Parse a hard or soft linebreak, returning an inline. +// Assumes the subject has a newline at the current position. +static cmark_node* handle_newline(subject *subj) +{ + int nlpos = subj->pos; + // skip over newline + advance(subj); + // skip spaces at beginning of line + while (peek_char(subj) == ' ') { + advance(subj); + } + if (nlpos > 1 && + peek_at(subj, nlpos - 1) == ' ' && + peek_at(subj, nlpos - 2) == ' ') { + return make_linebreak(); + } else { + return make_softbreak(); + } +} + +static int subject_find_special_char(subject *subj, int options) +{ + // "\n\\`&_*[]pos + 1; + + while (n < subj->input.len) { + if (SPECIAL_CHARS[subj->input.data[n]]) + return n; + if (options & CMARK_OPT_SMART && + SMART_PUNCT_CHARS[subj->input.data[n]]) + return n; + n++; + } + + return subj->input.len; +} + +// Parse an inline, advancing subject, and add it as a child of parent. +// Return 0 if no inline can be parsed, 1 otherwise. +static int parse_inline(subject* subj, cmark_node * parent, int options) +{ + cmark_node* new_inl = NULL; + cmark_chunk contents; + unsigned char c; + int endpos; + c = peek_char(subj); + if (c == 0) { + return 0; + } + switch(c) { + case '\n': + new_inl = handle_newline(subj); + break; + case '`': + new_inl = handle_backticks(subj); + break; + case '\\': + new_inl = handle_backslash(subj); + break; + case '&': + new_inl = handle_entity(subj); + break; + case '<': + new_inl = handle_pointy_brace(subj); + break; + case '*': + case '_': + case '\'': + case '"': + new_inl = handle_delim(subj, c, options & CMARK_OPT_SMART); + break; + case '-': + new_inl = handle_hyphen(subj, options & CMARK_OPT_SMART); + break; + case '.': + new_inl = handle_period(subj, options & CMARK_OPT_SMART); + break; + case '[': + advance(subj); + new_inl = make_str(cmark_chunk_literal("[")); + push_delimiter(subj, '[', true, false, new_inl); + break; + case ']': + new_inl = handle_close_bracket(subj, parent); + break; + case '!': + advance(subj); + if (peek_char(subj) == '[') { + advance(subj); + new_inl = make_str(cmark_chunk_literal("![")); + push_delimiter(subj, '!', false, true, new_inl); + } else { + new_inl = make_str(cmark_chunk_literal("!")); + } + break; + default: + endpos = subject_find_special_char(subj, options); + contents = cmark_chunk_dup(&subj->input, subj->pos, endpos - subj->pos); + subj->pos = endpos; + + // if we're at a newline, strip trailing spaces. + if (peek_char(subj) == '\n') { + cmark_chunk_rtrim(&contents); + } + + new_inl = make_str(contents); + } + if (new_inl != NULL) { + cmark_node_append_child(parent, new_inl); + } + + return 1; +} + +// Parse inlines from parent's string_content, adding as children of parent. +extern void cmark_parse_inlines(cmark_node* parent, cmark_reference_map *refmap, int options) +{ + subject subj; + subject_from_buf(&subj, &parent->string_content, refmap); + + while (!is_eof(&subj) && parse_inline(&subj, parent, options)) ; + + process_emphasis(&subj, NULL); +} + +// Parse zero or more space characters, including at most one newline. +static void spnl(subject* subj) +{ + bool seen_newline = false; + while (peek_char(subj) == ' ' || + (!seen_newline && + (seen_newline = peek_char(subj) == '\n'))) { + advance(subj); + } +} + +// Parse reference. Assumes string begins with '[' character. +// Modify refmap if a reference is encountered. +// Return 0 if no reference found, otherwise position of subject +// after reference is parsed. +int cmark_parse_reference_inline(cmark_strbuf *input, cmark_reference_map *refmap) +{ + subject subj; + + cmark_chunk lab; + cmark_chunk url; + cmark_chunk title; + + int matchlen = 0; + int beforetitle; + + subject_from_buf(&subj, input, NULL); + + // parse label: + if (!link_label(&subj, &lab)) + return 0; + + // colon: + if (peek_char(&subj) == ':') { + advance(&subj); + } else { + return 0; + } + + // parse link url: + spnl(&subj); + matchlen = scan_link_url(&subj.input, subj.pos); + if (matchlen) { + url = cmark_chunk_dup(&subj.input, subj.pos, matchlen); + subj.pos += matchlen; + } else { + return 0; + } + + // parse optional link_title + beforetitle = subj.pos; + spnl(&subj); + matchlen = scan_link_title(&subj.input, subj.pos); + if (matchlen) { + title = cmark_chunk_dup(&subj.input, subj.pos, matchlen); + subj.pos += matchlen; + } else { + subj.pos = beforetitle; + title = cmark_chunk_literal(""); + } + // parse final spaces and newline: + while (peek_char(&subj) == ' ') { + advance(&subj); + } + if (peek_char(&subj) == '\n') { + advance(&subj); + } else if (peek_char(&subj) != 0) { + return 0; + } + // insert reference into refmap + cmark_reference_create(refmap, &lab, &url, &title); + return subj.pos; +} diff --git a/cbits/inlines.h b/cbits/inlines.h new file mode 100644 --- /dev/null +++ b/cbits/inlines.h @@ -0,0 +1,19 @@ +#ifndef CMARK_INLINES_H +#define CMARK_INLINES_H + +#ifdef __cplusplus +extern "C" { +#endif + +unsigned char *cmark_clean_url(cmark_chunk *url); +unsigned char *cmark_clean_title(cmark_chunk *title); + +void cmark_parse_inlines(cmark_node* parent, cmark_reference_map *refmap, int options); + +int cmark_parse_reference_inline(cmark_strbuf *input, cmark_reference_map *refmap); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/cbits/iterator.c b/cbits/iterator.c new file mode 100644 --- /dev/null +++ b/cbits/iterator.c @@ -0,0 +1,146 @@ +#include +#include + +#include "config.h" +#include "node.h" +#include "cmark.h" +#include "iterator.h" + +static const int S_leaf_mask = + (1 << CMARK_NODE_HTML) | + (1 << CMARK_NODE_HRULE) | + (1 << CMARK_NODE_CODE_BLOCK) | + (1 << CMARK_NODE_TEXT) | + (1 << CMARK_NODE_SOFTBREAK) | + (1 << CMARK_NODE_LINEBREAK) | + (1 << CMARK_NODE_CODE) | + (1 << CMARK_NODE_INLINE_HTML); + +cmark_iter* +cmark_iter_new(cmark_node *root) +{ + if (root == NULL) { + return NULL; + } + cmark_iter *iter = (cmark_iter*)malloc(sizeof(cmark_iter)); + if (iter == NULL) { + return NULL; + } + iter->root = root; + iter->cur.ev_type = CMARK_EVENT_NONE; + iter->cur.node = NULL; + iter->next.ev_type = CMARK_EVENT_ENTER; + iter->next.node = root; + return iter; +} + +void +cmark_iter_free(cmark_iter *iter) +{ + free(iter); +} + +static bool +S_is_leaf(cmark_node *node) +{ + return (1 << node->type) & S_leaf_mask; +} + +cmark_event_type +cmark_iter_next(cmark_iter *iter) +{ + cmark_event_type ev_type = iter->next.ev_type; + cmark_node *node = iter->next.node; + + iter->cur.ev_type = ev_type; + iter->cur.node = node; + + if (ev_type == CMARK_EVENT_DONE) { + return ev_type; + } + + /* roll forward to next item, setting both fields */ + if (ev_type == CMARK_EVENT_ENTER && !S_is_leaf(node)) { + if (node->first_child == NULL) { + /* stay on this node but exit */ + iter->next.ev_type = CMARK_EVENT_EXIT; + } else { + iter->next.ev_type = CMARK_EVENT_ENTER; + iter->next.node = node->first_child; + } + } else if (node == iter->root) { + /* don't move past root */ + iter->next.ev_type = CMARK_EVENT_DONE; + iter->next.node = NULL; + } else if (node->next) { + iter->next.ev_type = CMARK_EVENT_ENTER; + iter->next.node = node->next; + } else if (node->parent) { + iter->next.ev_type = CMARK_EVENT_EXIT; + iter->next.node = node->parent; + } else { + assert(false); + iter->next.ev_type = CMARK_EVENT_DONE; + iter->next.node = NULL; + } + + return ev_type; +} + +void +cmark_iter_reset(cmark_iter *iter, cmark_node *current, + cmark_event_type event_type) +{ + iter->next.ev_type = event_type; + iter->next.node = current; + cmark_iter_next(iter); +} + +cmark_node* +cmark_iter_get_node(cmark_iter *iter) +{ + return iter->cur.node; +} + +cmark_event_type +cmark_iter_get_event_type(cmark_iter *iter) +{ + return iter->cur.ev_type; +} + +cmark_node* +cmark_iter_get_root(cmark_iter *iter) +{ + return iter->root; +} + + +void cmark_consolidate_text_nodes(cmark_node *root) +{ + cmark_iter *iter = cmark_iter_new(root); + cmark_strbuf buf = GH_BUF_INIT; + cmark_event_type ev_type; + cmark_node *cur, *tmp, *next; + + while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { + cur = cmark_iter_get_node(iter); + if (ev_type == CMARK_EVENT_ENTER && + cur->type == CMARK_NODE_TEXT && + cur->next && + cur->next->type == CMARK_NODE_TEXT) { + cmark_strbuf_clear(&buf); + cmark_strbuf_puts(&buf, cmark_node_get_literal(cur)); + tmp = cur->next; + while (tmp && tmp->type == CMARK_NODE_TEXT) { + cmark_iter_next(iter); // advance pointer + cmark_strbuf_puts(&buf, cmark_node_get_literal(tmp)); + next = tmp->next; + cmark_node_free(tmp); + tmp = next; + } + cmark_node_set_literal(cur, (char *)cmark_strbuf_detach(&buf)); + } + } + + cmark_iter_free(iter); +} diff --git a/cbits/iterator.h b/cbits/iterator.h new file mode 100644 --- /dev/null +++ b/cbits/iterator.h @@ -0,0 +1,25 @@ +#ifndef CMARK_ITERATOR_H +#define CMARK_ITERATOR_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "cmark.h" + +typedef struct { + cmark_event_type ev_type; + cmark_node *node; +} cmark_iter_state; + +struct cmark_iter { + cmark_node *root; + cmark_iter_state cur; + cmark_iter_state next; +}; + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/cbits/man.c b/cbits/man.c new file mode 100644 --- /dev/null +++ b/cbits/man.c @@ -0,0 +1,284 @@ +#include +#include +#include +#include + +#include "config.h" +#include "cmark.h" +#include "node.h" +#include "buffer.h" +#include "utf8.h" + +// Functions to convert cmark_nodes to groff man strings. + +static void escape_man(cmark_strbuf *dest, const unsigned char *source, int length) +{ + int32_t c; + int i = 0; + int len; + bool beginLine = true; + + while (i < length) { + len = utf8proc_iterate(source + i, length - i, &c); + switch(c) { + case 46: + if (beginLine) { + cmark_strbuf_puts(dest, "\\&."); + } else { + utf8proc_encode_char(c, dest); + } + break; + case 39: + if (beginLine) { + cmark_strbuf_puts(dest, "\\&'"); + } else { + utf8proc_encode_char(c, dest); + } + break; + case 45: + cmark_strbuf_puts(dest, "\\-"); + break; + case 92: + cmark_strbuf_puts(dest, "\\e"); + break; + case 8216: // left single quote + cmark_strbuf_puts(dest, "\\[oq]"); + break; + case 8217: // right single quote + cmark_strbuf_puts(dest, "\\[cq]"); + break; + case 8220: // left double quote + cmark_strbuf_puts(dest, "\\[lq]"); + break; + case 8221: // right double quote + cmark_strbuf_puts(dest, "\\[rq]"); + break; + case 8212: // em dash + cmark_strbuf_puts(dest, "\\[em]"); + break; + case 8211: // en dash + cmark_strbuf_puts(dest, "\\[en]"); + break; + default: + utf8proc_encode_char(c, dest); + } + beginLine = (c == 10); + i += len; + } +} + +static inline void cr(cmark_strbuf *man) +{ + if (man->size && man->ptr[man->size - 1] != '\n') + cmark_strbuf_putc(man, '\n'); +} + +struct render_state { + cmark_strbuf* man; + cmark_node *plain; +}; + +static int +S_render_node(cmark_node *node, cmark_event_type ev_type, + struct render_state *state) +{ + cmark_node *tmp; + cmark_strbuf *man = state->man; + int list_number; + bool entering = (ev_type == CMARK_EVENT_ENTER); + + if (state->plain == node) { // back at original node + state->plain = NULL; + } + + if (state->plain != NULL) { + switch(node->type) { + case CMARK_NODE_TEXT: + case CMARK_NODE_CODE: + escape_man(man, node->as.literal.data, + node->as.literal.len); + break; + + case CMARK_NODE_LINEBREAK: + case CMARK_NODE_SOFTBREAK: + cmark_strbuf_putc(man, ' '); + break; + + default: + break; + } + return 1; + } + + switch (node->type) { + case CMARK_NODE_DOCUMENT: + break; + + case CMARK_NODE_BLOCK_QUOTE: + if (entering) { + cr(man); + cmark_strbuf_puts(man, ".RS"); + cr(man); + } else { + cr(man); + cmark_strbuf_puts(man, ".RE"); + cr(man); + } + break; + + case CMARK_NODE_LIST: + break; + + case CMARK_NODE_ITEM: + if (entering) { + cr(man); + cmark_strbuf_puts(man, ".IP "); + if (cmark_node_get_list_type(node->parent) == + CMARK_BULLET_LIST) { + cmark_strbuf_puts(man, "\\[bu] 2"); + } else { + list_number = cmark_node_get_list_start(node->parent); + tmp = node; + while (tmp->prev) { + tmp = tmp->prev; + list_number += 1; + } + cmark_strbuf_printf(man, "\"%d.\" 4", list_number); + } + cr(man); + } else { + cr(man); + } + break; + + case CMARK_NODE_HEADER: + if (entering) { + cr(man); + cmark_strbuf_puts(man, + cmark_node_get_header_level(node) == 1 ? + ".SH" : ".SS"); + cr(man); + } else { + cr(man); + } + break; + + case CMARK_NODE_CODE_BLOCK: + cr(man); + cmark_strbuf_puts(man, ".IP\n.nf\n\\f[C]\n"); + escape_man(man, node->as.code.literal.data, + node->as.code.literal.len); + cr(man); + cmark_strbuf_puts(man, "\\f[]\n.fi"); + cr(man); + break; + + case CMARK_NODE_HTML: + break; + + case CMARK_NODE_HRULE: + cr(man); + cmark_strbuf_puts(man, ".PP\n * * * * *"); + cr(man); + break; + + case CMARK_NODE_PARAGRAPH: + if (entering) { + // no blank line if first paragraph in list: + if (node->parent && + node->parent->type == CMARK_NODE_ITEM && + node->prev == NULL) { + // no blank line or .PP + } else { + cr(man); + cmark_strbuf_puts(man, ".PP\n"); + } + } else { + cr(man); + } + break; + + case CMARK_NODE_TEXT: + escape_man(man, node->as.literal.data, + node->as.literal.len); + break; + + case CMARK_NODE_LINEBREAK: + cmark_strbuf_puts(man, ".PD 0\n.P\n.PD"); + cr(man); + break; + + case CMARK_NODE_SOFTBREAK: + cmark_strbuf_putc(man, '\n'); + break; + + case CMARK_NODE_CODE: + cmark_strbuf_puts(man, "\\f[C]"); + escape_man(man, node->as.literal.data, node->as.literal.len); + cmark_strbuf_puts(man, "\\f[]"); + break; + + case CMARK_NODE_INLINE_HTML: + break; + + case CMARK_NODE_STRONG: + if (entering) { + cmark_strbuf_puts(man, "\\f[B]"); + } else { + cmark_strbuf_puts(man, "\\f[]"); + } + break; + + case CMARK_NODE_EMPH: + if (entering) { + cmark_strbuf_puts(man, "\\f[I]"); + } else { + cmark_strbuf_puts(man, "\\f[]"); + } + break; + + case CMARK_NODE_LINK: + if (!entering) { + cmark_strbuf_printf(man, " (%s)", + cmark_node_get_url(node)); + } + break; + + case CMARK_NODE_IMAGE: + if (entering) { + cmark_strbuf_puts(man, "[IMAGE: "); + state->plain = node; + } else { + cmark_strbuf_puts(man, "]"); + } + break; + + default: + assert(false); + break; + } + + // cmark_strbuf_putc(man, 'x'); + return 1; +} + +char *cmark_render_man(cmark_node *root, int options) +{ + char *result; + cmark_strbuf man = GH_BUF_INIT; + struct render_state state = { &man, NULL }; + cmark_node *cur; + cmark_event_type ev_type; + cmark_iter *iter = cmark_iter_new(root); + + if (options == 0) options = 0; // avoid warning about unused parameters + + while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { + cur = cmark_iter_get_node(iter); + S_render_node(cur, ev_type, &state); + } + result = (char *)cmark_strbuf_detach(&man); + + cmark_iter_free(iter); + return result; +} diff --git a/cbits/node.c b/cbits/node.c new file mode 100644 --- /dev/null +++ b/cbits/node.c @@ -0,0 +1,873 @@ +#include +#include + +#include "config.h" +#include "node.h" + +static void +S_node_unlink(cmark_node *node); + +static inline bool +S_is_block(cmark_node *node) +{ + if (node == NULL) { + return false; + } + return node->type >= CMARK_NODE_FIRST_BLOCK + && node->type <= CMARK_NODE_LAST_BLOCK; +} + +static inline bool +S_is_inline(cmark_node *node) +{ + if (node == NULL) { + return false; + } + return node->type >= CMARK_NODE_FIRST_INLINE + && node->type <= CMARK_NODE_LAST_INLINE; +} + +static bool +S_can_contain(cmark_node *node, cmark_node *child) +{ + cmark_node *cur; + + if (node == NULL || child == NULL) { + return false; + } + + // Verify that child is not an ancestor of node or equal to node. + cur = node; + do { + if (cur == child) { + return false; + } + cur = cur->parent; + } while (cur != NULL); + + if (child->type == CMARK_NODE_DOCUMENT) { + return false; + } + + switch (node->type) { + case CMARK_NODE_DOCUMENT: + case CMARK_NODE_BLOCK_QUOTE: + case CMARK_NODE_ITEM: + return S_is_block(child) + && child->type != CMARK_NODE_ITEM; + + case CMARK_NODE_LIST: + return child->type == CMARK_NODE_ITEM; + + case CMARK_NODE_PARAGRAPH: + case CMARK_NODE_HEADER: + case CMARK_NODE_EMPH: + case CMARK_NODE_STRONG: + case CMARK_NODE_LINK: + case CMARK_NODE_IMAGE: + return S_is_inline(child); + + default: + break; + } + + return false; +} + +cmark_node* +cmark_node_new(cmark_node_type type) +{ + cmark_node *node = (cmark_node *)calloc(1, sizeof(*node)); + node->type = type; + + switch (node->type) { + case CMARK_NODE_HEADER: + node->as.header.level = 1; + break; + + case CMARK_NODE_LIST: { + cmark_list *list = &node->as.list; + list->list_type = CMARK_BULLET_LIST; + list->start = 1; + list->tight = false; + break; + } + + default: + break; + } + + return node; +} + +// Free a cmark_node list and any children. +static +void S_free_nodes(cmark_node *e) +{ + cmark_node *next; + while (e != NULL) { + if (S_is_block(e)) { + cmark_strbuf_free(&e->string_content); + } + switch (e->type) { + case NODE_CODE_BLOCK: + cmark_chunk_free(&e->as.code.info); + cmark_chunk_free(&e->as.code.literal); + break; + case NODE_TEXT: + case NODE_INLINE_HTML: + case NODE_CODE: + case NODE_HTML: + cmark_chunk_free(&e->as.literal); + break; + case NODE_LINK: + case NODE_IMAGE: + if (e->as.link.url) { + free(e->as.link.url); + } + if (e->as.link.title) { + free(e->as.link.title); + } + break; + default: + break; + } + if (e->last_child) { + // Splice children into list + e->last_child->next = e->next; + e->next = e->first_child; + } + next = e->next; + free(e); + e = next; + } +} + +void +cmark_node_free(cmark_node *node) +{ + S_node_unlink(node); + node->next = NULL; + S_free_nodes(node); +} + +cmark_node_type +cmark_node_get_type(cmark_node *node) +{ + if (node == NULL) { + return CMARK_NODE_NONE; + } else { + return node->type; + } +} + +const char* +cmark_node_get_type_string(cmark_node *node) +{ + if (node == NULL) { + return "NONE"; + } + + switch (node->type) { + case CMARK_NODE_NONE: + return "none"; + case CMARK_NODE_DOCUMENT: + return "document"; + case CMARK_NODE_BLOCK_QUOTE: + return "block_quote"; + case CMARK_NODE_LIST: + return "list"; + case CMARK_NODE_ITEM: + return "item"; + case CMARK_NODE_CODE_BLOCK: + return "code_block"; + case CMARK_NODE_HTML: + return "html"; + case CMARK_NODE_PARAGRAPH: + return "paragraph"; + case CMARK_NODE_HEADER: + return "header"; + case CMARK_NODE_HRULE: + return "hrule"; + case CMARK_NODE_TEXT: + return "text"; + case CMARK_NODE_SOFTBREAK: + return "softbreak"; + case CMARK_NODE_LINEBREAK: + return "linebreak"; + case CMARK_NODE_CODE: + return "code"; + case CMARK_NODE_INLINE_HTML: + return "inline_html"; + case CMARK_NODE_EMPH: + return "emph"; + case CMARK_NODE_STRONG: + return "strong"; + case CMARK_NODE_LINK: + return "link"; + case CMARK_NODE_IMAGE: + return "image"; + } + + return ""; +} + +cmark_node* +cmark_node_next(cmark_node *node) +{ + if (node == NULL) { + return NULL; + } else { + return node->next; + } +} + +cmark_node* +cmark_node_previous(cmark_node *node) +{ + if (node == NULL) { + return NULL; + } else { + return node->prev; + } +} + +cmark_node* +cmark_node_parent(cmark_node *node) +{ + if (node == NULL) { + return NULL; + } else { + return node->parent; + } +} + +cmark_node* +cmark_node_first_child(cmark_node *node) +{ + if (node == NULL) { + return NULL; + } else { + return node->first_child; + } +} + +cmark_node* +cmark_node_last_child(cmark_node *node) +{ + if (node == NULL) { + return NULL; + } else { + return node->last_child; + } +} + +void* +cmark_node_get_user_data(cmark_node *node) +{ + if (node == NULL) { + return NULL; + } else { + return node->user_data; + } +} + +int +cmark_node_set_user_data(cmark_node *node, void *user_data) +{ + if (node == NULL) { + return 0; + } + node->user_data = user_data; + return 1; +} + +static char* +S_strdup(const char *str) +{ + size_t size = strlen(str) + 1; + char *dup = (char *)malloc(size); + memcpy(dup, str, size); + return dup; +} + +const char* +cmark_node_get_literal(cmark_node *node) +{ + if (node == NULL) { + return NULL; + } + + switch (node->type) { + case NODE_HTML: + case NODE_TEXT: + case NODE_INLINE_HTML: + case NODE_CODE: + return cmark_chunk_to_cstr(&node->as.literal); + + case NODE_CODE_BLOCK: + return cmark_chunk_to_cstr(&node->as.code.literal); + + default: + break; + } + + return NULL; +} + +int +cmark_node_set_literal(cmark_node *node, const char *content) +{ + if (node == NULL) { + return 0; + } + + switch (node->type) { + case NODE_HTML: + case NODE_TEXT: + case NODE_INLINE_HTML: + case NODE_CODE: + cmark_chunk_set_cstr(&node->as.literal, content); + return 1; + + case NODE_CODE_BLOCK: + cmark_chunk_set_cstr(&node->as.code.literal, content); + return 1; + + default: + break; + } + + return 0; +} + +int +cmark_node_get_header_level(cmark_node *node) +{ + if (node == NULL) { + return 0; + } + + switch (node->type) { + case CMARK_NODE_HEADER: + return node->as.header.level; + + default: + break; + } + + return 0; +} + +int +cmark_node_set_header_level(cmark_node *node, int level) +{ + if (node == NULL || level < 1 || level > 6) { + return 0; + } + + switch (node->type) { + case CMARK_NODE_HEADER: + node->as.header.level = level; + return 1; + + default: + break; + } + + return 0; +} + +cmark_list_type +cmark_node_get_list_type(cmark_node *node) +{ + if (node == NULL) { + return CMARK_NO_LIST; + } + + if (node->type == CMARK_NODE_LIST) { + return node->as.list.list_type; + } else { + return CMARK_NO_LIST; + } +} + +int +cmark_node_set_list_type(cmark_node *node, cmark_list_type type) +{ + if (!(type == CMARK_BULLET_LIST || type == CMARK_ORDERED_LIST)) { + return 0; + } + + if (node == NULL) { + return 0; + } + + if (node->type == CMARK_NODE_LIST) { + node->as.list.list_type = type; + return 1; + } else { + return 0; + } +} + +cmark_delim_type +cmark_node_get_list_delim(cmark_node *node) +{ + if (node == NULL) { + return CMARK_NO_DELIM; + } + + if (node->type == CMARK_NODE_LIST) { + return node->as.list.delimiter; + } else { + return CMARK_NO_DELIM; + } +} + +int +cmark_node_set_list_delim(cmark_node *node, cmark_delim_type delim) +{ + if (!(delim == CMARK_PERIOD_DELIM || delim == CMARK_PAREN_DELIM)) { + return 0; + } + + if (node == NULL) { + return 0; + } + + if (node->type == CMARK_NODE_LIST) { + node->as.list.delimiter = delim; + return 1; + } else { + return 0; + } +} + +int +cmark_node_get_list_start(cmark_node *node) +{ + if (node == NULL) { + return 0; + } + + if (node->type == CMARK_NODE_LIST) { + return node->as.list.start; + } else { + return 0; + } +} + +int +cmark_node_set_list_start(cmark_node *node, int start) +{ + if (node == NULL || start < 0) { + return 0; + } + + if (node->type == CMARK_NODE_LIST) { + node->as.list.start = start; + return 1; + } else { + return 0; + } +} + +int +cmark_node_get_list_tight(cmark_node *node) +{ + if (node == NULL) { + return 0; + } + + if (node->type == CMARK_NODE_LIST) { + return node->as.list.tight; + } else { + return 0; + } +} + +int +cmark_node_set_list_tight(cmark_node *node, int tight) +{ + if (node == NULL) { + return 0; + } + + if (node->type == CMARK_NODE_LIST) { + node->as.list.tight = tight; + return 1; + } else { + return 0; + } +} + +const char* +cmark_node_get_fence_info(cmark_node *node) +{ + if (node == NULL) { + return NULL; + } + + if (node->type == NODE_CODE_BLOCK) { + return cmark_chunk_to_cstr(&node->as.code.info); + } else { + return NULL; + } +} + +int +cmark_node_set_fence_info(cmark_node *node, const char *info) +{ + if (node == NULL) { + return 0; + } + + if (node->type == NODE_CODE_BLOCK) { + cmark_chunk_set_cstr(&node->as.code.info, info); + return 1; + } else { + return 0; + } +} + +const char* +cmark_node_get_url(cmark_node *node) +{ + if (node == NULL) { + return NULL; + } + + switch (node->type) { + case NODE_LINK: + case NODE_IMAGE: + return (char *)node->as.link.url; + default: + break; + } + + return NULL; +} + +int +cmark_node_set_url(cmark_node *node, const char *url) +{ + if (node == NULL) { + return 0; + } + + switch (node->type) { + case NODE_LINK: + case NODE_IMAGE: + free(node->as.link.url); + node->as.link.url = (unsigned char *)S_strdup(url); + return 1; + default: + break; + } + + return 0; +} + +const char* +cmark_node_get_title(cmark_node *node) +{ + if (node == NULL) { + return NULL; + } + + switch (node->type) { + case NODE_LINK: + case NODE_IMAGE: + return (char *)node->as.link.title; + default: + break; + } + + return NULL; +} + +int +cmark_node_set_title(cmark_node *node, const char *title) +{ + if (node == NULL) { + return 0; + } + + switch (node->type) { + case NODE_LINK: + case NODE_IMAGE: + free(node->as.link.title); + node->as.link.title = (unsigned char *)S_strdup(title); + return 1; + default: + break; + } + + return 0; +} + +int +cmark_node_get_start_line(cmark_node *node) +{ + if (node == NULL) { + return 0; + } + return node->start_line; +} + +int +cmark_node_get_start_column(cmark_node *node) +{ + if (node == NULL) { + return 0; + } + return node->start_column; +} + +int +cmark_node_get_end_line(cmark_node *node) +{ + if (node == NULL) { + return 0; + } + return node->end_line; +} + +int +cmark_node_get_end_column(cmark_node *node) +{ + if (node == NULL) { + return 0; + } + return node->end_column; +} + +// Unlink a node without adjusting its next, prev, and parent pointers. +static void +S_node_unlink(cmark_node *node) +{ + if (node == NULL) { + return; + } + + if (node->prev) { + node->prev->next = node->next; + } + if (node->next) { + node->next->prev = node->prev; + } + + // Adjust first_child and last_child of parent. + cmark_node *parent = node->parent; + if (parent) { + if (parent->first_child == node) { + parent->first_child = node->next; + } + if (parent->last_child == node) { + parent->last_child = node->prev; + } + } +} + +void +cmark_node_unlink(cmark_node *node) +{ + S_node_unlink(node); + + node->next = NULL; + node->prev = NULL; + node->parent = NULL; + +} + +int +cmark_node_insert_before(cmark_node *node, cmark_node *sibling) +{ + if (node == NULL || sibling == NULL) { + return 0; + } + + if (!node->parent || !S_can_contain(node->parent, sibling)) { + return 0; + } + + S_node_unlink(sibling); + + cmark_node *old_prev = node->prev; + + // Insert 'sibling' between 'old_prev' and 'node'. + if (old_prev) { + old_prev->next = sibling; + } + sibling->prev = old_prev; + sibling->next = node; + node->prev = sibling; + + // Set new parent. + cmark_node *parent = node->parent; + sibling->parent = parent; + + // Adjust first_child of parent if inserted as first child. + if (parent && !old_prev) { + parent->first_child = sibling; + } + + return 1; +} + +int +cmark_node_insert_after(cmark_node *node, cmark_node *sibling) +{ + if (node == NULL || sibling == NULL) { + return 0; + } + + if (!node->parent || !S_can_contain(node->parent, sibling)) { + return 0; + } + + S_node_unlink(sibling); + + cmark_node *old_next = node->next; + + // Insert 'sibling' between 'node' and 'old_next'. + if (old_next) { + old_next->prev = sibling; + } + sibling->next = old_next; + sibling->prev = node; + node->next = sibling; + + // Set new parent. + cmark_node *parent = node->parent; + sibling->parent = parent; + + // Adjust last_child of parent if inserted as last child. + if (parent && !old_next) { + parent->last_child = sibling; + } + + return 1; +} + +int +cmark_node_prepend_child(cmark_node *node, cmark_node *child) +{ + if (!S_can_contain(node, child)) { + return 0; + } + + S_node_unlink(child); + + cmark_node *old_first_child = node->first_child; + + child->next = old_first_child; + child->prev = NULL; + child->parent = node; + node->first_child = child; + + if (old_first_child) { + old_first_child->prev = child; + } else { + // Also set last_child if node previously had no children. + node->last_child = child; + } + + return 1; +} + +int +cmark_node_append_child(cmark_node *node, cmark_node *child) +{ + if (!S_can_contain(node, child)) { + return 0; + } + + S_node_unlink(child); + + cmark_node *old_last_child = node->last_child; + + child->next = NULL; + child->prev = old_last_child; + child->parent = node; + node->last_child = child; + + if (old_last_child) { + old_last_child->next = child; + } else { + // Also set first_child if node previously had no children. + node->first_child = child; + } + + return 1; +} + +static void +S_print_error(FILE *out, cmark_node *node, const char *elem) +{ + if (out == NULL) { + return; + } + fprintf(out, "Invalid '%s' in node type %s at %d:%d\n", elem, + cmark_node_get_type_string(node), node->start_line, + node->start_column); +} + +int +cmark_node_check(cmark_node *node, FILE *out) +{ + cmark_node *cur; + int errors = 0; + + if (!node) { + return 0; + } + + cur = node; + while (true) { + if (cur->first_child) { + if (cur->first_child->prev != NULL) { + S_print_error(out, cur->first_child, "prev"); + cur->first_child->prev = NULL; + ++errors; + } + if (cur->first_child->parent != cur) { + S_print_error(out, cur->first_child, "parent"); + cur->first_child->parent = cur; + ++errors; + } + cur = cur->first_child; + continue; + } + +next_sibling: + if (cur == node) { + break; + } + if (cur->next) { + if (cur->next->prev != cur) { + S_print_error(out, cur->next, "prev"); + cur->next->prev = cur; + ++errors; + } + if (cur->next->parent != cur->parent) { + S_print_error(out, cur->next, "parent"); + cur->next->parent = cur->parent; + ++errors; + } + cur = cur->next; + continue; + } + + if (cur->parent->last_child != cur) { + S_print_error(out, cur->parent, "last_child"); + cur->parent->last_child = cur; + ++errors; + } + cur = cur->parent; + goto next_sibling; + } + + return errors; +} diff --git a/cbits/node.h b/cbits/node.h new file mode 100644 --- /dev/null +++ b/cbits/node.h @@ -0,0 +1,82 @@ +#ifndef CMARK_NODE_H +#define CMARK_NODE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include + +#include "cmark.h" +#include "buffer.h" +#include "chunk.h" + +typedef struct { + cmark_list_type list_type; + int marker_offset; + int padding; + int start; + cmark_delim_type delimiter; + unsigned char bullet_char; + bool tight; +} cmark_list; + +typedef struct { + cmark_chunk info; + cmark_chunk literal; + int fence_length; + /* fence_offset must be 0-3, so we can use int8_t */ + int8_t fence_offset; + unsigned char fence_char; + bool fenced; +} cmark_code; + +typedef struct { + int level; + bool setext; +} cmark_header; + +typedef struct { + unsigned char *url; + unsigned char *title; +} cmark_link; + +struct cmark_node { + struct cmark_node *next; + struct cmark_node *prev; + struct cmark_node *parent; + struct cmark_node *first_child; + struct cmark_node *last_child; + + void *user_data; + + int start_line; + int start_column; + int end_line; + int end_column; + + cmark_node_type type; + + bool open; + bool last_line_blank; + + cmark_strbuf string_content; + + union { + cmark_chunk literal; + cmark_list list; + cmark_code code; + cmark_header header; + cmark_link link; + } as; +}; + +CMARK_EXPORT int +cmark_node_check(cmark_node *node, FILE *out); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/cbits/parser.h b/cbits/parser.h new file mode 100644 --- /dev/null +++ b/cbits/parser.h @@ -0,0 +1,29 @@ +#ifndef CMARK_AST_H +#define CMARK_AST_H + +#include +#include "node.h" +#include "buffer.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define MAX_LINK_LABEL_LENGTH 1000 + +struct cmark_parser { + struct cmark_reference_map *refmap; + struct cmark_node* root; + struct cmark_node* current; + int line_number; + cmark_strbuf *curline; + int last_line_length; + cmark_strbuf *linebuf; + int options; +}; + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/cbits/references.c b/cbits/references.c new file mode 100644 --- /dev/null +++ b/cbits/references.c @@ -0,0 +1,154 @@ +#include "cmark.h" +#include "utf8.h" +#include "parser.h" +#include "references.h" +#include "inlines.h" +#include "chunk.h" + +static unsigned int +refhash(const unsigned char *link_ref) +{ + unsigned int hash = 0; + + while (*link_ref) + hash = (*link_ref++) + (hash << 6) + (hash << 16) - hash; + + return hash; +} + +static void reference_free(cmark_reference *ref) +{ + if(ref != NULL) { + free(ref->label); + free(ref->url); + free(ref->title); + free(ref); + } +} + +// normalize reference: collapse internal whitespace to single space, +// remove leading/trailing whitespace, case fold +// Return NULL if the reference name is actually empty (i.e. composed +// solely from whitespace) +static unsigned char *normalize_reference(cmark_chunk *ref) +{ + cmark_strbuf normalized = GH_BUF_INIT; + unsigned char *result; + + if(ref == NULL) + return NULL; + + if (ref->len == 0) + return NULL; + + utf8proc_case_fold(&normalized, ref->data, ref->len); + cmark_strbuf_trim(&normalized); + cmark_strbuf_normalize_whitespace(&normalized); + + result = cmark_strbuf_detach(&normalized); + assert(result); + + if (result[0] == '\0') { + free(result); + return NULL; + } + + return result; +} + +static void add_reference(cmark_reference_map *map, cmark_reference* ref) +{ + cmark_reference *t = ref->next = map->table[ref->hash % REFMAP_SIZE]; + + while (t) { + if (t->hash == ref->hash && + !strcmp((char *)t->label, (char *)ref->label)) { + reference_free(ref); + return; + } + + t = t->next; + } + + map->table[ref->hash % REFMAP_SIZE] = ref; +} + +void cmark_reference_create(cmark_reference_map *map, cmark_chunk *label, cmark_chunk *url, + cmark_chunk *title) +{ + cmark_reference *ref; + unsigned char *reflabel = normalize_reference(label); + + /* empty reference name, or composed from only whitespace */ + if (reflabel == NULL) + return; + + ref = (cmark_reference *)calloc(1, sizeof(*ref)); + if(ref != NULL) { + ref->label = reflabel; + ref->hash = refhash(ref->label); + ref->url = cmark_clean_url(url); + ref->title = cmark_clean_title(title); + ref->next = NULL; + + add_reference(map, ref); + } +} + +// Returns reference if refmap contains a reference with matching +// label, otherwise NULL. +cmark_reference* cmark_reference_lookup(cmark_reference_map *map, cmark_chunk *label) +{ + cmark_reference *ref = NULL; + unsigned char *norm; + unsigned int hash; + + if (label->len > MAX_LINK_LABEL_LENGTH) + return NULL; + + if (map == NULL) + return NULL; + + norm = normalize_reference(label); + if (norm == NULL) + return NULL; + + hash = refhash(norm); + ref = map->table[hash % REFMAP_SIZE]; + + while (ref) { + if (ref->hash == hash && + !strcmp((char *)ref->label, (char *)norm)) + break; + ref = ref->next; + } + + free(norm); + return ref; +} + +void cmark_reference_map_free(cmark_reference_map *map) +{ + unsigned int i; + + if(map == NULL) + return; + + for (i = 0; i < REFMAP_SIZE; ++i) { + cmark_reference *ref = map->table[i]; + cmark_reference *next; + + while (ref) { + next = ref->next; + reference_free(ref); + ref = next; + } + } + + free(map); +} + +cmark_reference_map *cmark_reference_map_new(void) +{ + return (cmark_reference_map *)calloc(1, sizeof(cmark_reference_map)); +} diff --git a/cbits/references.h b/cbits/references.h new file mode 100644 --- /dev/null +++ b/cbits/references.h @@ -0,0 +1,37 @@ +#ifndef CMARK_REFERENCES_H +#define CMARK_REFERENCES_H + +#include "chunk.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define REFMAP_SIZE 16 + +struct cmark_reference { + struct cmark_reference *next; + unsigned char *label; + unsigned char *url; + unsigned char *title; + unsigned int hash; +}; + +typedef struct cmark_reference cmark_reference; + +struct cmark_reference_map { + cmark_reference *table[REFMAP_SIZE]; +}; + +typedef struct cmark_reference_map cmark_reference_map; + +cmark_reference_map *cmark_reference_map_new(void); +void cmark_reference_map_free(cmark_reference_map *map); +cmark_reference* cmark_reference_lookup(cmark_reference_map *map, cmark_chunk *label); +extern void cmark_reference_create(cmark_reference_map *map, cmark_chunk *label, cmark_chunk *url, cmark_chunk *title); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/cbits/scanners.c b/cbits/scanners.c new file mode 100644 --- /dev/null +++ b/cbits/scanners.c @@ -0,0 +1,12392 @@ +/* Generated by re2c 0.13.6 */ +#include +#include "chunk.h" +#include "scanners.h" + +int _scan_at(int (*scanner)(const unsigned char *), cmark_chunk *c, int offset) +{ + int res; + unsigned char *ptr = (unsigned char *)c->data; + unsigned char lim = ptr[c->len]; + + ptr[c->len] = '\0'; + res = scanner(ptr + offset); + ptr[c->len] = lim; + + return res; +} + + + +// Try to match URI autolink after first <, returning number of chars matched. +int _scan_autolink_uri(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; + +{ + unsigned char yych; + static const unsigned char yybm[] = { + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 0, 128, 0, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + }; + + yych = *p; + switch (yych) { + case '\n': goto yy2; + case 'A': + case 'a': goto yy6; + case 'B': + case 'b': goto yy24; + case 'C': + case 'c': goto yy3; + case 'D': + case 'd': goto yy4; + case 'E': + case 'e': goto yy25; + case 'F': + case 'f': goto yy7; + case 'G': + case 'g': goto yy8; + case 'H': + case 'h': goto yy9; + case 'I': + case 'i': goto yy10; + case 'J': + case 'j': goto yy5; + case 'K': + case 'k': goto yy26; + case 'L': + case 'l': goto yy11; + case 'M': + case 'm': goto yy12; + case 'N': + case 'n': goto yy13; + case 'O': + case 'o': goto yy14; + case 'P': + case 'p': goto yy15; + case 'Q': + case 'q': goto yy27; + case 'R': + case 'r': goto yy16; + case 'S': + case 's': goto yy17; + case 'T': + case 't': goto yy18; + case 'U': + case 'u': goto yy19; + case 'V': + case 'v': goto yy20; + case 'W': + case 'w': goto yy21; + case 'X': + case 'x': goto yy22; + case 'Y': + case 'y': goto yy28; + case 'Z': + case 'z': goto yy23; + default: goto yy29; + } +yy2: + { return 0; } +yy3: + yych = *(marker = ++p); + switch (yych) { + case 'A': + case 'a': goto yy442; + case 'H': + case 'h': goto yy441; + case 'I': + case 'i': goto yy444; + case 'O': + case 'o': goto yy440; + case 'R': + case 'r': goto yy443; + case 'V': + case 'v': goto yy439; + default: goto yy2; + } +yy4: + yych = *(marker = ++p); + switch (yych) { + case 'A': + case 'a': goto yy415; + case 'I': + case 'i': goto yy414; + case 'L': + case 'l': goto yy412; + case 'N': + case 'n': goto yy413; + case 'O': + case 'o': goto yy416; + case 'T': + case 't': goto yy411; + case 'V': + case 'v': goto yy410; + default: goto yy2; + } +yy5: + yych = *(marker = ++p); + if (yych <= 'M') { + if (yych == 'A') goto yy402; + if (yych <= 'L') goto yy2; + goto yy401; + } else { + if (yych <= 'a') { + if (yych <= '`') goto yy2; + goto yy402; + } else { + if (yych == 'm') goto yy401; + goto yy2; + } + } +yy6: + yych = *(marker = ++p); + switch (yych) { + case 'A': + case 'a': goto yy383; + case 'B': + case 'b': goto yy382; + case 'C': + case 'c': goto yy381; + case 'D': + case 'd': goto yy380; + case 'F': + case 'f': goto yy379; + case 'I': + case 'i': goto yy378; + case 'P': + case 'p': goto yy377; + case 'T': + case 't': goto yy376; + case 'W': + case 'w': goto yy34; + default: goto yy2; + } +yy7: + yych = *(marker = ++p); + if (yych <= 'T') { + if (yych <= 'E') { + if (yych == 'A') goto yy363; + if (yych <= 'D') goto yy2; + goto yy362; + } else { + if (yych == 'I') goto yy361; + if (yych <= 'S') goto yy2; + goto yy364; + } + } else { + if (yych <= 'e') { + if (yych == 'a') goto yy363; + if (yych <= 'd') goto yy2; + goto yy362; + } else { + if (yych <= 'i') { + if (yych <= 'h') goto yy2; + goto yy361; + } else { + if (yych == 't') goto yy364; + goto yy2; + } + } + } +yy8: + yych = *(marker = ++p); + switch (yych) { + case 'E': + case 'e': goto yy346; + case 'G': + case 'g': goto yy34; + case 'I': + case 'i': goto yy344; + case 'O': + case 'o': goto yy345; + case 'T': + case 't': goto yy343; + default: goto yy2; + } +yy9: + yych = *(marker = ++p); + if (yych <= 'S') { + if (yych <= '3') { + if (yych <= '2') goto yy2; + goto yy339; + } else { + if (yych == 'C') goto yy337; + goto yy2; + } + } else { + if (yych <= 'c') { + if (yych <= 'T') goto yy338; + if (yych <= 'b') goto yy2; + goto yy337; + } else { + if (yych == 't') goto yy338; + goto yy2; + } + } +yy10: + yych = *(marker = ++p); + switch (yych) { + case 'A': + case 'a': goto yy319; + case 'C': + case 'c': goto yy316; + case 'M': + case 'm': goto yy318; + case 'N': + case 'n': goto yy317; + case 'P': + case 'p': goto yy315; + case 'R': + case 'r': goto yy314; + case 'T': + case 't': goto yy313; + default: goto yy2; + } +yy11: + yych = *(marker = ++p); + if (yych <= 'D') { + if (yych == 'A') goto yy307; + if (yych <= 'C') goto yy2; + goto yy306; + } else { + if (yych <= 'a') { + if (yych <= '`') goto yy2; + goto yy307; + } else { + if (yych == 'd') goto yy306; + goto yy2; + } + } +yy12: + yych = *(marker = ++p); + switch (yych) { + case 'A': + case 'a': goto yy273; + case 'E': + case 'e': goto yy272; + case 'I': + case 'i': goto yy275; + case 'M': + case 'm': goto yy271; + case 'S': + case 's': goto yy270; + case 'T': + case 't': goto yy274; + case 'U': + case 'u': goto yy269; + case 'V': + case 'v': goto yy268; + default: goto yy2; + } +yy13: + yych = *(marker = ++p); + switch (yych) { + case 'E': + case 'e': goto yy263; + case 'F': + case 'f': goto yy262; + case 'I': + case 'i': goto yy261; + case 'N': + case 'n': goto yy260; + case 'O': + case 'o': goto yy259; + default: goto yy2; + } +yy14: + yych = *(marker = ++p); + if (yych <= 'P') { + if (yych == 'I') goto yy245; + if (yych <= 'O') goto yy2; + goto yy246; + } else { + if (yych <= 'i') { + if (yych <= 'h') goto yy2; + goto yy245; + } else { + if (yych == 'p') goto yy246; + goto yy2; + } + } +yy15: + yych = *(marker = ++p); + if (yych <= 'S') { + if (yych <= 'L') { + if (yych == 'A') goto yy227; + if (yych <= 'K') goto yy2; + goto yy226; + } else { + if (yych <= 'O') { + if (yych <= 'N') goto yy2; + goto yy228; + } else { + if (yych <= 'Q') goto yy2; + if (yych <= 'R') goto yy225; + goto yy224; + } + } + } else { + if (yych <= 'n') { + if (yych <= 'a') { + if (yych <= '`') goto yy2; + goto yy227; + } else { + if (yych == 'l') goto yy226; + goto yy2; + } + } else { + if (yych <= 'q') { + if (yych <= 'o') goto yy228; + goto yy2; + } else { + if (yych <= 'r') goto yy225; + if (yych <= 's') goto yy224; + goto yy2; + } + } + } +yy16: + yych = *(marker = ++p); + if (yych <= 'T') { + if (yych <= 'L') { + if (yych == 'E') goto yy214; + goto yy2; + } else { + if (yych <= 'M') goto yy213; + if (yych <= 'R') goto yy2; + if (yych <= 'S') goto yy212; + goto yy211; + } + } else { + if (yych <= 'm') { + if (yych == 'e') goto yy214; + if (yych <= 'l') goto yy2; + goto yy213; + } else { + if (yych <= 'r') goto yy2; + if (yych <= 's') goto yy212; + if (yych <= 't') goto yy211; + goto yy2; + } + } +yy17: + yych = *(marker = ++p); + switch (yych) { + case 'E': + case 'e': goto yy167; + case 'F': + case 'f': goto yy166; + case 'G': + case 'g': goto yy165; + case 'H': + case 'h': goto yy170; + case 'I': + case 'i': goto yy169; + case 'K': + case 'k': goto yy164; + case 'M': + case 'm': goto yy163; + case 'N': + case 'n': goto yy168; + case 'O': + case 'o': goto yy162; + case 'P': + case 'p': goto yy161; + case 'S': + case 's': goto yy160; + case 'T': + case 't': goto yy159; + case 'V': + case 'v': goto yy158; + default: goto yy2; + } +yy18: + yych = *(marker = ++p); + switch (yych) { + case 'A': + case 'a': goto yy134; + case 'E': + case 'e': goto yy130; + case 'F': + case 'f': goto yy133; + case 'H': + case 'h': goto yy129; + case 'I': + case 'i': goto yy131; + case 'N': + case 'n': goto yy132; + case 'V': + case 'v': goto yy34; + default: goto yy2; + } +yy19: + yych = *(marker = ++p); + if (yych <= 'T') { + if (yych <= 'N') { + if (yych == 'D') goto yy121; + if (yych <= 'M') goto yy2; + goto yy120; + } else { + if (yych == 'R') goto yy122; + if (yych <= 'S') goto yy2; + goto yy119; + } + } else { + if (yych <= 'n') { + if (yych == 'd') goto yy121; + if (yych <= 'm') goto yy2; + goto yy120; + } else { + if (yych <= 'r') { + if (yych <= 'q') goto yy2; + goto yy122; + } else { + if (yych == 't') goto yy119; + goto yy2; + } + } + } +yy20: + yych = *(marker = ++p); + if (yych <= 'I') { + if (yych == 'E') goto yy103; + if (yych <= 'H') goto yy2; + goto yy102; + } else { + if (yych <= 'e') { + if (yych <= 'd') goto yy2; + goto yy103; + } else { + if (yych == 'i') goto yy102; + goto yy2; + } + } +yy21: + yych = *(marker = ++p); + if (yych <= 'Y') { + if (yych <= 'R') { + if (yych == 'E') goto yy92; + goto yy2; + } else { + if (yych <= 'S') goto yy93; + if (yych <= 'T') goto yy91; + if (yych <= 'X') goto yy2; + goto yy90; + } + } else { + if (yych <= 's') { + if (yych == 'e') goto yy92; + if (yych <= 'r') goto yy2; + goto yy93; + } else { + if (yych <= 't') goto yy91; + if (yych == 'y') goto yy90; + goto yy2; + } + } +yy22: + yych = *(marker = ++p); + if (yych <= 'R') { + if (yych <= 'F') { + if (yych == 'C') goto yy69; + if (yych <= 'E') goto yy2; + goto yy67; + } else { + if (yych == 'M') goto yy68; + if (yych <= 'Q') goto yy2; + goto yy66; + } + } else { + if (yych <= 'f') { + if (yych == 'c') goto yy69; + if (yych <= 'e') goto yy2; + goto yy67; + } else { + if (yych <= 'm') { + if (yych <= 'l') goto yy2; + goto yy68; + } else { + if (yych == 'r') goto yy66; + goto yy2; + } + } + } +yy23: + yych = *(marker = ++p); + if (yych == '3') goto yy61; + goto yy2; +yy24: + yych = *(marker = ++p); + if (yych <= 'O') { + if (yych <= 'H') { + if (yych == 'E') goto yy51; + goto yy2; + } else { + if (yych <= 'I') goto yy50; + if (yych <= 'N') goto yy2; + goto yy49; + } + } else { + if (yych <= 'h') { + if (yych == 'e') goto yy51; + goto yy2; + } else { + if (yych <= 'i') goto yy50; + if (yych == 'o') goto yy49; + goto yy2; + } + } +yy25: + yych = *(marker = ++p); + if (yych == 'D') goto yy47; + if (yych == 'd') goto yy47; + goto yy2; +yy26: + yych = *(marker = ++p); + if (yych == 'E') goto yy42; + if (yych == 'e') goto yy42; + goto yy2; +yy27: + yych = *(marker = ++p); + if (yych == 'U') goto yy39; + if (yych == 'u') goto yy39; + goto yy2; +yy28: + yych = *(marker = ++p); + if (yych == 'M') goto yy30; + if (yych == 'm') goto yy30; + goto yy2; +yy29: + yych = *++p; + goto yy2; +yy30: + yych = *++p; + if (yych == 'S') goto yy32; + if (yych == 's') goto yy32; +yy31: + p = marker; + goto yy2; +yy32: + yych = *++p; + if (yych == 'G') goto yy33; + if (yych != 'g') goto yy31; +yy33: + yych = *++p; + if (yych == 'R') goto yy34; + if (yych != 'r') goto yy31; +yy34: + yych = *++p; + if (yych != ':') goto yy31; +yy35: + ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy35; + } + if (yych <= '=') goto yy31; + ++p; + { return (p - start); } +yy39: + yych = *++p; + if (yych == 'E') goto yy40; + if (yych != 'e') goto yy31; +yy40: + yych = *++p; + if (yych == 'R') goto yy41; + if (yych != 'r') goto yy31; +yy41: + yych = *++p; + if (yych == 'Y') goto yy34; + if (yych == 'y') goto yy34; + goto yy31; +yy42: + yych = *++p; + if (yych == 'Y') goto yy43; + if (yych != 'y') goto yy31; +yy43: + yych = *++p; + if (yych == 'P') goto yy44; + if (yych != 'p') goto yy31; +yy44: + yych = *++p; + if (yych == 'A') goto yy45; + if (yych != 'a') goto yy31; +yy45: + yych = *++p; + if (yych == 'R') goto yy46; + if (yych != 'r') goto yy31; +yy46: + yych = *++p; + if (yych == 'C') goto yy34; + if (yych == 'c') goto yy34; + goto yy31; +yy47: + yych = *++p; + if (yych != '2') goto yy31; + yych = *++p; + if (yych == 'K') goto yy34; + if (yych == 'k') goto yy34; + goto yy31; +yy49: + yych = *++p; + if (yych == 'L') goto yy60; + if (yych == 'l') goto yy60; + goto yy31; +yy50: + yych = *++p; + if (yych == 'T') goto yy56; + if (yych == 't') goto yy56; + goto yy31; +yy51: + yych = *++p; + if (yych == 'S') goto yy52; + if (yych != 's') goto yy31; +yy52: + yych = *++p; + if (yych == 'H') goto yy53; + if (yych != 'h') goto yy31; +yy53: + yych = *++p; + if (yych == 'A') goto yy54; + if (yych != 'a') goto yy31; +yy54: + yych = *++p; + if (yych == 'R') goto yy55; + if (yych != 'r') goto yy31; +yy55: + yych = *++p; + if (yych == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +yy56: + yych = *++p; + if (yych == 'C') goto yy57; + if (yych != 'c') goto yy31; +yy57: + yych = *++p; + if (yych == 'O') goto yy58; + if (yych != 'o') goto yy31; +yy58: + yych = *++p; + if (yych == 'I') goto yy59; + if (yych != 'i') goto yy31; +yy59: + yych = *++p; + if (yych == 'N') goto yy34; + if (yych == 'n') goto yy34; + goto yy31; +yy60: + yych = *++p; + if (yych == 'O') goto yy34; + if (yych == 'o') goto yy34; + goto yy31; +yy61: + yych = *++p; + if (yych != '9') goto yy31; + yych = *++p; + if (yych != '.') goto yy31; + yych = *++p; + if (yych != '5') goto yy31; + yych = *++p; + if (yych != '0') goto yy31; + yych = *++p; + if (yych <= 'Q') goto yy31; + if (yych <= 'S') goto yy34; + if (yych <= 'q') goto yy31; + if (yych <= 's') goto yy34; + goto yy31; +yy66: + yych = *++p; + if (yych == 'I') goto yy34; + if (yych == 'i') goto yy34; + goto yy31; +yy67: + yych = *++p; + if (yych == 'I') goto yy88; + if (yych == 'i') goto yy88; + goto yy31; +yy68: + yych = *++p; + if (yych <= 'P') { + if (yych == 'L') goto yy78; + if (yych <= 'O') goto yy31; + goto yy79; + } else { + if (yych <= 'l') { + if (yych <= 'k') goto yy31; + goto yy78; + } else { + if (yych == 'p') goto yy79; + goto yy31; + } + } +yy69: + yych = *++p; + if (yych == 'O') goto yy70; + if (yych != 'o') goto yy31; +yy70: + yych = *++p; + if (yych == 'N') goto yy71; + if (yych != 'n') goto yy31; +yy71: + yych = *++p; + if (yych == '-') goto yy72; + if (yych == ':') goto yy35; + goto yy31; +yy72: + yych = *++p; + if (yych == 'U') goto yy73; + if (yych != 'u') goto yy31; +yy73: + yych = *++p; + if (yych == 'S') goto yy74; + if (yych != 's') goto yy31; +yy74: + yych = *++p; + if (yych == 'E') goto yy75; + if (yych != 'e') goto yy31; +yy75: + yych = *++p; + if (yych == 'R') goto yy76; + if (yych != 'r') goto yy31; +yy76: + yych = *++p; + if (yych == 'I') goto yy77; + if (yych != 'i') goto yy31; +yy77: + yych = *++p; + if (yych == 'D') goto yy34; + if (yych == 'd') goto yy34; + goto yy31; +yy78: + yych = *++p; + if (yych == 'R') goto yy80; + if (yych == 'r') goto yy80; + goto yy31; +yy79: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy80: + yych = *++p; + if (yych == 'P') goto yy81; + if (yych != 'p') goto yy31; +yy81: + yych = *++p; + if (yych == 'C') goto yy82; + if (yych != 'c') goto yy31; +yy82: + yych = *++p; + if (yych != '.') goto yy31; + yych = *++p; + if (yych == 'B') goto yy84; + if (yych != 'b') goto yy31; +yy84: + yych = *++p; + if (yych == 'E') goto yy85; + if (yych != 'e') goto yy31; +yy85: + yych = *++p; + if (yych == 'E') goto yy86; + if (yych != 'e') goto yy31; +yy86: + yych = *++p; + if (yych == 'P') goto yy87; + if (yych != 'p') goto yy31; +yy87: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') goto yy35; + goto yy31; + } else { + if (yych <= 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; + } +yy88: + yych = *++p; + if (yych == 'R') goto yy89; + if (yych != 'r') goto yy31; +yy89: + yych = *++p; + if (yych == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +yy90: + yych = *++p; + if (yych == 'C') goto yy98; + if (yych == 'c') goto yy98; + goto yy31; +yy91: + yych = *++p; + if (yych == 'A') goto yy97; + if (yych == 'a') goto yy97; + goto yy31; +yy92: + yych = *++p; + if (yych == 'B') goto yy94; + if (yych == 'b') goto yy94; + goto yy31; +yy93: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') goto yy35; + goto yy31; + } else { + if (yych <= 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; + } +yy94: + yych = *++p; + if (yych == 'C') goto yy95; + if (yych != 'c') goto yy31; +yy95: + yych = *++p; + if (yych == 'A') goto yy96; + if (yych != 'a') goto yy31; +yy96: + yych = *++p; + if (yych == 'L') goto yy34; + if (yych == 'l') goto yy34; + goto yy31; +yy97: + yych = *++p; + if (yych == 'I') goto yy34; + if (yych == 'i') goto yy34; + goto yy31; +yy98: + yych = *++p; + if (yych == 'I') goto yy99; + if (yych != 'i') goto yy31; +yy99: + yych = *++p; + if (yych == 'W') goto yy100; + if (yych != 'w') goto yy31; +yy100: + yych = *++p; + if (yych == 'Y') goto yy101; + if (yych != 'y') goto yy31; +yy101: + yych = *++p; + if (yych == 'G') goto yy34; + if (yych == 'g') goto yy34; + goto yy31; +yy102: + yych = *++p; + if (yych == 'E') goto yy111; + if (yych == 'e') goto yy111; + goto yy31; +yy103: + yych = *++p; + if (yych <= 'N') { + if (yych <= 'L') goto yy31; + if (yych >= 'N') goto yy105; + } else { + if (yych <= 'l') goto yy31; + if (yych <= 'm') goto yy104; + if (yych <= 'n') goto yy105; + goto yy31; + } +yy104: + yych = *++p; + if (yych == 'M') goto yy110; + if (yych == 'm') goto yy110; + goto yy31; +yy105: + yych = *++p; + if (yych == 'T') goto yy106; + if (yych != 't') goto yy31; +yy106: + yych = *++p; + if (yych == 'R') goto yy107; + if (yych != 'r') goto yy31; +yy107: + yych = *++p; + if (yych == 'I') goto yy108; + if (yych != 'i') goto yy31; +yy108: + yych = *++p; + if (yych == 'L') goto yy109; + if (yych != 'l') goto yy31; +yy109: + yych = *++p; + if (yych == 'O') goto yy34; + if (yych == 'o') goto yy34; + goto yy31; +yy110: + yych = *++p; + if (yych == 'I') goto yy34; + if (yych == 'i') goto yy34; + goto yy31; +yy111: + yych = *++p; + if (yych == 'W') goto yy112; + if (yych != 'w') goto yy31; +yy112: + yych = *++p; + if (yych != '-') goto yy31; + yych = *++p; + if (yych == 'S') goto yy114; + if (yych != 's') goto yy31; +yy114: + yych = *++p; + if (yych == 'O') goto yy115; + if (yych != 'o') goto yy31; +yy115: + yych = *++p; + if (yych == 'U') goto yy116; + if (yych != 'u') goto yy31; +yy116: + yych = *++p; + if (yych == 'R') goto yy117; + if (yych != 'r') goto yy31; +yy117: + yych = *++p; + if (yych == 'C') goto yy118; + if (yych != 'c') goto yy31; +yy118: + yych = *++p; + if (yych == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +yy119: + yych = *++p; + if (yych == '2') goto yy126; + goto yy31; +yy120: + yych = *++p; + if (yych == 'R') goto yy123; + if (yych == 'r') goto yy123; + goto yy31; +yy121: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy122: + yych = *++p; + if (yych == 'N') goto yy34; + if (yych == 'n') goto yy34; + goto yy31; +yy123: + yych = *++p; + if (yych == 'E') goto yy124; + if (yych != 'e') goto yy31; +yy124: + yych = *++p; + if (yych == 'A') goto yy125; + if (yych != 'a') goto yy31; +yy125: + yych = *++p; + if (yych == 'L') goto yy34; + if (yych == 'l') goto yy34; + goto yy31; +yy126: + yych = *++p; + if (yych != '0') goto yy31; + yych = *++p; + if (yych != '0') goto yy31; + yych = *++p; + if (yych == '4') goto yy34; + goto yy31; +yy129: + yych = *++p; + if (yych == 'I') goto yy148; + if (yych == 'i') goto yy148; + goto yy31; +yy130: + yych = *++p; + if (yych <= 'L') { + if (yych == 'A') goto yy140; + if (yych <= 'K') goto yy31; + goto yy139; + } else { + if (yych <= 'a') { + if (yych <= '`') goto yy31; + goto yy140; + } else { + if (yych == 'l') goto yy139; + goto yy31; + } + } +yy131: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy132: + yych = *++p; + if (yych == '3') goto yy136; + goto yy31; +yy133: + yych = *++p; + if (yych == 'T') goto yy135; + if (yych == 't') goto yy135; + goto yy31; +yy134: + yych = *++p; + if (yych == 'G') goto yy34; + if (yych == 'g') goto yy34; + goto yy31; +yy135: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy136: + yych = *++p; + if (yych != '2') goto yy31; + yych = *++p; + if (yych != '7') goto yy31; + yych = *++p; + if (yych == '0') goto yy34; + goto yy31; +yy139: + yych = *++p; + if (yych <= 'M') { + if (yych == ':') goto yy35; + goto yy31; + } else { + if (yych <= 'N') goto yy146; + if (yych == 'n') goto yy146; + goto yy31; + } +yy140: + yych = *++p; + if (yych == 'M') goto yy141; + if (yych != 'm') goto yy31; +yy141: + yych = *++p; + if (yych == 'S') goto yy142; + if (yych != 's') goto yy31; +yy142: + yych = *++p; + if (yych == 'P') goto yy143; + if (yych != 'p') goto yy31; +yy143: + yych = *++p; + if (yych == 'E') goto yy144; + if (yych != 'e') goto yy31; +yy144: + yych = *++p; + if (yych == 'A') goto yy145; + if (yych != 'a') goto yy31; +yy145: + yych = *++p; + if (yych == 'K') goto yy34; + if (yych == 'k') goto yy34; + goto yy31; +yy146: + yych = *++p; + if (yych == 'E') goto yy147; + if (yych != 'e') goto yy31; +yy147: + yych = *++p; + if (yych == 'T') goto yy34; + if (yych == 't') goto yy34; + goto yy31; +yy148: + yych = *++p; + if (yych <= 'S') { + if (yych == 'N') goto yy149; + if (yych <= 'R') goto yy31; + goto yy150; + } else { + if (yych <= 'n') { + if (yych <= 'm') goto yy31; + } else { + if (yych == 's') goto yy150; + goto yy31; + } + } +yy149: + yych = *++p; + if (yych == 'G') goto yy157; + if (yych == 'g') goto yy157; + goto yy31; +yy150: + yych = *++p; + if (yych == 'M') goto yy151; + if (yych != 'm') goto yy31; +yy151: + yych = *++p; + if (yych == 'E') goto yy152; + if (yych != 'e') goto yy31; +yy152: + yych = *++p; + if (yych == 'S') goto yy153; + if (yych != 's') goto yy31; +yy153: + yych = *++p; + if (yych == 'S') goto yy154; + if (yych != 's') goto yy31; +yy154: + yych = *++p; + if (yych == 'A') goto yy155; + if (yych != 'a') goto yy31; +yy155: + yych = *++p; + if (yych == 'G') goto yy156; + if (yych != 'g') goto yy31; +yy156: + yych = *++p; + if (yych == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +yy157: + yych = *++p; + if (yych == 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; +yy158: + yych = *++p; + if (yych == 'N') goto yy34; + if (yych == 'n') goto yy34; + goto yy31; +yy159: + yych = *++p; + if (yych == 'E') goto yy209; + if (yych == 'e') goto yy209; + goto yy31; +yy160: + yych = *++p; + if (yych == 'H') goto yy34; + if (yych == 'h') goto yy34; + goto yy31; +yy161: + yych = *++p; + if (yych == 'O') goto yy205; + if (yych == 'o') goto yy205; + goto yy31; +yy162: + yych = *++p; + if (yych <= 'L') { + if (yych == 'A') goto yy195; + if (yych <= 'K') goto yy31; + goto yy196; + } else { + if (yych <= 'a') { + if (yych <= '`') goto yy31; + goto yy195; + } else { + if (yych == 'l') goto yy196; + goto yy31; + } + } +yy163: + yych = *++p; + if (yych <= 'S') { + if (yych == 'B') goto yy34; + if (yych <= 'R') goto yy31; + goto yy34; + } else { + if (yych <= 'b') { + if (yych <= 'a') goto yy31; + goto yy34; + } else { + if (yych == 's') goto yy34; + goto yy31; + } + } +yy164: + yych = *++p; + if (yych == 'Y') goto yy193; + if (yych == 'y') goto yy193; + goto yy31; +yy165: + yych = *++p; + if (yych == 'N') goto yy34; + if (yych == 'n') goto yy34; + goto yy31; +yy166: + yych = *++p; + if (yych == 'T') goto yy192; + if (yych == 't') goto yy192; + goto yy31; +yy167: + yych = *++p; + if (yych <= 'S') { + if (yych <= 'C') { + if (yych <= 'B') goto yy31; + goto yy179; + } else { + if (yych <= 'Q') goto yy31; + if (yych <= 'R') goto yy177; + goto yy178; + } + } else { + if (yych <= 'q') { + if (yych == 'c') goto yy179; + goto yy31; + } else { + if (yych <= 'r') goto yy177; + if (yych <= 's') goto yy178; + goto yy31; + } + } +yy168: + yych = *++p; + if (yych == 'M') goto yy176; + if (yych == 'm') goto yy176; + goto yy31; +yy169: + yych = *++p; + if (yych <= 'P') { + if (yych == 'E') goto yy173; + if (yych <= 'O') goto yy31; + goto yy174; + } else { + if (yych <= 'e') { + if (yych <= 'd') goto yy31; + goto yy173; + } else { + if (yych == 'p') goto yy174; + goto yy31; + } + } +yy170: + yych = *++p; + if (yych == 'T') goto yy171; + if (yych != 't') goto yy31; +yy171: + yych = *++p; + if (yych == 'T') goto yy172; + if (yych != 't') goto yy31; +yy172: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy173: + yych = *++p; + if (yych == 'V') goto yy175; + if (yych == 'v') goto yy175; + goto yy31; +yy174: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') goto yy35; + goto yy31; + } else { + if (yych <= 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; + } +yy175: + yych = *++p; + if (yych == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +yy176: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy177: + yych = *++p; + if (yych == 'V') goto yy189; + if (yych == 'v') goto yy189; + goto yy31; +yy178: + yych = *++p; + if (yych == 'S') goto yy186; + if (yych == 's') goto yy186; + goto yy31; +yy179: + yych = *++p; + if (yych == 'O') goto yy180; + if (yych != 'o') goto yy31; +yy180: + yych = *++p; + if (yych == 'N') goto yy181; + if (yych != 'n') goto yy31; +yy181: + yych = *++p; + if (yych == 'D') goto yy182; + if (yych != 'd') goto yy31; +yy182: + yych = *++p; + if (yych == 'L') goto yy183; + if (yych != 'l') goto yy31; +yy183: + yych = *++p; + if (yych == 'I') goto yy184; + if (yych != 'i') goto yy31; +yy184: + yych = *++p; + if (yych == 'F') goto yy185; + if (yych != 'f') goto yy31; +yy185: + yych = *++p; + if (yych == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +yy186: + yych = *++p; + if (yych == 'I') goto yy187; + if (yych != 'i') goto yy31; +yy187: + yych = *++p; + if (yych == 'O') goto yy188; + if (yych != 'o') goto yy31; +yy188: + yych = *++p; + if (yych == 'N') goto yy34; + if (yych == 'n') goto yy34; + goto yy31; +yy189: + yych = *++p; + if (yych == 'I') goto yy190; + if (yych != 'i') goto yy31; +yy190: + yych = *++p; + if (yych == 'C') goto yy191; + if (yych != 'c') goto yy31; +yy191: + yych = *++p; + if (yych == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +yy192: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy193: + yych = *++p; + if (yych == 'P') goto yy194; + if (yych != 'p') goto yy31; +yy194: + yych = *++p; + if (yych == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +yy195: + yych = *++p; + if (yych == 'P') goto yy199; + if (yych == 'p') goto yy199; + goto yy31; +yy196: + yych = *++p; + if (yych == 'D') goto yy197; + if (yych != 'd') goto yy31; +yy197: + yych = *++p; + if (yych == 'A') goto yy198; + if (yych != 'a') goto yy31; +yy198: + yych = *++p; + if (yych == 'T') goto yy34; + if (yych == 't') goto yy34; + goto yy31; +yy199: + yych = *++p; + if (yych != '.') goto yy31; + yych = *++p; + if (yych == 'B') goto yy201; + if (yych != 'b') goto yy31; +yy201: + yych = *++p; + if (yych == 'E') goto yy202; + if (yych != 'e') goto yy31; +yy202: + yych = *++p; + if (yych == 'E') goto yy203; + if (yych != 'e') goto yy31; +yy203: + yych = *++p; + if (yych == 'P') goto yy204; + if (yych != 'p') goto yy31; +yy204: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') goto yy35; + goto yy31; + } else { + if (yych <= 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; + } +yy205: + yych = *++p; + if (yych == 'T') goto yy206; + if (yych != 't') goto yy31; +yy206: + yych = *++p; + if (yych == 'I') goto yy207; + if (yych != 'i') goto yy31; +yy207: + yych = *++p; + if (yych == 'F') goto yy208; + if (yych != 'f') goto yy31; +yy208: + yych = *++p; + if (yych == 'Y') goto yy34; + if (yych == 'y') goto yy34; + goto yy31; +yy209: + yych = *++p; + if (yych == 'A') goto yy210; + if (yych != 'a') goto yy31; +yy210: + yych = *++p; + if (yych == 'M') goto yy34; + if (yych == 'm') goto yy34; + goto yy31; +yy211: + yych = *++p; + if (yych <= 'S') { + if (yych == 'M') goto yy223; + if (yych <= 'R') goto yy31; + goto yy222; + } else { + if (yych <= 'm') { + if (yych <= 'l') goto yy31; + goto yy223; + } else { + if (yych == 's') goto yy222; + goto yy31; + } + } +yy212: + yych = *++p; + if (yych == 'Y') goto yy220; + if (yych == 'y') goto yy220; + goto yy31; +yy213: + yych = *++p; + if (yych == 'I') goto yy34; + if (yych == 'i') goto yy34; + goto yy31; +yy214: + yych = *++p; + if (yych == 'S') goto yy215; + if (yych != 's') goto yy31; +yy215: + yych = *++p; + if (yych <= 'N') { + if (yych == ':') goto yy35; + goto yy31; + } else { + if (yych <= 'O') goto yy216; + if (yych != 'o') goto yy31; + } +yy216: + yych = *++p; + if (yych == 'U') goto yy217; + if (yych != 'u') goto yy31; +yy217: + yych = *++p; + if (yych == 'R') goto yy218; + if (yych != 'r') goto yy31; +yy218: + yych = *++p; + if (yych == 'C') goto yy219; + if (yych != 'c') goto yy31; +yy219: + yych = *++p; + if (yych == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +yy220: + yych = *++p; + if (yych == 'N') goto yy221; + if (yych != 'n') goto yy31; +yy221: + yych = *++p; + if (yych == 'C') goto yy34; + if (yych == 'c') goto yy34; + goto yy31; +yy222: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy223: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy224: + yych = *++p; + if (yych == 'Y') goto yy244; + if (yych == 'y') goto yy244; + goto yy31; +yy225: + yych = *++p; + if (yych <= 'O') { + if (yych == 'E') goto yy241; + if (yych <= 'N') goto yy31; + goto yy242; + } else { + if (yych <= 'e') { + if (yych <= 'd') goto yy31; + goto yy241; + } else { + if (yych == 'o') goto yy242; + goto yy31; + } + } +yy226: + yych = *++p; + if (yych == 'A') goto yy236; + if (yych == 'a') goto yy236; + goto yy31; +yy227: + yych = *++p; + if (yych <= 'P') { + if (yych == 'L') goto yy229; + if (yych <= 'O') goto yy31; + goto yy230; + } else { + if (yych <= 'l') { + if (yych <= 'k') goto yy31; + goto yy229; + } else { + if (yych == 'p') goto yy230; + goto yy31; + } + } +yy228: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy229: + yych = *++p; + if (yych == 'M') goto yy34; + if (yych == 'm') goto yy34; + goto yy31; +yy230: + yych = *++p; + if (yych == 'A') goto yy231; + if (yych != 'a') goto yy31; +yy231: + yych = *++p; + if (yych == 'R') goto yy232; + if (yych != 'r') goto yy31; +yy232: + yych = *++p; + if (yych == 'A') goto yy233; + if (yych != 'a') goto yy31; +yy233: + yych = *++p; + if (yych == 'Z') goto yy234; + if (yych != 'z') goto yy31; +yy234: + yych = *++p; + if (yych == 'Z') goto yy235; + if (yych != 'z') goto yy31; +yy235: + yych = *++p; + if (yych == 'I') goto yy34; + if (yych == 'i') goto yy34; + goto yy31; +yy236: + yych = *++p; + if (yych == 'T') goto yy237; + if (yych != 't') goto yy31; +yy237: + yych = *++p; + if (yych == 'F') goto yy238; + if (yych != 'f') goto yy31; +yy238: + yych = *++p; + if (yych == 'O') goto yy239; + if (yych != 'o') goto yy31; +yy239: + yych = *++p; + if (yych == 'R') goto yy240; + if (yych != 'r') goto yy31; +yy240: + yych = *++p; + if (yych == 'M') goto yy34; + if (yych == 'm') goto yy34; + goto yy31; +yy241: + yych = *++p; + if (yych == 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; +yy242: + yych = *++p; + if (yych == 'X') goto yy243; + if (yych != 'x') goto yy31; +yy243: + yych = *++p; + if (yych == 'Y') goto yy34; + if (yych == 'y') goto yy34; + goto yy31; +yy244: + yych = *++p; + if (yych == 'C') goto yy34; + if (yych == 'c') goto yy34; + goto yy31; +yy245: + yych = *++p; + if (yych == 'D') goto yy34; + if (yych == 'd') goto yy34; + goto yy31; +yy246: + yych = *++p; + if (yych == 'A') goto yy247; + if (yych != 'a') goto yy31; +yy247: + yych = *++p; + if (yych == 'Q') goto yy248; + if (yych != 'q') goto yy31; +yy248: + yych = *++p; + if (yych == 'U') goto yy249; + if (yych != 'u') goto yy31; +yy249: + yych = *++p; + if (yych == 'E') goto yy250; + if (yych != 'e') goto yy31; +yy250: + yych = *++p; + if (yych == 'L') goto yy251; + if (yych != 'l') goto yy31; +yy251: + yych = *++p; + if (yych == 'O') goto yy252; + if (yych != 'o') goto yy31; +yy252: + yych = *++p; + if (yych == 'C') goto yy253; + if (yych != 'c') goto yy31; +yy253: + yych = *++p; + if (yych == 'K') goto yy254; + if (yych != 'k') goto yy31; +yy254: + yych = *++p; + if (yych == 'T') goto yy255; + if (yych != 't') goto yy31; +yy255: + yych = *++p; + if (yych == 'O') goto yy256; + if (yych != 'o') goto yy31; +yy256: + yych = *++p; + if (yych == 'K') goto yy257; + if (yych != 'k') goto yy31; +yy257: + yych = *++p; + if (yych == 'E') goto yy258; + if (yych != 'e') goto yy31; +yy258: + yych = *++p; + if (yych == 'N') goto yy34; + if (yych == 'n') goto yy34; + goto yy31; +yy259: + yych = *++p; + if (yych == 'T') goto yy266; + if (yych == 't') goto yy266; + goto yy31; +yy260: + yych = *++p; + if (yych == 'T') goto yy265; + if (yych == 't') goto yy265; + goto yy31; +yy261: + yych = *++p; + if (yych <= 'G') { + if (yych == ':') goto yy35; + goto yy31; + } else { + if (yych <= 'H') goto yy34; + if (yych == 'h') goto yy34; + goto yy31; + } +yy262: + yych = *++p; + if (yych == 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; +yy263: + yych = *++p; + if (yych == 'W') goto yy264; + if (yych != 'w') goto yy31; +yy264: + yych = *++p; + if (yych == 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; +yy265: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy266: + yych = *++p; + if (yych == 'E') goto yy267; + if (yych != 'e') goto yy31; +yy267: + yych = *++p; + if (yych == 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; +yy268: + yych = *++p; + if (yych == 'N') goto yy34; + if (yych == 'n') goto yy34; + goto yy31; +yy269: + yych = *++p; + if (yych <= 'P') { + if (yych == 'M') goto yy300; + if (yych <= 'O') goto yy31; + goto yy299; + } else { + if (yych <= 'm') { + if (yych <= 'l') goto yy31; + goto yy300; + } else { + if (yych == 'p') goto yy299; + goto yy31; + } + } +yy270: + yych = *++p; + if (yych <= 'Q') { + if (yych <= '-') { + if (yych <= ',') goto yy31; + goto yy292; + } else { + if (yych == 'N') goto yy293; + goto yy31; + } + } else { + if (yych <= 'n') { + if (yych <= 'R') goto yy291; + if (yych <= 'm') goto yy31; + goto yy293; + } else { + if (yych == 'r') goto yy291; + goto yy31; + } + } +yy271: + yych = *++p; + if (yych == 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; +yy272: + yych = *++p; + if (yych == 'S') goto yy287; + if (yych == 's') goto yy287; + goto yy31; +yy273: + yych = *++p; + switch (yych) { + case 'G': + case 'g': goto yy278; + case 'I': + case 'i': goto yy277; + case 'P': + case 'p': goto yy279; + case 'R': + case 'r': goto yy280; + default: goto yy31; + } +yy274: + yych = *++p; + if (yych == 'Q') goto yy276; + if (yych == 'q') goto yy276; + goto yy31; +yy275: + yych = *++p; + if (yych == 'D') goto yy34; + if (yych == 'd') goto yy34; + goto yy31; +yy276: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy277: + yych = *++p; + if (yych == 'L') goto yy285; + if (yych == 'l') goto yy285; + goto yy31; +yy278: + yych = *++p; + if (yych == 'N') goto yy283; + if (yych == 'n') goto yy283; + goto yy31; +yy279: + yych = *++p; + if (yych == 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; +yy280: + yych = *++p; + if (yych == 'K') goto yy281; + if (yych != 'k') goto yy31; +yy281: + yych = *++p; + if (yych == 'E') goto yy282; + if (yych != 'e') goto yy31; +yy282: + yych = *++p; + if (yych == 'T') goto yy34; + if (yych == 't') goto yy34; + goto yy31; +yy283: + yych = *++p; + if (yych == 'E') goto yy284; + if (yych != 'e') goto yy31; +yy284: + yych = *++p; + if (yych == 'T') goto yy34; + if (yych == 't') goto yy34; + goto yy31; +yy285: + yych = *++p; + if (yych == 'T') goto yy286; + if (yych != 't') goto yy31; +yy286: + yych = *++p; + if (yych == 'O') goto yy34; + if (yych == 'o') goto yy34; + goto yy31; +yy287: + yych = *++p; + if (yych == 'S') goto yy288; + if (yych != 's') goto yy31; +yy288: + yych = *++p; + if (yych == 'A') goto yy289; + if (yych != 'a') goto yy31; +yy289: + yych = *++p; + if (yych == 'G') goto yy290; + if (yych != 'g') goto yy31; +yy290: + yych = *++p; + if (yych == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +yy291: + yych = *++p; + if (yych == 'P') goto yy298; + if (yych == 'p') goto yy298; + goto yy31; +yy292: + yych = *++p; + if (yych == 'H') goto yy295; + if (yych == 'h') goto yy295; + goto yy31; +yy293: + yych = *++p; + if (yych == 'I') goto yy294; + if (yych != 'i') goto yy31; +yy294: + yych = *++p; + if (yych == 'M') goto yy34; + if (yych == 'm') goto yy34; + goto yy31; +yy295: + yych = *++p; + if (yych == 'E') goto yy296; + if (yych != 'e') goto yy31; +yy296: + yych = *++p; + if (yych == 'L') goto yy297; + if (yych != 'l') goto yy31; +yy297: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy298: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') goto yy35; + goto yy31; + } else { + if (yych <= 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; + } +yy299: + yych = *++p; + if (yych == 'D') goto yy303; + if (yych == 'd') goto yy303; + goto yy31; +yy300: + yych = *++p; + if (yych == 'B') goto yy301; + if (yych != 'b') goto yy31; +yy301: + yych = *++p; + if (yych == 'L') goto yy302; + if (yych != 'l') goto yy31; +yy302: + yych = *++p; + if (yych == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +yy303: + yych = *++p; + if (yych == 'A') goto yy304; + if (yych != 'a') goto yy31; +yy304: + yych = *++p; + if (yych == 'T') goto yy305; + if (yych != 't') goto yy31; +yy305: + yych = *++p; + if (yych == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +yy306: + yych = *++p; + if (yych == 'A') goto yy311; + if (yych == 'a') goto yy311; + goto yy31; +yy307: + yych = *++p; + if (yych == 'S') goto yy308; + if (yych != 's') goto yy31; +yy308: + yych = *++p; + if (yych == 'T') goto yy309; + if (yych != 't') goto yy31; +yy309: + yych = *++p; + if (yych == 'F') goto yy310; + if (yych != 'f') goto yy31; +yy310: + yych = *++p; + if (yych == 'M') goto yy34; + if (yych == 'm') goto yy34; + goto yy31; +yy311: + yych = *++p; + if (yych == 'P') goto yy312; + if (yych != 'p') goto yy31; +yy312: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') goto yy35; + goto yy31; + } else { + if (yych <= 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; + } +yy313: + yych = *++p; + if (yych == 'M') goto yy336; + if (yych == 'm') goto yy336; + goto yy31; +yy314: + yych = *++p; + if (yych <= 'I') { + if (yych == 'C') goto yy325; + if (yych <= 'H') goto yy31; + goto yy324; + } else { + if (yych <= 'c') { + if (yych <= 'b') goto yy31; + goto yy325; + } else { + if (yych == 'i') goto yy324; + goto yy31; + } + } +yy315: + yych = *++p; + if (yych <= 'P') { + if (yych == 'N') goto yy34; + if (yych <= 'O') goto yy31; + goto yy34; + } else { + if (yych <= 'n') { + if (yych <= 'm') goto yy31; + goto yy34; + } else { + if (yych == 'p') goto yy34; + goto yy31; + } + } +yy316: + yych = *++p; + if (yych <= 'O') { + if (yych == 'A') goto yy322; + if (yych <= 'N') goto yy31; + goto yy323; + } else { + if (yych <= 'a') { + if (yych <= '`') goto yy31; + goto yy322; + } else { + if (yych == 'o') goto yy323; + goto yy31; + } + } +yy317: + yych = *++p; + if (yych == 'F') goto yy321; + if (yych == 'f') goto yy321; + goto yy31; +yy318: + yych = *++p; + if (yych <= '@') { + if (yych == ':') goto yy35; + goto yy31; + } else { + if (yych <= 'A') goto yy320; + if (yych == 'a') goto yy320; + goto yy31; + } +yy319: + yych = *++p; + if (yych == 'X') goto yy34; + if (yych == 'x') goto yy34; + goto yy31; +yy320: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy321: + yych = *++p; + if (yych == 'O') goto yy34; + if (yych == 'o') goto yy34; + goto yy31; +yy322: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy323: + yych = *++p; + if (yych == 'N') goto yy34; + if (yych == 'n') goto yy34; + goto yy31; +yy324: + yych = *++p; + if (yych == 'S') goto yy326; + if (yych == 's') goto yy326; + goto yy31; +yy325: + yych = *++p; + if (yych <= ':') { + if (yych == '6') goto yy34; + if (yych <= '9') goto yy31; + goto yy35; + } else { + if (yych <= 'S') { + if (yych <= 'R') goto yy31; + goto yy34; + } else { + if (yych == 's') goto yy34; + goto yy31; + } + } +yy326: + yych = *++p; + if (yych == '.') goto yy327; + if (yych == ':') goto yy35; + goto yy31; +yy327: + yych = *++p; + if (yych <= 'X') { + if (yych <= 'K') { + if (yych == 'B') goto yy330; + goto yy31; + } else { + if (yych <= 'L') goto yy328; + if (yych <= 'W') goto yy31; + goto yy329; + } + } else { + if (yych <= 'k') { + if (yych == 'b') goto yy330; + goto yy31; + } else { + if (yych <= 'l') goto yy328; + if (yych == 'x') goto yy329; + goto yy31; + } + } +yy328: + yych = *++p; + if (yych == 'W') goto yy335; + if (yych == 'w') goto yy335; + goto yy31; +yy329: + yych = *++p; + if (yych == 'P') goto yy333; + if (yych == 'p') goto yy333; + goto yy31; +yy330: + yych = *++p; + if (yych == 'E') goto yy331; + if (yych != 'e') goto yy31; +yy331: + yych = *++p; + if (yych == 'E') goto yy332; + if (yych != 'e') goto yy31; +yy332: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy333: + yych = *++p; + if (yych == 'C') goto yy334; + if (yych != 'c') goto yy31; +yy334: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') goto yy35; + goto yy31; + } else { + if (yych <= 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; + } +yy335: + yych = *++p; + if (yych == 'Z') goto yy34; + if (yych == 'z') goto yy34; + goto yy31; +yy336: + yych = *++p; + if (yych == 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; +yy337: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy338: + yych = *++p; + if (yych == 'T') goto yy341; + if (yych == 't') goto yy341; + goto yy31; +yy339: + yych = *++p; + if (yych != '2') goto yy31; + yych = *++p; + if (yych == '3') goto yy34; + goto yy31; +yy341: + yych = *++p; + if (yych == 'P') goto yy342; + if (yych != 'p') goto yy31; +yy342: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') goto yy35; + goto yy31; + } else { + if (yych <= 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; + } +yy343: + yych = *++p; + if (yych == 'A') goto yy359; + if (yych == 'a') goto yy359; + goto yy31; +yy344: + yych = *++p; + if (yych <= 'Z') { + if (yych == 'T') goto yy34; + if (yych <= 'Y') goto yy31; + goto yy350; + } else { + if (yych <= 't') { + if (yych <= 's') goto yy31; + goto yy34; + } else { + if (yych == 'z') goto yy350; + goto yy31; + } + } +yy345: + yych = *++p; + if (yych <= 'O') { + if (yych == ':') goto yy35; + goto yy31; + } else { + if (yych <= 'P') goto yy347; + if (yych == 'p') goto yy347; + goto yy31; + } +yy346: + yych = *++p; + if (yych == 'O') goto yy34; + if (yych == 'o') goto yy34; + goto yy31; +yy347: + yych = *++p; + if (yych == 'H') goto yy348; + if (yych != 'h') goto yy31; +yy348: + yych = *++p; + if (yych == 'E') goto yy349; + if (yych != 'e') goto yy31; +yy349: + yych = *++p; + if (yych == 'R') goto yy34; + if (yych == 'r') goto yy34; + goto yy31; +yy350: + yych = *++p; + if (yych == 'M') goto yy351; + if (yych != 'm') goto yy31; +yy351: + yych = *++p; + if (yych == 'O') goto yy352; + if (yych != 'o') goto yy31; +yy352: + yych = *++p; + if (yych == 'P') goto yy353; + if (yych != 'p') goto yy31; +yy353: + yych = *++p; + if (yych == 'R') goto yy354; + if (yych != 'r') goto yy31; +yy354: + yych = *++p; + if (yych == 'O') goto yy355; + if (yych != 'o') goto yy31; +yy355: + yych = *++p; + if (yych == 'J') goto yy356; + if (yych != 'j') goto yy31; +yy356: + yych = *++p; + if (yych == 'E') goto yy357; + if (yych != 'e') goto yy31; +yy357: + yych = *++p; + if (yych == 'C') goto yy358; + if (yych != 'c') goto yy31; +yy358: + yych = *++p; + if (yych == 'T') goto yy34; + if (yych == 't') goto yy34; + goto yy31; +yy359: + yych = *++p; + if (yych == 'L') goto yy360; + if (yych != 'l') goto yy31; +yy360: + yych = *++p; + if (yych == 'K') goto yy34; + if (yych == 'k') goto yy34; + goto yy31; +yy361: + yych = *++p; + if (yych <= 'S') { + if (yych <= 'M') { + if (yych == 'L') goto yy371; + goto yy31; + } else { + if (yych <= 'N') goto yy372; + if (yych <= 'R') goto yy31; + goto yy373; + } + } else { + if (yych <= 'm') { + if (yych == 'l') goto yy371; + goto yy31; + } else { + if (yych <= 'n') goto yy372; + if (yych == 's') goto yy373; + goto yy31; + } + } +yy362: + yych = *++p; + if (yych == 'E') goto yy370; + if (yych == 'e') goto yy370; + goto yy31; +yy363: + yych = *++p; + if (yych == 'C') goto yy365; + if (yych == 'c') goto yy365; + goto yy31; +yy364: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy365: + yych = *++p; + if (yych == 'E') goto yy366; + if (yych != 'e') goto yy31; +yy366: + yych = *++p; + if (yych == 'T') goto yy367; + if (yych != 't') goto yy31; +yy367: + yych = *++p; + if (yych == 'I') goto yy368; + if (yych != 'i') goto yy31; +yy368: + yych = *++p; + if (yych == 'M') goto yy369; + if (yych != 'm') goto yy31; +yy369: + yych = *++p; + if (yych == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +yy370: + yych = *++p; + if (yych == 'D') goto yy34; + if (yych == 'd') goto yy34; + goto yy31; +yy371: + yych = *++p; + if (yych == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +yy372: + yych = *++p; + if (yych == 'G') goto yy374; + if (yych == 'g') goto yy374; + goto yy31; +yy373: + yych = *++p; + if (yych == 'H') goto yy34; + if (yych == 'h') goto yy34; + goto yy31; +yy374: + yych = *++p; + if (yych == 'E') goto yy375; + if (yych != 'e') goto yy31; +yy375: + yych = *++p; + if (yych == 'R') goto yy34; + if (yych == 'r') goto yy34; + goto yy31; +yy376: + yych = *++p; + if (yych == 'T') goto yy394; + if (yych == 't') goto yy394; + goto yy31; +yy377: + yych = *++p; + if (yych == 'T') goto yy34; + if (yych == 't') goto yy34; + goto yy31; +yy378: + yych = *++p; + if (yych == 'M') goto yy34; + if (yych == 'm') goto yy34; + goto yy31; +yy379: + yych = *++p; + if (yych <= 'S') { + if (yych == 'P') goto yy34; + if (yych <= 'R') goto yy31; + goto yy34; + } else { + if (yych <= 'p') { + if (yych <= 'o') goto yy31; + goto yy34; + } else { + if (yych == 's') goto yy34; + goto yy31; + } + } +yy380: + yych = *++p; + if (yych == 'I') goto yy388; + if (yych == 'i') goto yy388; + goto yy31; +yy381: + yych = *++p; + if (yych == 'A') goto yy387; + if (yych == 'a') goto yy387; + goto yy31; +yy382: + yych = *++p; + if (yych == 'O') goto yy385; + if (yych == 'o') goto yy385; + goto yy31; +yy383: + yych = *++p; + if (yych == 'A') goto yy384; + if (yych != 'a') goto yy31; +yy384: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') goto yy35; + goto yy31; + } else { + if (yych <= 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; + } +yy385: + yych = *++p; + if (yych == 'U') goto yy386; + if (yych != 'u') goto yy31; +yy386: + yych = *++p; + if (yych == 'T') goto yy34; + if (yych == 't') goto yy34; + goto yy31; +yy387: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy388: + yych = *++p; + if (yych == 'U') goto yy389; + if (yych != 'u') goto yy31; +yy389: + yych = *++p; + if (yych == 'M') goto yy390; + if (yych != 'm') goto yy31; +yy390: + yych = *++p; + if (yych == 'X') goto yy391; + if (yych != 'x') goto yy31; +yy391: + yych = *++p; + if (yych == 'T') goto yy392; + if (yych != 't') goto yy31; +yy392: + yych = *++p; + if (yych == 'R') goto yy393; + if (yych != 'r') goto yy31; +yy393: + yych = *++p; + if (yych == 'A') goto yy34; + if (yych == 'a') goto yy34; + goto yy31; +yy394: + yych = *++p; + if (yych == 'A') goto yy395; + if (yych != 'a') goto yy31; +yy395: + yych = *++p; + if (yych == 'C') goto yy396; + if (yych != 'c') goto yy31; +yy396: + yych = *++p; + if (yych == 'H') goto yy397; + if (yych != 'h') goto yy31; +yy397: + yych = *++p; + if (yych == 'M') goto yy398; + if (yych != 'm') goto yy31; +yy398: + yych = *++p; + if (yych == 'E') goto yy399; + if (yych != 'e') goto yy31; +yy399: + yych = *++p; + if (yych == 'N') goto yy400; + if (yych != 'n') goto yy31; +yy400: + yych = *++p; + if (yych == 'T') goto yy34; + if (yych == 't') goto yy34; + goto yy31; +yy401: + yych = *++p; + if (yych == 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; +yy402: + yych = *++p; + if (yych <= 'V') { + if (yych == 'R') goto yy34; + if (yych <= 'U') goto yy31; + } else { + if (yych <= 'r') { + if (yych <= 'q') goto yy31; + goto yy34; + } else { + if (yych != 'v') goto yy31; + } + } + yych = *++p; + if (yych == 'A') goto yy404; + if (yych != 'a') goto yy31; +yy404: + yych = *++p; + if (yych == 'S') goto yy405; + if (yych != 's') goto yy31; +yy405: + yych = *++p; + if (yych == 'C') goto yy406; + if (yych != 'c') goto yy31; +yy406: + yych = *++p; + if (yych == 'R') goto yy407; + if (yych != 'r') goto yy31; +yy407: + yych = *++p; + if (yych == 'I') goto yy408; + if (yych != 'i') goto yy31; +yy408: + yych = *++p; + if (yych == 'P') goto yy409; + if (yych != 'p') goto yy31; +yy409: + yych = *++p; + if (yych == 'T') goto yy34; + if (yych == 't') goto yy34; + goto yy31; +yy410: + yych = *++p; + if (yych == 'B') goto yy34; + if (yych == 'b') goto yy34; + goto yy31; +yy411: + yych = *++p; + if (yych == 'N') goto yy34; + if (yych == 'n') goto yy34; + goto yy31; +yy412: + yych = *++p; + if (yych == 'N') goto yy419; + if (yych == 'n') goto yy419; + goto yy31; +yy413: + yych = *++p; + if (yych == 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; +yy414: + yych = *++p; + if (yych == 'C') goto yy418; + if (yych == 'c') goto yy418; + goto yy31; +yy415: + yych = *++p; + if (yych <= 'V') { + if (yych == 'T') goto yy417; + if (yych <= 'U') goto yy31; + goto yy34; + } else { + if (yych <= 't') { + if (yych <= 's') goto yy31; + goto yy417; + } else { + if (yych == 'v') goto yy34; + goto yy31; + } + } +yy416: + yych = *++p; + if (yych == 'I') goto yy34; + if (yych == 'i') goto yy34; + goto yy31; +yy417: + yych = *++p; + if (yych == 'A') goto yy34; + if (yych == 'a') goto yy34; + goto yy31; +yy418: + yych = *++p; + if (yych == 'T') goto yy34; + if (yych == 't') goto yy34; + goto yy31; +yy419: + yych = *++p; + if (yych == 'A') goto yy420; + if (yych != 'a') goto yy31; +yy420: + yych = *++p; + if (yych != '-') goto yy31; + yych = *++p; + if (yych == 'P') goto yy422; + if (yych != 'p') goto yy31; +yy422: + yych = *++p; + if (yych == 'L') goto yy423; + if (yych != 'l') goto yy31; +yy423: + yych = *++p; + if (yych == 'A') goto yy424; + if (yych != 'a') goto yy31; +yy424: + yych = *++p; + if (yych == 'Y') goto yy425; + if (yych != 'y') goto yy31; +yy425: + yych = *++p; + if (yych <= 'S') { + if (yych == 'C') goto yy426; + if (yych <= 'R') goto yy31; + goto yy427; + } else { + if (yych <= 'c') { + if (yych <= 'b') goto yy31; + } else { + if (yych == 's') goto yy427; + goto yy31; + } + } +yy426: + yych = *++p; + if (yych == 'O') goto yy432; + if (yych == 'o') goto yy432; + goto yy31; +yy427: + yych = *++p; + if (yych == 'I') goto yy428; + if (yych != 'i') goto yy31; +yy428: + yych = *++p; + if (yych == 'N') goto yy429; + if (yych != 'n') goto yy31; +yy429: + yych = *++p; + if (yych == 'G') goto yy430; + if (yych != 'g') goto yy31; +yy430: + yych = *++p; + if (yych == 'L') goto yy431; + if (yych != 'l') goto yy31; +yy431: + yych = *++p; + if (yych == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +yy432: + yych = *++p; + if (yych == 'N') goto yy433; + if (yych != 'n') goto yy31; +yy433: + yych = *++p; + if (yych == 'T') goto yy434; + if (yych != 't') goto yy31; +yy434: + yych = *++p; + if (yych == 'A') goto yy435; + if (yych != 'a') goto yy31; +yy435: + yych = *++p; + if (yych == 'I') goto yy436; + if (yych != 'i') goto yy31; +yy436: + yych = *++p; + if (yych == 'N') goto yy437; + if (yych != 'n') goto yy31; +yy437: + yych = *++p; + if (yych == 'E') goto yy438; + if (yych != 'e') goto yy31; +yy438: + yych = *++p; + if (yych == 'R') goto yy34; + if (yych == 'r') goto yy34; + goto yy31; +yy439: + yych = *++p; + if (yych == 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; +yy440: + yych = *++p; + if (yych <= 'N') { + if (yych <= 'A') { + if (yych <= '@') goto yy31; + goto yy462; + } else { + if (yych <= 'L') goto yy31; + if (yych <= 'M') goto yy463; + goto yy464; + } + } else { + if (yych <= 'l') { + if (yych == 'a') goto yy462; + goto yy31; + } else { + if (yych <= 'm') goto yy463; + if (yych <= 'n') goto yy464; + goto yy31; + } + } +yy441: + yych = *++p; + if (yych == 'R') goto yy449; + if (yych == 'r') goto yy449; + goto yy31; +yy442: + yych = *++p; + if (yych <= 'P') { + if (yych == 'L') goto yy446; + if (yych <= 'O') goto yy31; + goto yy34; + } else { + if (yych <= 'l') { + if (yych <= 'k') goto yy31; + goto yy446; + } else { + if (yych == 'p') goto yy34; + goto yy31; + } + } +yy443: + yych = *++p; + if (yych == 'I') goto yy445; + if (yych == 'i') goto yy445; + goto yy31; +yy444: + yych = *++p; + if (yych == 'D') goto yy34; + if (yych == 'd') goto yy34; + goto yy31; +yy445: + yych = *++p; + if (yych == 'D') goto yy34; + if (yych == 'd') goto yy34; + goto yy31; +yy446: + yych = *++p; + if (yych == 'L') goto yy447; + if (yych != 'l') goto yy31; +yy447: + yych = *++p; + if (yych == 'T') goto yy448; + if (yych != 't') goto yy31; +yy448: + yych = *++p; + if (yych == 'O') goto yy34; + if (yych == 'o') goto yy34; + goto yy31; +yy449: + yych = *++p; + if (yych == 'O') goto yy450; + if (yych != 'o') goto yy31; +yy450: + yych = *++p; + if (yych == 'M') goto yy451; + if (yych != 'm') goto yy31; +yy451: + yych = *++p; + if (yych == 'E') goto yy452; + if (yych != 'e') goto yy31; +yy452: + yych = *++p; + if (yych == '-') goto yy453; + if (yych == ':') goto yy35; + goto yy31; +yy453: + yych = *++p; + if (yych == 'E') goto yy454; + if (yych != 'e') goto yy31; +yy454: + yych = *++p; + if (yych == 'X') goto yy455; + if (yych != 'x') goto yy31; +yy455: + yych = *++p; + if (yych == 'T') goto yy456; + if (yych != 't') goto yy31; +yy456: + yych = *++p; + if (yych == 'E') goto yy457; + if (yych != 'e') goto yy31; +yy457: + yych = *++p; + if (yych == 'N') goto yy458; + if (yych != 'n') goto yy31; +yy458: + yych = *++p; + if (yych == 'S') goto yy459; + if (yych != 's') goto yy31; +yy459: + yych = *++p; + if (yych == 'I') goto yy460; + if (yych != 'i') goto yy31; +yy460: + yych = *++p; + if (yych == 'O') goto yy461; + if (yych != 'o') goto yy31; +yy461: + yych = *++p; + if (yych == 'N') goto yy34; + if (yych == 'n') goto yy34; + goto yy31; +yy462: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy463: + yych = *++p; + if (yych == '-') goto yy468; + goto yy31; +yy464: + yych = *++p; + if (yych == 'T') goto yy465; + if (yych != 't') goto yy31; +yy465: + yych = *++p; + if (yych == 'E') goto yy466; + if (yych != 'e') goto yy31; +yy466: + yych = *++p; + if (yych == 'N') goto yy467; + if (yych != 'n') goto yy31; +yy467: + yych = *++p; + if (yych == 'T') goto yy34; + if (yych == 't') goto yy34; + goto yy31; +yy468: + yych = *++p; + if (yych == 'E') goto yy469; + if (yych != 'e') goto yy31; +yy469: + yych = *++p; + if (yych == 'V') goto yy470; + if (yych != 'v') goto yy31; +yy470: + yych = *++p; + if (yych == 'E') goto yy471; + if (yych != 'e') goto yy31; +yy471: + yych = *++p; + if (yych == 'N') goto yy472; + if (yych != 'n') goto yy31; +yy472: + yych = *++p; + if (yych == 'T') goto yy473; + if (yych != 't') goto yy31; +yy473: + yych = *++p; + if (yych == 'B') goto yy474; + if (yych != 'b') goto yy31; +yy474: + yych = *++p; + if (yych == 'R') goto yy475; + if (yych != 'r') goto yy31; +yy475: + yych = *++p; + if (yych == 'I') goto yy476; + if (yych != 'i') goto yy31; +yy476: + yych = *++p; + if (yych == 'T') goto yy477; + if (yych != 't') goto yy31; +yy477: + yych = *++p; + if (yych == 'E') goto yy478; + if (yych != 'e') goto yy31; +yy478: + yych = *++p; + if (yych != '-') goto yy31; + yych = *++p; + if (yych == 'A') goto yy480; + if (yych != 'a') goto yy31; +yy480: + yych = *++p; + if (yych == 'T') goto yy481; + if (yych != 't') goto yy31; +yy481: + yych = *++p; + if (yych == 'T') goto yy482; + if (yych != 't') goto yy31; +yy482: + yych = *++p; + if (yych == 'E') goto yy483; + if (yych != 'e') goto yy31; +yy483: + yych = *++p; + if (yych == 'N') goto yy484; + if (yych != 'n') goto yy31; +yy484: + yych = *++p; + if (yych == 'D') goto yy485; + if (yych != 'd') goto yy31; +yy485: + yych = *++p; + if (yych == 'E') goto yy486; + if (yych != 'e') goto yy31; +yy486: + ++p; + if ((yych = *p) == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +} + +} + +// Try to match email autolink after first <, returning num of chars matched. +int _scan_autolink_email(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; + +{ + unsigned char yych; + static const unsigned char yybm[] = { + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 128, 0, 128, 128, 128, 128, 128, + 0, 0, 128, 128, 0, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 0, 0, 0, 128, 0, 128, + 0, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 0, 0, 0, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + }; + yych = *p; + if (yych <= ',') { + if (yych <= '!') { + if (yych == '\n') goto yy489; + if (yych <= ' ') goto yy491; + goto yy490; + } else { + if (yych <= '\'') { + if (yych <= '"') goto yy491; + goto yy490; + } else { + if (yych <= ')') goto yy491; + if (yych <= '+') goto yy490; + goto yy491; + } + } + } else { + if (yych <= '?') { + if (yych <= '<') { + if (yych <= '9') goto yy490; + goto yy491; + } else { + if (yych == '>') goto yy491; + goto yy490; + } + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy491; + goto yy490; + } else { + if (yych <= ']') goto yy491; + if (yych <= '~') goto yy490; + goto yy491; + } + } + } +yy489: + { return 0; } +yy490: + yych = *(marker = ++p); + if (yych <= ',') { + if (yych <= '"') { + if (yych == '!') goto yy495; + goto yy489; + } else { + if (yych <= '\'') goto yy495; + if (yych <= ')') goto yy489; + if (yych <= '+') goto yy495; + goto yy489; + } + } else { + if (yych <= '>') { + if (yych <= '9') goto yy495; + if (yych == '=') goto yy495; + goto yy489; + } else { + if (yych <= 'Z') goto yy495; + if (yych <= ']') goto yy489; + if (yych <= '~') goto yy495; + goto yy489; + } + } +yy491: + yych = *++p; + goto yy489; +yy492: + yych = *++p; + if (yych <= '@') { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy496; + } else { + if (yych <= 'Z') goto yy496; + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy496; + } +yy493: + p = marker; + goto yy489; +yy494: + ++p; + yych = *p; +yy495: + if (yybm[0+yych] & 128) { + goto yy494; + } + if (yych == '@') goto yy492; + goto yy493; +yy496: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy498; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy498; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy498; + goto yy493; + } + } + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy626; + if (yych <= '/') goto yy493; + goto yy627; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy627; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy627; + goto yy493; + } + } +yy498: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych <= '-') goto yy626; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy627; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy627; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy627; + goto yy493; + } + } +yy499: + ++p; + yych = *p; + if (yych <= '@') { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy502; + goto yy493; + } else { + if (yych <= 'Z') goto yy502; + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy502; + goto yy493; + } +yy500: + ++p; + { return (p - start); } +yy502: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy504; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy504; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy504; + goto yy493; + } + } + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy505; + if (yych <= '/') goto yy493; + goto yy506; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy506; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy506; + goto yy493; + } + } +yy504: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy506; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy506; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy506; + goto yy493; + } + } +yy505: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy507; + if (yych <= '/') goto yy493; + goto yy508; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy508; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy508; + goto yy493; + } + } +yy506: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy508; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy508; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy508; + goto yy493; + } + } +yy507: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy509; + if (yych <= '/') goto yy493; + goto yy510; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy510; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy510; + goto yy493; + } + } +yy508: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy510; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy510; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy510; + goto yy493; + } + } +yy509: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy511; + if (yych <= '/') goto yy493; + goto yy512; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy512; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy512; + goto yy493; + } + } +yy510: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy512; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy512; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy512; + goto yy493; + } + } +yy511: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy513; + if (yych <= '/') goto yy493; + goto yy514; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy514; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy514; + goto yy493; + } + } +yy512: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy514; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy514; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy514; + goto yy493; + } + } +yy513: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy515; + if (yych <= '/') goto yy493; + goto yy516; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy516; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy516; + goto yy493; + } + } +yy514: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy516; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy516; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy516; + goto yy493; + } + } +yy515: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy517; + if (yych <= '/') goto yy493; + goto yy518; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy518; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy518; + goto yy493; + } + } +yy516: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy518; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy518; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy518; + goto yy493; + } + } +yy517: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy519; + if (yych <= '/') goto yy493; + goto yy520; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy520; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy520; + goto yy493; + } + } +yy518: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy520; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy520; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy520; + goto yy493; + } + } +yy519: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy521; + if (yych <= '/') goto yy493; + goto yy522; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy522; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy522; + goto yy493; + } + } +yy520: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy522; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy522; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy522; + goto yy493; + } + } +yy521: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy523; + if (yych <= '/') goto yy493; + goto yy524; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy524; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy524; + goto yy493; + } + } +yy522: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy524; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy524; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy524; + goto yy493; + } + } +yy523: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy525; + if (yych <= '/') goto yy493; + goto yy526; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy526; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy526; + goto yy493; + } + } +yy524: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy526; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy526; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy526; + goto yy493; + } + } +yy525: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy527; + if (yych <= '/') goto yy493; + goto yy528; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy528; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy528; + goto yy493; + } + } +yy526: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy528; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy528; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy528; + goto yy493; + } + } +yy527: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy529; + if (yych <= '/') goto yy493; + goto yy530; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy530; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy530; + goto yy493; + } + } +yy528: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy530; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy530; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy530; + goto yy493; + } + } +yy529: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy531; + if (yych <= '/') goto yy493; + goto yy532; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy532; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy532; + goto yy493; + } + } +yy530: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy532; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy532; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy532; + goto yy493; + } + } +yy531: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy533; + if (yych <= '/') goto yy493; + goto yy534; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy534; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy534; + goto yy493; + } + } +yy532: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy534; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy534; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy534; + goto yy493; + } + } +yy533: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy535; + if (yych <= '/') goto yy493; + goto yy536; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy536; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy536; + goto yy493; + } + } +yy534: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy536; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy536; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy536; + goto yy493; + } + } +yy535: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy537; + if (yych <= '/') goto yy493; + goto yy538; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy538; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy538; + goto yy493; + } + } +yy536: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy538; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy538; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy538; + goto yy493; + } + } +yy537: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy539; + if (yych <= '/') goto yy493; + goto yy540; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy540; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy540; + goto yy493; + } + } +yy538: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy540; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy540; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy540; + goto yy493; + } + } +yy539: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy541; + if (yych <= '/') goto yy493; + goto yy542; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy542; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy542; + goto yy493; + } + } +yy540: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy542; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy542; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy542; + goto yy493; + } + } +yy541: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy543; + if (yych <= '/') goto yy493; + goto yy544; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy544; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy544; + goto yy493; + } + } +yy542: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy544; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy544; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy544; + goto yy493; + } + } +yy543: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy545; + if (yych <= '/') goto yy493; + goto yy546; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy546; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy546; + goto yy493; + } + } +yy544: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy546; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy546; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy546; + goto yy493; + } + } +yy545: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy547; + if (yych <= '/') goto yy493; + goto yy548; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy548; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy548; + goto yy493; + } + } +yy546: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy548; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy548; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy548; + goto yy493; + } + } +yy547: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy549; + if (yych <= '/') goto yy493; + goto yy550; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy550; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy550; + goto yy493; + } + } +yy548: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy550; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy550; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy550; + goto yy493; + } + } +yy549: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy551; + if (yych <= '/') goto yy493; + goto yy552; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy552; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy552; + goto yy493; + } + } +yy550: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy552; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy552; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy552; + goto yy493; + } + } +yy551: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy553; + if (yych <= '/') goto yy493; + goto yy554; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy554; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy554; + goto yy493; + } + } +yy552: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy554; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy554; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy554; + goto yy493; + } + } +yy553: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy555; + if (yych <= '/') goto yy493; + goto yy556; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy556; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy556; + goto yy493; + } + } +yy554: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy556; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy556; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy556; + goto yy493; + } + } +yy555: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy557; + if (yych <= '/') goto yy493; + goto yy558; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy558; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy558; + goto yy493; + } + } +yy556: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy558; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy558; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy558; + goto yy493; + } + } +yy557: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy559; + if (yych <= '/') goto yy493; + goto yy560; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy560; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy560; + goto yy493; + } + } +yy558: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy560; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy560; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy560; + goto yy493; + } + } +yy559: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy561; + if (yych <= '/') goto yy493; + goto yy562; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy562; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy562; + goto yy493; + } + } +yy560: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy562; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy562; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy562; + goto yy493; + } + } +yy561: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy563; + if (yych <= '/') goto yy493; + goto yy564; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy564; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy564; + goto yy493; + } + } +yy562: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy564; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy564; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy564; + goto yy493; + } + } +yy563: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy565; + if (yych <= '/') goto yy493; + goto yy566; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy566; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy566; + goto yy493; + } + } +yy564: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy566; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy566; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy566; + goto yy493; + } + } +yy565: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy567; + if (yych <= '/') goto yy493; + goto yy568; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy568; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy568; + goto yy493; + } + } +yy566: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy568; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy568; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy568; + goto yy493; + } + } +yy567: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy569; + if (yych <= '/') goto yy493; + goto yy570; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy570; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy570; + goto yy493; + } + } +yy568: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy570; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy570; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy570; + goto yy493; + } + } +yy569: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy571; + if (yych <= '/') goto yy493; + goto yy572; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy572; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy572; + goto yy493; + } + } +yy570: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy572; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy572; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy572; + goto yy493; + } + } +yy571: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy573; + if (yych <= '/') goto yy493; + goto yy574; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy574; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy574; + goto yy493; + } + } +yy572: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy574; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy574; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy574; + goto yy493; + } + } +yy573: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy575; + if (yych <= '/') goto yy493; + goto yy576; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy576; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy576; + goto yy493; + } + } +yy574: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy576; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy576; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy576; + goto yy493; + } + } +yy575: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy577; + if (yych <= '/') goto yy493; + goto yy578; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy578; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy578; + goto yy493; + } + } +yy576: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy578; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy578; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy578; + goto yy493; + } + } +yy577: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy579; + if (yych <= '/') goto yy493; + goto yy580; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy580; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy580; + goto yy493; + } + } +yy578: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy580; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy580; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy580; + goto yy493; + } + } +yy579: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy581; + if (yych <= '/') goto yy493; + goto yy582; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy582; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy582; + goto yy493; + } + } +yy580: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy582; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy582; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy582; + goto yy493; + } + } +yy581: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy583; + if (yych <= '/') goto yy493; + goto yy584; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy584; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy584; + goto yy493; + } + } +yy582: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy584; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy584; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy584; + goto yy493; + } + } +yy583: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy585; + if (yych <= '/') goto yy493; + goto yy586; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy586; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy586; + goto yy493; + } + } +yy584: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy586; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy586; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy586; + goto yy493; + } + } +yy585: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy587; + if (yych <= '/') goto yy493; + goto yy588; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy588; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy588; + goto yy493; + } + } +yy586: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy588; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy588; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy588; + goto yy493; + } + } +yy587: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy589; + if (yych <= '/') goto yy493; + goto yy590; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy590; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy590; + goto yy493; + } + } +yy588: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy590; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy590; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy590; + goto yy493; + } + } +yy589: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy591; + if (yych <= '/') goto yy493; + goto yy592; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy592; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy592; + goto yy493; + } + } +yy590: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy592; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy592; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy592; + goto yy493; + } + } +yy591: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy593; + if (yych <= '/') goto yy493; + goto yy594; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy594; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy594; + goto yy493; + } + } +yy592: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy594; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy594; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy594; + goto yy493; + } + } +yy593: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy595; + if (yych <= '/') goto yy493; + goto yy596; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy596; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy596; + goto yy493; + } + } +yy594: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy596; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy596; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy596; + goto yy493; + } + } +yy595: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy597; + if (yych <= '/') goto yy493; + goto yy598; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy598; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy598; + goto yy493; + } + } +yy596: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy598; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy598; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy598; + goto yy493; + } + } +yy597: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy599; + if (yych <= '/') goto yy493; + goto yy600; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy600; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy600; + goto yy493; + } + } +yy598: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy600; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy600; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy600; + goto yy493; + } + } +yy599: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy601; + if (yych <= '/') goto yy493; + goto yy602; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy602; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy602; + goto yy493; + } + } +yy600: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy602; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy602; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy602; + goto yy493; + } + } +yy601: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy603; + if (yych <= '/') goto yy493; + goto yy604; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy604; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy604; + goto yy493; + } + } +yy602: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy604; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy604; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy604; + goto yy493; + } + } +yy603: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy605; + if (yych <= '/') goto yy493; + goto yy606; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy606; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy606; + goto yy493; + } + } +yy604: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy606; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy606; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy606; + goto yy493; + } + } +yy605: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy607; + if (yych <= '/') goto yy493; + goto yy608; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy608; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy608; + goto yy493; + } + } +yy606: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy608; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy608; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy608; + goto yy493; + } + } +yy607: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy609; + if (yych <= '/') goto yy493; + goto yy610; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy610; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy610; + goto yy493; + } + } +yy608: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy610; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy610; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy610; + goto yy493; + } + } +yy609: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy611; + if (yych <= '/') goto yy493; + goto yy612; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy612; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy612; + goto yy493; + } + } +yy610: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy612; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy612; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy612; + goto yy493; + } + } +yy611: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy613; + if (yych <= '/') goto yy493; + goto yy614; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy614; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy614; + goto yy493; + } + } +yy612: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy614; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy614; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy614; + goto yy493; + } + } +yy613: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy615; + if (yych <= '/') goto yy493; + goto yy616; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy616; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy616; + goto yy493; + } + } +yy614: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy616; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy616; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy616; + goto yy493; + } + } +yy615: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy617; + if (yych <= '/') goto yy493; + goto yy618; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy618; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy618; + goto yy493; + } + } +yy616: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy618; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy618; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy618; + goto yy493; + } + } +yy617: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy619; + if (yych <= '/') goto yy493; + goto yy620; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy620; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy620; + goto yy493; + } + } +yy618: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy620; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy620; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy620; + goto yy493; + } + } +yy619: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy621; + if (yych <= '/') goto yy493; + goto yy622; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy622; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy622; + goto yy493; + } + } +yy620: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy622; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy622; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy622; + goto yy493; + } + } +yy621: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy623; + if (yych <= '/') goto yy493; + goto yy624; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy624; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy624; + goto yy493; + } + } +yy622: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy624; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy624; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy624; + goto yy493; + } + } +yy623: + ++p; + yych = *p; + if (yych <= '@') { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy625; + goto yy493; + } else { + if (yych <= 'Z') goto yy625; + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy625; + goto yy493; + } +yy624: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= '-') goto yy493; + goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych >= ':') goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + } else { + if (yych <= '`') goto yy493; + if (yych >= '{') goto yy493; + } + } +yy625: + ++p; + yych = *p; + if (yych == '.') goto yy499; + if (yych == '>') goto yy500; + goto yy493; +yy626: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy628; + if (yych <= '/') goto yy493; + goto yy629; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy629; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy629; + goto yy493; + } + } +yy627: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy629; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy629; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy629; + goto yy493; + } + } +yy628: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy630; + if (yych <= '/') goto yy493; + goto yy631; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy631; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy631; + goto yy493; + } + } +yy629: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy631; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy631; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy631; + goto yy493; + } + } +yy630: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy632; + if (yych <= '/') goto yy493; + goto yy633; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy633; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy633; + goto yy493; + } + } +yy631: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy633; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy633; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy633; + goto yy493; + } + } +yy632: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy634; + if (yych <= '/') goto yy493; + goto yy635; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy635; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy635; + goto yy493; + } + } +yy633: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy635; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy635; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy635; + goto yy493; + } + } +yy634: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy636; + if (yych <= '/') goto yy493; + goto yy637; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy637; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy637; + goto yy493; + } + } +yy635: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy637; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy637; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy637; + goto yy493; + } + } +yy636: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy638; + if (yych <= '/') goto yy493; + goto yy639; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy639; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy639; + goto yy493; + } + } +yy637: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy639; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy639; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy639; + goto yy493; + } + } +yy638: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy640; + if (yych <= '/') goto yy493; + goto yy641; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy641; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy641; + goto yy493; + } + } +yy639: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy641; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy641; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy641; + goto yy493; + } + } +yy640: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy642; + if (yych <= '/') goto yy493; + goto yy643; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy643; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy643; + goto yy493; + } + } +yy641: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy643; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy643; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy643; + goto yy493; + } + } +yy642: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy644; + if (yych <= '/') goto yy493; + goto yy645; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy645; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy645; + goto yy493; + } + } +yy643: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy645; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy645; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy645; + goto yy493; + } + } +yy644: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy646; + if (yych <= '/') goto yy493; + goto yy647; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy647; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy647; + goto yy493; + } + } +yy645: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy647; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy647; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy647; + goto yy493; + } + } +yy646: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy648; + if (yych <= '/') goto yy493; + goto yy649; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy649; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy649; + goto yy493; + } + } +yy647: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy649; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy649; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy649; + goto yy493; + } + } +yy648: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy650; + if (yych <= '/') goto yy493; + goto yy651; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy651; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy651; + goto yy493; + } + } +yy649: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy651; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy651; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy651; + goto yy493; + } + } +yy650: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy652; + if (yych <= '/') goto yy493; + goto yy653; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy653; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy653; + goto yy493; + } + } +yy651: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy653; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy653; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy653; + goto yy493; + } + } +yy652: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy654; + if (yych <= '/') goto yy493; + goto yy655; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy655; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy655; + goto yy493; + } + } +yy653: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy655; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy655; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy655; + goto yy493; + } + } +yy654: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy656; + if (yych <= '/') goto yy493; + goto yy657; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy657; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy657; + goto yy493; + } + } +yy655: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy657; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy657; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy657; + goto yy493; + } + } +yy656: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy658; + if (yych <= '/') goto yy493; + goto yy659; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy659; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy659; + goto yy493; + } + } +yy657: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy659; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy659; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy659; + goto yy493; + } + } +yy658: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy660; + if (yych <= '/') goto yy493; + goto yy661; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy661; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy661; + goto yy493; + } + } +yy659: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy661; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy661; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy661; + goto yy493; + } + } +yy660: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy662; + if (yych <= '/') goto yy493; + goto yy663; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy663; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy663; + goto yy493; + } + } +yy661: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy663; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy663; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy663; + goto yy493; + } + } +yy662: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy664; + if (yych <= '/') goto yy493; + goto yy665; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy665; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy665; + goto yy493; + } + } +yy663: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy665; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy665; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy665; + goto yy493; + } + } +yy664: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy666; + if (yych <= '/') goto yy493; + goto yy667; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy667; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy667; + goto yy493; + } + } +yy665: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy667; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy667; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy667; + goto yy493; + } + } +yy666: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy668; + if (yych <= '/') goto yy493; + goto yy669; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy669; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy669; + goto yy493; + } + } +yy667: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy669; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy669; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy669; + goto yy493; + } + } +yy668: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy670; + if (yych <= '/') goto yy493; + goto yy671; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy671; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy671; + goto yy493; + } + } +yy669: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy671; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy671; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy671; + goto yy493; + } + } +yy670: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy672; + if (yych <= '/') goto yy493; + goto yy673; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy673; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy673; + goto yy493; + } + } +yy671: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy673; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy673; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy673; + goto yy493; + } + } +yy672: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy674; + if (yych <= '/') goto yy493; + goto yy675; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy675; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy675; + goto yy493; + } + } +yy673: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy675; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy675; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy675; + goto yy493; + } + } +yy674: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy676; + if (yych <= '/') goto yy493; + goto yy677; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy677; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy677; + goto yy493; + } + } +yy675: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy677; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy677; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy677; + goto yy493; + } + } +yy676: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy678; + if (yych <= '/') goto yy493; + goto yy679; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy679; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy679; + goto yy493; + } + } +yy677: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy679; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy679; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy679; + goto yy493; + } + } +yy678: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy680; + if (yych <= '/') goto yy493; + goto yy681; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy681; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy681; + goto yy493; + } + } +yy679: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy681; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy681; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy681; + goto yy493; + } + } +yy680: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy682; + if (yych <= '/') goto yy493; + goto yy683; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy683; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy683; + goto yy493; + } + } +yy681: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy683; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy683; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy683; + goto yy493; + } + } +yy682: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy684; + if (yych <= '/') goto yy493; + goto yy685; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy685; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy685; + goto yy493; + } + } +yy683: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy685; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy685; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy685; + goto yy493; + } + } +yy684: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy686; + if (yych <= '/') goto yy493; + goto yy687; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy687; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy687; + goto yy493; + } + } +yy685: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy687; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy687; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy687; + goto yy493; + } + } +yy686: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy688; + if (yych <= '/') goto yy493; + goto yy689; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy689; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy689; + goto yy493; + } + } +yy687: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy689; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy689; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy689; + goto yy493; + } + } +yy688: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy690; + if (yych <= '/') goto yy493; + goto yy691; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy691; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy691; + goto yy493; + } + } +yy689: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy691; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy691; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy691; + goto yy493; + } + } +yy690: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy692; + if (yych <= '/') goto yy493; + goto yy693; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy693; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy693; + goto yy493; + } + } +yy691: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy693; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy693; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy693; + goto yy493; + } + } +yy692: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy694; + if (yych <= '/') goto yy493; + goto yy695; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy695; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy695; + goto yy493; + } + } +yy693: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy695; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy695; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy695; + goto yy493; + } + } +yy694: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy696; + if (yych <= '/') goto yy493; + goto yy697; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy697; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy697; + goto yy493; + } + } +yy695: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy697; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy697; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy697; + goto yy493; + } + } +yy696: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy698; + if (yych <= '/') goto yy493; + goto yy699; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy699; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy699; + goto yy493; + } + } +yy697: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy699; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy699; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy699; + goto yy493; + } + } +yy698: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy700; + if (yych <= '/') goto yy493; + goto yy701; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy701; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy701; + goto yy493; + } + } +yy699: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy701; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy701; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy701; + goto yy493; + } + } +yy700: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy702; + if (yych <= '/') goto yy493; + goto yy703; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy703; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy703; + goto yy493; + } + } +yy701: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy703; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy703; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy703; + goto yy493; + } + } +yy702: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy704; + if (yych <= '/') goto yy493; + goto yy705; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy705; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy705; + goto yy493; + } + } +yy703: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy705; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy705; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy705; + goto yy493; + } + } +yy704: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy706; + if (yych <= '/') goto yy493; + goto yy707; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy707; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy707; + goto yy493; + } + } +yy705: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy707; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy707; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy707; + goto yy493; + } + } +yy706: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy708; + if (yych <= '/') goto yy493; + goto yy709; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy709; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy709; + goto yy493; + } + } +yy707: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy709; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy709; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy709; + goto yy493; + } + } +yy708: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy710; + if (yych <= '/') goto yy493; + goto yy711; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy711; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy711; + goto yy493; + } + } +yy709: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy711; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy711; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy711; + goto yy493; + } + } +yy710: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy712; + if (yych <= '/') goto yy493; + goto yy713; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy713; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy713; + goto yy493; + } + } +yy711: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy713; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy713; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy713; + goto yy493; + } + } +yy712: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy714; + if (yych <= '/') goto yy493; + goto yy715; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy715; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy715; + goto yy493; + } + } +yy713: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy715; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy715; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy715; + goto yy493; + } + } +yy714: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy716; + if (yych <= '/') goto yy493; + goto yy717; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy717; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy717; + goto yy493; + } + } +yy715: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy717; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy717; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy717; + goto yy493; + } + } +yy716: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy718; + if (yych <= '/') goto yy493; + goto yy719; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy719; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy719; + goto yy493; + } + } +yy717: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy719; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy719; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy719; + goto yy493; + } + } +yy718: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy720; + if (yych <= '/') goto yy493; + goto yy721; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy721; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy721; + goto yy493; + } + } +yy719: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy721; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy721; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy721; + goto yy493; + } + } +yy720: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy722; + if (yych <= '/') goto yy493; + goto yy723; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy723; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy723; + goto yy493; + } + } +yy721: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy723; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy723; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy723; + goto yy493; + } + } +yy722: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy724; + if (yych <= '/') goto yy493; + goto yy725; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy725; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy725; + goto yy493; + } + } +yy723: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy725; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy725; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy725; + goto yy493; + } + } +yy724: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy726; + if (yych <= '/') goto yy493; + goto yy727; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy727; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy727; + goto yy493; + } + } +yy725: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy727; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy727; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy727; + goto yy493; + } + } +yy726: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy728; + if (yych <= '/') goto yy493; + goto yy729; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy729; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy729; + goto yy493; + } + } +yy727: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy729; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy729; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy729; + goto yy493; + } + } +yy728: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy730; + if (yych <= '/') goto yy493; + goto yy731; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy731; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy731; + goto yy493; + } + } +yy729: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy731; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy731; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy731; + goto yy493; + } + } +yy730: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy732; + if (yych <= '/') goto yy493; + goto yy733; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy733; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy733; + goto yy493; + } + } +yy731: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy733; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy733; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy733; + goto yy493; + } + } +yy732: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy734; + if (yych <= '/') goto yy493; + goto yy735; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy735; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy735; + goto yy493; + } + } +yy733: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy735; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy735; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy735; + goto yy493; + } + } +yy734: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy736; + if (yych <= '/') goto yy493; + goto yy737; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy737; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy737; + goto yy493; + } + } +yy735: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy737; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy737; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy737; + goto yy493; + } + } +yy736: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy738; + if (yych <= '/') goto yy493; + goto yy739; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy739; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy739; + goto yy493; + } + } +yy737: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy739; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy739; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy739; + goto yy493; + } + } +yy738: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy740; + if (yych <= '/') goto yy493; + goto yy741; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy741; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy741; + goto yy493; + } + } +yy739: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy741; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy741; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy741; + goto yy493; + } + } +yy740: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy742; + if (yych <= '/') goto yy493; + goto yy743; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy743; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy743; + goto yy493; + } + } +yy741: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy743; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy743; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy743; + goto yy493; + } + } +yy742: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy744; + if (yych <= '/') goto yy493; + goto yy745; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy745; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy745; + goto yy493; + } + } +yy743: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy745; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy745; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy745; + goto yy493; + } + } +yy744: + yych = *++p; + if (yych <= '@') { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy625; + goto yy493; + } else { + if (yych <= 'Z') goto yy625; + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy625; + goto yy493; + } +yy745: + ++p; + if ((yych = *p) <= '=') { + if (yych <= '.') { + if (yych <= '-') goto yy493; + goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy625; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy625; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy625; + goto yy493; + } + } +} + +} + +// Try to match an HTML tag after first <, returning num of chars matched. +int _scan_html_tag(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; + +{ + unsigned char yych; + static const unsigned char yybm[] = { + /* table 1 .. 8: 0 */ + 0, 230, 230, 230, 230, 230, 230, 230, + 230, 199, 199, 199, 199, 199, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 199, 230, 70, 230, 230, 230, 230, 134, + 230, 230, 230, 230, 230, 246, 246, 230, + 254, 254, 254, 254, 254, 254, 254, 254, + 254, 254, 246, 230, 198, 198, 196, 230, + 230, 254, 254, 254, 254, 254, 254, 254, + 254, 254, 254, 254, 254, 254, 254, 254, + 254, 254, 254, 254, 254, 254, 254, 254, + 254, 254, 254, 230, 230, 226, 230, 246, + 198, 254, 254, 254, 254, 254, 254, 254, + 254, 254, 254, 254, 254, 254, 254, 254, + 254, 254, 254, 254, 254, 254, 254, 254, + 254, 254, 254, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + /* table 9 .. 11: 256 */ + 0, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 32, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 128, + 160, 224, 224, 224, 224, 224, 224, 224, + 224, 224, 224, 224, 224, 224, 224, 224, + 224, 224, 224, 224, 224, 224, 224, 224, + 224, 224, 224, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + }; + yych = *p; + if (yych <= '/') { + if (yych <= ' ') { + if (yych != '\n') goto yy753; + } else { + if (yych <= '!') goto yy751; + if (yych <= '.') goto yy753; + goto yy750; + } + } else { + if (yych <= '@') { + if (yych == '?') goto yy752; + goto yy753; + } else { + if (yych <= 'Z') goto yy749; + if (yych <= '`') goto yy753; + if (yych <= 'z') goto yy749; + goto yy753; + } + } +yy748: + { return 0; } +yy749: + yych = *(marker = ++p); + if (yych <= '9') { + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy748; + if (yych <= '\r') goto yy790; + goto yy748; + } else { + if (yych <= ' ') goto yy790; + if (yych <= '.') goto yy748; + if (yych <= '/') goto yy792; + goto yy788; + } + } else { + if (yych <= '@') { + if (yych == '>') goto yy758; + goto yy748; + } else { + if (yych <= 'Z') goto yy788; + if (yych <= '`') goto yy748; + if (yych <= 'z') goto yy788; + goto yy748; + } + } +yy750: + yych = *(marker = ++p); + if (yych <= '@') goto yy748; + if (yych <= 'Z') goto yy784; + if (yych <= '`') goto yy748; + if (yych <= 'z') goto yy784; + goto yy748; +yy751: + yych = *(marker = ++p); + if (yybm[256+yych] & 64) { + goto yy761; + } + if (yych == '-') goto yy763; + if (yych == '[') goto yy760; + goto yy748; +yy752: + yych = *(marker = ++p); + if (yych <= 0x00) goto yy748; + goto yy755; +yy753: + yych = *++p; + goto yy748; +yy754: + ++p; + yych = *p; +yy755: + if (yybm[256+yych] & 32) { + goto yy754; + } + if (yych >= 0x01) goto yy757; +yy756: + p = marker; + goto yy748; +yy757: + ++p; + yych = *p; + if (yych <= 0x00) goto yy756; + if (yych != '>') goto yy754; +yy758: + ++p; + { return (p - start); } +yy760: + yych = *++p; + if (yych == 'C') goto yy775; + if (yych == 'c') goto yy775; + goto yy756; +yy761: + ++p; + yych = *p; + if (yybm[0+yych] & 1) { + goto yy771; + } + if (yych <= '@') goto yy756; + if (yych <= 'Z') goto yy761; + goto yy756; +yy763: + yych = *++p; + if (yych != '-') goto yy756; + yych = *++p; + if (yych == '-') goto yy765; + if (yych == '>') goto yy756; + goto yy767; +yy765: + yych = *++p; + if (yych == '-') goto yy770; + if (yych == '>') goto yy756; + goto yy767; +yy766: + ++p; + yych = *p; +yy767: + if (yybm[256+yych] & 128) { + goto yy766; + } + if (yych <= 0x00) goto yy756; + ++p; + yych = *p; + if (yybm[256+yych] & 128) { + goto yy766; + } + if (yych <= 0x00) goto yy756; + yych = *++p; + if (yych == '>') goto yy758; + goto yy756; +yy770: + yych = *++p; + if (yych == '>') goto yy758; + goto yy756; +yy771: + ++p; + yych = *p; + if (yybm[0+yych] & 1) { + goto yy771; + } + if (yych <= 0x00) goto yy756; + if (yych == '>') goto yy758; +yy773: + ++p; + yych = *p; + if (yybm[0+yych] & 2) { + goto yy773; + } + if (yych <= 0x00) goto yy756; + goto yy758; +yy775: + yych = *++p; + if (yych == 'D') goto yy776; + if (yych != 'd') goto yy756; +yy776: + yych = *++p; + if (yych == 'A') goto yy777; + if (yych != 'a') goto yy756; +yy777: + yych = *++p; + if (yych == 'T') goto yy778; + if (yych != 't') goto yy756; +yy778: + yych = *++p; + if (yych == 'A') goto yy779; + if (yych != 'a') goto yy756; +yy779: + yych = *++p; + if (yych != '[') goto yy756; +yy780: + ++p; + yych = *p; + if (yybm[0+yych] & 4) { + goto yy780; + } + if (yych <= 0x00) goto yy756; + ++p; + yych = *p; + if (yybm[0+yych] & 4) { + goto yy780; + } + if (yych <= 0x00) goto yy756; + ++p; + yych = *p; + if (yych <= 0x00) goto yy756; + if (yych == '>') goto yy758; + goto yy780; +yy784: + ++p; + yych = *p; + if (yybm[0+yych] & 8) { + goto yy784; + } + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy756; + if (yych >= 0x0E) goto yy756; + } else { + if (yych <= ' ') goto yy786; + if (yych == '>') goto yy758; + goto yy756; + } +yy786: + ++p; + yych = *p; + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy756; + if (yych <= '\r') goto yy786; + goto yy756; + } else { + if (yych <= ' ') goto yy786; + if (yych == '>') goto yy758; + goto yy756; + } +yy788: + ++p; + yych = *p; + if (yych <= '9') { + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy756; + if (yych >= 0x0E) goto yy756; + } else { + if (yych <= ' ') goto yy790; + if (yych <= '.') goto yy756; + if (yych <= '/') goto yy792; + goto yy788; + } + } else { + if (yych <= '@') { + if (yych == '>') goto yy758; + goto yy756; + } else { + if (yych <= 'Z') goto yy788; + if (yych <= '`') goto yy756; + if (yych <= 'z') goto yy788; + goto yy756; + } + } +yy790: + ++p; + yych = *p; + if (yych <= ':') { + if (yych <= ' ') { + if (yych <= 0x08) goto yy756; + if (yych <= '\r') goto yy790; + if (yych <= 0x1F) goto yy756; + goto yy790; + } else { + if (yych == '/') goto yy792; + if (yych <= '9') goto yy756; + goto yy793; + } + } else { + if (yych <= 'Z') { + if (yych == '>') goto yy758; + if (yych <= '@') goto yy756; + goto yy793; + } else { + if (yych <= '_') { + if (yych <= '^') goto yy756; + goto yy793; + } else { + if (yych <= '`') goto yy756; + if (yych <= 'z') goto yy793; + goto yy756; + } + } + } +yy792: + yych = *++p; + if (yych == '>') goto yy758; + goto yy756; +yy793: + ++p; + yych = *p; + if (yybm[0+yych] & 16) { + goto yy793; + } + if (yych <= '.') { + if (yych <= '\r') { + if (yych <= 0x08) goto yy756; + } else { + if (yych != ' ') goto yy756; + } + } else { + if (yych <= '<') { + if (yych <= '/') goto yy792; + goto yy756; + } else { + if (yych <= '=') goto yy797; + if (yych <= '>') goto yy758; + goto yy756; + } + } +yy795: + ++p; + yych = *p; + if (yych <= '<') { + if (yych <= ' ') { + if (yych <= 0x08) goto yy756; + if (yych <= '\r') goto yy795; + if (yych <= 0x1F) goto yy756; + goto yy795; + } else { + if (yych <= '/') { + if (yych <= '.') goto yy756; + goto yy792; + } else { + if (yych == ':') goto yy793; + goto yy756; + } + } + } else { + if (yych <= 'Z') { + if (yych <= '=') goto yy797; + if (yych <= '>') goto yy758; + if (yych <= '@') goto yy756; + goto yy793; + } else { + if (yych <= '_') { + if (yych <= '^') goto yy756; + goto yy793; + } else { + if (yych <= '`') goto yy756; + if (yych <= 'z') goto yy793; + goto yy756; + } + } + } +yy797: + ++p; + yych = *p; + if (yybm[0+yych] & 32) { + goto yy799; + } + if (yych <= 0x00) goto yy756; + if (yych <= '!') goto yy798; + if (yych <= '"') goto yy803; + if (yych <= ';') goto yy801; + goto yy756; +yy798: + ++p; + yych = *p; + if (yybm[0+yych] & 32) { + goto yy799; + } + if (yych <= '"') { + if (yych <= 0x00) goto yy756; + if (yych <= '!') goto yy812; + goto yy803; + } else { + if (yych <= ';') goto yy801; + if (yych == '>') goto yy758; + goto yy756; + } +yy799: + ++p; + yych = *p; + if (yybm[0+yych] & 32) { + goto yy799; + } + if (yych <= 0x00) goto yy756; + if (yych <= '!') goto yy806; + if (yych == '>') goto yy758; + goto yy756; +yy801: + ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy801; + } + if (yych <= 0x00) goto yy756; + goto yy805; +yy803: + ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy803; + } + if (yych <= 0x00) goto yy756; +yy805: + ++p; + yych = *p; + if (yych <= ' ') { + if (yych <= 0x08) goto yy756; + if (yych <= '\r') goto yy790; + if (yych <= 0x1F) goto yy756; + goto yy790; + } else { + if (yych <= '/') { + if (yych <= '.') goto yy756; + goto yy792; + } else { + if (yych == '>') goto yy758; + goto yy756; + } + } +yy806: + ++p; + yych = *p; + if (yych <= '9') { + if (yych <= ' ') { + if (yych <= 0x08) { + if (yych <= 0x00) goto yy756; + goto yy799; + } else { + if (yych <= '\r') goto yy806; + if (yych <= 0x1F) goto yy799; + goto yy806; + } + } else { + if (yych <= '"') { + if (yych <= '!') goto yy799; + goto yy756; + } else { + if (yych == '\'') goto yy756; + goto yy799; + } + } + } else { + if (yych <= '@') { + if (yych <= ';') { + if (yych >= ';') goto yy799; + } else { + if (yych <= '=') goto yy756; + if (yych <= '>') goto yy758; + goto yy799; + } + } else { + if (yych <= '_') { + if (yych <= 'Z') goto yy808; + if (yych <= '^') goto yy799; + } else { + if (yych <= '`') goto yy756; + if (yych >= '{') goto yy799; + } + } + } +yy808: + ++p; + yych = *p; + if (yych <= '/') { + if (yych <= '!') { + if (yych <= '\r') { + if (yych <= 0x00) goto yy756; + if (yych <= 0x08) goto yy799; + } else { + if (yych != ' ') goto yy799; + } + } else { + if (yych <= '\'') { + if (yych <= '"') goto yy756; + if (yych <= '&') goto yy799; + goto yy756; + } else { + if (yych <= ',') goto yy799; + if (yych <= '.') goto yy808; + goto yy799; + } + } + } else { + if (yych <= '@') { + if (yych <= '<') { + if (yych <= ':') goto yy808; + if (yych <= ';') goto yy799; + goto yy756; + } else { + if (yych <= '=') goto yy797; + if (yych <= '>') goto yy758; + goto yy799; + } + } else { + if (yych <= '_') { + if (yych <= 'Z') goto yy808; + if (yych <= '^') goto yy799; + goto yy808; + } else { + if (yych <= '`') goto yy756; + if (yych <= 'z') goto yy808; + goto yy799; + } + } + } +yy810: + ++p; + yych = *p; + if (yych <= ':') { + if (yych <= ' ') { + if (yych <= 0x08) { + if (yych <= 0x00) goto yy756; + goto yy799; + } else { + if (yych <= '\r') goto yy810; + if (yych <= 0x1F) goto yy799; + goto yy810; + } + } else { + if (yych <= '&') { + if (yych == '"') goto yy756; + goto yy799; + } else { + if (yych <= '\'') goto yy756; + if (yych <= '9') goto yy799; + goto yy808; + } + } + } else { + if (yych <= '@') { + if (yych <= '<') { + if (yych <= ';') goto yy799; + goto yy756; + } else { + if (yych <= '=') goto yy797; + if (yych <= '>') goto yy758; + goto yy799; + } + } else { + if (yych <= '_') { + if (yych <= 'Z') goto yy808; + if (yych <= '^') goto yy799; + goto yy808; + } else { + if (yych <= '`') goto yy756; + if (yych <= 'z') goto yy808; + goto yy799; + } + } + } +yy812: + ++p; + yych = *p; + if (yych <= '9') { + if (yych <= ' ') { + if (yych <= 0x08) { + if (yych <= 0x00) goto yy756; + goto yy799; + } else { + if (yych <= '\r') goto yy812; + if (yych <= 0x1F) goto yy799; + goto yy812; + } + } else { + if (yych <= '"') { + if (yych <= '!') goto yy799; + goto yy803; + } else { + if (yych == '\'') goto yy801; + goto yy799; + } + } + } else { + if (yych <= '@') { + if (yych <= ';') { + if (yych <= ':') goto yy808; + goto yy799; + } else { + if (yych <= '=') goto yy756; + if (yych <= '>') goto yy758; + goto yy799; + } + } else { + if (yych <= '_') { + if (yych <= 'Z') goto yy808; + if (yych <= '^') goto yy799; + goto yy808; + } else { + if (yych <= '`') goto yy756; + if (yych <= 'z') goto yy808; + goto yy799; + } + } + } +} + +} + +// Try to match an HTML block tag including first <, +// returning num of chars matched. +int _scan_html_block_tag(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; + +{ + unsigned char yych; + yych = *p; + if (yych == '\n') goto yy816; + if (yych == '<') goto yy817; + goto yy818; +yy816: + { return 0; } +yy817: + yych = *(marker = ++p); + switch (yych) { + case '!': + case '?': goto yy819; + case '/': goto yy838; + case 'A': + case 'a': goto yy823; + case 'B': + case 'b': goto yy826; + case 'C': + case 'c': goto yy830; + case 'D': + case 'd': goto yy831; + case 'E': + case 'e': goto yy834; + case 'F': + case 'f': goto yy835; + case 'H': + case 'h': goto yy824; + case 'I': + case 'i': goto yy825; + case 'L': + case 'l': goto yy827; + case 'M': + case 'm': goto yy828; + case 'O': + case 'o': goto yy829; + case 'P': + case 'p': goto yy821; + case 'S': + case 's': goto yy832; + case 'T': + case 't': goto yy833; + case 'U': + case 'u': goto yy836; + case 'V': + case 'v': goto yy837; + default: goto yy816; + } +yy818: + yych = *++p; + goto yy816; +yy819: + ++p; + { return (p - start); } +yy821: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy822; + if (yych <= '\r') goto yy982; + } else { + if (yych <= ' ') goto yy982; + if (yych >= '/') goto yy982; + } + } else { + if (yych <= 'Q') { + if (yych == '>') goto yy982; + } else { + if (yych <= 'R') goto yy1095; + if (yych == 'r') goto yy1095; + } + } +yy822: + p = marker; + goto yy816; +yy823: + yych = *++p; + if (yych <= 'S') { + if (yych <= 'Q') goto yy822; + if (yych <= 'R') goto yy1088; + goto yy1087; + } else { + if (yych <= 'q') goto yy822; + if (yych <= 'r') goto yy1088; + if (yych <= 's') goto yy1087; + goto yy822; + } +yy824: + yych = *++p; + if (yych <= 'Q') { + if (yych <= 'D') { + if (yych <= '0') goto yy822; + if (yych <= '6') goto yy981; + goto yy822; + } else { + if (yych <= 'E') goto yy1080; + if (yych == 'G') goto yy1079; + goto yy822; + } + } else { + if (yych <= 'f') { + if (yych <= 'R') goto yy981; + if (yych == 'e') goto yy1080; + goto yy822; + } else { + if (yych <= 'g') goto yy1079; + if (yych == 'r') goto yy981; + goto yy822; + } + } +yy825: + yych = *++p; + if (yych == 'F') goto yy1075; + if (yych == 'f') goto yy1075; + goto yy822; +yy826: + yych = *++p; + if (yych <= 'U') { + if (yych <= 'N') { + if (yych == 'L') goto yy1063; + goto yy822; + } else { + if (yych <= 'O') goto yy1062; + if (yych <= 'T') goto yy822; + goto yy1061; + } + } else { + if (yych <= 'n') { + if (yych == 'l') goto yy1063; + goto yy822; + } else { + if (yych <= 'o') goto yy1062; + if (yych == 'u') goto yy1061; + goto yy822; + } + } +yy827: + yych = *++p; + if (yych == 'I') goto yy981; + if (yych == 'i') goto yy981; + goto yy822; +yy828: + yych = *++p; + if (yych == 'A') goto yy1060; + if (yych == 'a') goto yy1060; + goto yy822; +yy829: + yych = *++p; + if (yych <= 'U') { + if (yych <= 'K') { + if (yych == 'B') goto yy1053; + goto yy822; + } else { + if (yych <= 'L') goto yy981; + if (yych <= 'T') goto yy822; + goto yy1052; + } + } else { + if (yych <= 'k') { + if (yych == 'b') goto yy1053; + goto yy822; + } else { + if (yych <= 'l') goto yy981; + if (yych == 'u') goto yy1052; + goto yy822; + } + } +yy830: + yych = *++p; + if (yych <= 'O') { + if (yych == 'A') goto yy1039; + if (yych <= 'N') goto yy822; + goto yy1038; + } else { + if (yych <= 'a') { + if (yych <= '`') goto yy822; + goto yy1039; + } else { + if (yych == 'o') goto yy1038; + goto yy822; + } + } +yy831: + yych = *++p; + if (yych <= 'T') { + if (yych <= 'I') { + if (yych == 'D') goto yy981; + if (yych <= 'H') goto yy822; + goto yy1037; + } else { + if (yych == 'L') goto yy981; + if (yych <= 'S') goto yy822; + goto yy981; + } + } else { + if (yych <= 'i') { + if (yych == 'd') goto yy981; + if (yych <= 'h') goto yy822; + goto yy1037; + } else { + if (yych <= 'l') { + if (yych <= 'k') goto yy822; + goto yy981; + } else { + if (yych == 't') goto yy981; + goto yy822; + } + } + } +yy832: + yych = *++p; + if (yych <= 'T') { + if (yych <= 'D') { + if (yych == 'C') goto yy1026; + goto yy822; + } else { + if (yych <= 'E') goto yy1027; + if (yych <= 'S') goto yy822; + goto yy1025; + } + } else { + if (yych <= 'd') { + if (yych == 'c') goto yy1026; + goto yy822; + } else { + if (yych <= 'e') goto yy1027; + if (yych == 't') goto yy1025; + goto yy822; + } + } +yy833: + yych = *++p; + switch (yych) { + case 'A': + case 'a': goto yy1011; + case 'B': + case 'b': goto yy1010; + case 'D': + case 'R': + case 'd': + case 'r': goto yy981; + case 'E': + case 'e': goto yy1009; + case 'F': + case 'f': goto yy1008; + case 'H': + case 'h': goto yy1007; + default: goto yy822; + } +yy834: + yych = *++p; + if (yych == 'M') goto yy1004; + if (yych == 'm') goto yy1004; + goto yy822; +yy835: + yych = *++p; + if (yych <= 'O') { + if (yych == 'I') goto yy985; + if (yych <= 'N') goto yy822; + goto yy984; + } else { + if (yych <= 'i') { + if (yych <= 'h') goto yy822; + goto yy985; + } else { + if (yych == 'o') goto yy984; + goto yy822; + } + } +yy836: + yych = *++p; + if (yych == 'L') goto yy981; + if (yych == 'l') goto yy981; + goto yy822; +yy837: + yych = *++p; + if (yych == 'I') goto yy978; + if (yych == 'i') goto yy978; + goto yy822; +yy838: + yych = *++p; + switch (yych) { + case 'A': + case 'a': goto yy840; + case 'B': + case 'b': goto yy843; + case 'C': + case 'c': goto yy847; + case 'D': + case 'd': goto yy848; + case 'E': + case 'e': goto yy851; + case 'F': + case 'f': goto yy852; + case 'H': + case 'h': goto yy841; + case 'I': + case 'i': goto yy842; + case 'L': + case 'l': goto yy844; + case 'M': + case 'm': goto yy845; + case 'O': + case 'o': goto yy846; + case 'P': + case 'p': goto yy839; + case 'S': + case 's': goto yy849; + case 'T': + case 't': goto yy850; + case 'U': + case 'u': goto yy853; + case 'V': + case 'v': goto yy854; + default: goto yy822; + } +yy839: + yych = *++p; + if (yych <= '=') { + if (yych <= '\r') { + if (yych <= 0x08) goto yy822; + goto yy859; + } else { + if (yych == ' ') goto yy859; + goto yy822; + } + } else { + if (yych <= 'R') { + if (yych <= '>') goto yy859; + if (yych <= 'Q') goto yy822; + goto yy972; + } else { + if (yych == 'r') goto yy972; + goto yy822; + } + } +yy840: + yych = *++p; + if (yych <= 'S') { + if (yych <= 'Q') goto yy822; + if (yych <= 'R') goto yy965; + goto yy964; + } else { + if (yych <= 'q') goto yy822; + if (yych <= 'r') goto yy965; + if (yych <= 's') goto yy964; + goto yy822; + } +yy841: + yych = *++p; + if (yych <= 'Q') { + if (yych <= 'D') { + if (yych <= '0') goto yy822; + if (yych <= '6') goto yy858; + goto yy822; + } else { + if (yych <= 'E') goto yy957; + if (yych == 'G') goto yy956; + goto yy822; + } + } else { + if (yych <= 'f') { + if (yych <= 'R') goto yy858; + if (yych == 'e') goto yy957; + goto yy822; + } else { + if (yych <= 'g') goto yy956; + if (yych == 'r') goto yy858; + goto yy822; + } + } +yy842: + yych = *++p; + if (yych == 'F') goto yy952; + if (yych == 'f') goto yy952; + goto yy822; +yy843: + yych = *++p; + if (yych <= 'U') { + if (yych <= 'N') { + if (yych == 'L') goto yy940; + goto yy822; + } else { + if (yych <= 'O') goto yy939; + if (yych <= 'T') goto yy822; + goto yy938; + } + } else { + if (yych <= 'n') { + if (yych == 'l') goto yy940; + goto yy822; + } else { + if (yych <= 'o') goto yy939; + if (yych == 'u') goto yy938; + goto yy822; + } + } +yy844: + yych = *++p; + if (yych == 'I') goto yy858; + if (yych == 'i') goto yy858; + goto yy822; +yy845: + yych = *++p; + if (yych == 'A') goto yy937; + if (yych == 'a') goto yy937; + goto yy822; +yy846: + yych = *++p; + if (yych <= 'U') { + if (yych <= 'K') { + if (yych == 'B') goto yy930; + goto yy822; + } else { + if (yych <= 'L') goto yy858; + if (yych <= 'T') goto yy822; + goto yy929; + } + } else { + if (yych <= 'k') { + if (yych == 'b') goto yy930; + goto yy822; + } else { + if (yych <= 'l') goto yy858; + if (yych == 'u') goto yy929; + goto yy822; + } + } +yy847: + yych = *++p; + if (yych <= 'O') { + if (yych == 'A') goto yy916; + if (yych <= 'N') goto yy822; + goto yy915; + } else { + if (yych <= 'a') { + if (yych <= '`') goto yy822; + goto yy916; + } else { + if (yych == 'o') goto yy915; + goto yy822; + } + } +yy848: + yych = *++p; + if (yych <= 'T') { + if (yych <= 'I') { + if (yych == 'D') goto yy858; + if (yych <= 'H') goto yy822; + goto yy914; + } else { + if (yych == 'L') goto yy858; + if (yych <= 'S') goto yy822; + goto yy858; + } + } else { + if (yych <= 'i') { + if (yych == 'd') goto yy858; + if (yych <= 'h') goto yy822; + goto yy914; + } else { + if (yych <= 'l') { + if (yych <= 'k') goto yy822; + goto yy858; + } else { + if (yych == 't') goto yy858; + goto yy822; + } + } + } +yy849: + yych = *++p; + if (yych <= 'T') { + if (yych <= 'D') { + if (yych == 'C') goto yy903; + goto yy822; + } else { + if (yych <= 'E') goto yy904; + if (yych <= 'S') goto yy822; + goto yy902; + } + } else { + if (yych <= 'd') { + if (yych == 'c') goto yy903; + goto yy822; + } else { + if (yych <= 'e') goto yy904; + if (yych == 't') goto yy902; + goto yy822; + } + } +yy850: + yych = *++p; + switch (yych) { + case 'A': + case 'a': goto yy888; + case 'B': + case 'b': goto yy887; + case 'D': + case 'R': + case 'd': + case 'r': goto yy858; + case 'E': + case 'e': goto yy886; + case 'F': + case 'f': goto yy885; + case 'H': + case 'h': goto yy884; + default: goto yy822; + } +yy851: + yych = *++p; + if (yych == 'M') goto yy881; + if (yych == 'm') goto yy881; + goto yy822; +yy852: + yych = *++p; + if (yych <= 'O') { + if (yych == 'I') goto yy862; + if (yych <= 'N') goto yy822; + goto yy861; + } else { + if (yych <= 'i') { + if (yych <= 'h') goto yy822; + goto yy862; + } else { + if (yych == 'o') goto yy861; + goto yy822; + } + } +yy853: + yych = *++p; + if (yych == 'L') goto yy858; + if (yych == 'l') goto yy858; + goto yy822; +yy854: + yych = *++p; + if (yych == 'I') goto yy855; + if (yych != 'i') goto yy822; +yy855: + yych = *++p; + if (yych == 'D') goto yy856; + if (yych != 'd') goto yy822; +yy856: + yych = *++p; + if (yych == 'E') goto yy857; + if (yych != 'e') goto yy822; +yy857: + yych = *++p; + if (yych == 'O') goto yy858; + if (yych != 'o') goto yy822; +yy858: + yych = *++p; + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy822; + if (yych >= 0x0E) goto yy822; + } else { + if (yych <= ' ') goto yy859; + if (yych != '>') goto yy822; + } +yy859: + ++p; + { return (p - start); } +yy861: + yych = *++p; + if (yych <= 'R') { + if (yych == 'O') goto yy877; + if (yych <= 'Q') goto yy822; + goto yy878; + } else { + if (yych <= 'o') { + if (yych <= 'n') goto yy822; + goto yy877; + } else { + if (yych == 'r') goto yy878; + goto yy822; + } + } +yy862: + yych = *++p; + if (yych <= 'G') { + if (yych == 'E') goto yy863; + if (yych <= 'F') goto yy822; + goto yy864; + } else { + if (yych <= 'e') { + if (yych <= 'd') goto yy822; + } else { + if (yych == 'g') goto yy864; + goto yy822; + } + } +yy863: + yych = *++p; + if (yych == 'L') goto yy873; + if (yych == 'l') goto yy873; + goto yy822; +yy864: + yych = *++p; + if (yych <= 'U') { + if (yych == 'C') goto yy866; + if (yych <= 'T') goto yy822; + } else { + if (yych <= 'c') { + if (yych <= 'b') goto yy822; + goto yy866; + } else { + if (yych != 'u') goto yy822; + } + } + yych = *++p; + if (yych == 'R') goto yy872; + if (yych == 'r') goto yy872; + goto yy822; +yy866: + yych = *++p; + if (yych == 'A') goto yy867; + if (yych != 'a') goto yy822; +yy867: + yych = *++p; + if (yych == 'P') goto yy868; + if (yych != 'p') goto yy822; +yy868: + yych = *++p; + if (yych == 'T') goto yy869; + if (yych != 't') goto yy822; +yy869: + yych = *++p; + if (yych == 'I') goto yy870; + if (yych != 'i') goto yy822; +yy870: + yych = *++p; + if (yych == 'O') goto yy871; + if (yych != 'o') goto yy822; +yy871: + yych = *++p; + if (yych == 'N') goto yy858; + if (yych == 'n') goto yy858; + goto yy822; +yy872: + yych = *++p; + if (yych == 'E') goto yy858; + if (yych == 'e') goto yy858; + goto yy822; +yy873: + yych = *++p; + if (yych == 'D') goto yy874; + if (yych != 'd') goto yy822; +yy874: + yych = *++p; + if (yych == 'S') goto yy875; + if (yych != 's') goto yy822; +yy875: + yych = *++p; + if (yych == 'E') goto yy876; + if (yych != 'e') goto yy822; +yy876: + yych = *++p; + if (yych == 'T') goto yy858; + if (yych == 't') goto yy858; + goto yy822; +yy877: + yych = *++p; + if (yych == 'T') goto yy879; + if (yych == 't') goto yy879; + goto yy822; +yy878: + yych = *++p; + if (yych == 'M') goto yy858; + if (yych == 'm') goto yy858; + goto yy822; +yy879: + yych = *++p; + if (yych == 'E') goto yy880; + if (yych != 'e') goto yy822; +yy880: + yych = *++p; + if (yych == 'R') goto yy858; + if (yych == 'r') goto yy858; + goto yy822; +yy881: + yych = *++p; + if (yych == 'B') goto yy882; + if (yych != 'b') goto yy822; +yy882: + yych = *++p; + if (yych == 'E') goto yy883; + if (yych != 'e') goto yy822; +yy883: + yych = *++p; + if (yych == 'D') goto yy858; + if (yych == 'd') goto yy858; + goto yy822; +yy884: + yych = *++p; + if (yych <= '=') { + if (yych <= '\r') { + if (yych <= 0x08) goto yy822; + goto yy859; + } else { + if (yych == ' ') goto yy859; + goto yy822; + } + } else { + if (yych <= 'E') { + if (yych <= '>') goto yy859; + if (yych <= 'D') goto yy822; + goto yy900; + } else { + if (yych == 'e') goto yy900; + goto yy822; + } + } +yy885: + yych = *++p; + if (yych == 'O') goto yy898; + if (yych == 'o') goto yy898; + goto yy822; +yy886: + yych = *++p; + if (yych == 'X') goto yy893; + if (yych == 'x') goto yy893; + goto yy822; +yy887: + yych = *++p; + if (yych == 'O') goto yy891; + if (yych == 'o') goto yy891; + goto yy822; +yy888: + yych = *++p; + if (yych == 'B') goto yy889; + if (yych != 'b') goto yy822; +yy889: + yych = *++p; + if (yych == 'L') goto yy890; + if (yych != 'l') goto yy822; +yy890: + yych = *++p; + if (yych == 'E') goto yy858; + if (yych == 'e') goto yy858; + goto yy822; +yy891: + yych = *++p; + if (yych == 'D') goto yy892; + if (yych != 'd') goto yy822; +yy892: + yych = *++p; + if (yych == 'Y') goto yy858; + if (yych == 'y') goto yy858; + goto yy822; +yy893: + yych = *++p; + if (yych == 'T') goto yy894; + if (yych != 't') goto yy822; +yy894: + yych = *++p; + if (yych == 'A') goto yy895; + if (yych != 'a') goto yy822; +yy895: + yych = *++p; + if (yych == 'R') goto yy896; + if (yych != 'r') goto yy822; +yy896: + yych = *++p; + if (yych == 'E') goto yy897; + if (yych != 'e') goto yy822; +yy897: + yych = *++p; + if (yych == 'A') goto yy858; + if (yych == 'a') goto yy858; + goto yy822; +yy898: + yych = *++p; + if (yych == 'O') goto yy899; + if (yych != 'o') goto yy822; +yy899: + yych = *++p; + if (yych == 'T') goto yy858; + if (yych == 't') goto yy858; + goto yy822; +yy900: + yych = *++p; + if (yych == 'A') goto yy901; + if (yych != 'a') goto yy822; +yy901: + yych = *++p; + if (yych == 'D') goto yy858; + if (yych == 'd') goto yy858; + goto yy822; +yy902: + yych = *++p; + if (yych == 'Y') goto yy912; + if (yych == 'y') goto yy912; + goto yy822; +yy903: + yych = *++p; + if (yych == 'R') goto yy909; + if (yych == 'r') goto yy909; + goto yy822; +yy904: + yych = *++p; + if (yych == 'C') goto yy905; + if (yych != 'c') goto yy822; +yy905: + yych = *++p; + if (yych == 'T') goto yy906; + if (yych != 't') goto yy822; +yy906: + yych = *++p; + if (yych == 'I') goto yy907; + if (yych != 'i') goto yy822; +yy907: + yych = *++p; + if (yych == 'O') goto yy908; + if (yych != 'o') goto yy822; +yy908: + yych = *++p; + if (yych == 'N') goto yy858; + if (yych == 'n') goto yy858; + goto yy822; +yy909: + yych = *++p; + if (yych == 'I') goto yy910; + if (yych != 'i') goto yy822; +yy910: + yych = *++p; + if (yych == 'P') goto yy911; + if (yych != 'p') goto yy822; +yy911: + yych = *++p; + if (yych == 'T') goto yy858; + if (yych == 't') goto yy858; + goto yy822; +yy912: + yych = *++p; + if (yych == 'L') goto yy913; + if (yych != 'l') goto yy822; +yy913: + yych = *++p; + if (yych == 'E') goto yy858; + if (yych == 'e') goto yy858; + goto yy822; +yy914: + yych = *++p; + if (yych == 'V') goto yy858; + if (yych == 'v') goto yy858; + goto yy822; +yy915: + yych = *++p; + if (yych == 'L') goto yy924; + if (yych == 'l') goto yy924; + goto yy822; +yy916: + yych = *++p; + if (yych <= 'P') { + if (yych == 'N') goto yy917; + if (yych <= 'O') goto yy822; + goto yy918; + } else { + if (yych <= 'n') { + if (yych <= 'm') goto yy822; + } else { + if (yych == 'p') goto yy918; + goto yy822; + } + } +yy917: + yych = *++p; + if (yych == 'V') goto yy922; + if (yych == 'v') goto yy922; + goto yy822; +yy918: + yych = *++p; + if (yych == 'T') goto yy919; + if (yych != 't') goto yy822; +yy919: + yych = *++p; + if (yych == 'I') goto yy920; + if (yych != 'i') goto yy822; +yy920: + yych = *++p; + if (yych == 'O') goto yy921; + if (yych != 'o') goto yy822; +yy921: + yych = *++p; + if (yych == 'N') goto yy858; + if (yych == 'n') goto yy858; + goto yy822; +yy922: + yych = *++p; + if (yych == 'A') goto yy923; + if (yych != 'a') goto yy822; +yy923: + yych = *++p; + if (yych == 'S') goto yy858; + if (yych == 's') goto yy858; + goto yy822; +yy924: + yych = *++p; + if (yych <= '=') { + if (yych <= '\r') { + if (yych <= 0x08) goto yy822; + goto yy859; + } else { + if (yych == ' ') goto yy859; + goto yy822; + } + } else { + if (yych <= 'G') { + if (yych <= '>') goto yy859; + if (yych <= 'F') goto yy822; + } else { + if (yych != 'g') goto yy822; + } + } + yych = *++p; + if (yych == 'R') goto yy926; + if (yych != 'r') goto yy822; +yy926: + yych = *++p; + if (yych == 'O') goto yy927; + if (yych != 'o') goto yy822; +yy927: + yych = *++p; + if (yych == 'U') goto yy928; + if (yych != 'u') goto yy822; +yy928: + yych = *++p; + if (yych == 'P') goto yy858; + if (yych == 'p') goto yy858; + goto yy822; +yy929: + yych = *++p; + if (yych == 'T') goto yy934; + if (yych == 't') goto yy934; + goto yy822; +yy930: + yych = *++p; + if (yych == 'J') goto yy931; + if (yych != 'j') goto yy822; +yy931: + yych = *++p; + if (yych == 'E') goto yy932; + if (yych != 'e') goto yy822; +yy932: + yych = *++p; + if (yych == 'C') goto yy933; + if (yych != 'c') goto yy822; +yy933: + yych = *++p; + if (yych == 'T') goto yy858; + if (yych == 't') goto yy858; + goto yy822; +yy934: + yych = *++p; + if (yych == 'P') goto yy935; + if (yych != 'p') goto yy822; +yy935: + yych = *++p; + if (yych == 'U') goto yy936; + if (yych != 'u') goto yy822; +yy936: + yych = *++p; + if (yych == 'T') goto yy858; + if (yych == 't') goto yy858; + goto yy822; +yy937: + yych = *++p; + if (yych == 'P') goto yy858; + if (yych == 'p') goto yy858; + goto yy822; +yy938: + yych = *++p; + if (yych == 'T') goto yy949; + if (yych == 't') goto yy949; + goto yy822; +yy939: + yych = *++p; + if (yych == 'D') goto yy948; + if (yych == 'd') goto yy948; + goto yy822; +yy940: + yych = *++p; + if (yych == 'O') goto yy941; + if (yych != 'o') goto yy822; +yy941: + yych = *++p; + if (yych == 'C') goto yy942; + if (yych != 'c') goto yy822; +yy942: + yych = *++p; + if (yych == 'K') goto yy943; + if (yych != 'k') goto yy822; +yy943: + yych = *++p; + if (yych == 'Q') goto yy944; + if (yych != 'q') goto yy822; +yy944: + yych = *++p; + if (yych == 'U') goto yy945; + if (yych != 'u') goto yy822; +yy945: + yych = *++p; + if (yych == 'O') goto yy946; + if (yych != 'o') goto yy822; +yy946: + yych = *++p; + if (yych == 'T') goto yy947; + if (yych != 't') goto yy822; +yy947: + yych = *++p; + if (yych == 'E') goto yy858; + if (yych == 'e') goto yy858; + goto yy822; +yy948: + yych = *++p; + if (yych == 'Y') goto yy858; + if (yych == 'y') goto yy858; + goto yy822; +yy949: + yych = *++p; + if (yych == 'T') goto yy950; + if (yych != 't') goto yy822; +yy950: + yych = *++p; + if (yych == 'O') goto yy951; + if (yych != 'o') goto yy822; +yy951: + yych = *++p; + if (yych == 'N') goto yy858; + if (yych == 'n') goto yy858; + goto yy822; +yy952: + yych = *++p; + if (yych == 'R') goto yy953; + if (yych != 'r') goto yy822; +yy953: + yych = *++p; + if (yych == 'A') goto yy954; + if (yych != 'a') goto yy822; +yy954: + yych = *++p; + if (yych == 'M') goto yy955; + if (yych != 'm') goto yy822; +yy955: + yych = *++p; + if (yych == 'E') goto yy858; + if (yych == 'e') goto yy858; + goto yy822; +yy956: + yych = *++p; + if (yych == 'R') goto yy961; + if (yych == 'r') goto yy961; + goto yy822; +yy957: + yych = *++p; + if (yych == 'A') goto yy958; + if (yych != 'a') goto yy822; +yy958: + yych = *++p; + if (yych == 'D') goto yy959; + if (yych != 'd') goto yy822; +yy959: + yych = *++p; + if (yych == 'E') goto yy960; + if (yych != 'e') goto yy822; +yy960: + yych = *++p; + if (yych == 'R') goto yy858; + if (yych == 'r') goto yy858; + goto yy822; +yy961: + yych = *++p; + if (yych == 'O') goto yy962; + if (yych != 'o') goto yy822; +yy962: + yych = *++p; + if (yych == 'U') goto yy963; + if (yych != 'u') goto yy822; +yy963: + yych = *++p; + if (yych == 'P') goto yy858; + if (yych == 'p') goto yy858; + goto yy822; +yy964: + yych = *++p; + if (yych == 'I') goto yy970; + if (yych == 'i') goto yy970; + goto yy822; +yy965: + yych = *++p; + if (yych == 'T') goto yy966; + if (yych != 't') goto yy822; +yy966: + yych = *++p; + if (yych == 'I') goto yy967; + if (yych != 'i') goto yy822; +yy967: + yych = *++p; + if (yych == 'C') goto yy968; + if (yych != 'c') goto yy822; +yy968: + yych = *++p; + if (yych == 'L') goto yy969; + if (yych != 'l') goto yy822; +yy969: + yych = *++p; + if (yych == 'E') goto yy858; + if (yych == 'e') goto yy858; + goto yy822; +yy970: + yych = *++p; + if (yych == 'D') goto yy971; + if (yych != 'd') goto yy822; +yy971: + yych = *++p; + if (yych == 'E') goto yy858; + if (yych == 'e') goto yy858; + goto yy822; +yy972: + yych = *++p; + if (yych <= 'O') { + if (yych == 'E') goto yy858; + if (yych <= 'N') goto yy822; + } else { + if (yych <= 'e') { + if (yych <= 'd') goto yy822; + goto yy858; + } else { + if (yych != 'o') goto yy822; + } + } + yych = *++p; + if (yych == 'G') goto yy974; + if (yych != 'g') goto yy822; +yy974: + yych = *++p; + if (yych == 'R') goto yy975; + if (yych != 'r') goto yy822; +yy975: + yych = *++p; + if (yych == 'E') goto yy976; + if (yych != 'e') goto yy822; +yy976: + yych = *++p; + if (yych == 'S') goto yy977; + if (yych != 's') goto yy822; +yy977: + yych = *++p; + if (yych == 'S') goto yy858; + if (yych == 's') goto yy858; + goto yy822; +yy978: + yych = *++p; + if (yych == 'D') goto yy979; + if (yych != 'd') goto yy822; +yy979: + yych = *++p; + if (yych == 'E') goto yy980; + if (yych != 'e') goto yy822; +yy980: + yych = *++p; + if (yych == 'O') goto yy981; + if (yych != 'o') goto yy822; +yy981: + yych = *++p; + if (yych <= ' ') { + if (yych <= 0x08) goto yy822; + if (yych <= '\r') goto yy982; + if (yych <= 0x1F) goto yy822; + } else { + if (yych <= '/') { + if (yych <= '.') goto yy822; + } else { + if (yych != '>') goto yy822; + } + } +yy982: + ++p; + { return (p - start); } +yy984: + yych = *++p; + if (yych <= 'R') { + if (yych == 'O') goto yy1000; + if (yych <= 'Q') goto yy822; + goto yy1001; + } else { + if (yych <= 'o') { + if (yych <= 'n') goto yy822; + goto yy1000; + } else { + if (yych == 'r') goto yy1001; + goto yy822; + } + } +yy985: + yych = *++p; + if (yych <= 'G') { + if (yych == 'E') goto yy986; + if (yych <= 'F') goto yy822; + goto yy987; + } else { + if (yych <= 'e') { + if (yych <= 'd') goto yy822; + } else { + if (yych == 'g') goto yy987; + goto yy822; + } + } +yy986: + yych = *++p; + if (yych == 'L') goto yy996; + if (yych == 'l') goto yy996; + goto yy822; +yy987: + yych = *++p; + if (yych <= 'U') { + if (yych == 'C') goto yy989; + if (yych <= 'T') goto yy822; + } else { + if (yych <= 'c') { + if (yych <= 'b') goto yy822; + goto yy989; + } else { + if (yych != 'u') goto yy822; + } + } + yych = *++p; + if (yych == 'R') goto yy995; + if (yych == 'r') goto yy995; + goto yy822; +yy989: + yych = *++p; + if (yych == 'A') goto yy990; + if (yych != 'a') goto yy822; +yy990: + yych = *++p; + if (yych == 'P') goto yy991; + if (yych != 'p') goto yy822; +yy991: + yych = *++p; + if (yych == 'T') goto yy992; + if (yych != 't') goto yy822; +yy992: + yych = *++p; + if (yych == 'I') goto yy993; + if (yych != 'i') goto yy822; +yy993: + yych = *++p; + if (yych == 'O') goto yy994; + if (yych != 'o') goto yy822; +yy994: + yych = *++p; + if (yych == 'N') goto yy981; + if (yych == 'n') goto yy981; + goto yy822; +yy995: + yych = *++p; + if (yych == 'E') goto yy981; + if (yych == 'e') goto yy981; + goto yy822; +yy996: + yych = *++p; + if (yych == 'D') goto yy997; + if (yych != 'd') goto yy822; +yy997: + yych = *++p; + if (yych == 'S') goto yy998; + if (yych != 's') goto yy822; +yy998: + yych = *++p; + if (yych == 'E') goto yy999; + if (yych != 'e') goto yy822; +yy999: + yych = *++p; + if (yych == 'T') goto yy981; + if (yych == 't') goto yy981; + goto yy822; +yy1000: + yych = *++p; + if (yych == 'T') goto yy1002; + if (yych == 't') goto yy1002; + goto yy822; +yy1001: + yych = *++p; + if (yych == 'M') goto yy981; + if (yych == 'm') goto yy981; + goto yy822; +yy1002: + yych = *++p; + if (yych == 'E') goto yy1003; + if (yych != 'e') goto yy822; +yy1003: + yych = *++p; + if (yych == 'R') goto yy981; + if (yych == 'r') goto yy981; + goto yy822; +yy1004: + yych = *++p; + if (yych == 'B') goto yy1005; + if (yych != 'b') goto yy822; +yy1005: + yych = *++p; + if (yych == 'E') goto yy1006; + if (yych != 'e') goto yy822; +yy1006: + yych = *++p; + if (yych == 'D') goto yy981; + if (yych == 'd') goto yy981; + goto yy822; +yy1007: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy822; + if (yych <= '\r') goto yy982; + goto yy822; + } else { + if (yych <= ' ') goto yy982; + if (yych <= '.') goto yy822; + goto yy982; + } + } else { + if (yych <= 'D') { + if (yych == '>') goto yy982; + goto yy822; + } else { + if (yych <= 'E') goto yy1023; + if (yych == 'e') goto yy1023; + goto yy822; + } + } +yy1008: + yych = *++p; + if (yych == 'O') goto yy1021; + if (yych == 'o') goto yy1021; + goto yy822; +yy1009: + yych = *++p; + if (yych == 'X') goto yy1016; + if (yych == 'x') goto yy1016; + goto yy822; +yy1010: + yych = *++p; + if (yych == 'O') goto yy1014; + if (yych == 'o') goto yy1014; + goto yy822; +yy1011: + yych = *++p; + if (yych == 'B') goto yy1012; + if (yych != 'b') goto yy822; +yy1012: + yych = *++p; + if (yych == 'L') goto yy1013; + if (yych != 'l') goto yy822; +yy1013: + yych = *++p; + if (yych == 'E') goto yy981; + if (yych == 'e') goto yy981; + goto yy822; +yy1014: + yych = *++p; + if (yych == 'D') goto yy1015; + if (yych != 'd') goto yy822; +yy1015: + yych = *++p; + if (yych == 'Y') goto yy981; + if (yych == 'y') goto yy981; + goto yy822; +yy1016: + yych = *++p; + if (yych == 'T') goto yy1017; + if (yych != 't') goto yy822; +yy1017: + yych = *++p; + if (yych == 'A') goto yy1018; + if (yych != 'a') goto yy822; +yy1018: + yych = *++p; + if (yych == 'R') goto yy1019; + if (yych != 'r') goto yy822; +yy1019: + yych = *++p; + if (yych == 'E') goto yy1020; + if (yych != 'e') goto yy822; +yy1020: + yych = *++p; + if (yych == 'A') goto yy981; + if (yych == 'a') goto yy981; + goto yy822; +yy1021: + yych = *++p; + if (yych == 'O') goto yy1022; + if (yych != 'o') goto yy822; +yy1022: + yych = *++p; + if (yych == 'T') goto yy981; + if (yych == 't') goto yy981; + goto yy822; +yy1023: + yych = *++p; + if (yych == 'A') goto yy1024; + if (yych != 'a') goto yy822; +yy1024: + yych = *++p; + if (yych == 'D') goto yy981; + if (yych == 'd') goto yy981; + goto yy822; +yy1025: + yych = *++p; + if (yych == 'Y') goto yy1035; + if (yych == 'y') goto yy1035; + goto yy822; +yy1026: + yych = *++p; + if (yych == 'R') goto yy1032; + if (yych == 'r') goto yy1032; + goto yy822; +yy1027: + yych = *++p; + if (yych == 'C') goto yy1028; + if (yych != 'c') goto yy822; +yy1028: + yych = *++p; + if (yych == 'T') goto yy1029; + if (yych != 't') goto yy822; +yy1029: + yych = *++p; + if (yych == 'I') goto yy1030; + if (yych != 'i') goto yy822; +yy1030: + yych = *++p; + if (yych == 'O') goto yy1031; + if (yych != 'o') goto yy822; +yy1031: + yych = *++p; + if (yych == 'N') goto yy981; + if (yych == 'n') goto yy981; + goto yy822; +yy1032: + yych = *++p; + if (yych == 'I') goto yy1033; + if (yych != 'i') goto yy822; +yy1033: + yych = *++p; + if (yych == 'P') goto yy1034; + if (yych != 'p') goto yy822; +yy1034: + yych = *++p; + if (yych == 'T') goto yy981; + if (yych == 't') goto yy981; + goto yy822; +yy1035: + yych = *++p; + if (yych == 'L') goto yy1036; + if (yych != 'l') goto yy822; +yy1036: + yych = *++p; + if (yych == 'E') goto yy981; + if (yych == 'e') goto yy981; + goto yy822; +yy1037: + yych = *++p; + if (yych == 'V') goto yy981; + if (yych == 'v') goto yy981; + goto yy822; +yy1038: + yych = *++p; + if (yych == 'L') goto yy1047; + if (yych == 'l') goto yy1047; + goto yy822; +yy1039: + yych = *++p; + if (yych <= 'P') { + if (yych == 'N') goto yy1040; + if (yych <= 'O') goto yy822; + goto yy1041; + } else { + if (yych <= 'n') { + if (yych <= 'm') goto yy822; + } else { + if (yych == 'p') goto yy1041; + goto yy822; + } + } +yy1040: + yych = *++p; + if (yych == 'V') goto yy1045; + if (yych == 'v') goto yy1045; + goto yy822; +yy1041: + yych = *++p; + if (yych == 'T') goto yy1042; + if (yych != 't') goto yy822; +yy1042: + yych = *++p; + if (yych == 'I') goto yy1043; + if (yych != 'i') goto yy822; +yy1043: + yych = *++p; + if (yych == 'O') goto yy1044; + if (yych != 'o') goto yy822; +yy1044: + yych = *++p; + if (yych == 'N') goto yy981; + if (yych == 'n') goto yy981; + goto yy822; +yy1045: + yych = *++p; + if (yych == 'A') goto yy1046; + if (yych != 'a') goto yy822; +yy1046: + yych = *++p; + if (yych == 'S') goto yy981; + if (yych == 's') goto yy981; + goto yy822; +yy1047: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy822; + if (yych <= '\r') goto yy982; + goto yy822; + } else { + if (yych <= ' ') goto yy982; + if (yych <= '.') goto yy822; + goto yy982; + } + } else { + if (yych <= 'F') { + if (yych == '>') goto yy982; + goto yy822; + } else { + if (yych <= 'G') goto yy1048; + if (yych != 'g') goto yy822; + } + } +yy1048: + yych = *++p; + if (yych == 'R') goto yy1049; + if (yych != 'r') goto yy822; +yy1049: + yych = *++p; + if (yych == 'O') goto yy1050; + if (yych != 'o') goto yy822; +yy1050: + yych = *++p; + if (yych == 'U') goto yy1051; + if (yych != 'u') goto yy822; +yy1051: + yych = *++p; + if (yych == 'P') goto yy981; + if (yych == 'p') goto yy981; + goto yy822; +yy1052: + yych = *++p; + if (yych == 'T') goto yy1057; + if (yych == 't') goto yy1057; + goto yy822; +yy1053: + yych = *++p; + if (yych == 'J') goto yy1054; + if (yych != 'j') goto yy822; +yy1054: + yych = *++p; + if (yych == 'E') goto yy1055; + if (yych != 'e') goto yy822; +yy1055: + yych = *++p; + if (yych == 'C') goto yy1056; + if (yych != 'c') goto yy822; +yy1056: + yych = *++p; + if (yych == 'T') goto yy981; + if (yych == 't') goto yy981; + goto yy822; +yy1057: + yych = *++p; + if (yych == 'P') goto yy1058; + if (yych != 'p') goto yy822; +yy1058: + yych = *++p; + if (yych == 'U') goto yy1059; + if (yych != 'u') goto yy822; +yy1059: + yych = *++p; + if (yych == 'T') goto yy981; + if (yych == 't') goto yy981; + goto yy822; +yy1060: + yych = *++p; + if (yych == 'P') goto yy981; + if (yych == 'p') goto yy981; + goto yy822; +yy1061: + yych = *++p; + if (yych == 'T') goto yy1072; + if (yych == 't') goto yy1072; + goto yy822; +yy1062: + yych = *++p; + if (yych == 'D') goto yy1071; + if (yych == 'd') goto yy1071; + goto yy822; +yy1063: + yych = *++p; + if (yych == 'O') goto yy1064; + if (yych != 'o') goto yy822; +yy1064: + yych = *++p; + if (yych == 'C') goto yy1065; + if (yych != 'c') goto yy822; +yy1065: + yych = *++p; + if (yych == 'K') goto yy1066; + if (yych != 'k') goto yy822; +yy1066: + yych = *++p; + if (yych == 'Q') goto yy1067; + if (yych != 'q') goto yy822; +yy1067: + yych = *++p; + if (yych == 'U') goto yy1068; + if (yych != 'u') goto yy822; +yy1068: + yych = *++p; + if (yych == 'O') goto yy1069; + if (yych != 'o') goto yy822; +yy1069: + yych = *++p; + if (yych == 'T') goto yy1070; + if (yych != 't') goto yy822; +yy1070: + yych = *++p; + if (yych == 'E') goto yy981; + if (yych == 'e') goto yy981; + goto yy822; +yy1071: + yych = *++p; + if (yych == 'Y') goto yy981; + if (yych == 'y') goto yy981; + goto yy822; +yy1072: + yych = *++p; + if (yych == 'T') goto yy1073; + if (yych != 't') goto yy822; +yy1073: + yych = *++p; + if (yych == 'O') goto yy1074; + if (yych != 'o') goto yy822; +yy1074: + yych = *++p; + if (yych == 'N') goto yy981; + if (yych == 'n') goto yy981; + goto yy822; +yy1075: + yych = *++p; + if (yych == 'R') goto yy1076; + if (yych != 'r') goto yy822; +yy1076: + yych = *++p; + if (yych == 'A') goto yy1077; + if (yych != 'a') goto yy822; +yy1077: + yych = *++p; + if (yych == 'M') goto yy1078; + if (yych != 'm') goto yy822; +yy1078: + yych = *++p; + if (yych == 'E') goto yy981; + if (yych == 'e') goto yy981; + goto yy822; +yy1079: + yych = *++p; + if (yych == 'R') goto yy1084; + if (yych == 'r') goto yy1084; + goto yy822; +yy1080: + yych = *++p; + if (yych == 'A') goto yy1081; + if (yych != 'a') goto yy822; +yy1081: + yych = *++p; + if (yych == 'D') goto yy1082; + if (yych != 'd') goto yy822; +yy1082: + yych = *++p; + if (yych == 'E') goto yy1083; + if (yych != 'e') goto yy822; +yy1083: + yych = *++p; + if (yych == 'R') goto yy981; + if (yych == 'r') goto yy981; + goto yy822; +yy1084: + yych = *++p; + if (yych == 'O') goto yy1085; + if (yych != 'o') goto yy822; +yy1085: + yych = *++p; + if (yych == 'U') goto yy1086; + if (yych != 'u') goto yy822; +yy1086: + yych = *++p; + if (yych == 'P') goto yy981; + if (yych == 'p') goto yy981; + goto yy822; +yy1087: + yych = *++p; + if (yych == 'I') goto yy1093; + if (yych == 'i') goto yy1093; + goto yy822; +yy1088: + yych = *++p; + if (yych == 'T') goto yy1089; + if (yych != 't') goto yy822; +yy1089: + yych = *++p; + if (yych == 'I') goto yy1090; + if (yych != 'i') goto yy822; +yy1090: + yych = *++p; + if (yych == 'C') goto yy1091; + if (yych != 'c') goto yy822; +yy1091: + yych = *++p; + if (yych == 'L') goto yy1092; + if (yych != 'l') goto yy822; +yy1092: + yych = *++p; + if (yych == 'E') goto yy981; + if (yych == 'e') goto yy981; + goto yy822; +yy1093: + yych = *++p; + if (yych == 'D') goto yy1094; + if (yych != 'd') goto yy822; +yy1094: + yych = *++p; + if (yych == 'E') goto yy981; + if (yych == 'e') goto yy981; + goto yy822; +yy1095: + yych = *++p; + if (yych <= 'O') { + if (yych == 'E') goto yy981; + if (yych <= 'N') goto yy822; + } else { + if (yych <= 'e') { + if (yych <= 'd') goto yy822; + goto yy981; + } else { + if (yych != 'o') goto yy822; + } + } + yych = *++p; + if (yych == 'G') goto yy1097; + if (yych != 'g') goto yy822; +yy1097: + yych = *++p; + if (yych == 'R') goto yy1098; + if (yych != 'r') goto yy822; +yy1098: + yych = *++p; + if (yych == 'E') goto yy1099; + if (yych != 'e') goto yy822; +yy1099: + yych = *++p; + if (yych == 'S') goto yy1100; + if (yych != 's') goto yy822; +yy1100: + ++p; + if ((yych = *p) == 'S') goto yy981; + if (yych == 's') goto yy981; + goto yy822; +} + +} + +// Try to match a URL in a link or reference, return number of chars matched. +// This may optionally be contained in <..>; otherwise +// whitespace and unbalanced right parentheses aren't allowed. +// Newlines aren't ever allowed. +int _scan_link_url(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; + +{ + unsigned char yych; + unsigned int yyaccept = 0; + static const unsigned char yybm[] = { + 0, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 8, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, + 72, 112, 112, 112, 112, 112, 112, 112, + 64, 64, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 16, 112, 16, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 128, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + }; + yych = *p; + if (yych <= '(') { + if (yych <= 0x1F) { + if (yych == '\n') goto yy1104; + goto yy1112; + } else { + if (yych <= ' ') goto yy1106; + if (yych <= '\'') goto yy1108; + goto yy1111; + } + } else { + if (yych <= '<') { + if (yych <= ')') goto yy1112; + if (yych <= ';') goto yy1108; + goto yy1107; + } else { + if (yych == '\\') goto yy1109; + goto yy1108; + } + } +yy1103: + { return (p - start); } +yy1104: + yyaccept = 0; + marker = ++p; + yych = *p; +yy1105: + if (yybm[0+yych] & 8) { + goto yy1104; + } + if (yych <= ')') { + if (yych <= ' ') goto yy1103; + if (yych <= '\'') goto yy1117; + if (yych <= '(') goto yy1113; + goto yy1103; + } else { + if (yych <= '<') { + if (yych <= ';') goto yy1117; + goto yy1120; + } else { + if (yych == '\\') goto yy1119; + goto yy1117; + } + } +yy1106: + yyaccept = 0; + yych = *(marker = ++p); + goto yy1105; +yy1107: + yyaccept = 0; + yych = *(marker = ++p); + if (yybm[0+yych] & 32) { + goto yy1120; + } + if (yych <= '\'') { + if (yych <= 0x00) goto yy1103; + if (yych == '\n') goto yy1103; + goto yy1127; + } else { + if (yych <= ')') { + if (yych <= '(') goto yy1125; + goto yy1127; + } else { + if (yych <= '=') goto yy1117; + if (yych <= '>') goto yy1122; + goto yy1124; + } + } +yy1108: + yyaccept = 0; + yych = *(marker = ++p); + goto yy1118; +yy1109: + ++p; + if ((yych = *p) <= '@') { + if (yych <= ' ') goto yy1110; + if (yych <= '/') goto yy1117; + if (yych >= ':') goto yy1117; + } else { + if (yych <= '`') { + if (yych >= '[') goto yy1117; + } else { + if (yych <= 'z') goto yy1110; + if (yych <= '~') goto yy1117; + } + } +yy1110: + { return 0; } +yy1111: + yyaccept = 1; + yych = *(marker = ++p); + if (yych <= ' ') goto yy1110; + if (yych == '(') goto yy1110; + goto yy1114; +yy1112: + yych = *++p; + goto yy1110; +yy1113: + ++p; + yych = *p; +yy1114: + if (yybm[0+yych] & 16) { + goto yy1113; + } + if (yych <= '(') goto yy1115; + if (yych <= ')') goto yy1117; + goto yy1116; +yy1115: + p = marker; + if (yyaccept <= 1) { + if (yyaccept == 0) { + goto yy1103; + } else { + goto yy1110; + } + } else { + goto yy1123; + } +yy1116: + ++p; + yych = *p; + if (yych <= '@') { + if (yych <= ' ') goto yy1115; + if (yych <= '/') goto yy1113; + if (yych <= '9') goto yy1115; + goto yy1113; + } else { + if (yych <= '`') { + if (yych <= 'Z') goto yy1115; + goto yy1113; + } else { + if (yych <= 'z') goto yy1115; + if (yych <= '~') goto yy1113; + goto yy1115; + } + } +yy1117: + yyaccept = 0; + marker = ++p; + yych = *p; +yy1118: + if (yych <= '(') { + if (yych <= ' ') goto yy1103; + if (yych <= '\'') goto yy1117; + goto yy1113; + } else { + if (yych <= ')') goto yy1103; + if (yych != '\\') goto yy1117; + } +yy1119: + ++p; + yych = *p; + if (yych <= '@') { + if (yych <= ' ') goto yy1115; + if (yych <= '/') goto yy1117; + if (yych <= '9') goto yy1115; + goto yy1117; + } else { + if (yych <= '`') { + if (yych <= 'Z') goto yy1115; + goto yy1117; + } else { + if (yych <= 'z') goto yy1115; + if (yych <= '~') goto yy1117; + goto yy1115; + } + } +yy1120: + yyaccept = 0; + marker = ++p; + yych = *p; + if (yybm[0+yych] & 32) { + goto yy1120; + } + if (yych <= '\'') { + if (yych <= 0x00) goto yy1103; + if (yych == '\n') goto yy1103; + goto yy1127; + } else { + if (yych <= ')') { + if (yych <= '(') goto yy1125; + goto yy1127; + } else { + if (yych <= '=') goto yy1117; + if (yych >= '?') goto yy1124; + } + } +yy1122: + yyaccept = 2; + yych = *(marker = ++p); + if (yych <= ' ') goto yy1123; + if (yych != ')') goto yy1118; +yy1123: + { return (p - start); } +yy1124: + ++p; + yych = *p; + if (yych <= '>') { + if (yych <= ' ') { + if (yych <= 0x00) goto yy1115; + if (yych == '\n') goto yy1115; + goto yy1127; + } else { + if (yych <= '/') goto yy1120; + if (yych <= '9') goto yy1127; + if (yych <= '=') goto yy1120; + goto yy1137; + } + } else { + if (yych <= '\\') { + if (yych <= '@') goto yy1120; + if (yych <= 'Z') goto yy1127; + if (yych <= '[') goto yy1120; + goto yy1138; + } else { + if (yych <= '`') goto yy1120; + if (yych <= 'z') goto yy1127; + if (yych <= '~') goto yy1120; + goto yy1127; + } + } +yy1125: + ++p; + yych = *p; + if (yych <= ')') { + if (yych <= '\n') { + if (yych <= 0x00) goto yy1115; + if (yych >= '\n') goto yy1115; + } else { + if (yych <= ' ') goto yy1127; + if (yych <= '\'') goto yy1125; + if (yych >= ')') goto yy1120; + } + } else { + if (yych <= '=') { + if (yych == '<') goto yy1113; + goto yy1125; + } else { + if (yych <= '>') goto yy1133; + if (yych == '\\') goto yy1134; + goto yy1125; + } + } +yy1127: + ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1127; + } + if (yych <= '=') goto yy1115; + if (yych >= '?') goto yy1130; +yy1129: + yych = *++p; + goto yy1123; +yy1130: + ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy1130; + } + if (yych <= '\n') { + if (yych <= 0x00) goto yy1115; + if (yych <= '\t') goto yy1127; + goto yy1115; + } else { + if (yych != '>') goto yy1127; + } + yyaccept = 2; + marker = ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1127; + } + if (yych <= '=') goto yy1123; + if (yych <= '>') goto yy1129; + goto yy1130; +yy1133: + yyaccept = 2; + yych = *(marker = ++p); + if (yych <= ' ') goto yy1123; + if (yych == '(') goto yy1123; + goto yy1114; +yy1134: + ++p; + yych = *p; + if (yych <= '>') { + if (yych <= ' ') { + if (yych <= 0x00) goto yy1115; + if (yych == '\n') goto yy1115; + goto yy1127; + } else { + if (yych <= '/') goto yy1125; + if (yych <= '9') goto yy1127; + if (yych <= '=') goto yy1125; + } + } else { + if (yych <= '\\') { + if (yych <= '@') goto yy1125; + if (yych <= 'Z') goto yy1127; + if (yych <= '[') goto yy1125; + goto yy1136; + } else { + if (yych <= '`') goto yy1125; + if (yych <= 'z') goto yy1127; + if (yych <= '~') goto yy1125; + goto yy1127; + } + } +yy1135: + yyaccept = 2; + marker = ++p; + yych = *p; + if (yych <= ')') { + if (yych <= '\n') { + if (yych <= 0x00) goto yy1123; + if (yych <= '\t') goto yy1127; + goto yy1123; + } else { + if (yych <= ' ') goto yy1127; + if (yych <= '\'') goto yy1125; + if (yych <= '(') goto yy1127; + goto yy1120; + } + } else { + if (yych <= '=') { + if (yych == '<') goto yy1113; + goto yy1125; + } else { + if (yych <= '>') goto yy1133; + if (yych == '\\') goto yy1134; + goto yy1125; + } + } +yy1136: + ++p; + yych = *p; + if (yych <= '(') { + if (yych <= '\n') { + if (yych <= 0x00) goto yy1115; + if (yych <= '\t') goto yy1127; + goto yy1115; + } else { + if (yych <= ' ') goto yy1127; + if (yych <= '\'') goto yy1125; + goto yy1127; + } + } else { + if (yych <= '>') { + if (yych <= ')') goto yy1120; + if (yych <= '=') goto yy1125; + goto yy1135; + } else { + if (yych == '\\') goto yy1134; + goto yy1125; + } + } +yy1137: + yyaccept = 2; + marker = ++p; + yych = *p; + if (yybm[0+yych] & 32) { + goto yy1120; + } + if (yych <= '\'') { + if (yych <= 0x00) goto yy1123; + if (yych == '\n') goto yy1123; + goto yy1127; + } else { + if (yych <= ')') { + if (yych <= '(') goto yy1125; + goto yy1127; + } else { + if (yych <= '=') goto yy1117; + if (yych <= '>') goto yy1122; + goto yy1124; + } + } +yy1138: + yyaccept = 0; + marker = ++p; + yych = *p; + if (yych <= '(') { + if (yych <= '\n') { + if (yych <= 0x00) goto yy1103; + if (yych <= '\t') goto yy1127; + goto yy1103; + } else { + if (yych <= ' ') goto yy1127; + if (yych <= '\'') goto yy1120; + goto yy1125; + } + } else { + if (yych <= '>') { + if (yych <= ')') goto yy1127; + if (yych <= '=') goto yy1120; + goto yy1137; + } else { + if (yych == '\\') goto yy1124; + goto yy1120; + } + } +} + +} + +// Try to match a link title (in single quotes, in double quotes, or +// in parentheses), returning number of chars matched. Allow one +// level of internal nesting (quotes within quotes). +int _scan_link_title(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; + +{ + unsigned char yych; + unsigned int yyaccept = 0; + static const unsigned char yybm[] = { + 0, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 80, 208, 208, 208, 208, 144, + 208, 192, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 32, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + }; + yych = *p; + if (yych <= '"') { + if (yych == '\n') goto yy1141; + if (yych <= '!') goto yy1145; + goto yy1142; + } else { + if (yych <= '&') goto yy1145; + if (yych <= '\'') goto yy1143; + if (yych <= '(') goto yy1144; + goto yy1145; + } +yy1141: + { return 0; } +yy1142: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x00) goto yy1141; + goto yy1162; +yy1143: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x00) goto yy1141; + goto yy1155; +yy1144: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x00) goto yy1141; + goto yy1147; +yy1145: + yych = *++p; + goto yy1141; +yy1146: + ++p; + yych = *p; +yy1147: + if (yybm[0+yych] & 16) { + goto yy1146; + } + if (yych <= 0x00) goto yy1148; + if (yych <= '[') goto yy1151; + goto yy1149; +yy1148: + p = marker; + if (yyaccept <= 1) { + if (yyaccept == 0) { + goto yy1141; + } else { + goto yy1152; + } + } else { + if (yyaccept == 2) { + goto yy1159; + } else { + goto yy1166; + } + } +yy1149: + ++p; + yych = *p; + if (yybm[0+yych] & 16) { + goto yy1146; + } + if (yych <= 0x00) goto yy1148; + if (yych <= '[') goto yy1153; + goto yy1149; +yy1151: + ++p; +yy1152: + { return (p - start); } +yy1153: + yyaccept = 1; + marker = ++p; + yych = *p; + if (yybm[0+yych] & 16) { + goto yy1146; + } + if (yych <= 0x00) goto yy1152; + if (yych <= '[') goto yy1151; + goto yy1149; +yy1154: + ++p; + yych = *p; +yy1155: + if (yybm[0+yych] & 64) { + goto yy1154; + } + if (yych <= 0x00) goto yy1148; + if (yych <= '[') goto yy1158; +yy1156: + ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1154; + } + if (yych <= 0x00) goto yy1148; + if (yych <= '[') goto yy1160; + goto yy1156; +yy1158: + ++p; +yy1159: + { return (p - start); } +yy1160: + yyaccept = 2; + marker = ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1154; + } + if (yych <= 0x00) goto yy1159; + if (yych <= '[') goto yy1158; + goto yy1156; +yy1161: + ++p; + yych = *p; +yy1162: + if (yybm[0+yych] & 128) { + goto yy1161; + } + if (yych <= 0x00) goto yy1148; + if (yych <= '[') goto yy1165; +yy1163: + ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy1161; + } + if (yych <= 0x00) goto yy1148; + if (yych <= '[') goto yy1167; + goto yy1163; +yy1165: + ++p; +yy1166: + { return (p - start); } +yy1167: + yyaccept = 3; + marker = ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy1161; + } + if (yych <= 0x00) goto yy1166; + if (yych <= '[') goto yy1165; + goto yy1163; +} + +} + +// Match space characters, including newlines. +int _scan_spacechars(const unsigned char *p) +{ + const unsigned char *start = p; \ + +{ + unsigned char yych; + static const unsigned char yybm[] = { + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 128, 128, 128, 128, 128, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 128, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + }; + yych = *p; + if (yych <= '\n') { + if (yych <= 0x08) goto yy1174; + if (yych <= '\t') goto yy1171; + goto yy1172; + } else { + if (yych <= '\r') goto yy1171; + if (yych == ' ') goto yy1171; + goto yy1174; + } +yy1170: + { return (p - start); } +yy1171: + yych = *++p; + goto yy1173; +yy1172: + ++p; + yych = *p; +yy1173: + if (yybm[0+yych] & 128) { + goto yy1172; + } + goto yy1170; +yy1174: + ++p; + { return 0; } +} + +} + +// Match ATX header start. +int _scan_atx_header_start(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; + +{ + unsigned char yych; + static const unsigned char yybm[] = { + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 128, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + }; + yych = *p; + if (yych == '\n') goto yy1178; + if (yych == '#') goto yy1179; + goto yy1180; +yy1178: + { return 0; } +yy1179: + yych = *(marker = ++p); + if (yybm[0+yych] & 128) { + goto yy1183; + } + if (yych == '\n') goto yy1181; + if (yych == '#') goto yy1185; + goto yy1178; +yy1180: + yych = *++p; + goto yy1178; +yy1181: + ++p; +yy1182: + { return (p - start); } +yy1183: + ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy1183; + } + goto yy1182; +yy1185: + yych = *++p; + if (yybm[0+yych] & 128) { + goto yy1183; + } + if (yych == '\n') goto yy1181; + if (yych == '#') goto yy1187; +yy1186: + p = marker; + goto yy1178; +yy1187: + yych = *++p; + if (yybm[0+yych] & 128) { + goto yy1183; + } + if (yych == '\n') goto yy1181; + if (yych != '#') goto yy1186; + yych = *++p; + if (yybm[0+yych] & 128) { + goto yy1183; + } + if (yych == '\n') goto yy1181; + if (yych != '#') goto yy1186; + yych = *++p; + if (yybm[0+yych] & 128) { + goto yy1183; + } + if (yych == '\n') goto yy1181; + if (yych != '#') goto yy1186; + ++p; + if (yybm[0+(yych = *p)] & 128) { + goto yy1183; + } + if (yych == '\n') goto yy1181; + goto yy1186; +} + +} + +// Match sexext header line. Return 1 for level-1 header, +// 2 for level-2, 0 for no match. +int _scan_setext_header_line(const unsigned char *p) +{ + const unsigned char *marker = NULL; + +{ + unsigned char yych; + static const unsigned char yybm[] = { + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 64, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 128, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + }; + yych = *p; + if (yych <= ',') { + if (yych != '\n') goto yy1196; + } else { + if (yych <= '-') goto yy1195; + if (yych == '=') goto yy1194; + goto yy1196; + } +yy1193: + { return 0; } +yy1194: + yych = *(marker = ++p); + if (yybm[0+yych] & 128) { + goto yy1208; + } + if (yych == '\n') goto yy1206; + if (yych == ' ') goto yy1204; + goto yy1193; +yy1195: + yych = *(marker = ++p); + if (yybm[0+yych] & 32) { + goto yy1197; + } + if (yych == '\n') goto yy1200; + if (yych == '-') goto yy1202; + goto yy1193; +yy1196: + yych = *++p; + goto yy1193; +yy1197: + ++p; + yych = *p; + if (yybm[0+yych] & 32) { + goto yy1197; + } + if (yych == '\n') goto yy1200; +yy1199: + p = marker; + goto yy1193; +yy1200: + ++p; + { return 2; } +yy1202: + ++p; + yych = *p; + if (yybm[0+yych] & 32) { + goto yy1197; + } + if (yych == '\n') goto yy1200; + if (yych == '-') goto yy1202; + goto yy1199; +yy1204: + ++p; + yych = *p; + if (yych == '\n') goto yy1206; + if (yych == ' ') goto yy1204; + goto yy1199; +yy1206: + ++p; + { return 1; } +yy1208: + ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy1208; + } + if (yych == '\n') goto yy1206; + if (yych == ' ') goto yy1204; + goto yy1199; +} + +} + +// Scan a horizontal rule line: "...three or more hyphens, asterisks, +// or underscores on a line by themselves. If you wish, you may use +// spaces between the hyphens or asterisks." +int _scan_hrule(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; + +{ + unsigned char yych; + static const unsigned char yybm[] = { + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 248, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 128, 0, 0, 16, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 64, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + }; + yych = *p; + if (yych <= '*') { + if (yych == '\n') goto yy1212; + if (yych <= ')') goto yy1216; + goto yy1213; + } else { + if (yych <= '-') { + if (yych <= ',') goto yy1216; + goto yy1215; + } else { + if (yych == '_') goto yy1214; + goto yy1216; + } + } +yy1212: + { return 0; } +yy1213: + yych = *(marker = ++p); + if (yych == ' ') goto yy1238; + if (yych == '*') goto yy1240; + goto yy1212; +yy1214: + yych = *(marker = ++p); + if (yych == ' ') goto yy1228; + if (yych == '_') goto yy1230; + goto yy1212; +yy1215: + yych = *(marker = ++p); + if (yybm[0+yych] & 8) { + goto yy1217; + } + if (yych == '-') goto yy1220; + goto yy1212; +yy1216: + yych = *++p; + goto yy1212; +yy1217: + ++p; + yych = *p; + if (yybm[0+yych] & 8) { + goto yy1217; + } + if (yych == '-') goto yy1220; +yy1219: + p = marker; + goto yy1212; +yy1220: + ++p; + yych = *p; + if (yych == ' ') goto yy1220; + if (yych != '-') goto yy1219; +yy1222: + ++p; + yych = *p; + if (yybm[0+yych] & 16) { + goto yy1222; + } + if (yych <= 0x08) goto yy1219; + if (yych <= '\t') goto yy1224; + if (yych <= '\n') goto yy1226; + goto yy1219; +yy1224: + ++p; + yych = *p; + if (yybm[0+yych] & 32) { + goto yy1224; + } + if (yych != '\n') goto yy1219; +yy1226: + ++p; + { return (p - start); } +yy1228: + ++p; + yych = *p; + if (yych == ' ') goto yy1228; + if (yych != '_') goto yy1219; +yy1230: + ++p; + yych = *p; + if (yych == ' ') goto yy1230; + if (yych != '_') goto yy1219; +yy1232: + ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1232; + } + if (yych <= 0x08) goto yy1219; + if (yych <= '\t') goto yy1234; + if (yych <= '\n') goto yy1236; + goto yy1219; +yy1234: + ++p; + yych = *p; + if (yych <= '\n') { + if (yych <= 0x08) goto yy1219; + if (yych <= '\t') goto yy1234; + } else { + if (yych == ' ') goto yy1234; + goto yy1219; + } +yy1236: + ++p; + { return (p - start); } +yy1238: + ++p; + yych = *p; + if (yych == ' ') goto yy1238; + if (yych != '*') goto yy1219; +yy1240: + ++p; + yych = *p; + if (yych == ' ') goto yy1240; + if (yych != '*') goto yy1219; +yy1242: + ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy1242; + } + if (yych <= 0x08) goto yy1219; + if (yych <= '\t') goto yy1244; + if (yych <= '\n') goto yy1246; + goto yy1219; +yy1244: + ++p; + yych = *p; + if (yych <= '\n') { + if (yych <= 0x08) goto yy1219; + if (yych <= '\t') goto yy1244; + } else { + if (yych == ' ') goto yy1244; + goto yy1219; + } +yy1246: + ++p; + { return (p - start); } +} + +} + +// Scan an opening code fence. +int _scan_open_code_fence(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; + +{ + unsigned char yych; + static const unsigned char yybm[] = { + 0, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 0, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 96, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 144, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + }; + yych = *p; + if (yych <= '_') { + if (yych != '\n') goto yy1253; + } else { + if (yych <= '`') goto yy1251; + if (yych == '~') goto yy1252; + goto yy1253; + } +yy1250: + { return 0; } +yy1251: + yych = *(marker = ++p); + if (yych == '`') goto yy1262; + goto yy1250; +yy1252: + yych = *(marker = ++p); + if (yych == '~') goto yy1254; + goto yy1250; +yy1253: + yych = *++p; + goto yy1250; +yy1254: + yych = *++p; + if (yybm[0+yych] & 16) { + goto yy1256; + } +yy1255: + p = marker; + goto yy1250; +yy1256: + marker = p + 1; + ++p; + yych = *p; + if (yybm[0+yych] & 32) { + goto yy1258; + } + if (yych <= 0x00) goto yy1255; + if (yych <= '}') goto yy1260; + goto yy1256; +yy1258: + ++p; + yych = *p; + if (yybm[0+yych] & 32) { + goto yy1258; + } + if (yych <= 0x00) goto yy1255; + if (yych >= '~') goto yy1255; +yy1260: + ++p; + p = marker; + { return (p - start); } +yy1262: + yych = *++p; + if (yybm[0+yych] & 64) { + goto yy1263; + } + goto yy1255; +yy1263: + marker = p + 1; + ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy1265; + } + if (yych <= 0x00) goto yy1255; + if (yych <= '_') goto yy1267; + goto yy1263; +yy1265: + ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy1265; + } + if (yych <= 0x00) goto yy1255; + if (yych >= '`') goto yy1255; +yy1267: + ++p; + p = marker; + { return (p - start); } +} + +} + +// Scan a closing code fence with length at least len. +int _scan_close_code_fence(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; + +{ + unsigned char yych; + static const unsigned char yybm[] = { + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 64, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 128, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 32, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + }; + yych = *p; + if (yych <= '_') { + if (yych != '\n') goto yy1274; + } else { + if (yych <= '`') goto yy1272; + if (yych == '~') goto yy1273; + goto yy1274; + } +yy1271: + { return 0; } +yy1272: + yych = *(marker = ++p); + if (yych == '`') goto yy1283; + goto yy1271; +yy1273: + yych = *(marker = ++p); + if (yych == '~') goto yy1275; + goto yy1271; +yy1274: + yych = *++p; + goto yy1271; +yy1275: + yych = *++p; + if (yybm[0+yych] & 32) { + goto yy1277; + } +yy1276: + p = marker; + goto yy1271; +yy1277: + marker = p + 1; + ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1279; + } + if (yych == '\n') goto yy1281; + if (yych == '~') goto yy1277; + goto yy1276; +yy1279: + ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1279; + } + if (yych != '\n') goto yy1276; +yy1281: + ++p; + p = marker; + { return (p - start); } +yy1283: + yych = *++p; + if (yybm[0+yych] & 128) { + goto yy1284; + } + goto yy1276; +yy1284: + marker = p + 1; + ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy1284; + } + if (yych <= '\n') { + if (yych <= 0x08) goto yy1276; + if (yych >= '\n') goto yy1288; + } else { + if (yych != ' ') goto yy1276; + } +yy1286: + ++p; + yych = *p; + if (yych <= '\n') { + if (yych <= 0x08) goto yy1276; + if (yych <= '\t') goto yy1286; + } else { + if (yych == ' ') goto yy1286; + goto yy1276; + } +yy1288: + ++p; + p = marker; + { return (p - start); } +} + +} + +// Scans an entity. +// Returns number of chars matched. +int _scan_entity(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; + +{ + unsigned char yych; + yych = *p; + if (yych == '\n') goto yy1292; + if (yych == '&') goto yy1293; + goto yy1294; +yy1292: + { return 0; } +yy1293: + yych = *(marker = ++p); + if (yych <= '@') { + if (yych == '#') goto yy1295; + goto yy1292; + } else { + if (yych <= 'Z') goto yy1297; + if (yych <= '`') goto yy1292; + if (yych <= 'z') goto yy1297; + goto yy1292; + } +yy1294: + yych = *++p; + goto yy1292; +yy1295: + yych = *++p; + if (yych <= 'W') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1332; + } else { + if (yych <= 'X') goto yy1331; + if (yych == 'x') goto yy1331; + } +yy1296: + p = marker; + goto yy1292; +yy1297: + yych = *++p; + if (yych <= '@') { + if (yych <= '/') goto yy1296; + if (yych >= ':') goto yy1296; + } else { + if (yych <= 'Z') goto yy1298; + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } +yy1298: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1301; + if (yych <= ':') goto yy1296; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + goto yy1301; + } else { + if (yych <= '`') goto yy1296; + if (yych <= 'z') goto yy1301; + goto yy1296; + } + } +yy1299: + ++p; + { return (p - start); } +yy1301: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1302; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1302: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1303; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1303: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1304; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1304: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1305; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1305: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1306; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1306: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1307; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1307: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1308; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1308: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1309; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1309: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1310; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1310: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1311; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1311: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1312; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1312: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1313; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1313: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1314; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1314: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1315; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1315: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1316; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1316: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1317; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1317: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1318; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1318: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1319; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1319: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1320; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1320: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1321; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1321: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1322; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1322: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1323; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1323: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1324; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1324: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1325; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1325: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1326; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1326: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1327; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1327: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1328; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1328: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1329; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1329: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1330; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1330: + yych = *++p; + if (yych == ';') goto yy1299; + goto yy1296; +yy1331: + yych = *++p; + if (yych <= '@') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1339; + goto yy1296; + } else { + if (yych <= 'F') goto yy1339; + if (yych <= '`') goto yy1296; + if (yych <= 'f') goto yy1339; + goto yy1296; + } +yy1332: + yych = *++p; + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1333; + if (yych == ';') goto yy1299; + goto yy1296; +yy1333: + yych = *++p; + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1334; + if (yych == ';') goto yy1299; + goto yy1296; +yy1334: + yych = *++p; + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1335; + if (yych == ';') goto yy1299; + goto yy1296; +yy1335: + yych = *++p; + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1336; + if (yych == ';') goto yy1299; + goto yy1296; +yy1336: + yych = *++p; + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1337; + if (yych == ';') goto yy1299; + goto yy1296; +yy1337: + yych = *++p; + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1338; + if (yych == ';') goto yy1299; + goto yy1296; +yy1338: + yych = *++p; + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1330; + if (yych == ';') goto yy1299; + goto yy1296; +yy1339: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1340; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'F') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= 'g') goto yy1296; + } + } +yy1340: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1341; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'F') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= 'g') goto yy1296; + } + } +yy1341: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1342; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'F') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= 'g') goto yy1296; + } + } +yy1342: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1343; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'F') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= 'g') goto yy1296; + } + } +yy1343: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1344; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'F') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= 'g') goto yy1296; + } + } +yy1344: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1345; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'F') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= 'g') goto yy1296; + } + } +yy1345: + ++p; + if ((yych = *p) <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1330; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'F') { + if (yych <= '@') goto yy1296; + goto yy1330; + } else { + if (yych <= '`') goto yy1296; + if (yych <= 'f') goto yy1330; + goto yy1296; + } + } +} + +} diff --git a/cbits/scanners.h b/cbits/scanners.h new file mode 100644 --- /dev/null +++ b/cbits/scanners.h @@ -0,0 +1,39 @@ +#include "cmark.h" +#include "chunk.h" + +#ifdef __cplusplus +extern "C" { +#endif + +int _scan_at(int (*scanner)(const unsigned char *), cmark_chunk *c, int offset); +int _scan_autolink_uri(const unsigned char *p); +int _scan_autolink_email(const unsigned char *p); +int _scan_html_tag(const unsigned char *p); +int _scan_html_block_tag(const unsigned char *p); +int _scan_link_url(const unsigned char *p); +int _scan_link_title(const unsigned char *p); +int _scan_spacechars(const unsigned char *p); +int _scan_atx_header_start(const unsigned char *p); +int _scan_setext_header_line(const unsigned char *p); +int _scan_hrule(const unsigned char *p); +int _scan_open_code_fence(const unsigned char *p); +int _scan_close_code_fence(const unsigned char *p); +int _scan_entity(const unsigned char *p); + +#define scan_autolink_uri(c, n) _scan_at(&_scan_autolink_uri, c, n) +#define scan_autolink_email(c, n) _scan_at(&_scan_autolink_email, c, n) +#define scan_html_tag(c, n) _scan_at(&_scan_html_tag, c, n) +#define scan_html_block_tag(c, n) _scan_at(&_scan_html_block_tag, c, n) +#define scan_link_url(c, n) _scan_at(&_scan_link_url, c, n) +#define scan_link_title(c, n) _scan_at(&_scan_link_title, c, n) +#define scan_spacechars(c, n) _scan_at(&_scan_spacechars, c, n) +#define scan_atx_header_start(c, n) _scan_at(&_scan_atx_header_start, c, n) +#define scan_setext_header_line(c, n) _scan_at(&_scan_setext_header_line, c, n) +#define scan_hrule(c, n) _scan_at(&_scan_hrule, c, n) +#define scan_open_code_fence(c, n) _scan_at(&_scan_open_code_fence, c, n) +#define scan_close_code_fence(c, n) _scan_at(&_scan_close_code_fence, c, n) +#define scan_entity(c, n) _scan_at(&_scan_entity, c, n) + +#ifdef __cplusplus +} +#endif diff --git a/cbits/utf8.c b/cbits/utf8.c new file mode 100644 --- /dev/null +++ b/cbits/utf8.c @@ -0,0 +1,453 @@ +#include +#include +#include + +#include "cmark_ctype.h" +#include "utf8.h" + +static const int8_t utf8proc_utf8class[256] = { + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static void encode_unknown(cmark_strbuf *buf) +{ + static const uint8_t repl[] = {239, 191, 189}; + cmark_strbuf_put(buf, repl, 3); +} + +static int utf8proc_charlen(const uint8_t *str, int str_len) +{ + int length, i; + + if (!str_len) + return 0; + + length = utf8proc_utf8class[str[0]]; + + if (!length) + return -1; + + if (str_len >= 0 && length > str_len) + return -str_len; + + for (i = 1; i < length; i++) { + if ((str[i] & 0xC0) != 0x80) + return -i; + } + + return length; +} + +// Validate a single UTF-8 character according to RFC 3629. +static int utf8proc_valid(const uint8_t *str, int str_len) +{ + int length = utf8proc_charlen(str, str_len); + + if (length <= 0) + return length; + + switch (length) { + case 1: + if (str[0] == 0x00) { + // ASCII NUL is technically valid but rejected + // for security reasons. + return -length; + } + break; + + case 2: + if (str[0] < 0xC2) { + // Overlong + return -length; + } + break; + + case 3: + if (str[0] == 0xE0) { + if (str[1] < 0xA0) { + // Overlong + return -length; + } + } else if (str[0] == 0xED) { + if (str[1] >= 0xA0) { + // Surrogate + return -length; + } + } + break; + + case 4: + if (str[0] == 0xF0) { + if (str[1] < 0x90) { + // Overlong + return -length; + } + } else if (str[0] >= 0xF4) { + if (str[0] > 0xF4 || str[1] >= 0x90) { + // Above 0x10FFFF + return -length; + } + } + break; + } + + return length; +} + +void utf8proc_detab(cmark_strbuf *ob, const uint8_t *line, size_t size) +{ + static const uint8_t whitespace[] = " "; + + size_t i = 0, tab = 0; + + while (i < size) { + size_t org = i; + + while (i < size && line[i] != '\t' && line[i] != '\0' + && line[i] < 0x80) { + i++; + tab++; + } + + if (i > org) + cmark_strbuf_put(ob, line + org, i - org); + + if (i >= size) + break; + + if (line[i] == '\t') { + int numspaces = 4 - (tab % 4); + cmark_strbuf_put(ob, whitespace, numspaces); + i += 1; + tab += numspaces; + } else { + int charlen = utf8proc_valid(line + i, size - i); + + if (charlen >= 0) { + cmark_strbuf_put(ob, line + i, charlen); + } else { + encode_unknown(ob); + charlen = -charlen; + } + + i += charlen; + tab += 1; + } + } +} + +int utf8proc_iterate(const uint8_t *str, int str_len, int32_t *dst) +{ + int length; + int32_t uc = -1; + + *dst = -1; + length = utf8proc_charlen(str, str_len); + if (length < 0) + return -1; + + switch (length) { + case 1: + uc = str[0]; + break; + case 2: + uc = ((str[0] & 0x1F) << 6) + (str[1] & 0x3F); + if (uc < 0x80) uc = -1; + break; + case 3: + uc = ((str[0] & 0x0F) << 12) + ((str[1] & 0x3F) << 6) + + (str[2] & 0x3F); + if (uc < 0x800 || (uc >= 0xD800 && uc < 0xE000) || + (uc >= 0xFDD0 && uc < 0xFDF0)) uc = -1; + break; + case 4: + uc = ((str[0] & 0x07) << 18) + ((str[1] & 0x3F) << 12) + + ((str[2] & 0x3F) << 6) + (str[3] & 0x3F); + if (uc < 0x10000 || uc >= 0x110000) uc = -1; + break; + } + + if (uc < 0 || ((uc & 0xFFFF) >= 0xFFFE)) + return -1; + + *dst = uc; + return length; +} + +void utf8proc_encode_char(int32_t uc, cmark_strbuf *buf) +{ + uint8_t dst[4]; + int len = 0; + + assert(uc >= 0); + + if (uc < 0x80) { + dst[0] = uc; + len = 1; + } else if (uc < 0x800) { + dst[0] = 0xC0 + (uc >> 6); + dst[1] = 0x80 + (uc & 0x3F); + len = 2; + } else if (uc == 0xFFFF) { + dst[0] = 0xFF; + len = 1; + } else if (uc == 0xFFFE) { + dst[0] = 0xFE; + len = 1; + } else if (uc < 0x10000) { + dst[0] = 0xE0 + (uc >> 12); + dst[1] = 0x80 + ((uc >> 6) & 0x3F); + dst[2] = 0x80 + (uc & 0x3F); + len = 3; + } else if (uc < 0x110000) { + dst[0] = 0xF0 + (uc >> 18); + dst[1] = 0x80 + ((uc >> 12) & 0x3F); + dst[2] = 0x80 + ((uc >> 6) & 0x3F); + dst[3] = 0x80 + (uc & 0x3F); + len = 4; + } else { + encode_unknown(buf); + return; + } + + cmark_strbuf_put(buf, dst, len); +} + +void utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str, int len) +{ + int32_t c; + +#define bufpush(x) \ + utf8proc_encode_char(x, dest) + + while (len > 0) { + int char_len = utf8proc_iterate(str, len, &c); + + if (char_len >= 0) { +#include "case_fold_switch.inc" + } else { + encode_unknown(dest); + char_len = -char_len; + } + + str += char_len; + len -= char_len; + } +} + +// matches anything in the Zs class, plus LF, CR, TAB, FF. +int utf8proc_is_space(int32_t uc) +{ + return (uc == 9 || + uc == 10 || + uc == 12 || + uc == 13 || + uc == 32 || + uc == 160 || + uc == 5760 || + (uc >= 8192 && uc <= 8202) || + uc == 8239 || + uc == 8287 || + uc == 12288); +} + +// matches anything in the P[cdefios] classes. +int utf8proc_is_punctuation(int32_t uc) +{ + return ((uc < 128 && cmark_ispunct((char)uc)) || + uc == 161 || + uc == 167 || + uc == 171 || + uc == 182 || + uc == 183 || + uc == 187 || + uc == 191 || + uc == 894 || + uc == 903 || + (uc >= 1370 && uc <= 1375) || + uc == 1417 || + uc == 1418 || + uc == 1470 || + uc == 1472 || + uc == 1475 || + uc == 1478 || + uc == 1523 || + uc == 1524 || + uc == 1545 || + uc == 1546 || + uc == 1548 || + uc == 1549 || + uc == 1563 || + uc == 1566 || + uc == 1567 || + (uc >= 1642 && uc <= 1645) || + uc == 1748 || + (uc >= 1792 && uc <= 1805) || + (uc >= 2039 && uc <= 2041) || + (uc >= 2096 && uc <= 2110) || + uc == 2142 || + uc == 2404 || + uc == 2405 || + uc == 2416 || + uc == 2800 || + uc == 3572 || + uc == 3663 || + uc == 3674 || + uc == 3675 || + (uc >= 3844 && uc <= 3858) || + uc == 3860 || + (uc >= 3898 && uc <= 3901) || + uc == 3973 || + (uc >= 4048 && uc <= 4052) || + uc == 4057 || + uc == 4058 || + (uc >= 4170 && uc <= 4175) || + uc == 4347 || + (uc >= 4960 && uc <= 4968) || + uc == 5120 || + uc == 5741 || + uc == 5742 || + uc == 5787 || + uc == 5788 || + (uc >= 5867 && uc <= 5869) || + uc == 5941 || + uc == 5942 || + (uc >= 6100 && uc <= 6102) || + (uc >= 6104 && uc <= 6106) || + (uc >= 6144 && uc <= 6154) || + uc == 6468 || + uc == 6469 || + uc == 6686 || + uc == 6687 || + (uc >= 6816 && uc <= 6822) || + (uc >= 6824 && uc <= 6829) || + (uc >= 7002 && uc <= 7008) || + (uc >= 7164 && uc <= 7167) || + (uc >= 7227 && uc <= 7231) || + uc == 7294 || + uc == 7295 || + (uc >= 7360 && uc <= 7367) || + uc == 7379 || + (uc >= 8208 && uc <= 8231) || + (uc >= 8240 && uc <= 8259) || + (uc >= 8261 && uc <= 8273) || + (uc >= 8275 && uc <= 8286) || + uc == 8317 || + uc == 8318 || + uc == 8333 || + uc == 8334 || + (uc >= 8968 && uc <= 8971) || + uc == 9001 || + uc == 9002 || + (uc >= 10088 && uc <= 10101) || + uc == 10181 || + uc == 10182 || + (uc >= 10214 && uc <= 10223) || + (uc >= 10627 && uc <= 10648) || + (uc >= 10712 && uc <= 10715) || + uc == 10748 || + uc == 10749 || + (uc >= 11513 && uc <= 11516) || + uc == 11518 || + uc == 11519 || + uc == 11632 || + (uc >= 11776 && uc <= 11822) || + (uc >= 11824 && uc <= 11842) || + (uc >= 12289 && uc <= 12291) || + (uc >= 12296 && uc <= 12305) || + (uc >= 12308 && uc <= 12319) || + uc == 12336 || + uc == 12349 || + uc == 12448 || + uc == 12539 || + uc == 42238 || + uc == 42239 || + (uc >= 42509 && uc <= 42511) || + uc == 42611 || + uc == 42622 || + (uc >= 42738 && uc <= 42743) || + (uc >= 43124 && uc <= 43127) || + uc == 43214 || + uc == 43215 || + (uc >= 43256 && uc <= 43258) || + uc == 43310 || + uc == 43311 || + uc == 43359 || + (uc >= 43457 && uc <= 43469) || + uc == 43486 || + uc == 43487 || + (uc >= 43612 && uc <= 43615) || + uc == 43742 || + uc == 43743 || + uc == 43760 || + uc == 43761 || + uc == 44011 || + uc == 64830 || + uc == 64831 || + (uc >= 65040 && uc <= 65049) || + (uc >= 65072 && uc <= 65106) || + (uc >= 65108 && uc <= 65121) || + uc == 65123 || + uc == 65128 || + uc == 65130 || + uc == 65131 || + (uc >= 65281 && uc <= 65283) || + (uc >= 65285 && uc <= 65290) || + (uc >= 65292 && uc <= 65295) || + uc == 65306 || + uc == 65307 || + uc == 65311 || + uc == 65312 || + (uc >= 65339 && uc <= 65341) || + uc == 65343 || + uc == 65371 || + uc == 65373 || + (uc >= 65375 && uc <= 65381) || + (uc >= 65792 && uc <= 65794) || + uc == 66463 || + uc == 66512 || + uc == 66927 || + uc == 67671 || + uc == 67871 || + uc == 67903 || + (uc >= 68176 && uc <= 68184) || + uc == 68223 || + (uc >= 68336 && uc <= 68342) || + (uc >= 68409 && uc <= 68415) || + (uc >= 68505 && uc <= 68508) || + (uc >= 69703 && uc <= 69709) || + uc == 69819 || + uc == 69820 || + (uc >= 69822 && uc <= 69825) || + (uc >= 69952 && uc <= 69955) || + uc == 70004 || + uc == 70005 || + (uc >= 70085 && uc <= 70088) || + uc == 70093 || + (uc >= 70200 && uc <= 70205) || + uc == 70854 || + (uc >= 71105 && uc <= 71113) || + (uc >= 71233 && uc <= 71235) || + (uc >= 74864 && uc <= 74868) || + uc == 92782 || + uc == 92783 || + uc == 92917 || + (uc >= 92983 && uc <= 92987) || + uc == 92996 || + uc == 113823); +} diff --git a/cbits/utf8.h b/cbits/utf8.h new file mode 100644 --- /dev/null +++ b/cbits/utf8.h @@ -0,0 +1,22 @@ +#ifndef CMARK_UTF8_H +#define CMARK_UTF8_H + +#include +#include "buffer.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str, int len); +void utf8proc_encode_char(int32_t uc, cmark_strbuf *buf); +int utf8proc_iterate(const uint8_t *str, int str_len, int32_t *dst); +void utf8proc_detab(cmark_strbuf *dest, const uint8_t *line, size_t size); +int utf8proc_is_space(int32_t uc); +int utf8proc_is_punctuation(int32_t uc); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/cbits/xml.c b/cbits/xml.c new file mode 100644 --- /dev/null +++ b/cbits/xml.c @@ -0,0 +1,170 @@ +#include +#include +#include +#include + +#include "config.h" +#include "cmark.h" +#include "node.h" +#include "buffer.h" +#include "houdini.h" + +// Functions to convert cmark_nodes to XML strings. + +static void escape_xml(cmark_strbuf *dest, const unsigned char *source, int length) +{ + if (source != NULL) { + if (length < 0) + length = strlen((char *)source); + + houdini_escape_html0(dest, source, (size_t)length, 0); + } +} + +struct render_state { + cmark_strbuf* xml; + int indent; +}; + +static inline void indent(struct render_state *state) +{ + int i; + for (i = 0; i < state->indent; i++) { + cmark_strbuf_putc(state->xml, ' '); + } +} + +static int +S_render_node(cmark_node *node, cmark_event_type ev_type, + struct render_state *state, int options) +{ + cmark_strbuf *xml = state->xml; + bool literal = false; + cmark_delim_type delim; + bool entering = (ev_type == CMARK_EVENT_ENTER); + + if (entering) { + indent(state); + cmark_strbuf_printf(xml, "<%s", + cmark_node_get_type_string(node)); + + if (options & CMARK_OPT_SOURCEPOS && node->start_line != 0) { + cmark_strbuf_printf(xml, " sourcepos=\"%d:%d-%d:%d\"", + node->start_line, + node->start_column, + node->end_line, + node->end_column); + } + + literal = false; + + switch (node->type) { + case CMARK_NODE_TEXT: + case CMARK_NODE_CODE: + case CMARK_NODE_HTML: + case CMARK_NODE_INLINE_HTML: + cmark_strbuf_puts(xml, ">"); + escape_xml(xml, node->as.literal.data, + node->as.literal.len); + cmark_strbuf_puts(xml, "as.header.level); + break; + case CMARK_NODE_CODE_BLOCK: + if (node->as.code.info.len > 0) { + cmark_strbuf_puts(xml, " info=\""); + escape_xml(xml, node->as.code.info.data, + node->as.code.info.len); + cmark_strbuf_putc(xml, '"'); + } + cmark_strbuf_puts(xml, ">"); + escape_xml(xml, node->as.code.literal.data, + node->as.code.literal.len); + cmark_strbuf_puts(xml, "as.link.url, -1); + cmark_strbuf_putc(xml, '"'); + cmark_strbuf_puts(xml, " title=\""); + escape_xml(xml, node->as.link.title, -1); + cmark_strbuf_putc(xml, '"'); + break; + default: + break; + } + if (node->first_child) { + state->indent += 2; + } else if (!literal) { + cmark_strbuf_puts(xml, " /"); + } + cmark_strbuf_puts(xml, ">\n"); + + + } else if (node->first_child) { + state->indent -= 2; + indent(state); + cmark_strbuf_printf(xml, "\n", + cmark_node_get_type_string(node)); + } + + return 1; +} + +char *cmark_render_xml(cmark_node *root, int options) +{ + char *result; + cmark_strbuf xml = GH_BUF_INIT; + cmark_event_type ev_type; + cmark_node *cur; + struct render_state state = { &xml, 0 }; + + cmark_iter *iter = cmark_iter_new(root); + + cmark_strbuf_puts(state.xml, + "\n"); + cmark_strbuf_puts(state.xml, + "\n"); + while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { + cur = cmark_iter_get_node(iter); + S_render_node(cur, ev_type, &state, options); + } + result = (char *)cmark_strbuf_detach(&xml); + + cmark_iter_free(iter); + return result; +} diff --git a/cmark.cabal b/cmark.cabal --- a/cmark.cabal +++ b/cmark.cabal @@ -1,5 +1,5 @@ name: cmark -version: 0.2 +version: 0.2.0.1 synopsis: Fast, accurate CommonMark (Markdown) parser and renderer description: This package provides Haskell bindings for @@ -90,25 +90,25 @@ tested-with: GHC == 7.4.2, GHC == 7.6.3, GHC == 7.8.2 build-type: Simple extra-source-files: README.md - cmark/bench.h - cmark/chunk.h - cmark/cmark_export.h - cmark/debug.h - cmark/inlines.h - cmark/cmark.h - cmark/houdini.h - cmark/references.h - cmark/utf8.h - cmark/parser.h - cmark/cmark_version.h - cmark/html_unescape.h - cmark/iterator.h - cmark/node.h - cmark/buffer.h - cmark/cmark_ctype.h - cmark/config.h - cmark/scanners.h - cmark/case_fold_switch.inc + cbits/bench.h + cbits/chunk.h + cbits/cmark_export.h + cbits/debug.h + cbits/inlines.h + cbits/cmark.h + cbits/houdini.h + cbits/references.h + cbits/utf8.h + cbits/parser.h + cbits/cmark_version.h + cbits/html_unescape.h + cbits/iterator.h + cbits/node.h + cbits/buffer.h + cbits/cmark_ctype.h + cbits/config.h + cbits/scanners.h + cbits/case_fold_switch.inc bench/sample.md bench/full-sample.md cabal-version: >=1.14 @@ -124,25 +124,24 @@ build-depends: ghc-prim >= 0.2 default-language: Haskell2010 ghc-options: -Wall - Include-dirs: cmark + Include-dirs: cbits Includes: cmark.h - c-sources: cmark/houdini_html_u.c - cmark/man.c - cmark/references.c - cmark/utf8.c - cmark/blocks.c - cmark/cmark.c - cmark/html.c - cmark/iterator.c - cmark/node.c - cmark/buffer.c - cmark/cmark_ctype.c - cmark/houdini_href_e.c - cmark/scanners.c - cmark/xml.c - cmark/houdini_html_e.c - cmark/inlines.c - cmark/main.c + c-sources: cbits/houdini_html_u.c + cbits/man.c + cbits/references.c + cbits/utf8.c + cbits/blocks.c + cbits/cmark.c + cbits/html.c + cbits/iterator.c + cbits/node.c + cbits/buffer.c + cbits/cmark_ctype.c + cbits/houdini_href_e.c + cbits/scanners.c + cbits/xml.c + cbits/houdini_html_e.c + cbits/inlines.c benchmark bench-cmark type: exitcode-stdio-1.0 diff --git a/cmark/bench.h b/cmark/bench.h deleted file mode 100644 --- a/cmark/bench.h +++ /dev/null @@ -1,27 +0,0 @@ -#ifndef CMARK_BENCH_H -#define CMARK_BENCH_H - -#include -#include - -#ifdef TIMER -float _cmark_start_time; -float _cmark_end_time; -float _cmark_save_time; - -#define start_timer() \ - _cmark_save_time = _cmark_start_time; \ - _cmark_start_time = (float)clock()/CLOCKS_PER_SEC - -#define end_timer(M) \ - _cmark_end_time = (float)clock()/CLOCKS_PER_SEC; \ - fprintf(stderr, "[TIME] (%s:%d) %4.f ns " M "\n", __FILE__, \ - __LINE__, (_cmark_end_time - _cmark_start_time) * 1000000); \ - _cmark_start_time = _cmark_save_time; - -#else -#define start_timer() -#define end_timer(M) -#endif - -#endif diff --git a/cmark/blocks.c b/cmark/blocks.c deleted file mode 100644 --- a/cmark/blocks.c +++ /dev/null @@ -1,887 +0,0 @@ -#include -#include -#include - -#include "cmark_ctype.h" -#include "config.h" -#include "parser.h" -#include "cmark.h" -#include "node.h" -#include "references.h" -#include "utf8.h" -#include "scanners.h" -#include "inlines.h" -#include "houdini.h" -#include "buffer.h" -#include "debug.h" - -#define CODE_INDENT 4 -#define peek_at(i, n) (i)->data[n] - -static void -S_parser_feed(cmark_parser *parser, const unsigned char *buffer, size_t len, - bool eof); - -static void -S_process_line(cmark_parser *parser, const unsigned char *buffer, - size_t bytes); - -static cmark_node* make_block(cmark_node_type tag, int start_line, int start_column) -{ - cmark_node* e; - - e = (cmark_node *)calloc(1, sizeof(*e)); - if(e != NULL) { - e->type = tag; - e->open = true; - e->start_line = start_line; - e->start_column = start_column; - e->end_line = start_line; - cmark_strbuf_init(&e->string_content, 32); - } - - return e; -} - -// Create a root document node. -static cmark_node* make_document() -{ - cmark_node *e = make_block(NODE_DOCUMENT, 1, 1); - return e; -} - -cmark_parser *cmark_parser_new(int options) -{ - cmark_parser *parser = (cmark_parser*)malloc(sizeof(cmark_parser)); - cmark_node *document = make_document(); - cmark_strbuf *line = (cmark_strbuf*)malloc(sizeof(cmark_strbuf)); - cmark_strbuf *buf = (cmark_strbuf*)malloc(sizeof(cmark_strbuf)); - cmark_strbuf_init(line, 256); - cmark_strbuf_init(buf, 0); - - parser->refmap = cmark_reference_map_new(); - parser->root = document; - parser->current = document; - parser->line_number = 0; - parser->curline = line; - parser->last_line_length = 0; - parser->linebuf = buf; - parser->options = options; - - return parser; -} - -void cmark_parser_free(cmark_parser *parser) -{ - cmark_strbuf_free(parser->curline); - free(parser->curline); - cmark_strbuf_free(parser->linebuf); - free(parser->linebuf); - cmark_reference_map_free(parser->refmap); - free(parser); -} - -static cmark_node* -finalize(cmark_parser *parser, cmark_node* b); - -// Returns true if line has only space characters, else false. -static bool is_blank(cmark_strbuf *s, int offset) -{ - while (offset < s->size) { - switch (s->ptr[offset]) { - case '\n': - return true; - case ' ': - offset++; - break; - default: - return false; - } - } - - return true; -} - -static inline bool can_contain(cmark_node_type parent_type, cmark_node_type child_type) -{ - return ( parent_type == NODE_DOCUMENT || - parent_type == NODE_BLOCK_QUOTE || - parent_type == NODE_ITEM || - (parent_type == NODE_LIST && child_type == NODE_ITEM) ); -} - -static inline bool accepts_lines(cmark_node_type block_type) -{ - return (block_type == NODE_PARAGRAPH || - block_type == NODE_HEADER || - block_type == NODE_CODE_BLOCK); -} - -static void add_line(cmark_node* node, cmark_chunk *ch, int offset) -{ - assert(node->open); - cmark_strbuf_put(&node->string_content, ch->data + offset, ch->len - offset); -} - -static void remove_trailing_blank_lines(cmark_strbuf *ln) -{ - int i; - - for (i = ln->size - 1; i >= 0; --i) { - unsigned char c = ln->ptr[i]; - - if (c != ' ' && c != '\t' && c != '\r' && c != '\n') - break; - } - - if (i < 0) { - cmark_strbuf_clear(ln); - return; - } - - i = cmark_strbuf_strchr(ln, '\n', i); - if (i >= 0) - cmark_strbuf_truncate(ln, i); -} - -// Check to see if a node ends with a blank line, descending -// if needed into lists and sublists. -static bool ends_with_blank_line(cmark_node* node) -{ - cmark_node *cur = node; - while (cur != NULL) { - if (cur->last_line_blank) { - return true; - } - if (cur->type == NODE_LIST || cur->type == NODE_ITEM) { - cur = cur->last_child; - } else { - cur = NULL; - } - } - return false; -} - -// Break out of all containing lists -static int break_out_of_lists(cmark_parser *parser, cmark_node ** bptr) -{ - cmark_node *container = *bptr; - cmark_node *b = parser->root; - // find first containing NODE_LIST: - while (b && b->type != NODE_LIST) { - b = b->last_child; - } - if (b) { - while (container && container != b) { - container = finalize(parser, container); - } - finalize(parser, b); - *bptr = b->parent; - } - return 0; -} - - -static cmark_node* -finalize(cmark_parser *parser, cmark_node* b) -{ - int firstlinelen; - int pos; - cmark_node* item; - cmark_node* subitem; - cmark_node* parent; - - parent = b->parent; - - assert(b->open); // shouldn't call finalize on closed blocks - b->open = false; - - if (parser->curline->size == 0) { - // end of input - line number has not been incremented - b->end_line = parser->line_number; - b->end_column = parser->last_line_length; - } else if (b->type == NODE_DOCUMENT || - (b->type == NODE_CODE_BLOCK && b->as.code.fenced) || - (b->type == NODE_HEADER && b->as.header.setext)) { - b->end_line = parser->line_number; - b->end_column = parser->curline->size - - (parser->curline->ptr[parser->curline->size - 1] == '\n' ? - 1 : 0); - } else { - b->end_line = parser->line_number - 1; - b->end_column = parser->last_line_length; - } - - switch (b->type) { - case NODE_PARAGRAPH: - while (cmark_strbuf_at(&b->string_content, 0) == '[' && - (pos = cmark_parse_reference_inline(&b->string_content, parser->refmap))) { - - cmark_strbuf_drop(&b->string_content, pos); - } - if (is_blank(&b->string_content, 0)) { - // remove blank node (former reference def) - cmark_node_free(b); - } - break; - - case NODE_CODE_BLOCK: - if (!b->as.code.fenced) { // indented code - remove_trailing_blank_lines(&b->string_content); - cmark_strbuf_putc(&b->string_content, '\n'); - } else { - - // first line of contents becomes info - firstlinelen = cmark_strbuf_strchr(&b->string_content, '\n', 0); - - cmark_strbuf tmp = GH_BUF_INIT; - houdini_unescape_html_f( - &tmp, - b->string_content.ptr, - firstlinelen - ); - cmark_strbuf_trim(&tmp); - cmark_strbuf_unescape(&tmp); - b->as.code.info = cmark_chunk_buf_detach(&tmp); - - cmark_strbuf_drop(&b->string_content, firstlinelen + 1); - } - b->as.code.literal = cmark_chunk_buf_detach(&b->string_content); - break; - - case NODE_HTML: - b->as.literal = cmark_chunk_buf_detach(&b->string_content); - break; - - case NODE_LIST: // determine tight/loose status - b->as.list.tight = true; // tight by default - item = b->first_child; - - while (item) { - // check for non-final non-empty list item ending with blank line: - if (item->last_line_blank && item->next) { - b->as.list.tight = false; - break; - } - // recurse into children of list item, to see if there are - // spaces between them: - subitem = item->first_child; - while (subitem) { - if (ends_with_blank_line(subitem) && - (item->next || subitem->next)) { - b->as.list.tight = false; - break; - } - subitem = subitem->next; - } - if (!(b->as.list.tight)) { - break; - } - item = item->next; - } - - break; - - default: - break; - } - return parent; -} - -// Add a node as child of another. Return pointer to child. -static cmark_node* add_child(cmark_parser *parser, cmark_node* parent, - cmark_node_type block_type, int start_column) -{ - assert(parent); - - // if 'parent' isn't the kind of node that can accept this child, - // then back up til we hit a node that can. - while (!can_contain(parent->type, block_type)) { - parent = finalize(parser, parent); - } - - cmark_node* child = make_block(block_type, parser->line_number, start_column); - child->parent = parent; - - if (parent->last_child) { - parent->last_child->next = child; - child->prev = parent->last_child; - } else { - parent->first_child = child; - child->prev = NULL; - } - parent->last_child = child; - return child; -} - - -// Walk through node and all children, recursively, parsing -// string content into inline content where appropriate. -static void process_inlines(cmark_node* root, cmark_reference_map *refmap, int options) -{ - cmark_iter *iter = cmark_iter_new(root); - cmark_node *cur; - cmark_event_type ev_type; - - while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { - cur = cmark_iter_get_node(iter); - if (ev_type == CMARK_EVENT_ENTER) { - if (cur->type == NODE_PARAGRAPH || - cur->type == NODE_HEADER) { - cmark_parse_inlines(cur, refmap, options); - } - } - } - - cmark_iter_free(iter); -} - -// Attempts to parse a list item marker (bullet or enumerated). -// On success, returns length of the marker, and populates -// data with the details. On failure, returns 0. -static int parse_list_marker(cmark_chunk *input, int pos, cmark_list **dataptr) -{ - unsigned char c; - int startpos; - cmark_list *data; - - startpos = pos; - c = peek_at(input, pos); - - if ((c == '*' || c == '-' || c == '+') && !scan_hrule(input, pos)) { - pos++; - if (!cmark_isspace(peek_at(input, pos))) { - return 0; - } - data = (cmark_list *)calloc(1, sizeof(*data)); - if(data == NULL) { - return 0; - } else { - data->marker_offset = 0; // will be adjusted later - data->list_type = CMARK_BULLET_LIST; - data->bullet_char = c; - data->start = 1; - data->delimiter = CMARK_PERIOD_DELIM; - data->tight = false; - } - } else if (cmark_isdigit(c)) { - int start = 0; - - do { - start = (10 * start) + (peek_at(input, pos) - '0'); - pos++; - } while (cmark_isdigit(peek_at(input, pos))); - - c = peek_at(input, pos); - if (c == '.' || c == ')') { - pos++; - if (!cmark_isspace(peek_at(input, pos))) { - return 0; - } - data = (cmark_list *)calloc(1, sizeof(*data)); - if(data == NULL) { - return 0; - } else { - data->marker_offset = 0; // will be adjusted later - data->list_type = CMARK_ORDERED_LIST; - data->bullet_char = 0; - data->start = start; - data->delimiter = (c == '.' ? CMARK_PERIOD_DELIM : CMARK_PAREN_DELIM); - data->tight = false; - } - } else { - return 0; - } - - } else { - return 0; - } - - *dataptr = data; - return (pos - startpos); -} - -// Return 1 if list item belongs in list, else 0. -static int lists_match(cmark_list *list_data, cmark_list *item_data) -{ - return (list_data->list_type == item_data->list_type && - list_data->delimiter == item_data->delimiter && - // list_data->marker_offset == item_data.marker_offset && - list_data->bullet_char == item_data->bullet_char); -} - -static cmark_node *finalize_document(cmark_parser *parser) -{ - while (parser->current != parser->root) { - parser->current = finalize(parser, parser->current); - } - - finalize(parser, parser->root); - process_inlines(parser->root, parser->refmap, parser->options); - - return parser->root; -} - -cmark_node *cmark_parse_file(FILE *f, int options) -{ - unsigned char buffer[4096]; - cmark_parser *parser = cmark_parser_new(options); - size_t bytes; - cmark_node *document; - - while ((bytes = fread(buffer, 1, sizeof(buffer), f)) > 0) { - bool eof = bytes < sizeof(buffer); - S_parser_feed(parser, buffer, bytes, eof); - if (eof) { - break; - } - } - - document = cmark_parser_finish(parser); - cmark_parser_free(parser); - return document; -} - -cmark_node *cmark_parse_document(const char *buffer, size_t len, int options) -{ - cmark_parser *parser = cmark_parser_new(options); - cmark_node *document; - - S_parser_feed(parser, (const unsigned char *)buffer, len, true); - - document = cmark_parser_finish(parser); - cmark_parser_free(parser); - return document; -} - -void -cmark_parser_feed(cmark_parser *parser, const char *buffer, size_t len) -{ - S_parser_feed(parser, (const unsigned char *)buffer, len, false); -} - -static void -S_parser_feed(cmark_parser *parser, const unsigned char *buffer, size_t len, - bool eof) -{ - const unsigned char *end = buffer + len; - - while (buffer < end) { - const unsigned char *eol - = (const unsigned char *)memchr(buffer, '\n', - end - buffer); - size_t line_len; - - if (eol) { - line_len = eol + 1 - buffer; - } else if (eof) { - line_len = end - buffer; - } else { - cmark_strbuf_put(parser->linebuf, buffer, end - buffer); - break; - } - - if (parser->linebuf->size > 0) { - cmark_strbuf_put(parser->linebuf, buffer, line_len); - S_process_line(parser, parser->linebuf->ptr, - parser->linebuf->size); - cmark_strbuf_clear(parser->linebuf); - } else { - S_process_line(parser, buffer, line_len); - } - - buffer += line_len; - } -} - -static void chop_trailing_hashtags(cmark_chunk *ch) -{ - int n, orig_n; - - cmark_chunk_rtrim(ch); - orig_n = n = ch->len - 1; - - // if string ends in space followed by #s, remove these: - while (n >= 0 && peek_at(ch, n) == '#') - n--; - - // Check for a be a space before the final #s: - if (n != orig_n && n >= 0 && peek_at(ch, n) == ' ') { - ch->len = n; - cmark_chunk_rtrim(ch); - } -} - -static void -S_process_line(cmark_parser *parser, const unsigned char *buffer, size_t bytes) -{ - cmark_node* last_matched_container; - int offset = 0; - int matched = 0; - int lev = 0; - int i; - cmark_list *data = NULL; - bool all_matched = true; - cmark_node* container; - bool blank = false; - int first_nonspace; - int indent; - cmark_chunk input; - bool maybe_lazy; - - utf8proc_detab(parser->curline, buffer, bytes); - - // Add a newline to the end if not present: - // TODO this breaks abstraction: - if (parser->curline->ptr[parser->curline->size - 1] != '\n') { - cmark_strbuf_putc(parser->curline, '\n'); - } - input.data = parser->curline->ptr; - input.len = parser->curline->size; - - // container starts at the document root. - container = parser->root; - - parser->line_number++; - - // for each containing node, try to parse the associated line start. - // bail out on failure: container will point to the last matching node. - - while (container->last_child && container->last_child->open) { - container = container->last_child; - - first_nonspace = offset; - while (peek_at(&input, first_nonspace) == ' ') { - first_nonspace++; - } - - indent = first_nonspace - offset; - blank = peek_at(&input, first_nonspace) == '\n'; - - if (container->type == NODE_BLOCK_QUOTE) { - matched = indent <= 3 && peek_at(&input, first_nonspace) == '>'; - if (matched) { - offset = first_nonspace + 1; - if (peek_at(&input, offset) == ' ') - offset++; - } else { - all_matched = false; - } - - } else if (container->type == NODE_ITEM) { - - if (indent >= container->as.list.marker_offset + - container->as.list.padding) { - offset += container->as.list.marker_offset + - container->as.list.padding; - } else if (blank) { - offset = first_nonspace; - } else { - all_matched = false; - } - - } else if (container->type == NODE_CODE_BLOCK) { - - if (!container->as.code.fenced) { // indented - if (indent >= CODE_INDENT) { - offset += CODE_INDENT; - } else if (blank) { - offset = first_nonspace; - } else { - all_matched = false; - } - } else { // fenced - matched = 0; - if (indent <= 3 && - (peek_at(&input, first_nonspace) == - container->as.code.fence_char)) { - matched = scan_close_code_fence(&input, - first_nonspace); - } - if (matched >= container->as.code.fence_length) { - // closing fence - and since we're at - // the end of a line, we can return: - all_matched = false; - offset += matched; - parser->current = finalize(parser, container); - goto finished; - } else { - // skip opt. spaces of fence offset - i = container->as.code.fence_offset; - while (i > 0 && - peek_at(&input, offset) == ' ') { - offset++; - i--; - } - } - } - } else if (container->type == NODE_HEADER) { - - // a header can never contain more than one line - all_matched = false; - - } else if (container->type == NODE_HTML) { - - if (blank) { - all_matched = false; - } - - } else if (container->type == NODE_PARAGRAPH) { - - if (blank) { - all_matched = false; - } - - } - - if (!all_matched) { - container = container->parent; // back up to last matching node - break; - } - } - - last_matched_container = container; - - // check to see if we've hit 2nd blank line, break out of list: - if (blank && container->last_line_blank) { - break_out_of_lists(parser, &container); - } - - maybe_lazy = parser->current->type == NODE_PARAGRAPH; - // try new container starts: - while (container->type != NODE_CODE_BLOCK && - container->type != NODE_HTML) { - - first_nonspace = offset; - while (peek_at(&input, first_nonspace) == ' ') - first_nonspace++; - - indent = first_nonspace - offset; - blank = peek_at(&input, first_nonspace) == '\n'; - - if (indent >= CODE_INDENT) { - if (!maybe_lazy && !blank) { - offset += CODE_INDENT; - container = add_child(parser, container, NODE_CODE_BLOCK, offset + 1); - container->as.code.fenced = false; - container->as.code.fence_char = 0; - container->as.code.fence_length = 0; - container->as.code.fence_offset = 0; - container->as.code.info = cmark_chunk_literal(""); - } else { // indent > 4 in lazy line - break; - } - - } else if (peek_at(&input, first_nonspace) == '>') { - - offset = first_nonspace + 1; - // optional following character - if (peek_at(&input, offset) == ' ') - offset++; - container = add_child(parser, container, NODE_BLOCK_QUOTE, offset + 1); - - } else if ((matched = scan_atx_header_start(&input, first_nonspace))) { - - offset = first_nonspace + matched; - container = add_child(parser, container, NODE_HEADER, offset + 1); - - int hashpos = cmark_chunk_strchr(&input, '#', first_nonspace); - int level = 0; - - while (peek_at(&input, hashpos) == '#') { - level++; - hashpos++; - } - container->as.header.level = level; - container->as.header.setext = false; - - } else if ((matched = scan_open_code_fence(&input, first_nonspace))) { - - container = add_child(parser, container, NODE_CODE_BLOCK, first_nonspace + 1); - container->as.code.fenced = true; - container->as.code.fence_char = peek_at(&input, first_nonspace); - container->as.code.fence_length = matched; - container->as.code.fence_offset = first_nonspace - offset; - container->as.code.info = cmark_chunk_literal(""); - offset = first_nonspace + matched; - - } else if ((matched = scan_html_block_tag(&input, first_nonspace))) { - - container = add_child(parser, container, NODE_HTML, first_nonspace + 1); - // note, we don't adjust offset because the tag is part of the text - - } else if (container->type == NODE_PARAGRAPH && - (lev = scan_setext_header_line(&input, first_nonspace)) && - // check that there is only one line in the paragraph: - cmark_strbuf_strrchr(&container->string_content, '\n', - cmark_strbuf_len(&container->string_content) - 2) < 0) { - - container->type = NODE_HEADER; - container->as.header.level = lev; - container->as.header.setext = true; - offset = input.len - 1; - - } else if (!(container->type == NODE_PARAGRAPH && !all_matched) && - (matched = scan_hrule(&input, first_nonspace))) { - - // it's only now that we know the line is not part of a setext header: - container = add_child(parser, container, NODE_HRULE, first_nonspace + 1); - container = finalize(parser, container); - offset = input.len - 1; - - } else if ((matched = parse_list_marker(&input, first_nonspace, &data))) { - - // compute padding: - offset = first_nonspace + matched; - i = 0; - while (i <= 5 && peek_at(&input, offset + i) == ' ') { - i++; - } - // i = number of spaces after marker, up to 5 - if (i >= 5 || i < 1 || peek_at(&input, offset) == '\n') { - data->padding = matched + 1; - if (i > 0) { - offset += 1; - } - } else { - data->padding = matched + i; - offset += i; - } - - // check container; if it's a list, see if this list item - // can continue the list; otherwise, create a list container. - - data->marker_offset = indent; - - if (container->type != NODE_LIST || - !lists_match(&container->as.list, data)) { - container = add_child(parser, container, NODE_LIST, - first_nonspace + 1); - - memcpy(&container->as.list, data, sizeof(*data)); - } - - // add the list item - container = add_child(parser, container, NODE_ITEM, - first_nonspace + 1); - /* TODO: static */ - memcpy(&container->as.list, data, sizeof(*data)); - free(data); - } else { - break; - } - - if (accepts_lines(container->type)) { - // if it's a line container, it can't contain other containers - break; - } - maybe_lazy = false; - } - - // what remains at offset is a text line. add the text to the - // appropriate container. - - first_nonspace = offset; - while (peek_at(&input, first_nonspace) == ' ') - first_nonspace++; - - indent = first_nonspace - offset; - blank = peek_at(&input, first_nonspace) == '\n'; - - if (blank && container->last_child) { - container->last_child->last_line_blank = true; - } - - // block quote lines are never blank as they start with > - // and we don't count blanks in fenced code for purposes of tight/loose - // lists or breaking out of lists. we also don't set last_line_blank - // on an empty list item. - container->last_line_blank = (blank && - container->type != NODE_BLOCK_QUOTE && - container->type != NODE_HEADER && - !(container->type == NODE_CODE_BLOCK && - container->as.code.fenced) && - !(container->type == NODE_ITEM && - container->first_child == NULL && - container->start_line == parser->line_number)); - - cmark_node *cont = container; - while (cont->parent) { - cont->parent->last_line_blank = false; - cont = cont->parent; - } - - if (parser->current != last_matched_container && - container == last_matched_container && - !blank && - parser->current->type == NODE_PARAGRAPH && - cmark_strbuf_len(&parser->current->string_content) > 0) { - - add_line(parser->current, &input, offset); - - } else { // not a lazy continuation - - // finalize any blocks that were not matched and set cur to container: - while (parser->current != last_matched_container) { - parser->current = finalize(parser, parser->current); - assert(parser->current != NULL); - } - - if (container->type == NODE_CODE_BLOCK || - container->type == NODE_HTML) { - - add_line(container, &input, offset); - - } else if (blank) { - - // ??? do nothing - - } else if (accepts_lines(container->type)) { - - if (container->type == NODE_HEADER && - container->as.header.setext == false) { - chop_trailing_hashtags(&input); - } - add_line(container, &input, first_nonspace); - - } else { - // create paragraph container for line - container = add_child(parser, container, NODE_PARAGRAPH, first_nonspace + 1); - add_line(container, &input, first_nonspace); - - } - - parser->current = container; - } -finished: - parser->last_line_length = parser->curline->size - - (parser->curline->ptr[parser->curline->size - 1] == '\n' ? - 1 : 0); - ; - cmark_strbuf_clear(parser->curline); - -} - -cmark_node *cmark_parser_finish(cmark_parser *parser) -{ - if (parser->linebuf->size) { - S_process_line(parser, parser->linebuf->ptr, - parser->linebuf->size); - cmark_strbuf_clear(parser->linebuf); - } - - finalize_document(parser); - - if (parser->options & CMARK_OPT_NORMALIZE) { - cmark_consolidate_text_nodes(parser->root); - } - - cmark_strbuf_free(parser->curline); - -#if CMARK_DEBUG_NODES - if (cmark_node_check(parser->root, stderr)) { - abort(); - } -#endif - return parser->root; -} diff --git a/cmark/buffer.c b/cmark/buffer.c deleted file mode 100644 --- a/cmark/buffer.c +++ /dev/null @@ -1,381 +0,0 @@ -#include -#include -#include -#include -#include -#include - -#include "config.h" -#include "cmark_ctype.h" -#include "buffer.h" - -/* Used as default value for cmark_strbuf->ptr so that people can always - * assume ptr is non-NULL and zero terminated even for new cmark_strbufs. - */ -unsigned char cmark_strbuf__initbuf[1]; -unsigned char cmark_strbuf__oom[1]; - -#define ENSURE_SIZE(b, d) \ - if ((d) > buf->asize && cmark_strbuf_grow(b, (d)) < 0) \ - return -1; - -#ifndef MIN -#define MIN(x,y) ((xasize = 0; - buf->size = 0; - buf->ptr = cmark_strbuf__initbuf; - - if (initial_size) - cmark_strbuf_grow(buf, initial_size); -} - -int cmark_strbuf_try_grow(cmark_strbuf *buf, int target_size, bool mark_oom) -{ - unsigned char *new_ptr; - int new_size; - - if (buf->ptr == cmark_strbuf__oom) - return -1; - - if (target_size <= buf->asize) - return 0; - - if (buf->asize == 0) { - new_size = target_size; - new_ptr = NULL; - } else { - new_size = buf->asize; - new_ptr = buf->ptr; - } - - /* grow the buffer size by 1.5, until it's big enough - * to fit our target size */ - while (new_size < target_size) - new_size = (new_size << 1) - (new_size >> 1); - - /* round allocation up to multiple of 8 */ - new_size = (new_size + 7) & ~7; - - new_ptr = (unsigned char *)realloc(new_ptr, new_size); - - if (!new_ptr) { - if (mark_oom) - buf->ptr = cmark_strbuf__oom; - return -1; - } - - buf->asize = new_size; - buf->ptr = new_ptr; - - /* truncate the existing buffer size if necessary */ - if (buf->size >= buf->asize) - buf->size = buf->asize - 1; - buf->ptr[buf->size] = '\0'; - - return 0; -} - -int cmark_strbuf_grow(cmark_strbuf *buf, int target_size) -{ - return cmark_strbuf_try_grow(buf, target_size, true); -} - -bool cmark_strbuf_oom(const cmark_strbuf *buf) -{ - return (buf->ptr == cmark_strbuf__oom); -} - -size_t cmark_strbuf_len(const cmark_strbuf *buf) -{ - return buf->size; -} - -void cmark_strbuf_free(cmark_strbuf *buf) -{ - if (!buf) return; - - if (buf->ptr != cmark_strbuf__initbuf && buf->ptr != cmark_strbuf__oom) - free(buf->ptr); - - cmark_strbuf_init(buf, 0); -} - -void cmark_strbuf_clear(cmark_strbuf *buf) -{ - buf->size = 0; - - if (buf->asize > 0) - buf->ptr[0] = '\0'; -} - -int cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data, int len) -{ - if (len <= 0 || data == NULL) { - cmark_strbuf_clear(buf); - } else { - if (data != buf->ptr) { - ENSURE_SIZE(buf, len + 1); - memmove(buf->ptr, data, len); - } - buf->size = len; - buf->ptr[buf->size] = '\0'; - } - return 0; -} - -int cmark_strbuf_sets(cmark_strbuf *buf, const char *string) -{ - return cmark_strbuf_set(buf, - (const unsigned char *)string, - string ? strlen(string) : 0); -} - -int cmark_strbuf_putc(cmark_strbuf *buf, int c) -{ - ENSURE_SIZE(buf, buf->size + 2); - buf->ptr[buf->size++] = c; - buf->ptr[buf->size] = '\0'; - return 0; -} - -int cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data, int len) -{ - if (len <= 0) - return 0; - - ENSURE_SIZE(buf, buf->size + len + 1); - memmove(buf->ptr + buf->size, data, len); - buf->size += len; - buf->ptr[buf->size] = '\0'; - return 0; -} - -int cmark_strbuf_puts(cmark_strbuf *buf, const char *string) -{ - return cmark_strbuf_put(buf, (const unsigned char *)string, strlen(string)); -} - -int cmark_strbuf_vprintf(cmark_strbuf *buf, const char *format, va_list ap) -{ - const int expected_size = buf->size + (strlen(format) * 2); - int len; - - ENSURE_SIZE(buf, expected_size); - - while (1) { - va_list args; - va_copy(args, ap); - - len = vsnprintf( - (char *)buf->ptr + buf->size, - buf->asize - buf->size, - format, args - ); - - va_end(args); - - if (len < 0) { - free(buf->ptr); - buf->ptr = cmark_strbuf__oom; - return -1; - } - - if (len + 1 <= buf->asize - buf->size) { - buf->size += len; - break; - } - - ENSURE_SIZE(buf, buf->size + len + 1); - } - - return 0; -} - -int cmark_strbuf_printf(cmark_strbuf *buf, const char *format, ...) -{ - int r; - va_list ap; - - va_start(ap, format); - r = cmark_strbuf_vprintf(buf, format, ap); - va_end(ap); - - return r; -} - -void cmark_strbuf_copy_cstr(char *data, int datasize, const cmark_strbuf *buf) -{ - int copylen; - - assert(data && datasize && buf); - - data[0] = '\0'; - - if (buf->size == 0 || buf->asize <= 0) - return; - - copylen = buf->size; - if (copylen > datasize - 1) - copylen = datasize - 1; - memmove(data, buf->ptr, copylen); - data[copylen] = '\0'; -} - -void cmark_strbuf_swap(cmark_strbuf *buf_a, cmark_strbuf *buf_b) -{ - cmark_strbuf t = *buf_a; - *buf_a = *buf_b; - *buf_b = t; -} - -unsigned char *cmark_strbuf_detach(cmark_strbuf *buf) -{ - unsigned char *data = buf->ptr; - - if (buf->asize == 0 || buf->ptr == cmark_strbuf__oom) { - /* return an empty string */ - return (unsigned char *)calloc(1, 1); - } - - cmark_strbuf_init(buf, 0); - return data; -} - -void cmark_strbuf_attach(cmark_strbuf *buf, unsigned char *ptr, int asize) -{ - cmark_strbuf_free(buf); - - if (ptr) { - buf->ptr = ptr; - buf->size = strlen((char *)ptr); - if (asize) - buf->asize = (asize < buf->size) ? buf->size + 1 : asize; - else /* pass 0 to fall back on strlen + 1 */ - buf->asize = buf->size + 1; - } else { - cmark_strbuf_grow(buf, asize); - } -} - -int cmark_strbuf_cmp(const cmark_strbuf *a, const cmark_strbuf *b) -{ - int result = memcmp(a->ptr, b->ptr, MIN(a->size, b->size)); - return (result != 0) ? result : - (a->size < b->size) ? -1 : (a->size > b->size) ? 1 : 0; -} - -int cmark_strbuf_strchr(const cmark_strbuf *buf, int c, int pos) -{ - const unsigned char *p = (unsigned char *)memchr(buf->ptr + pos, c, buf->size - pos); - if (!p) - return -1; - - return (int)(p - (const unsigned char *)buf->ptr); -} - -int cmark_strbuf_strrchr(const cmark_strbuf *buf, int c, int pos) -{ - int i; - - for (i = pos; i >= 0; i--) { - if (buf->ptr[i] == (unsigned char) c) - return i; - } - - return -1; -} - -void cmark_strbuf_truncate(cmark_strbuf *buf, int len) -{ - if (len < buf->size) { - buf->size = len; - buf->ptr[buf->size] = '\0'; - } -} - -void cmark_strbuf_drop(cmark_strbuf *buf, int n) -{ - if (n > 0) { - buf->size = buf->size - n; - if (buf->size) - memmove(buf->ptr, buf->ptr + n, buf->size); - - buf->ptr[buf->size] = '\0'; - } -} - -void cmark_strbuf_rtrim(cmark_strbuf *buf) -{ - if (!buf->size) - return; - - while (buf->size > 0) { - if (!cmark_isspace(buf->ptr[buf->size - 1])) - break; - - buf->size--; - } - - buf->ptr[buf->size] = '\0'; -} - -void cmark_strbuf_trim(cmark_strbuf *buf) -{ - int i = 0; - - if (!buf->size) - return; - - while (i < buf->size && cmark_isspace(buf->ptr[i])) - i++; - - cmark_strbuf_drop(buf, i); - - cmark_strbuf_rtrim(buf); -} - -// Destructively modify string, collapsing consecutive -// space and newline characters into a single space. -void cmark_strbuf_normalize_whitespace(cmark_strbuf *s) -{ - bool last_char_was_space = false; - int r, w; - - for (r = 0, w = 0; r < s->size; ++r) { - switch (s->ptr[r]) { - case ' ': - case '\n': - if (last_char_was_space) - break; - - s->ptr[w++] = ' '; - last_char_was_space = true; - break; - - default: - s->ptr[w++] = s->ptr[r]; - last_char_was_space = false; - } - } - - cmark_strbuf_truncate(s, w); -} - -// Destructively unescape a string: remove backslashes before punctuation chars. -extern void cmark_strbuf_unescape(cmark_strbuf *buf) -{ - int r, w; - - for (r = 0, w = 0; r < buf->size; ++r) { - if (buf->ptr[r] == '\\' && cmark_ispunct(buf->ptr[r + 1])) - continue; - - buf->ptr[w++] = buf->ptr[r]; - } - - cmark_strbuf_truncate(buf, w); -} diff --git a/cmark/buffer.h b/cmark/buffer.h deleted file mode 100644 --- a/cmark/buffer.h +++ /dev/null @@ -1,113 +0,0 @@ -#ifndef CMARK_BUFFER_H -#define CMARK_BUFFER_H - -#include -#include -#include "config.h" - -#ifdef __cplusplus -extern "C" { -#endif - -typedef struct { - unsigned char *ptr; - int asize, size; -} cmark_strbuf; - -extern unsigned char cmark_strbuf__initbuf[]; - -extern unsigned char cmark_strbuf__oom[]; - -#define GH_BUF_INIT { cmark_strbuf__initbuf, 0, 0 } - -/** - * Initialize a cmark_strbuf structure. - * - * For the cases where GH_BUF_INIT cannot be used to do static - * initialization. - */ -void cmark_strbuf_init(cmark_strbuf *buf, int initial_size); - -/** - * Attempt to grow the buffer to hold at least `target_size` bytes. - * - * If the allocation fails, this will return an error. If mark_oom is true, - * this will mark the buffer as invalid for future operations; if false, - * existing buffer content will be preserved, but calling code must handle - * that buffer was not expanded. - */ -int cmark_strbuf_try_grow(cmark_strbuf *buf, int target_size, bool mark_oom); - -/** - * Grow the buffer to hold at least `target_size` bytes. - * - * If the allocation fails, this will return an error and the buffer will be - * marked as invalid for future operations, invaliding contents. - * - * @return 0 on success or -1 on failure - */ -int cmark_strbuf_grow(cmark_strbuf *buf, int target_size); - -void cmark_strbuf_free(cmark_strbuf *buf); -void cmark_strbuf_swap(cmark_strbuf *buf_a, cmark_strbuf *buf_b); - -/** - * Test if there have been any reallocation failures with this cmark_strbuf. - * - * Any function that writes to a cmark_strbuf can fail due to memory allocation - * issues. If one fails, the cmark_strbuf will be marked with an OOM error and - * further calls to modify the buffer will fail. Check cmark_strbuf_oom() at the - * end of your sequence and it will be true if you ran out of memory at any - * point with that buffer. - * - * @return false if no error, true if allocation error - */ -bool cmark_strbuf_oom(const cmark_strbuf *buf); - -size_t cmark_strbuf_len(const cmark_strbuf *buf); - -int cmark_strbuf_cmp(const cmark_strbuf *a, const cmark_strbuf *b); - -void cmark_strbuf_attach(cmark_strbuf *buf, unsigned char *ptr, int asize); -unsigned char *cmark_strbuf_detach(cmark_strbuf *buf); -void cmark_strbuf_copy_cstr(char *data, int datasize, const cmark_strbuf *buf); - -static inline const char *cmark_strbuf_cstr(const cmark_strbuf *buf) -{ - return (char *)buf->ptr; -} - -#define cmark_strbuf_at(buf, n) ((buf)->ptr[n]) - -/* - * Functions below that return int value error codes will return 0 on - * success or -1 on failure (which generally means an allocation failed). - * Using a cmark_strbuf where the allocation has failed with result in -1 from - * all further calls using that buffer. As a result, you can ignore the - * return code of these functions and call them in a series then just call - * cmark_strbuf_oom at the end. - */ -int cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data, int len); -int cmark_strbuf_sets(cmark_strbuf *buf, const char *string); -int cmark_strbuf_putc(cmark_strbuf *buf, int c); -int cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data, int len); -int cmark_strbuf_puts(cmark_strbuf *buf, const char *string); -int cmark_strbuf_printf(cmark_strbuf *buf, const char *format, ...) -CMARK_ATTRIBUTE((format (printf, 2, 3))); -int cmark_strbuf_vprintf(cmark_strbuf *buf, const char *format, va_list ap); -void cmark_strbuf_clear(cmark_strbuf *buf); - -int cmark_strbuf_strchr(const cmark_strbuf *buf, int c, int pos); -int cmark_strbuf_strrchr(const cmark_strbuf *buf, int c, int pos); -void cmark_strbuf_drop(cmark_strbuf *buf, int n); -void cmark_strbuf_truncate(cmark_strbuf *buf, int len); -void cmark_strbuf_rtrim(cmark_strbuf *buf); -void cmark_strbuf_trim(cmark_strbuf *buf); -void cmark_strbuf_normalize_whitespace(cmark_strbuf *s); -void cmark_strbuf_unescape(cmark_strbuf *s); - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/cmark/case_fold_switch.inc b/cmark/case_fold_switch.inc deleted file mode 100644 --- a/cmark/case_fold_switch.inc +++ /dev/null @@ -1,2637 +0,0 @@ - switch (c) { - case 0x0041: - bufpush(0x0061); - break; - case 0x0042: - bufpush(0x0062); - break; - case 0x0043: - bufpush(0x0063); - break; - case 0x0044: - bufpush(0x0064); - break; - case 0x0045: - bufpush(0x0065); - break; - case 0x0046: - bufpush(0x0066); - break; - case 0x0047: - bufpush(0x0067); - break; - case 0x0048: - bufpush(0x0068); - break; - case 0x0049: - bufpush(0x0069); - break; - case 0x004A: - bufpush(0x006A); - break; - case 0x004B: - bufpush(0x006B); - break; - case 0x004C: - bufpush(0x006C); - break; - case 0x004D: - bufpush(0x006D); - break; - case 0x004E: - bufpush(0x006E); - break; - case 0x004F: - bufpush(0x006F); - break; - case 0x0050: - bufpush(0x0070); - break; - case 0x0051: - bufpush(0x0071); - break; - case 0x0052: - bufpush(0x0072); - break; - case 0x0053: - bufpush(0x0073); - break; - case 0x0054: - bufpush(0x0074); - break; - case 0x0055: - bufpush(0x0075); - break; - case 0x0056: - bufpush(0x0076); - break; - case 0x0057: - bufpush(0x0077); - break; - case 0x0058: - bufpush(0x0078); - break; - case 0x0059: - bufpush(0x0079); - break; - case 0x005A: - bufpush(0x007A); - break; - case 0x00B5: - bufpush(0x03BC); - break; - case 0x00C0: - bufpush(0x00E0); - break; - case 0x00C1: - bufpush(0x00E1); - break; - case 0x00C2: - bufpush(0x00E2); - break; - case 0x00C3: - bufpush(0x00E3); - break; - case 0x00C4: - bufpush(0x00E4); - break; - case 0x00C5: - bufpush(0x00E5); - break; - case 0x00C6: - bufpush(0x00E6); - break; - case 0x00C7: - bufpush(0x00E7); - break; - case 0x00C8: - bufpush(0x00E8); - break; - case 0x00C9: - bufpush(0x00E9); - break; - case 0x00CA: - bufpush(0x00EA); - break; - case 0x00CB: - bufpush(0x00EB); - break; - case 0x00CC: - bufpush(0x00EC); - break; - case 0x00CD: - bufpush(0x00ED); - break; - case 0x00CE: - bufpush(0x00EE); - break; - case 0x00CF: - bufpush(0x00EF); - break; - case 0x00D0: - bufpush(0x00F0); - break; - case 0x00D1: - bufpush(0x00F1); - break; - case 0x00D2: - bufpush(0x00F2); - break; - case 0x00D3: - bufpush(0x00F3); - break; - case 0x00D4: - bufpush(0x00F4); - break; - case 0x00D5: - bufpush(0x00F5); - break; - case 0x00D6: - bufpush(0x00F6); - break; - case 0x00D8: - bufpush(0x00F8); - break; - case 0x00D9: - bufpush(0x00F9); - break; - case 0x00DA: - bufpush(0x00FA); - break; - case 0x00DB: - bufpush(0x00FB); - break; - case 0x00DC: - bufpush(0x00FC); - break; - case 0x00DD: - bufpush(0x00FD); - break; - case 0x00DE: - bufpush(0x00FE); - break; - case 0x00DF: - bufpush(0x0073); - bufpush(0x0073); - break; - case 0x0100: - bufpush(0x0101); - break; - case 0x0102: - bufpush(0x0103); - break; - case 0x0104: - bufpush(0x0105); - break; - case 0x0106: - bufpush(0x0107); - break; - case 0x0108: - bufpush(0x0109); - break; - case 0x010A: - bufpush(0x010B); - break; - case 0x010C: - bufpush(0x010D); - break; - case 0x010E: - bufpush(0x010F); - break; - case 0x0110: - bufpush(0x0111); - break; - case 0x0112: - bufpush(0x0113); - break; - case 0x0114: - bufpush(0x0115); - break; - case 0x0116: - bufpush(0x0117); - break; - case 0x0118: - bufpush(0x0119); - break; - case 0x011A: - bufpush(0x011B); - break; - case 0x011C: - bufpush(0x011D); - break; - case 0x011E: - bufpush(0x011F); - break; - case 0x0120: - bufpush(0x0121); - break; - case 0x0122: - bufpush(0x0123); - break; - case 0x0124: - bufpush(0x0125); - break; - case 0x0126: - bufpush(0x0127); - break; - case 0x0128: - bufpush(0x0129); - break; - case 0x012A: - bufpush(0x012B); - break; - case 0x012C: - bufpush(0x012D); - break; - case 0x012E: - bufpush(0x012F); - break; - case 0x0130: - bufpush(0x0069); - bufpush(0x0307); - break; - case 0x0132: - bufpush(0x0133); - break; - case 0x0134: - bufpush(0x0135); - break; - case 0x0136: - bufpush(0x0137); - break; - case 0x0139: - bufpush(0x013A); - break; - case 0x013B: - bufpush(0x013C); - break; - case 0x013D: - bufpush(0x013E); - break; - case 0x013F: - bufpush(0x0140); - break; - case 0x0141: - bufpush(0x0142); - break; - case 0x0143: - bufpush(0x0144); - break; - case 0x0145: - bufpush(0x0146); - break; - case 0x0147: - bufpush(0x0148); - break; - case 0x0149: - bufpush(0x02BC); - bufpush(0x006E); - break; - case 0x014A: - bufpush(0x014B); - break; - case 0x014C: - bufpush(0x014D); - break; - case 0x014E: - bufpush(0x014F); - break; - case 0x0150: - bufpush(0x0151); - break; - case 0x0152: - bufpush(0x0153); - break; - case 0x0154: - bufpush(0x0155); - break; - case 0x0156: - bufpush(0x0157); - break; - case 0x0158: - bufpush(0x0159); - break; - case 0x015A: - bufpush(0x015B); - break; - case 0x015C: - bufpush(0x015D); - break; - case 0x015E: - bufpush(0x015F); - break; - case 0x0160: - bufpush(0x0161); - break; - case 0x0162: - bufpush(0x0163); - break; - case 0x0164: - bufpush(0x0165); - break; - case 0x0166: - bufpush(0x0167); - break; - case 0x0168: - bufpush(0x0169); - break; - case 0x016A: - bufpush(0x016B); - break; - case 0x016C: - bufpush(0x016D); - break; - case 0x016E: - bufpush(0x016F); - break; - case 0x0170: - bufpush(0x0171); - break; - case 0x0172: - bufpush(0x0173); - break; - case 0x0174: - bufpush(0x0175); - break; - case 0x0176: - bufpush(0x0177); - break; - case 0x0178: - bufpush(0x00FF); - break; - case 0x0179: - bufpush(0x017A); - break; - case 0x017B: - bufpush(0x017C); - break; - case 0x017D: - bufpush(0x017E); - break; - case 0x017F: - bufpush(0x0073); - break; - case 0x0181: - bufpush(0x0253); - break; - case 0x0182: - bufpush(0x0183); - break; - case 0x0184: - bufpush(0x0185); - break; - case 0x0186: - bufpush(0x0254); - break; - case 0x0187: - bufpush(0x0188); - break; - case 0x0189: - bufpush(0x0256); - break; - case 0x018A: - bufpush(0x0257); - break; - case 0x018B: - bufpush(0x018C); - break; - case 0x018E: - bufpush(0x01DD); - break; - case 0x018F: - bufpush(0x0259); - break; - case 0x0190: - bufpush(0x025B); - break; - case 0x0191: - bufpush(0x0192); - break; - case 0x0193: - bufpush(0x0260); - break; - case 0x0194: - bufpush(0x0263); - break; - case 0x0196: - bufpush(0x0269); - break; - case 0x0197: - bufpush(0x0268); - break; - case 0x0198: - bufpush(0x0199); - break; - case 0x019C: - bufpush(0x026F); - break; - case 0x019D: - bufpush(0x0272); - break; - case 0x019F: - bufpush(0x0275); - break; - case 0x01A0: - bufpush(0x01A1); - break; - case 0x01A2: - bufpush(0x01A3); - break; - case 0x01A4: - bufpush(0x01A5); - break; - case 0x01A6: - bufpush(0x0280); - break; - case 0x01A7: - bufpush(0x01A8); - break; - case 0x01A9: - bufpush(0x0283); - break; - case 0x01AC: - bufpush(0x01AD); - break; - case 0x01AE: - bufpush(0x0288); - break; - case 0x01AF: - bufpush(0x01B0); - break; - case 0x01B1: - bufpush(0x028A); - break; - case 0x01B2: - bufpush(0x028B); - break; - case 0x01B3: - bufpush(0x01B4); - break; - case 0x01B5: - bufpush(0x01B6); - break; - case 0x01B7: - bufpush(0x0292); - break; - case 0x01B8: - bufpush(0x01B9); - break; - case 0x01BC: - bufpush(0x01BD); - break; - case 0x01C4: - bufpush(0x01C6); - break; - case 0x01C5: - bufpush(0x01C6); - break; - case 0x01C7: - bufpush(0x01C9); - break; - case 0x01C8: - bufpush(0x01C9); - break; - case 0x01CA: - bufpush(0x01CC); - break; - case 0x01CB: - bufpush(0x01CC); - break; - case 0x01CD: - bufpush(0x01CE); - break; - case 0x01CF: - bufpush(0x01D0); - break; - case 0x01D1: - bufpush(0x01D2); - break; - case 0x01D3: - bufpush(0x01D4); - break; - case 0x01D5: - bufpush(0x01D6); - break; - case 0x01D7: - bufpush(0x01D8); - break; - case 0x01D9: - bufpush(0x01DA); - break; - case 0x01DB: - bufpush(0x01DC); - break; - case 0x01DE: - bufpush(0x01DF); - break; - case 0x01E0: - bufpush(0x01E1); - break; - case 0x01E2: - bufpush(0x01E3); - break; - case 0x01E4: - bufpush(0x01E5); - break; - case 0x01E6: - bufpush(0x01E7); - break; - case 0x01E8: - bufpush(0x01E9); - break; - case 0x01EA: - bufpush(0x01EB); - break; - case 0x01EC: - bufpush(0x01ED); - break; - case 0x01EE: - bufpush(0x01EF); - break; - case 0x01F0: - bufpush(0x006A); - bufpush(0x030C); - break; - case 0x01F1: - bufpush(0x01F3); - break; - case 0x01F2: - bufpush(0x01F3); - break; - case 0x01F4: - bufpush(0x01F5); - break; - case 0x01F6: - bufpush(0x0195); - break; - case 0x01F7: - bufpush(0x01BF); - break; - case 0x01F8: - bufpush(0x01F9); - break; - case 0x01FA: - bufpush(0x01FB); - break; - case 0x01FC: - bufpush(0x01FD); - break; - case 0x01FE: - bufpush(0x01FF); - break; - case 0x0200: - bufpush(0x0201); - break; - case 0x0202: - bufpush(0x0203); - break; - case 0x0204: - bufpush(0x0205); - break; - case 0x0206: - bufpush(0x0207); - break; - case 0x0208: - bufpush(0x0209); - break; - case 0x020A: - bufpush(0x020B); - break; - case 0x020C: - bufpush(0x020D); - break; - case 0x020E: - bufpush(0x020F); - break; - case 0x0210: - bufpush(0x0211); - break; - case 0x0212: - bufpush(0x0213); - break; - case 0x0214: - bufpush(0x0215); - break; - case 0x0216: - bufpush(0x0217); - break; - case 0x0218: - bufpush(0x0219); - break; - case 0x021A: - bufpush(0x021B); - break; - case 0x021C: - bufpush(0x021D); - break; - case 0x021E: - bufpush(0x021F); - break; - case 0x0220: - bufpush(0x019E); - break; - case 0x0222: - bufpush(0x0223); - break; - case 0x0224: - bufpush(0x0225); - break; - case 0x0226: - bufpush(0x0227); - break; - case 0x0228: - bufpush(0x0229); - break; - case 0x022A: - bufpush(0x022B); - break; - case 0x022C: - bufpush(0x022D); - break; - case 0x022E: - bufpush(0x022F); - break; - case 0x0230: - bufpush(0x0231); - break; - case 0x0232: - bufpush(0x0233); - break; - case 0x0345: - bufpush(0x03B9); - break; - case 0x0386: - bufpush(0x03AC); - break; - case 0x0388: - bufpush(0x03AD); - break; - case 0x0389: - bufpush(0x03AE); - break; - case 0x038A: - bufpush(0x03AF); - break; - case 0x038C: - bufpush(0x03CC); - break; - case 0x038E: - bufpush(0x03CD); - break; - case 0x038F: - bufpush(0x03CE); - break; - case 0x0390: - bufpush(0x03B9); - bufpush(0x0308); - bufpush(0x0301); - break; - case 0x0391: - bufpush(0x03B1); - break; - case 0x0392: - bufpush(0x03B2); - break; - case 0x0393: - bufpush(0x03B3); - break; - case 0x0394: - bufpush(0x03B4); - break; - case 0x0395: - bufpush(0x03B5); - break; - case 0x0396: - bufpush(0x03B6); - break; - case 0x0397: - bufpush(0x03B7); - break; - case 0x0398: - bufpush(0x03B8); - break; - case 0x0399: - bufpush(0x03B9); - break; - case 0x039A: - bufpush(0x03BA); - break; - case 0x039B: - bufpush(0x03BB); - break; - case 0x039C: - bufpush(0x03BC); - break; - case 0x039D: - bufpush(0x03BD); - break; - case 0x039E: - bufpush(0x03BE); - break; - case 0x039F: - bufpush(0x03BF); - break; - case 0x03A0: - bufpush(0x03C0); - break; - case 0x03A1: - bufpush(0x03C1); - break; - case 0x03A3: - bufpush(0x03C3); - break; - case 0x03A4: - bufpush(0x03C4); - break; - case 0x03A5: - bufpush(0x03C5); - break; - case 0x03A6: - bufpush(0x03C6); - break; - case 0x03A7: - bufpush(0x03C7); - break; - case 0x03A8: - bufpush(0x03C8); - break; - case 0x03A9: - bufpush(0x03C9); - break; - case 0x03AA: - bufpush(0x03CA); - break; - case 0x03AB: - bufpush(0x03CB); - break; - case 0x03B0: - bufpush(0x03C5); - bufpush(0x0308); - bufpush(0x0301); - break; - case 0x03C2: - bufpush(0x03C3); - break; - case 0x03D0: - bufpush(0x03B2); - break; - case 0x03D1: - bufpush(0x03B8); - break; - case 0x03D5: - bufpush(0x03C6); - break; - case 0x03D6: - bufpush(0x03C0); - break; - case 0x03D8: - bufpush(0x03D9); - break; - case 0x03DA: - bufpush(0x03DB); - break; - case 0x03DC: - bufpush(0x03DD); - break; - case 0x03DE: - bufpush(0x03DF); - break; - case 0x03E0: - bufpush(0x03E1); - break; - case 0x03E2: - bufpush(0x03E3); - break; - case 0x03E4: - bufpush(0x03E5); - break; - case 0x03E6: - bufpush(0x03E7); - break; - case 0x03E8: - bufpush(0x03E9); - break; - case 0x03EA: - bufpush(0x03EB); - break; - case 0x03EC: - bufpush(0x03ED); - break; - case 0x03EE: - bufpush(0x03EF); - break; - case 0x03F0: - bufpush(0x03BA); - break; - case 0x03F1: - bufpush(0x03C1); - break; - case 0x03F2: - bufpush(0x03C3); - break; - case 0x03F4: - bufpush(0x03B8); - break; - case 0x03F5: - bufpush(0x03B5); - break; - case 0x0400: - bufpush(0x0450); - break; - case 0x0401: - bufpush(0x0451); - break; - case 0x0402: - bufpush(0x0452); - break; - case 0x0403: - bufpush(0x0453); - break; - case 0x0404: - bufpush(0x0454); - break; - case 0x0405: - bufpush(0x0455); - break; - case 0x0406: - bufpush(0x0456); - break; - case 0x0407: - bufpush(0x0457); - break; - case 0x0408: - bufpush(0x0458); - break; - case 0x0409: - bufpush(0x0459); - break; - case 0x040A: - bufpush(0x045A); - break; - case 0x040B: - bufpush(0x045B); - break; - case 0x040C: - bufpush(0x045C); - break; - case 0x040D: - bufpush(0x045D); - break; - case 0x040E: - bufpush(0x045E); - break; - case 0x040F: - bufpush(0x045F); - break; - case 0x0410: - bufpush(0x0430); - break; - case 0x0411: - bufpush(0x0431); - break; - case 0x0412: - bufpush(0x0432); - break; - case 0x0413: - bufpush(0x0433); - break; - case 0x0414: - bufpush(0x0434); - break; - case 0x0415: - bufpush(0x0435); - break; - case 0x0416: - bufpush(0x0436); - break; - case 0x0417: - bufpush(0x0437); - break; - case 0x0418: - bufpush(0x0438); - break; - case 0x0419: - bufpush(0x0439); - break; - case 0x041A: - bufpush(0x043A); - break; - case 0x041B: - bufpush(0x043B); - break; - case 0x041C: - bufpush(0x043C); - break; - case 0x041D: - bufpush(0x043D); - break; - case 0x041E: - bufpush(0x043E); - break; - case 0x041F: - bufpush(0x043F); - break; - case 0x0420: - bufpush(0x0440); - break; - case 0x0421: - bufpush(0x0441); - break; - case 0x0422: - bufpush(0x0442); - break; - case 0x0423: - bufpush(0x0443); - break; - case 0x0424: - bufpush(0x0444); - break; - case 0x0425: - bufpush(0x0445); - break; - case 0x0426: - bufpush(0x0446); - break; - case 0x0427: - bufpush(0x0447); - break; - case 0x0428: - bufpush(0x0448); - break; - case 0x0429: - bufpush(0x0449); - break; - case 0x042A: - bufpush(0x044A); - break; - case 0x042B: - bufpush(0x044B); - break; - case 0x042C: - bufpush(0x044C); - break; - case 0x042D: - bufpush(0x044D); - break; - case 0x042E: - bufpush(0x044E); - break; - case 0x042F: - bufpush(0x044F); - break; - case 0x0460: - bufpush(0x0461); - break; - case 0x0462: - bufpush(0x0463); - break; - case 0x0464: - bufpush(0x0465); - break; - case 0x0466: - bufpush(0x0467); - break; - case 0x0468: - bufpush(0x0469); - break; - case 0x046A: - bufpush(0x046B); - break; - case 0x046C: - bufpush(0x046D); - break; - case 0x046E: - bufpush(0x046F); - break; - case 0x0470: - bufpush(0x0471); - break; - case 0x0472: - bufpush(0x0473); - break; - case 0x0474: - bufpush(0x0475); - break; - case 0x0476: - bufpush(0x0477); - break; - case 0x0478: - bufpush(0x0479); - break; - case 0x047A: - bufpush(0x047B); - break; - case 0x047C: - bufpush(0x047D); - break; - case 0x047E: - bufpush(0x047F); - break; - case 0x0480: - bufpush(0x0481); - break; - case 0x048A: - bufpush(0x048B); - break; - case 0x048C: - bufpush(0x048D); - break; - case 0x048E: - bufpush(0x048F); - break; - case 0x0490: - bufpush(0x0491); - break; - case 0x0492: - bufpush(0x0493); - break; - case 0x0494: - bufpush(0x0495); - break; - case 0x0496: - bufpush(0x0497); - break; - case 0x0498: - bufpush(0x0499); - break; - case 0x049A: - bufpush(0x049B); - break; - case 0x049C: - bufpush(0x049D); - break; - case 0x049E: - bufpush(0x049F); - break; - case 0x04A0: - bufpush(0x04A1); - break; - case 0x04A2: - bufpush(0x04A3); - break; - case 0x04A4: - bufpush(0x04A5); - break; - case 0x04A6: - bufpush(0x04A7); - break; - case 0x04A8: - bufpush(0x04A9); - break; - case 0x04AA: - bufpush(0x04AB); - break; - case 0x04AC: - bufpush(0x04AD); - break; - case 0x04AE: - bufpush(0x04AF); - break; - case 0x04B0: - bufpush(0x04B1); - break; - case 0x04B2: - bufpush(0x04B3); - break; - case 0x04B4: - bufpush(0x04B5); - break; - case 0x04B6: - bufpush(0x04B7); - break; - case 0x04B8: - bufpush(0x04B9); - break; - case 0x04BA: - bufpush(0x04BB); - break; - case 0x04BC: - bufpush(0x04BD); - break; - case 0x04BE: - bufpush(0x04BF); - break; - case 0x04C1: - bufpush(0x04C2); - break; - case 0x04C3: - bufpush(0x04C4); - break; - case 0x04C5: - bufpush(0x04C6); - break; - case 0x04C7: - bufpush(0x04C8); - break; - case 0x04C9: - bufpush(0x04CA); - break; - case 0x04CB: - bufpush(0x04CC); - break; - case 0x04CD: - bufpush(0x04CE); - break; - case 0x04D0: - bufpush(0x04D1); - break; - case 0x04D2: - bufpush(0x04D3); - break; - case 0x04D4: - bufpush(0x04D5); - break; - case 0x04D6: - bufpush(0x04D7); - break; - case 0x04D8: - bufpush(0x04D9); - break; - case 0x04DA: - bufpush(0x04DB); - break; - case 0x04DC: - bufpush(0x04DD); - break; - case 0x04DE: - bufpush(0x04DF); - break; - case 0x04E0: - bufpush(0x04E1); - break; - case 0x04E2: - bufpush(0x04E3); - break; - case 0x04E4: - bufpush(0x04E5); - break; - case 0x04E6: - bufpush(0x04E7); - break; - case 0x04E8: - bufpush(0x04E9); - break; - case 0x04EA: - bufpush(0x04EB); - break; - case 0x04EC: - bufpush(0x04ED); - break; - case 0x04EE: - bufpush(0x04EF); - break; - case 0x04F0: - bufpush(0x04F1); - break; - case 0x04F2: - bufpush(0x04F3); - break; - case 0x04F4: - bufpush(0x04F5); - break; - case 0x04F8: - bufpush(0x04F9); - break; - case 0x0500: - bufpush(0x0501); - break; - case 0x0502: - bufpush(0x0503); - break; - case 0x0504: - bufpush(0x0505); - break; - case 0x0506: - bufpush(0x0507); - break; - case 0x0508: - bufpush(0x0509); - break; - case 0x050A: - bufpush(0x050B); - break; - case 0x050C: - bufpush(0x050D); - break; - case 0x050E: - bufpush(0x050F); - break; - case 0x0531: - bufpush(0x0561); - break; - case 0x0532: - bufpush(0x0562); - break; - case 0x0533: - bufpush(0x0563); - break; - case 0x0534: - bufpush(0x0564); - break; - case 0x0535: - bufpush(0x0565); - break; - case 0x0536: - bufpush(0x0566); - break; - case 0x0537: - bufpush(0x0567); - break; - case 0x0538: - bufpush(0x0568); - break; - case 0x0539: - bufpush(0x0569); - break; - case 0x053A: - bufpush(0x056A); - break; - case 0x053B: - bufpush(0x056B); - break; - case 0x053C: - bufpush(0x056C); - break; - case 0x053D: - bufpush(0x056D); - break; - case 0x053E: - bufpush(0x056E); - break; - case 0x053F: - bufpush(0x056F); - break; - case 0x0540: - bufpush(0x0570); - break; - case 0x0541: - bufpush(0x0571); - break; - case 0x0542: - bufpush(0x0572); - break; - case 0x0543: - bufpush(0x0573); - break; - case 0x0544: - bufpush(0x0574); - break; - case 0x0545: - bufpush(0x0575); - break; - case 0x0546: - bufpush(0x0576); - break; - case 0x0547: - bufpush(0x0577); - break; - case 0x0548: - bufpush(0x0578); - break; - case 0x0549: - bufpush(0x0579); - break; - case 0x054A: - bufpush(0x057A); - break; - case 0x054B: - bufpush(0x057B); - break; - case 0x054C: - bufpush(0x057C); - break; - case 0x054D: - bufpush(0x057D); - break; - case 0x054E: - bufpush(0x057E); - break; - case 0x054F: - bufpush(0x057F); - break; - case 0x0550: - bufpush(0x0580); - break; - case 0x0551: - bufpush(0x0581); - break; - case 0x0552: - bufpush(0x0582); - break; - case 0x0553: - bufpush(0x0583); - break; - case 0x0554: - bufpush(0x0584); - break; - case 0x0555: - bufpush(0x0585); - break; - case 0x0556: - bufpush(0x0586); - break; - case 0x0587: - bufpush(0x0565); - bufpush(0x0582); - break; - case 0x1E00: - bufpush(0x1E01); - break; - case 0x1E02: - bufpush(0x1E03); - break; - case 0x1E04: - bufpush(0x1E05); - break; - case 0x1E06: - bufpush(0x1E07); - break; - case 0x1E08: - bufpush(0x1E09); - break; - case 0x1E0A: - bufpush(0x1E0B); - break; - case 0x1E0C: - bufpush(0x1E0D); - break; - case 0x1E0E: - bufpush(0x1E0F); - break; - case 0x1E10: - bufpush(0x1E11); - break; - case 0x1E12: - bufpush(0x1E13); - break; - case 0x1E14: - bufpush(0x1E15); - break; - case 0x1E16: - bufpush(0x1E17); - break; - case 0x1E18: - bufpush(0x1E19); - break; - case 0x1E1A: - bufpush(0x1E1B); - break; - case 0x1E1C: - bufpush(0x1E1D); - break; - case 0x1E1E: - bufpush(0x1E1F); - break; - case 0x1E20: - bufpush(0x1E21); - break; - case 0x1E22: - bufpush(0x1E23); - break; - case 0x1E24: - bufpush(0x1E25); - break; - case 0x1E26: - bufpush(0x1E27); - break; - case 0x1E28: - bufpush(0x1E29); - break; - case 0x1E2A: - bufpush(0x1E2B); - break; - case 0x1E2C: - bufpush(0x1E2D); - break; - case 0x1E2E: - bufpush(0x1E2F); - break; - case 0x1E30: - bufpush(0x1E31); - break; - case 0x1E32: - bufpush(0x1E33); - break; - case 0x1E34: - bufpush(0x1E35); - break; - case 0x1E36: - bufpush(0x1E37); - break; - case 0x1E38: - bufpush(0x1E39); - break; - case 0x1E3A: - bufpush(0x1E3B); - break; - case 0x1E3C: - bufpush(0x1E3D); - break; - case 0x1E3E: - bufpush(0x1E3F); - break; - case 0x1E40: - bufpush(0x1E41); - break; - case 0x1E42: - bufpush(0x1E43); - break; - case 0x1E44: - bufpush(0x1E45); - break; - case 0x1E46: - bufpush(0x1E47); - break; - case 0x1E48: - bufpush(0x1E49); - break; - case 0x1E4A: - bufpush(0x1E4B); - break; - case 0x1E4C: - bufpush(0x1E4D); - break; - case 0x1E4E: - bufpush(0x1E4F); - break; - case 0x1E50: - bufpush(0x1E51); - break; - case 0x1E52: - bufpush(0x1E53); - break; - case 0x1E54: - bufpush(0x1E55); - break; - case 0x1E56: - bufpush(0x1E57); - break; - case 0x1E58: - bufpush(0x1E59); - break; - case 0x1E5A: - bufpush(0x1E5B); - break; - case 0x1E5C: - bufpush(0x1E5D); - break; - case 0x1E5E: - bufpush(0x1E5F); - break; - case 0x1E60: - bufpush(0x1E61); - break; - case 0x1E62: - bufpush(0x1E63); - break; - case 0x1E64: - bufpush(0x1E65); - break; - case 0x1E66: - bufpush(0x1E67); - break; - case 0x1E68: - bufpush(0x1E69); - break; - case 0x1E6A: - bufpush(0x1E6B); - break; - case 0x1E6C: - bufpush(0x1E6D); - break; - case 0x1E6E: - bufpush(0x1E6F); - break; - case 0x1E70: - bufpush(0x1E71); - break; - case 0x1E72: - bufpush(0x1E73); - break; - case 0x1E74: - bufpush(0x1E75); - break; - case 0x1E76: - bufpush(0x1E77); - break; - case 0x1E78: - bufpush(0x1E79); - break; - case 0x1E7A: - bufpush(0x1E7B); - break; - case 0x1E7C: - bufpush(0x1E7D); - break; - case 0x1E7E: - bufpush(0x1E7F); - break; - case 0x1E80: - bufpush(0x1E81); - break; - case 0x1E82: - bufpush(0x1E83); - break; - case 0x1E84: - bufpush(0x1E85); - break; - case 0x1E86: - bufpush(0x1E87); - break; - case 0x1E88: - bufpush(0x1E89); - break; - case 0x1E8A: - bufpush(0x1E8B); - break; - case 0x1E8C: - bufpush(0x1E8D); - break; - case 0x1E8E: - bufpush(0x1E8F); - break; - case 0x1E90: - bufpush(0x1E91); - break; - case 0x1E92: - bufpush(0x1E93); - break; - case 0x1E94: - bufpush(0x1E95); - break; - case 0x1E96: - bufpush(0x0068); - bufpush(0x0331); - break; - case 0x1E97: - bufpush(0x0074); - bufpush(0x0308); - break; - case 0x1E98: - bufpush(0x0077); - bufpush(0x030A); - break; - case 0x1E99: - bufpush(0x0079); - bufpush(0x030A); - break; - case 0x1E9A: - bufpush(0x0061); - bufpush(0x02BE); - break; - case 0x1E9B: - bufpush(0x1E61); - break; - case 0x1EA0: - bufpush(0x1EA1); - break; - case 0x1EA2: - bufpush(0x1EA3); - break; - case 0x1EA4: - bufpush(0x1EA5); - break; - case 0x1EA6: - bufpush(0x1EA7); - break; - case 0x1EA8: - bufpush(0x1EA9); - break; - case 0x1EAA: - bufpush(0x1EAB); - break; - case 0x1EAC: - bufpush(0x1EAD); - break; - case 0x1EAE: - bufpush(0x1EAF); - break; - case 0x1EB0: - bufpush(0x1EB1); - break; - case 0x1EB2: - bufpush(0x1EB3); - break; - case 0x1EB4: - bufpush(0x1EB5); - break; - case 0x1EB6: - bufpush(0x1EB7); - break; - case 0x1EB8: - bufpush(0x1EB9); - break; - case 0x1EBA: - bufpush(0x1EBB); - break; - case 0x1EBC: - bufpush(0x1EBD); - break; - case 0x1EBE: - bufpush(0x1EBF); - break; - case 0x1EC0: - bufpush(0x1EC1); - break; - case 0x1EC2: - bufpush(0x1EC3); - break; - case 0x1EC4: - bufpush(0x1EC5); - break; - case 0x1EC6: - bufpush(0x1EC7); - break; - case 0x1EC8: - bufpush(0x1EC9); - break; - case 0x1ECA: - bufpush(0x1ECB); - break; - case 0x1ECC: - bufpush(0x1ECD); - break; - case 0x1ECE: - bufpush(0x1ECF); - break; - case 0x1ED0: - bufpush(0x1ED1); - break; - case 0x1ED2: - bufpush(0x1ED3); - break; - case 0x1ED4: - bufpush(0x1ED5); - break; - case 0x1ED6: - bufpush(0x1ED7); - break; - case 0x1ED8: - bufpush(0x1ED9); - break; - case 0x1EDA: - bufpush(0x1EDB); - break; - case 0x1EDC: - bufpush(0x1EDD); - break; - case 0x1EDE: - bufpush(0x1EDF); - break; - case 0x1EE0: - bufpush(0x1EE1); - break; - case 0x1EE2: - bufpush(0x1EE3); - break; - case 0x1EE4: - bufpush(0x1EE5); - break; - case 0x1EE6: - bufpush(0x1EE7); - break; - case 0x1EE8: - bufpush(0x1EE9); - break; - case 0x1EEA: - bufpush(0x1EEB); - break; - case 0x1EEC: - bufpush(0x1EED); - break; - case 0x1EEE: - bufpush(0x1EEF); - break; - case 0x1EF0: - bufpush(0x1EF1); - break; - case 0x1EF2: - bufpush(0x1EF3); - break; - case 0x1EF4: - bufpush(0x1EF5); - break; - case 0x1EF6: - bufpush(0x1EF7); - break; - case 0x1EF8: - bufpush(0x1EF9); - break; - case 0x1F08: - bufpush(0x1F00); - break; - case 0x1F09: - bufpush(0x1F01); - break; - case 0x1F0A: - bufpush(0x1F02); - break; - case 0x1F0B: - bufpush(0x1F03); - break; - case 0x1F0C: - bufpush(0x1F04); - break; - case 0x1F0D: - bufpush(0x1F05); - break; - case 0x1F0E: - bufpush(0x1F06); - break; - case 0x1F0F: - bufpush(0x1F07); - break; - case 0x1F18: - bufpush(0x1F10); - break; - case 0x1F19: - bufpush(0x1F11); - break; - case 0x1F1A: - bufpush(0x1F12); - break; - case 0x1F1B: - bufpush(0x1F13); - break; - case 0x1F1C: - bufpush(0x1F14); - break; - case 0x1F1D: - bufpush(0x1F15); - break; - case 0x1F28: - bufpush(0x1F20); - break; - case 0x1F29: - bufpush(0x1F21); - break; - case 0x1F2A: - bufpush(0x1F22); - break; - case 0x1F2B: - bufpush(0x1F23); - break; - case 0x1F2C: - bufpush(0x1F24); - break; - case 0x1F2D: - bufpush(0x1F25); - break; - case 0x1F2E: - bufpush(0x1F26); - break; - case 0x1F2F: - bufpush(0x1F27); - break; - case 0x1F38: - bufpush(0x1F30); - break; - case 0x1F39: - bufpush(0x1F31); - break; - case 0x1F3A: - bufpush(0x1F32); - break; - case 0x1F3B: - bufpush(0x1F33); - break; - case 0x1F3C: - bufpush(0x1F34); - break; - case 0x1F3D: - bufpush(0x1F35); - break; - case 0x1F3E: - bufpush(0x1F36); - break; - case 0x1F3F: - bufpush(0x1F37); - break; - case 0x1F48: - bufpush(0x1F40); - break; - case 0x1F49: - bufpush(0x1F41); - break; - case 0x1F4A: - bufpush(0x1F42); - break; - case 0x1F4B: - bufpush(0x1F43); - break; - case 0x1F4C: - bufpush(0x1F44); - break; - case 0x1F4D: - bufpush(0x1F45); - break; - case 0x1F50: - bufpush(0x03C5); - bufpush(0x0313); - break; - case 0x1F52: - bufpush(0x03C5); - bufpush(0x0313); - bufpush(0x0300); - break; - case 0x1F54: - bufpush(0x03C5); - bufpush(0x0313); - bufpush(0x0301); - break; - case 0x1F56: - bufpush(0x03C5); - bufpush(0x0313); - bufpush(0x0342); - break; - case 0x1F59: - bufpush(0x1F51); - break; - case 0x1F5B: - bufpush(0x1F53); - break; - case 0x1F5D: - bufpush(0x1F55); - break; - case 0x1F5F: - bufpush(0x1F57); - break; - case 0x1F68: - bufpush(0x1F60); - break; - case 0x1F69: - bufpush(0x1F61); - break; - case 0x1F6A: - bufpush(0x1F62); - break; - case 0x1F6B: - bufpush(0x1F63); - break; - case 0x1F6C: - bufpush(0x1F64); - break; - case 0x1F6D: - bufpush(0x1F65); - break; - case 0x1F6E: - bufpush(0x1F66); - break; - case 0x1F6F: - bufpush(0x1F67); - break; - case 0x1F80: - bufpush(0x1F00); - bufpush(0x03B9); - break; - case 0x1F81: - bufpush(0x1F01); - bufpush(0x03B9); - break; - case 0x1F82: - bufpush(0x1F02); - bufpush(0x03B9); - break; - case 0x1F83: - bufpush(0x1F03); - bufpush(0x03B9); - break; - case 0x1F84: - bufpush(0x1F04); - bufpush(0x03B9); - break; - case 0x1F85: - bufpush(0x1F05); - bufpush(0x03B9); - break; - case 0x1F86: - bufpush(0x1F06); - bufpush(0x03B9); - break; - case 0x1F87: - bufpush(0x1F07); - bufpush(0x03B9); - break; - case 0x1F88: - bufpush(0x1F00); - bufpush(0x03B9); - break; - case 0x1F89: - bufpush(0x1F01); - bufpush(0x03B9); - break; - case 0x1F8A: - bufpush(0x1F02); - bufpush(0x03B9); - break; - case 0x1F8B: - bufpush(0x1F03); - bufpush(0x03B9); - break; - case 0x1F8C: - bufpush(0x1F04); - bufpush(0x03B9); - break; - case 0x1F8D: - bufpush(0x1F05); - bufpush(0x03B9); - break; - case 0x1F8E: - bufpush(0x1F06); - bufpush(0x03B9); - break; - case 0x1F8F: - bufpush(0x1F07); - bufpush(0x03B9); - break; - case 0x1F90: - bufpush(0x1F20); - bufpush(0x03B9); - break; - case 0x1F91: - bufpush(0x1F21); - bufpush(0x03B9); - break; - case 0x1F92: - bufpush(0x1F22); - bufpush(0x03B9); - break; - case 0x1F93: - bufpush(0x1F23); - bufpush(0x03B9); - break; - case 0x1F94: - bufpush(0x1F24); - bufpush(0x03B9); - break; - case 0x1F95: - bufpush(0x1F25); - bufpush(0x03B9); - break; - case 0x1F96: - bufpush(0x1F26); - bufpush(0x03B9); - break; - case 0x1F97: - bufpush(0x1F27); - bufpush(0x03B9); - break; - case 0x1F98: - bufpush(0x1F20); - bufpush(0x03B9); - break; - case 0x1F99: - bufpush(0x1F21); - bufpush(0x03B9); - break; - case 0x1F9A: - bufpush(0x1F22); - bufpush(0x03B9); - break; - case 0x1F9B: - bufpush(0x1F23); - bufpush(0x03B9); - break; - case 0x1F9C: - bufpush(0x1F24); - bufpush(0x03B9); - break; - case 0x1F9D: - bufpush(0x1F25); - bufpush(0x03B9); - break; - case 0x1F9E: - bufpush(0x1F26); - bufpush(0x03B9); - break; - case 0x1F9F: - bufpush(0x1F27); - bufpush(0x03B9); - break; - case 0x1FA0: - bufpush(0x1F60); - bufpush(0x03B9); - break; - case 0x1FA1: - bufpush(0x1F61); - bufpush(0x03B9); - break; - case 0x1FA2: - bufpush(0x1F62); - bufpush(0x03B9); - break; - case 0x1FA3: - bufpush(0x1F63); - bufpush(0x03B9); - break; - case 0x1FA4: - bufpush(0x1F64); - bufpush(0x03B9); - break; - case 0x1FA5: - bufpush(0x1F65); - bufpush(0x03B9); - break; - case 0x1FA6: - bufpush(0x1F66); - bufpush(0x03B9); - break; - case 0x1FA7: - bufpush(0x1F67); - bufpush(0x03B9); - break; - case 0x1FA8: - bufpush(0x1F60); - bufpush(0x03B9); - break; - case 0x1FA9: - bufpush(0x1F61); - bufpush(0x03B9); - break; - case 0x1FAA: - bufpush(0x1F62); - bufpush(0x03B9); - break; - case 0x1FAB: - bufpush(0x1F63); - bufpush(0x03B9); - break; - case 0x1FAC: - bufpush(0x1F64); - bufpush(0x03B9); - break; - case 0x1FAD: - bufpush(0x1F65); - bufpush(0x03B9); - break; - case 0x1FAE: - bufpush(0x1F66); - bufpush(0x03B9); - break; - case 0x1FAF: - bufpush(0x1F67); - bufpush(0x03B9); - break; - case 0x1FB2: - bufpush(0x1F70); - bufpush(0x03B9); - break; - case 0x1FB3: - bufpush(0x03B1); - bufpush(0x03B9); - break; - case 0x1FB4: - bufpush(0x03AC); - bufpush(0x03B9); - break; - case 0x1FB6: - bufpush(0x03B1); - bufpush(0x0342); - break; - case 0x1FB7: - bufpush(0x03B1); - bufpush(0x0342); - bufpush(0x03B9); - break; - case 0x1FB8: - bufpush(0x1FB0); - break; - case 0x1FB9: - bufpush(0x1FB1); - break; - case 0x1FBA: - bufpush(0x1F70); - break; - case 0x1FBB: - bufpush(0x1F71); - break; - case 0x1FBC: - bufpush(0x03B1); - bufpush(0x03B9); - break; - case 0x1FBE: - bufpush(0x03B9); - break; - case 0x1FC2: - bufpush(0x1F74); - bufpush(0x03B9); - break; - case 0x1FC3: - bufpush(0x03B7); - bufpush(0x03B9); - break; - case 0x1FC4: - bufpush(0x03AE); - bufpush(0x03B9); - break; - case 0x1FC6: - bufpush(0x03B7); - bufpush(0x0342); - break; - case 0x1FC7: - bufpush(0x03B7); - bufpush(0x0342); - bufpush(0x03B9); - break; - case 0x1FC8: - bufpush(0x1F72); - break; - case 0x1FC9: - bufpush(0x1F73); - break; - case 0x1FCA: - bufpush(0x1F74); - break; - case 0x1FCB: - bufpush(0x1F75); - break; - case 0x1FCC: - bufpush(0x03B7); - bufpush(0x03B9); - break; - case 0x1FD2: - bufpush(0x03B9); - bufpush(0x0308); - bufpush(0x0300); - break; - case 0x1FD3: - bufpush(0x03B9); - bufpush(0x0308); - bufpush(0x0301); - break; - case 0x1FD6: - bufpush(0x03B9); - bufpush(0x0342); - break; - case 0x1FD7: - bufpush(0x03B9); - bufpush(0x0308); - bufpush(0x0342); - break; - case 0x1FD8: - bufpush(0x1FD0); - break; - case 0x1FD9: - bufpush(0x1FD1); - break; - case 0x1FDA: - bufpush(0x1F76); - break; - case 0x1FDB: - bufpush(0x1F77); - break; - case 0x1FE2: - bufpush(0x03C5); - bufpush(0x0308); - bufpush(0x0300); - break; - case 0x1FE3: - bufpush(0x03C5); - bufpush(0x0308); - bufpush(0x0301); - break; - case 0x1FE4: - bufpush(0x03C1); - bufpush(0x0313); - break; - case 0x1FE6: - bufpush(0x03C5); - bufpush(0x0342); - break; - case 0x1FE7: - bufpush(0x03C5); - bufpush(0x0308); - bufpush(0x0342); - break; - case 0x1FE8: - bufpush(0x1FE0); - break; - case 0x1FE9: - bufpush(0x1FE1); - break; - case 0x1FEA: - bufpush(0x1F7A); - break; - case 0x1FEB: - bufpush(0x1F7B); - break; - case 0x1FEC: - bufpush(0x1FE5); - break; - case 0x1FF2: - bufpush(0x1F7C); - bufpush(0x03B9); - break; - case 0x1FF3: - bufpush(0x03C9); - bufpush(0x03B9); - break; - case 0x1FF4: - bufpush(0x03CE); - bufpush(0x03B9); - break; - case 0x1FF6: - bufpush(0x03C9); - bufpush(0x0342); - break; - case 0x1FF7: - bufpush(0x03C9); - bufpush(0x0342); - bufpush(0x03B9); - break; - case 0x1FF8: - bufpush(0x1F78); - break; - case 0x1FF9: - bufpush(0x1F79); - break; - case 0x1FFA: - bufpush(0x1F7C); - break; - case 0x1FFB: - bufpush(0x1F7D); - break; - case 0x1FFC: - bufpush(0x03C9); - bufpush(0x03B9); - break; - case 0x2126: - bufpush(0x03C9); - break; - case 0x212A: - bufpush(0x006B); - break; - case 0x212B: - bufpush(0x00E5); - break; - case 0x2160: - bufpush(0x2170); - break; - case 0x2161: - bufpush(0x2171); - break; - case 0x2162: - bufpush(0x2172); - break; - case 0x2163: - bufpush(0x2173); - break; - case 0x2164: - bufpush(0x2174); - break; - case 0x2165: - bufpush(0x2175); - break; - case 0x2166: - bufpush(0x2176); - break; - case 0x2167: - bufpush(0x2177); - break; - case 0x2168: - bufpush(0x2178); - break; - case 0x2169: - bufpush(0x2179); - break; - case 0x216A: - bufpush(0x217A); - break; - case 0x216B: - bufpush(0x217B); - break; - case 0x216C: - bufpush(0x217C); - break; - case 0x216D: - bufpush(0x217D); - break; - case 0x216E: - bufpush(0x217E); - break; - case 0x216F: - bufpush(0x217F); - break; - case 0x24B6: - bufpush(0x24D0); - break; - case 0x24B7: - bufpush(0x24D1); - break; - case 0x24B8: - bufpush(0x24D2); - break; - case 0x24B9: - bufpush(0x24D3); - break; - case 0x24BA: - bufpush(0x24D4); - break; - case 0x24BB: - bufpush(0x24D5); - break; - case 0x24BC: - bufpush(0x24D6); - break; - case 0x24BD: - bufpush(0x24D7); - break; - case 0x24BE: - bufpush(0x24D8); - break; - case 0x24BF: - bufpush(0x24D9); - break; - case 0x24C0: - bufpush(0x24DA); - break; - case 0x24C1: - bufpush(0x24DB); - break; - case 0x24C2: - bufpush(0x24DC); - break; - case 0x24C3: - bufpush(0x24DD); - break; - case 0x24C4: - bufpush(0x24DE); - break; - case 0x24C5: - bufpush(0x24DF); - break; - case 0x24C6: - bufpush(0x24E0); - break; - case 0x24C7: - bufpush(0x24E1); - break; - case 0x24C8: - bufpush(0x24E2); - break; - case 0x24C9: - bufpush(0x24E3); - break; - case 0x24CA: - bufpush(0x24E4); - break; - case 0x24CB: - bufpush(0x24E5); - break; - case 0x24CC: - bufpush(0x24E6); - break; - case 0x24CD: - bufpush(0x24E7); - break; - case 0x24CE: - bufpush(0x24E8); - break; - case 0x24CF: - bufpush(0x24E9); - break; - case 0xFB00: - bufpush(0x0066); - bufpush(0x0066); - break; - case 0xFB01: - bufpush(0x0066); - bufpush(0x0069); - break; - case 0xFB02: - bufpush(0x0066); - bufpush(0x006C); - break; - case 0xFB03: - bufpush(0x0066); - bufpush(0x0066); - bufpush(0x0069); - break; - case 0xFB04: - bufpush(0x0066); - bufpush(0x0066); - bufpush(0x006C); - break; - case 0xFB05: - bufpush(0x0073); - bufpush(0x0074); - break; - case 0xFB06: - bufpush(0x0073); - bufpush(0x0074); - break; - case 0xFB13: - bufpush(0x0574); - bufpush(0x0576); - break; - case 0xFB14: - bufpush(0x0574); - bufpush(0x0565); - break; - case 0xFB15: - bufpush(0x0574); - bufpush(0x056B); - break; - case 0xFB16: - bufpush(0x057E); - bufpush(0x0576); - break; - case 0xFB17: - bufpush(0x0574); - bufpush(0x056D); - break; - case 0xFF21: - bufpush(0xFF41); - break; - case 0xFF22: - bufpush(0xFF42); - break; - case 0xFF23: - bufpush(0xFF43); - break; - case 0xFF24: - bufpush(0xFF44); - break; - case 0xFF25: - bufpush(0xFF45); - break; - case 0xFF26: - bufpush(0xFF46); - break; - case 0xFF27: - bufpush(0xFF47); - break; - case 0xFF28: - bufpush(0xFF48); - break; - case 0xFF29: - bufpush(0xFF49); - break; - case 0xFF2A: - bufpush(0xFF4A); - break; - case 0xFF2B: - bufpush(0xFF4B); - break; - case 0xFF2C: - bufpush(0xFF4C); - break; - case 0xFF2D: - bufpush(0xFF4D); - break; - case 0xFF2E: - bufpush(0xFF4E); - break; - case 0xFF2F: - bufpush(0xFF4F); - break; - case 0xFF30: - bufpush(0xFF50); - break; - case 0xFF31: - bufpush(0xFF51); - break; - case 0xFF32: - bufpush(0xFF52); - break; - case 0xFF33: - bufpush(0xFF53); - break; - case 0xFF34: - bufpush(0xFF54); - break; - case 0xFF35: - bufpush(0xFF55); - break; - case 0xFF36: - bufpush(0xFF56); - break; - case 0xFF37: - bufpush(0xFF57); - break; - case 0xFF38: - bufpush(0xFF58); - break; - case 0xFF39: - bufpush(0xFF59); - break; - case 0xFF3A: - bufpush(0xFF5A); - break; - case 0x10400: - bufpush(0x10428); - break; - case 0x10401: - bufpush(0x10429); - break; - case 0x10402: - bufpush(0x1042A); - break; - case 0x10403: - bufpush(0x1042B); - break; - case 0x10404: - bufpush(0x1042C); - break; - case 0x10405: - bufpush(0x1042D); - break; - case 0x10406: - bufpush(0x1042E); - break; - case 0x10407: - bufpush(0x1042F); - break; - case 0x10408: - bufpush(0x10430); - break; - case 0x10409: - bufpush(0x10431); - break; - case 0x1040A: - bufpush(0x10432); - break; - case 0x1040B: - bufpush(0x10433); - break; - case 0x1040C: - bufpush(0x10434); - break; - case 0x1040D: - bufpush(0x10435); - break; - case 0x1040E: - bufpush(0x10436); - break; - case 0x1040F: - bufpush(0x10437); - break; - case 0x10410: - bufpush(0x10438); - break; - case 0x10411: - bufpush(0x10439); - break; - case 0x10412: - bufpush(0x1043A); - break; - case 0x10413: - bufpush(0x1043B); - break; - case 0x10414: - bufpush(0x1043C); - break; - case 0x10415: - bufpush(0x1043D); - break; - case 0x10416: - bufpush(0x1043E); - break; - case 0x10417: - bufpush(0x1043F); - break; - case 0x10418: - bufpush(0x10440); - break; - case 0x10419: - bufpush(0x10441); - break; - case 0x1041A: - bufpush(0x10442); - break; - case 0x1041B: - bufpush(0x10443); - break; - case 0x1041C: - bufpush(0x10444); - break; - case 0x1041D: - bufpush(0x10445); - break; - case 0x1041E: - bufpush(0x10446); - break; - case 0x1041F: - bufpush(0x10447); - break; - case 0x10420: - bufpush(0x10448); - break; - case 0x10421: - bufpush(0x10449); - break; - case 0x10422: - bufpush(0x1044A); - break; - case 0x10423: - bufpush(0x1044B); - break; - case 0x10424: - bufpush(0x1044C); - break; - case 0x10425: - bufpush(0x1044D); - break; - default: - bufpush(c); - } diff --git a/cmark/chunk.h b/cmark/chunk.h deleted file mode 100644 --- a/cmark/chunk.h +++ /dev/null @@ -1,110 +0,0 @@ -#ifndef CMARK_CHUNK_H -#define CMARK_CHUNK_H - -#include -#include -#include -#include "cmark_ctype.h" -#include "buffer.h" - -typedef struct { - unsigned char *data; - int len; - int alloc; // also implies a NULL-terminated string -} cmark_chunk; - -static inline void cmark_chunk_free(cmark_chunk *c) -{ - if (c->alloc) - free(c->data); - - c->data = NULL; - c->alloc = 0; - c->len = 0; -} - -static inline void cmark_chunk_ltrim(cmark_chunk *c) -{ - assert(!c->alloc); - - while (c->len && cmark_isspace(c->data[0])) { - c->data++; - c->len--; - } -} - -static inline void cmark_chunk_rtrim(cmark_chunk *c) -{ - while (c->len > 0) { - if (!cmark_isspace(c->data[c->len - 1])) - break; - - c->len--; - } -} - -static inline void cmark_chunk_trim(cmark_chunk *c) -{ - cmark_chunk_ltrim(c); - cmark_chunk_rtrim(c); -} - -static inline int cmark_chunk_strchr(cmark_chunk *ch, int c, int offset) -{ - const unsigned char *p = (unsigned char *)memchr(ch->data + offset, c, ch->len - offset); - return p ? (int)(p - ch->data) : ch->len; -} - -static inline const char *cmark_chunk_to_cstr(cmark_chunk *c) -{ - unsigned char *str; - - if (c->alloc) { - return (char *)c->data; - } - str = (unsigned char *)malloc(c->len + 1); - if(str != NULL) { - memcpy(str, c->data, c->len); - str[c->len] = 0; - } - c->data = str; - c->alloc = 1; - - return (char *)str; -} - -static inline void cmark_chunk_set_cstr(cmark_chunk *c, const char *str) -{ - if (c->alloc) { - free(c->data); - } - c->len = strlen(str); - c->data = (unsigned char *)malloc(c->len + 1); - c->alloc = 1; - memcpy(c->data, str, c->len + 1); -} - -static inline cmark_chunk cmark_chunk_literal(const char *data) -{ - cmark_chunk c = {(unsigned char *)data, data ? strlen(data) : 0, 0}; - return c; -} - -static inline cmark_chunk cmark_chunk_dup(const cmark_chunk *ch, int pos, int len) -{ - cmark_chunk c = {ch->data + pos, len, 0}; - return c; -} - -static inline cmark_chunk cmark_chunk_buf_detach(cmark_strbuf *buf) -{ - cmark_chunk c; - - c.len = buf->size; - c.data = cmark_strbuf_detach(buf); - c.alloc = 1; - - return c; -} - -#endif diff --git a/cmark/cmark.c b/cmark/cmark.c deleted file mode 100644 --- a/cmark/cmark.c +++ /dev/null @@ -1,24 +0,0 @@ -#include -#include -#include -#include "node.h" -#include "houdini.h" -#include "cmark.h" -#include "buffer.h" - -const int cmark_version = CMARK_VERSION; -const char cmark_version_string[] = CMARK_VERSION_STRING; - -char *cmark_markdown_to_html(const char *text, int len, int options) -{ - cmark_node *doc; - char *result; - - doc = cmark_parse_document(text, len, options); - - result = cmark_render_html(doc, options); - cmark_node_free(doc); - - return result; -} - diff --git a/cmark/cmark.h b/cmark/cmark.h deleted file mode 100644 --- a/cmark/cmark.h +++ /dev/null @@ -1,560 +0,0 @@ -#ifndef CMARK_H -#define CMARK_H - -#include -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -/** # NAME - * - * **cmark** - CommonMark parsing, manipulating, and rendering - */ - -/** # DESCRIPTION - * - * ## Simple Interface - */ - -/** Convert 'text' (assumed to be a UTF-8 encoded string with length - * 'len' from CommonMark Markdown to HTML, returning a null-terminated, - * UTF-8-encoded string. - */ -CMARK_EXPORT -char *cmark_markdown_to_html(const char *text, int len, int options); - -/** ## Node Structure - */ - -typedef enum { - /* Error status */ - CMARK_NODE_NONE, - - /* Block */ - CMARK_NODE_DOCUMENT, - CMARK_NODE_BLOCK_QUOTE, - CMARK_NODE_LIST, - CMARK_NODE_ITEM, - CMARK_NODE_CODE_BLOCK, - CMARK_NODE_HTML, - CMARK_NODE_PARAGRAPH, - CMARK_NODE_HEADER, - CMARK_NODE_HRULE, - - CMARK_NODE_FIRST_BLOCK = CMARK_NODE_DOCUMENT, - CMARK_NODE_LAST_BLOCK = CMARK_NODE_HRULE, - - /* Inline */ - CMARK_NODE_TEXT, - CMARK_NODE_SOFTBREAK, - CMARK_NODE_LINEBREAK, - CMARK_NODE_CODE, - CMARK_NODE_INLINE_HTML, - CMARK_NODE_EMPH, - CMARK_NODE_STRONG, - CMARK_NODE_LINK, - CMARK_NODE_IMAGE, - - CMARK_NODE_FIRST_INLINE = CMARK_NODE_TEXT, - CMARK_NODE_LAST_INLINE = CMARK_NODE_IMAGE, -} cmark_node_type; - - -typedef enum { - CMARK_NO_LIST, - CMARK_BULLET_LIST, - CMARK_ORDERED_LIST -} cmark_list_type; - -typedef enum { - CMARK_NO_DELIM, - CMARK_PERIOD_DELIM, - CMARK_PAREN_DELIM -} cmark_delim_type; - -typedef struct cmark_node cmark_node; -typedef struct cmark_parser cmark_parser; -typedef struct cmark_iter cmark_iter; - -typedef enum { - CMARK_EVENT_NONE, - CMARK_EVENT_DONE, - CMARK_EVENT_ENTER, - CMARK_EVENT_EXIT -} cmark_event_type; - -/** - * ## Creating and Destroying Nodes - */ - -/** Creates a new node of type 'type'. Note that the node may have - * other required properties, which it is the caller's responsibility - * to assign. - */ -CMARK_EXPORT cmark_node* -cmark_node_new(cmark_node_type type); - -/** Frees the memory allocated for a node. - */ -CMARK_EXPORT void -cmark_node_free(cmark_node *node); - -/** - * ## Tree Traversal - */ - -/** Returns the next node in the sequence after 'node', or NULL if - * there is none. - */ -CMARK_EXPORT cmark_node* -cmark_node_next(cmark_node *node); - -/** Returns the previous node in the sequence after 'node', or NULL if - * there is none. - */ -CMARK_EXPORT cmark_node* -cmark_node_previous(cmark_node *node); - -/** Returns the parent of 'node', or NULL if there is none. - */ -CMARK_EXPORT cmark_node* -cmark_node_parent(cmark_node *node); - -/** Returns the first child of 'node', or NULL if 'node' has no children. - */ -CMARK_EXPORT cmark_node* -cmark_node_first_child(cmark_node *node); - -/** Returns the last child of 'node', or NULL if 'node' has no children. - */ -CMARK_EXPORT cmark_node* -cmark_node_last_child(cmark_node *node); - -/** - * ## Iterator - * - * An iterator will walk through a tree of nodes, starting from a root - * node, returning one node at a time, together with information about - * whether the node is being entered or exited. The iterator will - * first descend to a child node, if there is one. When there is no - * child, the iterator will go to the next sibling. When there is no - * next sibling, the iterator will return to the parent (but with - * a 'cmark_event_type' of `CMARK_EVENT_EXIT`). The iterator will - * return `CMARK_EVENT_DONE` when it reaches the root node again. - * One natural application is an HTML renderer, where an `ENTER` event - * outputs an open tag and an `EXIT` event outputs a close tag. - * An iterator might also be used to transform an AST in some systematic - * way, for example, turning all level-3 headers into regular paragraphs. - * - * void - * usage_example(cmark_node *root) { - * cmark_event_type ev_type; - * cmark_iter *iter = cmark_iter_new(root); - * - * while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { - * cmark_node *cur = cmark_iter_get_node(iter); - * // Do something with `cur` and `ev_type` - * } - * - * cmark_iter_free(iter); - * } - * - * Iterators will never return `EXIT` events for leaf nodes, which are nodes - * of type: - * - * * CMARK_NODE_HTML - * * CMARK_NODE_HRULE - * * CMARK_NODE_CODE_BLOCK - * * CMARK_NODE_TEXT - * * CMARK_NODE_SOFTBREAK - * * CMARK_NODE_LINEBREAK - * * CMARK_NODE_CODE - * * CMARK_NODE_INLINE_HTML - * - * Nodes must only be modified after an `EXIT` event, or an `ENTER` event for - * leaf nodes. - */ - -/** Creates a new iterator starting at 'root'. The current node and event - * type are undefined until `cmark_iter_next` is called for the first time. - */ -CMARK_EXPORT -cmark_iter* -cmark_iter_new(cmark_node *root); - -/** Frees the memory allocated for an iterator. - */ -CMARK_EXPORT -void -cmark_iter_free(cmark_iter *iter); - -/** Advances to the next node and returns the event type (`CMARK_EVENT_ENTER`, - * `CMARK_EVENT_EXIT` or `CMARK_EVENT_DONE`). - */ -CMARK_EXPORT -cmark_event_type -cmark_iter_next(cmark_iter *iter); - -/** Returns the current node. - */ -CMARK_EXPORT -cmark_node* -cmark_iter_get_node(cmark_iter *iter); - -/** Returns the current event type. - */ -CMARK_EXPORT -cmark_event_type -cmark_iter_get_event_type(cmark_iter *iter); - -/** Returns the root node. - */ -CMARK_EXPORT -cmark_node* -cmark_iter_get_root(cmark_iter *iter); - -/** Resets the iterator so that the current node is 'current' and - * the event type is 'event_type'. The new current node must be a - * descendant of the root node or the root node itself. - */ -CMARK_EXPORT -void -cmark_iter_reset(cmark_iter *iter, cmark_node *current, - cmark_event_type event_type); - -/** - * ## Accessors - */ - -/** Returns the user data of 'node'. - */ -CMARK_EXPORT void* -cmark_node_get_user_data(cmark_node *node); - -/** Sets arbitrary user data for 'node'. Returns 1 on success, - * 0 on failure. - */ -CMARK_EXPORT int -cmark_node_set_user_data(cmark_node *node, void *user_data); - -/** Returns the type of 'node', or `CMARK_NODE_NONE` on error. - */ -CMARK_EXPORT cmark_node_type -cmark_node_get_type(cmark_node *node); - -/** Like 'cmark_node_get_type', but returns a string representation - of the type, or `""`. - */ -CMARK_EXPORT -const char* -cmark_node_get_type_string(cmark_node *node); - -/** Returns the string contents of 'node', or NULL if none. - */ -CMARK_EXPORT const char* -cmark_node_get_literal(cmark_node *node); - -/** Sets the string contents of 'node'. Returns 1 on success, - * 0 on failure. - */ -CMARK_EXPORT int -cmark_node_set_literal(cmark_node *node, const char *content); - -/** Returns the header level of 'node', or 0 if 'node' is not a header. - */ -CMARK_EXPORT int -cmark_node_get_header_level(cmark_node *node); - -/** Sets the header level of 'node', returning 1 on success and 0 on error. - */ -CMARK_EXPORT int -cmark_node_set_header_level(cmark_node *node, int level); - -/** Returns the list type of 'node', or `CMARK_NO_LIST` if 'node' - * is not a list. - */ -CMARK_EXPORT cmark_list_type -cmark_node_get_list_type(cmark_node *node); - -/** Sets the list type of 'node', returning 1 on success and 0 on error. - */ -CMARK_EXPORT int -cmark_node_set_list_type(cmark_node *node, cmark_list_type type); - -/** Returns the list delimiter type of 'node', or `CMARK_NO_DELIM` if 'node' - * is not a list. - */ -CMARK_EXPORT cmark_delim_type -cmark_node_get_list_delim(cmark_node *node); - -/** Sets the list delimiter type of 'node', returning 1 on success and 0 - * on error. - */ -CMARK_EXPORT int -cmark_node_set_list_delim(cmark_node *node, cmark_delim_type delim); - -/** Returns starting number of 'node', if it is an ordered list, otherwise 0. - */ -CMARK_EXPORT int -cmark_node_get_list_start(cmark_node *node); - -/** Sets starting number of 'node', if it is an ordered list. Returns 1 - * on success, 0 on failure. - */ -CMARK_EXPORT int -cmark_node_set_list_start(cmark_node *node, int start); - -/** Returns 1 if 'node' is a tight list, 0 otherwise. - */ -CMARK_EXPORT int -cmark_node_get_list_tight(cmark_node *node); - -/** Sets the "tightness" of a list. Returns 1 on success, 0 on failure. - */ -CMARK_EXPORT int -cmark_node_set_list_tight(cmark_node *node, int tight); - -/** Returns the info string from a fenced code block, or NULL if none. - */ -CMARK_EXPORT const char* -cmark_node_get_fence_info(cmark_node *node); - -/** Sets the info string in a fenced code block, returning 1 on - * success and 0 on failure. - */ -CMARK_EXPORT int -cmark_node_set_fence_info(cmark_node *node, const char *info); - -/** Gets the URL of a link or image 'node', or NULL if none. - */ -CMARK_EXPORT const char* -cmark_node_get_url(cmark_node *node); - -/** Sets the URL of a link or image 'node'. Returns 1 on success, - * 0 on failure. - */ -CMARK_EXPORT int -cmark_node_set_url(cmark_node *node, const char *url); - -/** Gets the title of a link or image 'node', or NULL if none. - */ -CMARK_EXPORT const char* -cmark_node_get_title(cmark_node *node); - -/** Sets the title of a link or image 'node'. Returns 1 on success, - * 0 on failure. - */ -CMARK_EXPORT int -cmark_node_set_title(cmark_node *node, const char *title); - -/** Returns the line on which 'node' begins. - */ -CMARK_EXPORT int -cmark_node_get_start_line(cmark_node *node); - -/** Returns the column at which 'node' begins. - */ -CMARK_EXPORT int -cmark_node_get_start_column(cmark_node *node); - -/** Returns the line on which 'node' ends. - */ -CMARK_EXPORT int -cmark_node_get_end_line(cmark_node *node); - -/** Returns the column at which 'node' ends. - */ -CMARK_EXPORT int -cmark_node_get_end_column(cmark_node *node); - -/** - * ## Tree Manipulation - */ - -/** Unlinks a 'node', removing it from the tree, but not freeing its - * memory. (Use 'cmark_node_free' for that.) - */ -CMARK_EXPORT void -cmark_node_unlink(cmark_node *node); - -/** Inserts 'sibling' before 'node'. Returns 1 on success, 0 on failure. - */ -CMARK_EXPORT int -cmark_node_insert_before(cmark_node *node, cmark_node *sibling); - -/** Inserts 'sibling' after 'node'. Returns 1 on success, 0 on failure. - */ -CMARK_EXPORT int -cmark_node_insert_after(cmark_node *node, cmark_node *sibling); - -/** Adds 'child' to the beginning of the children of 'node'. - * Returns 1 on success, 0 on failure. - */ -CMARK_EXPORT int -cmark_node_prepend_child(cmark_node *node, cmark_node *child); - -/** Adds 'child' to the end of the children of 'node'. - * Returns 1 on success, 0 on failure. - */ -CMARK_EXPORT int -cmark_node_append_child(cmark_node *node, cmark_node *child); - -/** Consolidates adjacent text nodes. - */ -CMARK_EXPORT void -cmark_consolidate_text_nodes(cmark_node *root); - -/** - * ## Parsing - * - * Simple interface: - * - * cmark_node *document = cmark_parse_document("Hello *world*", 12, - * CMARK_OPT_DEFAULT); - * - * Streaming interface: - * - * cmark_parser *parser = cmark_parser_new(CMARK_OPT_DEFAULT); - * FILE *fp = fopen("myfile.md", "r"); - * while ((bytes = fread(buffer, 1, sizeof(buffer), fp)) > 0) { - * cmark_parser_feed(parser, buffer, bytes); - * if (bytes < sizeof(buffer)) { - * break; - * } - * } - * document = cmark_parser_finish(parser); - * cmark_parser_free(parser); - */ - -/** Creates a new parser object. - */ -CMARK_EXPORT -cmark_parser *cmark_parser_new(int options); - -/** Frees memory allocated for a parser object. - */ -CMARK_EXPORT -void cmark_parser_free(cmark_parser *parser); - -/** Feeds a string of length 'len' to 'parser'. - */ -CMARK_EXPORT -void cmark_parser_feed(cmark_parser *parser, const char *buffer, size_t len); - -/** Finish parsing and return a pointer to a tree of nodes. - */ -CMARK_EXPORT -cmark_node *cmark_parser_finish(cmark_parser *parser); - -/** Parse a CommonMark document in 'buffer' of length 'len'. - * Returns a pointer to a tree of nodes. - */ -CMARK_EXPORT -cmark_node *cmark_parse_document(const char *buffer, size_t len, int options); - -/** Parse a CommonMark document in file 'f', returning a pointer to - * a tree of nodes. - */ -CMARK_EXPORT -cmark_node *cmark_parse_file(FILE *f, int options); - -/** - * ## Rendering - */ - -/** Render a 'node' tree as XML. - */ -CMARK_EXPORT -char *cmark_render_xml(cmark_node *root, int options); - -/** Render a 'node' tree as an HTML fragment. It is up to the user - * to add an appropriate header and footer. - */ -CMARK_EXPORT -char *cmark_render_html(cmark_node *root, int options); - -/** Render a 'node' tree as a groff man page, without the header. - */ -CMARK_EXPORT -char *cmark_render_man(cmark_node *root, int options); - -/** Default writer options. - */ -#define CMARK_OPT_DEFAULT 0 - -/** Include a `data-sourcepos` attribute on all block elements. - */ -#define CMARK_OPT_SOURCEPOS 1 - -/** Render `softbreak` elements as hard line breaks. - */ -#define CMARK_OPT_HARDBREAKS 2 - -/** Normalize tree by consolidating adjacent text nodes. - */ -#define CMARK_OPT_NORMALIZE 4 - -/** Convert straight quotes to curly, --- to em dashes, -- to en dashes. - */ -#define CMARK_OPT_SMART 8 - -/** - * ## Version information - */ - -/** The library version as integer for runtime checks. Also available as - * macro CMARK_VERSION for compile time checks. - * - * * Bits 16-23 contain the major version. - * * Bits 8-15 contain the minor version. - * * Bits 0-7 contain the patchlevel. - * - * In hexadecimal format, the number 0x010203 represents version 1.2.3. - */ -CMARK_EXPORT -extern const int cmark_version; - -/** The library version string for runtime checks. Also available as - * macro CMARK_VERSION_STRING for compile time checks. - */ -CMARK_EXPORT -extern const char cmark_version_string[]; - -/** # AUTHORS - * - * John MacFarlane, Vicent Marti, Kārlis Gaņģis, Nick Wellnhofer. - */ - -#ifndef CMARK_NO_SHORT_NAMES -#define NODE_DOCUMENT CMARK_NODE_DOCUMENT -#define NODE_BLOCK_QUOTE CMARK_NODE_BLOCK_QUOTE -#define NODE_LIST CMARK_NODE_LIST -#define NODE_ITEM CMARK_NODE_ITEM -#define NODE_CODE_BLOCK CMARK_NODE_CODE_BLOCK -#define NODE_HTML CMARK_NODE_HTML -#define NODE_PARAGRAPH CMARK_NODE_PARAGRAPH -#define NODE_HEADER CMARK_NODE_HEADER -#define NODE_HRULE CMARK_NODE_HRULE -#define NODE_TEXT CMARK_NODE_TEXT -#define NODE_SOFTBREAK CMARK_NODE_SOFTBREAK -#define NODE_LINEBREAK CMARK_NODE_LINEBREAK -#define NODE_CODE CMARK_NODE_CODE -#define NODE_INLINE_HTML CMARK_NODE_INLINE_HTML -#define NODE_EMPH CMARK_NODE_EMPH -#define NODE_STRONG CMARK_NODE_STRONG -#define NODE_LINK CMARK_NODE_LINK -#define NODE_IMAGE CMARK_NODE_IMAGE -#define BULLET_LIST CMARK_BULLET_LIST -#define ORDERED_LIST CMARK_ORDERED_LIST -#define PERIOD_DELIM CMARK_PERIOD_DELIM -#define PAREN_DELIM CMARK_PAREN_DELIM -#endif - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/cmark/cmark_ctype.c b/cmark/cmark_ctype.c deleted file mode 100644 --- a/cmark/cmark_ctype.c +++ /dev/null @@ -1,53 +0,0 @@ -#include - -#include "cmark_ctype.h" - -/** 1 = space, 2 = punct, 3 = digit, 4 = alpha, 0 = other - */ -static const int8_t cmark_ctype_class[256] = { - /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ - /* 0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, - /* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - /* 2 */ 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - /* 3 */ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, - /* 4 */ 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, - /* 5 */ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, - /* 6 */ 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, - /* 7 */ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 0, - /* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - /* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - /* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - /* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - /* c */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - /* d */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - /* e */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - /* f */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 -}; - -/** - * Returns 1 if c is a "whitespace" character as defined by the spec. - */ -int cmark_isspace(char c) -{ - return cmark_ctype_class[(int8_t)c] == 1; -} - -/** - * Returns 1 if c is an ascii punctuation character. - */ -int cmark_ispunct(char c) -{ - return cmark_ctype_class[(int8_t)c] == 2; -} - -int cmark_isalnum(char c) -{ - int8_t result; - result = cmark_ctype_class[(int8_t)c]; - return (result == 3 || result == 4); -} - -int cmark_isdigit(char c) -{ - return cmark_ctype_class[(int8_t)c] == 3; -} diff --git a/cmark/cmark_ctype.h b/cmark/cmark_ctype.h deleted file mode 100644 --- a/cmark/cmark_ctype.h +++ /dev/null @@ -1,24 +0,0 @@ -#ifndef CMARK_CMARK_CTYPE_H -#define CMARK_CMARK_CTYPE_H - -#ifdef __cplusplus -extern "C" { -#endif - -/** Locale-independent versions of functions from ctype.h. - * We want cmark to behave the same no matter what the system locale. - */ - -int cmark_isspace(char c); - -int cmark_ispunct(char c); - -int cmark_isalnum(char c); - -int cmark_isdigit(char c); - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/cmark/cmark_export.h b/cmark/cmark_export.h deleted file mode 100644 --- a/cmark/cmark_export.h +++ /dev/null @@ -1,35 +0,0 @@ - -#ifndef CMARK_EXPORT_H -#define CMARK_EXPORT_H - -#ifdef CMARK_STATIC_DEFINE -# define CMARK_EXPORT -# define CMARK_NO_EXPORT -#else -# ifndef CMARK_EXPORT -# ifdef libcmark_EXPORTS - /* We are building this library */ -# define CMARK_EXPORT __attribute__((visibility("default"))) -# else - /* We are using this library */ -# define CMARK_EXPORT __attribute__((visibility("default"))) -# endif -# endif - -# ifndef CMARK_NO_EXPORT -# define CMARK_NO_EXPORT __attribute__((visibility("hidden"))) -# endif -#endif - -#ifndef CMARK_DEPRECATED -# define CMARK_DEPRECATED __attribute__ ((__deprecated__)) -# define CMARK_DEPRECATED_EXPORT CMARK_EXPORT __attribute__ ((__deprecated__)) -# define CMARK_DEPRECATED_NO_EXPORT CMARK_NO_EXPORT __attribute__ ((__deprecated__)) -#endif - -#define DEFINE_NO_DEPRECATED 0 -#if DEFINE_NO_DEPRECATED -# define CMARK_NO_DEPRECATED -#endif - -#endif diff --git a/cmark/cmark_version.h b/cmark/cmark_version.h deleted file mode 100644 --- a/cmark/cmark_version.h +++ /dev/null @@ -1,7 +0,0 @@ -#ifndef CMARK_VERSION_H -#define CMARK_VERSION_H - -#define CMARK_VERSION ((0 << 16) | (18 << 8) | 1) -#define CMARK_VERSION_STRING "0.18.1" - -#endif diff --git a/cmark/config.h b/cmark/config.h deleted file mode 100644 --- a/cmark/config.h +++ /dev/null @@ -1,23 +0,0 @@ -#define HAVE_STDBOOL_H - -#ifdef HAVE_STDBOOL_H - #include -#elif !defined(__cplusplus) - typedef char bool; -#endif - -/* #undef HAVE___BUILTIN_EXPECT */ - -#define HAVE___ATTRIBUTE__ - -#ifdef HAVE___ATTRIBUTE__ - #define CMARK_ATTRIBUTE(list) __attribute__ (list) -#else - #define CMARK_ATTRIBUTE(list) -#endif - -#define HAVE_VA_COPY - -#ifndef HAVE_VA_COPY - #define va_copy(dest, src) ((dest) = (src)) -#endif diff --git a/cmark/debug.h b/cmark/debug.h deleted file mode 100644 --- a/cmark/debug.h +++ /dev/null @@ -1,36 +0,0 @@ -#ifndef CMARK_DEBUG_H -#define CMARK_DEBUG_H -#include -#include -#include - -#ifdef NDEBUG -#define debug(M, ...) -#else -#define debug(M, ...) \ - fprintf(stderr, "DEBUG %s:%d: " M "\n", __FILE__, __LINE__, ##__VA_ARGS__) -#endif - -#define clean_errno() (errno == 0 ? "None" : strerror(errno)) - -#define log_err(M, ...) \ - fprintf(stderr, "[ERROR] (%s:%d: errno: %s) " M "\n", __FILE__, __LINE__, \ - clean_errno(), ##__VA_ARGS__) - -#define log_warn(M, ...) \ - fprintf(stderr, "[WARN] (%s:%d: errno: %s) " M "\n", __FILE__, __LINE__, \ - clean_errno(), ##__VA_ARGS__) - -#define log_info(M, ...) fprintf(stderr, "[INFO] (%s:%d) " M "\n", __FILE__, \ - __LINE__, ##__VA_ARGS__) - -#define check(A, M, ...) \ - if(!(A)) { log_err(M, ##__VA_ARGS__); errno=0; goto error; } - -#define sentinel(M, ...) \ - { log_err(M, ##__VA_ARGS__); errno=0; goto error; } - -#define check_debug(A, M, ...) \ - if(!(A)) { debug(M, ##__VA_ARGS__); errno=0; goto error; } - -#endif diff --git a/cmark/houdini.h b/cmark/houdini.h deleted file mode 100644 --- a/cmark/houdini.h +++ /dev/null @@ -1,52 +0,0 @@ -#ifndef CMARK_HOUDINI_H -#define CMARK_HOUDINI_H - -#ifdef __cplusplus -extern "C" { -#endif - -#include -#include "config.h" -#include "buffer.h" - -#ifdef HAVE___BUILTIN_EXPECT -# define likely(x) __builtin_expect((x),1) -# define unlikely(x) __builtin_expect((x),0) -#else -# define likely(x) (x) -# define unlikely(x) (x) -#endif - -#ifdef HOUDINI_USE_LOCALE -# define _isxdigit(c) isxdigit(c) -# define _isdigit(c) isdigit(c) -#else -/* - * Helper _isdigit methods -- do not trust the current locale - * */ -# define _isxdigit(c) (strchr("0123456789ABCDEFabcdef", (c)) != NULL) -# define _isdigit(c) ((c) >= '0' && (c) <= '9') -#endif - -#define HOUDINI_ESCAPED_SIZE(x) (((x) * 12) / 10) -#define HOUDINI_UNESCAPED_SIZE(x) (x) - -extern size_t houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src, size_t size); -extern int houdini_escape_html(cmark_strbuf *ob, const uint8_t *src, size_t size); -extern int houdini_escape_html0(cmark_strbuf *ob, const uint8_t *src, size_t size, int secure); -extern int houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src, size_t size); -extern void houdini_unescape_html_f(cmark_strbuf *ob, const uint8_t *src, size_t size); -extern int houdini_escape_xml(cmark_strbuf *ob, const uint8_t *src, size_t size); -extern int houdini_escape_uri(cmark_strbuf *ob, const uint8_t *src, size_t size); -extern int houdini_escape_url(cmark_strbuf *ob, const uint8_t *src, size_t size); -extern int houdini_escape_href(cmark_strbuf *ob, const uint8_t *src, size_t size); -extern int houdini_unescape_uri(cmark_strbuf *ob, const uint8_t *src, size_t size); -extern int houdini_unescape_url(cmark_strbuf *ob, const uint8_t *src, size_t size); -extern int houdini_escape_js(cmark_strbuf *ob, const uint8_t *src, size_t size); -extern int houdini_unescape_js(cmark_strbuf *ob, const uint8_t *src, size_t size); - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/cmark/houdini_href_e.c b/cmark/houdini_href_e.c deleted file mode 100644 --- a/cmark/houdini_href_e.c +++ /dev/null @@ -1,107 +0,0 @@ -#include -#include -#include - -#include "houdini.h" - -/* - * The following characters will not be escaped: - * - * -_.+!*'(),%#@?=;:/,+&$ alphanum - * - * Note that this character set is the addition of: - * - * - The characters which are safe to be in an URL - * - The characters which are *not* safe to be in - * an URL because they are RESERVED characters. - * - * We asume (lazily) that any RESERVED char that - * appears inside an URL is actually meant to - * have its native function (i.e. as an URL - * component/separator) and hence needs no escaping. - * - * There are two exceptions: the chacters & (amp) - * and ' (single quote) do not appear in the table. - * They are meant to appear in the URL as components, - * yet they require special HTML-entity escaping - * to generate valid HTML markup. - * - * All other characters will be escaped to %XX. - * - */ -static const char HREF_SAFE[] = { - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, - 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -}; - -int -houdini_escape_href(cmark_strbuf *ob, const uint8_t *src, size_t size) -{ - static const uint8_t hex_chars[] = "0123456789ABCDEF"; - size_t i = 0, org; - uint8_t hex_str[3]; - - hex_str[0] = '%'; - - while (i < size) { - org = i; - while (i < size && HREF_SAFE[src[i]] != 0) - i++; - - if (likely(i > org)) - cmark_strbuf_put(ob, src + org, i - org); - - /* escaping */ - if (i >= size) - break; - - switch (src[i]) { - /* amp appears all the time in URLs, but needs - * HTML-entity escaping to be inside an href */ - case '&': - cmark_strbuf_puts(ob, "&"); - break; - - /* the single quote is a valid URL character - * according to the standard; it needs HTML - * entity escaping too */ - case '\'': - cmark_strbuf_puts(ob, "'"); - break; - - /* the space can be escaped to %20 or a plus - * sign. we're going with the generic escape - * for now. the plus thing is more commonly seen - * when building GET strings */ -#if 0 - case ' ': - cmark_strbuf_putc(ob, '+'); - break; -#endif - - /* every other character goes with a %XX escaping */ - default: - hex_str[1] = hex_chars[(src[i] >> 4) & 0xF]; - hex_str[2] = hex_chars[src[i] & 0xF]; - cmark_strbuf_put(ob, hex_str, 3); - } - - i++; - } - - return 1; -} diff --git a/cmark/houdini_html_e.c b/cmark/houdini_html_e.c deleted file mode 100644 --- a/cmark/houdini_html_e.c +++ /dev/null @@ -1,81 +0,0 @@ -#include -#include -#include - -#include "houdini.h" - -/** - * According to the OWASP rules: - * - * & --> & - * < --> < - * > --> > - * " --> " - * ' --> ' ' is not recommended - * / --> / forward slash is included as it helps end an HTML entity - * - */ -static const char HTML_ESCAPE_TABLE[] = { - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1, 0, 0, 0, 2, 3, 0, 0, 0, 0, 0, 0, 0, 4, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 6, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -}; - -static const char *HTML_ESCAPES[] = { - "", - """, - "&", - "'", - "/", - "<", - ">" -}; - -int -houdini_escape_html0(cmark_strbuf *ob, const uint8_t *src, size_t size, int secure) -{ - size_t i = 0, org, esc = 0; - - while (i < size) { - org = i; - while (i < size && (esc = HTML_ESCAPE_TABLE[src[i]]) == 0) - i++; - - if (i > org) - cmark_strbuf_put(ob, src + org, i - org); - - /* escaping */ - if (unlikely(i >= size)) - break; - - /* The forward slash is only escaped in secure mode */ - if ((src[i] == '/' || src[i] == '\'') && !secure) { - cmark_strbuf_putc(ob, src[i]); - } else { - cmark_strbuf_puts(ob, HTML_ESCAPES[esc]); - } - - i++; - } - - return 1; -} - -int -houdini_escape_html(cmark_strbuf *ob, const uint8_t *src, size_t size) -{ - return houdini_escape_html0(ob, src, size, 1); -} diff --git a/cmark/houdini_html_u.c b/cmark/houdini_html_u.c deleted file mode 100644 --- a/cmark/houdini_html_u.c +++ /dev/null @@ -1,116 +0,0 @@ -#include -#include -#include - -#include "buffer.h" -#include "houdini.h" -#include "utf8.h" -#include "html_unescape.h" - -size_t -houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src, size_t size) -{ - size_t i = 0; - - if (size > 3 && src[0] == '#') { - int codepoint = 0; - - if (_isdigit(src[1])) { - for (i = 1; i < size && _isdigit(src[i]); ++i) { - int cp = (codepoint * 10) + (src[i] - '0'); - - if (cp < codepoint) - return 0; - - codepoint = cp; - } - } - - else if (src[1] == 'x' || src[1] == 'X') { - for (i = 2; i < size && _isxdigit(src[i]); ++i) { - int cp = (codepoint * 16) + ((src[i] | 32) % 39 - 9); - - if (cp < codepoint) - return 0; - - codepoint = cp; - } - } - - if (i < size && src[i] == ';' && codepoint) { - utf8proc_encode_char(codepoint, ob); - return i + 1; - } - } - - else { - if (size > MAX_WORD_LENGTH) - size = MAX_WORD_LENGTH; - - for (i = MIN_WORD_LENGTH; i < size; ++i) { - if (src[i] == ' ') - break; - - if (src[i] == ';') { - const struct html_ent *entity = find_entity((char *)src, i); - - if (entity != NULL) { - int len = 0; - while (len < 4 && entity->utf8[len] != '\0') { - ++len; - } - cmark_strbuf_put(ob, entity->utf8, len); - return i + 1; - } - - break; - } - } - } - - return 0; -} - -int -houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src, size_t size) -{ - size_t i = 0, org, ent; - - while (i < size) { - org = i; - while (i < size && src[i] != '&') - i++; - - if (likely(i > org)) { - if (unlikely(org == 0)) { - if (i >= size) - return 0; - - cmark_strbuf_grow(ob, HOUDINI_UNESCAPED_SIZE(size)); - } - - cmark_strbuf_put(ob, src + org, i - org); - } - - /* escaping */ - if (i >= size) - break; - - i++; - - ent = houdini_unescape_ent(ob, src + i, size - i); - i += ent; - - /* not really an entity */ - if (ent == 0) - cmark_strbuf_putc(ob, '&'); - } - - return 1; -} - -void houdini_unescape_html_f(cmark_strbuf *ob, const uint8_t *src, size_t size) -{ - if (!houdini_unescape_html(ob, src, size)) - cmark_strbuf_put(ob, src, size); -} diff --git a/cmark/html.c b/cmark/html.c deleted file mode 100644 --- a/cmark/html.c +++ /dev/null @@ -1,322 +0,0 @@ -#include -#include -#include -#include - -#include "config.h" -#include "cmark.h" -#include "node.h" -#include "buffer.h" -#include "houdini.h" - -// Functions to convert cmark_nodes to HTML strings. - -static void escape_html(cmark_strbuf *dest, const unsigned char *source, int length) -{ - if (length < 0) - length = strlen((char *)source); - - houdini_escape_html0(dest, source, (size_t)length, 0); -} - -static void escape_href(cmark_strbuf *dest, const unsigned char *source, int length) -{ - if (length < 0) - length = strlen((char *)source); - - houdini_escape_href(dest, source, (size_t)length); -} - -static inline void cr(cmark_strbuf *html) -{ - if (html->size && html->ptr[html->size - 1] != '\n') - cmark_strbuf_putc(html, '\n'); -} - -struct render_state { - cmark_strbuf* html; - cmark_node *plain; -}; - -static void -S_render_sourcepos(cmark_node *node, cmark_strbuf *html, int options) -{ - if (CMARK_OPT_SOURCEPOS & options) { - cmark_strbuf_printf(html, " data-sourcepos=\"%d:%d-%d:%d\"", - cmark_node_get_start_line(node), - cmark_node_get_start_column(node), - cmark_node_get_end_line(node), - cmark_node_get_end_column(node)); - } -} - -static int -S_render_node(cmark_node *node, cmark_event_type ev_type, - struct render_state *state, int options) -{ - cmark_node *parent; - cmark_node *grandparent; - cmark_strbuf *html = state->html; - char start_header[] = "plain == node) { // back at original node - state->plain = NULL; - } - - if (state->plain != NULL) { - switch(node->type) { - case CMARK_NODE_TEXT: - case CMARK_NODE_CODE: - case CMARK_NODE_INLINE_HTML: - escape_html(html, node->as.literal.data, - node->as.literal.len); - break; - - case CMARK_NODE_LINEBREAK: - case CMARK_NODE_SOFTBREAK: - cmark_strbuf_putc(html, ' '); - break; - - default: - break; - } - return 1; - } - - switch (node->type) { - case CMARK_NODE_DOCUMENT: - break; - - case CMARK_NODE_BLOCK_QUOTE: - if (entering) { - cr(html); - cmark_strbuf_puts(html, "\n"); - } else { - cr(html); - cmark_strbuf_puts(html, "\n"); - } - break; - - case CMARK_NODE_LIST: { - cmark_list_type list_type = node->as.list.list_type; - int start = node->as.list.start; - - if (entering) { - cr(html); - if (list_type == CMARK_BULLET_LIST) { - cmark_strbuf_puts(html, "\n"); - } else if (start == 1) { - cmark_strbuf_puts(html, "\n"); - } else { - cmark_strbuf_printf(html, - "
    \n"); - } - } else { - cmark_strbuf_puts(html, - list_type == CMARK_BULLET_LIST ? - "\n" : "
\n"); - } - break; - } - - case CMARK_NODE_ITEM: - if (entering) { - cr(html); - cmark_strbuf_puts(html, "'); - } else { - cmark_strbuf_puts(html, "\n"); - } - break; - - case CMARK_NODE_HEADER: - if (entering) { - cr(html); - start_header[2] = '0' + node->as.header.level; - cmark_strbuf_puts(html, start_header); - S_render_sourcepos(node, html, options); - cmark_strbuf_putc(html, '>'); - } else { - end_header[3] = '0' + node->as.header.level; - cmark_strbuf_puts(html, end_header); - cmark_strbuf_puts(html, ">\n"); - } - break; - - case CMARK_NODE_CODE_BLOCK: - cr(html); - - if (!node->as.code.fenced || node->as.code.info.len == 0) { - cmark_strbuf_puts(html, ""); - } else { - int first_tag = 0; - while (first_tag < node->as.code.info.len && - node->as.code.info.data[first_tag] != ' ') { - first_tag += 1; - } - - cmark_strbuf_puts(html, "as.code.info.data, first_tag); - cmark_strbuf_puts(html, "\">"); - } - - escape_html(html, node->as.code.literal.data, - node->as.code.literal.len); - cmark_strbuf_puts(html, "\n"); - break; - - case CMARK_NODE_HTML: - cr(html); - cmark_strbuf_put(html, node->as.literal.data, node->as.literal.len); - break; - - case CMARK_NODE_HRULE: - cr(html); - cmark_strbuf_puts(html, "\n"); - break; - - case CMARK_NODE_PARAGRAPH: - parent = cmark_node_parent(node); - grandparent = cmark_node_parent(parent); - if (grandparent != NULL && - grandparent->type == CMARK_NODE_LIST) { - tight = grandparent->as.list.tight; - } else { - tight = false; - } - if (!tight) { - if (entering) { - cr(html); - cmark_strbuf_puts(html, "'); - } else { - cmark_strbuf_puts(html, "

\n"); - } - } - break; - - case CMARK_NODE_TEXT: - escape_html(html, node->as.literal.data, node->as.literal.len); - break; - - case CMARK_NODE_LINEBREAK: - cmark_strbuf_puts(html, "
\n"); - break; - - case CMARK_NODE_SOFTBREAK: - if (options & CMARK_OPT_HARDBREAKS) { - cmark_strbuf_puts(html, "
\n"); - } else { - cmark_strbuf_putc(html, '\n'); - } - break; - - case CMARK_NODE_CODE: - cmark_strbuf_puts(html, ""); - escape_html(html, node->as.literal.data, node->as.literal.len); - cmark_strbuf_puts(html, ""); - break; - - case CMARK_NODE_INLINE_HTML: - cmark_strbuf_put(html, node->as.literal.data, node->as.literal.len); - break; - - case CMARK_NODE_STRONG: - if (entering) { - cmark_strbuf_puts(html, ""); - } else { - cmark_strbuf_puts(html, ""); - } - break; - - case CMARK_NODE_EMPH: - if (entering) { - cmark_strbuf_puts(html, ""); - } else { - cmark_strbuf_puts(html, ""); - } - break; - - case CMARK_NODE_LINK: - if (entering) { - cmark_strbuf_puts(html, "as.link.url) - escape_href(html, node->as.link.url, -1); - - if (node->as.link.title) { - cmark_strbuf_puts(html, "\" title=\""); - escape_html(html, node->as.link.title, -1); - } - - cmark_strbuf_puts(html, "\">"); - } else { - cmark_strbuf_puts(html, ""); - } - break; - - case CMARK_NODE_IMAGE: - if (entering) { - cmark_strbuf_puts(html, "as.link.url) - escape_href(html, node->as.link.url, -1); - - cmark_strbuf_puts(html, "\" alt=\""); - state->plain = node; - } else { - if (node->as.link.title) { - cmark_strbuf_puts(html, "\" title=\""); - escape_html(html, node->as.link.title, -1); - } - - cmark_strbuf_puts(html, "\" />"); - } - break; - - default: - assert(false); - break; - } - - // cmark_strbuf_putc(html, 'x'); - return 1; -} - -char *cmark_render_html(cmark_node *root, int options) -{ - char *result; - cmark_strbuf html = GH_BUF_INIT; - cmark_event_type ev_type; - cmark_node *cur; - struct render_state state = { &html, NULL }; - cmark_iter *iter = cmark_iter_new(root); - - while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { - cur = cmark_iter_get_node(iter); - S_render_node(cur, ev_type, &state, options); - } - result = (char *)cmark_strbuf_detach(&html); - - cmark_iter_free(iter); - return result; -} diff --git a/cmark/html_unescape.h b/cmark/html_unescape.h deleted file mode 100644 --- a/cmark/html_unescape.h +++ /dev/null @@ -1,13375 +0,0 @@ -/* ANSI-C code produced by gperf version 3.0.3 */ -/* Command-line: /Library/Developer/CommandLineTools/usr/bin/gperf -L ANSI-C -I -t -N find_entity -H hash_entity -K entity -C -l -F ',{0}' --null-strings -m5 -P -Q entity_pool src/html_unescape.gperf */ -/* Computed positions: -k'1-7,10,12,$' */ - -#if !((' ' == 32) && ('!' == 33) && ('"' == 34) && ('#' == 35) \ - && ('%' == 37) && ('&' == 38) && ('\'' == 39) && ('(' == 40) \ - && (')' == 41) && ('*' == 42) && ('+' == 43) && (',' == 44) \ - && ('-' == 45) && ('.' == 46) && ('/' == 47) && ('0' == 48) \ - && ('1' == 49) && ('2' == 50) && ('3' == 51) && ('4' == 52) \ - && ('5' == 53) && ('6' == 54) && ('7' == 55) && ('8' == 56) \ - && ('9' == 57) && (':' == 58) && (';' == 59) && ('<' == 60) \ - && ('=' == 61) && ('>' == 62) && ('?' == 63) && ('A' == 65) \ - && ('B' == 66) && ('C' == 67) && ('D' == 68) && ('E' == 69) \ - && ('F' == 70) && ('G' == 71) && ('H' == 72) && ('I' == 73) \ - && ('J' == 74) && ('K' == 75) && ('L' == 76) && ('M' == 77) \ - && ('N' == 78) && ('O' == 79) && ('P' == 80) && ('Q' == 81) \ - && ('R' == 82) && ('S' == 83) && ('T' == 84) && ('U' == 85) \ - && ('V' == 86) && ('W' == 87) && ('X' == 88) && ('Y' == 89) \ - && ('Z' == 90) && ('[' == 91) && ('\\' == 92) && (']' == 93) \ - && ('^' == 94) && ('_' == 95) && ('a' == 97) && ('b' == 98) \ - && ('c' == 99) && ('d' == 100) && ('e' == 101) && ('f' == 102) \ - && ('g' == 103) && ('h' == 104) && ('i' == 105) && ('j' == 106) \ - && ('k' == 107) && ('l' == 108) && ('m' == 109) && ('n' == 110) \ - && ('o' == 111) && ('p' == 112) && ('q' == 113) && ('r' == 114) \ - && ('s' == 115) && ('t' == 116) && ('u' == 117) && ('v' == 118) \ - && ('w' == 119) && ('x' == 120) && ('y' == 121) && ('z' == 122) \ - && ('{' == 123) && ('|' == 124) && ('}' == 125) && ('~' == 126)) -/* The character set is not based on ISO-646. */ -#error "gperf generated tables don't work with this execution character set. Please report a bug to ." -#endif - -#line 1 "src/html_unescape.gperf" -struct html_ent { - int entity; - unsigned char utf8[4]; -}; -#include -#include - -#define TOTAL_KEYWORDS 2125 -#define MIN_WORD_LENGTH 2 -#define MAX_WORD_LENGTH 31 -#define MIN_HASH_VALUE 39 -#define MAX_HASH_VALUE 16000 -/* maximum key range = 15962, duplicates = 0 */ - -#ifdef __GNUC__ -__inline -#else -#ifdef __cplusplus -inline -#endif -#endif -static unsigned int -hash_entity (register const char *str, register unsigned int len) -{ - static const unsigned short asso_values[] = - { - 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, - 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, - 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, - 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, - 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 2, - 3, 7, 2, 4, 8, 16001, 10, 16001, 16001, 16001, - 16001, 16001, 16001, 16001, 16001, 1890, 1538, 220, 165, 1045, - 535, 1971, 1187, 1262, 35, 126, 201, 133, 350, 1487, - 1965, 3, 478, 134, 8, 147, 73, 41, 23, 212, - 9, 16001, 2, 16001, 2, 16001, 16001, 4154, 29, 3168, - 429, 10, 146, 1925, 2307, 280, 1313, 1924, 4, 651, - 27, 1031, 65, 176, 2, 6, 17, 15, 107, 482, - 3207, 3865, 757, 131, 178, 4, 4, 16001, 16001, 16001, - 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, - 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, - 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, - 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, - 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, - 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, - 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, - 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, - 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, - 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, - 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, - 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, - 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001 - }; - register unsigned int hval = len; - - switch (hval) - { - default: - hval += asso_values[(unsigned char)str[11]]; - /*FALLTHROUGH*/ - case 11: - case 10: - hval += asso_values[(unsigned char)str[9]]; - /*FALLTHROUGH*/ - case 9: - case 8: - case 7: - hval += asso_values[(unsigned char)str[6]]; - /*FALLTHROUGH*/ - case 6: - hval += asso_values[(unsigned char)str[5]]; - /*FALLTHROUGH*/ - case 5: - hval += asso_values[(unsigned char)str[4]+1]; - /*FALLTHROUGH*/ - case 4: - hval += asso_values[(unsigned char)str[3]+3]; - /*FALLTHROUGH*/ - case 3: - hval += asso_values[(unsigned char)str[2]+1]; - /*FALLTHROUGH*/ - case 2: - hval += asso_values[(unsigned char)str[1]+4]; - /*FALLTHROUGH*/ - case 1: - hval += asso_values[(unsigned char)str[0]]; - break; - } - return hval + asso_values[(unsigned char)str[len - 1]]; -} - -struct entity_pool_t - { - char entity_pool_str39[sizeof("rarr")]; - char entity_pool_str41[sizeof("larr")]; - char entity_pool_str49[sizeof("lat")]; - char entity_pool_str52[sizeof("uarr")]; - char entity_pool_str55[sizeof("npr")]; - char entity_pool_str62[sizeof("rarrtl")]; - char entity_pool_str64[sizeof("larrtl")]; - char entity_pool_str65[sizeof("roarr")]; - char entity_pool_str67[sizeof("loarr")]; - char entity_pool_str68[sizeof("not")]; - char entity_pool_str69[sizeof("rpar")]; - char entity_pool_str70[sizeof("bot")]; - char entity_pool_str71[sizeof("lpar")]; - char entity_pool_str73[sizeof("spar")]; - char entity_pool_str75[sizeof("ll")]; - char entity_pool_str76[sizeof("uharr")]; - char entity_pool_str77[sizeof("epar")]; - char entity_pool_str81[sizeof("el")]; - char entity_pool_str83[sizeof("rotimes")]; - char entity_pool_str85[sizeof("lotimes")]; - char entity_pool_str86[sizeof("par")]; - char entity_pool_str88[sizeof("nharr")]; - char entity_pool_str94[sizeof("npar")]; - char entity_pool_str97[sizeof("tprime")]; - char entity_pool_str101[sizeof("els")]; - char entity_pool_str102[sizeof("eparsl")]; - char entity_pool_str104[sizeof("ensp")]; - char entity_pool_str109[sizeof("bprime")]; - char entity_pool_str110[sizeof("lnap")]; - char entity_pool_str111[sizeof("blk14")]; - char entity_pool_str115[sizeof("blk12")]; - char entity_pool_str117[sizeof("blk34")]; - char entity_pool_str119[sizeof("nparsl")]; - char entity_pool_str123[sizeof("nldr")]; - char entity_pool_str124[sizeof("rlarr")]; - char entity_pool_str125[sizeof("npart")]; - char entity_pool_str126[sizeof("llarr")]; - char entity_pool_str127[sizeof("nlt")]; - char entity_pool_str128[sizeof("slarr")]; - char entity_pool_str138[sizeof("nparallel")]; - char entity_pool_str143[sizeof("Tau")]; - char entity_pool_str144[sizeof("varr")]; - char entity_pool_str146[sizeof("squ")]; - char entity_pool_str149[sizeof("nlarr")]; - char entity_pool_str152[sizeof("tau")]; - char entity_pool_str165[sizeof("lne")]; - char entity_pool_str166[sizeof("rrarr")]; - char entity_pool_str168[sizeof("lrarr")]; - char entity_pool_str170[sizeof("srarr")]; - char entity_pool_str171[sizeof("rharul")]; - char entity_pool_str173[sizeof("lharul")]; - char entity_pool_str174[sizeof("erarr")]; - char entity_pool_str176[sizeof("pr")]; - char entity_pool_str177[sizeof("rharu")]; - char entity_pool_str179[sizeof("lharu")]; - char entity_pool_str184[sizeof("Uarr")]; - char entity_pool_str188[sizeof("nGt")]; - char entity_pool_str190[sizeof("bne")]; - char entity_pool_str191[sizeof("nrarr")]; - char entity_pool_str194[sizeof("swarr")]; - char entity_pool_str198[sizeof("rarrap")]; - char entity_pool_str200[sizeof("upuparrows")]; - char entity_pool_str202[sizeof("Darr")]; - char entity_pool_str205[sizeof("rbarr")]; - char entity_pool_str206[sizeof("Dot")]; - char entity_pool_str207[sizeof("lbarr")]; - char entity_pool_str215[sizeof("nwarr")]; - char entity_pool_str217[sizeof("smt")]; - char entity_pool_str222[sizeof("emsp14")]; - char entity_pool_str223[sizeof("rarrpl")]; - char entity_pool_str225[sizeof("larrpl")]; - char entity_pool_str230[sizeof("phmmat")]; - char entity_pool_str232[sizeof("emsp13")]; - char entity_pool_str234[sizeof("LT")]; - char entity_pool_str238[sizeof("Larr")]; - char entity_pool_str239[sizeof("rbrkslu")]; - char entity_pool_str241[sizeof("lbrkslu")]; - char entity_pool_str243[sizeof("napos")]; - char entity_pool_str251[sizeof("nle")]; - char entity_pool_str253[sizeof("rHar")]; - char entity_pool_str255[sizeof("lHar")]; - char entity_pool_str256[sizeof("qprime")]; - char entity_pool_str258[sizeof("lap")]; - char entity_pool_str265[sizeof("nbsp")]; - char entity_pool_str266[sizeof("uHar")]; - char entity_pool_str267[sizeof("top")]; - char entity_pool_str269[sizeof("Vbar")]; - char entity_pool_str272[sizeof("Ll")]; - char entity_pool_str276[sizeof("prap")]; - char entity_pool_str278[sizeof("emsp")]; - char entity_pool_str281[sizeof("nap")]; - char entity_pool_str294[sizeof("looparrowleft")]; - char entity_pool_str296[sizeof("le")]; - char entity_pool_str300[sizeof("sharp")]; - char entity_pool_str302[sizeof("ee")]; - char entity_pool_str310[sizeof("les")]; - char entity_pool_str311[sizeof("in")]; - char entity_pool_str312[sizeof("prop")]; - char entity_pool_str314[sizeof("topbot")]; - char entity_pool_str317[sizeof("int")]; - char entity_pool_str319[sizeof("ne")]; - char entity_pool_str329[sizeof("nprcue")]; - char entity_pool_str331[sizeof("pre")]; - char entity_pool_str332[sizeof("epsi")]; - char entity_pool_str337[sizeof("upsi")]; - char entity_pool_str338[sizeof("there4")]; - char entity_pool_str342[sizeof("rbrke")]; - char entity_pool_str343[sizeof("searr")]; - char entity_pool_str344[sizeof("lbrke")]; - char entity_pool_str346[sizeof("blacktriangle")]; - char entity_pool_str349[sizeof("lneq")]; - char entity_pool_str352[sizeof("lneqq")]; - char entity_pool_str354[sizeof("plus")]; - char entity_pool_str355[sizeof("nles")]; - char entity_pool_str356[sizeof("nedot")]; - char entity_pool_str357[sizeof("blacktriangleleft")]; - char entity_pool_str358[sizeof("blacktriangleright")]; - char entity_pool_str364[sizeof("nearr")]; - char entity_pool_str367[sizeof("blacktriangledown")]; - char entity_pool_str373[sizeof("nless")]; - char entity_pool_str374[sizeof("emacr")]; - char entity_pool_str378[sizeof("vprop")]; - char entity_pool_str379[sizeof("umacr")]; - char entity_pool_str383[sizeof("smeparsl")]; - char entity_pool_str387[sizeof("Map")]; - char entity_pool_str390[sizeof("plusdu")]; - char entity_pool_str391[sizeof("Not")]; - char entity_pool_str408[sizeof("Verbar")]; - char entity_pool_str426[sizeof("perp")]; - char entity_pool_str430[sizeof("fltns")]; - char entity_pool_str431[sizeof("plusmn")]; - char entity_pool_str435[sizeof("nleq")]; - char entity_pool_str438[sizeof("nleqq")]; - char entity_pool_str440[sizeof("frac34")]; - char entity_pool_str441[sizeof("frac14")]; - char entity_pool_str442[sizeof("verbar")]; - char entity_pool_str443[sizeof("frac12")]; - char entity_pool_str444[sizeof("frac35")]; - char entity_pool_str445[sizeof("frac15")]; - char entity_pool_str446[sizeof("frac45")]; - char entity_pool_str449[sizeof("frac25")]; - char entity_pool_str451[sizeof("frac13")]; - char entity_pool_str453[sizeof("frac16")]; - char entity_pool_str454[sizeof("prurel")]; - char entity_pool_str455[sizeof("frac23")]; - char entity_pool_str456[sizeof("frac38")]; - char entity_pool_str457[sizeof("frac18")]; - char entity_pool_str458[sizeof("frac56")]; - char entity_pool_str462[sizeof("frac58")]; - char entity_pool_str464[sizeof("frac78")]; - char entity_pool_str465[sizeof("leq")]; - char entity_pool_str466[sizeof("darr")]; - char entity_pool_str469[sizeof("Upsi")]; - char entity_pool_str470[sizeof("dot")]; - char entity_pool_str471[sizeof("phone")]; - char entity_pool_str474[sizeof("Cap")]; - char entity_pool_str478[sizeof("blacksquare")]; - char entity_pool_str479[sizeof("rnmid")]; - char entity_pool_str483[sizeof("leqq")]; - char entity_pool_str486[sizeof("intcal")]; - char entity_pool_str490[sizeof("dharr")]; - char entity_pool_str494[sizeof("rhard")]; - char entity_pool_str496[sizeof("lhard")]; - char entity_pool_str505[sizeof("pluse")]; - char entity_pool_str511[sizeof("Umacr")]; - char entity_pool_str512[sizeof("Vee")]; - char entity_pool_str515[sizeof("Rarr")]; - char entity_pool_str527[sizeof("Cross")]; - char entity_pool_str529[sizeof("rsqb")]; - char entity_pool_str531[sizeof("lsqb")]; - char entity_pool_str538[sizeof("Rarrtl")]; - char entity_pool_str541[sizeof("esdot")]; - char entity_pool_str546[sizeof("vee")]; - char entity_pool_str547[sizeof("nbumpe")]; - char entity_pool_str553[sizeof("llcorner")]; - char entity_pool_str554[sizeof("fpartint")]; - char entity_pool_str558[sizeof("squf")]; - char entity_pool_str559[sizeof("plankv")]; - char entity_pool_str562[sizeof("eqvparsl")]; - char entity_pool_str564[sizeof("ulcorner")]; - char entity_pool_str566[sizeof("wp")]; - char entity_pool_str571[sizeof("lozf")]; - char entity_pool_str575[sizeof("COPY")]; - char entity_pool_str577[sizeof("ulcorn")]; - char entity_pool_str582[sizeof("veebar")]; - char entity_pool_str584[sizeof("part")]; - char entity_pool_str589[sizeof("square")]; - char entity_pool_str591[sizeof("nbump")]; - char entity_pool_str592[sizeof("bernou")]; - char entity_pool_str593[sizeof("wr")]; - char entity_pool_str594[sizeof("rBarr")]; - char entity_pool_str595[sizeof("lrcorner")]; - char entity_pool_str596[sizeof("lBarr")]; - char entity_pool_str599[sizeof("bnot")]; - char entity_pool_str601[sizeof("semi")]; - char entity_pool_str606[sizeof("urcorner")]; - char entity_pool_str612[sizeof("NotSubset")]; - char entity_pool_str614[sizeof("ropf")]; - char entity_pool_str615[sizeof("Qopf")]; - char entity_pool_str616[sizeof("lopf")]; - char entity_pool_str618[sizeof("sopf")]; - char entity_pool_str619[sizeof("urcorn")]; - char entity_pool_str620[sizeof("Topf")]; - char entity_pool_str621[sizeof("Zopf")]; - char entity_pool_str622[sizeof("eopf")]; - char entity_pool_str626[sizeof("ropar")]; - char entity_pool_str627[sizeof("uopf")]; - char entity_pool_str628[sizeof("lopar")]; - char entity_pool_str629[sizeof("topf")]; - char entity_pool_str635[sizeof("Xopf")]; - char entity_pool_str639[sizeof("nopf")]; - char entity_pool_str641[sizeof("bopf")]; - char entity_pool_str642[sizeof("epsiv")]; - char entity_pool_str643[sizeof("fnof")]; - char entity_pool_str644[sizeof("imacr")]; - char entity_pool_str647[sizeof("Jopf")]; - char entity_pool_str649[sizeof("nhpar")]; - char entity_pool_str653[sizeof("Wopf")]; - char entity_pool_str658[sizeof("Sqrt")]; - char entity_pool_str659[sizeof("nsub")]; - char entity_pool_str661[sizeof("napid")]; - char entity_pool_str664[sizeof("NotSuperset")]; - char entity_pool_str667[sizeof("brvbar")]; - char entity_pool_str670[sizeof("sol")]; - char entity_pool_str675[sizeof("easter")]; - char entity_pool_str677[sizeof("popf")]; - char entity_pool_str680[sizeof("dHar")]; - char entity_pool_str685[sizeof("Vopf")]; - char entity_pool_str690[sizeof("nsupset")]; - char entity_pool_str691[sizeof("nsup")]; - char entity_pool_str692[sizeof("vBar")]; - char entity_pool_str694[sizeof("nsubset")]; - char entity_pool_str700[sizeof("thkap")]; - char entity_pool_str704[sizeof("nis")]; - char entity_pool_str705[sizeof("profsurf")]; - char entity_pool_str706[sizeof("solb")]; - char entity_pool_str710[sizeof("lnsim")]; - char entity_pool_str712[sizeof("solbar")]; - char entity_pool_str717[sizeof("Square")]; - char entity_pool_str719[sizeof("vopf")]; - char entity_pool_str723[sizeof("uharl")]; - char entity_pool_str725[sizeof("ulcrop")]; - char entity_pool_str729[sizeof("eqsim")]; - char entity_pool_str730[sizeof("equiv")]; - char entity_pool_str733[sizeof("ell")]; - char entity_pool_str734[sizeof("smashp")]; - char entity_pool_str735[sizeof("mp")]; - char entity_pool_str738[sizeof("Kopf")]; - char entity_pool_str741[sizeof("simrarr")]; - char entity_pool_str743[sizeof("flat")]; - char entity_pool_str745[sizeof("Mopf")]; - char entity_pool_str746[sizeof("Sopf")]; - char entity_pool_str747[sizeof("mldr")]; - char entity_pool_str748[sizeof("rlm")]; - char entity_pool_str749[sizeof("iprod")]; - char entity_pool_str756[sizeof("lparlt")]; - char entity_pool_str758[sizeof("fopf")]; - char entity_pool_str759[sizeof("Uopf")]; - char entity_pool_str763[sizeof("varsubsetneq")]; - char entity_pool_str764[sizeof("varsubsetneqq")]; - char entity_pool_str767[sizeof("urcrop")]; - char entity_pool_str768[sizeof("LessLess")]; - char entity_pool_str770[sizeof("Re")]; - char entity_pool_str773[sizeof("NotNestedLessLess")]; - char entity_pool_str777[sizeof("Dopf")]; - char entity_pool_str779[sizeof("forkv")]; - char entity_pool_str781[sizeof("nsqsube")]; - char entity_pool_str783[sizeof("nsupe")]; - char entity_pool_str787[sizeof("nsube")]; - char entity_pool_str788[sizeof("qopf")]; - char entity_pool_str789[sizeof("rlhar")]; - char entity_pool_str792[sizeof("lrm")]; - char entity_pool_str796[sizeof("nlsim")]; - char entity_pool_str798[sizeof("pound")]; - char entity_pool_str799[sizeof("varsupsetneq")]; - char entity_pool_str800[sizeof("varsupsetneqq")]; - char entity_pool_str802[sizeof("bnequiv")]; - char entity_pool_str813[sizeof("Lopf")]; - char entity_pool_str817[sizeof("nsqsupe")]; - char entity_pool_str820[sizeof("rarrlp")]; - char entity_pool_str821[sizeof("wedbar")]; - char entity_pool_str822[sizeof("larrlp")]; - char entity_pool_str824[sizeof("Yopf")]; - char entity_pool_str829[sizeof("NotReverseElement")]; - char entity_pool_str832[sizeof("Copf")]; - char entity_pool_str833[sizeof("lrhar")]; - char entity_pool_str848[sizeof("parsl")]; - char entity_pool_str849[sizeof("uml")]; - char entity_pool_str850[sizeof("marker")]; - char entity_pool_str851[sizeof("nsupseteq")]; - char entity_pool_str855[sizeof("nsubseteq")]; - char entity_pool_str861[sizeof("squarf")]; - char entity_pool_str862[sizeof("Vert")]; - char entity_pool_str874[sizeof("SquareSupersetEqual")]; - char entity_pool_str876[sizeof("prsim")]; - char entity_pool_str879[sizeof("SquareSubsetEqual")]; - char entity_pool_str882[sizeof("SquareSuperset")]; - char entity_pool_str887[sizeof("SquareSubset")]; - char entity_pool_str888[sizeof("nvap")]; - char entity_pool_str892[sizeof("iopf")]; - char entity_pool_str894[sizeof("pm")]; - char entity_pool_str896[sizeof("vert")]; - char entity_pool_str898[sizeof("thetav")]; - char entity_pool_str901[sizeof("loz")]; - char entity_pool_str905[sizeof("map")]; - char entity_pool_str920[sizeof("lesseqqgtr")]; - char entity_pool_str934[sizeof("rscr")]; - char entity_pool_str935[sizeof("Qscr")]; - char entity_pool_str936[sizeof("lscr")]; - char entity_pool_str938[sizeof("sscr")]; - char entity_pool_str940[sizeof("Tscr")]; - char entity_pool_str941[sizeof("Zscr")]; - char entity_pool_str942[sizeof("escr")]; - char entity_pool_str947[sizeof("uscr")]; - char entity_pool_str949[sizeof("tscr")]; - char entity_pool_str951[sizeof("imof")]; - char entity_pool_str952[sizeof("Coproduct")]; - char entity_pool_str955[sizeof("Xscr")]; - char entity_pool_str956[sizeof("Xi")]; - char entity_pool_str959[sizeof("nscr")]; - char entity_pool_str960[sizeof("ni")]; - char entity_pool_str961[sizeof("bscr")]; - char entity_pool_str962[sizeof("Nopf")]; - char entity_pool_str967[sizeof("Jscr")]; - char entity_pool_str968[sizeof("preceq")]; - char entity_pool_str971[sizeof("nvrArr")]; - char entity_pool_str972[sizeof("backprime")]; - char entity_pool_str973[sizeof("Wscr")]; - char entity_pool_str975[sizeof("varphi")]; - char entity_pool_str984[sizeof("nsmid")]; - char entity_pool_str991[sizeof("dlcorn")]; - char entity_pool_str997[sizeof("pscr")]; - char entity_pool_str998[sizeof("pi")]; - char entity_pool_str1005[sizeof("Vscr")]; - char entity_pool_str1011[sizeof("nesim")]; - char entity_pool_str1021[sizeof("simne")]; - char entity_pool_str1028[sizeof("nsupseteqq")]; - char entity_pool_str1032[sizeof("nsubseteqq")]; - char entity_pool_str1033[sizeof("drcorn")]; - char entity_pool_str1038[sizeof("rbrace")]; - char entity_pool_str1039[sizeof("vscr")]; - char entity_pool_str1040[sizeof("lbrace")]; - char entity_pool_str1041[sizeof("dopf")]; - char entity_pool_str1049[sizeof("frasl")]; - char entity_pool_str1055[sizeof("LessTilde")]; - char entity_pool_str1058[sizeof("Kscr")]; - char entity_pool_str1064[sizeof("pluscir")]; - char entity_pool_str1065[sizeof("Mscr")]; - char entity_pool_str1066[sizeof("Sscr")]; - char entity_pool_str1067[sizeof("rbrksld")]; - char entity_pool_str1069[sizeof("lbrksld")]; - char entity_pool_str1070[sizeof("RBarr")]; - char entity_pool_str1073[sizeof("sqcaps")]; - char entity_pool_str1074[sizeof("rArr")]; - char entity_pool_str1075[sizeof("bNot")]; - char entity_pool_str1076[sizeof("lArr")]; - char entity_pool_str1078[sizeof("fscr")]; - char entity_pool_str1079[sizeof("Uscr")]; - char entity_pool_str1087[sizeof("uArr")]; - char entity_pool_str1090[sizeof("Ropf")]; - char entity_pool_str1094[sizeof("wopf")]; - char entity_pool_str1097[sizeof("Dscr")]; - char entity_pool_str1098[sizeof("opar")]; - char entity_pool_str1099[sizeof("seswar")]; - char entity_pool_str1103[sizeof("Del")]; - char entity_pool_str1104[sizeof("rAarr")]; - char entity_pool_str1105[sizeof("rho")]; - char entity_pool_str1106[sizeof("lAarr")]; - char entity_pool_str1107[sizeof("preccurlyeq")]; - char entity_pool_str1108[sizeof("qscr")]; - char entity_pool_str1111[sizeof("macr")]; - char entity_pool_str1115[sizeof("notin")]; - char entity_pool_str1120[sizeof("equivDD")]; - char entity_pool_str1125[sizeof("sqcap")]; - char entity_pool_str1127[sizeof("nspar")]; - char entity_pool_str1131[sizeof("olt")]; - char entity_pool_str1132[sizeof("ratio")]; - char entity_pool_str1133[sizeof("Lscr")]; - char entity_pool_str1137[sizeof("dharl")]; - char entity_pool_str1139[sizeof("dlcrop")]; - char entity_pool_str1140[sizeof("DoubleDot")]; - char entity_pool_str1141[sizeof("dotplus")]; - char entity_pool_str1142[sizeof("or")]; - char entity_pool_str1144[sizeof("Yscr")]; - char entity_pool_str1147[sizeof("Fopf")]; - char entity_pool_str1152[sizeof("Cscr")]; - char entity_pool_str1153[sizeof("olarr")]; - char entity_pool_str1154[sizeof("nrarrw")]; - char entity_pool_str1159[sizeof("lvertneqq")]; - char entity_pool_str1160[sizeof("eqslantgtr")]; - char entity_pool_str1164[sizeof("thorn")]; - char entity_pool_str1169[sizeof("eqslantless")]; - char entity_pool_str1172[sizeof("incare")]; - char entity_pool_str1179[sizeof("vArr")]; - char entity_pool_str1180[sizeof("rppolint")]; - char entity_pool_str1181[sizeof("drcrop")]; - char entity_pool_str1187[sizeof("parallel")]; - char entity_pool_str1195[sizeof("orarr")]; - char entity_pool_str1196[sizeof("ssmile")]; - char entity_pool_str1200[sizeof("DoubleLeftTee")]; - char entity_pool_str1201[sizeof("erDot")]; - char entity_pool_str1202[sizeof("diams")]; - char entity_pool_str1203[sizeof("ssetmn")]; - char entity_pool_str1208[sizeof("oS")]; - char entity_pool_str1212[sizeof("iscr")]; - char entity_pool_str1213[sizeof("ii")]; - char entity_pool_str1214[sizeof("rect")]; - char entity_pool_str1217[sizeof("nsccue")]; - char entity_pool_str1218[sizeof("sect")]; - char entity_pool_str1220[sizeof("mlcp")]; - char entity_pool_str1224[sizeof("oror")]; - char entity_pool_str1226[sizeof("DoubleContourIntegral")]; - char entity_pool_str1230[sizeof("equals")]; - char entity_pool_str1232[sizeof("Hat")]; - char entity_pool_str1236[sizeof("sstarf")]; - char entity_pool_str1237[sizeof("mstpos")]; - char entity_pool_str1239[sizeof("die")]; - char entity_pool_str1240[sizeof("measuredangle")]; - char entity_pool_str1252[sizeof("forall")]; - char entity_pool_str1255[sizeof("notinvb")]; - char entity_pool_str1263[sizeof("mopf")]; - char entity_pool_str1270[sizeof("niv")]; - char entity_pool_str1280[sizeof("vBarv")]; - char entity_pool_str1282[sizeof("Nscr")]; - char entity_pool_str1284[sizeof("period")]; - char entity_pool_str1292[sizeof("becaus")]; - char entity_pool_str1298[sizeof("between")]; - char entity_pool_str1299[sizeof("Int")]; - char entity_pool_str1307[sizeof("because")]; - char entity_pool_str1308[sizeof("piv")]; - char entity_pool_str1326[sizeof("rfr")]; - char entity_pool_str1327[sizeof("Qfr")]; - char entity_pool_str1328[sizeof("lfr")]; - char entity_pool_str1330[sizeof("sfr")]; - char entity_pool_str1331[sizeof("nleftrightarrow")]; - char entity_pool_str1332[sizeof("Tfr")]; - char entity_pool_str1333[sizeof("Zfr")]; - char entity_pool_str1334[sizeof("efr")]; - char entity_pool_str1338[sizeof("sim")]; - char entity_pool_str1339[sizeof("ufr")]; - char entity_pool_str1340[sizeof("roplus")]; - char entity_pool_str1341[sizeof("tfr")]; - char entity_pool_str1342[sizeof("loplus")]; - char entity_pool_str1347[sizeof("Xfr")]; - char entity_pool_str1350[sizeof("real")]; - char entity_pool_str1351[sizeof("nfr")]; - char entity_pool_str1353[sizeof("bfr")]; - char entity_pool_str1355[sizeof("NotHumpEqual")]; - char entity_pool_str1359[sizeof("Jfr")]; - char entity_pool_str1361[sizeof("dscr")]; - char entity_pool_str1365[sizeof("Wfr")]; - char entity_pool_str1367[sizeof("blacklozenge")]; - char entity_pool_str1369[sizeof("zopf")]; - char entity_pool_str1370[sizeof("reals")]; - char entity_pool_str1372[sizeof("NotCupCap")]; - char entity_pool_str1375[sizeof("simplus")]; - char entity_pool_str1377[sizeof("ForAll")]; - char entity_pool_str1389[sizeof("pfr")]; - char entity_pool_str1395[sizeof("omacr")]; - char entity_pool_str1397[sizeof("Vfr")]; - char entity_pool_str1409[sizeof("Emacr")]; - char entity_pool_str1410[sizeof("Rscr")]; - char entity_pool_str1414[sizeof("wscr")]; - char entity_pool_str1423[sizeof("ShortUpArrow")]; - char entity_pool_str1429[sizeof("setmn")]; - char entity_pool_str1431[sizeof("vfr")]; - char entity_pool_str1450[sizeof("Kfr")]; - char entity_pool_str1455[sizeof("operp")]; - char entity_pool_str1457[sizeof("Mfr")]; - char entity_pool_str1458[sizeof("Sfr")]; - char entity_pool_str1461[sizeof("nltrie")]; - char entity_pool_str1467[sizeof("Fscr")]; - char entity_pool_str1470[sizeof("ffr")]; - char entity_pool_str1471[sizeof("Ufr")]; - char entity_pool_str1473[sizeof("shortmid")]; - char entity_pool_str1488[sizeof("nvsim")]; - char entity_pool_str1489[sizeof("Dfr")]; - char entity_pool_str1490[sizeof("lessdot")]; - char entity_pool_str1493[sizeof("profline")]; - char entity_pool_str1500[sizeof("qfr")]; - char entity_pool_str1501[sizeof("dArr")]; - char entity_pool_str1503[sizeof("nrtrie")]; - char entity_pool_str1507[sizeof("ShortRightArrow")]; - char entity_pool_str1515[sizeof("Therefore")]; - char entity_pool_str1519[sizeof("DD")]; - char entity_pool_str1524[sizeof("therefore")]; - char entity_pool_str1525[sizeof("Lfr")]; - char entity_pool_str1532[sizeof("target")]; - char entity_pool_str1535[sizeof("Element")]; - char entity_pool_str1536[sizeof("Yfr")]; - char entity_pool_str1537[sizeof("ClockwiseContourIntegral")]; - char entity_pool_str1542[sizeof("olcir")]; - char entity_pool_str1544[sizeof("Cfr")]; - char entity_pool_str1559[sizeof("female")]; - char entity_pool_str1560[sizeof("nsucceq")]; - char entity_pool_str1561[sizeof("oast")]; - char entity_pool_str1568[sizeof("percnt")]; - char entity_pool_str1578[sizeof("ordf")]; - char entity_pool_str1580[sizeof("ord")]; - char entity_pool_str1581[sizeof("Rho")]; - char entity_pool_str1583[sizeof("mscr")]; - char entity_pool_str1585[sizeof("nvrtrie")]; - char entity_pool_str1589[sizeof("lnE")]; - char entity_pool_str1597[sizeof("nhArr")]; - char entity_pool_str1598[sizeof("Or")]; - char entity_pool_str1602[sizeof("divide")]; - char entity_pool_str1604[sizeof("ifr")]; - char entity_pool_str1605[sizeof("elinters")]; - char entity_pool_str1615[sizeof("bsol")]; - char entity_pool_str1616[sizeof("nvlArr")]; - char entity_pool_str1626[sizeof("Imacr")]; - char entity_pool_str1628[sizeof("backsimeq")]; - char entity_pool_str1629[sizeof("twixt")]; - char entity_pool_str1630[sizeof("olcross")]; - char entity_pool_str1639[sizeof("rarrsim")]; - char entity_pool_str1640[sizeof("DoubleDownArrow")]; - char entity_pool_str1641[sizeof("larrsim")]; - char entity_pool_str1642[sizeof("emptyset")]; - char entity_pool_str1643[sizeof("oopf")]; - char entity_pool_str1645[sizeof("exist")]; - char entity_pool_str1648[sizeof("llhard")]; - char entity_pool_str1656[sizeof("excl")]; - char entity_pool_str1657[sizeof("Eopf")]; - char entity_pool_str1658[sizeof("nlArr")]; - char entity_pool_str1663[sizeof("thinsp")]; - char entity_pool_str1664[sizeof("NotSubsetEqual")]; - char entity_pool_str1665[sizeof("phi")]; - char entity_pool_str1666[sizeof("DoubleLeftArrow")]; - char entity_pool_str1668[sizeof("topcir")]; - char entity_pool_str1672[sizeof("div")]; - char entity_pool_str1674[sizeof("Nfr")]; - char entity_pool_str1675[sizeof("nlE")]; - char entity_pool_str1689[sizeof("zscr")]; - char entity_pool_str1690[sizeof("lrhard")]; - char entity_pool_str1697[sizeof("lltri")]; - char entity_pool_str1700[sizeof("nrArr")]; - char entity_pool_str1701[sizeof("NotSupersetEqual")]; - char entity_pool_str1703[sizeof("swArr")]; - char entity_pool_str1704[sizeof("ThickSpace")]; - char entity_pool_str1708[sizeof("ultri")]; - char entity_pool_str1709[sizeof("notnivb")]; - char entity_pool_str1711[sizeof("prime")]; - char entity_pool_str1714[sizeof("primes")]; - char entity_pool_str1716[sizeof("ohm")]; - char entity_pool_str1719[sizeof("CircleTimes")]; - char entity_pool_str1720[sizeof("nltri")]; - char entity_pool_str1723[sizeof("siml")]; - char entity_pool_str1724[sizeof("nwArr")]; - char entity_pool_str1727[sizeof("varpi")]; - char entity_pool_str1730[sizeof("orv")]; - char entity_pool_str1735[sizeof("setminus")]; - char entity_pool_str1739[sizeof("lrtri")]; - char entity_pool_str1743[sizeof("permil")]; - char entity_pool_str1744[sizeof("mid")]; - char entity_pool_str1750[sizeof("urtri")]; - char entity_pool_str1753[sizeof("dfr")]; - char entity_pool_str1754[sizeof("mho")]; - char entity_pool_str1755[sizeof("prE")]; - char entity_pool_str1759[sizeof("vsupne")]; - char entity_pool_str1762[sizeof("nrtri")]; - char entity_pool_str1763[sizeof("vsubne")]; - char entity_pool_str1765[sizeof("eDot")]; - char entity_pool_str1778[sizeof("lesges")]; - char entity_pool_str1781[sizeof("backepsilon")]; - char entity_pool_str1783[sizeof("ratail")]; - char entity_pool_str1785[sizeof("latail")]; - char entity_pool_str1788[sizeof("UpEquilibrium")]; - char entity_pool_str1791[sizeof("epsilon")]; - char entity_pool_str1796[sizeof("upsilon")]; - char entity_pool_str1798[sizeof("midast")]; - char entity_pool_str1799[sizeof("Hopf")]; - char entity_pool_str1800[sizeof("vltri")]; - char entity_pool_str1802[sizeof("Rfr")]; - char entity_pool_str1805[sizeof("Wedge")]; - char entity_pool_str1806[sizeof("wfr")]; - char entity_pool_str1812[sizeof("barwed")]; - char entity_pool_str1815[sizeof("malt")]; - char entity_pool_str1820[sizeof("Chi")]; - char entity_pool_str1821[sizeof("emptyv")]; - char entity_pool_str1822[sizeof("notni")]; - char entity_pool_str1827[sizeof("LessGreater")]; - char entity_pool_str1829[sizeof("diam")]; - char entity_pool_str1842[sizeof("vrtri")]; - char entity_pool_str1849[sizeof("CircleMinus")]; - char entity_pool_str1851[sizeof("Omacr")]; - char entity_pool_str1852[sizeof("seArr")]; - char entity_pool_str1859[sizeof("Ffr")]; - char entity_pool_str1865[sizeof("precneqq")]; - char entity_pool_str1867[sizeof("Diamond")]; - char entity_pool_str1868[sizeof("ordm")]; - char entity_pool_str1873[sizeof("neArr")]; - char entity_pool_str1874[sizeof("Iopf")]; - char entity_pool_str1875[sizeof("CircleDot")]; - char entity_pool_str1878[sizeof("prnap")]; - char entity_pool_str1884[sizeof("dotminus")]; - char entity_pool_str1903[sizeof("nshortmid")]; - char entity_pool_str1905[sizeof("bottom")]; - char entity_pool_str1907[sizeof("pointint")]; - char entity_pool_str1917[sizeof("SquareUnion")]; - char entity_pool_str1925[sizeof("jopf")]; - char entity_pool_str1928[sizeof("Upsilon")]; - char entity_pool_str1936[sizeof("Colone")]; - char entity_pool_str1938[sizeof("nvlt")]; - char entity_pool_str1941[sizeof("NestedLessLess")]; - char entity_pool_str1942[sizeof("Colon")]; - char entity_pool_str1945[sizeof("bsolhsub")]; - char entity_pool_str1949[sizeof("DoubleLeftRightArrow")]; - char entity_pool_str1950[sizeof("plussim")]; - char entity_pool_str1959[sizeof("image")]; - char entity_pool_str1960[sizeof("egs")]; - char entity_pool_str1963[sizeof("oscr")]; - char entity_pool_str1964[sizeof("swnwar")]; - char entity_pool_str1969[sizeof("zeetrf")]; - char entity_pool_str1973[sizeof("maltese")]; - char entity_pool_str1975[sizeof("mfr")]; - char entity_pool_str1976[sizeof("rarrfs")]; - char entity_pool_str1977[sizeof("Escr")]; - char entity_pool_str1978[sizeof("larrfs")]; - char entity_pool_str1985[sizeof("mnplus")]; - char entity_pool_str1986[sizeof("ngt")]; - char entity_pool_str1987[sizeof("ngtr")]; - char entity_pool_str1996[sizeof("gl")]; - char entity_pool_str2003[sizeof("diamondsuit")]; - char entity_pool_str2004[sizeof("GT")]; - char entity_pool_str2014[sizeof("lesssim")]; - char entity_pool_str2015[sizeof("dsol")]; - char entity_pool_str2023[sizeof("upharpoonleft")]; - char entity_pool_str2024[sizeof("SquareIntersection")]; - char entity_pool_str2025[sizeof("lsime")]; - char entity_pool_str2027[sizeof("nLt")]; - char entity_pool_str2029[sizeof("NotLess")]; - char entity_pool_str2031[sizeof("gnap")]; - char entity_pool_str2035[sizeof("scap")]; - char entity_pool_str2038[sizeof("mapstoleft")]; - char entity_pool_str2039[sizeof("NotLessLess")]; - char entity_pool_str2043[sizeof("rfloor")]; - char entity_pool_str2045[sizeof("lfloor")]; - char entity_pool_str2048[sizeof("nsime")]; - char entity_pool_str2050[sizeof("bsime")]; - char entity_pool_str2051[sizeof("NotLessEqual")]; - char entity_pool_str2052[sizeof("NotLessTilde")]; - char entity_pool_str2056[sizeof("ncap")]; - char entity_pool_str2059[sizeof("NotLessGreater")]; - char entity_pool_str2070[sizeof("precsim")]; - char entity_pool_str2072[sizeof("looparrowright")]; - char entity_pool_str2076[sizeof("Pr")]; - char entity_pool_str2077[sizeof("rcub")]; - char entity_pool_str2078[sizeof("mapstoup")]; - char entity_pool_str2079[sizeof("lcub")]; - char entity_pool_str2081[sizeof("zfr")]; - char entity_pool_str2084[sizeof("uparrow")]; - char entity_pool_str2086[sizeof("gne")]; - char entity_pool_str2090[sizeof("sce")]; - char entity_pool_str2091[sizeof("Im")]; - char entity_pool_str2096[sizeof("rcaron")]; - char entity_pool_str2098[sizeof("lcaron")]; - char entity_pool_str2099[sizeof("Oopf")]; - char entity_pool_str2100[sizeof("scaron")]; - char entity_pool_str2101[sizeof("backsim")]; - char entity_pool_str2102[sizeof("Tcaron")]; - char entity_pool_str2103[sizeof("Zcaron")]; - char entity_pool_str2104[sizeof("ecaron")]; - char entity_pool_str2106[sizeof("Bernoullis")]; - char entity_pool_str2110[sizeof("nge")]; - char entity_pool_str2111[sizeof("tcaron")]; - char entity_pool_str2113[sizeof("fork")]; - char entity_pool_str2119[sizeof("Hscr")]; - char entity_pool_str2121[sizeof("ncaron")]; - char entity_pool_str2122[sizeof("elsdot")]; - char entity_pool_str2124[sizeof("tbrk")]; - char entity_pool_str2128[sizeof("triplus")]; - char entity_pool_str2131[sizeof("diamond")]; - char entity_pool_str2134[sizeof("ncup")]; - char entity_pool_str2136[sizeof("bbrk")]; - char entity_pool_str2138[sizeof("frown")]; - char entity_pool_str2139[sizeof("bkarow")]; - char entity_pool_str2141[sizeof("spades")]; - char entity_pool_str2143[sizeof("psi")]; - char entity_pool_str2150[sizeof("Bopf")]; - char entity_pool_str2156[sizeof("dollar")]; - char entity_pool_str2164[sizeof("disin")]; - char entity_pool_str2170[sizeof("spadesuit")]; - char entity_pool_str2176[sizeof("NotTilde")]; - char entity_pool_str2177[sizeof("doublebarwedge")]; - char entity_pool_str2179[sizeof("gap")]; - char entity_pool_str2186[sizeof("bbrktbrk")]; - char entity_pool_str2189[sizeof("swarrow")]; - char entity_pool_str2190[sizeof("bepsi")]; - char entity_pool_str2194[sizeof("Iscr")]; - char entity_pool_str2198[sizeof("NotTildeFullEqual")]; - char entity_pool_str2199[sizeof("eqcolon")]; - char entity_pool_str2202[sizeof("tint")]; - char entity_pool_str2205[sizeof("intprod")]; - char entity_pool_str2207[sizeof("nsupE")]; - char entity_pool_str2210[sizeof("nwarrow")]; - char entity_pool_str2211[sizeof("nsubE")]; - char entity_pool_str2214[sizeof("nges")]; - char entity_pool_str2216[sizeof("Uparrow")]; - char entity_pool_str2217[sizeof("ge")]; - char entity_pool_str2218[sizeof("OpenCurlyDoubleQuote")]; - char entity_pool_str2223[sizeof("smallsetminus")]; - char entity_pool_str2228[sizeof("Scaron")]; - char entity_pool_str2230[sizeof("nvltrie")]; - char entity_pool_str2231[sizeof("ges")]; - char entity_pool_str2232[sizeof("blank")]; - char entity_pool_str2233[sizeof("QUOT")]; - char entity_pool_str2238[sizeof("block")]; - char entity_pool_str2239[sizeof("trade")]; - char entity_pool_str2245[sizeof("jscr")]; - char entity_pool_str2246[sizeof("wedge")]; - char entity_pool_str2254[sizeof("Amacr")]; - char entity_pool_str2256[sizeof("Equal")]; - char entity_pool_str2259[sizeof("Dcaron")]; - char entity_pool_str2262[sizeof("DotDot")]; - char entity_pool_str2270[sizeof("gneq")]; - char entity_pool_str2271[sizeof("varpropto")]; - char entity_pool_str2273[sizeof("gneqq")]; - char entity_pool_str2274[sizeof("Proportional")]; - char entity_pool_str2279[sizeof("isins")]; - char entity_pool_str2281[sizeof("eDDot")]; - char entity_pool_str2282[sizeof("isin")]; - char entity_pool_str2286[sizeof("TripleDot")]; - char entity_pool_str2290[sizeof("Fouriertrf")]; - char entity_pool_str2291[sizeof("Proportion")]; - char entity_pool_str2294[sizeof("ngeq")]; - char entity_pool_str2295[sizeof("Lcaron")]; - char entity_pool_str2297[sizeof("ngeqq")]; - char entity_pool_str2313[sizeof("lE")]; - char entity_pool_str2314[sizeof("Ccaron")]; - char entity_pool_str2320[sizeof("bsemi")]; - char entity_pool_str2326[sizeof("propto")]; - char entity_pool_str2331[sizeof("lesdot")]; - char entity_pool_str2332[sizeof("Conint")]; - char entity_pool_str2334[sizeof("And")]; - char entity_pool_str2338[sizeof("searrow")]; - char entity_pool_str2343[sizeof("orslope")]; - char entity_pool_str2344[sizeof("harr")]; - char entity_pool_str2350[sizeof("late")]; - char entity_pool_str2352[sizeof("CenterDot")]; - char entity_pool_str2355[sizeof("ofr")]; - char entity_pool_str2359[sizeof("nearrow")]; - char entity_pool_str2361[sizeof("qint")]; - char entity_pool_str2364[sizeof("lates")]; - char entity_pool_str2365[sizeof("kappav")]; - char entity_pool_str2368[sizeof("horbar")]; - char entity_pool_str2369[sizeof("Efr")]; - char entity_pool_str2370[sizeof("hoarr")]; - char entity_pool_str2371[sizeof("npre")]; - char entity_pool_str2377[sizeof("inodot")]; - char entity_pool_str2379[sizeof("udarr")]; - char entity_pool_str2386[sizeof("geq")]; - char entity_pool_str2391[sizeof("nsimeq")]; - char entity_pool_str2404[sizeof("geqq")]; - char entity_pool_str2407[sizeof("efDot")]; - char entity_pool_str2410[sizeof("rpargt")]; - char entity_pool_str2419[sizeof("Oscr")]; - char entity_pool_str2422[sizeof("plusdo")]; - char entity_pool_str2425[sizeof("lagran")]; - char entity_pool_str2429[sizeof("thicksim")]; - char entity_pool_str2440[sizeof("precnsim")]; - char entity_pool_str2444[sizeof("Ncaron")]; - char entity_pool_str2449[sizeof("napE")]; - char entity_pool_str2457[sizeof("iiint")]; - char entity_pool_str2470[sizeof("Bscr")]; - char entity_pool_str2483[sizeof("mapstodown")]; - char entity_pool_str2486[sizeof("varrho")]; - char entity_pool_str2488[sizeof("isinsv")]; - char entity_pool_str2491[sizeof("nvHarr")]; - char entity_pool_str2494[sizeof("NotLeftTriangleBar")]; - char entity_pool_str2496[sizeof("equest")]; - char entity_pool_str2498[sizeof("NotLeftTriangleEqual")]; - char entity_pool_str2499[sizeof("NotLeftTriangle")]; - char entity_pool_str2502[sizeof("Aopf")]; - char entity_pool_str2503[sizeof("hbar")]; - char entity_pool_str2507[sizeof("vangrt")]; - char entity_pool_str2511[sizeof("Hfr")]; - char entity_pool_str2517[sizeof("range")]; - char entity_pool_str2518[sizeof("smte")]; - char entity_pool_str2519[sizeof("lsim")]; - char entity_pool_str2521[sizeof("npolint")]; - char entity_pool_str2523[sizeof("dcaron")]; - char entity_pool_str2525[sizeof("esim")]; - char entity_pool_str2527[sizeof("Union")]; - char entity_pool_str2532[sizeof("smtes")]; - char entity_pool_str2536[sizeof("kopf")]; - char entity_pool_str2537[sizeof("gopf")]; - char entity_pool_str2542[sizeof("nsim")]; - char entity_pool_str2544[sizeof("bsim")]; - char entity_pool_str2546[sizeof("SmallCircle")]; - char entity_pool_str2548[sizeof("NotDoubleVerticalBar")]; - char entity_pool_str2549[sizeof("NotNestedGreaterGreater")]; - char entity_pool_str2565[sizeof("EqualTilde")]; - char entity_pool_str2568[sizeof("notindot")]; - char entity_pool_str2572[sizeof("Rcaron")]; - char entity_pool_str2577[sizeof("Popf")]; - char entity_pool_str2583[sizeof("Gopf")]; - char entity_pool_str2586[sizeof("Ifr")]; - char entity_pool_str2589[sizeof("wedgeq")]; - char entity_pool_str2595[sizeof("prod")]; - char entity_pool_str2617[sizeof("osol")]; - char entity_pool_str2624[sizeof("DoubleUpArrow")]; - char entity_pool_str2627[sizeof("Congruent")]; - char entity_pool_str2631[sizeof("gnsim")]; - char entity_pool_str2635[sizeof("scsim")]; - char entity_pool_str2637[sizeof("jfr")]; - char entity_pool_str2645[sizeof("upsih")]; - char entity_pool_str2650[sizeof("nLl")]; - char entity_pool_str2653[sizeof("DoubleUpDownArrow")]; - char entity_pool_str2655[sizeof("ngsim")]; - char entity_pool_str2664[sizeof("hearts")]; - char entity_pool_str2666[sizeof("lesseqgtr")]; - char entity_pool_str2670[sizeof("nesear")]; - char entity_pool_str2676[sizeof("Exists")]; - char entity_pool_str2687[sizeof("smile")]; - char entity_pool_str2689[sizeof("uwangle")]; - char entity_pool_str2693[sizeof("heartsuit")]; - char entity_pool_str2700[sizeof("HorizontalLine")]; - char entity_pool_str2703[sizeof("GreaterLess")]; - char entity_pool_str2705[sizeof("rsaquo")]; - char entity_pool_str2707[sizeof("lsaquo")]; - char entity_pool_str2709[sizeof("realine")]; - char entity_pool_str2710[sizeof("Dashv")]; - char entity_pool_str2714[sizeof("simdot")]; - char entity_pool_str2715[sizeof("GreaterEqual")]; - char entity_pool_str2716[sizeof("GreaterTilde")]; - char entity_pool_str2721[sizeof("GreaterEqualLess")]; - char entity_pool_str2723[sizeof("GreaterGreater")]; - char entity_pool_str2737[sizeof("rceil")]; - char entity_pool_str2739[sizeof("lceil")]; - char entity_pool_str2743[sizeof("lessgtr")]; - char entity_pool_str2746[sizeof("oline")]; - char entity_pool_str2753[sizeof("thksim")]; - char entity_pool_str2755[sizeof("InvisibleTimes")]; - char entity_pool_str2762[sizeof("race")]; - char entity_pool_str2766[sizeof("iquest")]; - char entity_pool_str2774[sizeof("imagline")]; - char entity_pool_str2779[sizeof("UpTee")]; - char entity_pool_str2781[sizeof("midcir")]; - char entity_pool_str2790[sizeof("ofcir")]; - char entity_pool_str2793[sizeof("ddarr")]; - char entity_pool_str2800[sizeof("rangd")]; - char entity_pool_str2802[sizeof("langd")]; - char entity_pool_str2808[sizeof("Equilibrium")]; - char entity_pool_str2809[sizeof("parsim")]; - char entity_pool_str2810[sizeof("Vdashl")]; - char entity_pool_str2811[sizeof("Ofr")]; - char entity_pool_str2816[sizeof("Because")]; - char entity_pool_str2818[sizeof("rAtail")]; - char entity_pool_str2820[sizeof("lAtail")]; - char entity_pool_str2821[sizeof("ominus")]; - char entity_pool_str2822[sizeof("Ascr")]; - char entity_pool_str2826[sizeof("Epsilon")]; - char entity_pool_str2832[sizeof("ShortLeftArrow")]; - char entity_pool_str2845[sizeof("isinv")]; - char entity_pool_str2847[sizeof("micro")]; - char entity_pool_str2851[sizeof("zcaron")]; - char entity_pool_str2856[sizeof("kscr")]; - char entity_pool_str2857[sizeof("gscr")]; - char entity_pool_str2862[sizeof("Bfr")]; - char entity_pool_str2863[sizeof("gel")]; - char entity_pool_str2864[sizeof("hercon")]; - char entity_pool_str2871[sizeof("triminus")]; - char entity_pool_str2877[sizeof("egrave")]; - char entity_pool_str2881[sizeof("sdot")]; - char entity_pool_str2882[sizeof("ugrave")]; - char entity_pool_str2884[sizeof("Zdot")]; - char entity_pool_str2885[sizeof("edot")]; - char entity_pool_str2890[sizeof("NotTildeTilde")]; - char entity_pool_str2892[sizeof("tdot")]; - char entity_pool_str2897[sizeof("Pscr")]; - char entity_pool_str2898[sizeof("Pi")]; - char entity_pool_str2903[sizeof("Gscr")]; - char entity_pool_str2910[sizeof("plustwo")]; - char entity_pool_str2914[sizeof("NotElement")]; - char entity_pool_str2916[sizeof("PlusMinus")]; - char entity_pool_str2919[sizeof("hopf")]; - char entity_pool_str2920[sizeof("gammad")]; - char entity_pool_str2922[sizeof("mDDot")]; - char entity_pool_str2926[sizeof("divideontimes")]; - char entity_pool_str2940[sizeof("doteq")]; - char entity_pool_str2956[sizeof("varepsilon")]; - char entity_pool_str2963[sizeof("Precedes")]; - char entity_pool_str2966[sizeof("Gammad")]; - char entity_pool_str2974[sizeof("dashv")]; - char entity_pool_str2979[sizeof("NotCongruent")]; - char entity_pool_str2982[sizeof("ubreve")]; - char entity_pool_str2990[sizeof("ogt")]; - char entity_pool_str2994[sizeof("RoundImplies")]; - char entity_pool_str3002[sizeof("PrecedesSlantEqual")]; - char entity_pool_str3005[sizeof("sime")]; - char entity_pool_str3014[sizeof("Ugrave")]; - char entity_pool_str3016[sizeof("dbkarow")]; - char entity_pool_str3021[sizeof("sdote")]; - char entity_pool_str3023[sizeof("veeeq")]; - char entity_pool_str3027[sizeof("mapsto")]; - char entity_pool_str3030[sizeof("times")]; - char entity_pool_str3033[sizeof("rangle")]; - char entity_pool_str3035[sizeof("langle")]; - char entity_pool_str3038[sizeof("leftarrowtail")]; - char entity_pool_str3039[sizeof("hamilt")]; - char entity_pool_str3044[sizeof("udhar")]; - char entity_pool_str3053[sizeof("nisd")]; - char entity_pool_str3055[sizeof("rfisht")]; - char entity_pool_str3057[sizeof("lfisht")]; - char entity_pool_str3058[sizeof("harrcir")]; - char entity_pool_str3066[sizeof("OpenCurlyQuote")]; - char entity_pool_str3068[sizeof("ufisht")]; - char entity_pool_str3069[sizeof("NotHumpDownHump")]; - char entity_pool_str3072[sizeof("LeftTee")]; - char entity_pool_str3074[sizeof("rsh")]; - char entity_pool_str3076[sizeof("lsh")]; - char entity_pool_str3080[sizeof("gvertneqq")]; - char entity_pool_str3083[sizeof("timesb")]; - char entity_pool_str3092[sizeof("scpolint")]; - char entity_pool_str3095[sizeof("Cdot")]; - char entity_pool_str3103[sizeof("dwangle")]; - char entity_pool_str3114[sizeof("Ubreve")]; - char entity_pool_str3132[sizeof("LeftUpVector")]; - char entity_pool_str3135[sizeof("LeftUpVectorBar")]; - char entity_pool_str3139[sizeof("Ecaron")]; - char entity_pool_str3142[sizeof("homtht")]; - char entity_pool_str3147[sizeof("igrave")]; - char entity_pool_str3155[sizeof("npreceq")]; - char entity_pool_str3156[sizeof("ecolon")]; - char entity_pool_str3167[sizeof("dd")]; - char entity_pool_str3174[sizeof("simeq")]; - char entity_pool_str3179[sizeof("notinE")]; - char entity_pool_str3198[sizeof("bigoplus")]; - char entity_pool_str3214[sizeof("Afr")]; - char entity_pool_str3215[sizeof("leftarrow")]; - char entity_pool_str3216[sizeof("oint")]; - char entity_pool_str3218[sizeof("Tab")]; - char entity_pool_str3227[sizeof("ogon")]; - char entity_pool_str3230[sizeof("lt")]; - char entity_pool_str3231[sizeof("nLeftrightarrow")]; - char entity_pool_str3235[sizeof("rarrb")]; - char entity_pool_str3237[sizeof("larrb")]; - char entity_pool_str3239[sizeof("hscr")]; - char entity_pool_str3246[sizeof("LeftUpDownVector")]; - char entity_pool_str3248[sizeof("kfr")]; - char entity_pool_str3249[sizeof("gfr")]; - char entity_pool_str3250[sizeof("UpArrowBar")]; - char entity_pool_str3259[sizeof("nsce")]; - char entity_pool_str3260[sizeof("ltdot")]; - char entity_pool_str3261[sizeof("gesl")]; - char entity_pool_str3262[sizeof("xodot")]; - char entity_pool_str3263[sizeof("star")]; - char entity_pool_str3266[sizeof("lowbar")]; - char entity_pool_str3268[sizeof("xharr")]; - char entity_pool_str3269[sizeof("ecir")]; - char entity_pool_str3271[sizeof("utdot")]; - char entity_pool_str3272[sizeof("natur")]; - char entity_pool_str3273[sizeof("Lsh")]; - char entity_pool_str3274[sizeof("infin")]; - char entity_pool_str3276[sizeof("comp")]; - char entity_pool_str3278[sizeof("sigmav")]; - char entity_pool_str3285[sizeof("xotime")]; - char entity_pool_str3289[sizeof("Pfr")]; - char entity_pool_str3295[sizeof("Gfr")]; - char entity_pool_str3298[sizeof("bigcap")]; - char entity_pool_str3300[sizeof("simlE")]; - char entity_pool_str3319[sizeof("iiiint")]; - char entity_pool_str3320[sizeof("barwedge")]; - char entity_pool_str3321[sizeof("Barwed")]; - char entity_pool_str3329[sizeof("xlarr")]; - char entity_pool_str3330[sizeof("LessEqualGreater")]; - char entity_pool_str3332[sizeof("crarr")]; - char entity_pool_str3333[sizeof("isindot")]; - char entity_pool_str3335[sizeof("commat")]; - char entity_pool_str3342[sizeof("middot")]; - char entity_pool_str3349[sizeof("lesdotor")]; - char entity_pool_str3356[sizeof("sigmaf")]; - char entity_pool_str3366[sizeof("rarrbfs")]; - char entity_pool_str3368[sizeof("larrbfs")]; - char entity_pool_str3371[sizeof("xrarr")]; - char entity_pool_str3376[sizeof("bigcup")]; - char entity_pool_str3378[sizeof("clubs")]; - char entity_pool_str3379[sizeof("hArr")]; - char entity_pool_str3380[sizeof("rtrie")]; - char entity_pool_str3382[sizeof("ltrie")]; - char entity_pool_str3383[sizeof("imped")]; - char entity_pool_str3388[sizeof("eogon")]; - char entity_pool_str3389[sizeof("rx")]; - char entity_pool_str3390[sizeof("ltrPar")]; - char entity_pool_str3391[sizeof("Star")]; - char entity_pool_str3393[sizeof("uogon")]; - char entity_pool_str3396[sizeof("Tilde")]; - char entity_pool_str3398[sizeof("half")]; - char entity_pool_str3405[sizeof("tilde")]; - char entity_pool_str3412[sizeof("Leftarrow")]; - char entity_pool_str3417[sizeof("gesles")]; - char entity_pool_str3422[sizeof("cap")]; - char entity_pool_str3423[sizeof("strns")]; - char entity_pool_str3427[sizeof("Lt")]; - char entity_pool_str3439[sizeof("prnE")]; - char entity_pool_str3447[sizeof("sqsupe")]; - char entity_pool_str3462[sizeof("sqsupset")]; - char entity_pool_str3467[sizeof("tridot")]; - char entity_pool_str3468[sizeof("order")]; - char entity_pool_str3471[sizeof("caps")]; - char entity_pool_str3475[sizeof("cross")]; - char entity_pool_str3482[sizeof("dfisht")]; - char entity_pool_str3487[sizeof("xmap")]; - char entity_pool_str3491[sizeof("sqsup")]; - char entity_pool_str3503[sizeof("rtri")]; - char entity_pool_str3505[sizeof("ltri")]; - char entity_pool_str3506[sizeof("it")]; - char entity_pool_str3507[sizeof("rmoust")]; - char entity_pool_str3509[sizeof("lmoust")]; - char entity_pool_str3510[sizeof("gnE")]; - char entity_pool_str3511[sizeof("lgE")]; - char entity_pool_str3514[sizeof("scE")]; - char entity_pool_str3516[sizeof("utri")]; - char entity_pool_str3518[sizeof("vellip")]; - char entity_pool_str3520[sizeof("ETH")]; - char entity_pool_str3523[sizeof("lmidot")]; - char entity_pool_str3525[sizeof("Uogon")]; - char entity_pool_str3526[sizeof("CounterClockwiseContourIntegral")]; - char entity_pool_str3534[sizeof("ngE")]; - char entity_pool_str3535[sizeof("nwnear")]; - char entity_pool_str3543[sizeof("lesg")]; - char entity_pool_str3546[sizeof("plusb")]; - char entity_pool_str3550[sizeof("Rsh")]; - char entity_pool_str3555[sizeof("copysr")]; - char entity_pool_str3557[sizeof("infintie")]; - char entity_pool_str3559[sizeof("imath")]; - char entity_pool_str3560[sizeof("Esim")]; - char entity_pool_str3565[sizeof("Phi")]; - char entity_pool_str3573[sizeof("glE")]; - char entity_pool_str3579[sizeof("vnsup")]; - char entity_pool_str3582[sizeof("simgE")]; - char entity_pool_str3586[sizeof("DoubleLongLeftArrow")]; - char entity_pool_str3591[sizeof("DoubleLongLeftRightArrow")]; - char entity_pool_str3594[sizeof("nvgt")]; - char entity_pool_str3607[sizeof("Mellintrf")]; - char entity_pool_str3611[sizeof("Prime")]; - char entity_pool_str3615[sizeof("iinfin")]; - char entity_pool_str3620[sizeof("ReverseElement")]; - char entity_pool_str3627[sizeof("EmptySmallSquare")]; - char entity_pool_str3628[sizeof("radic")]; - char entity_pool_str3631[sizeof("hfr")]; - char entity_pool_str3632[sizeof("zdot")]; - char entity_pool_str3633[sizeof("male")]; - char entity_pool_str3635[sizeof("rarrc")]; - char entity_pool_str3636[sizeof("prec")]; - char entity_pool_str3637[sizeof("scnap")]; - char entity_pool_str3641[sizeof("DifferentialD")]; - char entity_pool_str3643[sizeof("models")]; - char entity_pool_str3657[sizeof("ltcir")]; - char entity_pool_str3658[sizeof("iogon")]; - char entity_pool_str3665[sizeof("capcap")]; - char entity_pool_str3667[sizeof("iff")]; - char entity_pool_str3669[sizeof("ddotseq")]; - char entity_pool_str3671[sizeof("CirclePlus")]; - char entity_pool_str3676[sizeof("rthree")]; - char entity_pool_str3678[sizeof("lthree")]; - char entity_pool_str3681[sizeof("PrecedesTilde")]; - char entity_pool_str3685[sizeof("dtdot")]; - char entity_pool_str3687[sizeof("clubsuit")]; - char entity_pool_str3689[sizeof("racute")]; - char entity_pool_str3691[sizeof("lacute")]; - char entity_pool_str3692[sizeof("trpezium")]; - char entity_pool_str3693[sizeof("sacute")]; - char entity_pool_str3696[sizeof("Zacute")]; - char entity_pool_str3697[sizeof("eacute")]; - char entity_pool_str3699[sizeof("TildeTilde")]; - char entity_pool_str3701[sizeof("Uarrocir")]; - char entity_pool_str3702[sizeof("uacute")]; - char entity_pool_str3703[sizeof("lowast")]; - char entity_pool_str3714[sizeof("nacute")]; - char entity_pool_str3716[sizeof("NotPrecedes")]; - char entity_pool_str3720[sizeof("Lmidot")]; - char entity_pool_str3725[sizeof("UpArrow")]; - char entity_pool_str3727[sizeof("rarrw")]; - char entity_pool_str3738[sizeof("DownTee")]; - char entity_pool_str3742[sizeof("FilledSmallSquare")]; - char entity_pool_str3743[sizeof("capcup")]; - char entity_pool_str3749[sizeof("GreaterFullEqual")]; - char entity_pool_str3756[sizeof("nvle")]; - char entity_pool_str3758[sizeof("trie")]; - char entity_pool_str3764[sizeof("omicron")]; - char entity_pool_str3766[sizeof("DoubleRightTee")]; - char entity_pool_str3767[sizeof("Cconint")]; - char entity_pool_str3768[sizeof("rsquor")]; - char entity_pool_str3770[sizeof("lsquor")]; - char entity_pool_str3772[sizeof("zigrarr")]; - char entity_pool_str3780[sizeof("copf")]; - char entity_pool_str3782[sizeof("ContourIntegral")]; - char entity_pool_str3798[sizeof("hairsp")]; - char entity_pool_str3799[sizeof("sqsupseteq")]; - char entity_pool_str3800[sizeof("csub")]; - char entity_pool_str3801[sizeof("upharpoonright")]; - char entity_pool_str3805[sizeof("DownBreve")]; - char entity_pool_str3817[sizeof("ShortDownArrow")]; - char entity_pool_str3819[sizeof("xopf")]; - char entity_pool_str3821[sizeof("Sacute")]; - char entity_pool_str3829[sizeof("vsupnE")]; - char entity_pool_str3830[sizeof("cir")]; - char entity_pool_str3831[sizeof("plusacir")]; - char entity_pool_str3832[sizeof("csup")]; - char entity_pool_str3833[sizeof("vsubnE")]; - char entity_pool_str3834[sizeof("Uacute")]; - char entity_pool_str3836[sizeof("isinE")]; - char entity_pool_str3845[sizeof("gEl")]; - char entity_pool_str3851[sizeof("sqcups")]; - char entity_pool_str3853[sizeof("smid")]; - char entity_pool_str3855[sizeof("lg")]; - char entity_pool_str3857[sizeof("DoubleLongRightArrow")]; - char entity_pool_str3858[sizeof("NotPrecedesSlantEqual")]; - char entity_pool_str3861[sizeof("eg")]; - char entity_pool_str3864[sizeof("AMP")]; - char entity_pool_str3874[sizeof("nmid")]; - char entity_pool_str3883[sizeof("timesd")]; - char entity_pool_str3886[sizeof("DownLeftVector")]; - char entity_pool_str3887[sizeof("zwnj")]; - char entity_pool_str3888[sizeof("Lacute")]; - char entity_pool_str3889[sizeof("DownLeftVectorBar")]; - char entity_pool_str3898[sizeof("ograve")]; - char entity_pool_str3899[sizeof("Yacute")]; - char entity_pool_str3903[sizeof("sqcup")]; - char entity_pool_str3906[sizeof("odot")]; - char entity_pool_str3907[sizeof("Cacute")]; - char entity_pool_str3909[sizeof("nu")]; - char entity_pool_str3910[sizeof("tritime")]; - char entity_pool_str3912[sizeof("Egrave")]; - char entity_pool_str3913[sizeof("eplus")]; - char entity_pool_str3915[sizeof("backcong")]; - char entity_pool_str3918[sizeof("uplus")]; - char entity_pool_str3920[sizeof("Edot")]; - char entity_pool_str3924[sizeof("csupe")]; - char entity_pool_str3926[sizeof("simg")]; - char entity_pool_str3927[sizeof("UpperRightArrow")]; - char entity_pool_str3928[sizeof("csube")]; - char entity_pool_str3930[sizeof("dtri")]; - char entity_pool_str3931[sizeof("prnsim")]; - char entity_pool_str3936[sizeof("boxUr")]; - char entity_pool_str3937[sizeof("uuarr")]; - char entity_pool_str3945[sizeof("DownLeftTeeVector")]; - char entity_pool_str3946[sizeof("gsime")]; - char entity_pool_str3950[sizeof("bigotimes")]; - char entity_pool_str3951[sizeof("Dagger")]; - char entity_pool_str3954[sizeof("Intersection")]; - char entity_pool_str3967[sizeof("iacute")]; - char entity_pool_str3969[sizeof("prcue")]; - char entity_pool_str3981[sizeof("egsdot")]; - char entity_pool_str3987[sizeof("Implies")]; - char entity_pool_str3988[sizeof("VDash")]; - char entity_pool_str3996[sizeof("bump")]; - char entity_pool_str4015[sizeof("Mu")]; - char entity_pool_str4022[sizeof("vDash")]; - char entity_pool_str4028[sizeof("lvnE")]; - char entity_pool_str4033[sizeof("LeftTeeArrow")]; - char entity_pool_str4037[sizeof("Nacute")]; - char entity_pool_str4042[sizeof("UnderBrace")]; - char entity_pool_str4043[sizeof("Psi")]; - char entity_pool_str4047[sizeof("rhov")]; - char entity_pool_str4049[sizeof("lescc")]; - char entity_pool_str4055[sizeof("sup1")]; - char entity_pool_str4058[sizeof("sup2")]; - char entity_pool_str4066[sizeof("sup3")]; - char entity_pool_str4071[sizeof("bigodot")]; - char entity_pool_str4078[sizeof("Downarrow")]; - char entity_pool_str4080[sizeof("xsqcup")]; - char entity_pool_str4082[sizeof("barvee")]; - char entity_pool_str4087[sizeof("NegativeMediumSpace")]; - char entity_pool_str4088[sizeof("bumpe")]; - char entity_pool_str4100[sizeof("cscr")]; - char entity_pool_str4109[sizeof("nsc")]; - char entity_pool_str4115[sizeof("sup")]; - char entity_pool_str4122[sizeof("cedil")]; - char entity_pool_str4125[sizeof("boxVr")]; - char entity_pool_str4127[sizeof("origof")]; - char entity_pool_str4128[sizeof("zwj")]; - char entity_pool_str4129[sizeof("Igrave")]; - char entity_pool_str4137[sizeof("Idot")]; - char entity_pool_str4139[sizeof("xscr")]; - char entity_pool_str4140[sizeof("xi")]; - char entity_pool_str4144[sizeof("nGtv")]; - char entity_pool_str4153[sizeof("boxHu")]; - char entity_pool_str4163[sizeof("THORN")]; - char entity_pool_str4165[sizeof("Racute")]; - char entity_pool_str4167[sizeof("rarrhk")]; - char entity_pool_str4169[sizeof("larrhk")]; - char entity_pool_str4177[sizeof("rtriltri")]; - char entity_pool_str4189[sizeof("boxV")]; - char entity_pool_str4215[sizeof("dagger")]; - char entity_pool_str4220[sizeof("Omicron")]; - char entity_pool_str4226[sizeof("DoubleVerticalBar")]; - char entity_pool_str4229[sizeof("nexists")]; - char entity_pool_str4232[sizeof("Nu")]; - char entity_pool_str4233[sizeof("nexist")]; - char entity_pool_str4234[sizeof("gE")]; - char entity_pool_str4238[sizeof("ap")]; - char entity_pool_str4243[sizeof("Sup")]; - char entity_pool_str4244[sizeof("doteqdot")]; - char entity_pool_str4247[sizeof("eng")]; - char entity_pool_str4249[sizeof("caron")]; - char entity_pool_str4251[sizeof("boxHU")]; - char entity_pool_str4252[sizeof("gesdot")]; - char entity_pool_str4257[sizeof("ReverseEquilibrium")]; - char entity_pool_str4262[sizeof("boxUL")]; - char entity_pool_str4264[sizeof("supmult")]; - char entity_pool_str4267[sizeof("pitchfork")]; - char entity_pool_str4272[sizeof("numsp")]; - char entity_pool_str4285[sizeof("rang")]; - char entity_pool_str4287[sizeof("lang")]; - char entity_pool_str4290[sizeof("ocir")]; - char entity_pool_str4292[sizeof("rationals")]; - char entity_pool_str4294[sizeof("coprod")]; - char entity_pool_str4307[sizeof("ltlarr")]; - char entity_pool_str4308[sizeof("breve")]; - char entity_pool_str4310[sizeof("nang")]; - char entity_pool_str4315[sizeof("swarhk")]; - char entity_pool_str4322[sizeof("raquo")]; - char entity_pool_str4324[sizeof("laquo")]; - char entity_pool_str4325[sizeof("supsub")]; - char entity_pool_str4329[sizeof("Cup")]; - char entity_pool_str4330[sizeof("ape")]; - char entity_pool_str4331[sizeof("quest")]; - char entity_pool_str4336[sizeof("nwarhk")]; - char entity_pool_str4340[sizeof("supset")]; - char entity_pool_str4342[sizeof("downarrow")]; - char entity_pool_str4351[sizeof("duarr")]; - char entity_pool_str4353[sizeof("apos")]; - char entity_pool_str4354[sizeof("Ograve")]; - char entity_pool_str4355[sizeof("shortparallel")]; - char entity_pool_str4364[sizeof("nsucc")]; - char entity_pool_str4368[sizeof("LongLeftArrow")]; - char entity_pool_str4377[sizeof("lesdoto")]; - char entity_pool_str4384[sizeof("supne")]; - char entity_pool_str4388[sizeof("nGg")]; - char entity_pool_str4396[sizeof("raemptyv")]; - char entity_pool_str4397[sizeof("supsup")]; - char entity_pool_str4398[sizeof("laemptyv")]; - char entity_pool_str4401[sizeof("topfork")]; - char entity_pool_str4423[sizeof("Eogon")]; - char entity_pool_str4429[sizeof("risingdotseq")]; - char entity_pool_str4431[sizeof("bumpeq")]; - char entity_pool_str4435[sizeof("lstrok")]; - char entity_pool_str4439[sizeof("Tstrok")]; - char entity_pool_str4440[sizeof("gsim")]; - char entity_pool_str4443[sizeof("bemptyv")]; - char entity_pool_str4444[sizeof("zacute")]; - char entity_pool_str4445[sizeof("gsiml")]; - char entity_pool_str4448[sizeof("tstrok")]; - char entity_pool_str4450[sizeof("roang")]; - char entity_pool_str4451[sizeof("boxVL")]; - char entity_pool_str4452[sizeof("loang")]; - char entity_pool_str4456[sizeof("nleqslant")]; - char entity_pool_str4462[sizeof("sbquo")]; - char entity_pool_str4464[sizeof("searhk")]; - char entity_pool_str4465[sizeof("lnapprox")]; - char entity_pool_str4468[sizeof("Supset")]; - char entity_pool_str4470[sizeof("boxHd")]; - char entity_pool_str4471[sizeof("varkappa")]; - char entity_pool_str4475[sizeof("circeq")]; - char entity_pool_str4477[sizeof("yopf")]; - char entity_pool_str4479[sizeof("UnionPlus")]; - char entity_pool_str4484[sizeof("Lang")]; - char entity_pool_str4485[sizeof("nearhk")]; - char entity_pool_str4486[sizeof("shcy")]; - char entity_pool_str4492[sizeof("cfr")]; - char entity_pool_str4506[sizeof("Kappa")]; - char entity_pool_str4507[sizeof("ljcy")]; - char entity_pool_str4508[sizeof("MediumSpace")]; - char entity_pool_str4511[sizeof("supseteq")]; - char entity_pool_str4512[sizeof("supseteqq")]; - char entity_pool_str4517[sizeof("reg")]; - char entity_pool_str4518[sizeof("amacr")]; - char entity_pool_str4519[sizeof("leg")]; - char entity_pool_str4524[sizeof("weierp")]; - char entity_pool_str4525[sizeof("TScy")]; - char entity_pool_str4529[sizeof("supsetneq")]; - char entity_pool_str4530[sizeof("njcy")]; - char entity_pool_str4531[sizeof("xfr")]; - char entity_pool_str4533[sizeof("mu")]; - char entity_pool_str4539[sizeof("nvinfin")]; - char entity_pool_str4540[sizeof("boxUR")]; - char entity_pool_str4545[sizeof("xoplus")]; - char entity_pool_str4551[sizeof("leftleftarrows")]; - char entity_pool_str4552[sizeof("sum")]; - char entity_pool_str4559[sizeof("beth")]; - char entity_pool_str4563[sizeof("complement")]; - char entity_pool_str4573[sizeof("num")]; - char entity_pool_str4574[sizeof("amp")]; - char entity_pool_str4583[sizeof("boxUl")]; - char entity_pool_str4590[sizeof("NotGreater")]; - char entity_pool_str4591[sizeof("boxplus")]; - char entity_pool_str4592[sizeof("jmath")]; - char entity_pool_str4594[sizeof("sfrown")]; - char entity_pool_str4596[sizeof("Dstrok")]; - char entity_pool_str4598[sizeof("and")]; - char entity_pool_str4599[sizeof("NotGreaterGreater")]; - char entity_pool_str4606[sizeof("NotGreaterSlantEqual")]; - char entity_pool_str4608[sizeof("NotGreaterLess")]; - char entity_pool_str4609[sizeof("quot")]; - char entity_pool_str4616[sizeof("NotGreaterFullEqual")]; - char entity_pool_str4617[sizeof("hyphen")]; - char entity_pool_str4618[sizeof("planck")]; - char entity_pool_str4620[sizeof("TildeEqual")]; - char entity_pool_str4627[sizeof("tosa")]; - char entity_pool_str4632[sizeof("Lstrok")]; - char entity_pool_str4635[sizeof("shy")]; - char entity_pool_str4639[sizeof("xnis")]; - char entity_pool_str4640[sizeof("Iogon")]; - char entity_pool_str4643[sizeof("DZcy")]; - char entity_pool_str4645[sizeof("ohbar")]; - char entity_pool_str4652[sizeof("cirscir")]; - char entity_pool_str4654[sizeof("sext")]; - char entity_pool_str4668[sizeof("para")]; - char entity_pool_str4671[sizeof("ast")]; - char entity_pool_str4678[sizeof("questeq")]; - char entity_pool_str4680[sizeof("Sum")]; - char entity_pool_str4682[sizeof("DScy")]; - char entity_pool_str4684[sizeof("ENG")]; - char entity_pool_str4686[sizeof("ZHcy")]; - char entity_pool_str4689[sizeof("longleftarrow")]; - char entity_pool_str4691[sizeof("dash")]; - char entity_pool_str4699[sizeof("DownTeeArrow")]; - char entity_pool_str4706[sizeof("supsetneqq")]; - char entity_pool_str4714[sizeof("profalar")]; - char entity_pool_str4718[sizeof("oacute")]; - char entity_pool_str4729[sizeof("boxVR")]; - char entity_pool_str4732[sizeof("Eacute")]; - char entity_pool_str4738[sizeof("supplus")]; - char entity_pool_str4740[sizeof("hookleftarrow")]; - char entity_pool_str4743[sizeof("CloseCurlyQuote")]; - char entity_pool_str4746[sizeof("trisb")]; - char entity_pool_str4747[sizeof("dotsquare")]; - char entity_pool_str4751[sizeof("rtimes")]; - char entity_pool_str4753[sizeof("ltimes")]; - char entity_pool_str4756[sizeof("toea")]; - char entity_pool_str4757[sizeof("Agrave")]; - char entity_pool_str4760[sizeof("Assign")]; - char entity_pool_str4761[sizeof("Rang")]; - char entity_pool_str4762[sizeof("iocy")]; - char entity_pool_str4764[sizeof("NotPrecedesEqual")]; - char entity_pool_str4766[sizeof("aopf")]; - char entity_pool_str4768[sizeof("chi")]; - char entity_pool_str4771[sizeof("quaternions")]; - char entity_pool_str4772[sizeof("boxVl")]; - char entity_pool_str4773[sizeof("NotGreaterEqual")]; - char entity_pool_str4777[sizeof("xhArr")]; - char entity_pool_str4791[sizeof("orderof")]; - char entity_pool_str4794[sizeof("rsquo")]; - char entity_pool_str4796[sizeof("lsquo")]; - char entity_pool_str4797[sizeof("yscr")]; - char entity_pool_str4800[sizeof("gdot")]; - char entity_pool_str4802[sizeof("NotSquareSubsetEqual")]; - char entity_pool_str4803[sizeof("KHcy")]; - char entity_pool_str4809[sizeof("bsolb")]; - char entity_pool_str4810[sizeof("NotSquareSubset")]; - char entity_pool_str4811[sizeof("SHcy")]; - char entity_pool_str4821[sizeof("YIcy")]; - char entity_pool_str4825[sizeof("cwint")]; - char entity_pool_str4828[sizeof("Theta")]; - char entity_pool_str4837[sizeof("theta")]; - char entity_pool_str4838[sizeof("xlArr")]; - char entity_pool_str4840[sizeof("NotSquareSupersetEqual")]; - char entity_pool_str4843[sizeof("demptyv")]; - char entity_pool_str4844[sizeof("triangle")]; - char entity_pool_str4846[sizeof("Gdot")]; - char entity_pool_str4848[sizeof("NotSquareSuperset")]; - char entity_pool_str4857[sizeof("Abreve")]; - char entity_pool_str4860[sizeof("dstrok")]; - char entity_pool_str4861[sizeof("pertenk")]; - char entity_pool_str4866[sizeof("rbrack")]; - char entity_pool_str4868[sizeof("lbrack")]; - char entity_pool_str4872[sizeof("odsold")]; - char entity_pool_str4878[sizeof("omid")]; - char entity_pool_str4880[sizeof("xrArr")]; - char entity_pool_str4882[sizeof("triangleleft")]; - char entity_pool_str4883[sizeof("NotGreaterTilde")]; - char entity_pool_str4884[sizeof("colone")]; - char entity_pool_str4886[sizeof("Longleftarrow")]; - char entity_pool_str4888[sizeof("iota")]; - char entity_pool_str4890[sizeof("colon")]; - char entity_pool_str4891[sizeof("Zeta")]; - char entity_pool_str4892[sizeof("gbreve")]; - char entity_pool_str4897[sizeof("CHcy")]; - char entity_pool_str4900[sizeof("YUcy")]; - char entity_pool_str4901[sizeof("REG")]; - char entity_pool_str4902[sizeof("szlig")]; - char entity_pool_str4909[sizeof("dzcy")]; - char entity_pool_str4911[sizeof("beta")]; - char entity_pool_str4918[sizeof("euro")]; - char entity_pool_str4921[sizeof("LeftArrow")]; - char entity_pool_str4924[sizeof("CapitalDifferentialD")]; - char entity_pool_str4926[sizeof("ring")]; - char entity_pool_str4927[sizeof("Laplacetrf")]; - char entity_pool_str4932[sizeof("djcy")]; - char entity_pool_str4934[sizeof("oplus")]; - char entity_pool_str4937[sizeof("integers")]; - char entity_pool_str4938[sizeof("Gbreve")]; - char entity_pool_str4940[sizeof("ubrcy")]; - char entity_pool_str4941[sizeof("euml")]; - char entity_pool_str4944[sizeof("deg")]; - char entity_pool_str4946[sizeof("uuml")]; - char entity_pool_str4949[sizeof("Iacute")]; - char entity_pool_str4950[sizeof("succeq")]; - char entity_pool_str4952[sizeof("KJcy")]; - char entity_pool_str4961[sizeof("CupCap")]; - char entity_pool_str4975[sizeof("tscy")]; - char entity_pool_str4982[sizeof("cent")]; - char entity_pool_str4991[sizeof("DJcy")]; - char entity_pool_str5009[sizeof("TildeFullEqual")]; - char entity_pool_str5011[sizeof("triangleq")]; - char entity_pool_str5016[sizeof("duhar")]; - char entity_pool_str5025[sizeof("LeftDoubleBracket")]; - char entity_pool_str5027[sizeof("LJcy")]; - char entity_pool_str5036[sizeof("iecy")]; - char entity_pool_str5043[sizeof("trianglelefteq")]; - char entity_pool_str5049[sizeof("nequiv")]; - char entity_pool_str5055[sizeof("nshortparallel")]; - char entity_pool_str5062[sizeof("ndash")]; - char entity_pool_str5063[sizeof("bowtie")]; - char entity_pool_str5065[sizeof("fjlig")]; - char entity_pool_str5072[sizeof("Ubrcy")]; - char entity_pool_str5074[sizeof("vartheta")]; - char entity_pool_str5078[sizeof("Uuml")]; - char entity_pool_str5084[sizeof("vartriangleright")]; - char entity_pool_str5085[sizeof("vartriangleleft")]; - char entity_pool_str5086[sizeof("ascr")]; - char entity_pool_str5089[sizeof("succcurlyeq")]; - char entity_pool_str5093[sizeof("cwconint")]; - char entity_pool_str5101[sizeof("sc")]; - char entity_pool_str5103[sizeof("fllig")]; - char entity_pool_str5105[sizeof("circledast")]; - char entity_pool_str5108[sizeof("Vdash")]; - char entity_pool_str5112[sizeof("nVdash")]; - char entity_pool_str5120[sizeof("suplarr")]; - char entity_pool_str5124[sizeof("robrk")]; - char entity_pool_str5126[sizeof("lobrk")]; - char entity_pool_str5142[sizeof("vdash")]; - char entity_pool_str5143[sizeof("Yuml")]; - char entity_pool_str5151[sizeof("gt")]; - char entity_pool_str5156[sizeof("ccaps")]; - char entity_pool_str5173[sizeof("Succeeds")]; - char entity_pool_str5174[sizeof("Oacute")]; - char entity_pool_str5175[sizeof("TRADE")]; - char entity_pool_str5176[sizeof("NJcy")]; - char entity_pool_str5181[sizeof("gtdot")]; - char entity_pool_str5189[sizeof("yfr")]; - char entity_pool_str5192[sizeof("compfn")]; - char entity_pool_str5197[sizeof("Gt")]; - char entity_pool_str5198[sizeof("scnE")]; - char entity_pool_str5199[sizeof("ijlig")]; - char entity_pool_str5203[sizeof("circledS")]; - char entity_pool_str5206[sizeof("yen")]; - char entity_pool_str5208[sizeof("thetasym")]; - char entity_pool_str5211[sizeof("iuml")]; - char entity_pool_str5212[sizeof("SucceedsSlantEqual")]; - char entity_pool_str5217[sizeof("boxH")]; - char entity_pool_str5218[sizeof("mumap")]; - char entity_pool_str5222[sizeof("rightrightarrows")]; - char entity_pool_str5227[sizeof("coloneq")]; - char entity_pool_str5229[sizeof("Sc")]; - char entity_pool_str5230[sizeof("glj")]; - char entity_pool_str5231[sizeof("iexcl")]; - char entity_pool_str5234[sizeof("ccups")]; - char entity_pool_str5236[sizeof("xcap")]; - char entity_pool_str5237[sizeof("zhcy")]; - char entity_pool_str5241[sizeof("boxHD")]; - char entity_pool_str5250[sizeof("leqslant")]; - char entity_pool_str5252[sizeof("UpperLeftArrow")]; - char entity_pool_str5257[sizeof("dblac")]; - char entity_pool_str5260[sizeof("puncsp")]; - char entity_pool_str5262[sizeof("ccaron")]; - char entity_pool_str5264[sizeof("rbbrk")]; - char entity_pool_str5266[sizeof("lbbrk")]; - char entity_pool_str5268[sizeof("Aogon")]; - char entity_pool_str5269[sizeof("LeftTriangleBar")]; - char entity_pool_str5272[sizeof("gesdotol")]; - char entity_pool_str5273[sizeof("LeftTriangleEqual")]; - char entity_pool_str5274[sizeof("LeftTriangle")]; - char entity_pool_str5280[sizeof("conint")]; - char entity_pool_str5283[sizeof("drbkarow")]; - char entity_pool_str5295[sizeof("rtrif")]; - char entity_pool_str5297[sizeof("ltrif")]; - char entity_pool_str5300[sizeof("ReverseUpEquilibrium")]; - char entity_pool_str5306[sizeof("LeftCeiling")]; - char entity_pool_str5308[sizeof("utrif")]; - char entity_pool_str5314[sizeof("xcup")]; - char entity_pool_str5319[sizeof("fallingdotseq")]; - char entity_pool_str5325[sizeof("rcedil")]; - char entity_pool_str5327[sizeof("lcedil")]; - char entity_pool_str5329[sizeof("scedil")]; - char entity_pool_str5331[sizeof("Tcedil")]; - char entity_pool_str5333[sizeof("starf")]; - char entity_pool_str5334[sizeof("boxminus")]; - char entity_pool_str5340[sizeof("tcedil")]; - char entity_pool_str5341[sizeof("ZeroWidthSpace")]; - char entity_pool_str5350[sizeof("ncedil")]; - char entity_pool_str5358[sizeof("phiv")]; - char entity_pool_str5375[sizeof("ic")]; - char entity_pool_str5384[sizeof("capdot")]; - char entity_pool_str5387[sizeof("dscy")]; - char entity_pool_str5397[sizeof("check")]; - char entity_pool_str5398[sizeof("ovbar")]; - char entity_pool_str5405[sizeof("ntriangleleft")]; - char entity_pool_str5411[sizeof("RightTee")]; - char entity_pool_str5412[sizeof("nvge")]; - char entity_pool_str5424[sizeof("leftrightsquigarrow")]; - char entity_pool_str5431[sizeof("lozenge")]; - char entity_pool_str5434[sizeof("RightTriangleBar")]; - char entity_pool_str5436[sizeof("RightTeeVector")]; - char entity_pool_str5438[sizeof("RightTriangleEqual")]; - char entity_pool_str5439[sizeof("RightTriangle")]; - char entity_pool_str5449[sizeof("Kcedil")]; - char entity_pool_str5457[sizeof("Scedil")]; - char entity_pool_str5468[sizeof("cirfnint")]; - char entity_pool_str5471[sizeof("empty")]; - char entity_pool_str5478[sizeof("afr")]; - char entity_pool_str5482[sizeof("DiacriticalTilde")]; - char entity_pool_str5489[sizeof("LeftDownVector")]; - char entity_pool_str5492[sizeof("LeftDownVectorBar")]; - char entity_pool_str5501[sizeof("lEg")]; - char entity_pool_str5509[sizeof("ApplyFunction")]; - char entity_pool_str5512[sizeof("bumpE")]; - char entity_pool_str5524[sizeof("Lcedil")]; - char entity_pool_str5528[sizeof("caret")]; - char entity_pool_str5530[sizeof("Barv")]; - char entity_pool_str5543[sizeof("Ccedil")]; - char entity_pool_str5547[sizeof("circledR")]; - char entity_pool_str5548[sizeof("LeftDownTeeVector")]; - char entity_pool_str5552[sizeof("tshcy")]; - char entity_pool_str5556[sizeof("DotEqual")]; - char entity_pool_str5564[sizeof("centerdot")]; - char entity_pool_str5566[sizeof("ntrianglelefteq")]; - char entity_pool_str5568[sizeof("minus")]; - char entity_pool_str5570[sizeof("gimel")]; - char entity_pool_str5577[sizeof("Aacute")]; - char entity_pool_str5578[sizeof("gtcir")]; - char entity_pool_str5583[sizeof("gtrarr")]; - char entity_pool_str5584[sizeof("bull")]; - char entity_pool_str5587[sizeof("DownArrow")]; - char entity_pool_str5593[sizeof("rdquor")]; - char entity_pool_str5595[sizeof("ldquor")]; - char entity_pool_str5598[sizeof("intlarhk")]; - char entity_pool_str5602[sizeof("utilde")]; - char entity_pool_str5612[sizeof("gacute")]; - char entity_pool_str5614[sizeof("ntilde")]; - char entity_pool_str5615[sizeof("af")]; - char entity_pool_str5618[sizeof("Hstrok")]; - char entity_pool_str5620[sizeof("exponentiale")]; - char entity_pool_str5621[sizeof("minusb")]; - char entity_pool_str5625[sizeof("RightUpTeeVector")]; - char entity_pool_str5630[sizeof("UpTeeArrow")]; - char entity_pool_str5639[sizeof("zeta")]; - char entity_pool_str5644[sizeof("DiacriticalDot")]; - char entity_pool_str5645[sizeof("DiacriticalDoubleAcute")]; - char entity_pool_str5663[sizeof("nleftarrow")]; - char entity_pool_str5664[sizeof("hkswarow")]; - char entity_pool_str5666[sizeof("iiota")]; - char entity_pool_str5669[sizeof("apacir")]; - char entity_pool_str5673[sizeof("Ncedil")]; - char entity_pool_str5678[sizeof("capand")]; - char entity_pool_str5686[sizeof("mdash")]; - char entity_pool_str5689[sizeof("filig")]; - char entity_pool_str5690[sizeof("scnsim")]; - char entity_pool_str5699[sizeof("realpart")]; - char entity_pool_str5703[sizeof("leftthreetimes")]; - char entity_pool_str5704[sizeof("asymp")]; - char entity_pool_str5718[sizeof("hellip")]; - char entity_pool_str5722[sizeof("dtrif")]; - char entity_pool_str5724[sizeof("NotExists")]; - char entity_pool_str5728[sizeof("sccue")]; - char entity_pool_str5733[sizeof("YAcy")]; - char entity_pool_str5734[sizeof("Utilde")]; - char entity_pool_str5741[sizeof("NotEqual")]; - char entity_pool_str5747[sizeof("ThinSpace")]; - char entity_pool_str5754[sizeof("apE")]; - char entity_pool_str5762[sizeof("bullet")]; - char entity_pool_str5765[sizeof("CloseCurlyDoubleQuote")]; - char entity_pool_str5766[sizeof("Delta")]; - char entity_pool_str5776[sizeof("gg")]; - char entity_pool_str5780[sizeof("otimes")]; - char entity_pool_str5799[sizeof("wreath")]; - char entity_pool_str5801[sizeof("Rcedil")]; - char entity_pool_str5807[sizeof("eth")]; - char entity_pool_str5808[sizeof("supnE")]; - char entity_pool_str5811[sizeof("awint")]; - char entity_pool_str5817[sizeof("Breve")]; - char entity_pool_str5822[sizeof("Gg")]; - char entity_pool_str5824[sizeof("HumpEqual")]; - char entity_pool_str5837[sizeof("Lleftarrow")]; - char entity_pool_str5838[sizeof("boxdr")]; - char entity_pool_str5847[sizeof("succneqq")]; - char entity_pool_str5848[sizeof("uring")]; - char entity_pool_str5849[sizeof("LessSlantEqual")]; - char entity_pool_str5860[sizeof("nvdash")]; - char entity_pool_str5866[sizeof("Hacek")]; - char entity_pool_str5867[sizeof("itilde")]; - char entity_pool_str5870[sizeof("Iota")]; - char entity_pool_str5872[sizeof("IOcy")]; - char entity_pool_str5884[sizeof("boxDr")]; - char entity_pool_str5891[sizeof("SucceedsTilde")]; - char entity_pool_str5905[sizeof("LeftFloor")]; - char entity_pool_str5906[sizeof("Vvdash")]; - char entity_pool_str5923[sizeof("triangledown")]; - char entity_pool_str5927[sizeof("LongLeftRightArrow")]; - char entity_pool_str5928[sizeof("RightFloor")]; - char entity_pool_str5931[sizeof("DownRightTeeVector")]; - char entity_pool_str5933[sizeof("quatint")]; - char entity_pool_str5937[sizeof("Ntilde")]; - char entity_pool_str5940[sizeof("Bumpeq")]; - char entity_pool_str5949[sizeof("gvnE")]; - char entity_pool_str5951[sizeof("boxhu")]; - char entity_pool_str5956[sizeof("gtlPar")]; - char entity_pool_str5959[sizeof("nprec")]; - char entity_pool_str5962[sizeof("ouml")]; - char entity_pool_str5970[sizeof("gescc")]; - char entity_pool_str5976[sizeof("Euml")]; - char entity_pool_str5980[sizeof("Uring")]; - char entity_pool_str5982[sizeof("UnderBracket")]; - char entity_pool_str5983[sizeof("nLtv")]; - char entity_pool_str5984[sizeof("LeftArrowBar")]; - char entity_pool_str5985[sizeof("ncongdot")]; - char entity_pool_str6003[sizeof("asympeq")]; - char entity_pool_str6023[sizeof("minusdu")]; - char entity_pool_str6030[sizeof("delta")]; - char entity_pool_str6032[sizeof("harrw")]; - char entity_pool_str6038[sizeof("andslope")]; - char entity_pool_str6043[sizeof("cdot")]; - char entity_pool_str6048[sizeof("Cayleys")]; - char entity_pool_str6049[sizeof("boxhU")]; - char entity_pool_str6052[sizeof("succsim")]; - char entity_pool_str6061[sizeof("cirE")]; - char entity_pool_str6062[sizeof("sdotb")]; - char entity_pool_str6066[sizeof("odash")]; - char entity_pool_str6067[sizeof("cirmid")]; - char entity_pool_str6068[sizeof("suphsub")]; - char entity_pool_str6069[sizeof("supdsub")]; - char entity_pool_str6077[sizeof("supdot")]; - char entity_pool_str6079[sizeof("awconint")]; - char entity_pool_str6084[sizeof("TSHcy")]; - char entity_pool_str6087[sizeof("grave")]; - char entity_pool_str6101[sizeof("lsimg")]; - char entity_pool_str6106[sizeof("UpArrowDownArrow")]; - char entity_pool_str6121[sizeof("LeftVector")]; - char entity_pool_str6122[sizeof("DoubleRightArrow")]; - char entity_pool_str6129[sizeof("NegativeThinSpace")]; - char entity_pool_str6140[sizeof("lhblk")]; - char entity_pool_str6146[sizeof("cire")]; - char entity_pool_str6147[sizeof("nVDash")]; - char entity_pool_str6151[sizeof("uhblk")]; - char entity_pool_str6155[sizeof("imagpart")]; - char entity_pool_str6161[sizeof("RightUpDownVector")]; - char entity_pool_str6164[sizeof("boxdL")]; - char entity_pool_str6176[sizeof("gla")]; - char entity_pool_str6193[sizeof("Iuml")]; - char entity_pool_str6203[sizeof("oelig")]; - char entity_pool_str6208[sizeof("NotLessSlantEqual")]; - char entity_pool_str6210[sizeof("boxDL")]; - char entity_pool_str6215[sizeof("gamma")]; - char entity_pool_str6236[sizeof("Otimes")]; - char entity_pool_str6248[sizeof("longleftrightarrow")]; - char entity_pool_str6261[sizeof("Gamma")]; - char entity_pool_str6262[sizeof("bigwedge")]; - char entity_pool_str6268[sizeof("boxhd")]; - char entity_pool_str6283[sizeof("supE")]; - char entity_pool_str6292[sizeof("LeftUpTeeVector")]; - char entity_pool_str6298[sizeof("gesdoto")]; - char entity_pool_str6304[sizeof("kappa")]; - char entity_pool_str6315[sizeof("ngeqslant")]; - char entity_pool_str6340[sizeof("gtrless")]; - char entity_pool_str6351[sizeof("fflig")]; - char entity_pool_str6352[sizeof("bigsqcup")]; - char entity_pool_str6367[sizeof("kgreen")]; - char entity_pool_str6368[sizeof("supe")]; - char entity_pool_str6370[sizeof("boxtimes")]; - char entity_pool_str6386[sizeof("gnapprox")]; - char entity_pool_str6394[sizeof("downdownarrows")]; - char entity_pool_str6403[sizeof("biguplus")]; - char entity_pool_str6404[sizeof("khcy")]; - char entity_pool_str6406[sizeof("ddagger")]; - char entity_pool_str6418[sizeof("Ouml")]; - char entity_pool_str6420[sizeof("Beta")]; - char entity_pool_str6421[sizeof("minusd")]; - char entity_pool_str6422[sizeof("succnsim")]; - char entity_pool_str6424[sizeof("ctdot")]; - char entity_pool_str6427[sizeof("kjcy")]; - char entity_pool_str6428[sizeof("gjcy")]; - char entity_pool_str6430[sizeof("ncong")]; - char entity_pool_str6431[sizeof("xvee")]; - char entity_pool_str6432[sizeof("bcong")]; - char entity_pool_str6439[sizeof("sqsube")]; - char entity_pool_str6442[sizeof("boxdR")]; - char entity_pool_str6445[sizeof("Longleftrightarrow")]; - char entity_pool_str6447[sizeof("sqsub")]; - char entity_pool_str6451[sizeof("DownLeftRightVector")]; - char entity_pool_str6454[sizeof("sqsubset")]; - char entity_pool_str6456[sizeof("NotVerticalBar")]; - char entity_pool_str6461[sizeof("NotEqualTilde")]; - char entity_pool_str6485[sizeof("boxdl")]; - char entity_pool_str6488[sizeof("boxDR")]; - char entity_pool_str6490[sizeof("andand")]; - char entity_pool_str6502[sizeof("RightVector")]; - char entity_pool_str6504[sizeof("IJlig")]; - char entity_pool_str6505[sizeof("NotTildeEqual")]; - char entity_pool_str6509[sizeof("angzarr")]; - char entity_pool_str6515[sizeof("angrt")]; - char entity_pool_str6521[sizeof("acd")]; - char entity_pool_str6524[sizeof("andd")]; - char entity_pool_str6526[sizeof("nrarrc")]; - char entity_pool_str6527[sizeof("VeryThinSpace")]; - char entity_pool_str6529[sizeof("Superset")]; - char entity_pool_str6531[sizeof("boxDl")]; - char entity_pool_str6535[sizeof("vnsub")]; - char entity_pool_str6538[sizeof("ccupssm")]; - char entity_pool_str6548[sizeof("varnothing")]; - char entity_pool_str6552[sizeof("rcy")]; - char entity_pool_str6554[sizeof("lcy")]; - char entity_pool_str6556[sizeof("scy")]; - char entity_pool_str6558[sizeof("Tcy")]; - char entity_pool_str6559[sizeof("Zcy")]; - char entity_pool_str6560[sizeof("ecy")]; - char entity_pool_str6561[sizeof("rdsh")]; - char entity_pool_str6563[sizeof("ldsh")]; - char entity_pool_str6565[sizeof("ucy")]; - char entity_pool_str6566[sizeof("boxVH")]; - char entity_pool_str6567[sizeof("tcy")]; - char entity_pool_str6577[sizeof("ncy")]; - char entity_pool_str6579[sizeof("bcy")]; - char entity_pool_str6580[sizeof("ntgl")]; - char entity_pool_str6585[sizeof("Jcy")]; - char entity_pool_str6600[sizeof("congdot")]; - char entity_pool_str6607[sizeof("angst")]; - char entity_pool_str6609[sizeof("RightDownTeeVector")]; - char entity_pool_str6612[sizeof("OverParenthesis")]; - char entity_pool_str6613[sizeof("ltquest")]; - char entity_pool_str6615[sizeof("pcy")]; - char entity_pool_str6618[sizeof("otilde")]; - char entity_pool_str6619[sizeof("rdquo")]; - char entity_pool_str6621[sizeof("ldquo")]; - char entity_pool_str6623[sizeof("Vcy")]; - char entity_pool_str6626[sizeof("capbrcup")]; - char entity_pool_str6646[sizeof("bdquo")]; - char entity_pool_str6650[sizeof("DownArrowBar")]; - char entity_pool_str6657[sizeof("vcy")]; - char entity_pool_str6665[sizeof("angrtvb")]; - char entity_pool_str6676[sizeof("Kcy")]; - char entity_pool_str6683[sizeof("Mcy")]; - char entity_pool_str6684[sizeof("Scy")]; - char entity_pool_str6691[sizeof("NewLine")]; - char entity_pool_str6696[sizeof("fcy")]; - char entity_pool_str6697[sizeof("Ucy")]; - char entity_pool_str6704[sizeof("boxVh")]; - char entity_pool_str6715[sizeof("Dcy")]; - char entity_pool_str6738[sizeof("hstrok")]; - char entity_pool_str6751[sizeof("Lcy")]; - char entity_pool_str6762[sizeof("Ycy")]; - char entity_pool_str6775[sizeof("supsim")]; - char entity_pool_str6789[sizeof("NonBreakingSpace")]; - char entity_pool_str6790[sizeof("OverBar")]; - char entity_pool_str6791[sizeof("sqsubseteq")]; - char entity_pool_str6797[sizeof("GJcy")]; - char entity_pool_str6800[sizeof("OverBrace")]; - char entity_pool_str6806[sizeof("eqcirc")]; - char entity_pool_str6819[sizeof("OverBracket")]; - char entity_pool_str6821[sizeof("Auml")]; - char entity_pool_str6829[sizeof("acute")]; - char entity_pool_str6830[sizeof("icy")]; - char entity_pool_str6849[sizeof("Itilde")]; - char entity_pool_str6850[sizeof("HilbertSpace")]; - char entity_pool_str6854[sizeof("omega")]; - char entity_pool_str6855[sizeof("cacute")]; - char entity_pool_str6861[sizeof("scirc")]; - char entity_pool_str6865[sizeof("ecirc")]; - char entity_pool_str6870[sizeof("ucirc")]; - char entity_pool_str6872[sizeof("GreaterSlantEqual")]; - char entity_pool_str6890[sizeof("Jcirc")]; - char entity_pool_str6895[sizeof("nvDash")]; - char entity_pool_str6896[sizeof("Wcirc")]; - char entity_pool_str6900[sizeof("Ncy")]; - char entity_pool_str6921[sizeof("RightTeeArrow")]; - char entity_pool_str6942[sizeof("LessFullEqual")]; - char entity_pool_str6958[sizeof("ltcc")]; - char entity_pool_str6963[sizeof("aleph")]; - char entity_pool_str6979[sizeof("dcy")]; - char entity_pool_str6989[sizeof("Scirc")]; - char entity_pool_str6991[sizeof("lessapprox")]; - char entity_pool_str7000[sizeof("IEcy")]; - char entity_pool_str7001[sizeof("LowerRightArrow")]; - char entity_pool_str7002[sizeof("Ucirc")]; - char entity_pool_str7021[sizeof("agrave")]; - char entity_pool_str7023[sizeof("MinusPlus")]; - char entity_pool_str7024[sizeof("bigvee")]; - char entity_pool_str7028[sizeof("Rcy")]; - char entity_pool_str7034[sizeof("suphsol")]; - char entity_pool_str7037[sizeof("EmptyVerySmallSquare")]; - char entity_pool_str7039[sizeof("boxhD")]; - char entity_pool_str7047[sizeof("precapprox")]; - char entity_pool_str7066[sizeof("angrtvbd")]; - char entity_pool_str7067[sizeof("Ycirc")]; - char entity_pool_str7071[sizeof("sub")]; - char entity_pool_str7074[sizeof("Otilde")]; - char entity_pool_str7075[sizeof("Ccirc")]; - char entity_pool_str7085[sizeof("Fcy")]; - char entity_pool_str7090[sizeof("complexes")]; - char entity_pool_str7096[sizeof("subrarr")]; - char entity_pool_str7115[sizeof("InvisibleComma")]; - char entity_pool_str7120[sizeof("boxur")]; - char entity_pool_str7121[sizeof("abreve")]; - char entity_pool_str7127[sizeof("ntlg")]; - char entity_pool_str7135[sizeof("icirc")]; - char entity_pool_str7142[sizeof("xdtri")]; - char entity_pool_str7143[sizeof("circ")]; - char entity_pool_str7168[sizeof("gtrdot")]; - char entity_pool_str7171[sizeof("geqslant")]; - char entity_pool_str7183[sizeof("ntriangleright")]; - char entity_pool_str7198[sizeof("cuepr")]; - char entity_pool_str7199[sizeof("Sub")]; - char entity_pool_str7201[sizeof("mcy")]; - char entity_pool_str7212[sizeof("timesbar")]; - char entity_pool_str7214[sizeof("hksearow")]; - char entity_pool_str7217[sizeof("sigma")]; - char entity_pool_str7224[sizeof("cupor")]; - char entity_pool_str7230[sizeof("oslash")]; - char entity_pool_str7231[sizeof("dzigrarr")]; - char entity_pool_str7234[sizeof("leftrightharpoons")]; - char entity_pool_str7245[sizeof("rightleftharpoons")]; - char entity_pool_str7247[sizeof("kcedil")]; - char entity_pool_str7256[sizeof("submult")]; - char entity_pool_str7260[sizeof("curren")]; - char entity_pool_str7269[sizeof("LeftTeeVector")]; - char entity_pool_str7274[sizeof("bigstar")]; - char entity_pool_str7277[sizeof("cup")]; - char entity_pool_str7278[sizeof("LongRightArrow")]; - char entity_pool_str7294[sizeof("Gcedil")]; - char entity_pool_str7296[sizeof("PrecedesEqual")]; - char entity_pool_str7307[sizeof("zcy")]; - char entity_pool_str7309[sizeof("planckh")]; - char entity_pool_str7310[sizeof("Omega")]; - char entity_pool_str7317[sizeof("subsub")]; - char entity_pool_str7325[sizeof("rdca")]; - char entity_pool_str7326[sizeof("cups")]; - char entity_pool_str7327[sizeof("ldca")]; - char entity_pool_str7332[sizeof("subset")]; - char entity_pool_str7333[sizeof("NotSucceeds")]; - char entity_pool_str7334[sizeof("LeftArrowRightArrow")]; - char entity_pool_str7337[sizeof("wcirc")]; - char entity_pool_str7338[sizeof("RightAngleBracket")]; - char entity_pool_str7344[sizeof("ntrianglerighteq")]; - char entity_pool_str7345[sizeof("Sigma")]; - char entity_pool_str7350[sizeof("NotSucceedsTilde")]; - char entity_pool_str7364[sizeof("DiacriticalAcute")]; - char entity_pool_str7376[sizeof("subne")]; - char entity_pool_str7378[sizeof("Product")]; - char entity_pool_str7385[sizeof("circleddash")]; - char entity_pool_str7389[sizeof("subsup")]; - char entity_pool_str7397[sizeof("copy")]; - char entity_pool_str7403[sizeof("eta")]; - char entity_pool_str7409[sizeof("angmsd")]; - char entity_pool_str7434[sizeof("natural")]; - char entity_pool_str7436[sizeof("supedot")]; - char entity_pool_str7437[sizeof("naturals")]; - char entity_pool_str7443[sizeof("triangleright")]; - char entity_pool_str7445[sizeof("DiacriticalGrave")]; - char entity_pool_str7446[sizeof("boxuL")]; - char entity_pool_str7447[sizeof("cong")]; - char entity_pool_str7451[sizeof("telrec")]; - char entity_pool_str7454[sizeof("comma")]; - char entity_pool_str7460[sizeof("Subset")]; - char entity_pool_str7475[sizeof("NotSucceedsSlantEqual")]; - char entity_pool_str7476[sizeof("gtreqless")]; - char entity_pool_str7477[sizeof("Atilde")]; - char entity_pool_str7484[sizeof("curarr")]; - char entity_pool_str7491[sizeof("cudarrr")]; - char entity_pool_str7495[sizeof("cudarrl")]; - char entity_pool_str7503[sizeof("subseteq")]; - char entity_pool_str7504[sizeof("subseteqq")]; - char entity_pool_str7505[sizeof("rightsquigarrow")]; - char entity_pool_str7520[sizeof("cupcap")]; - char entity_pool_str7521[sizeof("subsetneq")]; - char entity_pool_str7532[sizeof("aogon")]; - char entity_pool_str7533[sizeof("notinvc")]; - char entity_pool_str7534[sizeof("rightthreetimes")]; - char entity_pool_str7552[sizeof("yacute")]; - char entity_pool_str7563[sizeof("nLeftarrow")]; - char entity_pool_str7581[sizeof("ocy")]; - char entity_pool_str7582[sizeof("cemptyv")]; - char entity_pool_str7595[sizeof("Ecy")]; - char entity_pool_str7598[sizeof("cupcup")]; - char entity_pool_str7604[sizeof("trianglerighteq")]; - char entity_pool_str7615[sizeof("LeftRightArrow")]; - char entity_pool_str7618[sizeof("succ")]; - char entity_pool_str7631[sizeof("DownArrowUpArrow")]; - char entity_pool_str7641[sizeof("OElig")]; - char entity_pool_str7648[sizeof("chcy")]; - char entity_pool_str7649[sizeof("gtreqqless")]; - char entity_pool_str7655[sizeof("angle")]; - char entity_pool_str7662[sizeof("acE")]; - char entity_pool_str7668[sizeof("rmoustache")]; - char entity_pool_str7670[sizeof("lmoustache")]; - char entity_pool_str7674[sizeof("NegativeVeryThinSpace")]; - char entity_pool_str7677[sizeof("napprox")]; - char entity_pool_str7686[sizeof("Oslash")]; - char entity_pool_str7698[sizeof("subsetneqq")]; - char entity_pool_str7723[sizeof("Aring")]; - char entity_pool_str7724[sizeof("boxuR")]; - char entity_pool_str7730[sizeof("subplus")]; - char entity_pool_str7742[sizeof("xwedge")]; - char entity_pool_str7767[sizeof("boxul")]; - char entity_pool_str7778[sizeof("boxvr")]; - char entity_pool_str7800[sizeof("HumpDownHump")]; - char entity_pool_str7812[sizeof("Icy")]; - char entity_pool_str7828[sizeof("approxeq")]; - char entity_pool_str7841[sizeof("aacute")]; - char entity_pool_str7842[sizeof("apid")]; - char entity_pool_str7859[sizeof("UpDownArrow")]; - char entity_pool_str7861[sizeof("NestedGreaterGreater")]; - char entity_pool_str7863[sizeof("jcy")]; - char entity_pool_str7866[sizeof("gtrsim")]; - char entity_pool_str7876[sizeof("boxv")]; - char entity_pool_str7886[sizeof("ocirc")]; - char entity_pool_str7900[sizeof("Ecirc")]; - char entity_pool_str7987[sizeof("notnivc")]; - char entity_pool_str8006[sizeof("bigtriangleup")]; - char entity_pool_str8032[sizeof("daleth")]; - char entity_pool_str8037[sizeof("Ocy")]; - char entity_pool_str8042[sizeof("Hcirc")]; - char entity_pool_str8043[sizeof("RightVectorBar")]; - char entity_pool_str8044[sizeof("AElig")]; - char entity_pool_str8063[sizeof("FilledVerySmallSquare")]; - char entity_pool_str8084[sizeof("ggg")]; - char entity_pool_str8088[sizeof("Bcy")]; - char entity_pool_str8099[sizeof("Poincareplane")]; - char entity_pool_str8104[sizeof("boxvL")]; - char entity_pool_str8107[sizeof("PartialD")]; - char entity_pool_str8117[sizeof("Icirc")]; - char entity_pool_str8129[sizeof("cularr")]; - char entity_pool_str8135[sizeof("boxh")]; - char entity_pool_str8142[sizeof("andv")]; - char entity_pool_str8144[sizeof("sung")]; - char entity_pool_str8148[sizeof("RightDoubleBracket")]; - char entity_pool_str8168[sizeof("jcirc")]; - char entity_pool_str8174[sizeof("UnderBar")]; - char entity_pool_str8241[sizeof("RightArrow")]; - char entity_pool_str8242[sizeof("circledcirc")]; - char entity_pool_str8243[sizeof("Alpha")]; - char entity_pool_str8251[sizeof("leftharpoonup")]; - char entity_pool_str8258[sizeof("cularrp")]; - char entity_pool_str8260[sizeof("RightArrowLeftArrow")]; - char entity_pool_str8281[sizeof("varsigma")]; - char entity_pool_str8300[sizeof("numero")]; - char entity_pool_str8310[sizeof("ffllig")]; - char entity_pool_str8326[sizeof("LowerLeftArrow")]; - char entity_pool_str8340[sizeof("expectation")]; - char entity_pool_str8342[sizeof("Ocirc")]; - char entity_pool_str8351[sizeof("yacy")]; - char entity_pool_str8375[sizeof("lambda")]; - char entity_pool_str8381[sizeof("NotSucceedsEqual")]; - char entity_pool_str8382[sizeof("boxvR")]; - char entity_pool_str8384[sizeof("bigtriangledown")]; - char entity_pool_str8391[sizeof("ang")]; - char entity_pool_str8404[sizeof("xuplus")]; - char entity_pool_str8424[sizeof("nabla")]; - char entity_pool_str8425[sizeof("boxvl")]; - char entity_pool_str8438[sizeof("Eta")]; - char entity_pool_str8440[sizeof("Acy")]; - char entity_pool_str8474[sizeof("kcy")]; - char entity_pool_str8475[sizeof("gcy")]; - char entity_pool_str8485[sizeof("LeftRightVector")]; - char entity_pool_str8491[sizeof("ccedil")]; - char entity_pool_str8495[sizeof("Backslash")]; - char entity_pool_str8506[sizeof("hslash")]; - char entity_pool_str8515[sizeof("Pcy")]; - char entity_pool_str8521[sizeof("Gcy")]; - char entity_pool_str8534[sizeof("gtquest")]; - char entity_pool_str8572[sizeof("Lambda")]; - char entity_pool_str8627[sizeof("odiv")]; - char entity_pool_str8629[sizeof("leftharpoondown")]; - char entity_pool_str8672[sizeof("longmapsto")]; - char entity_pool_str8677[sizeof("Jukcy")]; - char entity_pool_str8687[sizeof("ldrdhar")]; - char entity_pool_str8700[sizeof("xutri")]; - char entity_pool_str8701[sizeof("nRightarrow")]; - char entity_pool_str8725[sizeof("ExponentialE")]; - char entity_pool_str8735[sizeof("nrightarrow")]; - char entity_pool_str8745[sizeof("Acirc")]; - char entity_pool_str8746[sizeof("NoBreak")]; - char entity_pool_str8780[sizeof("gcirc")]; - char entity_pool_str8784[sizeof("ange")]; - char entity_pool_str8785[sizeof("curarrm")]; - char entity_pool_str8791[sizeof("SHCHcy")]; - char entity_pool_str8796[sizeof("yuml")]; - char entity_pool_str8800[sizeof("subnE")]; - char entity_pool_str8803[sizeof("DDotrahd")]; - char entity_pool_str8810[sizeof("RuleDelayed")]; - char entity_pool_str8826[sizeof("Gcirc")]; - char entity_pool_str8843[sizeof("Jsercy")]; - char entity_pool_str8879[sizeof("gtcc")]; - char entity_pool_str8922[sizeof("iukcy")]; - char entity_pool_str8956[sizeof("updownarrow")]; - char entity_pool_str8962[sizeof("curlyvee")]; - char entity_pool_str8972[sizeof("ffilig")]; - char entity_pool_str8992[sizeof("yicy")]; - char entity_pool_str9015[sizeof("divonx")]; - char entity_pool_str9026[sizeof("gtrapprox")]; - char entity_pool_str9069[sizeof("subdot")]; - char entity_pool_str9079[sizeof("leftrightarrows")]; - char entity_pool_str9085[sizeof("auml")]; - char entity_pool_str9088[sizeof("Updownarrow")]; - char entity_pool_str9090[sizeof("rightleftarrows")]; - char entity_pool_str9151[sizeof("DownRightVector")]; - char entity_pool_str9154[sizeof("DownRightVectorBar")]; - char entity_pool_str9162[sizeof("hcirc")]; - char entity_pool_str9186[sizeof("Rrightarrow")]; - char entity_pool_str9217[sizeof("longrightarrow")]; - char entity_pool_str9239[sizeof("cupdot")]; - char entity_pool_str9249[sizeof("ac")]; - char entity_pool_str9268[sizeof("hookrightarrow")]; - char entity_pool_str9271[sizeof("NegativeThickSpace")]; - char entity_pool_str9275[sizeof("subE")]; - char entity_pool_str9307[sizeof("twoheadrightarrow")]; - char entity_pool_str9320[sizeof("downharpoonright")]; - char entity_pool_str9321[sizeof("downharpoonleft")]; - char entity_pool_str9326[sizeof("aelig")]; - char entity_pool_str9330[sizeof("rdldhar")]; - char entity_pool_str9349[sizeof("curlywedge")]; - char entity_pool_str9351[sizeof("hybull")]; - char entity_pool_str9360[sizeof("sube")]; - char entity_pool_str9414[sizeof("Longrightarrow")]; - char entity_pool_str9484[sizeof("Cedilla")]; - char entity_pool_str9505[sizeof("notinva")]; - char entity_pool_str9506[sizeof("SucceedsEqual")]; - char entity_pool_str9554[sizeof("leftrightarrow")]; - char entity_pool_str9580[sizeof("straightepsilon")]; - char entity_pool_str9627[sizeof("amalg")]; - char entity_pool_str9741[sizeof("atilde")]; - char entity_pool_str9747[sizeof("RightCeiling")]; - char entity_pool_str9751[sizeof("Leftrightarrow")]; - char entity_pool_str9767[sizeof("subsim")]; - char entity_pool_str9788[sizeof("VerticalLine")]; - char entity_pool_str9801[sizeof("RightUpVector")]; - char entity_pool_str9804[sizeof("RightUpVectorBar")]; - char entity_pool_str9829[sizeof("RightDownVector")]; - char entity_pool_str9832[sizeof("RightDownVectorBar")]; - char entity_pool_str9836[sizeof("alefsym")]; - char entity_pool_str9852[sizeof("circlearrowright")]; - char entity_pool_str9853[sizeof("circlearrowleft")]; - char entity_pool_str9904[sizeof("Iukcy")]; - char entity_pool_str9936[sizeof("otimesas")]; - char entity_pool_str9944[sizeof("intercal")]; - char entity_pool_str9952[sizeof("thickapprox")]; - char entity_pool_str9955[sizeof("jukcy")]; - char entity_pool_str9959[sizeof("notniva")]; - char entity_pool_str9963[sizeof("precnapprox")]; - char entity_pool_str9983[sizeof("cuvee")]; - char entity_pool_str9987[sizeof("aring")]; - char entity_pool_str10023[sizeof("ccirc")]; - char entity_pool_str10029[sizeof("rightarrow")]; - char entity_pool_str10061[sizeof("Integral")]; - char entity_pool_str10062[sizeof("xcirc")]; - char entity_pool_str10121[sizeof("jsercy")]; - char entity_pool_str10206[sizeof("checkmark")]; - char entity_pool_str10208[sizeof("VerticalTilde")]; - char entity_pool_str10219[sizeof("boxvH")]; - char entity_pool_str10240[sizeof("NotRightTriangleBar")]; - char entity_pool_str10244[sizeof("NotRightTriangleEqual")]; - char entity_pool_str10245[sizeof("NotRightTriangle")]; - char entity_pool_str10278[sizeof("LeftVectorBar")]; - char entity_pool_str10357[sizeof("boxvh")]; - char entity_pool_str10395[sizeof("boxbox")]; - char entity_pool_str10415[sizeof("ycy")]; - char entity_pool_str10428[sizeof("subedot")]; - char entity_pool_str10445[sizeof("SOFTcy")]; - char entity_pool_str10505[sizeof("Rightarrow")]; - char entity_pool_str10507[sizeof("alpha")]; - char entity_pool_str10528[sizeof("shchcy")]; - char entity_pool_str10584[sizeof("softcy")]; - char entity_pool_str10704[sizeof("acy")]; - char entity_pool_str10720[sizeof("ycirc")]; - char entity_pool_str10791[sizeof("bigcirc")]; - char entity_pool_str10808[sizeof("ImaginaryI")]; - char entity_pool_str10847[sizeof("approx")]; - char entity_pool_str10851[sizeof("SupersetEqual")]; - char entity_pool_str10879[sizeof("vzigzag")]; - char entity_pool_str10888[sizeof("cuesc")]; - char entity_pool_str10947[sizeof("UnderParenthesis")]; - char entity_pool_str11009[sizeof("acirc")]; - char entity_pool_str11029[sizeof("succapprox")]; - char entity_pool_str11047[sizeof("mcomma")]; - char entity_pool_str11146[sizeof("angmsdae")]; - char entity_pool_str11165[sizeof("angmsdab")]; - char entity_pool_str11282[sizeof("angmsdaf")]; - char entity_pool_str11366[sizeof("angsph")]; - char entity_pool_str11527[sizeof("luruhar")]; - char entity_pool_str11565[sizeof("angmsdad")]; - char entity_pool_str11664[sizeof("twoheadleftarrow")]; - char entity_pool_str11720[sizeof("cylcty")]; - char entity_pool_str11791[sizeof("straightphi")]; - char entity_pool_str11840[sizeof("multimap")]; - char entity_pool_str11918[sizeof("RightArrowBar")]; - char entity_pool_str12012[sizeof("ldrushar")]; - char entity_pool_str12103[sizeof("LeftAngleBracket")]; - char entity_pool_str12170[sizeof("ruluhar")]; - char entity_pool_str12202[sizeof("curlyeqprec")]; - char entity_pool_str12206[sizeof("yucy")]; - char entity_pool_str12288[sizeof("lurdshar")]; - char entity_pool_str12413[sizeof("hardcy")]; - char entity_pool_str12461[sizeof("rightharpoondown")]; - char entity_pool_str12497[sizeof("rightharpoonup")]; - char entity_pool_str12502[sizeof("HARDcy")]; - char entity_pool_str12651[sizeof("SubsetEqual")]; - char entity_pool_str12809[sizeof("digamma")]; - char entity_pool_str12892[sizeof("udblac")]; - char entity_pool_str12985[sizeof("SuchThat")]; - char entity_pool_str12991[sizeof("cuwed")]; - char entity_pool_str13024[sizeof("Udblac")]; - char entity_pool_str13061[sizeof("angmsdag")]; - char entity_pool_str13443[sizeof("angmsdah")]; - char entity_pool_str13643[sizeof("VerticalBar")]; - char entity_pool_str13659[sizeof("VerticalSeparator")]; - char entity_pool_str13709[sizeof("rightarrowtail")]; - char entity_pool_str13908[sizeof("odblac")]; - char entity_pool_str13945[sizeof("succnapprox")]; - char entity_pool_str14304[sizeof("angmsdac")]; - char entity_pool_str14364[sizeof("Odblac")]; - char entity_pool_str14620[sizeof("cupbrcap")]; - char entity_pool_str15290[sizeof("angmsdaa")]; - char entity_pool_str15360[sizeof("curlyeqsucc")]; - char entity_pool_str15729[sizeof("curvearrowleft")]; - char entity_pool_str16000[sizeof("curvearrowright")]; - }; -static const struct entity_pool_t entity_pool_contents = - { - "rarr", - "larr", - "lat", - "uarr", - "npr", - "rarrtl", - "larrtl", - "roarr", - "loarr", - "not", - "rpar", - "bot", - "lpar", - "spar", - "ll", - "uharr", - "epar", - "el", - "rotimes", - "lotimes", - "par", - "nharr", - "npar", - "tprime", - "els", - "eparsl", - "ensp", - "bprime", - "lnap", - "blk14", - "blk12", - "blk34", - "nparsl", - "nldr", - "rlarr", - "npart", - "llarr", - "nlt", - "slarr", - "nparallel", - "Tau", - "varr", - "squ", - "nlarr", - "tau", - "lne", - "rrarr", - "lrarr", - "srarr", - "rharul", - "lharul", - "erarr", - "pr", - "rharu", - "lharu", - "Uarr", - "nGt", - "bne", - "nrarr", - "swarr", - "rarrap", - "upuparrows", - "Darr", - "rbarr", - "Dot", - "lbarr", - "nwarr", - "smt", - "emsp14", - "rarrpl", - "larrpl", - "phmmat", - "emsp13", - "LT", - "Larr", - "rbrkslu", - "lbrkslu", - "napos", - "nle", - "rHar", - "lHar", - "qprime", - "lap", - "nbsp", - "uHar", - "top", - "Vbar", - "Ll", - "prap", - "emsp", - "nap", - "looparrowleft", - "le", - "sharp", - "ee", - "les", - "in", - "prop", - "topbot", - "int", - "ne", - "nprcue", - "pre", - "epsi", - "upsi", - "there4", - "rbrke", - "searr", - "lbrke", - "blacktriangle", - "lneq", - "lneqq", - "plus", - "nles", - "nedot", - "blacktriangleleft", - "blacktriangleright", - "nearr", - "blacktriangledown", - "nless", - "emacr", - "vprop", - "umacr", - "smeparsl", - "Map", - "plusdu", - "Not", - "Verbar", - "perp", - "fltns", - "plusmn", - "nleq", - "nleqq", - "frac34", - "frac14", - "verbar", - "frac12", - "frac35", - "frac15", - "frac45", - "frac25", - "frac13", - "frac16", - "prurel", - "frac23", - "frac38", - "frac18", - "frac56", - "frac58", - "frac78", - "leq", - "darr", - "Upsi", - "dot", - "phone", - "Cap", - "blacksquare", - "rnmid", - "leqq", - "intcal", - "dharr", - "rhard", - "lhard", - "pluse", - "Umacr", - "Vee", - "Rarr", - "Cross", - "rsqb", - "lsqb", - "Rarrtl", - "esdot", - "vee", - "nbumpe", - "llcorner", - "fpartint", - "squf", - "plankv", - "eqvparsl", - "ulcorner", - "wp", - "lozf", - "COPY", - "ulcorn", - "veebar", - "part", - "square", - "nbump", - "bernou", - "wr", - "rBarr", - "lrcorner", - "lBarr", - "bnot", - "semi", - "urcorner", - "NotSubset", - "ropf", - "Qopf", - "lopf", - "sopf", - "urcorn", - "Topf", - "Zopf", - "eopf", - "ropar", - "uopf", - "lopar", - "topf", - "Xopf", - "nopf", - "bopf", - "epsiv", - "fnof", - "imacr", - "Jopf", - "nhpar", - "Wopf", - "Sqrt", - "nsub", - "napid", - "NotSuperset", - "brvbar", - "sol", - "easter", - "popf", - "dHar", - "Vopf", - "nsupset", - "nsup", - "vBar", - "nsubset", - "thkap", - "nis", - "profsurf", - "solb", - "lnsim", - "solbar", - "Square", - "vopf", - "uharl", - "ulcrop", - "eqsim", - "equiv", - "ell", - "smashp", - "mp", - "Kopf", - "simrarr", - "flat", - "Mopf", - "Sopf", - "mldr", - "rlm", - "iprod", - "lparlt", - "fopf", - "Uopf", - "varsubsetneq", - "varsubsetneqq", - "urcrop", - "LessLess", - "Re", - "NotNestedLessLess", - "Dopf", - "forkv", - "nsqsube", - "nsupe", - "nsube", - "qopf", - "rlhar", - "lrm", - "nlsim", - "pound", - "varsupsetneq", - "varsupsetneqq", - "bnequiv", - "Lopf", - "nsqsupe", - "rarrlp", - "wedbar", - "larrlp", - "Yopf", - "NotReverseElement", - "Copf", - "lrhar", - "parsl", - "uml", - "marker", - "nsupseteq", - "nsubseteq", - "squarf", - "Vert", - "SquareSupersetEqual", - "prsim", - "SquareSubsetEqual", - "SquareSuperset", - "SquareSubset", - "nvap", - "iopf", - "pm", - "vert", - "thetav", - "loz", - "map", - "lesseqqgtr", - "rscr", - "Qscr", - "lscr", - "sscr", - "Tscr", - "Zscr", - "escr", - "uscr", - "tscr", - "imof", - "Coproduct", - "Xscr", - "Xi", - "nscr", - "ni", - "bscr", - "Nopf", - "Jscr", - "preceq", - "nvrArr", - "backprime", - "Wscr", - "varphi", - "nsmid", - "dlcorn", - "pscr", - "pi", - "Vscr", - "nesim", - "simne", - "nsupseteqq", - "nsubseteqq", - "drcorn", - "rbrace", - "vscr", - "lbrace", - "dopf", - "frasl", - "LessTilde", - "Kscr", - "pluscir", - "Mscr", - "Sscr", - "rbrksld", - "lbrksld", - "RBarr", - "sqcaps", - "rArr", - "bNot", - "lArr", - "fscr", - "Uscr", - "uArr", - "Ropf", - "wopf", - "Dscr", - "opar", - "seswar", - "Del", - "rAarr", - "rho", - "lAarr", - "preccurlyeq", - "qscr", - "macr", - "notin", - "equivDD", - "sqcap", - "nspar", - "olt", - "ratio", - "Lscr", - "dharl", - "dlcrop", - "DoubleDot", - "dotplus", - "or", - "Yscr", - "Fopf", - "Cscr", - "olarr", - "nrarrw", - "lvertneqq", - "eqslantgtr", - "thorn", - "eqslantless", - "incare", - "vArr", - "rppolint", - "drcrop", - "parallel", - "orarr", - "ssmile", - "DoubleLeftTee", - "erDot", - "diams", - "ssetmn", - "oS", - "iscr", - "ii", - "rect", - "nsccue", - "sect", - "mlcp", - "oror", - "DoubleContourIntegral", - "equals", - "Hat", - "sstarf", - "mstpos", - "die", - "measuredangle", - "forall", - "notinvb", - "mopf", - "niv", - "vBarv", - "Nscr", - "period", - "becaus", - "between", - "Int", - "because", - "piv", - "rfr", - "Qfr", - "lfr", - "sfr", - "nleftrightarrow", - "Tfr", - "Zfr", - "efr", - "sim", - "ufr", - "roplus", - "tfr", - "loplus", - "Xfr", - "real", - "nfr", - "bfr", - "NotHumpEqual", - "Jfr", - "dscr", - "Wfr", - "blacklozenge", - "zopf", - "reals", - "NotCupCap", - "simplus", - "ForAll", - "pfr", - "omacr", - "Vfr", - "Emacr", - "Rscr", - "wscr", - "ShortUpArrow", - "setmn", - "vfr", - "Kfr", - "operp", - "Mfr", - "Sfr", - "nltrie", - "Fscr", - "ffr", - "Ufr", - "shortmid", - "nvsim", - "Dfr", - "lessdot", - "profline", - "qfr", - "dArr", - "nrtrie", - "ShortRightArrow", - "Therefore", - "DD", - "therefore", - "Lfr", - "target", - "Element", - "Yfr", - "ClockwiseContourIntegral", - "olcir", - "Cfr", - "female", - "nsucceq", - "oast", - "percnt", - "ordf", - "ord", - "Rho", - "mscr", - "nvrtrie", - "lnE", - "nhArr", - "Or", - "divide", - "ifr", - "elinters", - "bsol", - "nvlArr", - "Imacr", - "backsimeq", - "twixt", - "olcross", - "rarrsim", - "DoubleDownArrow", - "larrsim", - "emptyset", - "oopf", - "exist", - "llhard", - "excl", - "Eopf", - "nlArr", - "thinsp", - "NotSubsetEqual", - "phi", - "DoubleLeftArrow", - "topcir", - "div", - "Nfr", - "nlE", - "zscr", - "lrhard", - "lltri", - "nrArr", - "NotSupersetEqual", - "swArr", - "ThickSpace", - "ultri", - "notnivb", - "prime", - "primes", - "ohm", - "CircleTimes", - "nltri", - "siml", - "nwArr", - "varpi", - "orv", - "setminus", - "lrtri", - "permil", - "mid", - "urtri", - "dfr", - "mho", - "prE", - "vsupne", - "nrtri", - "vsubne", - "eDot", - "lesges", - "backepsilon", - "ratail", - "latail", - "UpEquilibrium", - "epsilon", - "upsilon", - "midast", - "Hopf", - "vltri", - "Rfr", - "Wedge", - "wfr", - "barwed", - "malt", - "Chi", - "emptyv", - "notni", - "LessGreater", - "diam", - "vrtri", - "CircleMinus", - "Omacr", - "seArr", - "Ffr", - "precneqq", - "Diamond", - "ordm", - "neArr", - "Iopf", - "CircleDot", - "prnap", - "dotminus", - "nshortmid", - "bottom", - "pointint", - "SquareUnion", - "jopf", - "Upsilon", - "Colone", - "nvlt", - "NestedLessLess", - "Colon", - "bsolhsub", - "DoubleLeftRightArrow", - "plussim", - "image", - "egs", - "oscr", - "swnwar", - "zeetrf", - "maltese", - "mfr", - "rarrfs", - "Escr", - "larrfs", - "mnplus", - "ngt", - "ngtr", - "gl", - "diamondsuit", - "GT", - "lesssim", - "dsol", - "upharpoonleft", - "SquareIntersection", - "lsime", - "nLt", - "NotLess", - "gnap", - "scap", - "mapstoleft", - "NotLessLess", - "rfloor", - "lfloor", - "nsime", - "bsime", - "NotLessEqual", - "NotLessTilde", - "ncap", - "NotLessGreater", - "precsim", - "looparrowright", - "Pr", - "rcub", - "mapstoup", - "lcub", - "zfr", - "uparrow", - "gne", - "sce", - "Im", - "rcaron", - "lcaron", - "Oopf", - "scaron", - "backsim", - "Tcaron", - "Zcaron", - "ecaron", - "Bernoullis", - "nge", - "tcaron", - "fork", - "Hscr", - "ncaron", - "elsdot", - "tbrk", - "triplus", - "diamond", - "ncup", - "bbrk", - "frown", - "bkarow", - "spades", - "psi", - "Bopf", - "dollar", - "disin", - "spadesuit", - "NotTilde", - "doublebarwedge", - "gap", - "bbrktbrk", - "swarrow", - "bepsi", - "Iscr", - "NotTildeFullEqual", - "eqcolon", - "tint", - "intprod", - "nsupE", - "nwarrow", - "nsubE", - "nges", - "Uparrow", - "ge", - "OpenCurlyDoubleQuote", - "smallsetminus", - "Scaron", - "nvltrie", - "ges", - "blank", - "QUOT", - "block", - "trade", - "jscr", - "wedge", - "Amacr", - "Equal", - "Dcaron", - "DotDot", - "gneq", - "varpropto", - "gneqq", - "Proportional", - "isins", - "eDDot", - "isin", - "TripleDot", - "Fouriertrf", - "Proportion", - "ngeq", - "Lcaron", - "ngeqq", - "lE", - "Ccaron", - "bsemi", - "propto", - "lesdot", - "Conint", - "And", - "searrow", - "orslope", - "harr", - "late", - "CenterDot", - "ofr", - "nearrow", - "qint", - "lates", - "kappav", - "horbar", - "Efr", - "hoarr", - "npre", - "inodot", - "udarr", - "geq", - "nsimeq", - "geqq", - "efDot", - "rpargt", - "Oscr", - "plusdo", - "lagran", - "thicksim", - "precnsim", - "Ncaron", - "napE", - "iiint", - "Bscr", - "mapstodown", - "varrho", - "isinsv", - "nvHarr", - "NotLeftTriangleBar", - "equest", - "NotLeftTriangleEqual", - "NotLeftTriangle", - "Aopf", - "hbar", - "vangrt", - "Hfr", - "range", - "smte", - "lsim", - "npolint", - "dcaron", - "esim", - "Union", - "smtes", - "kopf", - "gopf", - "nsim", - "bsim", - "SmallCircle", - "NotDoubleVerticalBar", - "NotNestedGreaterGreater", - "EqualTilde", - "notindot", - "Rcaron", - "Popf", - "Gopf", - "Ifr", - "wedgeq", - "prod", - "osol", - "DoubleUpArrow", - "Congruent", - "gnsim", - "scsim", - "jfr", - "upsih", - "nLl", - "DoubleUpDownArrow", - "ngsim", - "hearts", - "lesseqgtr", - "nesear", - "Exists", - "smile", - "uwangle", - "heartsuit", - "HorizontalLine", - "GreaterLess", - "rsaquo", - "lsaquo", - "realine", - "Dashv", - "simdot", - "GreaterEqual", - "GreaterTilde", - "GreaterEqualLess", - "GreaterGreater", - "rceil", - "lceil", - "lessgtr", - "oline", - "thksim", - "InvisibleTimes", - "race", - "iquest", - "imagline", - "UpTee", - "midcir", - "ofcir", - "ddarr", - "rangd", - "langd", - "Equilibrium", - "parsim", - "Vdashl", - "Ofr", - "Because", - "rAtail", - "lAtail", - "ominus", - "Ascr", - "Epsilon", - "ShortLeftArrow", - "isinv", - "micro", - "zcaron", - "kscr", - "gscr", - "Bfr", - "gel", - "hercon", - "triminus", - "egrave", - "sdot", - "ugrave", - "Zdot", - "edot", - "NotTildeTilde", - "tdot", - "Pscr", - "Pi", - "Gscr", - "plustwo", - "NotElement", - "PlusMinus", - "hopf", - "gammad", - "mDDot", - "divideontimes", - "doteq", - "varepsilon", - "Precedes", - "Gammad", - "dashv", - "NotCongruent", - "ubreve", - "ogt", - "RoundImplies", - "PrecedesSlantEqual", - "sime", - "Ugrave", - "dbkarow", - "sdote", - "veeeq", - "mapsto", - "times", - "rangle", - "langle", - "leftarrowtail", - "hamilt", - "udhar", - "nisd", - "rfisht", - "lfisht", - "harrcir", - "OpenCurlyQuote", - "ufisht", - "NotHumpDownHump", - "LeftTee", - "rsh", - "lsh", - "gvertneqq", - "timesb", - "scpolint", - "Cdot", - "dwangle", - "Ubreve", - "LeftUpVector", - "LeftUpVectorBar", - "Ecaron", - "homtht", - "igrave", - "npreceq", - "ecolon", - "dd", - "simeq", - "notinE", - "bigoplus", - "Afr", - "leftarrow", - "oint", - "Tab", - "ogon", - "lt", - "nLeftrightarrow", - "rarrb", - "larrb", - "hscr", - "LeftUpDownVector", - "kfr", - "gfr", - "UpArrowBar", - "nsce", - "ltdot", - "gesl", - "xodot", - "star", - "lowbar", - "xharr", - "ecir", - "utdot", - "natur", - "Lsh", - "infin", - "comp", - "sigmav", - "xotime", - "Pfr", - "Gfr", - "bigcap", - "simlE", - "iiiint", - "barwedge", - "Barwed", - "xlarr", - "LessEqualGreater", - "crarr", - "isindot", - "commat", - "middot", - "lesdotor", - "sigmaf", - "rarrbfs", - "larrbfs", - "xrarr", - "bigcup", - "clubs", - "hArr", - "rtrie", - "ltrie", - "imped", - "eogon", - "rx", - "ltrPar", - "Star", - "uogon", - "Tilde", - "half", - "tilde", - "Leftarrow", - "gesles", - "cap", - "strns", - "Lt", - "prnE", - "sqsupe", - "sqsupset", - "tridot", - "order", - "caps", - "cross", - "dfisht", - "xmap", - "sqsup", - "rtri", - "ltri", - "it", - "rmoust", - "lmoust", - "gnE", - "lgE", - "scE", - "utri", - "vellip", - "ETH", - "lmidot", - "Uogon", - "CounterClockwiseContourIntegral", - "ngE", - "nwnear", - "lesg", - "plusb", - "Rsh", - "copysr", - "infintie", - "imath", - "Esim", - "Phi", - "glE", - "vnsup", - "simgE", - "DoubleLongLeftArrow", - "DoubleLongLeftRightArrow", - "nvgt", - "Mellintrf", - "Prime", - "iinfin", - "ReverseElement", - "EmptySmallSquare", - "radic", - "hfr", - "zdot", - "male", - "rarrc", - "prec", - "scnap", - "DifferentialD", - "models", - "ltcir", - "iogon", - "capcap", - "iff", - "ddotseq", - "CirclePlus", - "rthree", - "lthree", - "PrecedesTilde", - "dtdot", - "clubsuit", - "racute", - "lacute", - "trpezium", - "sacute", - "Zacute", - "eacute", - "TildeTilde", - "Uarrocir", - "uacute", - "lowast", - "nacute", - "NotPrecedes", - "Lmidot", - "UpArrow", - "rarrw", - "DownTee", - "FilledSmallSquare", - "capcup", - "GreaterFullEqual", - "nvle", - "trie", - "omicron", - "DoubleRightTee", - "Cconint", - "rsquor", - "lsquor", - "zigrarr", - "copf", - "ContourIntegral", - "hairsp", - "sqsupseteq", - "csub", - "upharpoonright", - "DownBreve", - "ShortDownArrow", - "xopf", - "Sacute", - "vsupnE", - "cir", - "plusacir", - "csup", - "vsubnE", - "Uacute", - "isinE", - "gEl", - "sqcups", - "smid", - "lg", - "DoubleLongRightArrow", - "NotPrecedesSlantEqual", - "eg", - "AMP", - "nmid", - "timesd", - "DownLeftVector", - "zwnj", - "Lacute", - "DownLeftVectorBar", - "ograve", - "Yacute", - "sqcup", - "odot", - "Cacute", - "nu", - "tritime", - "Egrave", - "eplus", - "backcong", - "uplus", - "Edot", - "csupe", - "simg", - "UpperRightArrow", - "csube", - "dtri", - "prnsim", - "boxUr", - "uuarr", - "DownLeftTeeVector", - "gsime", - "bigotimes", - "Dagger", - "Intersection", - "iacute", - "prcue", - "egsdot", - "Implies", - "VDash", - "bump", - "Mu", - "vDash", - "lvnE", - "LeftTeeArrow", - "Nacute", - "UnderBrace", - "Psi", - "rhov", - "lescc", - "sup1", - "sup2", - "sup3", - "bigodot", - "Downarrow", - "xsqcup", - "barvee", - "NegativeMediumSpace", - "bumpe", - "cscr", - "nsc", - "sup", - "cedil", - "boxVr", - "origof", - "zwj", - "Igrave", - "Idot", - "xscr", - "xi", - "nGtv", - "boxHu", - "THORN", - "Racute", - "rarrhk", - "larrhk", - "rtriltri", - "boxV", - "dagger", - "Omicron", - "DoubleVerticalBar", - "nexists", - "Nu", - "nexist", - "gE", - "ap", - "Sup", - "doteqdot", - "eng", - "caron", - "boxHU", - "gesdot", - "ReverseEquilibrium", - "boxUL", - "supmult", - "pitchfork", - "numsp", - "rang", - "lang", - "ocir", - "rationals", - "coprod", - "ltlarr", - "breve", - "nang", - "swarhk", - "raquo", - "laquo", - "supsub", - "Cup", - "ape", - "quest", - "nwarhk", - "supset", - "downarrow", - "duarr", - "apos", - "Ograve", - "shortparallel", - "nsucc", - "LongLeftArrow", - "lesdoto", - "supne", - "nGg", - "raemptyv", - "supsup", - "laemptyv", - "topfork", - "Eogon", - "risingdotseq", - "bumpeq", - "lstrok", - "Tstrok", - "gsim", - "bemptyv", - "zacute", - "gsiml", - "tstrok", - "roang", - "boxVL", - "loang", - "nleqslant", - "sbquo", - "searhk", - "lnapprox", - "Supset", - "boxHd", - "varkappa", - "circeq", - "yopf", - "UnionPlus", - "Lang", - "nearhk", - "shcy", - "cfr", - "Kappa", - "ljcy", - "MediumSpace", - "supseteq", - "supseteqq", - "reg", - "amacr", - "leg", - "weierp", - "TScy", - "supsetneq", - "njcy", - "xfr", - "mu", - "nvinfin", - "boxUR", - "xoplus", - "leftleftarrows", - "sum", - "beth", - "complement", - "num", - "amp", - "boxUl", - "NotGreater", - "boxplus", - "jmath", - "sfrown", - "Dstrok", - "and", - "NotGreaterGreater", - "NotGreaterSlantEqual", - "NotGreaterLess", - "quot", - "NotGreaterFullEqual", - "hyphen", - "planck", - "TildeEqual", - "tosa", - "Lstrok", - "shy", - "xnis", - "Iogon", - "DZcy", - "ohbar", - "cirscir", - "sext", - "para", - "ast", - "questeq", - "Sum", - "DScy", - "ENG", - "ZHcy", - "longleftarrow", - "dash", - "DownTeeArrow", - "supsetneqq", - "profalar", - "oacute", - "boxVR", - "Eacute", - "supplus", - "hookleftarrow", - "CloseCurlyQuote", - "trisb", - "dotsquare", - "rtimes", - "ltimes", - "toea", - "Agrave", - "Assign", - "Rang", - "iocy", - "NotPrecedesEqual", - "aopf", - "chi", - "quaternions", - "boxVl", - "NotGreaterEqual", - "xhArr", - "orderof", - "rsquo", - "lsquo", - "yscr", - "gdot", - "NotSquareSubsetEqual", - "KHcy", - "bsolb", - "NotSquareSubset", - "SHcy", - "YIcy", - "cwint", - "Theta", - "theta", - "xlArr", - "NotSquareSupersetEqual", - "demptyv", - "triangle", - "Gdot", - "NotSquareSuperset", - "Abreve", - "dstrok", - "pertenk", - "rbrack", - "lbrack", - "odsold", - "omid", - "xrArr", - "triangleleft", - "NotGreaterTilde", - "colone", - "Longleftarrow", - "iota", - "colon", - "Zeta", - "gbreve", - "CHcy", - "YUcy", - "REG", - "szlig", - "dzcy", - "beta", - "euro", - "LeftArrow", - "CapitalDifferentialD", - "ring", - "Laplacetrf", - "djcy", - "oplus", - "integers", - "Gbreve", - "ubrcy", - "euml", - "deg", - "uuml", - "Iacute", - "succeq", - "KJcy", - "CupCap", - "tscy", - "cent", - "DJcy", - "TildeFullEqual", - "triangleq", - "duhar", - "LeftDoubleBracket", - "LJcy", - "iecy", - "trianglelefteq", - "nequiv", - "nshortparallel", - "ndash", - "bowtie", - "fjlig", - "Ubrcy", - "vartheta", - "Uuml", - "vartriangleright", - "vartriangleleft", - "ascr", - "succcurlyeq", - "cwconint", - "sc", - "fllig", - "circledast", - "Vdash", - "nVdash", - "suplarr", - "robrk", - "lobrk", - "vdash", - "Yuml", - "gt", - "ccaps", - "Succeeds", - "Oacute", - "TRADE", - "NJcy", - "gtdot", - "yfr", - "compfn", - "Gt", - "scnE", - "ijlig", - "circledS", - "yen", - "thetasym", - "iuml", - "SucceedsSlantEqual", - "boxH", - "mumap", - "rightrightarrows", - "coloneq", - "Sc", - "glj", - "iexcl", - "ccups", - "xcap", - "zhcy", - "boxHD", - "leqslant", - "UpperLeftArrow", - "dblac", - "puncsp", - "ccaron", - "rbbrk", - "lbbrk", - "Aogon", - "LeftTriangleBar", - "gesdotol", - "LeftTriangleEqual", - "LeftTriangle", - "conint", - "drbkarow", - "rtrif", - "ltrif", - "ReverseUpEquilibrium", - "LeftCeiling", - "utrif", - "xcup", - "fallingdotseq", - "rcedil", - "lcedil", - "scedil", - "Tcedil", - "starf", - "boxminus", - "tcedil", - "ZeroWidthSpace", - "ncedil", - "phiv", - "ic", - "capdot", - "dscy", - "check", - "ovbar", - "ntriangleleft", - "RightTee", - "nvge", - "leftrightsquigarrow", - "lozenge", - "RightTriangleBar", - "RightTeeVector", - "RightTriangleEqual", - "RightTriangle", - "Kcedil", - "Scedil", - "cirfnint", - "empty", - "afr", - "DiacriticalTilde", - "LeftDownVector", - "LeftDownVectorBar", - "lEg", - "ApplyFunction", - "bumpE", - "Lcedil", - "caret", - "Barv", - "Ccedil", - "circledR", - "LeftDownTeeVector", - "tshcy", - "DotEqual", - "centerdot", - "ntrianglelefteq", - "minus", - "gimel", - "Aacute", - "gtcir", - "gtrarr", - "bull", - "DownArrow", - "rdquor", - "ldquor", - "intlarhk", - "utilde", - "gacute", - "ntilde", - "af", - "Hstrok", - "exponentiale", - "minusb", - "RightUpTeeVector", - "UpTeeArrow", - "zeta", - "DiacriticalDot", - "DiacriticalDoubleAcute", - "nleftarrow", - "hkswarow", - "iiota", - "apacir", - "Ncedil", - "capand", - "mdash", - "filig", - "scnsim", - "realpart", - "leftthreetimes", - "asymp", - "hellip", - "dtrif", - "NotExists", - "sccue", - "YAcy", - "Utilde", - "NotEqual", - "ThinSpace", - "apE", - "bullet", - "CloseCurlyDoubleQuote", - "Delta", - "gg", - "otimes", - "wreath", - "Rcedil", - "eth", - "supnE", - "awint", - "Breve", - "Gg", - "HumpEqual", - "Lleftarrow", - "boxdr", - "succneqq", - "uring", - "LessSlantEqual", - "nvdash", - "Hacek", - "itilde", - "Iota", - "IOcy", - "boxDr", - "SucceedsTilde", - "LeftFloor", - "Vvdash", - "triangledown", - "LongLeftRightArrow", - "RightFloor", - "DownRightTeeVector", - "quatint", - "Ntilde", - "Bumpeq", - "gvnE", - "boxhu", - "gtlPar", - "nprec", - "ouml", - "gescc", - "Euml", - "Uring", - "UnderBracket", - "nLtv", - "LeftArrowBar", - "ncongdot", - "asympeq", - "minusdu", - "delta", - "harrw", - "andslope", - "cdot", - "Cayleys", - "boxhU", - "succsim", - "cirE", - "sdotb", - "odash", - "cirmid", - "suphsub", - "supdsub", - "supdot", - "awconint", - "TSHcy", - "grave", - "lsimg", - "UpArrowDownArrow", - "LeftVector", - "DoubleRightArrow", - "NegativeThinSpace", - "lhblk", - "cire", - "nVDash", - "uhblk", - "imagpart", - "RightUpDownVector", - "boxdL", - "gla", - "Iuml", - "oelig", - "NotLessSlantEqual", - "boxDL", - "gamma", - "Otimes", - "longleftrightarrow", - "Gamma", - "bigwedge", - "boxhd", - "supE", - "LeftUpTeeVector", - "gesdoto", - "kappa", - "ngeqslant", - "gtrless", - "fflig", - "bigsqcup", - "kgreen", - "supe", - "boxtimes", - "gnapprox", - "downdownarrows", - "biguplus", - "khcy", - "ddagger", - "Ouml", - "Beta", - "minusd", - "succnsim", - "ctdot", - "kjcy", - "gjcy", - "ncong", - "xvee", - "bcong", - "sqsube", - "boxdR", - "Longleftrightarrow", - "sqsub", - "DownLeftRightVector", - "sqsubset", - "NotVerticalBar", - "NotEqualTilde", - "boxdl", - "boxDR", - "andand", - "RightVector", - "IJlig", - "NotTildeEqual", - "angzarr", - "angrt", - "acd", - "andd", - "nrarrc", - "VeryThinSpace", - "Superset", - "boxDl", - "vnsub", - "ccupssm", - "varnothing", - "rcy", - "lcy", - "scy", - "Tcy", - "Zcy", - "ecy", - "rdsh", - "ldsh", - "ucy", - "boxVH", - "tcy", - "ncy", - "bcy", - "ntgl", - "Jcy", - "congdot", - "angst", - "RightDownTeeVector", - "OverParenthesis", - "ltquest", - "pcy", - "otilde", - "rdquo", - "ldquo", - "Vcy", - "capbrcup", - "bdquo", - "DownArrowBar", - "vcy", - "angrtvb", - "Kcy", - "Mcy", - "Scy", - "NewLine", - "fcy", - "Ucy", - "boxVh", - "Dcy", - "hstrok", - "Lcy", - "Ycy", - "supsim", - "NonBreakingSpace", - "OverBar", - "sqsubseteq", - "GJcy", - "OverBrace", - "eqcirc", - "OverBracket", - "Auml", - "acute", - "icy", - "Itilde", - "HilbertSpace", - "omega", - "cacute", - "scirc", - "ecirc", - "ucirc", - "GreaterSlantEqual", - "Jcirc", - "nvDash", - "Wcirc", - "Ncy", - "RightTeeArrow", - "LessFullEqual", - "ltcc", - "aleph", - "dcy", - "Scirc", - "lessapprox", - "IEcy", - "LowerRightArrow", - "Ucirc", - "agrave", - "MinusPlus", - "bigvee", - "Rcy", - "suphsol", - "EmptyVerySmallSquare", - "boxhD", - "precapprox", - "angrtvbd", - "Ycirc", - "sub", - "Otilde", - "Ccirc", - "Fcy", - "complexes", - "subrarr", - "InvisibleComma", - "boxur", - "abreve", - "ntlg", - "icirc", - "xdtri", - "circ", - "gtrdot", - "geqslant", - "ntriangleright", - "cuepr", - "Sub", - "mcy", - "timesbar", - "hksearow", - "sigma", - "cupor", - "oslash", - "dzigrarr", - "leftrightharpoons", - "rightleftharpoons", - "kcedil", - "submult", - "curren", - "LeftTeeVector", - "bigstar", - "cup", - "LongRightArrow", - "Gcedil", - "PrecedesEqual", - "zcy", - "planckh", - "Omega", - "subsub", - "rdca", - "cups", - "ldca", - "subset", - "NotSucceeds", - "LeftArrowRightArrow", - "wcirc", - "RightAngleBracket", - "ntrianglerighteq", - "Sigma", - "NotSucceedsTilde", - "DiacriticalAcute", - "subne", - "Product", - "circleddash", - "subsup", - "copy", - "eta", - "angmsd", - "natural", - "supedot", - "naturals", - "triangleright", - "DiacriticalGrave", - "boxuL", - "cong", - "telrec", - "comma", - "Subset", - "NotSucceedsSlantEqual", - "gtreqless", - "Atilde", - "curarr", - "cudarrr", - "cudarrl", - "subseteq", - "subseteqq", - "rightsquigarrow", - "cupcap", - "subsetneq", - "aogon", - "notinvc", - "rightthreetimes", - "yacute", - "nLeftarrow", - "ocy", - "cemptyv", - "Ecy", - "cupcup", - "trianglerighteq", - "LeftRightArrow", - "succ", - "DownArrowUpArrow", - "OElig", - "chcy", - "gtreqqless", - "angle", - "acE", - "rmoustache", - "lmoustache", - "NegativeVeryThinSpace", - "napprox", - "Oslash", - "subsetneqq", - "Aring", - "boxuR", - "subplus", - "xwedge", - "boxul", - "boxvr", - "HumpDownHump", - "Icy", - "approxeq", - "aacute", - "apid", - "UpDownArrow", - "NestedGreaterGreater", - "jcy", - "gtrsim", - "boxv", - "ocirc", - "Ecirc", - "notnivc", - "bigtriangleup", - "daleth", - "Ocy", - "Hcirc", - "RightVectorBar", - "AElig", - "FilledVerySmallSquare", - "ggg", - "Bcy", - "Poincareplane", - "boxvL", - "PartialD", - "Icirc", - "cularr", - "boxh", - "andv", - "sung", - "RightDoubleBracket", - "jcirc", - "UnderBar", - "RightArrow", - "circledcirc", - "Alpha", - "leftharpoonup", - "cularrp", - "RightArrowLeftArrow", - "varsigma", - "numero", - "ffllig", - "LowerLeftArrow", - "expectation", - "Ocirc", - "yacy", - "lambda", - "NotSucceedsEqual", - "boxvR", - "bigtriangledown", - "ang", - "xuplus", - "nabla", - "boxvl", - "Eta", - "Acy", - "kcy", - "gcy", - "LeftRightVector", - "ccedil", - "Backslash", - "hslash", - "Pcy", - "Gcy", - "gtquest", - "Lambda", - "odiv", - "leftharpoondown", - "longmapsto", - "Jukcy", - "ldrdhar", - "xutri", - "nRightarrow", - "ExponentialE", - "nrightarrow", - "Acirc", - "NoBreak", - "gcirc", - "ange", - "curarrm", - "SHCHcy", - "yuml", - "subnE", - "DDotrahd", - "RuleDelayed", - "Gcirc", - "Jsercy", - "gtcc", - "iukcy", - "updownarrow", - "curlyvee", - "ffilig", - "yicy", - "divonx", - "gtrapprox", - "subdot", - "leftrightarrows", - "auml", - "Updownarrow", - "rightleftarrows", - "DownRightVector", - "DownRightVectorBar", - "hcirc", - "Rrightarrow", - "longrightarrow", - "cupdot", - "ac", - "hookrightarrow", - "NegativeThickSpace", - "subE", - "twoheadrightarrow", - "downharpoonright", - "downharpoonleft", - "aelig", - "rdldhar", - "curlywedge", - "hybull", - "sube", - "Longrightarrow", - "Cedilla", - "notinva", - "SucceedsEqual", - "leftrightarrow", - "straightepsilon", - "amalg", - "atilde", - "RightCeiling", - "Leftrightarrow", - "subsim", - "VerticalLine", - "RightUpVector", - "RightUpVectorBar", - "RightDownVector", - "RightDownVectorBar", - "alefsym", - "circlearrowright", - "circlearrowleft", - "Iukcy", - "otimesas", - "intercal", - "thickapprox", - "jukcy", - "notniva", - "precnapprox", - "cuvee", - "aring", - "ccirc", - "rightarrow", - "Integral", - "xcirc", - "jsercy", - "checkmark", - "VerticalTilde", - "boxvH", - "NotRightTriangleBar", - "NotRightTriangleEqual", - "NotRightTriangle", - "LeftVectorBar", - "boxvh", - "boxbox", - "ycy", - "subedot", - "SOFTcy", - "Rightarrow", - "alpha", - "shchcy", - "softcy", - "acy", - "ycirc", - "bigcirc", - "ImaginaryI", - "approx", - "SupersetEqual", - "vzigzag", - "cuesc", - "UnderParenthesis", - "acirc", - "succapprox", - "mcomma", - "angmsdae", - "angmsdab", - "angmsdaf", - "angsph", - "luruhar", - "angmsdad", - "twoheadleftarrow", - "cylcty", - "straightphi", - "multimap", - "RightArrowBar", - "ldrushar", - "LeftAngleBracket", - "ruluhar", - "curlyeqprec", - "yucy", - "lurdshar", - "hardcy", - "rightharpoondown", - "rightharpoonup", - "HARDcy", - "SubsetEqual", - "digamma", - "udblac", - "SuchThat", - "cuwed", - "Udblac", - "angmsdag", - "angmsdah", - "VerticalBar", - "VerticalSeparator", - "rightarrowtail", - "odblac", - "succnapprox", - "angmsdac", - "Odblac", - "cupbrcap", - "angmsdaa", - "curlyeqsucc", - "curvearrowleft", - "curvearrowright" - }; -#define entity_pool ((const char *) &entity_pool_contents) -const struct html_ent * -find_entity (register const char *str, register unsigned int len) -{ - static const unsigned char lengthtable[] = - { - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 4, - 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 0, 0, 3, - 0, 0, 0, 0, 0, 0, 6, 0, 6, 5, 0, 5, 3, 4, - 3, 4, 0, 4, 0, 2, 5, 4, 0, 0, 0, 2, 0, 7, - 0, 7, 3, 0, 5, 0, 0, 0, 0, 0, 4, 0, 0, 6, - 0, 0, 0, 3, 6, 0, 4, 0, 0, 0, 0, 6, 4, 5, - 0, 0, 0, 5, 0, 5, 0, 6, 0, 0, 0, 4, 5, 5, - 5, 3, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, - 0, 0, 0, 3, 4, 0, 3, 0, 0, 5, 0, 0, 3, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 5, 0, - 5, 0, 5, 6, 0, 6, 5, 0, 2, 5, 0, 5, 0, 0, - 0, 0, 4, 0, 0, 0, 3, 0, 3, 5, 0, 0, 5, 0, - 0, 0, 6, 0, 10, 0, 4, 0, 0, 5, 3, 5, 0, 0, - 0, 0, 0, 0, 0, 5, 0, 3, 0, 0, 0, 0, 6, 6, - 0, 6, 0, 0, 0, 0, 6, 0, 6, 0, 2, 0, 0, 0, - 4, 7, 0, 7, 0, 5, 0, 0, 0, 0, 0, 0, 0, 3, - 0, 4, 0, 4, 6, 0, 3, 0, 0, 0, 0, 0, 0, 4, - 4, 3, 0, 4, 0, 0, 2, 0, 0, 0, 4, 0, 4, 0, - 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 13, 0, 2, 0, 0, 0, 5, 0, 2, 0, 0, 0, 0, 0, - 0, 0, 3, 2, 4, 0, 6, 0, 0, 3, 0, 2, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 6, 0, 3, 4, 0, 0, 0, - 0, 4, 6, 0, 0, 0, 5, 5, 5, 0, 13, 0, 0, 4, - 0, 0, 5, 0, 4, 4, 5, 17, 18, 0, 0, 0, 0, 0, - 5, 0, 0, 17, 0, 0, 0, 0, 0, 5, 5, 0, 0, 0, - 5, 5, 0, 0, 0, 8, 0, 0, 0, 3, 0, 0, 6, 3, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 5, 6, 0, 0, - 0, 4, 0, 0, 5, 0, 6, 6, 6, 6, 6, 6, 6, 0, - 0, 6, 0, 6, 0, 6, 6, 6, 6, 6, 6, 0, 0, 0, - 6, 0, 6, 3, 4, 0, 0, 4, 3, 5, 0, 0, 3, 0, - 0, 0, 11, 5, 0, 0, 0, 4, 0, 0, 6, 0, 0, 0, - 5, 0, 0, 0, 5, 0, 5, 0, 0, 0, 0, 0, 0, 0, - 0, 5, 0, 0, 0, 0, 0, 5, 3, 0, 0, 4, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 4, 0, 4, - 0, 0, 0, 0, 0, 0, 6, 0, 0, 5, 0, 0, 0, 0, - 3, 6, 0, 0, 0, 0, 0, 8, 8, 0, 0, 0, 4, 6, - 0, 0, 8, 0, 8, 0, 2, 0, 0, 0, 0, 4, 0, 0, - 0, 4, 0, 6, 0, 0, 0, 0, 6, 0, 4, 0, 0, 0, - 0, 6, 0, 5, 6, 2, 5, 8, 5, 0, 0, 4, 0, 4, - 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 9, 0, 4, 4, - 4, 0, 4, 6, 4, 4, 4, 0, 0, 0, 5, 4, 5, 4, - 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 4, 5, 4, - 5, 0, 0, 4, 0, 5, 0, 0, 0, 4, 0, 0, 0, 0, - 4, 4, 0, 5, 0, 0, 11, 0, 0, 6, 0, 0, 3, 0, - 0, 0, 0, 6, 0, 4, 0, 0, 4, 0, 0, 0, 0, 4, - 0, 0, 0, 0, 7, 4, 4, 0, 7, 0, 0, 0, 0, 0, - 5, 0, 0, 0, 3, 8, 4, 0, 0, 0, 5, 0, 6, 0, - 0, 0, 0, 6, 0, 4, 0, 0, 0, 5, 0, 6, 0, 0, - 0, 5, 5, 0, 0, 3, 6, 2, 0, 0, 4, 0, 0, 7, - 0, 4, 0, 4, 4, 4, 3, 5, 0, 0, 0, 0, 0, 0, - 6, 0, 4, 4, 0, 0, 0, 12, 13, 0, 0, 6, 8, 0, - 2, 0, 0, 17, 0, 0, 0, 4, 0, 5, 0, 7, 0, 5, - 0, 0, 0, 5, 4, 5, 0, 0, 3, 0, 0, 0, 5, 0, - 5, 12, 13, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 4, 0, 0, 0, 7, 0, 0, 6, 6, 6, 0, 4, 0, - 0, 0, 0, 17, 0, 0, 4, 5, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 5, 3, 6, 9, 0, 0, - 0, 9, 0, 0, 0, 0, 0, 6, 4, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 19, 0, 5, 0, 0, 17, 0, 0, - 14, 0, 0, 0, 0, 12, 4, 0, 0, 0, 4, 0, 2, 0, - 4, 0, 6, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 0, - 4, 0, 4, 4, 4, 0, 0, 0, 0, 4, 0, 4, 0, 4, - 9, 0, 0, 4, 2, 0, 0, 4, 2, 4, 4, 0, 0, 0, - 0, 4, 6, 0, 0, 6, 9, 4, 0, 6, 0, 0, 0, 0, - 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 6, 0, 0, - 0, 0, 0, 4, 2, 0, 0, 0, 0, 0, 0, 4, 0, 0, - 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, - 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 10, 6, 0, 0, - 0, 0, 6, 4, 6, 4, 0, 0, 0, 0, 0, 0, 0, 5, - 0, 0, 0, 0, 0, 9, 0, 0, 4, 0, 0, 0, 0, 0, - 7, 4, 4, 7, 0, 7, 5, 0, 0, 6, 4, 4, 4, 0, - 4, 4, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 4, 0, - 0, 0, 4, 0, 0, 4, 4, 6, 0, 0, 0, 3, 5, 3, - 5, 11, 4, 0, 0, 4, 0, 0, 0, 5, 0, 0, 0, 0, - 7, 0, 0, 0, 0, 5, 0, 5, 0, 0, 0, 3, 5, 4, - 0, 0, 0, 5, 0, 6, 9, 7, 2, 0, 4, 0, 0, 4, - 0, 0, 0, 0, 4, 5, 6, 0, 0, 0, 0, 9, 10, 0, - 0, 0, 5, 0, 0, 0, 0, 11, 0, 0, 6, 0, 0, 0, - 0, 0, 0, 4, 8, 6, 0, 0, 0, 0, 0, 8, 0, 0, - 0, 0, 0, 0, 0, 5, 6, 0, 0, 0, 13, 5, 5, 6, - 0, 0, 0, 0, 2, 0, 0, 0, 4, 2, 4, 0, 0, 6, - 4, 0, 4, 0, 0, 0, 4, 0, 21, 0, 0, 0, 6, 0, - 3, 0, 0, 0, 6, 6, 0, 3, 13, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 6, 0, 0, 7, 0, 0, 0, 0, - 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 5, 0, 4, 0, 6, 0, 0, 0, - 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 7, 3, 0, 0, - 0, 0, 0, 0, 0, 7, 3, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, - 3, 15, 3, 3, 3, 0, 0, 0, 3, 3, 6, 3, 6, 0, - 0, 0, 0, 3, 0, 0, 4, 3, 0, 3, 0, 12, 0, 0, - 0, 3, 0, 4, 0, 0, 0, 3, 0, 12, 0, 4, 5, 0, - 9, 0, 0, 7, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 3, 0, 0, 0, 0, 0, 5, 0, 3, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 4, 0, 0, 0, - 4, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, - 0, 5, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 5, - 0, 3, 3, 0, 0, 6, 0, 0, 0, 0, 0, 4, 0, 0, - 3, 3, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 5, 3, 7, 0, 0, 8, 0, 0, 0, 0, - 0, 0, 3, 4, 0, 6, 0, 0, 0, 15, 0, 0, 0, 0, - 0, 0, 0, 9, 0, 0, 0, 2, 0, 0, 0, 0, 9, 3, - 0, 0, 0, 0, 0, 0, 6, 0, 0, 7, 3, 24, 0, 0, - 0, 0, 5, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 6, 7, 4, 0, 0, 0, 0, 0, 0, - 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 3, 3, - 0, 4, 0, 7, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, - 0, 5, 2, 0, 0, 0, 6, 0, 3, 8, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 4, 6, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 5, 0, 9, 5, 7, 0, 0, 0, 0, 0, 0, 0, - 0, 7, 15, 7, 8, 4, 0, 5, 0, 0, 6, 0, 0, 0, - 0, 0, 0, 0, 4, 4, 5, 0, 0, 0, 0, 6, 14, 3, - 15, 0, 6, 0, 0, 0, 3, 0, 3, 3, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 6, 0, 0, 0, - 0, 0, 0, 5, 0, 0, 5, 16, 0, 5, 10, 0, 0, 0, - 5, 7, 0, 5, 0, 0, 6, 0, 3, 0, 0, 11, 5, 0, - 0, 4, 5, 0, 0, 5, 0, 0, 3, 0, 0, 0, 0, 8, - 0, 0, 0, 5, 0, 0, 0, 6, 3, 0, 0, 0, 0, 0, - 5, 0, 0, 3, 3, 3, 0, 0, 0, 6, 0, 0, 5, 6, - 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 6, 0, 0, 11, 0, 6, 0, 6, 0, 0, 13, 0, 0, 7, - 0, 0, 0, 0, 7, 0, 6, 4, 5, 0, 3, 0, 0, 5, - 3, 0, 0, 0, 0, 0, 6, 0, 0, 4, 0, 0, 0, 0, - 3, 6, 5, 0, 0, 0, 0, 11, 0, 4, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, - 0, 11, 0, 5, 5, 0, 0, 0, 0, 0, 0, 3, 0, 0, - 0, 0, 0, 8, 0, 7, 4, 0, 0, 0, 0, 5, 4, 9, - 0, 0, 5, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, - 0, 6, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, - 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 7, 0, 0, 0, - 0, 0, 0, 0, 6, 0, 4, 0, 0, 14, 5, 0, 0, 8, - 0, 0, 0, 20, 7, 0, 0, 0, 0, 0, 0, 0, 0, 5, - 3, 0, 0, 4, 6, 0, 0, 0, 0, 6, 0, 0, 0, 7, - 0, 3, 6, 4, 6, 0, 0, 0, 0, 0, 0, 6, 3, 4, - 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, - 0, 11, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 4, - 0, 0, 0, 0, 0, 0, 0, 13, 18, 5, 0, 3, 0, 7, - 0, 4, 0, 0, 0, 4, 0, 0, 10, 11, 0, 0, 0, 6, - 0, 6, 0, 0, 5, 0, 5, 12, 12, 0, 0, 0, 4, 0, - 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, - 14, 0, 0, 0, 2, 4, 8, 4, 0, 3, 0, 0, 7, 0, - 3, 0, 0, 0, 3, 2, 0, 0, 0, 0, 6, 0, 6, 4, - 6, 7, 6, 6, 6, 0, 10, 0, 0, 0, 3, 6, 0, 4, - 0, 0, 0, 0, 0, 4, 0, 6, 6, 0, 4, 0, 0, 0, - 7, 0, 0, 7, 0, 0, 4, 0, 4, 0, 5, 6, 0, 6, - 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, - 6, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, - 9, 0, 0, 0, 0, 0, 8, 14, 0, 3, 0, 0, 0, 0, - 0, 0, 8, 0, 0, 7, 5, 0, 0, 0, 4, 0, 0, 0, - 17, 7, 0, 0, 4, 0, 0, 7, 0, 5, 0, 0, 7, 5, - 0, 0, 4, 0, 7, 2, 20, 0, 0, 0, 0, 13, 0, 0, - 0, 0, 6, 0, 7, 3, 5, 4, 0, 0, 0, 0, 5, 5, - 0, 0, 0, 0, 0, 4, 5, 0, 0, 0, 0, 0, 0, 0, - 5, 0, 5, 0, 0, 6, 0, 0, 6, 0, 0, 0, 0, 0, - 0, 0, 4, 9, 0, 5, 12, 0, 0, 0, 0, 5, 0, 5, - 4, 0, 0, 0, 9, 0, 0, 0, 10, 10, 0, 0, 4, 6, - 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 2, 6, 0, 0, 0, 0, 0, 5, 0, 0, 0, - 0, 0, 6, 0, 0, 0, 0, 6, 6, 0, 3, 0, 0, 0, - 7, 0, 0, 0, 0, 7, 4, 0, 0, 0, 0, 0, 4, 0, - 9, 0, 0, 3, 0, 0, 0, 7, 0, 4, 0, 0, 5, 6, - 0, 0, 6, 3, 5, 4, 0, 0, 0, 0, 0, 6, 0, 5, - 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 6, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 5, - 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, - 6, 0, 0, 6, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 8, 0, 0, 0, 6, 0, 0, 0, 0, 4, - 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 10, 0, 0, 6, 0, 6, 0, 0, 6, - 0, 0, 18, 0, 6, 0, 20, 15, 0, 0, 4, 4, 0, 0, - 0, 6, 0, 0, 0, 3, 0, 0, 0, 0, 0, 5, 4, 4, - 0, 7, 0, 6, 0, 4, 0, 5, 0, 0, 0, 0, 5, 0, - 0, 0, 4, 4, 0, 0, 0, 0, 4, 0, 4, 0, 11, 0, - 20, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 10, 0, 0, 8, 0, 0, 0, 6, 0, 0, 0, - 0, 4, 0, 0, 0, 0, 0, 4, 0, 0, 3, 0, 0, 6, - 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, - 0, 0, 0, 0, 0, 0, 13, 0, 0, 9, 0, 0, 0, 5, - 0, 0, 0, 5, 0, 3, 0, 0, 0, 0, 0, 0, 0, 5, - 0, 0, 0, 0, 3, 0, 0, 17, 0, 5, 0, 0, 0, 0, - 0, 0, 0, 0, 6, 0, 9, 0, 0, 0, 6, 0, 0, 0, - 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, - 0, 7, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 14, 0, - 0, 11, 0, 6, 0, 6, 0, 7, 5, 0, 0, 0, 6, 12, - 12, 0, 0, 0, 0, 16, 0, 14, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 5, 0, 5, 0, 0, 0, 7, - 0, 0, 5, 0, 0, 0, 0, 0, 0, 6, 0, 14, 0, 0, - 0, 0, 0, 0, 4, 0, 0, 0, 6, 0, 0, 0, 0, 0, - 0, 0, 8, 0, 0, 0, 0, 5, 0, 6, 0, 0, 0, 0, - 0, 0, 0, 0, 5, 0, 0, 5, 0, 0, 0, 0, 0, 0, - 5, 0, 5, 0, 0, 0, 0, 0, 11, 6, 6, 3, 0, 0, - 0, 0, 7, 0, 6, 0, 6, 6, 4, 0, 0, 0, 7, 0, - 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 5, 0, 5, 0, 0, 0, 6, 0, 0, 0, 0, - 4, 4, 0, 0, 0, 0, 3, 3, 6, 0, 0, 0, 0, 0, - 0, 8, 0, 0, 0, 0, 0, 6, 0, 0, 0, 4, 6, 0, - 4, 4, 0, 0, 0, 0, 13, 0, 4, 0, 0, 0, 0, 4, - 2, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 7, 0, - 0, 0, 10, 0, 9, 0, 0, 4, 6, 0, 5, 0, 0, 0, - 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 10, 0, 0, 0, 0, 0, 0, 8, 0, 0, 6, 0, - 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 12, 0, 0, - 6, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 12, 0, - 0, 0, 0, 0, 0, 0, 18, 0, 0, 4, 0, 0, 0, 0, - 0, 0, 0, 0, 6, 0, 7, 0, 0, 0, 0, 5, 0, 5, - 0, 0, 0, 6, 0, 0, 5, 0, 0, 6, 0, 6, 0, 0, - 13, 6, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, - 0, 4, 0, 6, 0, 6, 7, 0, 0, 0, 0, 0, 0, 0, - 14, 0, 6, 15, 0, 0, 7, 0, 3, 0, 3, 0, 0, 0, - 9, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, - 0, 4, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 15, - 0, 0, 0, 6, 0, 0, 6, 0, 0, 0, 0, 6, 0, 0, - 0, 0, 0, 0, 0, 7, 6, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, - 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 3, 9, 4, 0, 3, 0, - 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 2, 15, 0, 0, - 0, 5, 0, 5, 0, 4, 0, 0, 0, 0, 0, 0, 16, 0, - 3, 3, 10, 0, 0, 0, 0, 0, 0, 0, 0, 4, 5, 4, - 5, 4, 0, 0, 6, 0, 5, 4, 0, 5, 5, 3, 5, 0, - 4, 0, 6, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 3, - 0, 0, 0, 0, 0, 3, 0, 0, 6, 0, 5, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 6, 8, 6, 0, 0, 0, 0, 0, 0, 0, 5, 16, 0, - 5, 7, 0, 6, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, - 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 7, 0, 7, 0, 0, 5, 0, 0, - 0, 0, 6, 0, 5, 4, 5, 0, 5, 5, 0, 0, 0, 0, - 5, 2, 6, 4, 0, 5, 0, 0, 5, 0, 4, 0, 0, 0, - 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, - 0, 6, 0, 0, 0, 0, 3, 5, 0, 0, 0, 2, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, - 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 8, 0, 0, 0, 0, 6, 5, 0, 0, 4, - 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, - 0, 4, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 4, 0, 4, 2, 6, 0, 6, 3, 3, 0, 0, - 3, 0, 4, 0, 6, 0, 3, 0, 0, 6, 0, 5, 31, 0, - 0, 0, 0, 0, 0, 0, 3, 6, 0, 0, 0, 0, 0, 0, - 0, 4, 0, 0, 5, 0, 0, 0, 3, 0, 0, 0, 0, 6, - 0, 8, 0, 5, 4, 0, 0, 0, 0, 3, 0, 0, 0, 0, - 0, 0, 0, 3, 0, 0, 0, 0, 0, 5, 0, 0, 5, 0, - 0, 0, 19, 0, 0, 0, 0, 24, 0, 0, 4, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 5, - 0, 0, 0, 6, 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, - 0, 16, 5, 0, 0, 3, 4, 4, 0, 5, 4, 5, 0, 0, - 0, 13, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 5, 5, 0, 0, 0, 0, 0, 0, 6, 0, 3, - 0, 7, 0, 10, 0, 0, 0, 0, 6, 0, 6, 0, 0, 13, - 0, 0, 0, 5, 0, 8, 0, 6, 0, 6, 8, 6, 0, 0, - 6, 6, 0, 10, 0, 8, 6, 6, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 6, 0, 11, 0, 0, 0, 6, 0, 0, 0, - 0, 7, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 7, 0, 0, 0, 17, 6, 0, 0, 0, 0, 0, 16, 0, 0, - 0, 0, 0, 0, 4, 0, 4, 0, 0, 0, 0, 0, 7, 0, - 14, 7, 6, 0, 6, 0, 7, 0, 0, 0, 0, 0, 0, 0, - 4, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 6, 10, 4, 14, 0, 0, 0, 9, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 0, 4, 0, 6, - 0, 0, 0, 0, 0, 0, 0, 6, 3, 8, 4, 6, 6, 0, - 5, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, - 0, 6, 0, 4, 0, 2, 0, 20, 21, 0, 0, 2, 0, 0, - 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, - 0, 0, 0, 0, 0, 6, 0, 0, 14, 4, 6, 17, 0, 0, - 0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 0, 5, 0, 0, - 4, 6, 0, 2, 7, 0, 6, 5, 0, 8, 0, 0, 5, 0, - 4, 0, 0, 0, 5, 0, 4, 15, 5, 0, 4, 6, 0, 0, - 0, 0, 5, 5, 0, 0, 0, 0, 0, 0, 0, 17, 5, 0, - 0, 0, 9, 6, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 6, 0, 5, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 7, 5, 0, - 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, - 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 4, 0, 0, 0, - 0, 12, 0, 0, 0, 6, 0, 0, 0, 0, 10, 3, 0, 0, - 0, 4, 0, 5, 0, 0, 0, 0, 0, 4, 0, 0, 4, 0, - 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 7, 0, 0, - 0, 0, 0, 0, 9, 0, 6, 0, 6, 0, 0, 0, 0, 19, - 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, - 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 3, - 0, 0, 0, 0, 0, 0, 5, 0, 0, 5, 0, 6, 3, 6, - 0, 0, 0, 0, 0, 0, 0, 4, 0, 4, 2, 0, 0, 0, - 4, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 5, 0, 6, 0, 6, 0, 6, 0, 0, - 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 6, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 17, 0, - 0, 7, 0, 0, 2, 6, 2, 0, 0, 0, 2, 0, 0, 0, - 0, 3, 8, 0, 0, 3, 0, 5, 0, 5, 6, 0, 0, 0, - 0, 18, 0, 0, 0, 0, 5, 0, 7, 0, 0, 9, 0, 0, - 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 4, 0, 4, 0, 0, 4, 0, 9, 0, 6, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 5, 0, 4, 0, - 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 5, 0, 5, 6, - 0, 0, 0, 3, 3, 5, 0, 0, 0, 0, 6, 0, 0, 0, - 6, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 4, - 6, 13, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, - 13, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, - 0, 0, 5, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, - 8, 6, 8, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, - 0, 0, 0, 0, 0, 12, 0, 6, 0, 0, 0, 6, 0, 0, - 0, 6, 4, 0, 0, 7, 6, 5, 0, 0, 6, 0, 5, 5, - 5, 0, 0, 0, 9, 0, 0, 0, 0, 0, 5, 0, 6, 8, - 0, 0, 6, 0, 5, 8, 0, 0, 0, 6, 0, 4, 0, 9, - 0, 0, 0, 0, 4, 6, 4, 0, 0, 0, 0, 0, 3, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 4, - 11, 0, 0, 8, 9, 0, 0, 0, 0, 3, 5, 3, 0, 0, - 0, 0, 6, 4, 0, 0, 0, 9, 4, 3, 0, 2, 0, 0, - 0, 0, 0, 7, 5, 0, 0, 0, 0, 6, 0, 0, 0, 0, - 0, 14, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 10, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 0, 0, 0, - 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 10, 7, - 5, 0, 6, 0, 6, 0, 3, 17, 0, 0, 0, 0, 0, 0, - 20, 0, 14, 4, 0, 0, 0, 0, 0, 0, 19, 6, 6, 0, - 10, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 6, 0, - 0, 3, 0, 0, 0, 4, 5, 0, 0, 4, 0, 5, 0, 0, - 0, 0, 0, 0, 7, 0, 4, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 4, 0, 0, 3, 0, 0, 0, 0, - 0, 0, 7, 0, 3, 0, 4, 0, 3, 0, 4, 0, 0, 13, - 0, 4, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, - 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, - 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, - 6, 0, 0, 0, 0, 0, 7, 0, 13, 0, 0, 15, 0, 0, - 5, 9, 0, 0, 0, 6, 0, 6, 0, 0, 4, 6, 0, 0, - 6, 4, 4, 0, 16, 0, 4, 0, 3, 0, 0, 11, 5, 15, - 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 7, 0, 0, 5, 0, 5, 4, 0, 0, 4, 0, - 20, 4, 0, 0, 0, 0, 0, 5, 15, 4, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 4, 0, 0, 0, 5, 0, 0, 5, 0, - 0, 0, 0, 0, 0, 0, 0, 5, 5, 0, 22, 0, 0, 7, - 8, 0, 4, 0, 17, 0, 0, 0, 0, 0, 0, 0, 0, 6, - 0, 0, 6, 7, 0, 0, 0, 0, 6, 0, 6, 0, 0, 0, - 6, 0, 0, 0, 0, 0, 4, 0, 5, 0, 12, 15, 6, 0, - 13, 0, 4, 0, 5, 4, 6, 0, 0, 0, 0, 4, 0, 0, - 4, 3, 5, 0, 0, 0, 0, 0, 0, 4, 0, 4, 0, 0, - 0, 0, 0, 0, 4, 0, 0, 9, 0, 0, 20, 0, 4, 10, - 0, 0, 0, 0, 4, 0, 5, 0, 0, 8, 6, 0, 5, 4, - 0, 0, 3, 0, 4, 0, 0, 6, 6, 0, 4, 0, 0, 0, - 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 4, 0, - 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 0, 9, - 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 17, - 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, - 0, 0, 0, 14, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, - 0, 14, 0, 0, 0, 0, 0, 0, 5, 6, 0, 5, 0, 0, - 0, 0, 0, 0, 5, 0, 8, 0, 0, 0, 4, 0, 0, 0, - 0, 0, 16, 15, 4, 0, 0, 11, 0, 0, 0, 8, 0, 0, - 0, 0, 0, 0, 0, 2, 0, 5, 0, 10, 0, 0, 5, 0, - 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, - 5, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 5, 4, 0, 0, 0, 0, 0, 0, 0, 2, - 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 8, 6, 5, 4, 0, 0, 0, - 0, 5, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 6, 0, - 0, 0, 0, 2, 4, 5, 0, 0, 0, 8, 0, 0, 3, 0, - 8, 0, 0, 4, 18, 0, 0, 0, 0, 4, 5, 0, 0, 0, - 16, 0, 0, 0, 0, 7, 0, 2, 3, 5, 0, 0, 5, 0, - 4, 4, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, - 8, 0, 14, 0, 0, 0, 0, 5, 0, 0, 6, 0, 6, 0, - 5, 0, 5, 0, 5, 15, 0, 0, 8, 17, 12, 0, 0, 0, - 0, 0, 6, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 5, 0, 5, 0, 0, 20, 0, 0, 0, 0, 0, - 11, 0, 5, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 13, - 0, 0, 0, 0, 0, 6, 0, 6, 0, 6, 0, 6, 0, 5, - 8, 0, 0, 0, 0, 0, 6, 14, 0, 0, 0, 0, 0, 0, - 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, - 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 4, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 5, 5, 0, 0, 0, 0, 0, - 0, 13, 0, 0, 0, 0, 0, 8, 4, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 19, 0, 0, 0, 0, 0, 0, 7, - 0, 0, 16, 0, 14, 0, 18, 13, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 5, 0, 0, - 0, 0, 0, 0, 3, 0, 0, 0, 16, 0, 0, 0, 0, 0, - 0, 14, 0, 0, 17, 0, 0, 0, 0, 0, 0, 0, 0, 3, - 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 5, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 5, 0, - 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, - 0, 0, 0, 8, 17, 0, 0, 0, 5, 0, 0, 0, 8, 0, - 0, 0, 0, 0, 0, 0, 9, 0, 15, 0, 5, 0, 5, 0, - 0, 0, 0, 0, 0, 6, 5, 0, 0, 0, 0, 6, 4, 0, - 0, 9, 0, 0, 0, 0, 0, 6, 0, 6, 0, 0, 8, 0, - 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, - 6, 2, 0, 0, 6, 0, 12, 6, 0, 0, 0, 16, 0, 0, - 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, - 0, 0, 14, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 10, 8, 0, 5, 0, 0, 6, - 0, 0, 0, 6, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, - 0, 0, 5, 0, 0, 5, 6, 0, 0, 0, 0, 0, 0, 0, - 0, 8, 0, 0, 0, 14, 5, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 5, 0, 9, 0, - 0, 0, 5, 0, 0, 0, 0, 4, 6, 0, 0, 0, 0, 0, - 0, 8, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, - 3, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 21, 5, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 6, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 6, 0, 6, 0, 0, 0, 0, 0, 3, 5, 0, - 0, 5, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 2, 0, - 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, - 5, 0, 0, 0, 0, 0, 0, 0, 0, 8, 5, 14, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, - 5, 6, 0, 0, 4, 0, 4, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 13, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 6, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 12, 0, 0, 0, 18, 10, 0, 0, 18, 0, 7, 0, 0, - 0, 6, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 4, - 0, 5, 0, 0, 0, 0, 6, 0, 0, 5, 0, 0, 4, 0, - 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 4, 0, - 0, 0, 5, 0, 12, 4, 12, 8, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 5, 0, 5, 0, - 0, 0, 0, 0, 8, 0, 0, 0, 0, 4, 0, 0, 0, 0, - 7, 5, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 4, - 5, 0, 0, 0, 5, 6, 7, 7, 0, 0, 0, 0, 0, 0, - 0, 6, 0, 8, 0, 0, 0, 0, 5, 0, 0, 5, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, - 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 10, 16, 0, 0, 0, 0, 0, 0, 17, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, - 4, 6, 0, 0, 0, 5, 0, 0, 0, 8, 0, 0, 0, 0, - 0, 17, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 5, 0, 0, 0, 0, 17, 0, 5, 0, 0, 0, 0, 5, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 5, 8, 0, 0, 0, 0, 0, 5, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, - 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0, 0, 7, 0, - 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 8, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 4, 0, - 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 14, 0, 0, 0, - 0, 0, 0, 0, 0, 8, 4, 0, 7, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 4, 0, 4, 6, 8, 0, 5, 0, - 0, 4, 4, 0, 5, 4, 5, 0, 0, 0, 0, 0, 0, 6, - 0, 0, 5, 0, 0, 18, 0, 5, 0, 0, 0, 19, 0, 0, - 8, 0, 14, 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 5, 0, 0, 5, 0, 6, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 11, 0, 5, 13, 0, 0, 0, 7, - 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 3, 0, 0, - 4, 0, 6, 13, 0, 8, 0, 5, 0, 0, 0, 5, 0, 0, - 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, - 3, 0, 3, 0, 3, 0, 3, 3, 3, 4, 0, 4, 0, 3, - 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, - 4, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 5, - 0, 18, 0, 0, 15, 7, 0, 3, 0, 0, 6, 5, 0, 5, - 0, 3, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, - 12, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, - 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, - 0, 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 7, - 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 5, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, - 7, 10, 0, 0, 0, 0, 0, 4, 0, 0, 9, 0, 0, 0, - 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 11, 0, 4, 0, 0, 0, 0, 0, 0, 0, 5, 3, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 6, 12, 0, 0, 0, 5, 6, 0, 0, 0, 0, - 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 5, 0, 17, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 5, 0, 0, 0, 0, 6, 5, 0, 0, 0, 3, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 4, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 5, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, - 4, 15, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 6, 0, 9, 6, 0, 0, 0, - 3, 0, 0, 0, 0, 0, 7, 0, 0, 20, 0, 5, 0, 0, - 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 5, 0, 0, - 0, 3, 0, 0, 6, 5, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 3, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 7, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 14, 0, 0, 0, 0, 5, 6, 0, 0, 0, 0, - 0, 4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, - 0, 0, 5, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 6, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 5, 3, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 8, 0, 8, 0, 0, 5, 0, 0, 0, 0, 0, 0, - 5, 0, 0, 0, 0, 0, 6, 8, 0, 0, 17, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 17, 0, 6, 0, 0, 0, 0, - 0, 0, 0, 0, 7, 0, 0, 0, 6, 0, 0, 0, 0, 0, - 0, 0, 0, 13, 0, 0, 0, 0, 7, 0, 0, 3, 14, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 6, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, - 0, 7, 5, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, - 0, 0, 0, 4, 4, 4, 0, 0, 0, 0, 6, 11, 19, 0, - 0, 5, 17, 0, 0, 0, 0, 0, 16, 5, 0, 0, 0, 0, - 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, - 7, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 6, 0, 0, - 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 3, 0, 0, - 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 7, 0, 7, 8, 0, 0, 0, 0, 0, 13, 0, 16, 5, 4, - 0, 0, 0, 6, 0, 0, 5, 0, 0, 0, 0, 0, 6, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, - 9, 6, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, - 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 8, - 9, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 6, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 5, 7, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 3, 7, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 6, 0, 0, 0, - 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, - 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, - 0, 0, 0, 0, 4, 10, 0, 0, 0, 0, 0, 5, 0, 0, - 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 10, 0, 10, 0, - 0, 0, 21, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, - 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 0, 0, 0, - 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 6, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 11, 0, 20, 0, 3, 0, 0, 6, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, - 0, 3, 0, 0, 0, 0, 5, 14, 5, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, 5, 0, - 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, - 0, 4, 0, 0, 0, 0, 0, 0, 4, 0, 4, 0, 0, 0, - 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 8, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 11, 5, 0, 0, - 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 7, 0, - 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 5, 0, - 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 6, 0, 0, 0, 0, 0, 16, 5, 0, 15, 0, - 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 15, 0, 0, 0, 0, 0, 6, 0, 0, 0, 9, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, - 0, 0, 0, 3, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 4, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 5, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 5, 11, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 7, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 5, 0, 0, 0, 4, 7, 0, 0, 0, 0, 0, 6, - 0, 0, 0, 0, 4, 0, 0, 0, 5, 0, 0, 8, 0, 0, - 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, - 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0, 0, 4, - 0, 0, 11, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 18, 0, - 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 14, 0, 0, 18, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 15, 0, 0, - 0, 0, 5, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 6, - 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, - 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, - 0, 0, 0, 12, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 13, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 15, 0, 0, 18, 0, 0, 0, 7, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 15, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, - 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 11, 0, - 0, 5, 0, 0, 0, 7, 0, 0, 0, 11, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, - 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 5, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 9, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 19, 0, 0, 0, 21, 16, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 10, 0, 5, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, - 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 4, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 0, 0, 0, 0, - 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 5, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15 - }; - static const struct html_ent wordlist[] = - { - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1501 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str39), {226, 134, 146, 0}}, - {-1,{0}}, -#line 833 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str41), {226, 134, 144, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 844 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str49), {226, 170, 171, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1903 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str52), {226, 134, 145, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1235 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str55), {226, 138, 128, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1510 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str62), {226, 134, 163, 0}}, - {-1,{0}}, -#line 841 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str64), {226, 134, 162, 0}}, -#line 1601 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str65), {226, 135, 190, 0}}, - {-1,{0}}, -#line 963 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str67), {226, 135, 189, 0}}, -#line 1168 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str68), {194, 172, 0}}, -#line 1609 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str69), {41, 0}}, -#line 146 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str70), {226, 138, 165, 0}}, -#line 989 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str71), {40, 0}}, - {-1,{0}}, -#line 1715 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str73), {226, 136, 165, 0}}, - {-1,{0}}, -#line 945 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str75), {226, 137, 170, 0}}, -#line 1926 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str76), {226, 134, 190, 0}}, -#line 505 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str77), {226, 139, 149, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 482 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str81), {226, 170, 153, 0}}, - {-1,{0}}, -#line 1607 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str83), {226, 168, 181, 0}}, - {-1,{0}}, -#line 981 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str85), {226, 168, 180, 0}}, -#line 1388 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str86), {226, 136, 165, 0}}, - {-1,{0}}, -#line 1132 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str88), {226, 134, 174, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1231 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str94), {226, 136, 166, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1872 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str97), {226, 128, 180, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 486 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str101), {226, 170, 149, 0}}, -#line 506 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str102), {226, 167, 163, 0}}, - {-1,{0}}, -#line 500 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str104), {226, 128, 130, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 193 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str109), {226, 128, 181, 0}}, -#line 955 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str110), {226, 170, 137, 0}}, -#line 137 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str111), {226, 150, 145, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 136 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str115), {226, 150, 146, 0}}, - {-1,{0}}, -#line 138 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str117), {226, 150, 147, 0}}, - {-1,{0}}, -#line 1232 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str119), {226, 171, 189, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1143 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str123), {226, 128, 165, 0}}, -#line 1594 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str124), {226, 135, 132, 0}}, -#line 1233 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str125), {226, 136, 130, 0}}, -#line 944 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str126), {226, 135, 135, 0}}, -#line 1158 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str127), {226, 137, 174, 0}}, -#line 1696 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str128), {226, 134, 144, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1230 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str138), {226, 136, 166, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1825 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str143), {206, 164, 0}}, -#line 1991 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str144), {226, 134, 149, 0}}, - {-1,{0}}, -#line 1738 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str146), {226, 150, 161, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1141 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str149), {226, 134, 154, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1826 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str152), {207, 132, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 957 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str165), {226, 170, 135, 0}}, -#line 1612 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str166), {226, 135, 137, 0}}, - {-1,{0}}, -#line 991 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str168), {226, 135, 134, 0}}, - {-1,{0}}, -#line 1740 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str170), {226, 134, 146, 0}}, -#line 1556 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str171), {226, 165, 172, 0}}, - {-1,{0}}, -#line 940 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str173), {226, 165, 170, 0}}, -#line 525 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str174), {226, 165, 177, 0}}, - {-1,{0}}, -#line 1433 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str176), {226, 137, 186, 0}}, -#line 1555 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str177), {226, 135, 128, 0}}, - {-1,{0}}, -#line 939 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str179), {226, 134, 188, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1904 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str184), {226, 134, 159, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1128 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str188), {226, 137, 171, 0}}, - {-1,{0}}, -#line 140 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str190), {61, 0}}, -#line 1241 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str191), {226, 134, 155, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1818 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str194), {226, 134, 153, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1497 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str198), {226, 165, 181, 0}}, - {-1,{0}}, -#line 1966 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str200), {226, 135, 136, 0}}, - {-1,{0}}, -#line 344 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str202), {226, 134, 161, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1516 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str205), {226, 164, 141, 0}}, -#line 397 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str206), {194, 168, 0}}, -#line 847 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str207), {226, 164, 140, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1306 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str215), {226, 134, 150, 0}}, - {-1,{0}}, -#line 1703 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str217), {226, 170, 170, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 496 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str222), {226, 128, 133, 0}}, -#line 1507 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str223), {226, 165, 133, 0}}, - {-1,{0}}, -#line 839 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str225), {226, 164, 185, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1405 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str230), {226, 132, 179, 0}}, - {-1,{0}}, -#line 495 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str232), {226, 128, 132, 0}}, - {-1,{0}}, -#line 1013 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str234), {60, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 834 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str238), {226, 134, 158, 0}}, -#line 1524 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str239), {226, 166, 144, 0}}, - {-1,{0}}, -#line 854 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str241), {226, 166, 141, 0}}, - {-1,{0}}, -#line 1081 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str243), {197, 137, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1145 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str251), {226, 137, 176, 0}}, - {-1,{0}}, -#line 1553 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str253), {226, 165, 164, 0}}, - {-1,{0}}, -#line 937 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str255), {226, 165, 162, 0}}, -#line 1476 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str256), {226, 129, 151, 0}}, - {-1,{0}}, -#line 828 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str258), {226, 170, 133, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1086 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str265), {194, 160, 0}}, -#line 1924 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str266), {226, 165, 163, 0}}, -#line 1867 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str267), {226, 138, 164, 0}}, - {-1,{0}}, -#line 2003 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str269), {226, 171, 171, 0}}, - {-1,{0}}, {-1,{0}}, -#line 946 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str272), {226, 139, 152, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1431 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str276), {226, 170, 183, 0}}, - {-1,{0}}, -#line 497 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str278), {226, 128, 131, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1078 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str281), {226, 137, 137, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 975 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str294), {226, 134, 171, 0}}, - {-1,{0}}, -#line 869 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str296), {226, 137, 164, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1669 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str300), {226, 153, 175, 0}}, - {-1,{0}}, -#line 473 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str302), {226, 133, 135, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 913 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str310), {226, 169, 189, 0}}, -#line 744 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str311), {226, 136, 136, 0}}, -#line 1460 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str312), {226, 136, 157, 0}}, - {-1,{0}}, -#line 1865 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str314), {226, 140, 182, 0}}, - {-1,{0}}, {-1,{0}}, -#line 749 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str317), {226, 136, 171, 0}}, - {-1,{0}}, -#line 1104 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str319), {226, 137, 160, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1236 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str329), {226, 139, 160, 0}}, - {-1,{0}}, -#line 1446 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str331), {226, 170, 175, 0}}, -#line 508 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str332), {206, 181, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1959 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str337), {207, 133, 0}}, -#line 1838 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str338), {226, 136, 180, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1522 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str342), {226, 166, 140, 0}}, -#line 1657 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str343), {226, 134, 152, 0}}, -#line 852 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str344), {226, 166, 139, 0}}, - {-1,{0}}, -#line 131 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str346), {226, 150, 180, 0}}, - {-1,{0}}, {-1,{0}}, -#line 959 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str349), {226, 170, 135, 0}}, - {-1,{0}}, {-1,{0}}, -#line 960 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str352), {226, 137, 168, 0}}, - {-1,{0}}, -#line 1417 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str354), {43, 0}}, -#line 1153 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str355), {226, 169, 189, 0}}, -#line 1105 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str356), {226, 137, 144, 0}}, -#line 133 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str357), {226, 151, 130, 0}}, -#line 134 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str358), {226, 150, 184, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1101 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str364), {226, 134, 151, 0}}, - {-1,{0}}, {-1,{0}}, -#line 132 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str367), {226, 150, 190, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1154 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str373), {226, 137, 174, 0}}, -#line 489 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str374), {196, 147, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2033 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str378), {226, 136, 157, 0}}, -#line 1933 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str379), {197, 171, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1700 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str383), {226, 167, 164, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1032 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str387), {226, 164, 133, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1419 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str390), {226, 168, 165, 0}}, -#line 1167 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str391), {226, 171, 172, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 2018 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str408), {226, 128, 150, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1398 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str426), {226, 138, 165, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 560 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str430), {226, 150, 177, 0}}, -#line 1422 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str431), {194, 177, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1150 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str435), {226, 137, 176, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1151 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str438), {226, 137, 166, 0}}, - {-1,{0}}, -#line 578 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str440), {194, 190, 0}}, -#line 572 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str441), {194, 188, 0}}, -#line 2017 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str442), {124, 0}}, -#line 570 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str443), {194, 189, 0}}, -#line 579 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str444), {226, 133, 151, 0}}, -#line 573 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str445), {226, 133, 149, 0}}, -#line 581 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str446), {226, 133, 152, 0}}, - {-1,{0}}, {-1,{0}}, -#line 577 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str449), {226, 133, 150, 0}}, - {-1,{0}}, -#line 571 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str451), {226, 133, 147, 0}}, - {-1,{0}}, -#line 574 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str453), {226, 133, 153, 0}}, -#line 1465 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str454), {226, 138, 176, 0}}, -#line 576 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str455), {226, 133, 148, 0}}, -#line 580 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str456), {226, 133, 156, 0}}, -#line 575 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str457), {226, 133, 155, 0}}, -#line 582 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str458), {226, 133, 154, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 583 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str462), {226, 133, 157, 0}}, - {-1,{0}}, -#line 584 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str464), {226, 133, 158, 0}}, -#line 909 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str465), {226, 137, 164, 0}}, -#line 343 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str466), {226, 134, 147, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1960 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str469), {207, 146, 0}}, -#line 398 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str470), {203, 153, 0}}, -#line 1406 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str471), {226, 152, 142, 0}}, - {-1,{0}}, {-1,{0}}, -#line 218 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str474), {226, 139, 146, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 130 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str478), {226, 150, 170, 0}}, -#line 1599 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str479), {226, 171, 174, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 910 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str483), {226, 137, 166, 0}}, - {-1,{0}}, {-1,{0}}, -#line 748 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str486), {226, 138, 186, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 371 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str490), {226, 135, 130, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1554 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str494), {226, 135, 129, 0}}, - {-1,{0}}, -#line 938 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str496), {226, 134, 189, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1420 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str505), {226, 169, 178, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1932 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str511), {197, 170, 0}}, -#line 2014 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str512), {226, 139, 129, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1502 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str515), {226, 134, 160, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 303 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str527), {226, 168, 175, 0}}, - {-1,{0}}, -#line 1619 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str529), {93, 0}}, - {-1,{0}}, -#line 1005 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str531), {91, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1509 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str538), {226, 164, 150, 0}}, - {-1,{0}}, {-1,{0}}, -#line 529 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str541), {226, 137, 144, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2013 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str546), {226, 136, 168, 0}}, -#line 1088 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str547), {226, 137, 143, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 947 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str553), {226, 140, 158, 0}}, -#line 569 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str554), {226, 168, 141, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1739 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str558), {226, 150, 170, 0}}, -#line 1413 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str559), {226, 132, 143, 0}}, - {-1,{0}}, {-1,{0}}, -#line 524 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str562), {226, 167, 165, 0}}, - {-1,{0}}, -#line 1929 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str564), {226, 140, 156, 0}}, - {-1,{0}}, -#line 2054 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str566), {226, 132, 152, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 988 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str571), {226, 167, 171, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 298 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str575), {194, 169, 0}}, - {-1,{0}}, -#line 1928 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str577), {226, 140, 156, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2012 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str582), {226, 138, 187, 0}}, - {-1,{0}}, -#line 1391 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str584), {226, 136, 130, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1729 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str589), {226, 150, 161, 0}}, - {-1,{0}}, -#line 1087 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str591), {226, 137, 142, 0}}, -#line 107 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str592), {226, 132, 172, 0}}, -#line 2055 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str593), {226, 137, 128, 0}}, -#line 1517 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str594), {226, 164, 143, 0}}, -#line 992 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str595), {226, 140, 159, 0}}, -#line 848 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str596), {226, 164, 142, 0}}, - {-1,{0}}, {-1,{0}}, -#line 143 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str599), {226, 140, 144, 0}}, - {-1,{0}}, -#line 1661 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str601), {59, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1968 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str606), {226, 140, 157, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1217 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str612), {226, 138, 130, 0}}, - {-1,{0}}, -#line 1604 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str614), {240, 157, 149, 163}}, -#line 1475 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str615), {226, 132, 154, 0}}, -#line 979 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str616), {240, 157, 149, 157}}, - {-1,{0}}, -#line 1712 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str618), {240, 157, 149, 164}}, -#line 1967 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str619), {226, 140, 157, 0}}, -#line 1868 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str620), {240, 157, 149, 139}}, -#line 2126 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str621), {226, 132, 164, 0}}, -#line 504 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str622), {240, 157, 149, 150}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1603 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str626), {226, 166, 134, 0}}, -#line 1944 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str627), {240, 157, 149, 166}}, -#line 977 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str628), {226, 166, 133, 0}}, -#line 1869 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str629), {240, 157, 149, 165}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2074 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str635), {240, 157, 149, 143}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1165 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str639), {240, 157, 149, 159}}, - {-1,{0}}, -#line 145 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str641), {240, 157, 149, 147}}, -#line 511 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str642), {207, 181, 0}}, -#line 561 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str643), {198, 146, 0}}, -#line 733 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str644), {196, 171, 0}}, - {-1,{0}}, {-1,{0}}, -#line 791 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str647), {240, 157, 149, 129}}, - {-1,{0}}, -#line 1134 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str649), {226, 171, 178, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2052 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str653), {240, 157, 149, 142}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1720 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str658), {226, 136, 154, 0}}, -#line 1262 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str659), {226, 138, 132, 0}}, - {-1,{0}}, -#line 1080 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str661), {226, 137, 139, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1223 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str664), {226, 138, 131, 0}}, - {-1,{0}}, {-1,{0}}, -#line 196 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str667), {194, 166, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1710 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str670), {47, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 460 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str675), {226, 169, 174, 0}}, - {-1,{0}}, -#line 1428 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str677), {240, 157, 149, 161}}, - {-1,{0}}, {-1,{0}}, -#line 369 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str680), {226, 165, 165, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2031 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str685), {240, 157, 149, 141}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1273 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str690), {226, 138, 131, 0}}, -#line 1270 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str691), {226, 138, 133, 0}}, -#line 2002 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str692), {226, 171, 168, 0}}, - {-1,{0}}, -#line 1265 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str694), {226, 138, 130, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1850 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str700), {226, 137, 136, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1136 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str704), {226, 139, 188, 0}}, -#line 1459 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str705), {226, 140, 147, 0}}, -#line 1709 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str706), {226, 167, 132, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 961 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str710), {226, 139, 166, 0}}, - {-1,{0}}, -#line 1708 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str712), {226, 140, 191, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1730 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str717), {226, 150, 161, 0}}, - {-1,{0}}, -#line 2032 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str719), {240, 157, 149, 167}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1925 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str723), {226, 134, 191, 0}}, - {-1,{0}}, -#line 1930 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str725), {226, 140, 143, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 514 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str729), {226, 137, 130, 0}}, -#line 522 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str730), {226, 137, 161, 0}}, - {-1,{0}}, {-1,{0}}, -#line 485 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str733), {226, 132, 147, 0}}, -#line 1699 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str734), {226, 168, 179, 0}}, -#line 1066 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str735), {226, 136, 147, 0}}, - {-1,{0}}, {-1,{0}}, -#line 813 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str738), {240, 157, 149, 130}}, - {-1,{0}}, {-1,{0}}, -#line 1695 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str741), {226, 165, 178, 0}}, - {-1,{0}}, -#line 558 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str743), {226, 153, 173, 0}}, - {-1,{0}}, -#line 1064 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str745), {240, 157, 149, 132}}, -#line 1711 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str746), {240, 157, 149, 138}}, -#line 1061 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str747), {226, 128, 166, 0}}, -#line 1596 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str748), {226, 128, 143, 0}}, -#line 767 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str749), {226, 168, 188, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 990 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str756), {226, 166, 147, 0}}, - {-1,{0}}, -#line 563 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str758), {240, 157, 149, 151}}, -#line 1943 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str759), {240, 157, 149, 140}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1995 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str763), {226, 138, 138, 0}}, -#line 1996 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str764), {226, 171, 139, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1969 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str767), {226, 140, 142, 0}}, -#line 927 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str768), {226, 170, 161, 0}}, - {-1,{0}}, -#line 1542 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str770), {226, 132, 156, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1201 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str773), {226, 170, 161, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 395 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str777), {240, 157, 148, 187}}, - {-1,{0}}, -#line 567 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str779), {226, 171, 153, 0}}, - {-1,{0}}, -#line 1260 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str781), {226, 139, 162, 0}}, - {-1,{0}}, -#line 1272 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str783), {226, 138, 137, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1264 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str787), {226, 138, 136, 0}}, -#line 1474 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str788), {240, 157, 149, 162}}, -#line 1595 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str789), {226, 135, 140, 0}}, - {-1,{0}}, {-1,{0}}, -#line 995 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str792), {226, 128, 142, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1156 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str796), {226, 137, 180, 0}}, - {-1,{0}}, -#line 1430 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str798), {194, 163, 0}}, -#line 1997 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str799), {226, 138, 139, 0}}, -#line 1998 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str800), {226, 171, 140, 0}}, - {-1,{0}}, -#line 141 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str802), {226, 137, 161, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 978 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str813), {240, 157, 149, 131}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1261 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str817), {226, 139, 163, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1506 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str820), {226, 134, 172, 0}}, -#line 2045 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str821), {226, 169, 159, 0}}, -#line 838 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str822), {226, 134, 171, 0}}, - {-1,{0}}, -#line 2100 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str824), {240, 157, 149, 144}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1209 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str829), {226, 136, 140, 0}}, - {-1,{0}}, {-1,{0}}, -#line 294 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str832), {226, 132, 130, 0}}, -#line 993 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str833), {226, 135, 139, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1390 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str848), {226, 171, 189, 0}}, -#line 1934 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str849), {194, 168, 0}}, -#line 1038 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str850), {226, 150, 174, 0}}, -#line 1274 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str851), {226, 138, 137, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1266 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str855), {226, 138, 136, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1737 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str861), {226, 150, 170, 0}}, -#line 2020 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str862), {226, 128, 150, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1735 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str874), {226, 138, 146, 0}}, - {-1,{0}}, -#line 1464 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str876), {226, 137, 190, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1733 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str879), {226, 138, 145, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1734 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str882), {226, 138, 144, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1732 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str887), {226, 138, 143, 0}}, -#line 1289 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str888), {226, 137, 141, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 764 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str892), {240, 157, 149, 154}}, - {-1,{0}}, -#line 1425 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str894), {194, 177, 0}}, - {-1,{0}}, -#line 2019 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str896), {124, 0}}, - {-1,{0}}, -#line 1844 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str898), {207, 145, 0}}, - {-1,{0}}, {-1,{0}}, -#line 986 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str901), {226, 151, 138, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1033 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str905), {226, 134, 166, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 922 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str920), {226, 170, 139, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1615 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str934), {240, 157, 147, 135}}, -#line 1477 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str935), {240, 157, 146, 172}}, -#line 998 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str936), {240, 157, 147, 129}}, - {-1,{0}}, -#line 1742 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str938), {240, 157, 147, 136}}, - {-1,{0}}, -#line 1890 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str940), {240, 157, 146, 175}}, -#line 2127 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str941), {240, 157, 146, 181}}, -#line 527 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str942), {226, 132, 175, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1974 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str947), {240, 157, 147, 138}}, - {-1,{0}}, -#line 1891 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str949), {240, 157, 147, 137}}, - {-1,{0}}, -#line 740 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str951), {226, 138, 183, 0}}, -#line 296 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str952), {226, 136, 144, 0}}, - {-1,{0}}, {-1,{0}}, -#line 2080 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str955), {240, 157, 146, 179}}, -#line 2067 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str956), {206, 158, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1252 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str959), {240, 157, 147, 131}}, -#line 1135 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str960), {226, 136, 139, 0}}, -#line 197 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str961), {240, 157, 146, 183}}, -#line 1166 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str962), {226, 132, 149, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 793 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str967), {240, 157, 146, 165}}, -#line 1442 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str968), {226, 170, 175, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1302 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str971), {226, 164, 131, 0}}, -#line 87 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str972), {226, 128, 181, 0}}, -#line 2057 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str973), {240, 157, 146, 178}}, - {-1,{0}}, -#line 1988 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str975), {207, 149, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1258 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str984), {226, 136, 164, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 392 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str991), {226, 140, 158, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1467 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str997), {240, 157, 147, 133}}, -#line 1408 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str998), {207, 128, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 2035 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1005), {240, 157, 146, 177}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1112 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1011), {226, 137, 130, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1693 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1021), {226, 137, 134, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1275 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1028), {226, 171, 134, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1267 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1032), {226, 171, 133, 0}}, -#line 440 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1033), {226, 140, 159, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1520 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1038), {125, 0}}, -#line 2036 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1039), {240, 157, 147, 139}}, -#line 850 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1040), {123, 0}}, -#line 396 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1041), {240, 157, 149, 149}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 585 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1049), {226, 129, 132, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 930 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1055), {226, 137, 178, 0}}, - {-1,{0}}, {-1,{0}}, -#line 815 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1058), {240, 157, 146, 166}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1416 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1064), {226, 168, 162, 0}}, -#line 1068 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1065), {226, 132, 179, 0}}, -#line 1741 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1066), {240, 157, 146, 174}}, -#line 1523 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1067), {226, 166, 142, 0}}, - {-1,{0}}, -#line 853 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1069), {226, 166, 143, 0}}, -#line 1518 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1070), {226, 164, 144, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1717 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1073), {226, 138, 147, 0}}, -#line 1503 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1074), {226, 135, 146, 0}}, -#line 142 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1075), {226, 171, 173, 0}}, -#line 835 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1076), {226, 135, 144, 0}}, - {-1,{0}}, -#line 587 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1078), {240, 157, 146, 187}}, -#line 1973 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1079), {240, 157, 146, 176}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1905 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1087), {226, 135, 145, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1605 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1090), {226, 132, 157, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2053 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1094), {240, 157, 149, 168}}, - {-1,{0}}, {-1,{0}}, -#line 442 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1097), {240, 157, 146, 159}}, -#line 1351 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1098), {226, 166, 183, 0}}, -#line 1662 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1099), {226, 164, 169, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 362 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1103), {226, 136, 135, 0}}, -#line 1485 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1104), {226, 135, 155, 0}}, -#line 1558 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1105), {207, 129, 0}}, -#line 817 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1106), {226, 135, 154, 0}}, -#line 1437 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1107), {226, 137, 188, 0}}, -#line 1478 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1108), {240, 157, 147, 134}}, - {-1,{0}}, {-1,{0}}, -#line 1028 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1111), {194, 175, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1185 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1115), {226, 136, 137, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 523 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1120), {226, 169, 184, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1716 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1125), {226, 138, 147, 0}}, - {-1,{0}}, -#line 1259 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1127), {226, 136, 166, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1340 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1131), {226, 167, 128, 0}}, -#line 1514 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1132), {226, 136, 182, 0}}, -#line 999 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1133), {226, 132, 146, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 370 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1137), {226, 135, 131, 0}}, - {-1,{0}}, -#line 393 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1139), {226, 140, 141, 0}}, -#line 408 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1140), {194, 168, 0}}, -#line 404 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1141), {226, 136, 148, 0}}, -#line 1358 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1142), {226, 136, 168, 0}}, - {-1,{0}}, -#line 2102 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1144), {240, 157, 146, 180}}, - {-1,{0}}, {-1,{0}}, -#line 562 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1147), {240, 157, 148, 189}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 304 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1152), {240, 157, 146, 158}}, -#line 1336 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1153), {226, 134, 186, 0}}, -#line 1243 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1154), {226, 134, 157, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1026 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1159), {226, 137, 168, 0}}, -#line 515 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1160), {226, 170, 150, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1853 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1164), {195, 190, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 516 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1169), {226, 170, 149, 0}}, - {-1,{0}}, {-1,{0}}, -#line 743 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1172), {226, 132, 133, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1992 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1179), {226, 135, 149, 0}}, -#line 1611 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1180), {226, 168, 146, 0}}, -#line 441 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1181), {226, 140, 140, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1387 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1187), {226, 136, 165, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1356 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1195), {226, 134, 187, 0}}, -#line 1744 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1196), {226, 140, 163, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 412 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1200), {226, 171, 164, 0}}, -#line 526 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1201), {226, 137, 147, 0}}, -#line 381 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1202), {226, 153, 166, 0}}, -#line 1743 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1203), {226, 136, 150, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1368 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1208), {226, 147, 136, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 769 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1212), {240, 157, 146, 190}}, -#line 725 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1213), {226, 133, 136, 0}}, -#line 1543 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1214), {226, 150, 173, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1249 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1217), {226, 139, 161, 0}}, -#line 1660 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1218), {194, 167, 0}}, - {-1,{0}}, -#line 1060 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1220), {226, 171, 155, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1365 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1224), {226, 169, 150, 0}}, - {-1,{0}}, -#line 407 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1226), {226, 136, 175, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 518 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1230), {61, 0}}, - {-1,{0}}, -#line 679 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1232), {94, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1745 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1236), {226, 139, 134, 0}}, -#line 1069 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1237), {226, 136, 190, 0}}, - {-1,{0}}, -#line 382 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1239), {194, 168, 0}}, -#line 1044 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1240), {226, 136, 161, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 564 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1252), {226, 136, 128, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1189 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1255), {226, 139, 183, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1065 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1263), {240, 157, 149, 158}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1138 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1270), {226, 136, 139, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2004 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1280), {226, 171, 169, 0}}, - {-1,{0}}, -#line 1251 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1282), {240, 157, 146, 169}}, - {-1,{0}}, -#line 1396 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1284), {46, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 102 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1292), {226, 136, 181, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 112 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1298), {226, 137, 172, 0}}, -#line 750 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1299), {226, 136, 172, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 103 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1307), {226, 136, 181, 0}}, -#line 1410 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1308), {207, 150, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1551 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1326), {240, 157, 148, 175}}, -#line 1471 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1327), {240, 157, 148, 148}}, -#line 934 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1328), {240, 157, 148, 169}}, - {-1,{0}}, -#line 1667 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1330), {240, 157, 148, 176}}, -#line 1148 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1331), {226, 134, 174, 0}}, -#line 1836 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1332), {240, 157, 148, 151}}, -#line 2121 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1333), {226, 132, 168, 0}}, -#line 476 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1334), {240, 157, 148, 162}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1685 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1338), {226, 136, 188, 0}}, -#line 1921 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1339), {240, 157, 148, 178}}, -#line 1606 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1340), {226, 168, 174, 0}}, -#line 1837 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1341), {240, 157, 148, 177}}, -#line 980 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1342), {226, 168, 173, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2063 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1347), {240, 157, 148, 155}}, - {-1,{0}}, {-1,{0}}, -#line 1538 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1350), {226, 132, 156, 0}}, -#line 1119 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1351), {240, 157, 148, 171}}, - {-1,{0}}, -#line 114 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1353), {240, 157, 148, 159}}, - {-1,{0}}, -#line 1184 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1355), {226, 137, 143, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 788 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1359), {240, 157, 148, 141}}, - {-1,{0}}, -#line 443 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1361), {240, 157, 146, 185}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2050 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1365), {240, 157, 148, 154}}, - {-1,{0}}, -#line 129 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1367), {226, 167, 171, 0}}, - {-1,{0}}, -#line 2125 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1369), {240, 157, 149, 171}}, -#line 1541 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1370), {226, 132, 157, 0}}, - {-1,{0}}, -#line 1170 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1372), {226, 137, 173, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1694 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1375), {226, 168, 164, 0}}, - {-1,{0}}, -#line 565 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1377), {226, 136, 128, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1401 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1389), {240, 157, 148, 173}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1342 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1395), {197, 141, 0}}, - {-1,{0}}, -#line 2026 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1397), {240, 157, 148, 153}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 488 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1409), {196, 146, 0}}, -#line 1616 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1410), {226, 132, 155, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2058 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1414), {240, 157, 147, 140}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1679 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1423), {226, 134, 145, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1664 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1429), {226, 136, 150, 0}}, - {-1,{0}}, -#line 2027 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1431), {240, 157, 148, 179}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 806 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1450), {240, 157, 148, 142}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1354 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1455), {226, 166, 185, 0}}, - {-1,{0}}, -#line 1047 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1457), {240, 157, 148, 144}}, -#line 1666 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1458), {240, 157, 148, 150}}, - {-1,{0}}, {-1,{0}}, -#line 1160 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1461), {226, 139, 172, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 588 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1467), {226, 132, 177, 0}}, - {-1,{0}}, {-1,{0}}, -#line 553 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1470), {240, 157, 148, 163}}, -#line 1920 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1471), {240, 157, 148, 152}}, - {-1,{0}}, -#line 1676 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1473), {226, 136, 163, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1304 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1488), {226, 136, 188, 0}}, -#line 367 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1489), {240, 157, 148, 135}}, -#line 920 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1490), {226, 139, 150, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1458 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1493), {226, 140, 146, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1472 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1500), {240, 157, 148, 174}}, -#line 345 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1501), {226, 135, 147, 0}}, - {-1,{0}}, -#line 1247 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1503), {226, 139, 173, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1678 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1507), {226, 134, 146, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1840 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1515), {226, 136, 180, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 357 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1519), {226, 133, 133, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1839 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1524), {226, 136, 180, 0}}, -#line 933 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1525), {240, 157, 148, 143}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1824 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1532), {226, 140, 150, 0}}, - {-1,{0}}, {-1,{0}}, -#line 483 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1535), {226, 136, 136, 0}}, -#line 2096 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1536), {240, 157, 148, 156}}, -#line 271 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1537), {226, 136, 178, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1337 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1542), {226, 166, 190, 0}}, - {-1,{0}}, -#line 245 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1544), {226, 132, 173, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 548 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1559), {226, 153, 128, 0}}, -#line 1269 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1560), {226, 170, 176, 0}}, -#line 1312 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1561), {226, 138, 155, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1395 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1568), {37, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1362 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1578), {194, 170, 0}}, - {-1,{0}}, -#line 1359 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1580), {226, 169, 157, 0}}, -#line 1557 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1581), {206, 161, 0}}, - {-1,{0}}, -#line 1067 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1583), {240, 157, 147, 130}}, - {-1,{0}}, -#line 1303 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1585), {226, 138, 181, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 958 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1589), {226, 137, 168, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1133 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1597), {226, 135, 142, 0}}, -#line 1357 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1598), {226, 169, 148, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 387 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1602), {195, 183, 0}}, - {-1,{0}}, -#line 721 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1604), {240, 157, 148, 166}}, -#line 484 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1605), {226, 143, 167, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 203 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1615), {92, 0}}, -#line 1298 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1616), {226, 164, 130, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 732 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1626), {196, 170, 0}}, - {-1,{0}}, -#line 89 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1628), {226, 139, 141, 0}}, -#line 1898 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1629), {226, 137, 172, 0}}, -#line 1338 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1630), {226, 166, 187, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1508 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1639), {226, 165, 180, 0}}, -#line 409 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1640), {226, 135, 147, 0}}, -#line 840 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1641), {226, 165, 179, 0}}, -#line 491 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1642), {226, 136, 133, 0}}, -#line 1350 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1643), {240, 157, 149, 160}}, - {-1,{0}}, -#line 540 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1645), {226, 136, 131, 0}}, - {-1,{0}}, {-1,{0}}, -#line 949 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1648), {226, 165, 171, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 539 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1656), {33, 0}}, -#line 503 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1657), {240, 157, 148, 188}}, -#line 1142 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1658), {226, 135, 141, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1849 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1663), {226, 128, 137, 0}}, -#line 1218 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1664), {226, 138, 136, 0}}, -#line 1403 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1665), {207, 134, 0}}, -#line 410 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1666), {226, 135, 144, 0}}, - {-1,{0}}, -#line 1866 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1668), {226, 171, 177, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 386 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1672), {195, 183, 0}}, - {-1,{0}}, -#line 1118 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1674), {240, 157, 148, 145}}, -#line 1144 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1675), {226, 137, 166, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2128 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1689), {240, 157, 147, 143}}, -#line 994 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1690), {226, 165, 173, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 950 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1697), {226, 151, 186, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1242 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1700), {226, 135, 143, 0}}, -#line 1224 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1701), {226, 138, 137, 0}}, - {-1,{0}}, -#line 1819 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1703), {226, 135, 153, 0}}, -#line 1847 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1704), {226, 129, 159, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1931 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1708), {226, 151, 184, 0}}, -#line 1204 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1709), {226, 139, 190, 0}}, - {-1,{0}}, -#line 1449 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1711), {226, 128, 178, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1451 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1714), {226, 132, 153, 0}}, - {-1,{0}}, -#line 1334 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1716), {206, 169, 0}}, - {-1,{0}}, {-1,{0}}, -#line 264 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1719), {226, 138, 151, 0}}, -#line 1159 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1720), {226, 139, 170, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1691 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1723), {226, 170, 157, 0}}, -#line 1307 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1724), {226, 135, 150, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1989 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1727), {207, 150, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1367 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1730), {226, 169, 155, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1663 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1735), {226, 136, 150, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 996 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1739), {226, 138, 191, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1397 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1743), {226, 128, 176, 0}}, -#line 1053 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1744), {226, 136, 163, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1972 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1750), {226, 151, 185, 0}}, - {-1,{0}}, {-1,{0}}, -#line 368 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1753), {240, 157, 148, 161}}, -#line 1049 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1754), {226, 132, 167, 0}}, -#line 1447 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1755), {226, 170, 179, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2040 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1759), {226, 138, 139, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1246 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1762), {226, 139, 171, 0}}, -#line 2038 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1763), {226, 138, 138, 0}}, - {-1,{0}}, -#line 472 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1765), {226, 137, 145, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 918 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1778), {226, 170, 147, 0}}, - {-1,{0}}, {-1,{0}}, -#line 86 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1781), {207, 182, 0}}, - {-1,{0}}, -#line 1512 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1783), {226, 164, 154, 0}}, - {-1,{0}}, -#line 842 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1785), {226, 164, 153, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1953 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1788), {226, 165, 174, 0}}, - {-1,{0}}, {-1,{0}}, -#line 510 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1791), {206, 181, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1963 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1796), {207, 133, 0}}, - {-1,{0}}, -#line 1051 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1798), {42, 0}}, -#line 697 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1799), {226, 132, 141, 0}}, -#line 2028 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1800), {226, 138, 178, 0}}, - {-1,{0}}, -#line 1552 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1802), {226, 132, 156, 0}}, - {-1,{0}}, {-1,{0}}, -#line 2047 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1805), {226, 139, 128, 0}}, -#line 2051 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1806), {240, 157, 148, 180}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 93 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1812), {226, 140, 133, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1030 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1815), {226, 156, 160, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 250 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1820), {206, 167, 0}}, -#line 493 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1821), {226, 136, 133, 0}}, -#line 1202 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1822), {226, 136, 140, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 925 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1827), {226, 137, 182, 0}}, - {-1,{0}}, -#line 377 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1829), {226, 139, 132, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 2034 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1842), {226, 138, 179, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 262 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1849), {226, 138, 150, 0}}, - {-1,{0}}, -#line 1341 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1851), {197, 140, 0}}, -#line 1658 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1852), {226, 135, 152, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 552 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1859), {240, 157, 148, 137}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1444 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1865), {226, 170, 181, 0}}, - {-1,{0}}, -#line 379 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1867), {226, 139, 132, 0}}, -#line 1363 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1868), {194, 186, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1102 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1873), {226, 135, 151, 0}}, -#line 763 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1874), {240, 157, 149, 128}}, -#line 259 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1875), {226, 138, 153, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1452 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1878), {226, 170, 185, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 403 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1884), {226, 136, 184, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1253 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1903), {226, 136, 164, 0}}, - {-1,{0}}, -#line 147 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1905), {226, 138, 165, 0}}, - {-1,{0}}, -#line 1427 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1907), {226, 168, 149, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1736 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1917), {226, 138, 148, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 792 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1925), {240, 157, 149, 155}}, - {-1,{0}}, {-1,{0}}, -#line 1962 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1928), {206, 165, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 278 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1936), {226, 169, 180, 0}}, - {-1,{0}}, -#line 1300 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1938), {60, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1114 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1941), {226, 137, 170, 0}}, -#line 277 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1942), {226, 136, 183, 0}}, - {-1,{0}}, {-1,{0}}, -#line 204 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1945), {226, 159, 136, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 411 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1949), {226, 135, 148, 0}}, -#line 1423 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1950), {226, 168, 166, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 734 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1959), {226, 132, 145, 0}}, -#line 480 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1960), {226, 170, 150, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1370 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1963), {226, 132, 180, 0}}, -#line 1821 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1964), {226, 164, 170, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2116 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1969), {226, 132, 168, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1031 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1973), {226, 156, 160, 0}}, - {-1,{0}}, -#line 1048 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1975), {240, 157, 148, 170}}, -#line 1504 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1976), {226, 164, 158, 0}}, -#line 528 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1977), {226, 132, 176, 0}}, -#line 836 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1978), {226, 164, 157, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1062 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1985), {226, 136, 147, 0}}, -#line 1129 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1986), {226, 137, 175, 0}}, -#line 1130 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1987), {226, 137, 175, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 627 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str1996), {226, 137, 183, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 380 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2003), {226, 153, 166, 0}}, -#line 655 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2004), {62, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 928 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2014), {226, 137, 178, 0}}, -#line 446 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2015), {226, 167, 182, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1954 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2023), {226, 134, 191, 0}}, -#line 1731 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2024), {226, 138, 147, 0}}, -#line 1003 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2025), {226, 170, 141, 0}}, - {-1,{0}}, -#line 1157 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2027), {226, 137, 170, 0}}, - {-1,{0}}, -#line 1194 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2029), {226, 137, 174, 0}}, - {-1,{0}}, -#line 630 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2031), {226, 170, 138, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1634 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2035), {226, 170, 184, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1036 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2038), {226, 134, 164, 0}}, -#line 1197 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2039), {226, 137, 170, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1550 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2043), {226, 140, 139, 0}}, - {-1,{0}}, -#line 932 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2045), {226, 140, 138, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1256 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2048), {226, 137, 132, 0}}, - {-1,{0}}, -#line 201 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2050), {226, 139, 141, 0}}, -#line 1195 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2051), {226, 137, 176, 0}}, -#line 1199 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2052), {226, 137, 180, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1089 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2056), {226, 169, 131, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1196 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2059), {226, 137, 184, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1448 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2070), {226, 137, 190, 0}}, - {-1,{0}}, -#line 976 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2072), {226, 134, 172, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1432 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2076), {226, 170, 187, 0}}, -#line 1530 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2077), {125, 0}}, -#line 1037 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2078), {226, 134, 165, 0}}, -#line 860 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2079), {123, 0}}, - {-1,{0}}, -#line 2120 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2081), {240, 157, 148, 183}}, - {-1,{0}}, {-1,{0}}, -#line 1946 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2084), {226, 134, 145, 0}}, - {-1,{0}}, -#line 632 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2086), {226, 170, 136, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1640 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2090), {226, 170, 176, 0}}, -#line 739 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2091), {226, 132, 145, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1526 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2096), {197, 153, 0}}, - {-1,{0}}, -#line 856 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2098), {196, 190, 0}}, -#line 1349 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2099), {240, 157, 149, 134}}, -#line 1636 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2100), {197, 161, 0}}, -#line 88 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2101), {226, 136, 189, 0}}, -#line 1828 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2102), {197, 164, 0}}, -#line 2110 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2103), {197, 189, 0}}, -#line 462 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2104), {196, 155, 0}}, - {-1,{0}}, -#line 108 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2106), {226, 132, 172, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1121 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2110), {226, 137, 177, 0}}, -#line 1829 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2111), {197, 165, 0}}, - {-1,{0}}, -#line 566 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2113), {226, 139, 148, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 701 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2119), {226, 132, 139, 0}}, - {-1,{0}}, -#line 1091 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2121), {197, 136, 0}}, -#line 487 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2122), {226, 170, 151, 0}}, - {-1,{0}}, -#line 1827 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2124), {226, 142, 180, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1886 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2128), {226, 168, 185, 0}}, - {-1,{0}}, {-1,{0}}, -#line 378 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2131), {226, 139, 132, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1096 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2134), {226, 169, 130, 0}}, - {-1,{0}}, -#line 96 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2136), {226, 142, 181, 0}}, - {-1,{0}}, -#line 586 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2138), {226, 140, 162, 0}}, -#line 128 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2139), {226, 164, 141, 0}}, - {-1,{0}}, -#line 1713 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2141), {226, 153, 160, 0}}, - {-1,{0}}, -#line 1469 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2143), {207, 136, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 144 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2150), {240, 157, 148, 185}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 394 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2156), {36, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 385 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2164), {226, 139, 178, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1714 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2170), {226, 153, 160, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1225 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2176), {226, 137, 129, 0}}, -#line 406 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2177), {226, 140, 134, 0}}, - {-1,{0}}, -#line 594 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2179), {226, 170, 134, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 97 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2186), {226, 142, 182, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1820 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2189), {226, 134, 153, 0}}, -#line 106 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2190), {207, 182, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 770 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2194), {226, 132, 144, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1227 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2198), {226, 137, 135, 0}}, -#line 513 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2199), {226, 137, 149, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1863 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2202), {226, 136, 173, 0}}, - {-1,{0}}, {-1,{0}}, -#line 756 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2205), {226, 168, 188, 0}}, - {-1,{0}}, -#line 1271 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2207), {226, 171, 134, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1308 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2210), {226, 134, 150, 0}}, -#line 1263 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2211), {226, 171, 133, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1125 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2214), {226, 169, 190, 0}}, - {-1,{0}}, -#line 1948 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2216), {226, 135, 145, 0}}, -#line 604 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2217), {226, 137, 165, 0}}, -#line 1352 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2218), {226, 128, 156, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1698 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2223), {226, 136, 150, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1635 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2228), {197, 160, 0}}, - {-1,{0}}, -#line 1301 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2230), {226, 138, 180, 0}}, -#line 612 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2231), {226, 169, 190, 0}}, -#line 135 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2232), {226, 144, 163, 0}}, -#line 1484 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2233), {34, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 139 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2238), {226, 150, 136, 0}}, -#line 1873 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2239), {226, 132, 162, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 794 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2245), {240, 157, 146, 191}}, -#line 2046 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2246), {226, 136, 167, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 29 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2254), {196, 128, 0}}, - {-1,{0}}, -#line 517 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2256), {226, 169, 181, 0}}, - {-1,{0}}, {-1,{0}}, -#line 351 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2259), {196, 142, 0}}, - {-1,{0}}, {-1,{0}}, -#line 399 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2262), {226, 131, 156, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 634 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2270), {226, 170, 136, 0}}, -#line 1990 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2271), {226, 136, 157, 0}}, - {-1,{0}}, -#line 635 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2273), {226, 137, 169, 0}}, -#line 1461 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2274), {226, 136, 157, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 774 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2279), {226, 139, 180, 0}}, - {-1,{0}}, -#line 469 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2281), {226, 169, 183, 0}}, -#line 771 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2282), {226, 136, 136, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1885 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2286), {226, 131, 155, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 568 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2290), {226, 132, 177, 0}}, -#line 1462 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2291), {226, 136, 183, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1122 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2294), {226, 137, 177, 0}}, -#line 855 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2295), {196, 189, 0}}, - {-1,{0}}, -#line 1123 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2297), {226, 137, 167, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 870 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2313), {226, 137, 166, 0}}, -#line 227 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2314), {196, 140, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 199 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2320), {226, 129, 143, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1463 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2326), {226, 136, 157, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 914 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2331), {226, 169, 191, 0}}, -#line 291 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2332), {226, 136, 175, 0}}, - {-1,{0}}, -#line 35 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2334), {226, 169, 147, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1659 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2338), {226, 134, 152, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1366 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2343), {226, 169, 151, 0}}, -#line 676 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2344), {226, 134, 148, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 845 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2350), {226, 170, 173, 0}}, - {-1,{0}}, -#line 243 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2352), {194, 183, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1328 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2355), {240, 157, 148, 172}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1103 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2359), {226, 134, 151, 0}}, - {-1,{0}}, -#line 1473 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2361), {226, 168, 140, 0}}, - {-1,{0}}, {-1,{0}}, -#line 846 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2364), {226, 170, 173, 0}}, -#line 801 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2365), {207, 176, 0}}, - {-1,{0}}, {-1,{0}}, -#line 698 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2368), {226, 128, 149, 0}}, -#line 475 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2369), {240, 157, 148, 136}}, -#line 692 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2370), {226, 135, 191, 0}}, -#line 1239 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2371), {226, 170, 175, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 747 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2377), {196, 177, 0}}, - {-1,{0}}, -#line 1915 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2379), {226, 135, 133, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 608 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2386), {226, 137, 165, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1257 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2391), {226, 137, 132, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 609 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2404), {226, 137, 167, 0}}, - {-1,{0}}, {-1,{0}}, -#line 474 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2407), {226, 137, 146, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1610 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2410), {226, 166, 148, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1369 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2419), {240, 157, 146, 170}}, - {-1,{0}}, {-1,{0}}, -#line 1418 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2422), {226, 136, 148, 0}}, - {-1,{0}}, {-1,{0}}, -#line 821 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2425), {226, 132, 146, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1846 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2429), {226, 136, 188, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1445 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2440), {226, 139, 168, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1090 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2444), {197, 135, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1079 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2449), {226, 169, 176, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 727 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2457), {226, 136, 173, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 198 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2470), {226, 132, 172, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1035 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2483), {226, 134, 167, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1993 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2486), {207, 177, 0}}, - {-1,{0}}, -#line 775 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2488), {226, 139, 179, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1296 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2491), {226, 164, 132, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1191 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2494), {226, 167, 143, 0}}, - {-1,{0}}, -#line 520 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2496), {226, 137, 159, 0}}, - {-1,{0}}, -#line 1193 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2498), {226, 139, 172, 0}}, -#line 1192 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2499), {226, 139, 170, 0}}, - {-1,{0}}, {-1,{0}}, -#line 60 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2502), {240, 157, 148, 184}}, -#line 680 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2503), {226, 132, 143, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1984 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2507), {226, 166, 156, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 688 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2511), {226, 132, 140, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1494 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2517), {226, 166, 165, 0}}, -#line 1704 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2518), {226, 170, 172, 0}}, -#line 1002 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2519), {226, 137, 178, 0}}, - {-1,{0}}, -#line 1234 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2521), {226, 168, 148, 0}}, - {-1,{0}}, -#line 352 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2523), {196, 143, 0}}, - {-1,{0}}, -#line 531 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2525), {226, 137, 130, 0}}, - {-1,{0}}, -#line 1939 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2527), {226, 139, 131, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1705 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2532), {226, 170, 172, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 814 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2536), {240, 157, 149, 156}}, -#line 638 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2537), {240, 157, 149, 152}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1255 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2542), {226, 137, 129, 0}}, - {-1,{0}}, -#line 200 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2544), {226, 136, 189, 0}}, - {-1,{0}}, -#line 1697 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2546), {226, 136, 152, 0}}, - {-1,{0}}, -#line 1171 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2548), {226, 136, 166, 0}}, -#line 1200 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2549), {226, 170, 162, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 519 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2565), {226, 137, 130, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1186 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2568), {226, 139, 181, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1525 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2572), {197, 152, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1429 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2577), {226, 132, 153, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 637 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2583), {240, 157, 148, 190}}, - {-1,{0}}, {-1,{0}}, -#line 722 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2586), {226, 132, 145, 0}}, - {-1,{0}}, {-1,{0}}, -#line 2048 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2589), {226, 137, 153, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1455 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2595), {226, 136, 143, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1373 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2617), {226, 138, 152, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 418 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2624), {226, 135, 145, 0}}, - {-1,{0}}, {-1,{0}}, -#line 289 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2627), {226, 137, 161, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 636 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2631), {226, 139, 167, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1650 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2635), {226, 137, 191, 0}}, - {-1,{0}}, -#line 789 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2637), {240, 157, 148, 167}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1961 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2645), {207, 146, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1155 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2650), {226, 139, 152, 0}}, - {-1,{0}}, {-1,{0}}, -#line 419 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2653), {226, 135, 149, 0}}, - {-1,{0}}, -#line 1127 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2655), {226, 137, 181, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 683 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2664), {226, 153, 165, 0}}, - {-1,{0}}, -#line 921 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2666), {226, 139, 154, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1111 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2670), {226, 164, 168, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 541 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2676), {226, 136, 131, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1702 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2687), {226, 140, 163, 0}}, - {-1,{0}}, -#line 1983 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2689), {226, 166, 167, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 684 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2693), {226, 153, 165, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 699 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2700), {226, 148, 128, 0}}, - {-1,{0}}, {-1,{0}}, -#line 644 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2703), {226, 137, 183, 0}}, - {-1,{0}}, -#line 1614 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2705), {226, 128, 186, 0}}, - {-1,{0}}, -#line 997 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2707), {226, 128, 185, 0}}, - {-1,{0}}, -#line 1539 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2709), {226, 132, 155, 0}}, -#line 347 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2710), {226, 171, 164, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1686 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2714), {226, 169, 170, 0}}, -#line 640 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2715), {226, 137, 165, 0}}, -#line 646 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2716), {226, 137, 179, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 641 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2721), {226, 139, 155, 0}}, - {-1,{0}}, -#line 643 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2723), {226, 170, 162, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1529 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2737), {226, 140, 137, 0}}, - {-1,{0}}, -#line 859 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2739), {226, 140, 136, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 926 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2743), {226, 137, 182, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1339 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2746), {226, 128, 190, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1851 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2753), {226, 136, 188, 0}}, - {-1,{0}}, -#line 758 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2755), {226, 129, 162, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1486 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2762), {226, 136, 189, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 768 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2766), {194, 191, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 736 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2774), {226, 132, 144, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1965 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2779), {226, 138, 165, 0}}, - {-1,{0}}, -#line 1052 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2781), {226, 171, 176, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1326 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2790), {226, 166, 191, 0}}, - {-1,{0}}, {-1,{0}}, -#line 356 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2793), {226, 135, 138, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1493 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2800), {226, 166, 146, 0}}, - {-1,{0}}, -#line 826 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2802), {226, 166, 145, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 521 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2808), {226, 135, 140, 0}}, -#line 1389 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2809), {226, 171, 179, 0}}, -#line 2011 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2810), {226, 171, 166, 0}}, -#line 1327 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2811), {240, 157, 148, 146}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 104 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2816), {226, 136, 181, 0}}, - {-1,{0}}, -#line 1513 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2818), {226, 164, 156, 0}}, - {-1,{0}}, -#line 843 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2820), {226, 164, 155, 0}}, -#line 1348 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2821), {226, 138, 150, 0}}, -#line 73 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2822), {240, 157, 146, 156}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 509 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2826), {206, 149, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1675 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2832), {226, 134, 144, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 776 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2845), {226, 136, 136, 0}}, - {-1,{0}}, -#line 1050 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2847), {194, 181, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2111 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2851), {197, 190, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 816 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2856), {240, 157, 147, 128}}, -#line 648 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2857), {226, 132, 138, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 113 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2862), {240, 157, 148, 133}}, -#line 607 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2863), {226, 139, 155, 0}}, -#line 686 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2864), {226, 138, 185, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1884 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2871), {226, 168, 186, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 479 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2877), {195, 168, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1654 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2881), {226, 139, 133, 0}}, -#line 1923 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2882), {195, 185, 0}}, - {-1,{0}}, -#line 2114 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2884), {197, 187, 0}}, -#line 471 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2885), {196, 151, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1228 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2890), {226, 137, 137, 0}}, - {-1,{0}}, -#line 1834 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2892), {226, 131, 155, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1466 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2897), {240, 157, 146, 171}}, -#line 1407 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2898), {206, 160, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 647 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2903), {240, 157, 146, 162}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1424 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2910), {226, 168, 167, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1172 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2914), {226, 136, 137, 0}}, - {-1,{0}}, -#line 1421 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2916), {194, 177, 0}}, - {-1,{0}}, {-1,{0}}, -#line 696 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2919), {240, 157, 149, 153}}, -#line 593 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2920), {207, 157, 0}}, - {-1,{0}}, -#line 1043 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2922), {226, 136, 186, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 388 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2926), {226, 139, 135, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 400 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2940), {226, 137, 144, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1985 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2956), {207, 181, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1438 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2963), {226, 137, 186, 0}}, - {-1,{0}}, {-1,{0}}, -#line 592 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2966), {207, 156, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 348 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2974), {226, 138, 163, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1169 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2979), {226, 137, 162, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1910 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2982), {197, 173, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1332 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2990), {226, 167, 129, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1608 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str2994), {226, 165, 176, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1440 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3002), {226, 137, 188, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1687 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3005), {226, 137, 131, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1922 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3014), {195, 153, 0}}, - {-1,{0}}, -#line 349 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3016), {226, 164, 143, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1655 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3021), {226, 169, 166, 0}}, - {-1,{0}}, -#line 2015 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3023), {226, 137, 154, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1034 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3027), {226, 134, 166, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1861 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3030), {195, 151, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1495 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3033), {226, 159, 169, 0}}, - {-1,{0}}, -#line 827 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3035), {226, 159, 168, 0}}, - {-1,{0}}, {-1,{0}}, -#line 877 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3038), {226, 134, 162, 0}}, -#line 672 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3039), {226, 132, 139, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1918 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3044), {226, 165, 174, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1137 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3053), {226, 139, 186, 0}}, - {-1,{0}}, -#line 1549 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3055), {226, 165, 189, 0}}, - {-1,{0}}, -#line 931 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3057), {226, 165, 188, 0}}, -#line 675 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3058), {226, 165, 136, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1353 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3066), {226, 128, 152, 0}}, - {-1,{0}}, -#line 1919 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3068), {226, 165, 190, 0}}, -#line 1183 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3069), {226, 137, 142, 0}}, - {-1,{0}}, {-1,{0}}, -#line 895 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3072), {226, 138, 163, 0}}, - {-1,{0}}, -#line 1617 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3074), {226, 134, 177, 0}}, - {-1,{0}}, -#line 1000 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3076), {226, 134, 176, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 667 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3080), {226, 137, 169, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1860 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3083), {226, 138, 160, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1649 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3092), {226, 168, 147, 0}}, - {-1,{0}}, {-1,{0}}, -#line 236 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3095), {196, 138, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 454 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3103), {226, 166, 166, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1909 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3114), {197, 172, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 904 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3132), {226, 134, 191, 0}}, - {-1,{0}}, {-1,{0}}, -#line 903 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3135), {226, 165, 152, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 461 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3139), {196, 154, 0}}, - {-1,{0}}, {-1,{0}}, -#line 693 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3142), {226, 136, 187, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 724 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3147), {195, 172, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1238 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3155), {226, 170, 175, 0}}, -#line 466 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3156), {226, 137, 149, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 358 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3167), {226, 133, 134, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1688 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3174), {226, 137, 131, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1187 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3179), {226, 139, 185, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 119 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3198), {226, 168, 129, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 21 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3214), {240, 157, 148, 132}}, -#line 873 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3215), {226, 134, 144, 0}}, -#line 1335 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3216), {226, 136, 174, 0}}, - {-1,{0}}, -#line 1823 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3218), {9, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1329 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3227), {203, 155, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1012 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3230), {60, 0}}, -#line 1149 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3231), {226, 135, 142, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1498 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3235), {226, 135, 165, 0}}, - {-1,{0}}, -#line 831 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3237), {226, 135, 164, 0}}, - {-1,{0}}, -#line 700 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3239), {240, 157, 146, 189}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 901 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3246), {226, 165, 145, 0}}, - {-1,{0}}, -#line 807 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3248), {240, 157, 148, 168}}, -#line 619 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3249), {240, 157, 148, 164}}, -#line 1945 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3250), {226, 164, 146, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1250 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3259), {226, 170, 176, 0}}, -#line 1015 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3260), {226, 139, 150, 0}}, -#line 616 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3261), {226, 139, 155, 0}}, -#line 2073 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3262), {226, 168, 128, 0}}, -#line 1747 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3263), {226, 152, 134, 0}}, - {-1,{0}}, {-1,{0}}, -#line 983 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3266), {95, 0}}, - {-1,{0}}, -#line 2065 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3268), {226, 159, 183, 0}}, -#line 465 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3269), {226, 137, 150, 0}}, - {-1,{0}}, -#line 1975 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3271), {226, 139, 176, 0}}, -#line 1085 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3272), {226, 153, 174, 0}}, -#line 1001 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3273), {226, 134, 176, 0}}, -#line 745 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3274), {226, 136, 158, 0}}, - {-1,{0}}, -#line 283 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3276), {226, 136, 129, 0}}, - {-1,{0}}, -#line 1684 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3278), {207, 130, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 2077 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3285), {226, 168, 130, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1400 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3289), {240, 157, 148, 147}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 618 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3295), {240, 157, 148, 138}}, - {-1,{0}}, {-1,{0}}, -#line 115 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3298), {226, 139, 130, 0}}, - {-1,{0}}, -#line 1692 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3300), {226, 170, 159, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 726 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3319), {226, 168, 140, 0}}, -#line 95 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3320), {226, 140, 133, 0}}, -#line 94 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3321), {226, 140, 134, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 2069 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3329), {226, 159, 181, 0}}, -#line 923 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3330), {226, 139, 154, 0}}, - {-1,{0}}, -#line 301 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3332), {226, 134, 181, 0}}, -#line 772 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3333), {226, 139, 181, 0}}, - {-1,{0}}, -#line 282 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3335), {64, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1054 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3342), {194, 183, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 916 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3349), {226, 170, 131, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1683 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3356), {207, 130, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1499 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3366), {226, 164, 160, 0}}, - {-1,{0}}, -#line 832 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3368), {226, 164, 159, 0}}, - {-1,{0}}, {-1,{0}}, -#line 2078 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3371), {226, 159, 182, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 117 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3376), {226, 139, 131, 0}}, - {-1,{0}}, -#line 274 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3378), {226, 153, 163, 0}}, -#line 677 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3379), {226, 135, 148, 0}}, -#line 1625 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3380), {226, 138, 181, 0}}, - {-1,{0}}, -#line 1021 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3382), {226, 138, 180, 0}}, -#line 741 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3383), {198, 181, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 502 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3388), {196, 153, 0}}, -#line 1630 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3389), {226, 132, 158, 0}}, -#line 1023 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3390), {226, 166, 150, 0}}, -#line 1746 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3391), {226, 139, 134, 0}}, - {-1,{0}}, -#line 1942 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3393), {197, 179, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1855 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3396), {226, 136, 188, 0}}, - {-1,{0}}, -#line 671 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3398), {194, 189, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1854 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3405), {203, 156, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 875 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3412), {226, 135, 144, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 617 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3417), {226, 170, 148, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 217 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3422), {226, 136, 169, 0}}, -#line 1751 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3423), {194, 175, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1014 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3427), {226, 137, 170, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1453 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3439), {226, 170, 181, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1726 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3447), {226, 138, 146, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1727 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3462), {226, 138, 144, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1882 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3467), {226, 151, 172, 0}}, -#line 1360 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3468), {226, 132, 180, 0}}, - {-1,{0}}, {-1,{0}}, -#line 222 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3471), {226, 136, 169, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 302 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3475), {226, 156, 151, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 366 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3482), {226, 165, 191, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2071 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3487), {226, 159, 188, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1725 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3491), {226, 138, 144, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1624 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3503), {226, 150, 185, 0}}, - {-1,{0}}, -#line 1020 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3505), {226, 151, 131, 0}}, -#line 777 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3506), {226, 129, 162, 0}}, -#line 1598 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3507), {226, 142, 177, 0}}, - {-1,{0}}, -#line 954 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3509), {226, 142, 176, 0}}, -#line 633 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3510), {226, 137, 169, 0}}, -#line 936 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3511), {226, 170, 145, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1641 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3514), {226, 170, 180, 0}}, - {-1,{0}}, -#line 1978 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3516), {226, 150, 181, 0}}, - {-1,{0}}, -#line 2016 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3518), {226, 139, 174, 0}}, - {-1,{0}}, -#line 534 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3520), {195, 144, 0}}, - {-1,{0}}, {-1,{0}}, -#line 952 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3523), {197, 128, 0}}, - {-1,{0}}, -#line 1941 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3525), {197, 178, 0}}, -#line 300 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3526), {226, 136, 179, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1120 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3534), {226, 137, 167, 0}}, -#line 1309 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3535), {226, 164, 167, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 917 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3543), {226, 139, 154, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1415 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3546), {226, 138, 158, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1618 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3550), {226, 134, 177, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 299 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3555), {226, 132, 151, 0}}, - {-1,{0}}, -#line 746 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3557), {226, 167, 157, 0}}, - {-1,{0}}, -#line 738 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3559), {196, 177, 0}}, -#line 530 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3560), {226, 169, 179, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1402 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3565), {206, 166, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 628 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3573), {226, 170, 146, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2030 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3579), {226, 138, 131, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1690 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3582), {226, 170, 160, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 413 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3586), {226, 159, 184, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 414 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3591), {226, 159, 186, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1295 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3594), {62, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1046 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3607), {226, 132, 179, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1450 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3611), {226, 128, 179, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 728 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3615), {226, 167, 156, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1546 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3620), {226, 136, 139, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 492 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3627), {226, 151, 187, 0}}, -#line 1489 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3628), {226, 136, 154, 0}}, - {-1,{0}}, {-1,{0}}, -#line 687 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3631), {240, 157, 148, 165}}, -#line 2115 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3632), {197, 188, 0}}, -#line 1029 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3633), {226, 153, 130, 0}}, - {-1,{0}}, -#line 1500 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3635), {226, 164, 179, 0}}, -#line 1436 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3636), {226, 137, 186, 0}}, -#line 1646 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3637), {226, 170, 186, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 383 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3641), {226, 133, 134, 0}}, - {-1,{0}}, -#line 1063 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3643), {226, 138, 167, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1011 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3657), {226, 169, 185, 0}}, -#line 762 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3658), {196, 175, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 216 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3665), {226, 169, 139, 0}}, - {-1,{0}}, -#line 720 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3667), {226, 135, 148, 0}}, - {-1,{0}}, -#line 360 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3669), {226, 169, 183, 0}}, - {-1,{0}}, -#line 263 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3671), {226, 138, 149, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1622 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3676), {226, 139, 140, 0}}, - {-1,{0}}, -#line 1016 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3678), {226, 139, 139, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1441 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3681), {226, 137, 190, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 449 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3685), {226, 139, 177, 0}}, - {-1,{0}}, -#line 275 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3687), {226, 153, 163, 0}}, - {-1,{0}}, -#line 1488 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3689), {197, 149, 0}}, - {-1,{0}}, -#line 819 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3691), {196, 186, 0}}, -#line 1889 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3692), {226, 143, 162, 0}}, -#line 1632 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3693), {197, 155, 0}}, - {-1,{0}}, {-1,{0}}, -#line 2108 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3696), {197, 185, 0}}, -#line 459 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3697), {195, 169, 0}}, - {-1,{0}}, -#line 1858 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3699), {226, 137, 136, 0}}, - {-1,{0}}, -#line 1906 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3701), {226, 165, 137, 0}}, -#line 1902 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3702), {195, 186, 0}}, -#line 982 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3703), {226, 136, 151, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1076 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3714), {197, 132, 0}}, - {-1,{0}}, -#line 1206 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3716), {226, 138, 128, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 951 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3720), {196, 191, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1947 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3725), {226, 134, 145, 0}}, - {-1,{0}}, -#line 1511 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3727), {226, 134, 157, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 438 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3738), {226, 138, 164, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 555 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3742), {226, 151, 188, 0}}, -#line 219 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3743), {226, 169, 135, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 642 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3749), {226, 137, 167, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1299 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3756), {226, 137, 164, 0}}, - {-1,{0}}, -#line 1883 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3758), {226, 137, 156, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1346 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3764), {206, 191, 0}}, - {-1,{0}}, -#line 417 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3766), {226, 138, 168, 0}}, -#line 233 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3767), {226, 136, 176, 0}}, -#line 1621 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3768), {226, 128, 153, 0}}, - {-1,{0}}, -#line 1007 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3770), {226, 128, 154, 0}}, - {-1,{0}}, -#line 2124 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3772), {226, 135, 157, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 293 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3780), {240, 157, 149, 148}}, - {-1,{0}}, -#line 292 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3782), {226, 136, 174, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 670 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3798), {226, 128, 138, 0}}, -#line 1728 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3799), {226, 138, 146, 0}}, -#line 306 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3800), {226, 171, 143, 0}}, -#line 1955 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3801), {226, 134, 190, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 426 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3805), {204, 145, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1674 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3817), {226, 134, 147, 0}}, - {-1,{0}}, -#line 2075 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3819), {240, 157, 149, 169}}, - {-1,{0}}, -#line 1631 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3821), {197, 154, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 2039 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3829), {226, 171, 140, 0}}, -#line 265 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3830), {226, 151, 139, 0}}, -#line 1414 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3831), {226, 168, 163, 0}}, -#line 308 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3832), {226, 171, 144, 0}}, -#line 2037 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3833), {226, 171, 139, 0}}, -#line 1901 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3834), {195, 154, 0}}, - {-1,{0}}, -#line 773 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3836), {226, 139, 185, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 606 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3845), {226, 170, 140, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1719 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3851), {226, 138, 148, 0}}, - {-1,{0}}, -#line 1701 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3853), {226, 136, 163, 0}}, - {-1,{0}}, -#line 935 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3855), {226, 137, 182, 0}}, - {-1,{0}}, -#line 415 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3857), {226, 159, 185, 0}}, -#line 1208 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3858), {226, 139, 160, 0}}, - {-1,{0}}, {-1,{0}}, -#line 477 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3861), {226, 170, 154, 0}}, - {-1,{0}}, {-1,{0}}, -#line 33 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3864), {38, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1162 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3874), {226, 136, 164, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1862 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3883), {226, 168, 176, 0}}, - {-1,{0}}, {-1,{0}}, -#line 433 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3886), {226, 134, 189, 0}}, -#line 2130 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3887), {226, 128, 140, 0}}, -#line 818 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3888), {196, 185, 0}}, -#line 432 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3889), {226, 165, 150, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1331 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3898), {195, 178, 0}}, -#line 2087 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3899), {195, 157, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1718 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3903), {226, 138, 148, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1322 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3906), {226, 138, 153, 0}}, -#line 212 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3907), {196, 134, 0}}, - {-1,{0}}, -#line 1285 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3909), {206, 189, 0}}, -#line 1888 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3910), {226, 168, 187, 0}}, - {-1,{0}}, -#line 478 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3912), {195, 136, 0}}, -#line 507 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3913), {226, 169, 177, 0}}, - {-1,{0}}, -#line 85 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3915), {226, 137, 140, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1956 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3918), {226, 138, 142, 0}}, - {-1,{0}}, -#line 470 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3920), {196, 150, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 309 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3924), {226, 171, 146, 0}}, - {-1,{0}}, -#line 1689 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3926), {226, 170, 158, 0}}, -#line 1958 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3927), {226, 134, 151, 0}}, -#line 307 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3928), {226, 171, 145, 0}}, - {-1,{0}}, -#line 450 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3930), {226, 150, 191, 0}}, -#line 1454 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3931), {226, 139, 168, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 177 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3936), {226, 149, 153, 0}}, -#line 1980 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3937), {226, 135, 136, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 431 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3945), {226, 165, 158, 0}}, -#line 650 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3946), {226, 170, 142, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 120 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3950), {226, 168, 130, 0}}, -#line 341 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3951), {226, 128, 161, 0}}, - {-1,{0}}, {-1,{0}}, -#line 754 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3954), {226, 139, 130, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 710 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3967), {195, 173, 0}}, - {-1,{0}}, -#line 1434 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3969), {226, 137, 188, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 481 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3981), {226, 170, 152, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 742 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3987), {226, 135, 146, 0}}, -#line 2010 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3988), {226, 138, 171, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 207 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str3996), {226, 137, 142, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1070 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4015), {206, 156, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 2008 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4022), {226, 138, 168, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1027 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4028), {226, 137, 168, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 894 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4033), {226, 134, 164, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1075 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4037), {197, 131, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1936 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4042), {226, 143, 159, 0}}, -#line 1468 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4043), {206, 168, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1559 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4047), {207, 177, 0}}, - {-1,{0}}, -#line 912 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4049), {226, 170, 168, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1789 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4055), {194, 185, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1790 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4058), {194, 178, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1791 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4066), {194, 179, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 118 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4071), {226, 168, 128, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 424 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4078), {226, 135, 147, 0}}, - {-1,{0}}, -#line 2082 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4080), {226, 168, 134, 0}}, - {-1,{0}}, -#line 92 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4082), {226, 138, 189, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1106 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4087), {226, 128, 139, 0}}, -#line 209 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4088), {226, 137, 143, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 305 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4100), {240, 157, 146, 184}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1248 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4109), {226, 138, 129, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1792 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4115), {226, 138, 131, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 238 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4122), {194, 184, 0}}, - {-1,{0}}, {-1,{0}}, -#line 191 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4125), {226, 149, 159, 0}}, - {-1,{0}}, -#line 1364 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4127), {226, 138, 182, 0}}, -#line 2129 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4128), {226, 128, 141, 0}}, -#line 723 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4129), {195, 140, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 716 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4137), {196, 176, 0}}, - {-1,{0}}, -#line 2081 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4139), {240, 157, 147, 141}}, -#line 2068 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4140), {206, 190, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1131 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4144), {226, 137, 171, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 165 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4153), {226, 149, 167, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1852 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4163), {195, 158, 0}}, - {-1,{0}}, -#line 1487 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4165), {197, 148, 0}}, - {-1,{0}}, -#line 1505 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4167), {226, 134, 170, 0}}, - {-1,{0}}, -#line 837 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4169), {226, 134, 169, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1627 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4177), {226, 167, 142, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 180 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4189), {226, 149, 145, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 340 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4215), {226, 128, 160, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1345 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4220), {206, 159, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 420 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4226), {226, 136, 165, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1117 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4229), {226, 136, 132, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1284 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4232), {206, 157, 0}}, -#line 1116 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4233), {226, 136, 132, 0}}, -#line 605 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4234), {226, 137, 167, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 63 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4238), {226, 137, 136, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1793 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4243), {226, 139, 145, 0}}, -#line 401 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4244), {226, 137, 145, 0}}, - {-1,{0}}, {-1,{0}}, -#line 499 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4247), {197, 139, 0}}, - {-1,{0}}, -#line 224 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4249), {203, 135, 0}}, - {-1,{0}}, -#line 167 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4251), {226, 149, 169, 0}}, -#line 613 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4252), {226, 170, 128, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1547 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4257), {226, 135, 139, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 174 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4262), {226, 149, 157, 0}}, - {-1,{0}}, -#line 1804 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4264), {226, 171, 130, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1409 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4267), {226, 139, 148, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1288 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4272), {226, 128, 135, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1491 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4285), {226, 159, 169, 0}}, - {-1,{0}}, -#line 824 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4287), {226, 159, 168, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1315 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4290), {226, 138, 154, 0}}, - {-1,{0}}, -#line 1515 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4292), {226, 132, 154, 0}}, - {-1,{0}}, -#line 295 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4294), {226, 136, 144, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1018 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4307), {226, 165, 182, 0}}, -#line 194 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4308), {203, 152, 0}}, - {-1,{0}}, -#line 1077 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4310), {226, 136, 160, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1817 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4315), {226, 164, 166, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1496 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4322), {194, 187, 0}}, - {-1,{0}}, -#line 830 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4324), {194, 171, 0}}, -#line 1815 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4325), {226, 171, 148, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 321 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4329), {226, 139, 147, 0}}, -#line 65 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4330), {226, 137, 138, 0}}, -#line 1481 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4331), {63, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1305 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4336), {226, 164, 163, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1808 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4340), {226, 138, 131, 0}}, - {-1,{0}}, -#line 422 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4342), {226, 134, 147, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 452 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4351), {226, 135, 181, 0}}, - {-1,{0}}, -#line 67 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4353), {39, 0}}, -#line 1330 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4354), {195, 146, 0}}, -#line 1677 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4355), {226, 136, 165, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1268 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4364), {226, 138, 129, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 966 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4368), {226, 159, 181, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 915 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4377), {226, 170, 129, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1806 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4384), {226, 138, 139, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1126 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4388), {226, 139, 153, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1490 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4396), {226, 166, 179, 0}}, -#line 1816 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4397), {226, 171, 150, 0}}, -#line 820 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4398), {226, 166, 180, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1870 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4401), {226, 171, 154, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 501 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4423), {196, 152, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1593 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4429), {226, 137, 147, 0}}, - {-1,{0}}, -#line 211 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4431), {226, 137, 143, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1009 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4435), {197, 130, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1896 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4439), {197, 166, 0}}, -#line 649 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4440), {226, 137, 179, 0}}, - {-1,{0}}, {-1,{0}}, -#line 105 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4443), {226, 166, 176, 0}}, -#line 2109 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4444), {197, 186, 0}}, -#line 651 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4445), {226, 170, 144, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1897 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4448), {197, 167, 0}}, - {-1,{0}}, -#line 1600 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4450), {226, 159, 173, 0}}, -#line 188 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4451), {226, 149, 163, 0}}, -#line 962 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4452), {226, 159, 172, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1152 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4456), {226, 169, 189, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1633 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4462), {226, 128, 154, 0}}, - {-1,{0}}, -#line 1656 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4464), {226, 164, 165, 0}}, -#line 956 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4465), {226, 170, 137, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1809 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4468), {226, 139, 145, 0}}, - {-1,{0}}, -#line 161 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4470), {226, 149, 164, 0}}, -#line 1986 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4471), {207, 176, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 253 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4475), {226, 137, 151, 0}}, - {-1,{0}}, -#line 2101 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4477), {240, 157, 149, 170}}, - {-1,{0}}, -#line 1940 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4479), {226, 138, 142, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 825 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4484), {226, 159, 170, 0}}, -#line 1100 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4485), {226, 164, 164, 0}}, -#line 1673 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4486), {209, 136, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 244 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4492), {240, 157, 148, 160}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 799 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4506), {206, 154, 0}}, -#line 943 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4507), {209, 153, 0}}, -#line 1045 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4508), {226, 129, 159, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1810 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4511), {226, 138, 135, 0}}, -#line 1811 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4512), {226, 171, 134, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1544 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4517), {194, 174, 0}}, -#line 30 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4518), {196, 129, 0}}, -#line 908 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4519), {226, 139, 154, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2049 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4524), {226, 132, 152, 0}}, -#line 1892 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4525), {208, 166, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1812 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4529), {226, 138, 139, 0}}, -#line 1140 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4530), {209, 154, 0}}, -#line 2064 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4531), {240, 157, 148, 181}}, - {-1,{0}}, -#line 1071 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4533), {206, 188, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1297 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4539), {226, 167, 158, 0}}, -#line 178 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4540), {226, 149, 154, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2076 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4545), {226, 168, 129, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 886 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4551), {226, 135, 135, 0}}, -#line 1786 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4552), {226, 136, 145, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 111 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4559), {226, 132, 182, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 285 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4563), {226, 136, 129, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1286 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4573), {35, 0}}, -#line 32 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4574), {38, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 173 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4583), {226, 149, 156, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1176 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4590), {226, 137, 175, 0}}, -#line 169 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4591), {226, 138, 158, 0}}, -#line 790 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4592), {200, 183, 0}}, - {-1,{0}}, -#line 1668 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4594), {226, 140, 162, 0}}, - {-1,{0}}, -#line 447 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4596), {196, 144, 0}}, - {-1,{0}}, -#line 36 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4598), {226, 136, 167, 0}}, -#line 1179 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4599), {226, 137, 171, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1181 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4606), {226, 169, 190, 0}}, - {-1,{0}}, -#line 1180 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4608), {226, 137, 185, 0}}, -#line 1483 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4609), {34, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1178 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4616), {226, 137, 167, 0}}, -#line 708 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4617), {226, 128, 144, 0}}, -#line 1411 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4618), {226, 132, 143, 0}}, - {-1,{0}}, -#line 1856 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4620), {226, 137, 131, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1871 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4627), {226, 164, 169, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1008 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4632), {197, 129, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1680 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4635), {194, 173, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2072 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4639), {226, 139, 187, 0}}, -#line 761 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4640), {196, 174, 0}}, - {-1,{0}}, {-1,{0}}, -#line 455 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4643), {208, 143, 0}}, - {-1,{0}}, -#line 1333 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4645), {226, 166, 181, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 270 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4652), {226, 167, 130, 0}}, - {-1,{0}}, -#line 1665 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4654), {226, 156, 182, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1386 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4668), {194, 182, 0}}, - {-1,{0}}, {-1,{0}}, -#line 76 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4671), {42, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1482 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4678), {226, 137, 159, 0}}, - {-1,{0}}, -#line 1787 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4680), {226, 136, 145, 0}}, - {-1,{0}}, -#line 444 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4682), {208, 133, 0}}, - {-1,{0}}, -#line 498 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4684), {197, 138, 0}}, - {-1,{0}}, -#line 2122 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4686), {208, 150, 0}}, - {-1,{0}}, {-1,{0}}, -#line 965 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4689), {226, 159, 181, 0}}, - {-1,{0}}, -#line 346 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4691), {226, 128, 144, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 437 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4699), {226, 134, 167, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1813 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4706), {226, 171, 140, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1457 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4714), {226, 140, 174, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1311 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4718), {195, 179, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 192 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4729), {226, 149, 160, 0}}, - {-1,{0}}, {-1,{0}}, -#line 458 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4732), {195, 137, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1807 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4738), {226, 171, 128, 0}}, - {-1,{0}}, -#line 694 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4740), {226, 134, 169, 0}}, - {-1,{0}}, {-1,{0}}, -#line 273 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4743), {226, 128, 153, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1887 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4746), {226, 167, 141, 0}}, -#line 405 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4747), {226, 138, 161, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1623 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4751), {226, 139, 138, 0}}, - {-1,{0}}, -#line 1017 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4753), {226, 139, 137, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1864 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4756), {226, 164, 168, 0}}, -#line 23 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4757), {195, 128, 0}}, - {-1,{0}}, {-1,{0}}, -#line 75 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4760), {226, 137, 148, 0}}, -#line 1492 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4761), {226, 159, 171, 0}}, -#line 760 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4762), {209, 145, 0}}, - {-1,{0}}, -#line 1207 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4764), {226, 170, 175, 0}}, - {-1,{0}}, -#line 61 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4766), {240, 157, 149, 146}}, - {-1,{0}}, -#line 251 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4768), {207, 135, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1479 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4771), {226, 132, 141, 0}}, -#line 187 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4772), {226, 149, 162, 0}}, -#line 1177 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4773), {226, 137, 177, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2066 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4777), {226, 159, 186, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1361 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4791), {226, 132, 180, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1620 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4794), {226, 128, 153, 0}}, - {-1,{0}}, -#line 1006 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4796), {226, 128, 152, 0}}, -#line 2103 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4797), {240, 157, 147, 142}}, - {-1,{0}}, {-1,{0}}, -#line 603 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4800), {196, 161, 0}}, - {-1,{0}}, -#line 1214 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4802), {226, 139, 162, 0}}, -#line 809 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4803), {208, 165, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 202 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4809), {226, 167, 133, 0}}, -#line 1213 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4810), {226, 138, 143, 0}}, -#line 1672 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4811), {208, 168, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2098 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4821), {208, 135, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 338 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4825), {226, 136, 177, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1841 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4828), {206, 152, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1842 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4837), {206, 184, 0}}, -#line 2070 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4838), {226, 159, 184, 0}}, - {-1,{0}}, -#line 1216 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4840), {226, 139, 163, 0}}, - {-1,{0}}, {-1,{0}}, -#line 365 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4843), {226, 166, 177, 0}}, -#line 1875 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4844), {226, 150, 181, 0}}, - {-1,{0}}, -#line 602 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4846), {196, 160, 0}}, - {-1,{0}}, -#line 1215 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4848), {226, 138, 144, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 8 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4857), {196, 130, 0}}, - {-1,{0}}, {-1,{0}}, -#line 448 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4860), {196, 145, 0}}, -#line 1399 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4861), {226, 128, 177, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1521 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4866), {93, 0}}, - {-1,{0}}, -#line 851 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4868), {91, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1323 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4872), {226, 166, 188, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1347 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4878), {226, 166, 182, 0}}, - {-1,{0}}, -#line 2079 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4880), {226, 159, 185, 0}}, - {-1,{0}}, -#line 1877 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4882), {226, 151, 131, 0}}, -#line 1182 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4883), {226, 137, 181, 0}}, -#line 279 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4884), {226, 137, 148, 0}}, - {-1,{0}}, -#line 967 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4886), {226, 159, 184, 0}}, - {-1,{0}}, -#line 766 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4888), {206, 185, 0}}, - {-1,{0}}, -#line 276 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4890), {58, 0}}, -#line 2118 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4891), {206, 150, 0}}, -#line 596 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4892), {196, 159, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 246 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4897), {208, 167, 0}}, - {-1,{0}}, {-1,{0}}, -#line 2104 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4900), {208, 174, 0}}, -#line 1545 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4901), {194, 174, 0}}, -#line 1822 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4902), {195, 159, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 456 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4909), {209, 159, 0}}, - {-1,{0}}, -#line 110 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4911), {206, 178, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 538 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4918), {226, 130, 172, 0}}, - {-1,{0}}, {-1,{0}}, -#line 874 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4921), {226, 134, 144, 0}}, - {-1,{0}}, {-1,{0}}, -#line 221 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4924), {226, 133, 133, 0}}, - {-1,{0}}, -#line 1592 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4926), {203, 154, 0}}, -#line 829 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4927), {226, 132, 146, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 391 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4932), {209, 146, 0}}, - {-1,{0}}, -#line 1355 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4934), {226, 138, 149, 0}}, - {-1,{0}}, {-1,{0}}, -#line 751 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4937), {226, 132, 164, 0}}, -#line 595 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4938), {196, 158, 0}}, - {-1,{0}}, -#line 1908 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4940), {209, 158, 0}}, -#line 537 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4941), {195, 171, 0}}, - {-1,{0}}, {-1,{0}}, -#line 361 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4944), {194, 176, 0}}, - {-1,{0}}, -#line 1982 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4946), {195, 188, 0}}, - {-1,{0}}, {-1,{0}}, -#line 709 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4949), {195, 141, 0}}, -#line 1780 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4950), {226, 170, 176, 0}}, - {-1,{0}}, -#line 811 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4952), {208, 140, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 319 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4961), {226, 137, 141, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1893 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4975), {209, 134, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 241 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4982), {194, 162, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 390 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str4991), {208, 130, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1857 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5009), {226, 137, 133, 0}}, - {-1,{0}}, -#line 1879 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5011), {226, 137, 156, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 453 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5016), {226, 165, 175, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 879 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5025), {226, 159, 166, 0}}, - {-1,{0}}, -#line 942 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5027), {208, 137, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 718 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5036), {208, 181, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1878 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5043), {226, 138, 180, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1110 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5049), {226, 137, 162, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1254 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5055), {226, 136, 166, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1099 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5062), {226, 128, 147, 0}}, -#line 148 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5063), {226, 139, 136, 0}}, - {-1,{0}}, -#line 557 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5065), {102, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1907 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5072), {208, 142, 0}}, - {-1,{0}}, -#line 1999 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5074), {207, 145, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1981 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5078), {195, 156, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2001 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5084), {226, 138, 179, 0}}, -#line 2000 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5085), {226, 138, 178, 0}}, -#line 74 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5086), {240, 157, 146, 182}}, - {-1,{0}}, {-1,{0}}, -#line 1775 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5089), {226, 137, 189, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 337 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5093), {226, 136, 178, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1638 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5101), {226, 137, 187, 0}}, - {-1,{0}}, -#line 559 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5103), {239, 172, 130, 0}}, - {-1,{0}}, -#line 256 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5105), {226, 138, 155, 0}}, - {-1,{0}}, {-1,{0}}, -#line 2009 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5108), {226, 138, 169, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1292 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5112), {226, 138, 174, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1803 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5120), {226, 165, 187, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1602 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5124), {226, 159, 167, 0}}, - {-1,{0}}, -#line 964 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5126), {226, 159, 166, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2007 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5142), {226, 138, 162, 0}}, -#line 2107 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5143), {197, 184, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 654 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5151), {62, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 226 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5156), {226, 169, 141, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1776 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5173), {226, 137, 187, 0}}, -#line 1310 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5174), {195, 147, 0}}, -#line 1874 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5175), {226, 132, 162, 0}}, -#line 1139 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5176), {208, 138, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 657 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5181), {226, 139, 151, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 2097 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5189), {240, 157, 148, 182}}, - {-1,{0}}, {-1,{0}}, -#line 284 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5192), {226, 136, 152, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 656 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5197), {226, 137, 171, 0}}, -#line 1647 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5198), {226, 170, 182, 0}}, -#line 731 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5199), {196, 179, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 261 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5203), {226, 147, 136, 0}}, - {-1,{0}}, {-1,{0}}, -#line 2095 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5206), {194, 165, 0}}, - {-1,{0}}, -#line 1843 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5208), {207, 145, 0}}, - {-1,{0}}, {-1,{0}}, -#line 783 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5211), {195, 175, 0}}, -#line 1778 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5212), {226, 137, 189, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 159 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5217), {226, 149, 144, 0}}, -#line 1073 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5218), {226, 138, 184, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1577 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5222), {226, 135, 137, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 280 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5227), {226, 137, 148, 0}}, - {-1,{0}}, -#line 1637 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5229), {226, 170, 188, 0}}, -#line 629 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5230), {226, 170, 164, 0}}, -#line 719 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5231), {194, 161, 0}}, - {-1,{0}}, {-1,{0}}, -#line 234 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5234), {226, 169, 140, 0}}, - {-1,{0}}, -#line 2059 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5236), {226, 139, 130, 0}}, -#line 2123 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5237), {208, 182, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 163 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5241), {226, 149, 166, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 911 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5250), {226, 169, 189, 0}}, - {-1,{0}}, -#line 1957 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5252), {226, 134, 150, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 350 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5257), {203, 157, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1470 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5260), {226, 128, 136, 0}}, - {-1,{0}}, -#line 228 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5262), {196, 141, 0}}, - {-1,{0}}, -#line 1519 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5264), {226, 157, 179, 0}}, - {-1,{0}}, -#line 849 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5266), {226, 157, 178, 0}}, - {-1,{0}}, -#line 58 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5268), {196, 132, 0}}, -#line 898 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5269), {226, 167, 143, 0}}, - {-1,{0}}, {-1,{0}}, -#line 615 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5272), {226, 170, 132, 0}}, -#line 900 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5273), {226, 138, 180, 0}}, -#line 899 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5274), {226, 138, 178, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 290 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5280), {226, 136, 174, 0}}, - {-1,{0}}, {-1,{0}}, -#line 439 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5283), {226, 164, 144, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1626 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5295), {226, 150, 184, 0}}, - {-1,{0}}, -#line 1022 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5297), {226, 151, 130, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1548 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5300), {226, 165, 175, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 878 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5306), {226, 140, 136, 0}}, - {-1,{0}}, -#line 1979 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5308), {226, 150, 180, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2061 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5314), {226, 139, 131, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 545 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5319), {226, 137, 146, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1528 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5325), {197, 151, 0}}, - {-1,{0}}, -#line 858 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5327), {196, 188, 0}}, - {-1,{0}}, -#line 1643 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5329), {197, 159, 0}}, - {-1,{0}}, -#line 1830 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5331), {197, 162, 0}}, - {-1,{0}}, -#line 1748 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5333), {226, 152, 133, 0}}, -#line 168 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5334), {226, 138, 159, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1831 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5340), {197, 163, 0}}, -#line 2117 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5341), {226, 128, 139, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1093 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5350), {197, 134, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1404 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5358), {207, 149, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 711 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5375), {226, 129, 163, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 220 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5384), {226, 169, 128, 0}}, - {-1,{0}}, {-1,{0}}, -#line 445 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5387), {209, 149, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 248 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5397), {226, 156, 147, 0}}, -#line 1381 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5398), {226, 140, 189, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1280 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5405), {226, 139, 170, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1580 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5411), {226, 138, 162, 0}}, -#line 1294 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5412), {226, 137, 165, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 892 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5424), {226, 134, 173, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 987 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5431), {226, 151, 138, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1583 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5434), {226, 167, 144, 0}}, - {-1,{0}}, -#line 1581 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5436), {226, 165, 155, 0}}, - {-1,{0}}, -#line 1585 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5438), {226, 138, 181, 0}}, -#line 1584 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5439), {226, 138, 179, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 802 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5449), {196, 182, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1642 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5457), {197, 158, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 268 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5468), {226, 168, 144, 0}}, - {-1,{0}}, {-1,{0}}, -#line 490 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5471), {226, 136, 133, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 22 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5478), {240, 157, 148, 158}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 376 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5482), {203, 156, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 882 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5489), {226, 135, 131, 0}}, - {-1,{0}}, {-1,{0}}, -#line 881 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5492), {226, 165, 153, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 907 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5501), {226, 170, 139, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 68 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5509), {226, 129, 161, 0}}, - {-1,{0}}, {-1,{0}}, -#line 208 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5512), {226, 170, 174, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 857 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5524), {196, 187, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 223 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5528), {226, 129, 129, 0}}, - {-1,{0}}, -#line 91 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5530), {226, 171, 167, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 229 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5543), {195, 135, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 260 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5547), {194, 174, 0}}, -#line 880 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5548), {226, 165, 161, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1895 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5552), {209, 155, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 402 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5556), {226, 137, 144, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 242 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5564), {194, 183, 0}}, - {-1,{0}}, -#line 1281 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5566), {226, 139, 172, 0}}, - {-1,{0}}, -#line 1056 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5568), {226, 136, 146, 0}}, - {-1,{0}}, -#line 623 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5570), {226, 132, 183, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 6 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5577), {195, 129, 0}}, -#line 653 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5578), {226, 169, 186, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 661 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5583), {226, 165, 184, 0}}, -#line 205 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5584), {226, 128, 162, 0}}, - {-1,{0}}, {-1,{0}}, -#line 423 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5587), {226, 134, 147, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1536 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5593), {226, 128, 157, 0}}, - {-1,{0}}, -#line 865 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5595), {226, 128, 158, 0}}, - {-1,{0}}, {-1,{0}}, -#line 755 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5598), {226, 168, 151, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1977 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5602), {197, 169, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 589 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5612), {199, 181, 0}}, - {-1,{0}}, -#line 1278 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5614), {195, 177, 0}}, -#line 20 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5615), {226, 129, 161, 0}}, - {-1,{0}}, {-1,{0}}, -#line 703 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5618), {196, 166, 0}}, - {-1,{0}}, -#line 543 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5620), {226, 133, 135, 0}}, -#line 1055 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5621), {226, 138, 159, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1587 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5625), {226, 165, 156, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1964 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5630), {226, 134, 165, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2119 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5639), {206, 182, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 373 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5644), {203, 153, 0}}, -#line 374 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5645), {203, 157, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1146 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5663), {226, 134, 154, 0}}, -#line 691 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5664), {226, 164, 166, 0}}, - {-1,{0}}, -#line 729 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5666), {226, 132, 169, 0}}, - {-1,{0}}, {-1,{0}}, -#line 62 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5669), {226, 169, 175, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1092 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5673), {197, 133, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 214 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5678), {226, 169, 132, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1042 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5686), {226, 128, 148, 0}}, - {-1,{0}}, {-1,{0}}, -#line 554 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5689), {239, 172, 129, 0}}, -#line 1648 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5690), {226, 139, 169, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1540 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5699), {226, 132, 156, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 897 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5703), {226, 139, 139, 0}}, -#line 77 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5704), {226, 137, 136, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 685 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5718), {226, 128, 166, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 451 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5722), {226, 150, 190, 0}}, - {-1,{0}}, -#line 1175 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5724), {226, 136, 132, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1639 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5728), {226, 137, 189, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2089 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5733), {208, 175, 0}}, -#line 1976 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5734), {197, 168, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1173 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5741), {226, 137, 160, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1848 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5747), {226, 128, 137, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 64 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5754), {226, 169, 176, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 206 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5762), {226, 128, 162, 0}}, - {-1,{0}}, {-1,{0}}, -#line 272 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5765), {226, 128, 157, 0}}, -#line 363 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5766), {206, 148, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 620 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5776), {226, 137, 171, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1378 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5780), {226, 138, 151, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2056 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5799), {226, 137, 128, 0}}, - {-1,{0}}, -#line 1527 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5801), {197, 150, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 535 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5807), {195, 176, 0}}, -#line 1805 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5808), {226, 171, 140, 0}}, - {-1,{0}}, {-1,{0}}, -#line 84 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5811), {226, 168, 145, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 195 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5817), {203, 152, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 621 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5822), {226, 139, 153, 0}}, - {-1,{0}}, -#line 706 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5824), {226, 137, 143, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 948 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5837), {226, 135, 154, 0}}, -#line 154 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5838), {226, 148, 140, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1782 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5847), {226, 170, 182, 0}}, -#line 1971 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5848), {197, 175, 0}}, -#line 929 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5849), {226, 169, 189, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1290 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5860), {226, 138, 172, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 669 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5866), {203, 135, 0}}, -#line 779 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5867), {196, 169, 0}}, - {-1,{0}}, {-1,{0}}, -#line 765 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5870), {206, 153, 0}}, - {-1,{0}}, -#line 759 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5872), {208, 129, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 156 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5884), {226, 149, 147, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1779 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5891), {226, 137, 191, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 883 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5905), {226, 140, 138, 0}}, -#line 2041 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5906), {226, 138, 170, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1876 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5923), {226, 150, 191, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 969 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5927), {226, 159, 183, 0}}, -#line 1572 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5928), {226, 140, 139, 0}}, - {-1,{0}}, {-1,{0}}, -#line 434 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5931), {226, 165, 159, 0}}, - {-1,{0}}, -#line 1480 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5933), {226, 168, 150, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1277 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5937), {195, 145, 0}}, - {-1,{0}}, {-1,{0}}, -#line 210 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5940), {226, 137, 142, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 668 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5949), {226, 137, 169, 0}}, - {-1,{0}}, -#line 164 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5951), {226, 148, 180, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 658 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5956), {226, 166, 149, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1237 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5959), {226, 138, 128, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1380 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5962), {195, 182, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 611 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5970), {226, 170, 169, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 536 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5976), {195, 139, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1970 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5980), {197, 174, 0}}, - {-1,{0}}, -#line 1937 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5982), {226, 142, 181, 0}}, -#line 1161 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5983), {226, 137, 170, 0}}, -#line 872 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5984), {226, 135, 164, 0}}, -#line 1095 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str5985), {226, 169, 173, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 78 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6003), {226, 137, 141, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1058 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6023), {226, 168, 170, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 364 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6030), {206, 180, 0}}, - {-1,{0}}, -#line 678 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6032), {226, 134, 173, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 38 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6038), {226, 169, 152, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 237 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6043), {196, 139, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 225 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6048), {226, 132, 173, 0}}, -#line 166 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6049), {226, 149, 168, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1784 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6052), {226, 137, 191, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 266 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6061), {226, 167, 131, 0}}, -#line 1653 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6062), {226, 138, 161, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1318 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6066), {226, 138, 157, 0}}, -#line 269 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6067), {226, 171, 175, 0}}, -#line 1802 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6068), {226, 171, 151, 0}}, -#line 1795 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6069), {226, 171, 152, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1794 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6077), {226, 170, 190, 0}}, - {-1,{0}}, -#line 83 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6079), {226, 136, 179, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1894 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6084), {208, 139, 0}}, - {-1,{0}}, {-1,{0}}, -#line 639 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6087), {96, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1004 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6101), {226, 170, 143, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1949 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6106), {226, 135, 133, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 906 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6121), {226, 134, 188, 0}}, -#line 416 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6122), {226, 135, 146, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1108 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6129), {226, 128, 139, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 941 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6140), {226, 150, 132, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 267 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6146), {226, 137, 151, 0}}, -#line 1293 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6147), {226, 138, 175, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1927 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6151), {226, 150, 128, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 737 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6155), {226, 132, 145, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1586 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6161), {226, 165, 143, 0}}, - {-1,{0}}, {-1,{0}}, -#line 151 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6164), {226, 149, 149, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 626 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6176), {226, 170, 165, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 782 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6193), {195, 143, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1325 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6203), {197, 147, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1198 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6208), {226, 169, 189, 0}}, - {-1,{0}}, -#line 153 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6210), {226, 149, 151, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 591 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6215), {206, 179, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1377 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6236), {226, 168, 183, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 968 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6248), {226, 159, 183, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 590 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6261), {206, 147, 0}}, -#line 127 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6262), {226, 139, 128, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 160 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6268), {226, 148, 172, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1796 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6283), {226, 171, 134, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 902 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6292), {226, 165, 160, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 614 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6298), {226, 170, 130, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 800 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6304), {206, 186, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1124 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6315), {226, 169, 190, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 665 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6340), {226, 137, 183, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 550 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6351), {239, 172, 128, 0}}, -#line 121 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6352), {226, 168, 134, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 808 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6367), {196, 184, 0}}, -#line 1797 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6368), {226, 138, 135, 0}}, - {-1,{0}}, -#line 170 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6370), {226, 138, 160, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 631 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6386), {226, 170, 138, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 427 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6394), {226, 135, 138, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 125 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6403), {226, 168, 132, 0}}, -#line 810 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6404), {209, 133, 0}}, - {-1,{0}}, -#line 355 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6406), {226, 128, 161, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1379 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6418), {195, 150, 0}}, - {-1,{0}}, -#line 109 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6420), {206, 146, 0}}, -#line 1057 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6421), {226, 136, 184, 0}}, -#line 1783 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6422), {226, 139, 169, 0}}, - {-1,{0}}, -#line 310 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6424), {226, 139, 175, 0}}, - {-1,{0}}, {-1,{0}}, -#line 812 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6427), {209, 156, 0}}, -#line 625 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6428), {209, 147, 0}}, - {-1,{0}}, -#line 1094 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6430), {226, 137, 135, 0}}, -#line 2085 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6431), {226, 139, 129, 0}}, -#line 98 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6432), {226, 137, 140, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1722 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6439), {226, 138, 145, 0}}, - {-1,{0}}, {-1,{0}}, -#line 155 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6442), {226, 149, 146, 0}}, - {-1,{0}}, {-1,{0}}, -#line 970 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6445), {226, 159, 186, 0}}, - {-1,{0}}, -#line 1721 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6447), {226, 138, 143, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 430 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6451), {226, 165, 144, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1723 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6454), {226, 138, 143, 0}}, - {-1,{0}}, -#line 1229 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6456), {226, 136, 164, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1174 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6461), {226, 137, 130, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 150 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6485), {226, 148, 144, 0}}, - {-1,{0}}, {-1,{0}}, -#line 157 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6488), {226, 149, 148, 0}}, - {-1,{0}}, -#line 34 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6490), {226, 169, 149, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1591 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6502), {226, 135, 128, 0}}, - {-1,{0}}, -#line 730 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6504), {196, 178, 0}}, -#line 1226 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6505), {226, 137, 132, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 57 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6509), {226, 141, 188, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 52 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6515), {226, 136, 159, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 11 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6521), {226, 136, 191, 0}}, - {-1,{0}}, {-1,{0}}, -#line 37 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6524), {226, 169, 156, 0}}, - {-1,{0}}, -#line 1240 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6526), {226, 164, 179, 0}}, -#line 2025 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6527), {226, 128, 138, 0}}, - {-1,{0}}, -#line 1799 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6529), {226, 138, 131, 0}}, - {-1,{0}}, -#line 152 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6531), {226, 149, 150, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2029 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6535), {226, 138, 130, 0}}, - {-1,{0}}, {-1,{0}}, -#line 235 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6538), {226, 169, 144, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1987 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6548), {226, 136, 133, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1532 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6552), {209, 128, 0}}, - {-1,{0}}, -#line 862 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6554), {208, 187, 0}}, - {-1,{0}}, -#line 1652 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6556), {209, 129, 0}}, - {-1,{0}}, -#line 1832 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6558), {208, 162, 0}}, -#line 2112 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6559), {208, 151, 0}}, -#line 468 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6560), {209, 141, 0}}, -#line 1537 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6561), {226, 134, 179, 0}}, - {-1,{0}}, -#line 868 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6563), {226, 134, 178, 0}}, - {-1,{0}}, -#line 1914 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6565), {209, 131, 0}}, -#line 184 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6566), {226, 149, 172, 0}}, -#line 1833 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6567), {209, 130, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1098 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6577), {208, 189, 0}}, - {-1,{0}}, -#line 100 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6579), {208, 177, 0}}, -#line 1276 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6580), {226, 137, 185, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 786 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6585), {208, 153, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 288 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6600), {226, 169, 173, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 56 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6607), {195, 133, 0}}, - {-1,{0}}, -#line 1569 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6609), {226, 165, 157, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1385 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6612), {226, 143, 156, 0}}, -#line 1019 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6613), {226, 169, 187, 0}}, - {-1,{0}}, -#line 1394 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6615), {208, 191, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1375 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6618), {195, 181, 0}}, -#line 1535 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6619), {226, 128, 157, 0}}, - {-1,{0}}, -#line 864 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6621), {226, 128, 156, 0}}, - {-1,{0}}, -#line 2005 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6623), {208, 146, 0}}, - {-1,{0}}, {-1,{0}}, -#line 215 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6626), {226, 169, 137, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 101 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6646), {226, 128, 158, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 421 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6650), {226, 164, 147, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 2006 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6657), {208, 178, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 53 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6665), {226, 138, 190, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 804 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6676), {208, 154, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1040 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6683), {208, 156, 0}}, -#line 1651 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6684), {208, 161, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1115 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6691), {10, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 547 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6696), {209, 132, 0}}, -#line 1913 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6697), {208, 163, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 183 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6704), {226, 149, 171, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 353 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6715), {208, 148, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 704 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6738), {196, 167, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 861 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6751), {208, 155, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2093 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6762), {208, 171, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1814 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6775), {226, 171, 136, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1164 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6789), {194, 160, 0}}, -#line 1382 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6790), {226, 128, 190, 0}}, -#line 1724 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6791), {226, 138, 145, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 624 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6797), {208, 131, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1383 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6800), {226, 143, 158, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 512 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6806), {226, 137, 150, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1384 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6819), {226, 142, 180, 0}}, - {-1,{0}}, -#line 81 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6821), {195, 132, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 15 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6829), {194, 180, 0}}, -#line 715 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6830), {208, 184, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 778 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6849), {196, 168, 0}}, -#line 689 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6850), {226, 132, 139, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1344 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6854), {207, 137, 0}}, -#line 213 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6855), {196, 135, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1645 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6861), {197, 157, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 464 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6865), {195, 170, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1912 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6870), {195, 187, 0}}, - {-1,{0}}, -#line 645 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6872), {226, 169, 190, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 784 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6890), {196, 180, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1291 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6895), {226, 138, 173, 0}}, -#line 2043 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6896), {197, 180, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1097 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6900), {208, 157, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1579 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6921), {226, 134, 166, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 924 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6942), {226, 137, 166, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1010 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6958), {226, 170, 166, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 26 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6963), {226, 132, 181, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 354 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6979), {208, 180, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1644 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6989), {197, 156, 0}}, - {-1,{0}}, -#line 919 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str6991), {226, 170, 133, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 717 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7000), {208, 149, 0}}, -#line 985 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7001), {226, 134, 152, 0}}, -#line 1911 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7002), {195, 155, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 24 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7021), {195, 160, 0}}, - {-1,{0}}, -#line 1059 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7023), {226, 136, 147, 0}}, -#line 126 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7024), {226, 139, 129, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1531 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7028), {208, 160, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1801 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7034), {226, 159, 137, 0}}, - {-1,{0}}, {-1,{0}}, -#line 494 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7037), {226, 150, 171, 0}}, - {-1,{0}}, -#line 162 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7039), {226, 149, 165, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1435 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7047), {226, 170, 183, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 54 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7066), {226, 166, 157, 0}}, -#line 2091 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7067), {197, 182, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1752 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7071), {226, 138, 130, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1374 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7074), {195, 149, 0}}, -#line 231 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7075), {196, 136, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 546 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7085), {208, 164, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 286 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7090), {226, 132, 130, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1762 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7096), {226, 165, 185, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 757 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7115), {226, 129, 163, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 175 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7120), {226, 148, 148, 0}}, -#line 9 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7121), {196, 131, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1279 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7127), {226, 137, 184, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 713 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7135), {195, 174, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 2062 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7142), {226, 150, 189, 0}}, -#line 252 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7143), {203, 134, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 662 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7168), {226, 139, 151, 0}}, - {-1,{0}}, {-1,{0}}, -#line 610 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7171), {226, 169, 190, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1282 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7183), {226, 139, 171, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 313 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7198), {226, 139, 158, 0}}, -#line 1753 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7199), {226, 139, 144, 0}}, - {-1,{0}}, -#line 1041 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7201), {208, 188, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1859 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7212), {226, 168, 177, 0}}, - {-1,{0}}, -#line 690 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7214), {226, 164, 165, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1682 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7217), {207, 131, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 324 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7224), {226, 169, 133, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1372 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7230), {195, 184, 0}}, -#line 457 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7231), {226, 159, 191, 0}}, - {-1,{0}}, {-1,{0}}, -#line 891 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7234), {226, 135, 139, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1576 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7245), {226, 135, 140, 0}}, - {-1,{0}}, -#line 803 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7247), {196, 183, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1758 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7256), {226, 171, 129, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 332 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7260), {194, 164, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 896 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7269), {226, 165, 154, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 122 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7274), {226, 152, 133, 0}}, - {-1,{0}}, {-1,{0}}, -#line 320 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7277), {226, 136, 170, 0}}, -#line 973 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7278), {226, 159, 182, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 597 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7294), {196, 162, 0}}, - {-1,{0}}, -#line 1439 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7296), {226, 170, 175, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2113 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7307), {208, 183, 0}}, - {-1,{0}}, -#line 1412 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7309), {226, 132, 142, 0}}, -#line 1343 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7310), {206, 169, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1771 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7317), {226, 171, 149, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1533 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7325), {226, 164, 183, 0}}, -#line 325 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7326), {226, 136, 170, 0}}, -#line 863 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7327), {226, 164, 182, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1763 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7332), {226, 138, 130, 0}}, -#line 1219 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7333), {226, 138, 129, 0}}, -#line 876 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7334), {226, 135, 134, 0}}, - {-1,{0}}, {-1,{0}}, -#line 2044 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7337), {197, 181, 0}}, -#line 1560 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7338), {226, 159, 169, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1283 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7344), {226, 139, 173, 0}}, -#line 1681 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7345), {206, 163, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1222 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7350), {226, 137, 191, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 372 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7364), {194, 180, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1760 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7376), {226, 138, 138, 0}}, - {-1,{0}}, -#line 1456 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7378), {226, 136, 143, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 258 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7385), {226, 138, 157, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1772 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7389), {226, 171, 147, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 297 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7397), {194, 169, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 533 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7403), {206, 183, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 51 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7409), {226, 136, 161, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1083 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7434), {226, 153, 174, 0}}, - {-1,{0}}, -#line 1798 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7436), {226, 171, 132, 0}}, -#line 1084 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7437), {226, 132, 149, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1880 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7443), {226, 150, 185, 0}}, - {-1,{0}}, -#line 375 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7445), {96, 0}}, -#line 172 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7446), {226, 149, 155, 0}}, -#line 287 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7447), {226, 137, 133, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1835 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7451), {226, 140, 149, 0}}, - {-1,{0}}, {-1,{0}}, -#line 281 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7454), {44, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1764 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7460), {226, 139, 144, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1221 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7475), {226, 139, 161, 0}}, -#line 663 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7476), {226, 139, 155, 0}}, -#line 79 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7477), {195, 131, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 326 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7484), {226, 134, 183, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 312 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7491), {226, 164, 181, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 311 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7495), {226, 164, 184, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1765 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7503), {226, 138, 134, 0}}, -#line 1766 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7504), {226, 171, 133, 0}}, -#line 1578 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7505), {226, 134, 157, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 318 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7520), {226, 169, 134, 0}}, -#line 1768 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7521), {226, 138, 138, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 59 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7532), {196, 133, 0}}, -#line 1190 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7533), {226, 139, 182, 0}}, -#line 1582 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7534), {226, 139, 140, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 2088 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7552), {195, 189, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1147 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7563), {226, 135, 141, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1317 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7581), {208, 190, 0}}, -#line 240 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7582), {226, 166, 178, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 467 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7595), {208, 173, 0}}, - {-1,{0}}, {-1,{0}}, -#line 322 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7598), {226, 169, 138, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1881 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7604), {226, 138, 181, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 888 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7615), {226, 134, 148, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1774 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7618), {226, 137, 187, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 425 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7631), {226, 135, 181, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1324 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7641), {197, 146, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 247 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7648), {209, 135, 0}}, -#line 664 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7649), {226, 170, 140, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 42 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7655), {226, 136, 160, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 12 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7662), {226, 136, 190, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1597 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7668), {226, 142, 177, 0}}, - {-1,{0}}, -#line 953 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7670), {226, 142, 176, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1109 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7674), {226, 128, 139, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1082 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7677), {226, 137, 137, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1371 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7686), {195, 152, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1769 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7698), {226, 171, 139, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 71 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7723), {195, 133, 0}}, -#line 176 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7724), {226, 149, 152, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1761 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7730), {226, 170, 191, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 2086 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7742), {226, 139, 128, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 171 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7767), {226, 148, 152, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 189 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7778), {226, 148, 156, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 705 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7800), {226, 137, 142, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 714 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7812), {208, 152, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 70 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7828), {226, 137, 138, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 7 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7841), {195, 161, 0}}, -#line 66 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7842), {226, 137, 139, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1951 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7859), {226, 134, 149, 0}}, - {-1,{0}}, -#line 1113 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7861), {226, 137, 171, 0}}, - {-1,{0}}, -#line 787 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7863), {208, 185, 0}}, - {-1,{0}}, {-1,{0}}, -#line 666 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7866), {226, 137, 179, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 179 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7876), {226, 148, 130, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1314 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7886), {195, 180, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 463 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7900), {195, 138, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1205 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str7987), {226, 139, 189, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 124 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8006), {226, 150, 179, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 342 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8032), {226, 132, 184, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1316 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8037), {208, 158, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 681 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8042), {196, 164, 0}}, -#line 1590 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8043), {226, 165, 147, 0}}, -#line 18 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8044), {195, 134, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 556 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8063), {226, 150, 170, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 622 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8084), {226, 139, 153, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 99 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8088), {208, 145, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1426 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8099), {226, 132, 140, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 186 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8104), {226, 149, 161, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1392 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8107), {226, 136, 130, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 712 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8117), {195, 142, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 315 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8129), {226, 134, 182, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 158 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8135), {226, 148, 128, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 39 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8142), {226, 169, 154, 0}}, - {-1,{0}}, -#line 1788 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8144), {226, 153, 170, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1568 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8148), {226, 159, 167, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 785 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8168), {196, 181, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1935 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8174), {95, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1563 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8241), {226, 134, 146, 0}}, -#line 257 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8242), {226, 138, 154, 0}}, -#line 27 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8243), {206, 145, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 885 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8251), {226, 134, 188, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 316 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8258), {226, 164, 189, 0}}, - {-1,{0}}, -#line 1565 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8260), {226, 135, 132, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1994 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8281), {207, 130, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1287 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8300), {226, 132, 150, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 551 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8310), {239, 172, 132, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 984 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8326), {226, 134, 153, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 542 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8340), {226, 132, 176, 0}}, - {-1,{0}}, -#line 1313 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8342), {195, 148, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2090 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8351), {209, 143, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 823 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8375), {206, 187, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1220 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8381), {226, 170, 176, 0}}, -#line 190 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8382), {226, 149, 158, 0}}, - {-1,{0}}, -#line 123 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8384), {226, 150, 189, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 40 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8391), {226, 136, 160, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 2083 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8404), {226, 168, 132, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1074 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8424), {226, 136, 135, 0}}, -#line 185 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8425), {226, 148, 164, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 532 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8438), {206, 151, 0}}, - {-1,{0}}, -#line 16 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8440), {208, 144, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 805 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8474), {208, 186, 0}}, -#line 601 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8475), {208, 179, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 893 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8485), {226, 165, 142, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 230 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8491), {195, 167, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 90 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8495), {226, 136, 150, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 702 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8506), {226, 132, 143, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1393 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8515), {208, 159, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 600 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8521), {208, 147, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 659 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8534), {226, 169, 188, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 822 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8572), {206, 155, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1321 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8627), {226, 168, 184, 0}}, - {-1,{0}}, -#line 884 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8629), {226, 134, 189, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 971 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8672), {226, 159, 188, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 797 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8677), {208, 132, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 866 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8687), {226, 165, 167, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 2084 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8700), {226, 150, 179, 0}}, -#line 1245 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8701), {226, 135, 143, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 544 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8725), {226, 133, 135, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1244 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8735), {226, 134, 155, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 13 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8745), {195, 130, 0}}, -#line 1163 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8746), {226, 129, 160, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 599 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8780), {196, 157, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 41 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8784), {226, 166, 164, 0}}, -#line 327 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8785), {226, 164, 188, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1670 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8791), {208, 169, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2106 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8796), {195, 191, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1759 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8800), {226, 171, 139, 0}}, - {-1,{0}}, {-1,{0}}, -#line 359 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8803), {226, 164, 145, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1628 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8810), {226, 167, 180, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 598 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8826), {196, 156, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 795 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8843), {208, 136, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 652 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8879), {226, 170, 167, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 781 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8922), {209, 150, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1950 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8956), {226, 134, 149, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 330 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8962), {226, 139, 142, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 549 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8972), {239, 172, 131, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2099 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str8992), {209, 151, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 389 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9015), {226, 139, 135, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 660 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9026), {226, 170, 134, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1754 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9069), {226, 170, 189, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 890 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9079), {226, 135, 134, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 82 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9085), {195, 164, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1952 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9088), {226, 135, 149, 0}}, - {-1,{0}}, -#line 1575 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9090), {226, 135, 132, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 436 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9151), {226, 135, 129, 0}}, - {-1,{0}}, {-1,{0}}, -#line 435 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9154), {226, 165, 151, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 682 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9162), {196, 165, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1613 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9186), {226, 135, 155, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 972 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9217), {226, 159, 182, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 323 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9239), {226, 138, 141, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 10 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9249), {226, 136, 190, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 695 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9268), {226, 134, 170, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1107 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9271), {226, 128, 139, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1755 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9275), {226, 171, 133, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1900 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9307), {226, 134, 160, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 429 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9320), {226, 135, 130, 0}}, -#line 428 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9321), {226, 135, 131, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 19 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9326), {195, 166, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1534 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9330), {226, 165, 169, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 331 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9349), {226, 139, 143, 0}}, - {-1,{0}}, -#line 707 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9351), {226, 129, 131, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1756 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9360), {226, 138, 134, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 974 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9414), {226, 159, 185, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 239 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9484), {194, 184, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1188 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9505), {226, 136, 137, 0}}, -#line 1777 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9506), {226, 170, 176, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 887 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9554), {226, 134, 148, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1749 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9580), {207, 181, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 31 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9627), {226, 168, 191, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 80 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9741), {195, 163, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1567 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9747), {226, 140, 137, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 889 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9751), {226, 135, 148, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1770 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9767), {226, 171, 135, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2022 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9788), {124, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1589 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9801), {226, 134, 190, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1588 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9804), {226, 165, 148, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1571 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9829), {226, 135, 130, 0}}, - {-1,{0}}, {-1,{0}}, -#line 1570 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9832), {226, 165, 149, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 25 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9836), {226, 132, 181, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 255 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9852), {226, 134, 187, 0}}, -#line 254 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9853), {226, 134, 186, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 780 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9904), {208, 134, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1376 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9936), {226, 168, 182, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 753 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9944), {226, 138, 186, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1845 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9952), {226, 137, 136, 0}}, - {-1,{0}}, {-1,{0}}, -#line 798 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9955), {209, 148, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1203 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9959), {226, 136, 140, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1443 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9963), {226, 170, 185, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 335 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9983), {226, 139, 142, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 72 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str9987), {195, 165, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 232 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str10023), {196, 137, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1562 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str10029), {226, 134, 146, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 752 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str10061), {226, 136, 171, 0}}, -#line 2060 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str10062), {226, 151, 175, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 796 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str10121), {209, 152, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 249 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str10206), {226, 156, 147, 0}}, - {-1,{0}}, -#line 2024 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str10208), {226, 137, 128, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 182 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str10219), {226, 149, 170, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1210 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str10240), {226, 167, 144, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1212 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str10244), {226, 139, 173, 0}}, -#line 1211 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str10245), {226, 139, 171, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 905 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str10278), {226, 165, 146, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 181 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str10357), {226, 148, 188, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 149 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str10395), {226, 167, 137, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2094 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str10415), {209, 139, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1757 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str10428), {226, 171, 131, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1706 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str10445), {208, 172, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1564 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str10505), {226, 135, 146, 0}}, - {-1,{0}}, -#line 28 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str10507), {206, 177, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1671 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str10528), {209, 137, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1707 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str10584), {209, 140, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 17 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str10704), {208, 176, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2092 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str10720), {197, 183, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 116 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str10791), {226, 151, 175, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 735 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str10808), {226, 133, 136, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 69 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str10847), {226, 137, 136, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1800 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str10851), {226, 138, 135, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 2042 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str10879), {226, 166, 154, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 314 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str10888), {226, 139, 159, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1938 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str10947), {226, 143, 157, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 14 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str11009), {195, 162, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1773 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str11029), {226, 170, 184, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1039 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str11047), {226, 168, 169, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 47 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str11146), {226, 166, 172, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 44 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str11165), {226, 166, 169, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 48 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str11282), {226, 166, 173, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 55 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str11366), {226, 136, 162, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1025 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str11527), {226, 165, 166, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 46 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str11565), {226, 166, 171, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1899 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str11664), {226, 134, 158, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 339 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str11720), {226, 140, 173, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1750 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str11791), {207, 149, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1072 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str11840), {226, 138, 184, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1561 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str11918), {226, 135, 165, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 867 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str12012), {226, 165, 139, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 871 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str12103), {226, 159, 168, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1629 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str12170), {226, 165, 168, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 328 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str12202), {226, 139, 158, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2105 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str12206), {209, 142, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1024 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str12288), {226, 165, 138, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 674 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str12413), {209, 138, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1573 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str12461), {226, 135, 129, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1574 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str12497), {226, 135, 128, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 673 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str12502), {208, 170, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1767 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str12651), {226, 138, 134, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 384 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str12809), {207, 157, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1917 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str12892), {197, 177, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1785 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str12985), {226, 136, 139, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 336 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str12991), {226, 139, 143, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, -#line 1916 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str13024), {197, 176, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 49 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str13061), {226, 166, 174, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 50 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str13443), {226, 166, 175, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2021 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str13643), {226, 136, 163, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 2023 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str13659), {226, 157, 152, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1566 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str13709), {226, 134, 163, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1320 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str13908), {197, 145, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, -#line 1781 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str13945), {226, 170, 186, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 45 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str14304), {226, 166, 170, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 1319 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str14364), {197, 144, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 317 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str14620), {226, 169, 136, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 43 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str15290), {226, 166, 168, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 329 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str15360), {226, 139, 159, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 333 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str15729), {226, 134, 182, 0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, - {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, -#line 334 "src/html_unescape.gperf" - {offsetof(struct entity_pool_t, entity_pool_str16000), {226, 134, 183, 0}} - }; - - if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH) - { - unsigned int key = hash_entity (str, len); - - if (key <= MAX_HASH_VALUE) - if (len == lengthtable[key]) - { - register const char *s = wordlist[key].entity + entity_pool; - - if (*str == *s && !memcmp (str + 1, s + 1, len - 1)) - return &wordlist[key]; - } - } - return 0; -} diff --git a/cmark/inlines.c b/cmark/inlines.c deleted file mode 100644 --- a/cmark/inlines.c +++ /dev/null @@ -1,1145 +0,0 @@ -#include -#include -#include - -#include "cmark_ctype.h" -#include "config.h" -#include "node.h" -#include "parser.h" -#include "references.h" -#include "cmark.h" -#include "houdini.h" -#include "utf8.h" -#include "scanners.h" -#include "inlines.h" - - -static const char *EMDASH = "\xE2\x80\x94"; -static const char *ENDASH = "\xE2\x80\x93"; -static const char *ELLIPSES = "\xE2\x80\xA6"; -static const char *LEFTDOUBLEQUOTE = "\xE2\x80\x9C"; -static const char *RIGHTDOUBLEQUOTE = "\xE2\x80\x9D"; -static const char *LEFTSINGLEQUOTE = "\xE2\x80\x98"; -static const char *RIGHTSINGLEQUOTE = "\xE2\x80\x99"; - - -// Macros for creating various kinds of simple. -#define make_str(s) make_literal(CMARK_NODE_TEXT, s) -#define make_code(s) make_literal(CMARK_NODE_CODE, s) -#define make_raw_html(s) make_literal(CMARK_NODE_INLINE_HTML, s) -#define make_linebreak() make_simple(CMARK_NODE_LINEBREAK) -#define make_softbreak() make_simple(CMARK_NODE_SOFTBREAK) -#define make_emph() make_simple(CMARK_NODE_EMPH) -#define make_strong() make_simple(CMARK_NODE_STRONG) - -typedef struct delimiter { - struct delimiter *previous; - struct delimiter *next; - cmark_node *inl_text; - int position; - unsigned char delim_char; - bool can_open; - bool can_close; - bool active; -} delimiter; - -typedef struct { - cmark_chunk input; - int pos; - cmark_reference_map *refmap; - delimiter *last_delim; -} subject; - -static delimiter* -S_insert_emph(subject *subj, delimiter *opener, delimiter *closer); - -static int parse_inline(subject* subj, cmark_node * parent, int options); - -static void subject_from_buf(subject *e, cmark_strbuf *buffer, - cmark_reference_map *refmap); -static int subject_find_special_char(subject *subj, int options); - -static unsigned char *cmark_clean_autolink(cmark_chunk *url, int is_email) -{ - cmark_strbuf buf = GH_BUF_INIT; - - cmark_chunk_trim(url); - - if (url->len == 0) - return NULL; - - if (is_email) - cmark_strbuf_puts(&buf, "mailto:"); - - houdini_unescape_html_f(&buf, url->data, url->len); - return cmark_strbuf_detach(&buf); -} - -static inline cmark_node *make_link(cmark_node *label, unsigned char *url, unsigned char *title) -{ - cmark_node* e = (cmark_node *)calloc(1, sizeof(*e)); - if(e != NULL) { - e->type = CMARK_NODE_LINK; - e->first_child = label; - e->last_child = label; - e->as.link.url = url; - e->as.link.title = title; - e->next = NULL; - label->parent = e; - } - return e; -} - -static inline cmark_node* make_autolink(cmark_node* label, cmark_chunk url, int is_email) -{ - return make_link(label, cmark_clean_autolink(&url, is_email), NULL); -} - -// Create an inline with a literal string value. -static inline cmark_node* make_literal(cmark_node_type t, cmark_chunk s) -{ - cmark_node * e = (cmark_node *)calloc(1, sizeof(*e)); - if(e != NULL) { - e->type = t; - e->as.literal = s; - e->next = NULL; - e->prev = NULL; - e->parent = NULL; - e->first_child = NULL; - e->last_child = NULL; - // These fields aren't used for inlines: - e->start_line = 0; - e->start_column = 0; - e->end_line = 0; - } - return e; -} - -// Create an inline with no value. -static inline cmark_node* make_simple(cmark_node_type t) -{ - cmark_node* e = (cmark_node *)calloc(1, sizeof(*e)); - if(e != NULL) { - e->type = t; - e->next = NULL; - e->prev = NULL; - e->parent = NULL; - e->first_child = NULL; - e->last_child = NULL; - // These fields aren't used for inlines: - e->start_line = 0; - e->start_column = 0; - e->end_line = 0; - } - return e; -} - -static unsigned char *bufdup(const unsigned char *buf) -{ - unsigned char *new_buf = NULL; - - if (buf) { - int len = strlen((char *)buf); - new_buf = (unsigned char *)calloc(len + 1, sizeof(*new_buf)); - if(new_buf != NULL) { - memcpy(new_buf, buf, len + 1); - } - } - - return new_buf; -} - -static void subject_from_buf(subject *e, cmark_strbuf *buffer, - cmark_reference_map *refmap) -{ - e->input.data = buffer->ptr; - e->input.len = buffer->size; - e->input.alloc = 0; - e->pos = 0; - e->refmap = refmap; - e->last_delim = NULL; - - cmark_chunk_rtrim(&e->input); -} - -static inline int isbacktick(int c) -{ - return (c == '`'); -} - -static inline unsigned char peek_char(subject *subj) -{ - return (subj->pos < subj->input.len) ? subj->input.data[subj->pos] : 0; -} - -static inline unsigned char peek_at(subject *subj, int pos) -{ - return subj->input.data[pos]; -} - -// Return true if there are more characters in the subject. -static inline int is_eof(subject* subj) -{ - return (subj->pos >= subj->input.len); -} - -// Advance the subject. Doesn't check for eof. -#define advance(subj) (subj)->pos += 1 - -// Take characters while a predicate holds, and return a string. -static inline cmark_chunk take_while(subject* subj, int (*f)(int)) -{ - unsigned char c; - int startpos = subj->pos; - int len = 0; - - while ((c = peek_char(subj)) && (*f)(c)) { - advance(subj); - len++; - } - - return cmark_chunk_dup(&subj->input, startpos, len); -} - -// Try to process a backtick code span that began with a -// span of ticks of length openticklength length (already -// parsed). Return 0 if you don't find matching closing -// backticks, otherwise return the position in the subject -// after the closing backticks. -static int scan_to_closing_backticks(subject* subj, int openticklength) -{ - // read non backticks - unsigned char c; - while ((c = peek_char(subj)) && c != '`') { - advance(subj); - } - if (is_eof(subj)) { - return 0; // did not find closing ticks, return 0 - } - int numticks = 0; - while (peek_char(subj) == '`') { - advance(subj); - numticks++; - } - if (numticks != openticklength) { - return(scan_to_closing_backticks(subj, openticklength)); - } - return (subj->pos); -} - -// Parse backtick code section or raw backticks, return an inline. -// Assumes that the subject has a backtick at the current position. -static cmark_node* handle_backticks(subject *subj) -{ - cmark_chunk openticks = take_while(subj, isbacktick); - int startpos = subj->pos; - int endpos = scan_to_closing_backticks(subj, openticks.len); - - if (endpos == 0) { // not found - subj->pos = startpos; // rewind - return make_str(openticks); - } else { - cmark_strbuf buf = GH_BUF_INIT; - - cmark_strbuf_set(&buf, subj->input.data + startpos, endpos - startpos - openticks.len); - cmark_strbuf_trim(&buf); - cmark_strbuf_normalize_whitespace(&buf); - - return make_code(cmark_chunk_buf_detach(&buf)); - } -} - -// Scan ***, **, or * and return number scanned, or 0. -// Advances position. -static int -scan_delims(subject* subj, unsigned char c, bool * can_open, bool * can_close) -{ - int numdelims = 0; - int before_char_pos; - int32_t after_char = 0; - int32_t before_char = 0; - int len; - bool left_flanking, right_flanking; - - if (subj->pos == 0) { - before_char = 10; - } else { - before_char_pos = subj->pos - 1; - // walk back to the beginning of the UTF_8 sequence: - while (peek_at(subj, before_char_pos) >> 6 == 2 && - before_char_pos > 0) { - before_char_pos -= 1; - } - len = utf8proc_iterate(subj->input.data + before_char_pos, - subj->pos - before_char_pos, &before_char); - if (len == -1) { - before_char = 10; - } - } - - if (c == '\'' || c == '"') { - numdelims++; - advance(subj); // limit to 1 delim for quotes - } else { - while (peek_char(subj) == c) { - numdelims++; - advance(subj); - } - } - - len = utf8proc_iterate(subj->input.data + subj->pos, - subj->input.len - subj->pos, &after_char); - if (len == -1) { - after_char = 10; - } - left_flanking = numdelims > 0 && !utf8proc_is_space(after_char) && - !(utf8proc_is_punctuation(after_char) && - !utf8proc_is_space(before_char) && - !utf8proc_is_punctuation(before_char)); - right_flanking = numdelims > 0 && !utf8proc_is_space(before_char) && - !(utf8proc_is_punctuation(before_char) && - !utf8proc_is_space(after_char) && - !utf8proc_is_punctuation(after_char)); - if (c == '_') { - *can_open = left_flanking && !right_flanking; - *can_close = right_flanking && !left_flanking; - } else if (c == '\'' || c == '"') { - *can_open = left_flanking && !right_flanking; - *can_close = right_flanking; - } else { - *can_open = left_flanking; - *can_close = right_flanking; - } - return numdelims; -} - -/* -static void print_delimiters(subject *subj) -{ - delimiter *delim; - delim = subj->last_delim; - while (delim != NULL) { - printf("Item at %p: %d %d %d next(%p) prev(%p)\n", - delim, delim->delim_char, - delim->can_open, delim->can_close, - delim->next, delim->previous); - delim = delim->previous; - } -} -*/ - -static void remove_delimiter(subject *subj, delimiter *delim) -{ - if (delim == NULL) return; - if (delim->next == NULL) { - // end of list: - assert(delim == subj->last_delim); - subj->last_delim = delim->previous; - } else { - delim->next->previous = delim->previous; - } - if (delim->previous != NULL) { - delim->previous->next = delim->next; - } - free(delim); -} - -static void push_delimiter(subject *subj, unsigned char c, bool can_open, - bool can_close, cmark_node *inl_text) -{ - delimiter *delim = - (delimiter*)malloc(sizeof(delimiter)); - if (delim == NULL) { - return; - } - delim->delim_char = c; - delim->can_open = can_open; - delim->can_close = can_close; - delim->inl_text = inl_text; - delim->previous = subj->last_delim; - delim->next = NULL; - if (delim->previous != NULL) { - delim->previous->next = delim; - } - delim->position = subj->pos; - delim->active = true; - subj->last_delim = delim; -} - -// Assumes the subject has a c at the current position. -static cmark_node* handle_delim(subject* subj, unsigned char c, bool smart) -{ - int numdelims; - cmark_node * inl_text; - bool can_open, can_close; - cmark_chunk contents; - - numdelims = scan_delims(subj, c, &can_open, &can_close); - - if (c == '\'' && smart) { - contents = cmark_chunk_literal(RIGHTSINGLEQUOTE); - } else if (c == '"' && smart) { - contents = cmark_chunk_literal(can_close ? RIGHTDOUBLEQUOTE : LEFTDOUBLEQUOTE); - } else { - contents = cmark_chunk_dup(&subj->input, subj->pos - numdelims, numdelims); - } - - inl_text = make_str(contents); - - if ((can_open || can_close) && - (!(c == '\'' || c == '"') || smart)) { - push_delimiter(subj, c, can_open, can_close, inl_text); - } - - return inl_text; -} - -// Assumes we have a hyphen at the current position. -static cmark_node* handle_hyphen(subject* subj, bool smart) -{ - advance(subj); - if (smart && peek_char(subj) == '-') { - advance(subj); - if (peek_char(subj) == '-') { - advance(subj); - return make_str(cmark_chunk_literal(EMDASH)); - } else { - return make_str(cmark_chunk_literal(ENDASH)); - } - } else { - return make_str(cmark_chunk_literal("-")); - } -} - -// Assumes we have a period at the current position. -static cmark_node* handle_period(subject* subj, bool smart) -{ - advance(subj); - if (smart && peek_char(subj) == '.') { - advance(subj); - if (peek_char(subj) == '.') { - advance(subj); - return make_str(cmark_chunk_literal(ELLIPSES)); - } else { - return make_str(cmark_chunk_literal("..")); - } - } else { - return make_str(cmark_chunk_literal(".")); - } -} - -static void process_emphasis(subject *subj, delimiter *start_delim) -{ - delimiter *closer = subj->last_delim; - delimiter *opener; - - // move back to first relevant delim. - while (closer != NULL && closer->previous != start_delim) { - closer = closer->previous; - } - - // now move forward, looking for closers, and handling each - while (closer != NULL) { - if (closer->can_close && - (closer->delim_char == '*' || closer->delim_char == '_' || - closer->delim_char == '"' || closer->delim_char == '\'')) { - // Now look backwards for first matching opener: - opener = closer->previous; - while (opener != NULL && opener != start_delim) { - if (opener->delim_char == closer->delim_char && - opener->can_open) { - break; - } - opener = opener->previous; - } - if (closer->delim_char == '*' || closer->delim_char == '_') { - if (opener != NULL && opener != start_delim) { - closer = S_insert_emph(subj, opener, closer); - } else { - closer = closer->next; - } - } else if (closer->delim_char == '\'') { - cmark_chunk_free(&closer->inl_text->as.literal); - closer->inl_text->as.literal = - cmark_chunk_literal(RIGHTSINGLEQUOTE); - if (opener != NULL && opener != start_delim) { - cmark_chunk_free(&opener->inl_text->as.literal); - opener->inl_text->as.literal = - cmark_chunk_literal(LEFTSINGLEQUOTE); - } - closer = closer->next; - } else if (closer->delim_char == '"') { - cmark_chunk_free(&closer->inl_text->as.literal); - closer->inl_text->as.literal = - cmark_chunk_literal(RIGHTDOUBLEQUOTE); - if (opener != NULL && opener != start_delim) { - cmark_chunk_free(&opener->inl_text->as.literal); - opener->inl_text->as.literal = - cmark_chunk_literal(LEFTDOUBLEQUOTE); - } - closer = closer->next; - } - } else { - closer = closer->next; - } - } - // free all delimiters in list until start_delim: - while (subj->last_delim != start_delim) { - remove_delimiter(subj, subj->last_delim); - } -} - -static delimiter* -S_insert_emph(subject *subj, delimiter *opener, delimiter *closer) -{ - delimiter *delim, *tmp_delim; - int use_delims; - cmark_node *opener_inl = opener->inl_text; - cmark_node *closer_inl = closer->inl_text; - int opener_num_chars = opener_inl->as.literal.len; - int closer_num_chars = closer_inl->as.literal.len; - cmark_node *tmp, *emph, *first_child, *last_child; - - // calculate the actual number of characters used from this closer - if (closer_num_chars < 3 || opener_num_chars < 3) { - use_delims = closer_num_chars <= opener_num_chars ? - closer_num_chars : opener_num_chars; - } else { // closer and opener both have >= 3 characters - use_delims = closer_num_chars % 2 == 0 ? 2 : 1; - } - - // remove used characters from associated inlines. - opener_num_chars -= use_delims; - closer_num_chars -= use_delims; - opener_inl->as.literal.len = opener_num_chars; - closer_inl->as.literal.len = closer_num_chars; - - // free delimiters between opener and closer - delim = closer->previous; - while (delim != NULL && delim != opener) { - tmp_delim = delim->previous; - remove_delimiter(subj, delim); - delim = tmp_delim; - } - - first_child = opener_inl->next; - last_child = closer_inl->prev; - - // if opener has 0 characters, remove it and its associated inline - if (opener_num_chars == 0) { - // replace empty opener inline with emph - cmark_chunk_free(&(opener_inl->as.literal)); - emph = opener_inl; - emph->type = use_delims == 1 ? NODE_EMPH : NODE_STRONG; - // remove opener from list - remove_delimiter(subj, opener); - } else { - // create new emph or strong, and splice it in to our inlines - // between the opener and closer - emph = use_delims == 1 ? make_emph() : make_strong(); - emph->parent = opener_inl->parent; - emph->prev = opener_inl; - opener_inl->next = emph; - } - - // push children below emph - emph->next = closer_inl; - closer_inl->prev = emph; - emph->first_child = first_child; - emph->last_child = last_child; - - // fix children pointers - first_child->prev = NULL; - last_child->next = NULL; - for (tmp = first_child; tmp != NULL; tmp = tmp->next) { - tmp->parent = emph; - } - - // if closer has 0 characters, remove it and its associated inline - if (closer_num_chars == 0) { - // remove empty closer inline - cmark_node_free(closer_inl); - // remove closer from list - tmp_delim = closer->next; - remove_delimiter(subj, closer); - closer = tmp_delim; - } - - return closer; -} - -// Parse backslash-escape or just a backslash, returning an inline. -static cmark_node* handle_backslash(subject *subj) -{ - advance(subj); - unsigned char nextchar = peek_char(subj); - if (cmark_ispunct(nextchar)) { // only ascii symbols and newline can be escaped - advance(subj); - return make_str(cmark_chunk_dup(&subj->input, subj->pos - 1, 1)); - } else if (nextchar == '\n') { - advance(subj); - return make_linebreak(); - } else { - return make_str(cmark_chunk_literal("\\")); - } -} - -// Parse an entity or a regular "&" string. -// Assumes the subject has an '&' character at the current position. -static cmark_node* handle_entity(subject* subj) -{ - cmark_strbuf ent = GH_BUF_INIT; - size_t len; - - advance(subj); - - len = houdini_unescape_ent(&ent, - subj->input.data + subj->pos, - subj->input.len - subj->pos - ); - - if (len == 0) - return make_str(cmark_chunk_literal("&")); - - subj->pos += len; - return make_str(cmark_chunk_buf_detach(&ent)); -} - -// Like make_str, but parses entities. -// Returns an inline sequence consisting of str and entity elements. -static cmark_node *make_str_with_entities(cmark_chunk *content) -{ - cmark_strbuf unescaped = GH_BUF_INIT; - - if (houdini_unescape_html(&unescaped, content->data, (size_t)content->len)) { - return make_str(cmark_chunk_buf_detach(&unescaped)); - } else { - return make_str(*content); - } -} - -// Clean a URL: remove surrounding whitespace and surrounding <>, -// and remove \ that escape punctuation. -unsigned char *cmark_clean_url(cmark_chunk *url) -{ - cmark_strbuf buf = GH_BUF_INIT; - - cmark_chunk_trim(url); - - if (url->len == 0) - return NULL; - - if (url->data[0] == '<' && url->data[url->len - 1] == '>') { - houdini_unescape_html_f(&buf, url->data + 1, url->len - 2); - } else { - houdini_unescape_html_f(&buf, url->data, url->len); - } - - cmark_strbuf_unescape(&buf); - return cmark_strbuf_detach(&buf); -} - -unsigned char *cmark_clean_title(cmark_chunk *title) -{ - cmark_strbuf buf = GH_BUF_INIT; - unsigned char first, last; - - if (title->len == 0) - return NULL; - - first = title->data[0]; - last = title->data[title->len - 1]; - - // remove surrounding quotes if any: - if ((first == '\'' && last == '\'') || - (first == '(' && last == ')') || - (first == '"' && last == '"')) { - houdini_unescape_html_f(&buf, title->data + 1, title->len - 2); - } else { - houdini_unescape_html_f(&buf, title->data, title->len); - } - - cmark_strbuf_unescape(&buf); - return cmark_strbuf_detach(&buf); -} - -// Parse an autolink or HTML tag. -// Assumes the subject has a '<' character at the current position. -static cmark_node* handle_pointy_brace(subject* subj) -{ - int matchlen = 0; - cmark_chunk contents; - - advance(subj); // advance past first < - - // first try to match a URL autolink - matchlen = scan_autolink_uri(&subj->input, subj->pos); - if (matchlen > 0) { - contents = cmark_chunk_dup(&subj->input, subj->pos, matchlen - 1); - subj->pos += matchlen; - - return make_autolink( - make_str_with_entities(&contents), - contents, 0 - ); - } - - // next try to match an email autolink - matchlen = scan_autolink_email(&subj->input, subj->pos); - if (matchlen > 0) { - contents = cmark_chunk_dup(&subj->input, subj->pos, matchlen - 1); - subj->pos += matchlen; - - return make_autolink( - make_str_with_entities(&contents), - contents, 1 - ); - } - - // finally, try to match an html tag - matchlen = scan_html_tag(&subj->input, subj->pos); - if (matchlen > 0) { - contents = cmark_chunk_dup(&subj->input, subj->pos - 1, matchlen + 1); - subj->pos += matchlen; - return make_raw_html(contents); - } - - // if nothing matches, just return the opening <: - return make_str(cmark_chunk_literal("<")); -} - -// Parse a link label. Returns 1 if successful. -// Note: unescaped brackets are not allowed in labels. -// The label begins with `[` and ends with the first `]` character -// encountered. Backticks in labels do not start code spans. -static int link_label(subject* subj, cmark_chunk *raw_label) -{ - int startpos = subj->pos; - int length = 0; - unsigned char c; - - // advance past [ - if (peek_char(subj) == '[') { - advance(subj); - } else { - return 0; - } - - while ((c = peek_char(subj)) && c != '[' && c != ']') { - if (c == '\\') { - advance(subj); - length++; - if (cmark_ispunct(peek_char(subj))) { - advance(subj); - length++; - } - } else { - advance(subj); - length++; - } - if (length > MAX_LINK_LABEL_LENGTH) { - goto noMatch; - } - } - - if (c == ']') { // match found - *raw_label = cmark_chunk_dup(&subj->input, startpos + 1, subj->pos - (startpos + 1)); - advance(subj); // advance past ] - return 1; - } - -noMatch: - subj->pos = startpos; // rewind - return 0; - -} - -// Return a link, an image, or a literal close bracket. -static cmark_node* handle_close_bracket(subject* subj, cmark_node *parent) -{ - int initial_pos; - int starturl, endurl, starttitle, endtitle, endall; - int n; - int sps; - cmark_reference *ref; - bool is_image = false; - cmark_chunk url_chunk, title_chunk; - unsigned char *url, *title; - delimiter *opener; - cmark_node *link_text; - cmark_node *inl; - cmark_chunk raw_label; - int found_label; - - advance(subj); // advance past ] - initial_pos = subj->pos; - - // look through list of delimiters for a [ or ! - opener = subj->last_delim; - while (opener) { - if (opener->delim_char == '[' || opener->delim_char == '!') { - break; - } - opener = opener->previous; - } - - if (opener == NULL) { - return make_str(cmark_chunk_literal("]")); - } - - if (!opener->active) { - // take delimiter off stack - remove_delimiter(subj, opener); - return make_str(cmark_chunk_literal("]")); - } - - // If we got here, we matched a potential link/image text. - is_image = opener->delim_char == '!'; - link_text = opener->inl_text->next; - - // Now we check to see if it's a link/image. - - // First, look for an inline link. - if (peek_char(subj) == '(' && - ((sps = scan_spacechars(&subj->input, subj->pos + 1)) > -1) && - ((n = scan_link_url(&subj->input, subj->pos + 1 + sps)) > -1)) { - - // try to parse an explicit link: - starturl = subj->pos + 1 + sps; // after ( - endurl = starturl + n; - starttitle = endurl + scan_spacechars(&subj->input, endurl); - - // ensure there are spaces btw url and title - endtitle = (starttitle == endurl) ? starttitle : - starttitle + scan_link_title(&subj->input, starttitle); - - endall = endtitle + scan_spacechars(&subj->input, endtitle); - - if (peek_at(subj, endall) == ')') { - subj->pos = endall + 1; - - url_chunk = cmark_chunk_dup(&subj->input, starturl, endurl - starturl); - title_chunk = cmark_chunk_dup(&subj->input, starttitle, endtitle - starttitle); - url = cmark_clean_url(&url_chunk); - title = cmark_clean_title(&title_chunk); - cmark_chunk_free(&url_chunk); - cmark_chunk_free(&title_chunk); - goto match; - - } else { - goto noMatch; - } - } - - // Next, look for a following [link label] that matches in refmap. - // skip spaces - subj->pos = subj->pos + scan_spacechars(&subj->input, subj->pos); - raw_label = cmark_chunk_literal(""); - found_label = link_label(subj, &raw_label); - if (!found_label || raw_label.len == 0) { - cmark_chunk_free(&raw_label); - raw_label = cmark_chunk_dup(&subj->input, opener->position, - initial_pos - opener->position - 1); - } - - if (!found_label) { - // If we have a shortcut reference link, back up - // to before the spacse we skipped. - subj->pos = initial_pos; - } - - ref = cmark_reference_lookup(subj->refmap, &raw_label); - cmark_chunk_free(&raw_label); - - if (ref != NULL) { // found - url = bufdup(ref->url); - title = bufdup(ref->title); - goto match; - } else { - goto noMatch; - } - -noMatch: - // If we fall through to here, it means we didn't match a link: - remove_delimiter(subj, opener); // remove this opener from delimiter list - subj->pos = initial_pos; - return make_str(cmark_chunk_literal("]")); - -match: - inl = opener->inl_text; - inl->type = is_image ? NODE_IMAGE : NODE_LINK; - cmark_chunk_free(&inl->as.literal); - inl->first_child = link_text; - process_emphasis(subj, opener->previous); - inl->as.link.url = url; - inl->as.link.title = title; - inl->next = NULL; - if (link_text) { - cmark_node *tmp; - link_text->prev = NULL; - for (tmp = link_text; tmp->next != NULL; tmp = tmp->next) { - tmp->parent = inl; - } - tmp->parent = inl; - inl->last_child = tmp; - } - parent->last_child = inl; - - // process_emphasis will remove this delimiter and all later ones. - // Now, if we have a link, we also want to deactivate earlier link - // delimiters. (This code can be removed if we decide to allow links - // inside links.) - if (!is_image) { - opener = subj->last_delim; - while (opener != NULL) { - if (opener->delim_char == '[') { - if (!opener->active) { - break; - } else { - opener->active = false; - } - } - opener = opener->previous; - } - } - - return NULL; -} - -// Parse a hard or soft linebreak, returning an inline. -// Assumes the subject has a newline at the current position. -static cmark_node* handle_newline(subject *subj) -{ - int nlpos = subj->pos; - // skip over newline - advance(subj); - // skip spaces at beginning of line - while (peek_char(subj) == ' ') { - advance(subj); - } - if (nlpos > 1 && - peek_at(subj, nlpos - 1) == ' ' && - peek_at(subj, nlpos - 2) == ' ') { - return make_linebreak(); - } else { - return make_softbreak(); - } -} - -static int subject_find_special_char(subject *subj, int options) -{ - // "\n\\`&_*[]pos + 1; - - while (n < subj->input.len) { - if (SPECIAL_CHARS[subj->input.data[n]]) - return n; - if (options & CMARK_OPT_SMART && - SMART_PUNCT_CHARS[subj->input.data[n]]) - return n; - n++; - } - - return subj->input.len; -} - -// Parse an inline, advancing subject, and add it as a child of parent. -// Return 0 if no inline can be parsed, 1 otherwise. -static int parse_inline(subject* subj, cmark_node * parent, int options) -{ - cmark_node* new_inl = NULL; - cmark_chunk contents; - unsigned char c; - int endpos; - c = peek_char(subj); - if (c == 0) { - return 0; - } - switch(c) { - case '\n': - new_inl = handle_newline(subj); - break; - case '`': - new_inl = handle_backticks(subj); - break; - case '\\': - new_inl = handle_backslash(subj); - break; - case '&': - new_inl = handle_entity(subj); - break; - case '<': - new_inl = handle_pointy_brace(subj); - break; - case '*': - case '_': - case '\'': - case '"': - new_inl = handle_delim(subj, c, options & CMARK_OPT_SMART); - break; - case '-': - new_inl = handle_hyphen(subj, options & CMARK_OPT_SMART); - break; - case '.': - new_inl = handle_period(subj, options & CMARK_OPT_SMART); - break; - case '[': - advance(subj); - new_inl = make_str(cmark_chunk_literal("[")); - push_delimiter(subj, '[', true, false, new_inl); - break; - case ']': - new_inl = handle_close_bracket(subj, parent); - break; - case '!': - advance(subj); - if (peek_char(subj) == '[') { - advance(subj); - new_inl = make_str(cmark_chunk_literal("![")); - push_delimiter(subj, '!', false, true, new_inl); - } else { - new_inl = make_str(cmark_chunk_literal("!")); - } - break; - default: - endpos = subject_find_special_char(subj, options); - contents = cmark_chunk_dup(&subj->input, subj->pos, endpos - subj->pos); - subj->pos = endpos; - - // if we're at a newline, strip trailing spaces. - if (peek_char(subj) == '\n') { - cmark_chunk_rtrim(&contents); - } - - new_inl = make_str(contents); - } - if (new_inl != NULL) { - cmark_node_append_child(parent, new_inl); - } - - return 1; -} - -// Parse inlines from parent's string_content, adding as children of parent. -extern void cmark_parse_inlines(cmark_node* parent, cmark_reference_map *refmap, int options) -{ - subject subj; - subject_from_buf(&subj, &parent->string_content, refmap); - - while (!is_eof(&subj) && parse_inline(&subj, parent, options)) ; - - process_emphasis(&subj, NULL); -} - -// Parse zero or more space characters, including at most one newline. -static void spnl(subject* subj) -{ - bool seen_newline = false; - while (peek_char(subj) == ' ' || - (!seen_newline && - (seen_newline = peek_char(subj) == '\n'))) { - advance(subj); - } -} - -// Parse reference. Assumes string begins with '[' character. -// Modify refmap if a reference is encountered. -// Return 0 if no reference found, otherwise position of subject -// after reference is parsed. -int cmark_parse_reference_inline(cmark_strbuf *input, cmark_reference_map *refmap) -{ - subject subj; - - cmark_chunk lab; - cmark_chunk url; - cmark_chunk title; - - int matchlen = 0; - int beforetitle; - - subject_from_buf(&subj, input, NULL); - - // parse label: - if (!link_label(&subj, &lab)) - return 0; - - // colon: - if (peek_char(&subj) == ':') { - advance(&subj); - } else { - return 0; - } - - // parse link url: - spnl(&subj); - matchlen = scan_link_url(&subj.input, subj.pos); - if (matchlen) { - url = cmark_chunk_dup(&subj.input, subj.pos, matchlen); - subj.pos += matchlen; - } else { - return 0; - } - - // parse optional link_title - beforetitle = subj.pos; - spnl(&subj); - matchlen = scan_link_title(&subj.input, subj.pos); - if (matchlen) { - title = cmark_chunk_dup(&subj.input, subj.pos, matchlen); - subj.pos += matchlen; - } else { - subj.pos = beforetitle; - title = cmark_chunk_literal(""); - } - // parse final spaces and newline: - while (peek_char(&subj) == ' ') { - advance(&subj); - } - if (peek_char(&subj) == '\n') { - advance(&subj); - } else if (peek_char(&subj) != 0) { - return 0; - } - // insert reference into refmap - cmark_reference_create(refmap, &lab, &url, &title); - return subj.pos; -} diff --git a/cmark/inlines.h b/cmark/inlines.h deleted file mode 100644 --- a/cmark/inlines.h +++ /dev/null @@ -1,19 +0,0 @@ -#ifndef CMARK_INLINES_H -#define CMARK_INLINES_H - -#ifdef __cplusplus -extern "C" { -#endif - -unsigned char *cmark_clean_url(cmark_chunk *url); -unsigned char *cmark_clean_title(cmark_chunk *title); - -void cmark_parse_inlines(cmark_node* parent, cmark_reference_map *refmap, int options); - -int cmark_parse_reference_inline(cmark_strbuf *input, cmark_reference_map *refmap); - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/cmark/iterator.c b/cmark/iterator.c deleted file mode 100644 --- a/cmark/iterator.c +++ /dev/null @@ -1,146 +0,0 @@ -#include -#include - -#include "config.h" -#include "node.h" -#include "cmark.h" -#include "iterator.h" - -static const int S_leaf_mask = - (1 << CMARK_NODE_HTML) | - (1 << CMARK_NODE_HRULE) | - (1 << CMARK_NODE_CODE_BLOCK) | - (1 << CMARK_NODE_TEXT) | - (1 << CMARK_NODE_SOFTBREAK) | - (1 << CMARK_NODE_LINEBREAK) | - (1 << CMARK_NODE_CODE) | - (1 << CMARK_NODE_INLINE_HTML); - -cmark_iter* -cmark_iter_new(cmark_node *root) -{ - if (root == NULL) { - return NULL; - } - cmark_iter *iter = (cmark_iter*)malloc(sizeof(cmark_iter)); - if (iter == NULL) { - return NULL; - } - iter->root = root; - iter->cur.ev_type = CMARK_EVENT_NONE; - iter->cur.node = NULL; - iter->next.ev_type = CMARK_EVENT_ENTER; - iter->next.node = root; - return iter; -} - -void -cmark_iter_free(cmark_iter *iter) -{ - free(iter); -} - -static bool -S_is_leaf(cmark_node *node) -{ - return (1 << node->type) & S_leaf_mask; -} - -cmark_event_type -cmark_iter_next(cmark_iter *iter) -{ - cmark_event_type ev_type = iter->next.ev_type; - cmark_node *node = iter->next.node; - - iter->cur.ev_type = ev_type; - iter->cur.node = node; - - if (ev_type == CMARK_EVENT_DONE) { - return ev_type; - } - - /* roll forward to next item, setting both fields */ - if (ev_type == CMARK_EVENT_ENTER && !S_is_leaf(node)) { - if (node->first_child == NULL) { - /* stay on this node but exit */ - iter->next.ev_type = CMARK_EVENT_EXIT; - } else { - iter->next.ev_type = CMARK_EVENT_ENTER; - iter->next.node = node->first_child; - } - } else if (node == iter->root) { - /* don't move past root */ - iter->next.ev_type = CMARK_EVENT_DONE; - iter->next.node = NULL; - } else if (node->next) { - iter->next.ev_type = CMARK_EVENT_ENTER; - iter->next.node = node->next; - } else if (node->parent) { - iter->next.ev_type = CMARK_EVENT_EXIT; - iter->next.node = node->parent; - } else { - assert(false); - iter->next.ev_type = CMARK_EVENT_DONE; - iter->next.node = NULL; - } - - return ev_type; -} - -void -cmark_iter_reset(cmark_iter *iter, cmark_node *current, - cmark_event_type event_type) -{ - iter->next.ev_type = event_type; - iter->next.node = current; - cmark_iter_next(iter); -} - -cmark_node* -cmark_iter_get_node(cmark_iter *iter) -{ - return iter->cur.node; -} - -cmark_event_type -cmark_iter_get_event_type(cmark_iter *iter) -{ - return iter->cur.ev_type; -} - -cmark_node* -cmark_iter_get_root(cmark_iter *iter) -{ - return iter->root; -} - - -void cmark_consolidate_text_nodes(cmark_node *root) -{ - cmark_iter *iter = cmark_iter_new(root); - cmark_strbuf buf = GH_BUF_INIT; - cmark_event_type ev_type; - cmark_node *cur, *tmp, *next; - - while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { - cur = cmark_iter_get_node(iter); - if (ev_type == CMARK_EVENT_ENTER && - cur->type == CMARK_NODE_TEXT && - cur->next && - cur->next->type == CMARK_NODE_TEXT) { - cmark_strbuf_clear(&buf); - cmark_strbuf_puts(&buf, cmark_node_get_literal(cur)); - tmp = cur->next; - while (tmp && tmp->type == CMARK_NODE_TEXT) { - cmark_iter_next(iter); // advance pointer - cmark_strbuf_puts(&buf, cmark_node_get_literal(tmp)); - next = tmp->next; - cmark_node_free(tmp); - tmp = next; - } - cmark_node_set_literal(cur, (char *)cmark_strbuf_detach(&buf)); - } - } - - cmark_iter_free(iter); -} diff --git a/cmark/iterator.h b/cmark/iterator.h deleted file mode 100644 --- a/cmark/iterator.h +++ /dev/null @@ -1,25 +0,0 @@ -#ifndef CMARK_ITERATOR_H -#define CMARK_ITERATOR_H - -#ifdef __cplusplus -extern "C" { -#endif - -#include "cmark.h" - -typedef struct { - cmark_event_type ev_type; - cmark_node *node; -} cmark_iter_state; - -struct cmark_iter { - cmark_node *root; - cmark_iter_state cur; - cmark_iter_state next; -}; - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/cmark/main.c b/cmark/main.c deleted file mode 100644 --- a/cmark/main.c +++ /dev/null @@ -1,166 +0,0 @@ -#include -#include -#include -#include -#include "config.h" -#include "cmark.h" -#include "debug.h" -#include "bench.h" - -#if defined(_WIN32) && !defined(__CYGWIN__) -#include -#include -#endif - -typedef enum { - FORMAT_NONE, - FORMAT_HTML, - FORMAT_XML, - FORMAT_MAN, -} writer_format; - -void print_usage() -{ - printf("Usage: cmark [FILE*]\n"); - printf("Options:\n"); - printf(" --to, -t FORMAT Specify output format (html, xml, man)\n"); - printf(" --sourcepos Include source position attribute\n"); - printf(" --hardbreaks Treat newlines as hard line breaks\n"); - printf(" --smart Use smart punctuation\n"); - printf(" --normalize Consolidate adjacent text nodes\n"); - printf(" --help, -h Print usage information\n"); - printf(" --version Print version\n"); -} - -static void print_document(cmark_node *document, writer_format writer, - int options) -{ - char *result; - switch (writer) { - case FORMAT_HTML: - result = cmark_render_html(document, options); - break; - case FORMAT_XML: - result = cmark_render_xml(document, options); - break; - case FORMAT_MAN: - result = cmark_render_man(document, options); - break; - default: - fprintf(stderr, "Unknown format %d\n", writer); - exit(1); - } - printf("%s", result); - free(result); -} - -int main(int argc, char *argv[]) -{ - int i, numfps = 0; - int *files; - char buffer[4096]; - cmark_parser *parser; - size_t bytes; - cmark_node *document; - writer_format writer = FORMAT_HTML; - int options = CMARK_OPT_DEFAULT; - -#if defined(_WIN32) && !defined(__CYGWIN__) - _setmode(_fileno(stdout), _O_BINARY); -#endif - - files = (int *)malloc(argc * sizeof(*files)); - - for (i = 1; i < argc; i++) { - if (strcmp(argv[i], "--version") == 0) { - printf("cmark %s", CMARK_VERSION_STRING); - printf(" - CommonMark converter (c) 2014 John MacFarlane\n"); - exit(0); - } else if (strcmp(argv[i], "--sourcepos") == 0) { - options |= CMARK_OPT_SOURCEPOS; - } else if (strcmp(argv[i], "--hardbreaks") == 0) { - options |= CMARK_OPT_HARDBREAKS; - } else if (strcmp(argv[i], "--smart") == 0) { - options |= CMARK_OPT_SMART; - } else if (strcmp(argv[i], "--normalize") == 0) { - options |= CMARK_OPT_NORMALIZE; - } else if ((strcmp(argv[i], "--help") == 0) || - (strcmp(argv[i], "-h") == 0)) { - print_usage(); - exit(0); - } else if ((strcmp(argv[i], "-t") == 0) || - (strcmp(argv[i], "--to") == 0)) { - i += 1; - if (i < argc) { - if (strcmp(argv[i], "man") == 0) { - writer = FORMAT_MAN; - } else if (strcmp(argv[i], "html") == 0) { - writer = FORMAT_HTML; - } else if (strcmp(argv[i], "xml") == 0) { - writer = FORMAT_XML; - } else { - fprintf(stderr, - "Unknown format %s\n", argv[i]); - exit(1); - } - } else { - fprintf(stderr, "No argument provided for %s\n", - argv[i - 1]); - exit(1); - } - } else if (*argv[i] == '-') { - print_usage(); - exit(1); - } else { // treat as file argument - files[numfps++] = i; - } - } - - parser = cmark_parser_new(options); - for (i = 0; i < numfps; i++) { - FILE *fp = fopen(argv[files[i]], "r"); - if (fp == NULL) { - fprintf(stderr, "Error opening file %s: %s\n", - argv[files[i]], strerror(errno)); - exit(1); - } - - start_timer(); - while ((bytes = fread(buffer, 1, sizeof(buffer), fp)) > 0) { - cmark_parser_feed(parser, buffer, bytes); - if (bytes < sizeof(buffer)) { - break; - } - } - end_timer("processing lines"); - - fclose(fp); - } - - if (numfps == 0) { - - while ((bytes = fread(buffer, 1, sizeof(buffer), stdin)) > 0) { - cmark_parser_feed(parser, buffer, bytes); - if (bytes < sizeof(buffer)) { - break; - } - } - } - - start_timer(); - document = cmark_parser_finish(parser); - end_timer("finishing document"); - cmark_parser_free(parser); - - start_timer(); - print_document(document, writer, options); - end_timer("print_document"); - - start_timer(); - cmark_node_free(document); - end_timer("free_blocks"); - - free(files); - - return 0; -} diff --git a/cmark/man.c b/cmark/man.c deleted file mode 100644 --- a/cmark/man.c +++ /dev/null @@ -1,284 +0,0 @@ -#include -#include -#include -#include - -#include "config.h" -#include "cmark.h" -#include "node.h" -#include "buffer.h" -#include "utf8.h" - -// Functions to convert cmark_nodes to groff man strings. - -static void escape_man(cmark_strbuf *dest, const unsigned char *source, int length) -{ - int32_t c; - int i = 0; - int len; - bool beginLine = true; - - while (i < length) { - len = utf8proc_iterate(source + i, length - i, &c); - switch(c) { - case 46: - if (beginLine) { - cmark_strbuf_puts(dest, "\\&."); - } else { - utf8proc_encode_char(c, dest); - } - break; - case 39: - if (beginLine) { - cmark_strbuf_puts(dest, "\\&'"); - } else { - utf8proc_encode_char(c, dest); - } - break; - case 45: - cmark_strbuf_puts(dest, "\\-"); - break; - case 92: - cmark_strbuf_puts(dest, "\\e"); - break; - case 8216: // left single quote - cmark_strbuf_puts(dest, "\\[oq]"); - break; - case 8217: // right single quote - cmark_strbuf_puts(dest, "\\[cq]"); - break; - case 8220: // left double quote - cmark_strbuf_puts(dest, "\\[lq]"); - break; - case 8221: // right double quote - cmark_strbuf_puts(dest, "\\[rq]"); - break; - case 8212: // em dash - cmark_strbuf_puts(dest, "\\[em]"); - break; - case 8211: // en dash - cmark_strbuf_puts(dest, "\\[en]"); - break; - default: - utf8proc_encode_char(c, dest); - } - beginLine = (c == 10); - i += len; - } -} - -static inline void cr(cmark_strbuf *man) -{ - if (man->size && man->ptr[man->size - 1] != '\n') - cmark_strbuf_putc(man, '\n'); -} - -struct render_state { - cmark_strbuf* man; - cmark_node *plain; -}; - -static int -S_render_node(cmark_node *node, cmark_event_type ev_type, - struct render_state *state) -{ - cmark_node *tmp; - cmark_strbuf *man = state->man; - int list_number; - bool entering = (ev_type == CMARK_EVENT_ENTER); - - if (state->plain == node) { // back at original node - state->plain = NULL; - } - - if (state->plain != NULL) { - switch(node->type) { - case CMARK_NODE_TEXT: - case CMARK_NODE_CODE: - escape_man(man, node->as.literal.data, - node->as.literal.len); - break; - - case CMARK_NODE_LINEBREAK: - case CMARK_NODE_SOFTBREAK: - cmark_strbuf_putc(man, ' '); - break; - - default: - break; - } - return 1; - } - - switch (node->type) { - case CMARK_NODE_DOCUMENT: - break; - - case CMARK_NODE_BLOCK_QUOTE: - if (entering) { - cr(man); - cmark_strbuf_puts(man, ".RS"); - cr(man); - } else { - cr(man); - cmark_strbuf_puts(man, ".RE"); - cr(man); - } - break; - - case CMARK_NODE_LIST: - break; - - case CMARK_NODE_ITEM: - if (entering) { - cr(man); - cmark_strbuf_puts(man, ".IP "); - if (cmark_node_get_list_type(node->parent) == - CMARK_BULLET_LIST) { - cmark_strbuf_puts(man, "\\[bu] 2"); - } else { - list_number = cmark_node_get_list_start(node->parent); - tmp = node; - while (tmp->prev) { - tmp = tmp->prev; - list_number += 1; - } - cmark_strbuf_printf(man, "\"%d.\" 4", list_number); - } - cr(man); - } else { - cr(man); - } - break; - - case CMARK_NODE_HEADER: - if (entering) { - cr(man); - cmark_strbuf_puts(man, - cmark_node_get_header_level(node) == 1 ? - ".SH" : ".SS"); - cr(man); - } else { - cr(man); - } - break; - - case CMARK_NODE_CODE_BLOCK: - cr(man); - cmark_strbuf_puts(man, ".IP\n.nf\n\\f[C]\n"); - escape_man(man, node->as.code.literal.data, - node->as.code.literal.len); - cr(man); - cmark_strbuf_puts(man, "\\f[]\n.fi"); - cr(man); - break; - - case CMARK_NODE_HTML: - break; - - case CMARK_NODE_HRULE: - cr(man); - cmark_strbuf_puts(man, ".PP\n * * * * *"); - cr(man); - break; - - case CMARK_NODE_PARAGRAPH: - if (entering) { - // no blank line if first paragraph in list: - if (node->parent && - node->parent->type == CMARK_NODE_ITEM && - node->prev == NULL) { - // no blank line or .PP - } else { - cr(man); - cmark_strbuf_puts(man, ".PP\n"); - } - } else { - cr(man); - } - break; - - case CMARK_NODE_TEXT: - escape_man(man, node->as.literal.data, - node->as.literal.len); - break; - - case CMARK_NODE_LINEBREAK: - cmark_strbuf_puts(man, ".PD 0\n.P\n.PD"); - cr(man); - break; - - case CMARK_NODE_SOFTBREAK: - cmark_strbuf_putc(man, '\n'); - break; - - case CMARK_NODE_CODE: - cmark_strbuf_puts(man, "\\f[C]"); - escape_man(man, node->as.literal.data, node->as.literal.len); - cmark_strbuf_puts(man, "\\f[]"); - break; - - case CMARK_NODE_INLINE_HTML: - break; - - case CMARK_NODE_STRONG: - if (entering) { - cmark_strbuf_puts(man, "\\f[B]"); - } else { - cmark_strbuf_puts(man, "\\f[]"); - } - break; - - case CMARK_NODE_EMPH: - if (entering) { - cmark_strbuf_puts(man, "\\f[I]"); - } else { - cmark_strbuf_puts(man, "\\f[]"); - } - break; - - case CMARK_NODE_LINK: - if (!entering) { - cmark_strbuf_printf(man, " (%s)", - cmark_node_get_url(node)); - } - break; - - case CMARK_NODE_IMAGE: - if (entering) { - cmark_strbuf_puts(man, "[IMAGE: "); - state->plain = node; - } else { - cmark_strbuf_puts(man, "]"); - } - break; - - default: - assert(false); - break; - } - - // cmark_strbuf_putc(man, 'x'); - return 1; -} - -char *cmark_render_man(cmark_node *root, int options) -{ - char *result; - cmark_strbuf man = GH_BUF_INIT; - struct render_state state = { &man, NULL }; - cmark_node *cur; - cmark_event_type ev_type; - cmark_iter *iter = cmark_iter_new(root); - - if (options == 0) options = 0; // avoid warning about unused parameters - - while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { - cur = cmark_iter_get_node(iter); - S_render_node(cur, ev_type, &state); - } - result = (char *)cmark_strbuf_detach(&man); - - cmark_iter_free(iter); - return result; -} diff --git a/cmark/node.c b/cmark/node.c deleted file mode 100644 --- a/cmark/node.c +++ /dev/null @@ -1,873 +0,0 @@ -#include -#include - -#include "config.h" -#include "node.h" - -static void -S_node_unlink(cmark_node *node); - -static inline bool -S_is_block(cmark_node *node) -{ - if (node == NULL) { - return false; - } - return node->type >= CMARK_NODE_FIRST_BLOCK - && node->type <= CMARK_NODE_LAST_BLOCK; -} - -static inline bool -S_is_inline(cmark_node *node) -{ - if (node == NULL) { - return false; - } - return node->type >= CMARK_NODE_FIRST_INLINE - && node->type <= CMARK_NODE_LAST_INLINE; -} - -static bool -S_can_contain(cmark_node *node, cmark_node *child) -{ - cmark_node *cur; - - if (node == NULL || child == NULL) { - return false; - } - - // Verify that child is not an ancestor of node or equal to node. - cur = node; - do { - if (cur == child) { - return false; - } - cur = cur->parent; - } while (cur != NULL); - - if (child->type == CMARK_NODE_DOCUMENT) { - return false; - } - - switch (node->type) { - case CMARK_NODE_DOCUMENT: - case CMARK_NODE_BLOCK_QUOTE: - case CMARK_NODE_ITEM: - return S_is_block(child) - && child->type != CMARK_NODE_ITEM; - - case CMARK_NODE_LIST: - return child->type == CMARK_NODE_ITEM; - - case CMARK_NODE_PARAGRAPH: - case CMARK_NODE_HEADER: - case CMARK_NODE_EMPH: - case CMARK_NODE_STRONG: - case CMARK_NODE_LINK: - case CMARK_NODE_IMAGE: - return S_is_inline(child); - - default: - break; - } - - return false; -} - -cmark_node* -cmark_node_new(cmark_node_type type) -{ - cmark_node *node = (cmark_node *)calloc(1, sizeof(*node)); - node->type = type; - - switch (node->type) { - case CMARK_NODE_HEADER: - node->as.header.level = 1; - break; - - case CMARK_NODE_LIST: { - cmark_list *list = &node->as.list; - list->list_type = CMARK_BULLET_LIST; - list->start = 1; - list->tight = false; - break; - } - - default: - break; - } - - return node; -} - -// Free a cmark_node list and any children. -static -void S_free_nodes(cmark_node *e) -{ - cmark_node *next; - while (e != NULL) { - if (S_is_block(e)) { - cmark_strbuf_free(&e->string_content); - } - switch (e->type) { - case NODE_CODE_BLOCK: - cmark_chunk_free(&e->as.code.info); - cmark_chunk_free(&e->as.code.literal); - break; - case NODE_TEXT: - case NODE_INLINE_HTML: - case NODE_CODE: - case NODE_HTML: - cmark_chunk_free(&e->as.literal); - break; - case NODE_LINK: - case NODE_IMAGE: - if (e->as.link.url) { - free(e->as.link.url); - } - if (e->as.link.title) { - free(e->as.link.title); - } - break; - default: - break; - } - if (e->last_child) { - // Splice children into list - e->last_child->next = e->next; - e->next = e->first_child; - } - next = e->next; - free(e); - e = next; - } -} - -void -cmark_node_free(cmark_node *node) -{ - S_node_unlink(node); - node->next = NULL; - S_free_nodes(node); -} - -cmark_node_type -cmark_node_get_type(cmark_node *node) -{ - if (node == NULL) { - return CMARK_NODE_NONE; - } else { - return node->type; - } -} - -const char* -cmark_node_get_type_string(cmark_node *node) -{ - if (node == NULL) { - return "NONE"; - } - - switch (node->type) { - case CMARK_NODE_NONE: - return "none"; - case CMARK_NODE_DOCUMENT: - return "document"; - case CMARK_NODE_BLOCK_QUOTE: - return "block_quote"; - case CMARK_NODE_LIST: - return "list"; - case CMARK_NODE_ITEM: - return "item"; - case CMARK_NODE_CODE_BLOCK: - return "code_block"; - case CMARK_NODE_HTML: - return "html"; - case CMARK_NODE_PARAGRAPH: - return "paragraph"; - case CMARK_NODE_HEADER: - return "header"; - case CMARK_NODE_HRULE: - return "hrule"; - case CMARK_NODE_TEXT: - return "text"; - case CMARK_NODE_SOFTBREAK: - return "softbreak"; - case CMARK_NODE_LINEBREAK: - return "linebreak"; - case CMARK_NODE_CODE: - return "code"; - case CMARK_NODE_INLINE_HTML: - return "inline_html"; - case CMARK_NODE_EMPH: - return "emph"; - case CMARK_NODE_STRONG: - return "strong"; - case CMARK_NODE_LINK: - return "link"; - case CMARK_NODE_IMAGE: - return "image"; - } - - return ""; -} - -cmark_node* -cmark_node_next(cmark_node *node) -{ - if (node == NULL) { - return NULL; - } else { - return node->next; - } -} - -cmark_node* -cmark_node_previous(cmark_node *node) -{ - if (node == NULL) { - return NULL; - } else { - return node->prev; - } -} - -cmark_node* -cmark_node_parent(cmark_node *node) -{ - if (node == NULL) { - return NULL; - } else { - return node->parent; - } -} - -cmark_node* -cmark_node_first_child(cmark_node *node) -{ - if (node == NULL) { - return NULL; - } else { - return node->first_child; - } -} - -cmark_node* -cmark_node_last_child(cmark_node *node) -{ - if (node == NULL) { - return NULL; - } else { - return node->last_child; - } -} - -void* -cmark_node_get_user_data(cmark_node *node) -{ - if (node == NULL) { - return NULL; - } else { - return node->user_data; - } -} - -int -cmark_node_set_user_data(cmark_node *node, void *user_data) -{ - if (node == NULL) { - return 0; - } - node->user_data = user_data; - return 1; -} - -static char* -S_strdup(const char *str) -{ - size_t size = strlen(str) + 1; - char *dup = (char *)malloc(size); - memcpy(dup, str, size); - return dup; -} - -const char* -cmark_node_get_literal(cmark_node *node) -{ - if (node == NULL) { - return NULL; - } - - switch (node->type) { - case NODE_HTML: - case NODE_TEXT: - case NODE_INLINE_HTML: - case NODE_CODE: - return cmark_chunk_to_cstr(&node->as.literal); - - case NODE_CODE_BLOCK: - return cmark_chunk_to_cstr(&node->as.code.literal); - - default: - break; - } - - return NULL; -} - -int -cmark_node_set_literal(cmark_node *node, const char *content) -{ - if (node == NULL) { - return 0; - } - - switch (node->type) { - case NODE_HTML: - case NODE_TEXT: - case NODE_INLINE_HTML: - case NODE_CODE: - cmark_chunk_set_cstr(&node->as.literal, content); - return 1; - - case NODE_CODE_BLOCK: - cmark_chunk_set_cstr(&node->as.code.literal, content); - return 1; - - default: - break; - } - - return 0; -} - -int -cmark_node_get_header_level(cmark_node *node) -{ - if (node == NULL) { - return 0; - } - - switch (node->type) { - case CMARK_NODE_HEADER: - return node->as.header.level; - - default: - break; - } - - return 0; -} - -int -cmark_node_set_header_level(cmark_node *node, int level) -{ - if (node == NULL || level < 1 || level > 6) { - return 0; - } - - switch (node->type) { - case CMARK_NODE_HEADER: - node->as.header.level = level; - return 1; - - default: - break; - } - - return 0; -} - -cmark_list_type -cmark_node_get_list_type(cmark_node *node) -{ - if (node == NULL) { - return CMARK_NO_LIST; - } - - if (node->type == CMARK_NODE_LIST) { - return node->as.list.list_type; - } else { - return CMARK_NO_LIST; - } -} - -int -cmark_node_set_list_type(cmark_node *node, cmark_list_type type) -{ - if (!(type == CMARK_BULLET_LIST || type == CMARK_ORDERED_LIST)) { - return 0; - } - - if (node == NULL) { - return 0; - } - - if (node->type == CMARK_NODE_LIST) { - node->as.list.list_type = type; - return 1; - } else { - return 0; - } -} - -cmark_delim_type -cmark_node_get_list_delim(cmark_node *node) -{ - if (node == NULL) { - return CMARK_NO_DELIM; - } - - if (node->type == CMARK_NODE_LIST) { - return node->as.list.delimiter; - } else { - return CMARK_NO_DELIM; - } -} - -int -cmark_node_set_list_delim(cmark_node *node, cmark_delim_type delim) -{ - if (!(delim == CMARK_PERIOD_DELIM || delim == CMARK_PAREN_DELIM)) { - return 0; - } - - if (node == NULL) { - return 0; - } - - if (node->type == CMARK_NODE_LIST) { - node->as.list.delimiter = delim; - return 1; - } else { - return 0; - } -} - -int -cmark_node_get_list_start(cmark_node *node) -{ - if (node == NULL) { - return 0; - } - - if (node->type == CMARK_NODE_LIST) { - return node->as.list.start; - } else { - return 0; - } -} - -int -cmark_node_set_list_start(cmark_node *node, int start) -{ - if (node == NULL || start < 0) { - return 0; - } - - if (node->type == CMARK_NODE_LIST) { - node->as.list.start = start; - return 1; - } else { - return 0; - } -} - -int -cmark_node_get_list_tight(cmark_node *node) -{ - if (node == NULL) { - return 0; - } - - if (node->type == CMARK_NODE_LIST) { - return node->as.list.tight; - } else { - return 0; - } -} - -int -cmark_node_set_list_tight(cmark_node *node, int tight) -{ - if (node == NULL) { - return 0; - } - - if (node->type == CMARK_NODE_LIST) { - node->as.list.tight = tight; - return 1; - } else { - return 0; - } -} - -const char* -cmark_node_get_fence_info(cmark_node *node) -{ - if (node == NULL) { - return NULL; - } - - if (node->type == NODE_CODE_BLOCK) { - return cmark_chunk_to_cstr(&node->as.code.info); - } else { - return NULL; - } -} - -int -cmark_node_set_fence_info(cmark_node *node, const char *info) -{ - if (node == NULL) { - return 0; - } - - if (node->type == NODE_CODE_BLOCK) { - cmark_chunk_set_cstr(&node->as.code.info, info); - return 1; - } else { - return 0; - } -} - -const char* -cmark_node_get_url(cmark_node *node) -{ - if (node == NULL) { - return NULL; - } - - switch (node->type) { - case NODE_LINK: - case NODE_IMAGE: - return (char *)node->as.link.url; - default: - break; - } - - return NULL; -} - -int -cmark_node_set_url(cmark_node *node, const char *url) -{ - if (node == NULL) { - return 0; - } - - switch (node->type) { - case NODE_LINK: - case NODE_IMAGE: - free(node->as.link.url); - node->as.link.url = (unsigned char *)S_strdup(url); - return 1; - default: - break; - } - - return 0; -} - -const char* -cmark_node_get_title(cmark_node *node) -{ - if (node == NULL) { - return NULL; - } - - switch (node->type) { - case NODE_LINK: - case NODE_IMAGE: - return (char *)node->as.link.title; - default: - break; - } - - return NULL; -} - -int -cmark_node_set_title(cmark_node *node, const char *title) -{ - if (node == NULL) { - return 0; - } - - switch (node->type) { - case NODE_LINK: - case NODE_IMAGE: - free(node->as.link.title); - node->as.link.title = (unsigned char *)S_strdup(title); - return 1; - default: - break; - } - - return 0; -} - -int -cmark_node_get_start_line(cmark_node *node) -{ - if (node == NULL) { - return 0; - } - return node->start_line; -} - -int -cmark_node_get_start_column(cmark_node *node) -{ - if (node == NULL) { - return 0; - } - return node->start_column; -} - -int -cmark_node_get_end_line(cmark_node *node) -{ - if (node == NULL) { - return 0; - } - return node->end_line; -} - -int -cmark_node_get_end_column(cmark_node *node) -{ - if (node == NULL) { - return 0; - } - return node->end_column; -} - -// Unlink a node without adjusting its next, prev, and parent pointers. -static void -S_node_unlink(cmark_node *node) -{ - if (node == NULL) { - return; - } - - if (node->prev) { - node->prev->next = node->next; - } - if (node->next) { - node->next->prev = node->prev; - } - - // Adjust first_child and last_child of parent. - cmark_node *parent = node->parent; - if (parent) { - if (parent->first_child == node) { - parent->first_child = node->next; - } - if (parent->last_child == node) { - parent->last_child = node->prev; - } - } -} - -void -cmark_node_unlink(cmark_node *node) -{ - S_node_unlink(node); - - node->next = NULL; - node->prev = NULL; - node->parent = NULL; - -} - -int -cmark_node_insert_before(cmark_node *node, cmark_node *sibling) -{ - if (node == NULL || sibling == NULL) { - return 0; - } - - if (!node->parent || !S_can_contain(node->parent, sibling)) { - return 0; - } - - S_node_unlink(sibling); - - cmark_node *old_prev = node->prev; - - // Insert 'sibling' between 'old_prev' and 'node'. - if (old_prev) { - old_prev->next = sibling; - } - sibling->prev = old_prev; - sibling->next = node; - node->prev = sibling; - - // Set new parent. - cmark_node *parent = node->parent; - sibling->parent = parent; - - // Adjust first_child of parent if inserted as first child. - if (parent && !old_prev) { - parent->first_child = sibling; - } - - return 1; -} - -int -cmark_node_insert_after(cmark_node *node, cmark_node *sibling) -{ - if (node == NULL || sibling == NULL) { - return 0; - } - - if (!node->parent || !S_can_contain(node->parent, sibling)) { - return 0; - } - - S_node_unlink(sibling); - - cmark_node *old_next = node->next; - - // Insert 'sibling' between 'node' and 'old_next'. - if (old_next) { - old_next->prev = sibling; - } - sibling->next = old_next; - sibling->prev = node; - node->next = sibling; - - // Set new parent. - cmark_node *parent = node->parent; - sibling->parent = parent; - - // Adjust last_child of parent if inserted as last child. - if (parent && !old_next) { - parent->last_child = sibling; - } - - return 1; -} - -int -cmark_node_prepend_child(cmark_node *node, cmark_node *child) -{ - if (!S_can_contain(node, child)) { - return 0; - } - - S_node_unlink(child); - - cmark_node *old_first_child = node->first_child; - - child->next = old_first_child; - child->prev = NULL; - child->parent = node; - node->first_child = child; - - if (old_first_child) { - old_first_child->prev = child; - } else { - // Also set last_child if node previously had no children. - node->last_child = child; - } - - return 1; -} - -int -cmark_node_append_child(cmark_node *node, cmark_node *child) -{ - if (!S_can_contain(node, child)) { - return 0; - } - - S_node_unlink(child); - - cmark_node *old_last_child = node->last_child; - - child->next = NULL; - child->prev = old_last_child; - child->parent = node; - node->last_child = child; - - if (old_last_child) { - old_last_child->next = child; - } else { - // Also set first_child if node previously had no children. - node->first_child = child; - } - - return 1; -} - -static void -S_print_error(FILE *out, cmark_node *node, const char *elem) -{ - if (out == NULL) { - return; - } - fprintf(out, "Invalid '%s' in node type %s at %d:%d\n", elem, - cmark_node_get_type_string(node), node->start_line, - node->start_column); -} - -int -cmark_node_check(cmark_node *node, FILE *out) -{ - cmark_node *cur; - int errors = 0; - - if (!node) { - return 0; - } - - cur = node; - while (true) { - if (cur->first_child) { - if (cur->first_child->prev != NULL) { - S_print_error(out, cur->first_child, "prev"); - cur->first_child->prev = NULL; - ++errors; - } - if (cur->first_child->parent != cur) { - S_print_error(out, cur->first_child, "parent"); - cur->first_child->parent = cur; - ++errors; - } - cur = cur->first_child; - continue; - } - -next_sibling: - if (cur == node) { - break; - } - if (cur->next) { - if (cur->next->prev != cur) { - S_print_error(out, cur->next, "prev"); - cur->next->prev = cur; - ++errors; - } - if (cur->next->parent != cur->parent) { - S_print_error(out, cur->next, "parent"); - cur->next->parent = cur->parent; - ++errors; - } - cur = cur->next; - continue; - } - - if (cur->parent->last_child != cur) { - S_print_error(out, cur->parent, "last_child"); - cur->parent->last_child = cur; - ++errors; - } - cur = cur->parent; - goto next_sibling; - } - - return errors; -} diff --git a/cmark/node.h b/cmark/node.h deleted file mode 100644 --- a/cmark/node.h +++ /dev/null @@ -1,82 +0,0 @@ -#ifndef CMARK_NODE_H -#define CMARK_NODE_H - -#ifdef __cplusplus -extern "C" { -#endif - -#include -#include - -#include "cmark.h" -#include "buffer.h" -#include "chunk.h" - -typedef struct { - cmark_list_type list_type; - int marker_offset; - int padding; - int start; - cmark_delim_type delimiter; - unsigned char bullet_char; - bool tight; -} cmark_list; - -typedef struct { - cmark_chunk info; - cmark_chunk literal; - int fence_length; - /* fence_offset must be 0-3, so we can use int8_t */ - int8_t fence_offset; - unsigned char fence_char; - bool fenced; -} cmark_code; - -typedef struct { - int level; - bool setext; -} cmark_header; - -typedef struct { - unsigned char *url; - unsigned char *title; -} cmark_link; - -struct cmark_node { - struct cmark_node *next; - struct cmark_node *prev; - struct cmark_node *parent; - struct cmark_node *first_child; - struct cmark_node *last_child; - - void *user_data; - - int start_line; - int start_column; - int end_line; - int end_column; - - cmark_node_type type; - - bool open; - bool last_line_blank; - - cmark_strbuf string_content; - - union { - cmark_chunk literal; - cmark_list list; - cmark_code code; - cmark_header header; - cmark_link link; - } as; -}; - -CMARK_EXPORT int -cmark_node_check(cmark_node *node, FILE *out); - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/cmark/parser.h b/cmark/parser.h deleted file mode 100644 --- a/cmark/parser.h +++ /dev/null @@ -1,29 +0,0 @@ -#ifndef CMARK_AST_H -#define CMARK_AST_H - -#include -#include "node.h" -#include "buffer.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#define MAX_LINK_LABEL_LENGTH 1000 - -struct cmark_parser { - struct cmark_reference_map *refmap; - struct cmark_node* root; - struct cmark_node* current; - int line_number; - cmark_strbuf *curline; - int last_line_length; - cmark_strbuf *linebuf; - int options; -}; - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/cmark/references.c b/cmark/references.c deleted file mode 100644 --- a/cmark/references.c +++ /dev/null @@ -1,154 +0,0 @@ -#include "cmark.h" -#include "utf8.h" -#include "parser.h" -#include "references.h" -#include "inlines.h" -#include "chunk.h" - -static unsigned int -refhash(const unsigned char *link_ref) -{ - unsigned int hash = 0; - - while (*link_ref) - hash = (*link_ref++) + (hash << 6) + (hash << 16) - hash; - - return hash; -} - -static void reference_free(cmark_reference *ref) -{ - if(ref != NULL) { - free(ref->label); - free(ref->url); - free(ref->title); - free(ref); - } -} - -// normalize reference: collapse internal whitespace to single space, -// remove leading/trailing whitespace, case fold -// Return NULL if the reference name is actually empty (i.e. composed -// solely from whitespace) -static unsigned char *normalize_reference(cmark_chunk *ref) -{ - cmark_strbuf normalized = GH_BUF_INIT; - unsigned char *result; - - if(ref == NULL) - return NULL; - - if (ref->len == 0) - return NULL; - - utf8proc_case_fold(&normalized, ref->data, ref->len); - cmark_strbuf_trim(&normalized); - cmark_strbuf_normalize_whitespace(&normalized); - - result = cmark_strbuf_detach(&normalized); - assert(result); - - if (result[0] == '\0') { - free(result); - return NULL; - } - - return result; -} - -static void add_reference(cmark_reference_map *map, cmark_reference* ref) -{ - cmark_reference *t = ref->next = map->table[ref->hash % REFMAP_SIZE]; - - while (t) { - if (t->hash == ref->hash && - !strcmp((char *)t->label, (char *)ref->label)) { - reference_free(ref); - return; - } - - t = t->next; - } - - map->table[ref->hash % REFMAP_SIZE] = ref; -} - -void cmark_reference_create(cmark_reference_map *map, cmark_chunk *label, cmark_chunk *url, - cmark_chunk *title) -{ - cmark_reference *ref; - unsigned char *reflabel = normalize_reference(label); - - /* empty reference name, or composed from only whitespace */ - if (reflabel == NULL) - return; - - ref = (cmark_reference *)calloc(1, sizeof(*ref)); - if(ref != NULL) { - ref->label = reflabel; - ref->hash = refhash(ref->label); - ref->url = cmark_clean_url(url); - ref->title = cmark_clean_title(title); - ref->next = NULL; - - add_reference(map, ref); - } -} - -// Returns reference if refmap contains a reference with matching -// label, otherwise NULL. -cmark_reference* cmark_reference_lookup(cmark_reference_map *map, cmark_chunk *label) -{ - cmark_reference *ref = NULL; - unsigned char *norm; - unsigned int hash; - - if (label->len > MAX_LINK_LABEL_LENGTH) - return NULL; - - if (map == NULL) - return NULL; - - norm = normalize_reference(label); - if (norm == NULL) - return NULL; - - hash = refhash(norm); - ref = map->table[hash % REFMAP_SIZE]; - - while (ref) { - if (ref->hash == hash && - !strcmp((char *)ref->label, (char *)norm)) - break; - ref = ref->next; - } - - free(norm); - return ref; -} - -void cmark_reference_map_free(cmark_reference_map *map) -{ - unsigned int i; - - if(map == NULL) - return; - - for (i = 0; i < REFMAP_SIZE; ++i) { - cmark_reference *ref = map->table[i]; - cmark_reference *next; - - while (ref) { - next = ref->next; - reference_free(ref); - ref = next; - } - } - - free(map); -} - -cmark_reference_map *cmark_reference_map_new(void) -{ - return (cmark_reference_map *)calloc(1, sizeof(cmark_reference_map)); -} diff --git a/cmark/references.h b/cmark/references.h deleted file mode 100644 --- a/cmark/references.h +++ /dev/null @@ -1,37 +0,0 @@ -#ifndef CMARK_REFERENCES_H -#define CMARK_REFERENCES_H - -#include "chunk.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#define REFMAP_SIZE 16 - -struct cmark_reference { - struct cmark_reference *next; - unsigned char *label; - unsigned char *url; - unsigned char *title; - unsigned int hash; -}; - -typedef struct cmark_reference cmark_reference; - -struct cmark_reference_map { - cmark_reference *table[REFMAP_SIZE]; -}; - -typedef struct cmark_reference_map cmark_reference_map; - -cmark_reference_map *cmark_reference_map_new(void); -void cmark_reference_map_free(cmark_reference_map *map); -cmark_reference* cmark_reference_lookup(cmark_reference_map *map, cmark_chunk *label); -extern void cmark_reference_create(cmark_reference_map *map, cmark_chunk *label, cmark_chunk *url, cmark_chunk *title); - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/cmark/scanners.c b/cmark/scanners.c deleted file mode 100644 --- a/cmark/scanners.c +++ /dev/null @@ -1,12392 +0,0 @@ -/* Generated by re2c 0.13.6 */ -#include -#include "chunk.h" -#include "scanners.h" - -int _scan_at(int (*scanner)(const unsigned char *), cmark_chunk *c, int offset) -{ - int res; - unsigned char *ptr = (unsigned char *)c->data; - unsigned char lim = ptr[c->len]; - - ptr[c->len] = '\0'; - res = scanner(ptr + offset); - ptr[c->len] = lim; - - return res; -} - - - -// Try to match URI autolink after first <, returning number of chars matched. -int _scan_autolink_uri(const unsigned char *p) -{ - const unsigned char *marker = NULL; - const unsigned char *start = p; - -{ - unsigned char yych; - static const unsigned char yybm[] = { - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 0, 128, 0, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - }; - - yych = *p; - switch (yych) { - case '\n': goto yy2; - case 'A': - case 'a': goto yy6; - case 'B': - case 'b': goto yy24; - case 'C': - case 'c': goto yy3; - case 'D': - case 'd': goto yy4; - case 'E': - case 'e': goto yy25; - case 'F': - case 'f': goto yy7; - case 'G': - case 'g': goto yy8; - case 'H': - case 'h': goto yy9; - case 'I': - case 'i': goto yy10; - case 'J': - case 'j': goto yy5; - case 'K': - case 'k': goto yy26; - case 'L': - case 'l': goto yy11; - case 'M': - case 'm': goto yy12; - case 'N': - case 'n': goto yy13; - case 'O': - case 'o': goto yy14; - case 'P': - case 'p': goto yy15; - case 'Q': - case 'q': goto yy27; - case 'R': - case 'r': goto yy16; - case 'S': - case 's': goto yy17; - case 'T': - case 't': goto yy18; - case 'U': - case 'u': goto yy19; - case 'V': - case 'v': goto yy20; - case 'W': - case 'w': goto yy21; - case 'X': - case 'x': goto yy22; - case 'Y': - case 'y': goto yy28; - case 'Z': - case 'z': goto yy23; - default: goto yy29; - } -yy2: - { return 0; } -yy3: - yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': goto yy442; - case 'H': - case 'h': goto yy441; - case 'I': - case 'i': goto yy444; - case 'O': - case 'o': goto yy440; - case 'R': - case 'r': goto yy443; - case 'V': - case 'v': goto yy439; - default: goto yy2; - } -yy4: - yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': goto yy415; - case 'I': - case 'i': goto yy414; - case 'L': - case 'l': goto yy412; - case 'N': - case 'n': goto yy413; - case 'O': - case 'o': goto yy416; - case 'T': - case 't': goto yy411; - case 'V': - case 'v': goto yy410; - default: goto yy2; - } -yy5: - yych = *(marker = ++p); - if (yych <= 'M') { - if (yych == 'A') goto yy402; - if (yych <= 'L') goto yy2; - goto yy401; - } else { - if (yych <= 'a') { - if (yych <= '`') goto yy2; - goto yy402; - } else { - if (yych == 'm') goto yy401; - goto yy2; - } - } -yy6: - yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': goto yy383; - case 'B': - case 'b': goto yy382; - case 'C': - case 'c': goto yy381; - case 'D': - case 'd': goto yy380; - case 'F': - case 'f': goto yy379; - case 'I': - case 'i': goto yy378; - case 'P': - case 'p': goto yy377; - case 'T': - case 't': goto yy376; - case 'W': - case 'w': goto yy34; - default: goto yy2; - } -yy7: - yych = *(marker = ++p); - if (yych <= 'T') { - if (yych <= 'E') { - if (yych == 'A') goto yy363; - if (yych <= 'D') goto yy2; - goto yy362; - } else { - if (yych == 'I') goto yy361; - if (yych <= 'S') goto yy2; - goto yy364; - } - } else { - if (yych <= 'e') { - if (yych == 'a') goto yy363; - if (yych <= 'd') goto yy2; - goto yy362; - } else { - if (yych <= 'i') { - if (yych <= 'h') goto yy2; - goto yy361; - } else { - if (yych == 't') goto yy364; - goto yy2; - } - } - } -yy8: - yych = *(marker = ++p); - switch (yych) { - case 'E': - case 'e': goto yy346; - case 'G': - case 'g': goto yy34; - case 'I': - case 'i': goto yy344; - case 'O': - case 'o': goto yy345; - case 'T': - case 't': goto yy343; - default: goto yy2; - } -yy9: - yych = *(marker = ++p); - if (yych <= 'S') { - if (yych <= '3') { - if (yych <= '2') goto yy2; - goto yy339; - } else { - if (yych == 'C') goto yy337; - goto yy2; - } - } else { - if (yych <= 'c') { - if (yych <= 'T') goto yy338; - if (yych <= 'b') goto yy2; - goto yy337; - } else { - if (yych == 't') goto yy338; - goto yy2; - } - } -yy10: - yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': goto yy319; - case 'C': - case 'c': goto yy316; - case 'M': - case 'm': goto yy318; - case 'N': - case 'n': goto yy317; - case 'P': - case 'p': goto yy315; - case 'R': - case 'r': goto yy314; - case 'T': - case 't': goto yy313; - default: goto yy2; - } -yy11: - yych = *(marker = ++p); - if (yych <= 'D') { - if (yych == 'A') goto yy307; - if (yych <= 'C') goto yy2; - goto yy306; - } else { - if (yych <= 'a') { - if (yych <= '`') goto yy2; - goto yy307; - } else { - if (yych == 'd') goto yy306; - goto yy2; - } - } -yy12: - yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': goto yy273; - case 'E': - case 'e': goto yy272; - case 'I': - case 'i': goto yy275; - case 'M': - case 'm': goto yy271; - case 'S': - case 's': goto yy270; - case 'T': - case 't': goto yy274; - case 'U': - case 'u': goto yy269; - case 'V': - case 'v': goto yy268; - default: goto yy2; - } -yy13: - yych = *(marker = ++p); - switch (yych) { - case 'E': - case 'e': goto yy263; - case 'F': - case 'f': goto yy262; - case 'I': - case 'i': goto yy261; - case 'N': - case 'n': goto yy260; - case 'O': - case 'o': goto yy259; - default: goto yy2; - } -yy14: - yych = *(marker = ++p); - if (yych <= 'P') { - if (yych == 'I') goto yy245; - if (yych <= 'O') goto yy2; - goto yy246; - } else { - if (yych <= 'i') { - if (yych <= 'h') goto yy2; - goto yy245; - } else { - if (yych == 'p') goto yy246; - goto yy2; - } - } -yy15: - yych = *(marker = ++p); - if (yych <= 'S') { - if (yych <= 'L') { - if (yych == 'A') goto yy227; - if (yych <= 'K') goto yy2; - goto yy226; - } else { - if (yych <= 'O') { - if (yych <= 'N') goto yy2; - goto yy228; - } else { - if (yych <= 'Q') goto yy2; - if (yych <= 'R') goto yy225; - goto yy224; - } - } - } else { - if (yych <= 'n') { - if (yych <= 'a') { - if (yych <= '`') goto yy2; - goto yy227; - } else { - if (yych == 'l') goto yy226; - goto yy2; - } - } else { - if (yych <= 'q') { - if (yych <= 'o') goto yy228; - goto yy2; - } else { - if (yych <= 'r') goto yy225; - if (yych <= 's') goto yy224; - goto yy2; - } - } - } -yy16: - yych = *(marker = ++p); - if (yych <= 'T') { - if (yych <= 'L') { - if (yych == 'E') goto yy214; - goto yy2; - } else { - if (yych <= 'M') goto yy213; - if (yych <= 'R') goto yy2; - if (yych <= 'S') goto yy212; - goto yy211; - } - } else { - if (yych <= 'm') { - if (yych == 'e') goto yy214; - if (yych <= 'l') goto yy2; - goto yy213; - } else { - if (yych <= 'r') goto yy2; - if (yych <= 's') goto yy212; - if (yych <= 't') goto yy211; - goto yy2; - } - } -yy17: - yych = *(marker = ++p); - switch (yych) { - case 'E': - case 'e': goto yy167; - case 'F': - case 'f': goto yy166; - case 'G': - case 'g': goto yy165; - case 'H': - case 'h': goto yy170; - case 'I': - case 'i': goto yy169; - case 'K': - case 'k': goto yy164; - case 'M': - case 'm': goto yy163; - case 'N': - case 'n': goto yy168; - case 'O': - case 'o': goto yy162; - case 'P': - case 'p': goto yy161; - case 'S': - case 's': goto yy160; - case 'T': - case 't': goto yy159; - case 'V': - case 'v': goto yy158; - default: goto yy2; - } -yy18: - yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': goto yy134; - case 'E': - case 'e': goto yy130; - case 'F': - case 'f': goto yy133; - case 'H': - case 'h': goto yy129; - case 'I': - case 'i': goto yy131; - case 'N': - case 'n': goto yy132; - case 'V': - case 'v': goto yy34; - default: goto yy2; - } -yy19: - yych = *(marker = ++p); - if (yych <= 'T') { - if (yych <= 'N') { - if (yych == 'D') goto yy121; - if (yych <= 'M') goto yy2; - goto yy120; - } else { - if (yych == 'R') goto yy122; - if (yych <= 'S') goto yy2; - goto yy119; - } - } else { - if (yych <= 'n') { - if (yych == 'd') goto yy121; - if (yych <= 'm') goto yy2; - goto yy120; - } else { - if (yych <= 'r') { - if (yych <= 'q') goto yy2; - goto yy122; - } else { - if (yych == 't') goto yy119; - goto yy2; - } - } - } -yy20: - yych = *(marker = ++p); - if (yych <= 'I') { - if (yych == 'E') goto yy103; - if (yych <= 'H') goto yy2; - goto yy102; - } else { - if (yych <= 'e') { - if (yych <= 'd') goto yy2; - goto yy103; - } else { - if (yych == 'i') goto yy102; - goto yy2; - } - } -yy21: - yych = *(marker = ++p); - if (yych <= 'Y') { - if (yych <= 'R') { - if (yych == 'E') goto yy92; - goto yy2; - } else { - if (yych <= 'S') goto yy93; - if (yych <= 'T') goto yy91; - if (yych <= 'X') goto yy2; - goto yy90; - } - } else { - if (yych <= 's') { - if (yych == 'e') goto yy92; - if (yych <= 'r') goto yy2; - goto yy93; - } else { - if (yych <= 't') goto yy91; - if (yych == 'y') goto yy90; - goto yy2; - } - } -yy22: - yych = *(marker = ++p); - if (yych <= 'R') { - if (yych <= 'F') { - if (yych == 'C') goto yy69; - if (yych <= 'E') goto yy2; - goto yy67; - } else { - if (yych == 'M') goto yy68; - if (yych <= 'Q') goto yy2; - goto yy66; - } - } else { - if (yych <= 'f') { - if (yych == 'c') goto yy69; - if (yych <= 'e') goto yy2; - goto yy67; - } else { - if (yych <= 'm') { - if (yych <= 'l') goto yy2; - goto yy68; - } else { - if (yych == 'r') goto yy66; - goto yy2; - } - } - } -yy23: - yych = *(marker = ++p); - if (yych == '3') goto yy61; - goto yy2; -yy24: - yych = *(marker = ++p); - if (yych <= 'O') { - if (yych <= 'H') { - if (yych == 'E') goto yy51; - goto yy2; - } else { - if (yych <= 'I') goto yy50; - if (yych <= 'N') goto yy2; - goto yy49; - } - } else { - if (yych <= 'h') { - if (yych == 'e') goto yy51; - goto yy2; - } else { - if (yych <= 'i') goto yy50; - if (yych == 'o') goto yy49; - goto yy2; - } - } -yy25: - yych = *(marker = ++p); - if (yych == 'D') goto yy47; - if (yych == 'd') goto yy47; - goto yy2; -yy26: - yych = *(marker = ++p); - if (yych == 'E') goto yy42; - if (yych == 'e') goto yy42; - goto yy2; -yy27: - yych = *(marker = ++p); - if (yych == 'U') goto yy39; - if (yych == 'u') goto yy39; - goto yy2; -yy28: - yych = *(marker = ++p); - if (yych == 'M') goto yy30; - if (yych == 'm') goto yy30; - goto yy2; -yy29: - yych = *++p; - goto yy2; -yy30: - yych = *++p; - if (yych == 'S') goto yy32; - if (yych == 's') goto yy32; -yy31: - p = marker; - goto yy2; -yy32: - yych = *++p; - if (yych == 'G') goto yy33; - if (yych != 'g') goto yy31; -yy33: - yych = *++p; - if (yych == 'R') goto yy34; - if (yych != 'r') goto yy31; -yy34: - yych = *++p; - if (yych != ':') goto yy31; -yy35: - ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy35; - } - if (yych <= '=') goto yy31; - ++p; - { return (p - start); } -yy39: - yych = *++p; - if (yych == 'E') goto yy40; - if (yych != 'e') goto yy31; -yy40: - yych = *++p; - if (yych == 'R') goto yy41; - if (yych != 'r') goto yy31; -yy41: - yych = *++p; - if (yych == 'Y') goto yy34; - if (yych == 'y') goto yy34; - goto yy31; -yy42: - yych = *++p; - if (yych == 'Y') goto yy43; - if (yych != 'y') goto yy31; -yy43: - yych = *++p; - if (yych == 'P') goto yy44; - if (yych != 'p') goto yy31; -yy44: - yych = *++p; - if (yych == 'A') goto yy45; - if (yych != 'a') goto yy31; -yy45: - yych = *++p; - if (yych == 'R') goto yy46; - if (yych != 'r') goto yy31; -yy46: - yych = *++p; - if (yych == 'C') goto yy34; - if (yych == 'c') goto yy34; - goto yy31; -yy47: - yych = *++p; - if (yych != '2') goto yy31; - yych = *++p; - if (yych == 'K') goto yy34; - if (yych == 'k') goto yy34; - goto yy31; -yy49: - yych = *++p; - if (yych == 'L') goto yy60; - if (yych == 'l') goto yy60; - goto yy31; -yy50: - yych = *++p; - if (yych == 'T') goto yy56; - if (yych == 't') goto yy56; - goto yy31; -yy51: - yych = *++p; - if (yych == 'S') goto yy52; - if (yych != 's') goto yy31; -yy52: - yych = *++p; - if (yych == 'H') goto yy53; - if (yych != 'h') goto yy31; -yy53: - yych = *++p; - if (yych == 'A') goto yy54; - if (yych != 'a') goto yy31; -yy54: - yych = *++p; - if (yych == 'R') goto yy55; - if (yych != 'r') goto yy31; -yy55: - yych = *++p; - if (yych == 'E') goto yy34; - if (yych == 'e') goto yy34; - goto yy31; -yy56: - yych = *++p; - if (yych == 'C') goto yy57; - if (yych != 'c') goto yy31; -yy57: - yych = *++p; - if (yych == 'O') goto yy58; - if (yych != 'o') goto yy31; -yy58: - yych = *++p; - if (yych == 'I') goto yy59; - if (yych != 'i') goto yy31; -yy59: - yych = *++p; - if (yych == 'N') goto yy34; - if (yych == 'n') goto yy34; - goto yy31; -yy60: - yych = *++p; - if (yych == 'O') goto yy34; - if (yych == 'o') goto yy34; - goto yy31; -yy61: - yych = *++p; - if (yych != '9') goto yy31; - yych = *++p; - if (yych != '.') goto yy31; - yych = *++p; - if (yych != '5') goto yy31; - yych = *++p; - if (yych != '0') goto yy31; - yych = *++p; - if (yych <= 'Q') goto yy31; - if (yych <= 'S') goto yy34; - if (yych <= 'q') goto yy31; - if (yych <= 's') goto yy34; - goto yy31; -yy66: - yych = *++p; - if (yych == 'I') goto yy34; - if (yych == 'i') goto yy34; - goto yy31; -yy67: - yych = *++p; - if (yych == 'I') goto yy88; - if (yych == 'i') goto yy88; - goto yy31; -yy68: - yych = *++p; - if (yych <= 'P') { - if (yych == 'L') goto yy78; - if (yych <= 'O') goto yy31; - goto yy79; - } else { - if (yych <= 'l') { - if (yych <= 'k') goto yy31; - goto yy78; - } else { - if (yych == 'p') goto yy79; - goto yy31; - } - } -yy69: - yych = *++p; - if (yych == 'O') goto yy70; - if (yych != 'o') goto yy31; -yy70: - yych = *++p; - if (yych == 'N') goto yy71; - if (yych != 'n') goto yy31; -yy71: - yych = *++p; - if (yych == '-') goto yy72; - if (yych == ':') goto yy35; - goto yy31; -yy72: - yych = *++p; - if (yych == 'U') goto yy73; - if (yych != 'u') goto yy31; -yy73: - yych = *++p; - if (yych == 'S') goto yy74; - if (yych != 's') goto yy31; -yy74: - yych = *++p; - if (yych == 'E') goto yy75; - if (yych != 'e') goto yy31; -yy75: - yych = *++p; - if (yych == 'R') goto yy76; - if (yych != 'r') goto yy31; -yy76: - yych = *++p; - if (yych == 'I') goto yy77; - if (yych != 'i') goto yy31; -yy77: - yych = *++p; - if (yych == 'D') goto yy34; - if (yych == 'd') goto yy34; - goto yy31; -yy78: - yych = *++p; - if (yych == 'R') goto yy80; - if (yych == 'r') goto yy80; - goto yy31; -yy79: - yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; - goto yy31; -yy80: - yych = *++p; - if (yych == 'P') goto yy81; - if (yych != 'p') goto yy31; -yy81: - yych = *++p; - if (yych == 'C') goto yy82; - if (yych != 'c') goto yy31; -yy82: - yych = *++p; - if (yych != '.') goto yy31; - yych = *++p; - if (yych == 'B') goto yy84; - if (yych != 'b') goto yy31; -yy84: - yych = *++p; - if (yych == 'E') goto yy85; - if (yych != 'e') goto yy31; -yy85: - yych = *++p; - if (yych == 'E') goto yy86; - if (yych != 'e') goto yy31; -yy86: - yych = *++p; - if (yych == 'P') goto yy87; - if (yych != 'p') goto yy31; -yy87: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy35; - goto yy31; - } else { - if (yych <= 'S') goto yy34; - if (yych == 's') goto yy34; - goto yy31; - } -yy88: - yych = *++p; - if (yych == 'R') goto yy89; - if (yych != 'r') goto yy31; -yy89: - yych = *++p; - if (yych == 'E') goto yy34; - if (yych == 'e') goto yy34; - goto yy31; -yy90: - yych = *++p; - if (yych == 'C') goto yy98; - if (yych == 'c') goto yy98; - goto yy31; -yy91: - yych = *++p; - if (yych == 'A') goto yy97; - if (yych == 'a') goto yy97; - goto yy31; -yy92: - yych = *++p; - if (yych == 'B') goto yy94; - if (yych == 'b') goto yy94; - goto yy31; -yy93: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy35; - goto yy31; - } else { - if (yych <= 'S') goto yy34; - if (yych == 's') goto yy34; - goto yy31; - } -yy94: - yych = *++p; - if (yych == 'C') goto yy95; - if (yych != 'c') goto yy31; -yy95: - yych = *++p; - if (yych == 'A') goto yy96; - if (yych != 'a') goto yy31; -yy96: - yych = *++p; - if (yych == 'L') goto yy34; - if (yych == 'l') goto yy34; - goto yy31; -yy97: - yych = *++p; - if (yych == 'I') goto yy34; - if (yych == 'i') goto yy34; - goto yy31; -yy98: - yych = *++p; - if (yych == 'I') goto yy99; - if (yych != 'i') goto yy31; -yy99: - yych = *++p; - if (yych == 'W') goto yy100; - if (yych != 'w') goto yy31; -yy100: - yych = *++p; - if (yych == 'Y') goto yy101; - if (yych != 'y') goto yy31; -yy101: - yych = *++p; - if (yych == 'G') goto yy34; - if (yych == 'g') goto yy34; - goto yy31; -yy102: - yych = *++p; - if (yych == 'E') goto yy111; - if (yych == 'e') goto yy111; - goto yy31; -yy103: - yych = *++p; - if (yych <= 'N') { - if (yych <= 'L') goto yy31; - if (yych >= 'N') goto yy105; - } else { - if (yych <= 'l') goto yy31; - if (yych <= 'm') goto yy104; - if (yych <= 'n') goto yy105; - goto yy31; - } -yy104: - yych = *++p; - if (yych == 'M') goto yy110; - if (yych == 'm') goto yy110; - goto yy31; -yy105: - yych = *++p; - if (yych == 'T') goto yy106; - if (yych != 't') goto yy31; -yy106: - yych = *++p; - if (yych == 'R') goto yy107; - if (yych != 'r') goto yy31; -yy107: - yych = *++p; - if (yych == 'I') goto yy108; - if (yych != 'i') goto yy31; -yy108: - yych = *++p; - if (yych == 'L') goto yy109; - if (yych != 'l') goto yy31; -yy109: - yych = *++p; - if (yych == 'O') goto yy34; - if (yych == 'o') goto yy34; - goto yy31; -yy110: - yych = *++p; - if (yych == 'I') goto yy34; - if (yych == 'i') goto yy34; - goto yy31; -yy111: - yych = *++p; - if (yych == 'W') goto yy112; - if (yych != 'w') goto yy31; -yy112: - yych = *++p; - if (yych != '-') goto yy31; - yych = *++p; - if (yych == 'S') goto yy114; - if (yych != 's') goto yy31; -yy114: - yych = *++p; - if (yych == 'O') goto yy115; - if (yych != 'o') goto yy31; -yy115: - yych = *++p; - if (yych == 'U') goto yy116; - if (yych != 'u') goto yy31; -yy116: - yych = *++p; - if (yych == 'R') goto yy117; - if (yych != 'r') goto yy31; -yy117: - yych = *++p; - if (yych == 'C') goto yy118; - if (yych != 'c') goto yy31; -yy118: - yych = *++p; - if (yych == 'E') goto yy34; - if (yych == 'e') goto yy34; - goto yy31; -yy119: - yych = *++p; - if (yych == '2') goto yy126; - goto yy31; -yy120: - yych = *++p; - if (yych == 'R') goto yy123; - if (yych == 'r') goto yy123; - goto yy31; -yy121: - yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; - goto yy31; -yy122: - yych = *++p; - if (yych == 'N') goto yy34; - if (yych == 'n') goto yy34; - goto yy31; -yy123: - yych = *++p; - if (yych == 'E') goto yy124; - if (yych != 'e') goto yy31; -yy124: - yych = *++p; - if (yych == 'A') goto yy125; - if (yych != 'a') goto yy31; -yy125: - yych = *++p; - if (yych == 'L') goto yy34; - if (yych == 'l') goto yy34; - goto yy31; -yy126: - yych = *++p; - if (yych != '0') goto yy31; - yych = *++p; - if (yych != '0') goto yy31; - yych = *++p; - if (yych == '4') goto yy34; - goto yy31; -yy129: - yych = *++p; - if (yych == 'I') goto yy148; - if (yych == 'i') goto yy148; - goto yy31; -yy130: - yych = *++p; - if (yych <= 'L') { - if (yych == 'A') goto yy140; - if (yych <= 'K') goto yy31; - goto yy139; - } else { - if (yych <= 'a') { - if (yych <= '`') goto yy31; - goto yy140; - } else { - if (yych == 'l') goto yy139; - goto yy31; - } - } -yy131: - yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; - goto yy31; -yy132: - yych = *++p; - if (yych == '3') goto yy136; - goto yy31; -yy133: - yych = *++p; - if (yych == 'T') goto yy135; - if (yych == 't') goto yy135; - goto yy31; -yy134: - yych = *++p; - if (yych == 'G') goto yy34; - if (yych == 'g') goto yy34; - goto yy31; -yy135: - yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; - goto yy31; -yy136: - yych = *++p; - if (yych != '2') goto yy31; - yych = *++p; - if (yych != '7') goto yy31; - yych = *++p; - if (yych == '0') goto yy34; - goto yy31; -yy139: - yych = *++p; - if (yych <= 'M') { - if (yych == ':') goto yy35; - goto yy31; - } else { - if (yych <= 'N') goto yy146; - if (yych == 'n') goto yy146; - goto yy31; - } -yy140: - yych = *++p; - if (yych == 'M') goto yy141; - if (yych != 'm') goto yy31; -yy141: - yych = *++p; - if (yych == 'S') goto yy142; - if (yych != 's') goto yy31; -yy142: - yych = *++p; - if (yych == 'P') goto yy143; - if (yych != 'p') goto yy31; -yy143: - yych = *++p; - if (yych == 'E') goto yy144; - if (yych != 'e') goto yy31; -yy144: - yych = *++p; - if (yych == 'A') goto yy145; - if (yych != 'a') goto yy31; -yy145: - yych = *++p; - if (yych == 'K') goto yy34; - if (yych == 'k') goto yy34; - goto yy31; -yy146: - yych = *++p; - if (yych == 'E') goto yy147; - if (yych != 'e') goto yy31; -yy147: - yych = *++p; - if (yych == 'T') goto yy34; - if (yych == 't') goto yy34; - goto yy31; -yy148: - yych = *++p; - if (yych <= 'S') { - if (yych == 'N') goto yy149; - if (yych <= 'R') goto yy31; - goto yy150; - } else { - if (yych <= 'n') { - if (yych <= 'm') goto yy31; - } else { - if (yych == 's') goto yy150; - goto yy31; - } - } -yy149: - yych = *++p; - if (yych == 'G') goto yy157; - if (yych == 'g') goto yy157; - goto yy31; -yy150: - yych = *++p; - if (yych == 'M') goto yy151; - if (yych != 'm') goto yy31; -yy151: - yych = *++p; - if (yych == 'E') goto yy152; - if (yych != 'e') goto yy31; -yy152: - yych = *++p; - if (yych == 'S') goto yy153; - if (yych != 's') goto yy31; -yy153: - yych = *++p; - if (yych == 'S') goto yy154; - if (yych != 's') goto yy31; -yy154: - yych = *++p; - if (yych == 'A') goto yy155; - if (yych != 'a') goto yy31; -yy155: - yych = *++p; - if (yych == 'G') goto yy156; - if (yych != 'g') goto yy31; -yy156: - yych = *++p; - if (yych == 'E') goto yy34; - if (yych == 'e') goto yy34; - goto yy31; -yy157: - yych = *++p; - if (yych == 'S') goto yy34; - if (yych == 's') goto yy34; - goto yy31; -yy158: - yych = *++p; - if (yych == 'N') goto yy34; - if (yych == 'n') goto yy34; - goto yy31; -yy159: - yych = *++p; - if (yych == 'E') goto yy209; - if (yych == 'e') goto yy209; - goto yy31; -yy160: - yych = *++p; - if (yych == 'H') goto yy34; - if (yych == 'h') goto yy34; - goto yy31; -yy161: - yych = *++p; - if (yych == 'O') goto yy205; - if (yych == 'o') goto yy205; - goto yy31; -yy162: - yych = *++p; - if (yych <= 'L') { - if (yych == 'A') goto yy195; - if (yych <= 'K') goto yy31; - goto yy196; - } else { - if (yych <= 'a') { - if (yych <= '`') goto yy31; - goto yy195; - } else { - if (yych == 'l') goto yy196; - goto yy31; - } - } -yy163: - yych = *++p; - if (yych <= 'S') { - if (yych == 'B') goto yy34; - if (yych <= 'R') goto yy31; - goto yy34; - } else { - if (yych <= 'b') { - if (yych <= 'a') goto yy31; - goto yy34; - } else { - if (yych == 's') goto yy34; - goto yy31; - } - } -yy164: - yych = *++p; - if (yych == 'Y') goto yy193; - if (yych == 'y') goto yy193; - goto yy31; -yy165: - yych = *++p; - if (yych == 'N') goto yy34; - if (yych == 'n') goto yy34; - goto yy31; -yy166: - yych = *++p; - if (yych == 'T') goto yy192; - if (yych == 't') goto yy192; - goto yy31; -yy167: - yych = *++p; - if (yych <= 'S') { - if (yych <= 'C') { - if (yych <= 'B') goto yy31; - goto yy179; - } else { - if (yych <= 'Q') goto yy31; - if (yych <= 'R') goto yy177; - goto yy178; - } - } else { - if (yych <= 'q') { - if (yych == 'c') goto yy179; - goto yy31; - } else { - if (yych <= 'r') goto yy177; - if (yych <= 's') goto yy178; - goto yy31; - } - } -yy168: - yych = *++p; - if (yych == 'M') goto yy176; - if (yych == 'm') goto yy176; - goto yy31; -yy169: - yych = *++p; - if (yych <= 'P') { - if (yych == 'E') goto yy173; - if (yych <= 'O') goto yy31; - goto yy174; - } else { - if (yych <= 'e') { - if (yych <= 'd') goto yy31; - goto yy173; - } else { - if (yych == 'p') goto yy174; - goto yy31; - } - } -yy170: - yych = *++p; - if (yych == 'T') goto yy171; - if (yych != 't') goto yy31; -yy171: - yych = *++p; - if (yych == 'T') goto yy172; - if (yych != 't') goto yy31; -yy172: - yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; - goto yy31; -yy173: - yych = *++p; - if (yych == 'V') goto yy175; - if (yych == 'v') goto yy175; - goto yy31; -yy174: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy35; - goto yy31; - } else { - if (yych <= 'S') goto yy34; - if (yych == 's') goto yy34; - goto yy31; - } -yy175: - yych = *++p; - if (yych == 'E') goto yy34; - if (yych == 'e') goto yy34; - goto yy31; -yy176: - yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; - goto yy31; -yy177: - yych = *++p; - if (yych == 'V') goto yy189; - if (yych == 'v') goto yy189; - goto yy31; -yy178: - yych = *++p; - if (yych == 'S') goto yy186; - if (yych == 's') goto yy186; - goto yy31; -yy179: - yych = *++p; - if (yych == 'O') goto yy180; - if (yych != 'o') goto yy31; -yy180: - yych = *++p; - if (yych == 'N') goto yy181; - if (yych != 'n') goto yy31; -yy181: - yych = *++p; - if (yych == 'D') goto yy182; - if (yych != 'd') goto yy31; -yy182: - yych = *++p; - if (yych == 'L') goto yy183; - if (yych != 'l') goto yy31; -yy183: - yych = *++p; - if (yych == 'I') goto yy184; - if (yych != 'i') goto yy31; -yy184: - yych = *++p; - if (yych == 'F') goto yy185; - if (yych != 'f') goto yy31; -yy185: - yych = *++p; - if (yych == 'E') goto yy34; - if (yych == 'e') goto yy34; - goto yy31; -yy186: - yych = *++p; - if (yych == 'I') goto yy187; - if (yych != 'i') goto yy31; -yy187: - yych = *++p; - if (yych == 'O') goto yy188; - if (yych != 'o') goto yy31; -yy188: - yych = *++p; - if (yych == 'N') goto yy34; - if (yych == 'n') goto yy34; - goto yy31; -yy189: - yych = *++p; - if (yych == 'I') goto yy190; - if (yych != 'i') goto yy31; -yy190: - yych = *++p; - if (yych == 'C') goto yy191; - if (yych != 'c') goto yy31; -yy191: - yych = *++p; - if (yych == 'E') goto yy34; - if (yych == 'e') goto yy34; - goto yy31; -yy192: - yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; - goto yy31; -yy193: - yych = *++p; - if (yych == 'P') goto yy194; - if (yych != 'p') goto yy31; -yy194: - yych = *++p; - if (yych == 'E') goto yy34; - if (yych == 'e') goto yy34; - goto yy31; -yy195: - yych = *++p; - if (yych == 'P') goto yy199; - if (yych == 'p') goto yy199; - goto yy31; -yy196: - yych = *++p; - if (yych == 'D') goto yy197; - if (yych != 'd') goto yy31; -yy197: - yych = *++p; - if (yych == 'A') goto yy198; - if (yych != 'a') goto yy31; -yy198: - yych = *++p; - if (yych == 'T') goto yy34; - if (yych == 't') goto yy34; - goto yy31; -yy199: - yych = *++p; - if (yych != '.') goto yy31; - yych = *++p; - if (yych == 'B') goto yy201; - if (yych != 'b') goto yy31; -yy201: - yych = *++p; - if (yych == 'E') goto yy202; - if (yych != 'e') goto yy31; -yy202: - yych = *++p; - if (yych == 'E') goto yy203; - if (yych != 'e') goto yy31; -yy203: - yych = *++p; - if (yych == 'P') goto yy204; - if (yych != 'p') goto yy31; -yy204: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy35; - goto yy31; - } else { - if (yych <= 'S') goto yy34; - if (yych == 's') goto yy34; - goto yy31; - } -yy205: - yych = *++p; - if (yych == 'T') goto yy206; - if (yych != 't') goto yy31; -yy206: - yych = *++p; - if (yych == 'I') goto yy207; - if (yych != 'i') goto yy31; -yy207: - yych = *++p; - if (yych == 'F') goto yy208; - if (yych != 'f') goto yy31; -yy208: - yych = *++p; - if (yych == 'Y') goto yy34; - if (yych == 'y') goto yy34; - goto yy31; -yy209: - yych = *++p; - if (yych == 'A') goto yy210; - if (yych != 'a') goto yy31; -yy210: - yych = *++p; - if (yych == 'M') goto yy34; - if (yych == 'm') goto yy34; - goto yy31; -yy211: - yych = *++p; - if (yych <= 'S') { - if (yych == 'M') goto yy223; - if (yych <= 'R') goto yy31; - goto yy222; - } else { - if (yych <= 'm') { - if (yych <= 'l') goto yy31; - goto yy223; - } else { - if (yych == 's') goto yy222; - goto yy31; - } - } -yy212: - yych = *++p; - if (yych == 'Y') goto yy220; - if (yych == 'y') goto yy220; - goto yy31; -yy213: - yych = *++p; - if (yych == 'I') goto yy34; - if (yych == 'i') goto yy34; - goto yy31; -yy214: - yych = *++p; - if (yych == 'S') goto yy215; - if (yych != 's') goto yy31; -yy215: - yych = *++p; - if (yych <= 'N') { - if (yych == ':') goto yy35; - goto yy31; - } else { - if (yych <= 'O') goto yy216; - if (yych != 'o') goto yy31; - } -yy216: - yych = *++p; - if (yych == 'U') goto yy217; - if (yych != 'u') goto yy31; -yy217: - yych = *++p; - if (yych == 'R') goto yy218; - if (yych != 'r') goto yy31; -yy218: - yych = *++p; - if (yych == 'C') goto yy219; - if (yych != 'c') goto yy31; -yy219: - yych = *++p; - if (yych == 'E') goto yy34; - if (yych == 'e') goto yy34; - goto yy31; -yy220: - yych = *++p; - if (yych == 'N') goto yy221; - if (yych != 'n') goto yy31; -yy221: - yych = *++p; - if (yych == 'C') goto yy34; - if (yych == 'c') goto yy34; - goto yy31; -yy222: - yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; - goto yy31; -yy223: - yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; - goto yy31; -yy224: - yych = *++p; - if (yych == 'Y') goto yy244; - if (yych == 'y') goto yy244; - goto yy31; -yy225: - yych = *++p; - if (yych <= 'O') { - if (yych == 'E') goto yy241; - if (yych <= 'N') goto yy31; - goto yy242; - } else { - if (yych <= 'e') { - if (yych <= 'd') goto yy31; - goto yy241; - } else { - if (yych == 'o') goto yy242; - goto yy31; - } - } -yy226: - yych = *++p; - if (yych == 'A') goto yy236; - if (yych == 'a') goto yy236; - goto yy31; -yy227: - yych = *++p; - if (yych <= 'P') { - if (yych == 'L') goto yy229; - if (yych <= 'O') goto yy31; - goto yy230; - } else { - if (yych <= 'l') { - if (yych <= 'k') goto yy31; - goto yy229; - } else { - if (yych == 'p') goto yy230; - goto yy31; - } - } -yy228: - yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; - goto yy31; -yy229: - yych = *++p; - if (yych == 'M') goto yy34; - if (yych == 'm') goto yy34; - goto yy31; -yy230: - yych = *++p; - if (yych == 'A') goto yy231; - if (yych != 'a') goto yy31; -yy231: - yych = *++p; - if (yych == 'R') goto yy232; - if (yych != 'r') goto yy31; -yy232: - yych = *++p; - if (yych == 'A') goto yy233; - if (yych != 'a') goto yy31; -yy233: - yych = *++p; - if (yych == 'Z') goto yy234; - if (yych != 'z') goto yy31; -yy234: - yych = *++p; - if (yych == 'Z') goto yy235; - if (yych != 'z') goto yy31; -yy235: - yych = *++p; - if (yych == 'I') goto yy34; - if (yych == 'i') goto yy34; - goto yy31; -yy236: - yych = *++p; - if (yych == 'T') goto yy237; - if (yych != 't') goto yy31; -yy237: - yych = *++p; - if (yych == 'F') goto yy238; - if (yych != 'f') goto yy31; -yy238: - yych = *++p; - if (yych == 'O') goto yy239; - if (yych != 'o') goto yy31; -yy239: - yych = *++p; - if (yych == 'R') goto yy240; - if (yych != 'r') goto yy31; -yy240: - yych = *++p; - if (yych == 'M') goto yy34; - if (yych == 'm') goto yy34; - goto yy31; -yy241: - yych = *++p; - if (yych == 'S') goto yy34; - if (yych == 's') goto yy34; - goto yy31; -yy242: - yych = *++p; - if (yych == 'X') goto yy243; - if (yych != 'x') goto yy31; -yy243: - yych = *++p; - if (yych == 'Y') goto yy34; - if (yych == 'y') goto yy34; - goto yy31; -yy244: - yych = *++p; - if (yych == 'C') goto yy34; - if (yych == 'c') goto yy34; - goto yy31; -yy245: - yych = *++p; - if (yych == 'D') goto yy34; - if (yych == 'd') goto yy34; - goto yy31; -yy246: - yych = *++p; - if (yych == 'A') goto yy247; - if (yych != 'a') goto yy31; -yy247: - yych = *++p; - if (yych == 'Q') goto yy248; - if (yych != 'q') goto yy31; -yy248: - yych = *++p; - if (yych == 'U') goto yy249; - if (yych != 'u') goto yy31; -yy249: - yych = *++p; - if (yych == 'E') goto yy250; - if (yych != 'e') goto yy31; -yy250: - yych = *++p; - if (yych == 'L') goto yy251; - if (yych != 'l') goto yy31; -yy251: - yych = *++p; - if (yych == 'O') goto yy252; - if (yych != 'o') goto yy31; -yy252: - yych = *++p; - if (yych == 'C') goto yy253; - if (yych != 'c') goto yy31; -yy253: - yych = *++p; - if (yych == 'K') goto yy254; - if (yych != 'k') goto yy31; -yy254: - yych = *++p; - if (yych == 'T') goto yy255; - if (yych != 't') goto yy31; -yy255: - yych = *++p; - if (yych == 'O') goto yy256; - if (yych != 'o') goto yy31; -yy256: - yych = *++p; - if (yych == 'K') goto yy257; - if (yych != 'k') goto yy31; -yy257: - yych = *++p; - if (yych == 'E') goto yy258; - if (yych != 'e') goto yy31; -yy258: - yych = *++p; - if (yych == 'N') goto yy34; - if (yych == 'n') goto yy34; - goto yy31; -yy259: - yych = *++p; - if (yych == 'T') goto yy266; - if (yych == 't') goto yy266; - goto yy31; -yy260: - yych = *++p; - if (yych == 'T') goto yy265; - if (yych == 't') goto yy265; - goto yy31; -yy261: - yych = *++p; - if (yych <= 'G') { - if (yych == ':') goto yy35; - goto yy31; - } else { - if (yych <= 'H') goto yy34; - if (yych == 'h') goto yy34; - goto yy31; - } -yy262: - yych = *++p; - if (yych == 'S') goto yy34; - if (yych == 's') goto yy34; - goto yy31; -yy263: - yych = *++p; - if (yych == 'W') goto yy264; - if (yych != 'w') goto yy31; -yy264: - yych = *++p; - if (yych == 'S') goto yy34; - if (yych == 's') goto yy34; - goto yy31; -yy265: - yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; - goto yy31; -yy266: - yych = *++p; - if (yych == 'E') goto yy267; - if (yych != 'e') goto yy31; -yy267: - yych = *++p; - if (yych == 'S') goto yy34; - if (yych == 's') goto yy34; - goto yy31; -yy268: - yych = *++p; - if (yych == 'N') goto yy34; - if (yych == 'n') goto yy34; - goto yy31; -yy269: - yych = *++p; - if (yych <= 'P') { - if (yych == 'M') goto yy300; - if (yych <= 'O') goto yy31; - goto yy299; - } else { - if (yych <= 'm') { - if (yych <= 'l') goto yy31; - goto yy300; - } else { - if (yych == 'p') goto yy299; - goto yy31; - } - } -yy270: - yych = *++p; - if (yych <= 'Q') { - if (yych <= '-') { - if (yych <= ',') goto yy31; - goto yy292; - } else { - if (yych == 'N') goto yy293; - goto yy31; - } - } else { - if (yych <= 'n') { - if (yych <= 'R') goto yy291; - if (yych <= 'm') goto yy31; - goto yy293; - } else { - if (yych == 'r') goto yy291; - goto yy31; - } - } -yy271: - yych = *++p; - if (yych == 'S') goto yy34; - if (yych == 's') goto yy34; - goto yy31; -yy272: - yych = *++p; - if (yych == 'S') goto yy287; - if (yych == 's') goto yy287; - goto yy31; -yy273: - yych = *++p; - switch (yych) { - case 'G': - case 'g': goto yy278; - case 'I': - case 'i': goto yy277; - case 'P': - case 'p': goto yy279; - case 'R': - case 'r': goto yy280; - default: goto yy31; - } -yy274: - yych = *++p; - if (yych == 'Q') goto yy276; - if (yych == 'q') goto yy276; - goto yy31; -yy275: - yych = *++p; - if (yych == 'D') goto yy34; - if (yych == 'd') goto yy34; - goto yy31; -yy276: - yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; - goto yy31; -yy277: - yych = *++p; - if (yych == 'L') goto yy285; - if (yych == 'l') goto yy285; - goto yy31; -yy278: - yych = *++p; - if (yych == 'N') goto yy283; - if (yych == 'n') goto yy283; - goto yy31; -yy279: - yych = *++p; - if (yych == 'S') goto yy34; - if (yych == 's') goto yy34; - goto yy31; -yy280: - yych = *++p; - if (yych == 'K') goto yy281; - if (yych != 'k') goto yy31; -yy281: - yych = *++p; - if (yych == 'E') goto yy282; - if (yych != 'e') goto yy31; -yy282: - yych = *++p; - if (yych == 'T') goto yy34; - if (yych == 't') goto yy34; - goto yy31; -yy283: - yych = *++p; - if (yych == 'E') goto yy284; - if (yych != 'e') goto yy31; -yy284: - yych = *++p; - if (yych == 'T') goto yy34; - if (yych == 't') goto yy34; - goto yy31; -yy285: - yych = *++p; - if (yych == 'T') goto yy286; - if (yych != 't') goto yy31; -yy286: - yych = *++p; - if (yych == 'O') goto yy34; - if (yych == 'o') goto yy34; - goto yy31; -yy287: - yych = *++p; - if (yych == 'S') goto yy288; - if (yych != 's') goto yy31; -yy288: - yych = *++p; - if (yych == 'A') goto yy289; - if (yych != 'a') goto yy31; -yy289: - yych = *++p; - if (yych == 'G') goto yy290; - if (yych != 'g') goto yy31; -yy290: - yych = *++p; - if (yych == 'E') goto yy34; - if (yych == 'e') goto yy34; - goto yy31; -yy291: - yych = *++p; - if (yych == 'P') goto yy298; - if (yych == 'p') goto yy298; - goto yy31; -yy292: - yych = *++p; - if (yych == 'H') goto yy295; - if (yych == 'h') goto yy295; - goto yy31; -yy293: - yych = *++p; - if (yych == 'I') goto yy294; - if (yych != 'i') goto yy31; -yy294: - yych = *++p; - if (yych == 'M') goto yy34; - if (yych == 'm') goto yy34; - goto yy31; -yy295: - yych = *++p; - if (yych == 'E') goto yy296; - if (yych != 'e') goto yy31; -yy296: - yych = *++p; - if (yych == 'L') goto yy297; - if (yych != 'l') goto yy31; -yy297: - yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; - goto yy31; -yy298: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy35; - goto yy31; - } else { - if (yych <= 'S') goto yy34; - if (yych == 's') goto yy34; - goto yy31; - } -yy299: - yych = *++p; - if (yych == 'D') goto yy303; - if (yych == 'd') goto yy303; - goto yy31; -yy300: - yych = *++p; - if (yych == 'B') goto yy301; - if (yych != 'b') goto yy31; -yy301: - yych = *++p; - if (yych == 'L') goto yy302; - if (yych != 'l') goto yy31; -yy302: - yych = *++p; - if (yych == 'E') goto yy34; - if (yych == 'e') goto yy34; - goto yy31; -yy303: - yych = *++p; - if (yych == 'A') goto yy304; - if (yych != 'a') goto yy31; -yy304: - yych = *++p; - if (yych == 'T') goto yy305; - if (yych != 't') goto yy31; -yy305: - yych = *++p; - if (yych == 'E') goto yy34; - if (yych == 'e') goto yy34; - goto yy31; -yy306: - yych = *++p; - if (yych == 'A') goto yy311; - if (yych == 'a') goto yy311; - goto yy31; -yy307: - yych = *++p; - if (yych == 'S') goto yy308; - if (yych != 's') goto yy31; -yy308: - yych = *++p; - if (yych == 'T') goto yy309; - if (yych != 't') goto yy31; -yy309: - yych = *++p; - if (yych == 'F') goto yy310; - if (yych != 'f') goto yy31; -yy310: - yych = *++p; - if (yych == 'M') goto yy34; - if (yych == 'm') goto yy34; - goto yy31; -yy311: - yych = *++p; - if (yych == 'P') goto yy312; - if (yych != 'p') goto yy31; -yy312: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy35; - goto yy31; - } else { - if (yych <= 'S') goto yy34; - if (yych == 's') goto yy34; - goto yy31; - } -yy313: - yych = *++p; - if (yych == 'M') goto yy336; - if (yych == 'm') goto yy336; - goto yy31; -yy314: - yych = *++p; - if (yych <= 'I') { - if (yych == 'C') goto yy325; - if (yych <= 'H') goto yy31; - goto yy324; - } else { - if (yych <= 'c') { - if (yych <= 'b') goto yy31; - goto yy325; - } else { - if (yych == 'i') goto yy324; - goto yy31; - } - } -yy315: - yych = *++p; - if (yych <= 'P') { - if (yych == 'N') goto yy34; - if (yych <= 'O') goto yy31; - goto yy34; - } else { - if (yych <= 'n') { - if (yych <= 'm') goto yy31; - goto yy34; - } else { - if (yych == 'p') goto yy34; - goto yy31; - } - } -yy316: - yych = *++p; - if (yych <= 'O') { - if (yych == 'A') goto yy322; - if (yych <= 'N') goto yy31; - goto yy323; - } else { - if (yych <= 'a') { - if (yych <= '`') goto yy31; - goto yy322; - } else { - if (yych == 'o') goto yy323; - goto yy31; - } - } -yy317: - yych = *++p; - if (yych == 'F') goto yy321; - if (yych == 'f') goto yy321; - goto yy31; -yy318: - yych = *++p; - if (yych <= '@') { - if (yych == ':') goto yy35; - goto yy31; - } else { - if (yych <= 'A') goto yy320; - if (yych == 'a') goto yy320; - goto yy31; - } -yy319: - yych = *++p; - if (yych == 'X') goto yy34; - if (yych == 'x') goto yy34; - goto yy31; -yy320: - yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; - goto yy31; -yy321: - yych = *++p; - if (yych == 'O') goto yy34; - if (yych == 'o') goto yy34; - goto yy31; -yy322: - yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; - goto yy31; -yy323: - yych = *++p; - if (yych == 'N') goto yy34; - if (yych == 'n') goto yy34; - goto yy31; -yy324: - yych = *++p; - if (yych == 'S') goto yy326; - if (yych == 's') goto yy326; - goto yy31; -yy325: - yych = *++p; - if (yych <= ':') { - if (yych == '6') goto yy34; - if (yych <= '9') goto yy31; - goto yy35; - } else { - if (yych <= 'S') { - if (yych <= 'R') goto yy31; - goto yy34; - } else { - if (yych == 's') goto yy34; - goto yy31; - } - } -yy326: - yych = *++p; - if (yych == '.') goto yy327; - if (yych == ':') goto yy35; - goto yy31; -yy327: - yych = *++p; - if (yych <= 'X') { - if (yych <= 'K') { - if (yych == 'B') goto yy330; - goto yy31; - } else { - if (yych <= 'L') goto yy328; - if (yych <= 'W') goto yy31; - goto yy329; - } - } else { - if (yych <= 'k') { - if (yych == 'b') goto yy330; - goto yy31; - } else { - if (yych <= 'l') goto yy328; - if (yych == 'x') goto yy329; - goto yy31; - } - } -yy328: - yych = *++p; - if (yych == 'W') goto yy335; - if (yych == 'w') goto yy335; - goto yy31; -yy329: - yych = *++p; - if (yych == 'P') goto yy333; - if (yych == 'p') goto yy333; - goto yy31; -yy330: - yych = *++p; - if (yych == 'E') goto yy331; - if (yych != 'e') goto yy31; -yy331: - yych = *++p; - if (yych == 'E') goto yy332; - if (yych != 'e') goto yy31; -yy332: - yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; - goto yy31; -yy333: - yych = *++p; - if (yych == 'C') goto yy334; - if (yych != 'c') goto yy31; -yy334: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy35; - goto yy31; - } else { - if (yych <= 'S') goto yy34; - if (yych == 's') goto yy34; - goto yy31; - } -yy335: - yych = *++p; - if (yych == 'Z') goto yy34; - if (yych == 'z') goto yy34; - goto yy31; -yy336: - yych = *++p; - if (yych == 'S') goto yy34; - if (yych == 's') goto yy34; - goto yy31; -yy337: - yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; - goto yy31; -yy338: - yych = *++p; - if (yych == 'T') goto yy341; - if (yych == 't') goto yy341; - goto yy31; -yy339: - yych = *++p; - if (yych != '2') goto yy31; - yych = *++p; - if (yych == '3') goto yy34; - goto yy31; -yy341: - yych = *++p; - if (yych == 'P') goto yy342; - if (yych != 'p') goto yy31; -yy342: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy35; - goto yy31; - } else { - if (yych <= 'S') goto yy34; - if (yych == 's') goto yy34; - goto yy31; - } -yy343: - yych = *++p; - if (yych == 'A') goto yy359; - if (yych == 'a') goto yy359; - goto yy31; -yy344: - yych = *++p; - if (yych <= 'Z') { - if (yych == 'T') goto yy34; - if (yych <= 'Y') goto yy31; - goto yy350; - } else { - if (yych <= 't') { - if (yych <= 's') goto yy31; - goto yy34; - } else { - if (yych == 'z') goto yy350; - goto yy31; - } - } -yy345: - yych = *++p; - if (yych <= 'O') { - if (yych == ':') goto yy35; - goto yy31; - } else { - if (yych <= 'P') goto yy347; - if (yych == 'p') goto yy347; - goto yy31; - } -yy346: - yych = *++p; - if (yych == 'O') goto yy34; - if (yych == 'o') goto yy34; - goto yy31; -yy347: - yych = *++p; - if (yych == 'H') goto yy348; - if (yych != 'h') goto yy31; -yy348: - yych = *++p; - if (yych == 'E') goto yy349; - if (yych != 'e') goto yy31; -yy349: - yych = *++p; - if (yych == 'R') goto yy34; - if (yych == 'r') goto yy34; - goto yy31; -yy350: - yych = *++p; - if (yych == 'M') goto yy351; - if (yych != 'm') goto yy31; -yy351: - yych = *++p; - if (yych == 'O') goto yy352; - if (yych != 'o') goto yy31; -yy352: - yych = *++p; - if (yych == 'P') goto yy353; - if (yych != 'p') goto yy31; -yy353: - yych = *++p; - if (yych == 'R') goto yy354; - if (yych != 'r') goto yy31; -yy354: - yych = *++p; - if (yych == 'O') goto yy355; - if (yych != 'o') goto yy31; -yy355: - yych = *++p; - if (yych == 'J') goto yy356; - if (yych != 'j') goto yy31; -yy356: - yych = *++p; - if (yych == 'E') goto yy357; - if (yych != 'e') goto yy31; -yy357: - yych = *++p; - if (yych == 'C') goto yy358; - if (yych != 'c') goto yy31; -yy358: - yych = *++p; - if (yych == 'T') goto yy34; - if (yych == 't') goto yy34; - goto yy31; -yy359: - yych = *++p; - if (yych == 'L') goto yy360; - if (yych != 'l') goto yy31; -yy360: - yych = *++p; - if (yych == 'K') goto yy34; - if (yych == 'k') goto yy34; - goto yy31; -yy361: - yych = *++p; - if (yych <= 'S') { - if (yych <= 'M') { - if (yych == 'L') goto yy371; - goto yy31; - } else { - if (yych <= 'N') goto yy372; - if (yych <= 'R') goto yy31; - goto yy373; - } - } else { - if (yych <= 'm') { - if (yych == 'l') goto yy371; - goto yy31; - } else { - if (yych <= 'n') goto yy372; - if (yych == 's') goto yy373; - goto yy31; - } - } -yy362: - yych = *++p; - if (yych == 'E') goto yy370; - if (yych == 'e') goto yy370; - goto yy31; -yy363: - yych = *++p; - if (yych == 'C') goto yy365; - if (yych == 'c') goto yy365; - goto yy31; -yy364: - yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; - goto yy31; -yy365: - yych = *++p; - if (yych == 'E') goto yy366; - if (yych != 'e') goto yy31; -yy366: - yych = *++p; - if (yych == 'T') goto yy367; - if (yych != 't') goto yy31; -yy367: - yych = *++p; - if (yych == 'I') goto yy368; - if (yych != 'i') goto yy31; -yy368: - yych = *++p; - if (yych == 'M') goto yy369; - if (yych != 'm') goto yy31; -yy369: - yych = *++p; - if (yych == 'E') goto yy34; - if (yych == 'e') goto yy34; - goto yy31; -yy370: - yych = *++p; - if (yych == 'D') goto yy34; - if (yych == 'd') goto yy34; - goto yy31; -yy371: - yych = *++p; - if (yych == 'E') goto yy34; - if (yych == 'e') goto yy34; - goto yy31; -yy372: - yych = *++p; - if (yych == 'G') goto yy374; - if (yych == 'g') goto yy374; - goto yy31; -yy373: - yych = *++p; - if (yych == 'H') goto yy34; - if (yych == 'h') goto yy34; - goto yy31; -yy374: - yych = *++p; - if (yych == 'E') goto yy375; - if (yych != 'e') goto yy31; -yy375: - yych = *++p; - if (yych == 'R') goto yy34; - if (yych == 'r') goto yy34; - goto yy31; -yy376: - yych = *++p; - if (yych == 'T') goto yy394; - if (yych == 't') goto yy394; - goto yy31; -yy377: - yych = *++p; - if (yych == 'T') goto yy34; - if (yych == 't') goto yy34; - goto yy31; -yy378: - yych = *++p; - if (yych == 'M') goto yy34; - if (yych == 'm') goto yy34; - goto yy31; -yy379: - yych = *++p; - if (yych <= 'S') { - if (yych == 'P') goto yy34; - if (yych <= 'R') goto yy31; - goto yy34; - } else { - if (yych <= 'p') { - if (yych <= 'o') goto yy31; - goto yy34; - } else { - if (yych == 's') goto yy34; - goto yy31; - } - } -yy380: - yych = *++p; - if (yych == 'I') goto yy388; - if (yych == 'i') goto yy388; - goto yy31; -yy381: - yych = *++p; - if (yych == 'A') goto yy387; - if (yych == 'a') goto yy387; - goto yy31; -yy382: - yych = *++p; - if (yych == 'O') goto yy385; - if (yych == 'o') goto yy385; - goto yy31; -yy383: - yych = *++p; - if (yych == 'A') goto yy384; - if (yych != 'a') goto yy31; -yy384: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy35; - goto yy31; - } else { - if (yych <= 'S') goto yy34; - if (yych == 's') goto yy34; - goto yy31; - } -yy385: - yych = *++p; - if (yych == 'U') goto yy386; - if (yych != 'u') goto yy31; -yy386: - yych = *++p; - if (yych == 'T') goto yy34; - if (yych == 't') goto yy34; - goto yy31; -yy387: - yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; - goto yy31; -yy388: - yych = *++p; - if (yych == 'U') goto yy389; - if (yych != 'u') goto yy31; -yy389: - yych = *++p; - if (yych == 'M') goto yy390; - if (yych != 'm') goto yy31; -yy390: - yych = *++p; - if (yych == 'X') goto yy391; - if (yych != 'x') goto yy31; -yy391: - yych = *++p; - if (yych == 'T') goto yy392; - if (yych != 't') goto yy31; -yy392: - yych = *++p; - if (yych == 'R') goto yy393; - if (yych != 'r') goto yy31; -yy393: - yych = *++p; - if (yych == 'A') goto yy34; - if (yych == 'a') goto yy34; - goto yy31; -yy394: - yych = *++p; - if (yych == 'A') goto yy395; - if (yych != 'a') goto yy31; -yy395: - yych = *++p; - if (yych == 'C') goto yy396; - if (yych != 'c') goto yy31; -yy396: - yych = *++p; - if (yych == 'H') goto yy397; - if (yych != 'h') goto yy31; -yy397: - yych = *++p; - if (yych == 'M') goto yy398; - if (yych != 'm') goto yy31; -yy398: - yych = *++p; - if (yych == 'E') goto yy399; - if (yych != 'e') goto yy31; -yy399: - yych = *++p; - if (yych == 'N') goto yy400; - if (yych != 'n') goto yy31; -yy400: - yych = *++p; - if (yych == 'T') goto yy34; - if (yych == 't') goto yy34; - goto yy31; -yy401: - yych = *++p; - if (yych == 'S') goto yy34; - if (yych == 's') goto yy34; - goto yy31; -yy402: - yych = *++p; - if (yych <= 'V') { - if (yych == 'R') goto yy34; - if (yych <= 'U') goto yy31; - } else { - if (yych <= 'r') { - if (yych <= 'q') goto yy31; - goto yy34; - } else { - if (yych != 'v') goto yy31; - } - } - yych = *++p; - if (yych == 'A') goto yy404; - if (yych != 'a') goto yy31; -yy404: - yych = *++p; - if (yych == 'S') goto yy405; - if (yych != 's') goto yy31; -yy405: - yych = *++p; - if (yych == 'C') goto yy406; - if (yych != 'c') goto yy31; -yy406: - yych = *++p; - if (yych == 'R') goto yy407; - if (yych != 'r') goto yy31; -yy407: - yych = *++p; - if (yych == 'I') goto yy408; - if (yych != 'i') goto yy31; -yy408: - yych = *++p; - if (yych == 'P') goto yy409; - if (yych != 'p') goto yy31; -yy409: - yych = *++p; - if (yych == 'T') goto yy34; - if (yych == 't') goto yy34; - goto yy31; -yy410: - yych = *++p; - if (yych == 'B') goto yy34; - if (yych == 'b') goto yy34; - goto yy31; -yy411: - yych = *++p; - if (yych == 'N') goto yy34; - if (yych == 'n') goto yy34; - goto yy31; -yy412: - yych = *++p; - if (yych == 'N') goto yy419; - if (yych == 'n') goto yy419; - goto yy31; -yy413: - yych = *++p; - if (yych == 'S') goto yy34; - if (yych == 's') goto yy34; - goto yy31; -yy414: - yych = *++p; - if (yych == 'C') goto yy418; - if (yych == 'c') goto yy418; - goto yy31; -yy415: - yych = *++p; - if (yych <= 'V') { - if (yych == 'T') goto yy417; - if (yych <= 'U') goto yy31; - goto yy34; - } else { - if (yych <= 't') { - if (yych <= 's') goto yy31; - goto yy417; - } else { - if (yych == 'v') goto yy34; - goto yy31; - } - } -yy416: - yych = *++p; - if (yych == 'I') goto yy34; - if (yych == 'i') goto yy34; - goto yy31; -yy417: - yych = *++p; - if (yych == 'A') goto yy34; - if (yych == 'a') goto yy34; - goto yy31; -yy418: - yych = *++p; - if (yych == 'T') goto yy34; - if (yych == 't') goto yy34; - goto yy31; -yy419: - yych = *++p; - if (yych == 'A') goto yy420; - if (yych != 'a') goto yy31; -yy420: - yych = *++p; - if (yych != '-') goto yy31; - yych = *++p; - if (yych == 'P') goto yy422; - if (yych != 'p') goto yy31; -yy422: - yych = *++p; - if (yych == 'L') goto yy423; - if (yych != 'l') goto yy31; -yy423: - yych = *++p; - if (yych == 'A') goto yy424; - if (yych != 'a') goto yy31; -yy424: - yych = *++p; - if (yych == 'Y') goto yy425; - if (yych != 'y') goto yy31; -yy425: - yych = *++p; - if (yych <= 'S') { - if (yych == 'C') goto yy426; - if (yych <= 'R') goto yy31; - goto yy427; - } else { - if (yych <= 'c') { - if (yych <= 'b') goto yy31; - } else { - if (yych == 's') goto yy427; - goto yy31; - } - } -yy426: - yych = *++p; - if (yych == 'O') goto yy432; - if (yych == 'o') goto yy432; - goto yy31; -yy427: - yych = *++p; - if (yych == 'I') goto yy428; - if (yych != 'i') goto yy31; -yy428: - yych = *++p; - if (yych == 'N') goto yy429; - if (yych != 'n') goto yy31; -yy429: - yych = *++p; - if (yych == 'G') goto yy430; - if (yych != 'g') goto yy31; -yy430: - yych = *++p; - if (yych == 'L') goto yy431; - if (yych != 'l') goto yy31; -yy431: - yych = *++p; - if (yych == 'E') goto yy34; - if (yych == 'e') goto yy34; - goto yy31; -yy432: - yych = *++p; - if (yych == 'N') goto yy433; - if (yych != 'n') goto yy31; -yy433: - yych = *++p; - if (yych == 'T') goto yy434; - if (yych != 't') goto yy31; -yy434: - yych = *++p; - if (yych == 'A') goto yy435; - if (yych != 'a') goto yy31; -yy435: - yych = *++p; - if (yych == 'I') goto yy436; - if (yych != 'i') goto yy31; -yy436: - yych = *++p; - if (yych == 'N') goto yy437; - if (yych != 'n') goto yy31; -yy437: - yych = *++p; - if (yych == 'E') goto yy438; - if (yych != 'e') goto yy31; -yy438: - yych = *++p; - if (yych == 'R') goto yy34; - if (yych == 'r') goto yy34; - goto yy31; -yy439: - yych = *++p; - if (yych == 'S') goto yy34; - if (yych == 's') goto yy34; - goto yy31; -yy440: - yych = *++p; - if (yych <= 'N') { - if (yych <= 'A') { - if (yych <= '@') goto yy31; - goto yy462; - } else { - if (yych <= 'L') goto yy31; - if (yych <= 'M') goto yy463; - goto yy464; - } - } else { - if (yych <= 'l') { - if (yych == 'a') goto yy462; - goto yy31; - } else { - if (yych <= 'm') goto yy463; - if (yych <= 'n') goto yy464; - goto yy31; - } - } -yy441: - yych = *++p; - if (yych == 'R') goto yy449; - if (yych == 'r') goto yy449; - goto yy31; -yy442: - yych = *++p; - if (yych <= 'P') { - if (yych == 'L') goto yy446; - if (yych <= 'O') goto yy31; - goto yy34; - } else { - if (yych <= 'l') { - if (yych <= 'k') goto yy31; - goto yy446; - } else { - if (yych == 'p') goto yy34; - goto yy31; - } - } -yy443: - yych = *++p; - if (yych == 'I') goto yy445; - if (yych == 'i') goto yy445; - goto yy31; -yy444: - yych = *++p; - if (yych == 'D') goto yy34; - if (yych == 'd') goto yy34; - goto yy31; -yy445: - yych = *++p; - if (yych == 'D') goto yy34; - if (yych == 'd') goto yy34; - goto yy31; -yy446: - yych = *++p; - if (yych == 'L') goto yy447; - if (yych != 'l') goto yy31; -yy447: - yych = *++p; - if (yych == 'T') goto yy448; - if (yych != 't') goto yy31; -yy448: - yych = *++p; - if (yych == 'O') goto yy34; - if (yych == 'o') goto yy34; - goto yy31; -yy449: - yych = *++p; - if (yych == 'O') goto yy450; - if (yych != 'o') goto yy31; -yy450: - yych = *++p; - if (yych == 'M') goto yy451; - if (yych != 'm') goto yy31; -yy451: - yych = *++p; - if (yych == 'E') goto yy452; - if (yych != 'e') goto yy31; -yy452: - yych = *++p; - if (yych == '-') goto yy453; - if (yych == ':') goto yy35; - goto yy31; -yy453: - yych = *++p; - if (yych == 'E') goto yy454; - if (yych != 'e') goto yy31; -yy454: - yych = *++p; - if (yych == 'X') goto yy455; - if (yych != 'x') goto yy31; -yy455: - yych = *++p; - if (yych == 'T') goto yy456; - if (yych != 't') goto yy31; -yy456: - yych = *++p; - if (yych == 'E') goto yy457; - if (yych != 'e') goto yy31; -yy457: - yych = *++p; - if (yych == 'N') goto yy458; - if (yych != 'n') goto yy31; -yy458: - yych = *++p; - if (yych == 'S') goto yy459; - if (yych != 's') goto yy31; -yy459: - yych = *++p; - if (yych == 'I') goto yy460; - if (yych != 'i') goto yy31; -yy460: - yych = *++p; - if (yych == 'O') goto yy461; - if (yych != 'o') goto yy31; -yy461: - yych = *++p; - if (yych == 'N') goto yy34; - if (yych == 'n') goto yy34; - goto yy31; -yy462: - yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; - goto yy31; -yy463: - yych = *++p; - if (yych == '-') goto yy468; - goto yy31; -yy464: - yych = *++p; - if (yych == 'T') goto yy465; - if (yych != 't') goto yy31; -yy465: - yych = *++p; - if (yych == 'E') goto yy466; - if (yych != 'e') goto yy31; -yy466: - yych = *++p; - if (yych == 'N') goto yy467; - if (yych != 'n') goto yy31; -yy467: - yych = *++p; - if (yych == 'T') goto yy34; - if (yych == 't') goto yy34; - goto yy31; -yy468: - yych = *++p; - if (yych == 'E') goto yy469; - if (yych != 'e') goto yy31; -yy469: - yych = *++p; - if (yych == 'V') goto yy470; - if (yych != 'v') goto yy31; -yy470: - yych = *++p; - if (yych == 'E') goto yy471; - if (yych != 'e') goto yy31; -yy471: - yych = *++p; - if (yych == 'N') goto yy472; - if (yych != 'n') goto yy31; -yy472: - yych = *++p; - if (yych == 'T') goto yy473; - if (yych != 't') goto yy31; -yy473: - yych = *++p; - if (yych == 'B') goto yy474; - if (yych != 'b') goto yy31; -yy474: - yych = *++p; - if (yych == 'R') goto yy475; - if (yych != 'r') goto yy31; -yy475: - yych = *++p; - if (yych == 'I') goto yy476; - if (yych != 'i') goto yy31; -yy476: - yych = *++p; - if (yych == 'T') goto yy477; - if (yych != 't') goto yy31; -yy477: - yych = *++p; - if (yych == 'E') goto yy478; - if (yych != 'e') goto yy31; -yy478: - yych = *++p; - if (yych != '-') goto yy31; - yych = *++p; - if (yych == 'A') goto yy480; - if (yych != 'a') goto yy31; -yy480: - yych = *++p; - if (yych == 'T') goto yy481; - if (yych != 't') goto yy31; -yy481: - yych = *++p; - if (yych == 'T') goto yy482; - if (yych != 't') goto yy31; -yy482: - yych = *++p; - if (yych == 'E') goto yy483; - if (yych != 'e') goto yy31; -yy483: - yych = *++p; - if (yych == 'N') goto yy484; - if (yych != 'n') goto yy31; -yy484: - yych = *++p; - if (yych == 'D') goto yy485; - if (yych != 'd') goto yy31; -yy485: - yych = *++p; - if (yych == 'E') goto yy486; - if (yych != 'e') goto yy31; -yy486: - ++p; - if ((yych = *p) == 'E') goto yy34; - if (yych == 'e') goto yy34; - goto yy31; -} - -} - -// Try to match email autolink after first <, returning num of chars matched. -int _scan_autolink_email(const unsigned char *p) -{ - const unsigned char *marker = NULL; - const unsigned char *start = p; - -{ - unsigned char yych; - static const unsigned char yybm[] = { - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 128, 0, 128, 128, 128, 128, 128, - 0, 0, 128, 128, 0, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 0, 0, 0, 128, 0, 128, - 0, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 0, 0, 0, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - }; - yych = *p; - if (yych <= ',') { - if (yych <= '!') { - if (yych == '\n') goto yy489; - if (yych <= ' ') goto yy491; - goto yy490; - } else { - if (yych <= '\'') { - if (yych <= '"') goto yy491; - goto yy490; - } else { - if (yych <= ')') goto yy491; - if (yych <= '+') goto yy490; - goto yy491; - } - } - } else { - if (yych <= '?') { - if (yych <= '<') { - if (yych <= '9') goto yy490; - goto yy491; - } else { - if (yych == '>') goto yy491; - goto yy490; - } - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy491; - goto yy490; - } else { - if (yych <= ']') goto yy491; - if (yych <= '~') goto yy490; - goto yy491; - } - } - } -yy489: - { return 0; } -yy490: - yych = *(marker = ++p); - if (yych <= ',') { - if (yych <= '"') { - if (yych == '!') goto yy495; - goto yy489; - } else { - if (yych <= '\'') goto yy495; - if (yych <= ')') goto yy489; - if (yych <= '+') goto yy495; - goto yy489; - } - } else { - if (yych <= '>') { - if (yych <= '9') goto yy495; - if (yych == '=') goto yy495; - goto yy489; - } else { - if (yych <= 'Z') goto yy495; - if (yych <= ']') goto yy489; - if (yych <= '~') goto yy495; - goto yy489; - } - } -yy491: - yych = *++p; - goto yy489; -yy492: - yych = *++p; - if (yych <= '@') { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy496; - } else { - if (yych <= 'Z') goto yy496; - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy496; - } -yy493: - p = marker; - goto yy489; -yy494: - ++p; - yych = *p; -yy495: - if (yybm[0+yych] & 128) { - goto yy494; - } - if (yych == '@') goto yy492; - goto yy493; -yy496: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy498; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy498; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy498; - goto yy493; - } - } - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy626; - if (yych <= '/') goto yy493; - goto yy627; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy627; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy627; - goto yy493; - } - } -yy498: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych <= '-') goto yy626; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy627; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy627; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy627; - goto yy493; - } - } -yy499: - ++p; - yych = *p; - if (yych <= '@') { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy502; - goto yy493; - } else { - if (yych <= 'Z') goto yy502; - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy502; - goto yy493; - } -yy500: - ++p; - { return (p - start); } -yy502: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy504; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy504; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy504; - goto yy493; - } - } - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy505; - if (yych <= '/') goto yy493; - goto yy506; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy506; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy506; - goto yy493; - } - } -yy504: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy506; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy506; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy506; - goto yy493; - } - } -yy505: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy507; - if (yych <= '/') goto yy493; - goto yy508; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy508; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy508; - goto yy493; - } - } -yy506: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy508; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy508; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy508; - goto yy493; - } - } -yy507: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy509; - if (yych <= '/') goto yy493; - goto yy510; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy510; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy510; - goto yy493; - } - } -yy508: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy510; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy510; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy510; - goto yy493; - } - } -yy509: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy511; - if (yych <= '/') goto yy493; - goto yy512; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy512; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy512; - goto yy493; - } - } -yy510: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy512; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy512; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy512; - goto yy493; - } - } -yy511: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy513; - if (yych <= '/') goto yy493; - goto yy514; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy514; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy514; - goto yy493; - } - } -yy512: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy514; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy514; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy514; - goto yy493; - } - } -yy513: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy515; - if (yych <= '/') goto yy493; - goto yy516; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy516; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy516; - goto yy493; - } - } -yy514: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy516; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy516; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy516; - goto yy493; - } - } -yy515: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy517; - if (yych <= '/') goto yy493; - goto yy518; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy518; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy518; - goto yy493; - } - } -yy516: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy518; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy518; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy518; - goto yy493; - } - } -yy517: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy519; - if (yych <= '/') goto yy493; - goto yy520; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy520; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy520; - goto yy493; - } - } -yy518: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy520; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy520; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy520; - goto yy493; - } - } -yy519: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy521; - if (yych <= '/') goto yy493; - goto yy522; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy522; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy522; - goto yy493; - } - } -yy520: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy522; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy522; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy522; - goto yy493; - } - } -yy521: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy523; - if (yych <= '/') goto yy493; - goto yy524; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy524; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy524; - goto yy493; - } - } -yy522: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy524; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy524; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy524; - goto yy493; - } - } -yy523: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy525; - if (yych <= '/') goto yy493; - goto yy526; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy526; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy526; - goto yy493; - } - } -yy524: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy526; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy526; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy526; - goto yy493; - } - } -yy525: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy527; - if (yych <= '/') goto yy493; - goto yy528; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy528; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy528; - goto yy493; - } - } -yy526: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy528; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy528; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy528; - goto yy493; - } - } -yy527: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy529; - if (yych <= '/') goto yy493; - goto yy530; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy530; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy530; - goto yy493; - } - } -yy528: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy530; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy530; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy530; - goto yy493; - } - } -yy529: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy531; - if (yych <= '/') goto yy493; - goto yy532; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy532; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy532; - goto yy493; - } - } -yy530: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy532; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy532; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy532; - goto yy493; - } - } -yy531: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy533; - if (yych <= '/') goto yy493; - goto yy534; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy534; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy534; - goto yy493; - } - } -yy532: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy534; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy534; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy534; - goto yy493; - } - } -yy533: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy535; - if (yych <= '/') goto yy493; - goto yy536; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy536; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy536; - goto yy493; - } - } -yy534: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy536; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy536; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy536; - goto yy493; - } - } -yy535: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy537; - if (yych <= '/') goto yy493; - goto yy538; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy538; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy538; - goto yy493; - } - } -yy536: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy538; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy538; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy538; - goto yy493; - } - } -yy537: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy539; - if (yych <= '/') goto yy493; - goto yy540; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy540; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy540; - goto yy493; - } - } -yy538: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy540; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy540; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy540; - goto yy493; - } - } -yy539: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy541; - if (yych <= '/') goto yy493; - goto yy542; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy542; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy542; - goto yy493; - } - } -yy540: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy542; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy542; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy542; - goto yy493; - } - } -yy541: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy543; - if (yych <= '/') goto yy493; - goto yy544; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy544; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy544; - goto yy493; - } - } -yy542: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy544; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy544; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy544; - goto yy493; - } - } -yy543: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy545; - if (yych <= '/') goto yy493; - goto yy546; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy546; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy546; - goto yy493; - } - } -yy544: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy546; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy546; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy546; - goto yy493; - } - } -yy545: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy547; - if (yych <= '/') goto yy493; - goto yy548; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy548; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy548; - goto yy493; - } - } -yy546: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy548; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy548; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy548; - goto yy493; - } - } -yy547: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy549; - if (yych <= '/') goto yy493; - goto yy550; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy550; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy550; - goto yy493; - } - } -yy548: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy550; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy550; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy550; - goto yy493; - } - } -yy549: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy551; - if (yych <= '/') goto yy493; - goto yy552; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy552; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy552; - goto yy493; - } - } -yy550: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy552; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy552; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy552; - goto yy493; - } - } -yy551: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy553; - if (yych <= '/') goto yy493; - goto yy554; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy554; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy554; - goto yy493; - } - } -yy552: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy554; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy554; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy554; - goto yy493; - } - } -yy553: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy555; - if (yych <= '/') goto yy493; - goto yy556; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy556; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy556; - goto yy493; - } - } -yy554: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy556; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy556; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy556; - goto yy493; - } - } -yy555: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy557; - if (yych <= '/') goto yy493; - goto yy558; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy558; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy558; - goto yy493; - } - } -yy556: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy558; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy558; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy558; - goto yy493; - } - } -yy557: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy559; - if (yych <= '/') goto yy493; - goto yy560; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy560; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy560; - goto yy493; - } - } -yy558: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy560; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy560; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy560; - goto yy493; - } - } -yy559: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy561; - if (yych <= '/') goto yy493; - goto yy562; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy562; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy562; - goto yy493; - } - } -yy560: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy562; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy562; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy562; - goto yy493; - } - } -yy561: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy563; - if (yych <= '/') goto yy493; - goto yy564; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy564; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy564; - goto yy493; - } - } -yy562: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy564; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy564; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy564; - goto yy493; - } - } -yy563: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy565; - if (yych <= '/') goto yy493; - goto yy566; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy566; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy566; - goto yy493; - } - } -yy564: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy566; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy566; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy566; - goto yy493; - } - } -yy565: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy567; - if (yych <= '/') goto yy493; - goto yy568; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy568; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy568; - goto yy493; - } - } -yy566: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy568; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy568; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy568; - goto yy493; - } - } -yy567: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy569; - if (yych <= '/') goto yy493; - goto yy570; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy570; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy570; - goto yy493; - } - } -yy568: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy570; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy570; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy570; - goto yy493; - } - } -yy569: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy571; - if (yych <= '/') goto yy493; - goto yy572; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy572; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy572; - goto yy493; - } - } -yy570: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy572; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy572; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy572; - goto yy493; - } - } -yy571: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy573; - if (yych <= '/') goto yy493; - goto yy574; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy574; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy574; - goto yy493; - } - } -yy572: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy574; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy574; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy574; - goto yy493; - } - } -yy573: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy575; - if (yych <= '/') goto yy493; - goto yy576; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy576; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy576; - goto yy493; - } - } -yy574: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy576; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy576; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy576; - goto yy493; - } - } -yy575: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy577; - if (yych <= '/') goto yy493; - goto yy578; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy578; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy578; - goto yy493; - } - } -yy576: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy578; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy578; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy578; - goto yy493; - } - } -yy577: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy579; - if (yych <= '/') goto yy493; - goto yy580; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy580; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy580; - goto yy493; - } - } -yy578: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy580; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy580; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy580; - goto yy493; - } - } -yy579: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy581; - if (yych <= '/') goto yy493; - goto yy582; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy582; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy582; - goto yy493; - } - } -yy580: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy582; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy582; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy582; - goto yy493; - } - } -yy581: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy583; - if (yych <= '/') goto yy493; - goto yy584; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy584; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy584; - goto yy493; - } - } -yy582: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy584; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy584; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy584; - goto yy493; - } - } -yy583: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy585; - if (yych <= '/') goto yy493; - goto yy586; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy586; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy586; - goto yy493; - } - } -yy584: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy586; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy586; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy586; - goto yy493; - } - } -yy585: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy587; - if (yych <= '/') goto yy493; - goto yy588; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy588; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy588; - goto yy493; - } - } -yy586: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy588; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy588; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy588; - goto yy493; - } - } -yy587: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy589; - if (yych <= '/') goto yy493; - goto yy590; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy590; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy590; - goto yy493; - } - } -yy588: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy590; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy590; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy590; - goto yy493; - } - } -yy589: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy591; - if (yych <= '/') goto yy493; - goto yy592; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy592; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy592; - goto yy493; - } - } -yy590: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy592; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy592; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy592; - goto yy493; - } - } -yy591: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy593; - if (yych <= '/') goto yy493; - goto yy594; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy594; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy594; - goto yy493; - } - } -yy592: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy594; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy594; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy594; - goto yy493; - } - } -yy593: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy595; - if (yych <= '/') goto yy493; - goto yy596; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy596; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy596; - goto yy493; - } - } -yy594: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy596; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy596; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy596; - goto yy493; - } - } -yy595: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy597; - if (yych <= '/') goto yy493; - goto yy598; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy598; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy598; - goto yy493; - } - } -yy596: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy598; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy598; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy598; - goto yy493; - } - } -yy597: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy599; - if (yych <= '/') goto yy493; - goto yy600; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy600; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy600; - goto yy493; - } - } -yy598: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy600; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy600; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy600; - goto yy493; - } - } -yy599: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy601; - if (yych <= '/') goto yy493; - goto yy602; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy602; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy602; - goto yy493; - } - } -yy600: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy602; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy602; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy602; - goto yy493; - } - } -yy601: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy603; - if (yych <= '/') goto yy493; - goto yy604; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy604; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy604; - goto yy493; - } - } -yy602: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy604; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy604; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy604; - goto yy493; - } - } -yy603: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy605; - if (yych <= '/') goto yy493; - goto yy606; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy606; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy606; - goto yy493; - } - } -yy604: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy606; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy606; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy606; - goto yy493; - } - } -yy605: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy607; - if (yych <= '/') goto yy493; - goto yy608; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy608; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy608; - goto yy493; - } - } -yy606: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy608; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy608; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy608; - goto yy493; - } - } -yy607: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy609; - if (yych <= '/') goto yy493; - goto yy610; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy610; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy610; - goto yy493; - } - } -yy608: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy610; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy610; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy610; - goto yy493; - } - } -yy609: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy611; - if (yych <= '/') goto yy493; - goto yy612; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy612; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy612; - goto yy493; - } - } -yy610: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy612; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy612; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy612; - goto yy493; - } - } -yy611: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy613; - if (yych <= '/') goto yy493; - goto yy614; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy614; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy614; - goto yy493; - } - } -yy612: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy614; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy614; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy614; - goto yy493; - } - } -yy613: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy615; - if (yych <= '/') goto yy493; - goto yy616; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy616; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy616; - goto yy493; - } - } -yy614: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy616; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy616; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy616; - goto yy493; - } - } -yy615: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy617; - if (yych <= '/') goto yy493; - goto yy618; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy618; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy618; - goto yy493; - } - } -yy616: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy618; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy618; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy618; - goto yy493; - } - } -yy617: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy619; - if (yych <= '/') goto yy493; - goto yy620; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy620; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy620; - goto yy493; - } - } -yy618: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy620; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy620; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy620; - goto yy493; - } - } -yy619: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy621; - if (yych <= '/') goto yy493; - goto yy622; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy622; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy622; - goto yy493; - } - } -yy620: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy622; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy622; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy622; - goto yy493; - } - } -yy621: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy623; - if (yych <= '/') goto yy493; - goto yy624; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy624; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy624; - goto yy493; - } - } -yy622: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy624; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy624; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy624; - goto yy493; - } - } -yy623: - ++p; - yych = *p; - if (yych <= '@') { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy625; - goto yy493; - } else { - if (yych <= 'Z') goto yy625; - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy625; - goto yy493; - } -yy624: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= '-') goto yy493; - goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych >= ':') goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - } else { - if (yych <= '`') goto yy493; - if (yych >= '{') goto yy493; - } - } -yy625: - ++p; - yych = *p; - if (yych == '.') goto yy499; - if (yych == '>') goto yy500; - goto yy493; -yy626: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy628; - if (yych <= '/') goto yy493; - goto yy629; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy629; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy629; - goto yy493; - } - } -yy627: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy629; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy629; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy629; - goto yy493; - } - } -yy628: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy630; - if (yych <= '/') goto yy493; - goto yy631; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy631; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy631; - goto yy493; - } - } -yy629: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy631; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy631; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy631; - goto yy493; - } - } -yy630: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy632; - if (yych <= '/') goto yy493; - goto yy633; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy633; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy633; - goto yy493; - } - } -yy631: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy633; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy633; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy633; - goto yy493; - } - } -yy632: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy634; - if (yych <= '/') goto yy493; - goto yy635; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy635; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy635; - goto yy493; - } - } -yy633: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy635; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy635; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy635; - goto yy493; - } - } -yy634: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy636; - if (yych <= '/') goto yy493; - goto yy637; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy637; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy637; - goto yy493; - } - } -yy635: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy637; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy637; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy637; - goto yy493; - } - } -yy636: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy638; - if (yych <= '/') goto yy493; - goto yy639; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy639; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy639; - goto yy493; - } - } -yy637: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy639; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy639; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy639; - goto yy493; - } - } -yy638: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy640; - if (yych <= '/') goto yy493; - goto yy641; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy641; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy641; - goto yy493; - } - } -yy639: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy641; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy641; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy641; - goto yy493; - } - } -yy640: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy642; - if (yych <= '/') goto yy493; - goto yy643; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy643; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy643; - goto yy493; - } - } -yy641: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy643; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy643; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy643; - goto yy493; - } - } -yy642: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy644; - if (yych <= '/') goto yy493; - goto yy645; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy645; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy645; - goto yy493; - } - } -yy643: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy645; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy645; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy645; - goto yy493; - } - } -yy644: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy646; - if (yych <= '/') goto yy493; - goto yy647; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy647; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy647; - goto yy493; - } - } -yy645: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy647; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy647; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy647; - goto yy493; - } - } -yy646: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy648; - if (yych <= '/') goto yy493; - goto yy649; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy649; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy649; - goto yy493; - } - } -yy647: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy649; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy649; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy649; - goto yy493; - } - } -yy648: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy650; - if (yych <= '/') goto yy493; - goto yy651; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy651; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy651; - goto yy493; - } - } -yy649: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy651; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy651; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy651; - goto yy493; - } - } -yy650: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy652; - if (yych <= '/') goto yy493; - goto yy653; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy653; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy653; - goto yy493; - } - } -yy651: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy653; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy653; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy653; - goto yy493; - } - } -yy652: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy654; - if (yych <= '/') goto yy493; - goto yy655; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy655; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy655; - goto yy493; - } - } -yy653: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy655; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy655; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy655; - goto yy493; - } - } -yy654: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy656; - if (yych <= '/') goto yy493; - goto yy657; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy657; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy657; - goto yy493; - } - } -yy655: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy657; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy657; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy657; - goto yy493; - } - } -yy656: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy658; - if (yych <= '/') goto yy493; - goto yy659; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy659; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy659; - goto yy493; - } - } -yy657: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy659; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy659; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy659; - goto yy493; - } - } -yy658: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy660; - if (yych <= '/') goto yy493; - goto yy661; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy661; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy661; - goto yy493; - } - } -yy659: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy661; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy661; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy661; - goto yy493; - } - } -yy660: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy662; - if (yych <= '/') goto yy493; - goto yy663; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy663; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy663; - goto yy493; - } - } -yy661: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy663; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy663; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy663; - goto yy493; - } - } -yy662: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy664; - if (yych <= '/') goto yy493; - goto yy665; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy665; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy665; - goto yy493; - } - } -yy663: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy665; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy665; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy665; - goto yy493; - } - } -yy664: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy666; - if (yych <= '/') goto yy493; - goto yy667; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy667; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy667; - goto yy493; - } - } -yy665: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy667; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy667; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy667; - goto yy493; - } - } -yy666: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy668; - if (yych <= '/') goto yy493; - goto yy669; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy669; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy669; - goto yy493; - } - } -yy667: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy669; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy669; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy669; - goto yy493; - } - } -yy668: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy670; - if (yych <= '/') goto yy493; - goto yy671; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy671; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy671; - goto yy493; - } - } -yy669: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy671; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy671; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy671; - goto yy493; - } - } -yy670: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy672; - if (yych <= '/') goto yy493; - goto yy673; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy673; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy673; - goto yy493; - } - } -yy671: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy673; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy673; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy673; - goto yy493; - } - } -yy672: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy674; - if (yych <= '/') goto yy493; - goto yy675; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy675; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy675; - goto yy493; - } - } -yy673: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy675; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy675; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy675; - goto yy493; - } - } -yy674: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy676; - if (yych <= '/') goto yy493; - goto yy677; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy677; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy677; - goto yy493; - } - } -yy675: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy677; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy677; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy677; - goto yy493; - } - } -yy676: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy678; - if (yych <= '/') goto yy493; - goto yy679; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy679; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy679; - goto yy493; - } - } -yy677: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy679; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy679; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy679; - goto yy493; - } - } -yy678: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy680; - if (yych <= '/') goto yy493; - goto yy681; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy681; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy681; - goto yy493; - } - } -yy679: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy681; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy681; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy681; - goto yy493; - } - } -yy680: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy682; - if (yych <= '/') goto yy493; - goto yy683; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy683; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy683; - goto yy493; - } - } -yy681: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy683; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy683; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy683; - goto yy493; - } - } -yy682: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy684; - if (yych <= '/') goto yy493; - goto yy685; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy685; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy685; - goto yy493; - } - } -yy683: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy685; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy685; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy685; - goto yy493; - } - } -yy684: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy686; - if (yych <= '/') goto yy493; - goto yy687; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy687; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy687; - goto yy493; - } - } -yy685: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy687; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy687; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy687; - goto yy493; - } - } -yy686: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy688; - if (yych <= '/') goto yy493; - goto yy689; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy689; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy689; - goto yy493; - } - } -yy687: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy689; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy689; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy689; - goto yy493; - } - } -yy688: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy690; - if (yych <= '/') goto yy493; - goto yy691; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy691; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy691; - goto yy493; - } - } -yy689: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy691; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy691; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy691; - goto yy493; - } - } -yy690: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy692; - if (yych <= '/') goto yy493; - goto yy693; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy693; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy693; - goto yy493; - } - } -yy691: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy693; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy693; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy693; - goto yy493; - } - } -yy692: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy694; - if (yych <= '/') goto yy493; - goto yy695; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy695; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy695; - goto yy493; - } - } -yy693: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy695; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy695; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy695; - goto yy493; - } - } -yy694: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy696; - if (yych <= '/') goto yy493; - goto yy697; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy697; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy697; - goto yy493; - } - } -yy695: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy697; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy697; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy697; - goto yy493; - } - } -yy696: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy698; - if (yych <= '/') goto yy493; - goto yy699; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy699; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy699; - goto yy493; - } - } -yy697: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy699; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy699; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy699; - goto yy493; - } - } -yy698: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy700; - if (yych <= '/') goto yy493; - goto yy701; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy701; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy701; - goto yy493; - } - } -yy699: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy701; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy701; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy701; - goto yy493; - } - } -yy700: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy702; - if (yych <= '/') goto yy493; - goto yy703; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy703; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy703; - goto yy493; - } - } -yy701: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy703; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy703; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy703; - goto yy493; - } - } -yy702: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy704; - if (yych <= '/') goto yy493; - goto yy705; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy705; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy705; - goto yy493; - } - } -yy703: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy705; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy705; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy705; - goto yy493; - } - } -yy704: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy706; - if (yych <= '/') goto yy493; - goto yy707; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy707; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy707; - goto yy493; - } - } -yy705: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy707; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy707; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy707; - goto yy493; - } - } -yy706: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy708; - if (yych <= '/') goto yy493; - goto yy709; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy709; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy709; - goto yy493; - } - } -yy707: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy709; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy709; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy709; - goto yy493; - } - } -yy708: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy710; - if (yych <= '/') goto yy493; - goto yy711; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy711; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy711; - goto yy493; - } - } -yy709: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy711; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy711; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy711; - goto yy493; - } - } -yy710: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy712; - if (yych <= '/') goto yy493; - goto yy713; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy713; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy713; - goto yy493; - } - } -yy711: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy713; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy713; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy713; - goto yy493; - } - } -yy712: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy714; - if (yych <= '/') goto yy493; - goto yy715; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy715; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy715; - goto yy493; - } - } -yy713: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy715; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy715; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy715; - goto yy493; - } - } -yy714: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy716; - if (yych <= '/') goto yy493; - goto yy717; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy717; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy717; - goto yy493; - } - } -yy715: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy717; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy717; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy717; - goto yy493; - } - } -yy716: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy718; - if (yych <= '/') goto yy493; - goto yy719; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy719; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy719; - goto yy493; - } - } -yy717: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy719; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy719; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy719; - goto yy493; - } - } -yy718: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy720; - if (yych <= '/') goto yy493; - goto yy721; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy721; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy721; - goto yy493; - } - } -yy719: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy721; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy721; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy721; - goto yy493; - } - } -yy720: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy722; - if (yych <= '/') goto yy493; - goto yy723; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy723; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy723; - goto yy493; - } - } -yy721: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy723; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy723; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy723; - goto yy493; - } - } -yy722: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy724; - if (yych <= '/') goto yy493; - goto yy725; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy725; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy725; - goto yy493; - } - } -yy723: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy725; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy725; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy725; - goto yy493; - } - } -yy724: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy726; - if (yych <= '/') goto yy493; - goto yy727; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy727; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy727; - goto yy493; - } - } -yy725: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy727; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy727; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy727; - goto yy493; - } - } -yy726: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy728; - if (yych <= '/') goto yy493; - goto yy729; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy729; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy729; - goto yy493; - } - } -yy727: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy729; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy729; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy729; - goto yy493; - } - } -yy728: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy730; - if (yych <= '/') goto yy493; - goto yy731; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy731; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy731; - goto yy493; - } - } -yy729: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy731; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy731; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy731; - goto yy493; - } - } -yy730: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy732; - if (yych <= '/') goto yy493; - goto yy733; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy733; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy733; - goto yy493; - } - } -yy731: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy733; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy733; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy733; - goto yy493; - } - } -yy732: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy734; - if (yych <= '/') goto yy493; - goto yy735; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy735; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy735; - goto yy493; - } - } -yy733: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy735; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy735; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy735; - goto yy493; - } - } -yy734: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy736; - if (yych <= '/') goto yy493; - goto yy737; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy737; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy737; - goto yy493; - } - } -yy735: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy737; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy737; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy737; - goto yy493; - } - } -yy736: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy738; - if (yych <= '/') goto yy493; - goto yy739; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy739; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy739; - goto yy493; - } - } -yy737: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy739; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy739; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy739; - goto yy493; - } - } -yy738: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy740; - if (yych <= '/') goto yy493; - goto yy741; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy741; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy741; - goto yy493; - } - } -yy739: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy741; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy741; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy741; - goto yy493; - } - } -yy740: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy742; - if (yych <= '/') goto yy493; - goto yy743; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy743; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy743; - goto yy493; - } - } -yy741: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy743; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy743; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy743; - goto yy493; - } - } -yy742: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy744; - if (yych <= '/') goto yy493; - goto yy745; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy745; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy745; - goto yy493; - } - } -yy743: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy745; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy745; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy745; - goto yy493; - } - } -yy744: - yych = *++p; - if (yych <= '@') { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy625; - goto yy493; - } else { - if (yych <= 'Z') goto yy625; - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy625; - goto yy493; - } -yy745: - ++p; - if ((yych = *p) <= '=') { - if (yych <= '.') { - if (yych <= '-') goto yy493; - goto yy499; - } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy625; - goto yy493; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy625; - } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy625; - goto yy493; - } - } -} - -} - -// Try to match an HTML tag after first <, returning num of chars matched. -int _scan_html_tag(const unsigned char *p) -{ - const unsigned char *marker = NULL; - const unsigned char *start = p; - -{ - unsigned char yych; - static const unsigned char yybm[] = { - /* table 1 .. 8: 0 */ - 0, 230, 230, 230, 230, 230, 230, 230, - 230, 199, 199, 199, 199, 199, 230, 230, - 230, 230, 230, 230, 230, 230, 230, 230, - 230, 230, 230, 230, 230, 230, 230, 230, - 199, 230, 70, 230, 230, 230, 230, 134, - 230, 230, 230, 230, 230, 246, 246, 230, - 254, 254, 254, 254, 254, 254, 254, 254, - 254, 254, 246, 230, 198, 198, 196, 230, - 230, 254, 254, 254, 254, 254, 254, 254, - 254, 254, 254, 254, 254, 254, 254, 254, - 254, 254, 254, 254, 254, 254, 254, 254, - 254, 254, 254, 230, 230, 226, 230, 246, - 198, 254, 254, 254, 254, 254, 254, 254, - 254, 254, 254, 254, 254, 254, 254, 254, - 254, 254, 254, 254, 254, 254, 254, 254, - 254, 254, 254, 230, 230, 230, 230, 230, - 230, 230, 230, 230, 230, 230, 230, 230, - 230, 230, 230, 230, 230, 230, 230, 230, - 230, 230, 230, 230, 230, 230, 230, 230, - 230, 230, 230, 230, 230, 230, 230, 230, - 230, 230, 230, 230, 230, 230, 230, 230, - 230, 230, 230, 230, 230, 230, 230, 230, - 230, 230, 230, 230, 230, 230, 230, 230, - 230, 230, 230, 230, 230, 230, 230, 230, - 230, 230, 230, 230, 230, 230, 230, 230, - 230, 230, 230, 230, 230, 230, 230, 230, - 230, 230, 230, 230, 230, 230, 230, 230, - 230, 230, 230, 230, 230, 230, 230, 230, - 230, 230, 230, 230, 230, 230, 230, 230, - 230, 230, 230, 230, 230, 230, 230, 230, - 230, 230, 230, 230, 230, 230, 230, 230, - 230, 230, 230, 230, 230, 230, 230, 230, - /* table 9 .. 11: 256 */ - 0, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 32, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 128, - 160, 224, 224, 224, 224, 224, 224, 224, - 224, 224, 224, 224, 224, 224, 224, 224, - 224, 224, 224, 224, 224, 224, 224, 224, - 224, 224, 224, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - }; - yych = *p; - if (yych <= '/') { - if (yych <= ' ') { - if (yych != '\n') goto yy753; - } else { - if (yych <= '!') goto yy751; - if (yych <= '.') goto yy753; - goto yy750; - } - } else { - if (yych <= '@') { - if (yych == '?') goto yy752; - goto yy753; - } else { - if (yych <= 'Z') goto yy749; - if (yych <= '`') goto yy753; - if (yych <= 'z') goto yy749; - goto yy753; - } - } -yy748: - { return 0; } -yy749: - yych = *(marker = ++p); - if (yych <= '9') { - if (yych <= 0x1F) { - if (yych <= 0x08) goto yy748; - if (yych <= '\r') goto yy790; - goto yy748; - } else { - if (yych <= ' ') goto yy790; - if (yych <= '.') goto yy748; - if (yych <= '/') goto yy792; - goto yy788; - } - } else { - if (yych <= '@') { - if (yych == '>') goto yy758; - goto yy748; - } else { - if (yych <= 'Z') goto yy788; - if (yych <= '`') goto yy748; - if (yych <= 'z') goto yy788; - goto yy748; - } - } -yy750: - yych = *(marker = ++p); - if (yych <= '@') goto yy748; - if (yych <= 'Z') goto yy784; - if (yych <= '`') goto yy748; - if (yych <= 'z') goto yy784; - goto yy748; -yy751: - yych = *(marker = ++p); - if (yybm[256+yych] & 64) { - goto yy761; - } - if (yych == '-') goto yy763; - if (yych == '[') goto yy760; - goto yy748; -yy752: - yych = *(marker = ++p); - if (yych <= 0x00) goto yy748; - goto yy755; -yy753: - yych = *++p; - goto yy748; -yy754: - ++p; - yych = *p; -yy755: - if (yybm[256+yych] & 32) { - goto yy754; - } - if (yych >= 0x01) goto yy757; -yy756: - p = marker; - goto yy748; -yy757: - ++p; - yych = *p; - if (yych <= 0x00) goto yy756; - if (yych != '>') goto yy754; -yy758: - ++p; - { return (p - start); } -yy760: - yych = *++p; - if (yych == 'C') goto yy775; - if (yych == 'c') goto yy775; - goto yy756; -yy761: - ++p; - yych = *p; - if (yybm[0+yych] & 1) { - goto yy771; - } - if (yych <= '@') goto yy756; - if (yych <= 'Z') goto yy761; - goto yy756; -yy763: - yych = *++p; - if (yych != '-') goto yy756; - yych = *++p; - if (yych == '-') goto yy765; - if (yych == '>') goto yy756; - goto yy767; -yy765: - yych = *++p; - if (yych == '-') goto yy770; - if (yych == '>') goto yy756; - goto yy767; -yy766: - ++p; - yych = *p; -yy767: - if (yybm[256+yych] & 128) { - goto yy766; - } - if (yych <= 0x00) goto yy756; - ++p; - yych = *p; - if (yybm[256+yych] & 128) { - goto yy766; - } - if (yych <= 0x00) goto yy756; - yych = *++p; - if (yych == '>') goto yy758; - goto yy756; -yy770: - yych = *++p; - if (yych == '>') goto yy758; - goto yy756; -yy771: - ++p; - yych = *p; - if (yybm[0+yych] & 1) { - goto yy771; - } - if (yych <= 0x00) goto yy756; - if (yych == '>') goto yy758; -yy773: - ++p; - yych = *p; - if (yybm[0+yych] & 2) { - goto yy773; - } - if (yych <= 0x00) goto yy756; - goto yy758; -yy775: - yych = *++p; - if (yych == 'D') goto yy776; - if (yych != 'd') goto yy756; -yy776: - yych = *++p; - if (yych == 'A') goto yy777; - if (yych != 'a') goto yy756; -yy777: - yych = *++p; - if (yych == 'T') goto yy778; - if (yych != 't') goto yy756; -yy778: - yych = *++p; - if (yych == 'A') goto yy779; - if (yych != 'a') goto yy756; -yy779: - yych = *++p; - if (yych != '[') goto yy756; -yy780: - ++p; - yych = *p; - if (yybm[0+yych] & 4) { - goto yy780; - } - if (yych <= 0x00) goto yy756; - ++p; - yych = *p; - if (yybm[0+yych] & 4) { - goto yy780; - } - if (yych <= 0x00) goto yy756; - ++p; - yych = *p; - if (yych <= 0x00) goto yy756; - if (yych == '>') goto yy758; - goto yy780; -yy784: - ++p; - yych = *p; - if (yybm[0+yych] & 8) { - goto yy784; - } - if (yych <= 0x1F) { - if (yych <= 0x08) goto yy756; - if (yych >= 0x0E) goto yy756; - } else { - if (yych <= ' ') goto yy786; - if (yych == '>') goto yy758; - goto yy756; - } -yy786: - ++p; - yych = *p; - if (yych <= 0x1F) { - if (yych <= 0x08) goto yy756; - if (yych <= '\r') goto yy786; - goto yy756; - } else { - if (yych <= ' ') goto yy786; - if (yych == '>') goto yy758; - goto yy756; - } -yy788: - ++p; - yych = *p; - if (yych <= '9') { - if (yych <= 0x1F) { - if (yych <= 0x08) goto yy756; - if (yych >= 0x0E) goto yy756; - } else { - if (yych <= ' ') goto yy790; - if (yych <= '.') goto yy756; - if (yych <= '/') goto yy792; - goto yy788; - } - } else { - if (yych <= '@') { - if (yych == '>') goto yy758; - goto yy756; - } else { - if (yych <= 'Z') goto yy788; - if (yych <= '`') goto yy756; - if (yych <= 'z') goto yy788; - goto yy756; - } - } -yy790: - ++p; - yych = *p; - if (yych <= ':') { - if (yych <= ' ') { - if (yych <= 0x08) goto yy756; - if (yych <= '\r') goto yy790; - if (yych <= 0x1F) goto yy756; - goto yy790; - } else { - if (yych == '/') goto yy792; - if (yych <= '9') goto yy756; - goto yy793; - } - } else { - if (yych <= 'Z') { - if (yych == '>') goto yy758; - if (yych <= '@') goto yy756; - goto yy793; - } else { - if (yych <= '_') { - if (yych <= '^') goto yy756; - goto yy793; - } else { - if (yych <= '`') goto yy756; - if (yych <= 'z') goto yy793; - goto yy756; - } - } - } -yy792: - yych = *++p; - if (yych == '>') goto yy758; - goto yy756; -yy793: - ++p; - yych = *p; - if (yybm[0+yych] & 16) { - goto yy793; - } - if (yych <= '.') { - if (yych <= '\r') { - if (yych <= 0x08) goto yy756; - } else { - if (yych != ' ') goto yy756; - } - } else { - if (yych <= '<') { - if (yych <= '/') goto yy792; - goto yy756; - } else { - if (yych <= '=') goto yy797; - if (yych <= '>') goto yy758; - goto yy756; - } - } -yy795: - ++p; - yych = *p; - if (yych <= '<') { - if (yych <= ' ') { - if (yych <= 0x08) goto yy756; - if (yych <= '\r') goto yy795; - if (yych <= 0x1F) goto yy756; - goto yy795; - } else { - if (yych <= '/') { - if (yych <= '.') goto yy756; - goto yy792; - } else { - if (yych == ':') goto yy793; - goto yy756; - } - } - } else { - if (yych <= 'Z') { - if (yych <= '=') goto yy797; - if (yych <= '>') goto yy758; - if (yych <= '@') goto yy756; - goto yy793; - } else { - if (yych <= '_') { - if (yych <= '^') goto yy756; - goto yy793; - } else { - if (yych <= '`') goto yy756; - if (yych <= 'z') goto yy793; - goto yy756; - } - } - } -yy797: - ++p; - yych = *p; - if (yybm[0+yych] & 32) { - goto yy799; - } - if (yych <= 0x00) goto yy756; - if (yych <= '!') goto yy798; - if (yych <= '"') goto yy803; - if (yych <= ';') goto yy801; - goto yy756; -yy798: - ++p; - yych = *p; - if (yybm[0+yych] & 32) { - goto yy799; - } - if (yych <= '"') { - if (yych <= 0x00) goto yy756; - if (yych <= '!') goto yy812; - goto yy803; - } else { - if (yych <= ';') goto yy801; - if (yych == '>') goto yy758; - goto yy756; - } -yy799: - ++p; - yych = *p; - if (yybm[0+yych] & 32) { - goto yy799; - } - if (yych <= 0x00) goto yy756; - if (yych <= '!') goto yy806; - if (yych == '>') goto yy758; - goto yy756; -yy801: - ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy801; - } - if (yych <= 0x00) goto yy756; - goto yy805; -yy803: - ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy803; - } - if (yych <= 0x00) goto yy756; -yy805: - ++p; - yych = *p; - if (yych <= ' ') { - if (yych <= 0x08) goto yy756; - if (yych <= '\r') goto yy790; - if (yych <= 0x1F) goto yy756; - goto yy790; - } else { - if (yych <= '/') { - if (yych <= '.') goto yy756; - goto yy792; - } else { - if (yych == '>') goto yy758; - goto yy756; - } - } -yy806: - ++p; - yych = *p; - if (yych <= '9') { - if (yych <= ' ') { - if (yych <= 0x08) { - if (yych <= 0x00) goto yy756; - goto yy799; - } else { - if (yych <= '\r') goto yy806; - if (yych <= 0x1F) goto yy799; - goto yy806; - } - } else { - if (yych <= '"') { - if (yych <= '!') goto yy799; - goto yy756; - } else { - if (yych == '\'') goto yy756; - goto yy799; - } - } - } else { - if (yych <= '@') { - if (yych <= ';') { - if (yych >= ';') goto yy799; - } else { - if (yych <= '=') goto yy756; - if (yych <= '>') goto yy758; - goto yy799; - } - } else { - if (yych <= '_') { - if (yych <= 'Z') goto yy808; - if (yych <= '^') goto yy799; - } else { - if (yych <= '`') goto yy756; - if (yych >= '{') goto yy799; - } - } - } -yy808: - ++p; - yych = *p; - if (yych <= '/') { - if (yych <= '!') { - if (yych <= '\r') { - if (yych <= 0x00) goto yy756; - if (yych <= 0x08) goto yy799; - } else { - if (yych != ' ') goto yy799; - } - } else { - if (yych <= '\'') { - if (yych <= '"') goto yy756; - if (yych <= '&') goto yy799; - goto yy756; - } else { - if (yych <= ',') goto yy799; - if (yych <= '.') goto yy808; - goto yy799; - } - } - } else { - if (yych <= '@') { - if (yych <= '<') { - if (yych <= ':') goto yy808; - if (yych <= ';') goto yy799; - goto yy756; - } else { - if (yych <= '=') goto yy797; - if (yych <= '>') goto yy758; - goto yy799; - } - } else { - if (yych <= '_') { - if (yych <= 'Z') goto yy808; - if (yych <= '^') goto yy799; - goto yy808; - } else { - if (yych <= '`') goto yy756; - if (yych <= 'z') goto yy808; - goto yy799; - } - } - } -yy810: - ++p; - yych = *p; - if (yych <= ':') { - if (yych <= ' ') { - if (yych <= 0x08) { - if (yych <= 0x00) goto yy756; - goto yy799; - } else { - if (yych <= '\r') goto yy810; - if (yych <= 0x1F) goto yy799; - goto yy810; - } - } else { - if (yych <= '&') { - if (yych == '"') goto yy756; - goto yy799; - } else { - if (yych <= '\'') goto yy756; - if (yych <= '9') goto yy799; - goto yy808; - } - } - } else { - if (yych <= '@') { - if (yych <= '<') { - if (yych <= ';') goto yy799; - goto yy756; - } else { - if (yych <= '=') goto yy797; - if (yych <= '>') goto yy758; - goto yy799; - } - } else { - if (yych <= '_') { - if (yych <= 'Z') goto yy808; - if (yych <= '^') goto yy799; - goto yy808; - } else { - if (yych <= '`') goto yy756; - if (yych <= 'z') goto yy808; - goto yy799; - } - } - } -yy812: - ++p; - yych = *p; - if (yych <= '9') { - if (yych <= ' ') { - if (yych <= 0x08) { - if (yych <= 0x00) goto yy756; - goto yy799; - } else { - if (yych <= '\r') goto yy812; - if (yych <= 0x1F) goto yy799; - goto yy812; - } - } else { - if (yych <= '"') { - if (yych <= '!') goto yy799; - goto yy803; - } else { - if (yych == '\'') goto yy801; - goto yy799; - } - } - } else { - if (yych <= '@') { - if (yych <= ';') { - if (yych <= ':') goto yy808; - goto yy799; - } else { - if (yych <= '=') goto yy756; - if (yych <= '>') goto yy758; - goto yy799; - } - } else { - if (yych <= '_') { - if (yych <= 'Z') goto yy808; - if (yych <= '^') goto yy799; - goto yy808; - } else { - if (yych <= '`') goto yy756; - if (yych <= 'z') goto yy808; - goto yy799; - } - } - } -} - -} - -// Try to match an HTML block tag including first <, -// returning num of chars matched. -int _scan_html_block_tag(const unsigned char *p) -{ - const unsigned char *marker = NULL; - const unsigned char *start = p; - -{ - unsigned char yych; - yych = *p; - if (yych == '\n') goto yy816; - if (yych == '<') goto yy817; - goto yy818; -yy816: - { return 0; } -yy817: - yych = *(marker = ++p); - switch (yych) { - case '!': - case '?': goto yy819; - case '/': goto yy838; - case 'A': - case 'a': goto yy823; - case 'B': - case 'b': goto yy826; - case 'C': - case 'c': goto yy830; - case 'D': - case 'd': goto yy831; - case 'E': - case 'e': goto yy834; - case 'F': - case 'f': goto yy835; - case 'H': - case 'h': goto yy824; - case 'I': - case 'i': goto yy825; - case 'L': - case 'l': goto yy827; - case 'M': - case 'm': goto yy828; - case 'O': - case 'o': goto yy829; - case 'P': - case 'p': goto yy821; - case 'S': - case 's': goto yy832; - case 'T': - case 't': goto yy833; - case 'U': - case 'u': goto yy836; - case 'V': - case 'v': goto yy837; - default: goto yy816; - } -yy818: - yych = *++p; - goto yy816; -yy819: - ++p; - { return (p - start); } -yy821: - yych = *++p; - if (yych <= '/') { - if (yych <= 0x1F) { - if (yych <= 0x08) goto yy822; - if (yych <= '\r') goto yy982; - } else { - if (yych <= ' ') goto yy982; - if (yych >= '/') goto yy982; - } - } else { - if (yych <= 'Q') { - if (yych == '>') goto yy982; - } else { - if (yych <= 'R') goto yy1095; - if (yych == 'r') goto yy1095; - } - } -yy822: - p = marker; - goto yy816; -yy823: - yych = *++p; - if (yych <= 'S') { - if (yych <= 'Q') goto yy822; - if (yych <= 'R') goto yy1088; - goto yy1087; - } else { - if (yych <= 'q') goto yy822; - if (yych <= 'r') goto yy1088; - if (yych <= 's') goto yy1087; - goto yy822; - } -yy824: - yych = *++p; - if (yych <= 'Q') { - if (yych <= 'D') { - if (yych <= '0') goto yy822; - if (yych <= '6') goto yy981; - goto yy822; - } else { - if (yych <= 'E') goto yy1080; - if (yych == 'G') goto yy1079; - goto yy822; - } - } else { - if (yych <= 'f') { - if (yych <= 'R') goto yy981; - if (yych == 'e') goto yy1080; - goto yy822; - } else { - if (yych <= 'g') goto yy1079; - if (yych == 'r') goto yy981; - goto yy822; - } - } -yy825: - yych = *++p; - if (yych == 'F') goto yy1075; - if (yych == 'f') goto yy1075; - goto yy822; -yy826: - yych = *++p; - if (yych <= 'U') { - if (yych <= 'N') { - if (yych == 'L') goto yy1063; - goto yy822; - } else { - if (yych <= 'O') goto yy1062; - if (yych <= 'T') goto yy822; - goto yy1061; - } - } else { - if (yych <= 'n') { - if (yych == 'l') goto yy1063; - goto yy822; - } else { - if (yych <= 'o') goto yy1062; - if (yych == 'u') goto yy1061; - goto yy822; - } - } -yy827: - yych = *++p; - if (yych == 'I') goto yy981; - if (yych == 'i') goto yy981; - goto yy822; -yy828: - yych = *++p; - if (yych == 'A') goto yy1060; - if (yych == 'a') goto yy1060; - goto yy822; -yy829: - yych = *++p; - if (yych <= 'U') { - if (yych <= 'K') { - if (yych == 'B') goto yy1053; - goto yy822; - } else { - if (yych <= 'L') goto yy981; - if (yych <= 'T') goto yy822; - goto yy1052; - } - } else { - if (yych <= 'k') { - if (yych == 'b') goto yy1053; - goto yy822; - } else { - if (yych <= 'l') goto yy981; - if (yych == 'u') goto yy1052; - goto yy822; - } - } -yy830: - yych = *++p; - if (yych <= 'O') { - if (yych == 'A') goto yy1039; - if (yych <= 'N') goto yy822; - goto yy1038; - } else { - if (yych <= 'a') { - if (yych <= '`') goto yy822; - goto yy1039; - } else { - if (yych == 'o') goto yy1038; - goto yy822; - } - } -yy831: - yych = *++p; - if (yych <= 'T') { - if (yych <= 'I') { - if (yych == 'D') goto yy981; - if (yych <= 'H') goto yy822; - goto yy1037; - } else { - if (yych == 'L') goto yy981; - if (yych <= 'S') goto yy822; - goto yy981; - } - } else { - if (yych <= 'i') { - if (yych == 'd') goto yy981; - if (yych <= 'h') goto yy822; - goto yy1037; - } else { - if (yych <= 'l') { - if (yych <= 'k') goto yy822; - goto yy981; - } else { - if (yych == 't') goto yy981; - goto yy822; - } - } - } -yy832: - yych = *++p; - if (yych <= 'T') { - if (yych <= 'D') { - if (yych == 'C') goto yy1026; - goto yy822; - } else { - if (yych <= 'E') goto yy1027; - if (yych <= 'S') goto yy822; - goto yy1025; - } - } else { - if (yych <= 'd') { - if (yych == 'c') goto yy1026; - goto yy822; - } else { - if (yych <= 'e') goto yy1027; - if (yych == 't') goto yy1025; - goto yy822; - } - } -yy833: - yych = *++p; - switch (yych) { - case 'A': - case 'a': goto yy1011; - case 'B': - case 'b': goto yy1010; - case 'D': - case 'R': - case 'd': - case 'r': goto yy981; - case 'E': - case 'e': goto yy1009; - case 'F': - case 'f': goto yy1008; - case 'H': - case 'h': goto yy1007; - default: goto yy822; - } -yy834: - yych = *++p; - if (yych == 'M') goto yy1004; - if (yych == 'm') goto yy1004; - goto yy822; -yy835: - yych = *++p; - if (yych <= 'O') { - if (yych == 'I') goto yy985; - if (yych <= 'N') goto yy822; - goto yy984; - } else { - if (yych <= 'i') { - if (yych <= 'h') goto yy822; - goto yy985; - } else { - if (yych == 'o') goto yy984; - goto yy822; - } - } -yy836: - yych = *++p; - if (yych == 'L') goto yy981; - if (yych == 'l') goto yy981; - goto yy822; -yy837: - yych = *++p; - if (yych == 'I') goto yy978; - if (yych == 'i') goto yy978; - goto yy822; -yy838: - yych = *++p; - switch (yych) { - case 'A': - case 'a': goto yy840; - case 'B': - case 'b': goto yy843; - case 'C': - case 'c': goto yy847; - case 'D': - case 'd': goto yy848; - case 'E': - case 'e': goto yy851; - case 'F': - case 'f': goto yy852; - case 'H': - case 'h': goto yy841; - case 'I': - case 'i': goto yy842; - case 'L': - case 'l': goto yy844; - case 'M': - case 'm': goto yy845; - case 'O': - case 'o': goto yy846; - case 'P': - case 'p': goto yy839; - case 'S': - case 's': goto yy849; - case 'T': - case 't': goto yy850; - case 'U': - case 'u': goto yy853; - case 'V': - case 'v': goto yy854; - default: goto yy822; - } -yy839: - yych = *++p; - if (yych <= '=') { - if (yych <= '\r') { - if (yych <= 0x08) goto yy822; - goto yy859; - } else { - if (yych == ' ') goto yy859; - goto yy822; - } - } else { - if (yych <= 'R') { - if (yych <= '>') goto yy859; - if (yych <= 'Q') goto yy822; - goto yy972; - } else { - if (yych == 'r') goto yy972; - goto yy822; - } - } -yy840: - yych = *++p; - if (yych <= 'S') { - if (yych <= 'Q') goto yy822; - if (yych <= 'R') goto yy965; - goto yy964; - } else { - if (yych <= 'q') goto yy822; - if (yych <= 'r') goto yy965; - if (yych <= 's') goto yy964; - goto yy822; - } -yy841: - yych = *++p; - if (yych <= 'Q') { - if (yych <= 'D') { - if (yych <= '0') goto yy822; - if (yych <= '6') goto yy858; - goto yy822; - } else { - if (yych <= 'E') goto yy957; - if (yych == 'G') goto yy956; - goto yy822; - } - } else { - if (yych <= 'f') { - if (yych <= 'R') goto yy858; - if (yych == 'e') goto yy957; - goto yy822; - } else { - if (yych <= 'g') goto yy956; - if (yych == 'r') goto yy858; - goto yy822; - } - } -yy842: - yych = *++p; - if (yych == 'F') goto yy952; - if (yych == 'f') goto yy952; - goto yy822; -yy843: - yych = *++p; - if (yych <= 'U') { - if (yych <= 'N') { - if (yych == 'L') goto yy940; - goto yy822; - } else { - if (yych <= 'O') goto yy939; - if (yych <= 'T') goto yy822; - goto yy938; - } - } else { - if (yych <= 'n') { - if (yych == 'l') goto yy940; - goto yy822; - } else { - if (yych <= 'o') goto yy939; - if (yych == 'u') goto yy938; - goto yy822; - } - } -yy844: - yych = *++p; - if (yych == 'I') goto yy858; - if (yych == 'i') goto yy858; - goto yy822; -yy845: - yych = *++p; - if (yych == 'A') goto yy937; - if (yych == 'a') goto yy937; - goto yy822; -yy846: - yych = *++p; - if (yych <= 'U') { - if (yych <= 'K') { - if (yych == 'B') goto yy930; - goto yy822; - } else { - if (yych <= 'L') goto yy858; - if (yych <= 'T') goto yy822; - goto yy929; - } - } else { - if (yych <= 'k') { - if (yych == 'b') goto yy930; - goto yy822; - } else { - if (yych <= 'l') goto yy858; - if (yych == 'u') goto yy929; - goto yy822; - } - } -yy847: - yych = *++p; - if (yych <= 'O') { - if (yych == 'A') goto yy916; - if (yych <= 'N') goto yy822; - goto yy915; - } else { - if (yych <= 'a') { - if (yych <= '`') goto yy822; - goto yy916; - } else { - if (yych == 'o') goto yy915; - goto yy822; - } - } -yy848: - yych = *++p; - if (yych <= 'T') { - if (yych <= 'I') { - if (yych == 'D') goto yy858; - if (yych <= 'H') goto yy822; - goto yy914; - } else { - if (yych == 'L') goto yy858; - if (yych <= 'S') goto yy822; - goto yy858; - } - } else { - if (yych <= 'i') { - if (yych == 'd') goto yy858; - if (yych <= 'h') goto yy822; - goto yy914; - } else { - if (yych <= 'l') { - if (yych <= 'k') goto yy822; - goto yy858; - } else { - if (yych == 't') goto yy858; - goto yy822; - } - } - } -yy849: - yych = *++p; - if (yych <= 'T') { - if (yych <= 'D') { - if (yych == 'C') goto yy903; - goto yy822; - } else { - if (yych <= 'E') goto yy904; - if (yych <= 'S') goto yy822; - goto yy902; - } - } else { - if (yych <= 'd') { - if (yych == 'c') goto yy903; - goto yy822; - } else { - if (yych <= 'e') goto yy904; - if (yych == 't') goto yy902; - goto yy822; - } - } -yy850: - yych = *++p; - switch (yych) { - case 'A': - case 'a': goto yy888; - case 'B': - case 'b': goto yy887; - case 'D': - case 'R': - case 'd': - case 'r': goto yy858; - case 'E': - case 'e': goto yy886; - case 'F': - case 'f': goto yy885; - case 'H': - case 'h': goto yy884; - default: goto yy822; - } -yy851: - yych = *++p; - if (yych == 'M') goto yy881; - if (yych == 'm') goto yy881; - goto yy822; -yy852: - yych = *++p; - if (yych <= 'O') { - if (yych == 'I') goto yy862; - if (yych <= 'N') goto yy822; - goto yy861; - } else { - if (yych <= 'i') { - if (yych <= 'h') goto yy822; - goto yy862; - } else { - if (yych == 'o') goto yy861; - goto yy822; - } - } -yy853: - yych = *++p; - if (yych == 'L') goto yy858; - if (yych == 'l') goto yy858; - goto yy822; -yy854: - yych = *++p; - if (yych == 'I') goto yy855; - if (yych != 'i') goto yy822; -yy855: - yych = *++p; - if (yych == 'D') goto yy856; - if (yych != 'd') goto yy822; -yy856: - yych = *++p; - if (yych == 'E') goto yy857; - if (yych != 'e') goto yy822; -yy857: - yych = *++p; - if (yych == 'O') goto yy858; - if (yych != 'o') goto yy822; -yy858: - yych = *++p; - if (yych <= 0x1F) { - if (yych <= 0x08) goto yy822; - if (yych >= 0x0E) goto yy822; - } else { - if (yych <= ' ') goto yy859; - if (yych != '>') goto yy822; - } -yy859: - ++p; - { return (p - start); } -yy861: - yych = *++p; - if (yych <= 'R') { - if (yych == 'O') goto yy877; - if (yych <= 'Q') goto yy822; - goto yy878; - } else { - if (yych <= 'o') { - if (yych <= 'n') goto yy822; - goto yy877; - } else { - if (yych == 'r') goto yy878; - goto yy822; - } - } -yy862: - yych = *++p; - if (yych <= 'G') { - if (yych == 'E') goto yy863; - if (yych <= 'F') goto yy822; - goto yy864; - } else { - if (yych <= 'e') { - if (yych <= 'd') goto yy822; - } else { - if (yych == 'g') goto yy864; - goto yy822; - } - } -yy863: - yych = *++p; - if (yych == 'L') goto yy873; - if (yych == 'l') goto yy873; - goto yy822; -yy864: - yych = *++p; - if (yych <= 'U') { - if (yych == 'C') goto yy866; - if (yych <= 'T') goto yy822; - } else { - if (yych <= 'c') { - if (yych <= 'b') goto yy822; - goto yy866; - } else { - if (yych != 'u') goto yy822; - } - } - yych = *++p; - if (yych == 'R') goto yy872; - if (yych == 'r') goto yy872; - goto yy822; -yy866: - yych = *++p; - if (yych == 'A') goto yy867; - if (yych != 'a') goto yy822; -yy867: - yych = *++p; - if (yych == 'P') goto yy868; - if (yych != 'p') goto yy822; -yy868: - yych = *++p; - if (yych == 'T') goto yy869; - if (yych != 't') goto yy822; -yy869: - yych = *++p; - if (yych == 'I') goto yy870; - if (yych != 'i') goto yy822; -yy870: - yych = *++p; - if (yych == 'O') goto yy871; - if (yych != 'o') goto yy822; -yy871: - yych = *++p; - if (yych == 'N') goto yy858; - if (yych == 'n') goto yy858; - goto yy822; -yy872: - yych = *++p; - if (yych == 'E') goto yy858; - if (yych == 'e') goto yy858; - goto yy822; -yy873: - yych = *++p; - if (yych == 'D') goto yy874; - if (yych != 'd') goto yy822; -yy874: - yych = *++p; - if (yych == 'S') goto yy875; - if (yych != 's') goto yy822; -yy875: - yych = *++p; - if (yych == 'E') goto yy876; - if (yych != 'e') goto yy822; -yy876: - yych = *++p; - if (yych == 'T') goto yy858; - if (yych == 't') goto yy858; - goto yy822; -yy877: - yych = *++p; - if (yych == 'T') goto yy879; - if (yych == 't') goto yy879; - goto yy822; -yy878: - yych = *++p; - if (yych == 'M') goto yy858; - if (yych == 'm') goto yy858; - goto yy822; -yy879: - yych = *++p; - if (yych == 'E') goto yy880; - if (yych != 'e') goto yy822; -yy880: - yych = *++p; - if (yych == 'R') goto yy858; - if (yych == 'r') goto yy858; - goto yy822; -yy881: - yych = *++p; - if (yych == 'B') goto yy882; - if (yych != 'b') goto yy822; -yy882: - yych = *++p; - if (yych == 'E') goto yy883; - if (yych != 'e') goto yy822; -yy883: - yych = *++p; - if (yych == 'D') goto yy858; - if (yych == 'd') goto yy858; - goto yy822; -yy884: - yych = *++p; - if (yych <= '=') { - if (yych <= '\r') { - if (yych <= 0x08) goto yy822; - goto yy859; - } else { - if (yych == ' ') goto yy859; - goto yy822; - } - } else { - if (yych <= 'E') { - if (yych <= '>') goto yy859; - if (yych <= 'D') goto yy822; - goto yy900; - } else { - if (yych == 'e') goto yy900; - goto yy822; - } - } -yy885: - yych = *++p; - if (yych == 'O') goto yy898; - if (yych == 'o') goto yy898; - goto yy822; -yy886: - yych = *++p; - if (yych == 'X') goto yy893; - if (yych == 'x') goto yy893; - goto yy822; -yy887: - yych = *++p; - if (yych == 'O') goto yy891; - if (yych == 'o') goto yy891; - goto yy822; -yy888: - yych = *++p; - if (yych == 'B') goto yy889; - if (yych != 'b') goto yy822; -yy889: - yych = *++p; - if (yych == 'L') goto yy890; - if (yych != 'l') goto yy822; -yy890: - yych = *++p; - if (yych == 'E') goto yy858; - if (yych == 'e') goto yy858; - goto yy822; -yy891: - yych = *++p; - if (yych == 'D') goto yy892; - if (yych != 'd') goto yy822; -yy892: - yych = *++p; - if (yych == 'Y') goto yy858; - if (yych == 'y') goto yy858; - goto yy822; -yy893: - yych = *++p; - if (yych == 'T') goto yy894; - if (yych != 't') goto yy822; -yy894: - yych = *++p; - if (yych == 'A') goto yy895; - if (yych != 'a') goto yy822; -yy895: - yych = *++p; - if (yych == 'R') goto yy896; - if (yych != 'r') goto yy822; -yy896: - yych = *++p; - if (yych == 'E') goto yy897; - if (yych != 'e') goto yy822; -yy897: - yych = *++p; - if (yych == 'A') goto yy858; - if (yych == 'a') goto yy858; - goto yy822; -yy898: - yych = *++p; - if (yych == 'O') goto yy899; - if (yych != 'o') goto yy822; -yy899: - yych = *++p; - if (yych == 'T') goto yy858; - if (yych == 't') goto yy858; - goto yy822; -yy900: - yych = *++p; - if (yych == 'A') goto yy901; - if (yych != 'a') goto yy822; -yy901: - yych = *++p; - if (yych == 'D') goto yy858; - if (yych == 'd') goto yy858; - goto yy822; -yy902: - yych = *++p; - if (yych == 'Y') goto yy912; - if (yych == 'y') goto yy912; - goto yy822; -yy903: - yych = *++p; - if (yych == 'R') goto yy909; - if (yych == 'r') goto yy909; - goto yy822; -yy904: - yych = *++p; - if (yych == 'C') goto yy905; - if (yych != 'c') goto yy822; -yy905: - yych = *++p; - if (yych == 'T') goto yy906; - if (yych != 't') goto yy822; -yy906: - yych = *++p; - if (yych == 'I') goto yy907; - if (yych != 'i') goto yy822; -yy907: - yych = *++p; - if (yych == 'O') goto yy908; - if (yych != 'o') goto yy822; -yy908: - yych = *++p; - if (yych == 'N') goto yy858; - if (yych == 'n') goto yy858; - goto yy822; -yy909: - yych = *++p; - if (yych == 'I') goto yy910; - if (yych != 'i') goto yy822; -yy910: - yych = *++p; - if (yych == 'P') goto yy911; - if (yych != 'p') goto yy822; -yy911: - yych = *++p; - if (yych == 'T') goto yy858; - if (yych == 't') goto yy858; - goto yy822; -yy912: - yych = *++p; - if (yych == 'L') goto yy913; - if (yych != 'l') goto yy822; -yy913: - yych = *++p; - if (yych == 'E') goto yy858; - if (yych == 'e') goto yy858; - goto yy822; -yy914: - yych = *++p; - if (yych == 'V') goto yy858; - if (yych == 'v') goto yy858; - goto yy822; -yy915: - yych = *++p; - if (yych == 'L') goto yy924; - if (yych == 'l') goto yy924; - goto yy822; -yy916: - yych = *++p; - if (yych <= 'P') { - if (yych == 'N') goto yy917; - if (yych <= 'O') goto yy822; - goto yy918; - } else { - if (yych <= 'n') { - if (yych <= 'm') goto yy822; - } else { - if (yych == 'p') goto yy918; - goto yy822; - } - } -yy917: - yych = *++p; - if (yych == 'V') goto yy922; - if (yych == 'v') goto yy922; - goto yy822; -yy918: - yych = *++p; - if (yych == 'T') goto yy919; - if (yych != 't') goto yy822; -yy919: - yych = *++p; - if (yych == 'I') goto yy920; - if (yych != 'i') goto yy822; -yy920: - yych = *++p; - if (yych == 'O') goto yy921; - if (yych != 'o') goto yy822; -yy921: - yych = *++p; - if (yych == 'N') goto yy858; - if (yych == 'n') goto yy858; - goto yy822; -yy922: - yych = *++p; - if (yych == 'A') goto yy923; - if (yych != 'a') goto yy822; -yy923: - yych = *++p; - if (yych == 'S') goto yy858; - if (yych == 's') goto yy858; - goto yy822; -yy924: - yych = *++p; - if (yych <= '=') { - if (yych <= '\r') { - if (yych <= 0x08) goto yy822; - goto yy859; - } else { - if (yych == ' ') goto yy859; - goto yy822; - } - } else { - if (yych <= 'G') { - if (yych <= '>') goto yy859; - if (yych <= 'F') goto yy822; - } else { - if (yych != 'g') goto yy822; - } - } - yych = *++p; - if (yych == 'R') goto yy926; - if (yych != 'r') goto yy822; -yy926: - yych = *++p; - if (yych == 'O') goto yy927; - if (yych != 'o') goto yy822; -yy927: - yych = *++p; - if (yych == 'U') goto yy928; - if (yych != 'u') goto yy822; -yy928: - yych = *++p; - if (yych == 'P') goto yy858; - if (yych == 'p') goto yy858; - goto yy822; -yy929: - yych = *++p; - if (yych == 'T') goto yy934; - if (yych == 't') goto yy934; - goto yy822; -yy930: - yych = *++p; - if (yych == 'J') goto yy931; - if (yych != 'j') goto yy822; -yy931: - yych = *++p; - if (yych == 'E') goto yy932; - if (yych != 'e') goto yy822; -yy932: - yych = *++p; - if (yych == 'C') goto yy933; - if (yych != 'c') goto yy822; -yy933: - yych = *++p; - if (yych == 'T') goto yy858; - if (yych == 't') goto yy858; - goto yy822; -yy934: - yych = *++p; - if (yych == 'P') goto yy935; - if (yych != 'p') goto yy822; -yy935: - yych = *++p; - if (yych == 'U') goto yy936; - if (yych != 'u') goto yy822; -yy936: - yych = *++p; - if (yych == 'T') goto yy858; - if (yych == 't') goto yy858; - goto yy822; -yy937: - yych = *++p; - if (yych == 'P') goto yy858; - if (yych == 'p') goto yy858; - goto yy822; -yy938: - yych = *++p; - if (yych == 'T') goto yy949; - if (yych == 't') goto yy949; - goto yy822; -yy939: - yych = *++p; - if (yych == 'D') goto yy948; - if (yych == 'd') goto yy948; - goto yy822; -yy940: - yych = *++p; - if (yych == 'O') goto yy941; - if (yych != 'o') goto yy822; -yy941: - yych = *++p; - if (yych == 'C') goto yy942; - if (yych != 'c') goto yy822; -yy942: - yych = *++p; - if (yych == 'K') goto yy943; - if (yych != 'k') goto yy822; -yy943: - yych = *++p; - if (yych == 'Q') goto yy944; - if (yych != 'q') goto yy822; -yy944: - yych = *++p; - if (yych == 'U') goto yy945; - if (yych != 'u') goto yy822; -yy945: - yych = *++p; - if (yych == 'O') goto yy946; - if (yych != 'o') goto yy822; -yy946: - yych = *++p; - if (yych == 'T') goto yy947; - if (yych != 't') goto yy822; -yy947: - yych = *++p; - if (yych == 'E') goto yy858; - if (yych == 'e') goto yy858; - goto yy822; -yy948: - yych = *++p; - if (yych == 'Y') goto yy858; - if (yych == 'y') goto yy858; - goto yy822; -yy949: - yych = *++p; - if (yych == 'T') goto yy950; - if (yych != 't') goto yy822; -yy950: - yych = *++p; - if (yych == 'O') goto yy951; - if (yych != 'o') goto yy822; -yy951: - yych = *++p; - if (yych == 'N') goto yy858; - if (yych == 'n') goto yy858; - goto yy822; -yy952: - yych = *++p; - if (yych == 'R') goto yy953; - if (yych != 'r') goto yy822; -yy953: - yych = *++p; - if (yych == 'A') goto yy954; - if (yych != 'a') goto yy822; -yy954: - yych = *++p; - if (yych == 'M') goto yy955; - if (yych != 'm') goto yy822; -yy955: - yych = *++p; - if (yych == 'E') goto yy858; - if (yych == 'e') goto yy858; - goto yy822; -yy956: - yych = *++p; - if (yych == 'R') goto yy961; - if (yych == 'r') goto yy961; - goto yy822; -yy957: - yych = *++p; - if (yych == 'A') goto yy958; - if (yych != 'a') goto yy822; -yy958: - yych = *++p; - if (yych == 'D') goto yy959; - if (yych != 'd') goto yy822; -yy959: - yych = *++p; - if (yych == 'E') goto yy960; - if (yych != 'e') goto yy822; -yy960: - yych = *++p; - if (yych == 'R') goto yy858; - if (yych == 'r') goto yy858; - goto yy822; -yy961: - yych = *++p; - if (yych == 'O') goto yy962; - if (yych != 'o') goto yy822; -yy962: - yych = *++p; - if (yych == 'U') goto yy963; - if (yych != 'u') goto yy822; -yy963: - yych = *++p; - if (yych == 'P') goto yy858; - if (yych == 'p') goto yy858; - goto yy822; -yy964: - yych = *++p; - if (yych == 'I') goto yy970; - if (yych == 'i') goto yy970; - goto yy822; -yy965: - yych = *++p; - if (yych == 'T') goto yy966; - if (yych != 't') goto yy822; -yy966: - yych = *++p; - if (yych == 'I') goto yy967; - if (yych != 'i') goto yy822; -yy967: - yych = *++p; - if (yych == 'C') goto yy968; - if (yych != 'c') goto yy822; -yy968: - yych = *++p; - if (yych == 'L') goto yy969; - if (yych != 'l') goto yy822; -yy969: - yych = *++p; - if (yych == 'E') goto yy858; - if (yych == 'e') goto yy858; - goto yy822; -yy970: - yych = *++p; - if (yych == 'D') goto yy971; - if (yych != 'd') goto yy822; -yy971: - yych = *++p; - if (yych == 'E') goto yy858; - if (yych == 'e') goto yy858; - goto yy822; -yy972: - yych = *++p; - if (yych <= 'O') { - if (yych == 'E') goto yy858; - if (yych <= 'N') goto yy822; - } else { - if (yych <= 'e') { - if (yych <= 'd') goto yy822; - goto yy858; - } else { - if (yych != 'o') goto yy822; - } - } - yych = *++p; - if (yych == 'G') goto yy974; - if (yych != 'g') goto yy822; -yy974: - yych = *++p; - if (yych == 'R') goto yy975; - if (yych != 'r') goto yy822; -yy975: - yych = *++p; - if (yych == 'E') goto yy976; - if (yych != 'e') goto yy822; -yy976: - yych = *++p; - if (yych == 'S') goto yy977; - if (yych != 's') goto yy822; -yy977: - yych = *++p; - if (yych == 'S') goto yy858; - if (yych == 's') goto yy858; - goto yy822; -yy978: - yych = *++p; - if (yych == 'D') goto yy979; - if (yych != 'd') goto yy822; -yy979: - yych = *++p; - if (yych == 'E') goto yy980; - if (yych != 'e') goto yy822; -yy980: - yych = *++p; - if (yych == 'O') goto yy981; - if (yych != 'o') goto yy822; -yy981: - yych = *++p; - if (yych <= ' ') { - if (yych <= 0x08) goto yy822; - if (yych <= '\r') goto yy982; - if (yych <= 0x1F) goto yy822; - } else { - if (yych <= '/') { - if (yych <= '.') goto yy822; - } else { - if (yych != '>') goto yy822; - } - } -yy982: - ++p; - { return (p - start); } -yy984: - yych = *++p; - if (yych <= 'R') { - if (yych == 'O') goto yy1000; - if (yych <= 'Q') goto yy822; - goto yy1001; - } else { - if (yych <= 'o') { - if (yych <= 'n') goto yy822; - goto yy1000; - } else { - if (yych == 'r') goto yy1001; - goto yy822; - } - } -yy985: - yych = *++p; - if (yych <= 'G') { - if (yych == 'E') goto yy986; - if (yych <= 'F') goto yy822; - goto yy987; - } else { - if (yych <= 'e') { - if (yych <= 'd') goto yy822; - } else { - if (yych == 'g') goto yy987; - goto yy822; - } - } -yy986: - yych = *++p; - if (yych == 'L') goto yy996; - if (yych == 'l') goto yy996; - goto yy822; -yy987: - yych = *++p; - if (yych <= 'U') { - if (yych == 'C') goto yy989; - if (yych <= 'T') goto yy822; - } else { - if (yych <= 'c') { - if (yych <= 'b') goto yy822; - goto yy989; - } else { - if (yych != 'u') goto yy822; - } - } - yych = *++p; - if (yych == 'R') goto yy995; - if (yych == 'r') goto yy995; - goto yy822; -yy989: - yych = *++p; - if (yych == 'A') goto yy990; - if (yych != 'a') goto yy822; -yy990: - yych = *++p; - if (yych == 'P') goto yy991; - if (yych != 'p') goto yy822; -yy991: - yych = *++p; - if (yych == 'T') goto yy992; - if (yych != 't') goto yy822; -yy992: - yych = *++p; - if (yych == 'I') goto yy993; - if (yych != 'i') goto yy822; -yy993: - yych = *++p; - if (yych == 'O') goto yy994; - if (yych != 'o') goto yy822; -yy994: - yych = *++p; - if (yych == 'N') goto yy981; - if (yych == 'n') goto yy981; - goto yy822; -yy995: - yych = *++p; - if (yych == 'E') goto yy981; - if (yych == 'e') goto yy981; - goto yy822; -yy996: - yych = *++p; - if (yych == 'D') goto yy997; - if (yych != 'd') goto yy822; -yy997: - yych = *++p; - if (yych == 'S') goto yy998; - if (yych != 's') goto yy822; -yy998: - yych = *++p; - if (yych == 'E') goto yy999; - if (yych != 'e') goto yy822; -yy999: - yych = *++p; - if (yych == 'T') goto yy981; - if (yych == 't') goto yy981; - goto yy822; -yy1000: - yych = *++p; - if (yych == 'T') goto yy1002; - if (yych == 't') goto yy1002; - goto yy822; -yy1001: - yych = *++p; - if (yych == 'M') goto yy981; - if (yych == 'm') goto yy981; - goto yy822; -yy1002: - yych = *++p; - if (yych == 'E') goto yy1003; - if (yych != 'e') goto yy822; -yy1003: - yych = *++p; - if (yych == 'R') goto yy981; - if (yych == 'r') goto yy981; - goto yy822; -yy1004: - yych = *++p; - if (yych == 'B') goto yy1005; - if (yych != 'b') goto yy822; -yy1005: - yych = *++p; - if (yych == 'E') goto yy1006; - if (yych != 'e') goto yy822; -yy1006: - yych = *++p; - if (yych == 'D') goto yy981; - if (yych == 'd') goto yy981; - goto yy822; -yy1007: - yych = *++p; - if (yych <= '/') { - if (yych <= 0x1F) { - if (yych <= 0x08) goto yy822; - if (yych <= '\r') goto yy982; - goto yy822; - } else { - if (yych <= ' ') goto yy982; - if (yych <= '.') goto yy822; - goto yy982; - } - } else { - if (yych <= 'D') { - if (yych == '>') goto yy982; - goto yy822; - } else { - if (yych <= 'E') goto yy1023; - if (yych == 'e') goto yy1023; - goto yy822; - } - } -yy1008: - yych = *++p; - if (yych == 'O') goto yy1021; - if (yych == 'o') goto yy1021; - goto yy822; -yy1009: - yych = *++p; - if (yych == 'X') goto yy1016; - if (yych == 'x') goto yy1016; - goto yy822; -yy1010: - yych = *++p; - if (yych == 'O') goto yy1014; - if (yych == 'o') goto yy1014; - goto yy822; -yy1011: - yych = *++p; - if (yych == 'B') goto yy1012; - if (yych != 'b') goto yy822; -yy1012: - yych = *++p; - if (yych == 'L') goto yy1013; - if (yych != 'l') goto yy822; -yy1013: - yych = *++p; - if (yych == 'E') goto yy981; - if (yych == 'e') goto yy981; - goto yy822; -yy1014: - yych = *++p; - if (yych == 'D') goto yy1015; - if (yych != 'd') goto yy822; -yy1015: - yych = *++p; - if (yych == 'Y') goto yy981; - if (yych == 'y') goto yy981; - goto yy822; -yy1016: - yych = *++p; - if (yych == 'T') goto yy1017; - if (yych != 't') goto yy822; -yy1017: - yych = *++p; - if (yych == 'A') goto yy1018; - if (yych != 'a') goto yy822; -yy1018: - yych = *++p; - if (yych == 'R') goto yy1019; - if (yych != 'r') goto yy822; -yy1019: - yych = *++p; - if (yych == 'E') goto yy1020; - if (yych != 'e') goto yy822; -yy1020: - yych = *++p; - if (yych == 'A') goto yy981; - if (yych == 'a') goto yy981; - goto yy822; -yy1021: - yych = *++p; - if (yych == 'O') goto yy1022; - if (yych != 'o') goto yy822; -yy1022: - yych = *++p; - if (yych == 'T') goto yy981; - if (yych == 't') goto yy981; - goto yy822; -yy1023: - yych = *++p; - if (yych == 'A') goto yy1024; - if (yych != 'a') goto yy822; -yy1024: - yych = *++p; - if (yych == 'D') goto yy981; - if (yych == 'd') goto yy981; - goto yy822; -yy1025: - yych = *++p; - if (yych == 'Y') goto yy1035; - if (yych == 'y') goto yy1035; - goto yy822; -yy1026: - yych = *++p; - if (yych == 'R') goto yy1032; - if (yych == 'r') goto yy1032; - goto yy822; -yy1027: - yych = *++p; - if (yych == 'C') goto yy1028; - if (yych != 'c') goto yy822; -yy1028: - yych = *++p; - if (yych == 'T') goto yy1029; - if (yych != 't') goto yy822; -yy1029: - yych = *++p; - if (yych == 'I') goto yy1030; - if (yych != 'i') goto yy822; -yy1030: - yych = *++p; - if (yych == 'O') goto yy1031; - if (yych != 'o') goto yy822; -yy1031: - yych = *++p; - if (yych == 'N') goto yy981; - if (yych == 'n') goto yy981; - goto yy822; -yy1032: - yych = *++p; - if (yych == 'I') goto yy1033; - if (yych != 'i') goto yy822; -yy1033: - yych = *++p; - if (yych == 'P') goto yy1034; - if (yych != 'p') goto yy822; -yy1034: - yych = *++p; - if (yych == 'T') goto yy981; - if (yych == 't') goto yy981; - goto yy822; -yy1035: - yych = *++p; - if (yych == 'L') goto yy1036; - if (yych != 'l') goto yy822; -yy1036: - yych = *++p; - if (yych == 'E') goto yy981; - if (yych == 'e') goto yy981; - goto yy822; -yy1037: - yych = *++p; - if (yych == 'V') goto yy981; - if (yych == 'v') goto yy981; - goto yy822; -yy1038: - yych = *++p; - if (yych == 'L') goto yy1047; - if (yych == 'l') goto yy1047; - goto yy822; -yy1039: - yych = *++p; - if (yych <= 'P') { - if (yych == 'N') goto yy1040; - if (yych <= 'O') goto yy822; - goto yy1041; - } else { - if (yych <= 'n') { - if (yych <= 'm') goto yy822; - } else { - if (yych == 'p') goto yy1041; - goto yy822; - } - } -yy1040: - yych = *++p; - if (yych == 'V') goto yy1045; - if (yych == 'v') goto yy1045; - goto yy822; -yy1041: - yych = *++p; - if (yych == 'T') goto yy1042; - if (yych != 't') goto yy822; -yy1042: - yych = *++p; - if (yych == 'I') goto yy1043; - if (yych != 'i') goto yy822; -yy1043: - yych = *++p; - if (yych == 'O') goto yy1044; - if (yych != 'o') goto yy822; -yy1044: - yych = *++p; - if (yych == 'N') goto yy981; - if (yych == 'n') goto yy981; - goto yy822; -yy1045: - yych = *++p; - if (yych == 'A') goto yy1046; - if (yych != 'a') goto yy822; -yy1046: - yych = *++p; - if (yych == 'S') goto yy981; - if (yych == 's') goto yy981; - goto yy822; -yy1047: - yych = *++p; - if (yych <= '/') { - if (yych <= 0x1F) { - if (yych <= 0x08) goto yy822; - if (yych <= '\r') goto yy982; - goto yy822; - } else { - if (yych <= ' ') goto yy982; - if (yych <= '.') goto yy822; - goto yy982; - } - } else { - if (yych <= 'F') { - if (yych == '>') goto yy982; - goto yy822; - } else { - if (yych <= 'G') goto yy1048; - if (yych != 'g') goto yy822; - } - } -yy1048: - yych = *++p; - if (yych == 'R') goto yy1049; - if (yych != 'r') goto yy822; -yy1049: - yych = *++p; - if (yych == 'O') goto yy1050; - if (yych != 'o') goto yy822; -yy1050: - yych = *++p; - if (yych == 'U') goto yy1051; - if (yych != 'u') goto yy822; -yy1051: - yych = *++p; - if (yych == 'P') goto yy981; - if (yych == 'p') goto yy981; - goto yy822; -yy1052: - yych = *++p; - if (yych == 'T') goto yy1057; - if (yych == 't') goto yy1057; - goto yy822; -yy1053: - yych = *++p; - if (yych == 'J') goto yy1054; - if (yych != 'j') goto yy822; -yy1054: - yych = *++p; - if (yych == 'E') goto yy1055; - if (yych != 'e') goto yy822; -yy1055: - yych = *++p; - if (yych == 'C') goto yy1056; - if (yych != 'c') goto yy822; -yy1056: - yych = *++p; - if (yych == 'T') goto yy981; - if (yych == 't') goto yy981; - goto yy822; -yy1057: - yych = *++p; - if (yych == 'P') goto yy1058; - if (yych != 'p') goto yy822; -yy1058: - yych = *++p; - if (yych == 'U') goto yy1059; - if (yych != 'u') goto yy822; -yy1059: - yych = *++p; - if (yych == 'T') goto yy981; - if (yych == 't') goto yy981; - goto yy822; -yy1060: - yych = *++p; - if (yych == 'P') goto yy981; - if (yych == 'p') goto yy981; - goto yy822; -yy1061: - yych = *++p; - if (yych == 'T') goto yy1072; - if (yych == 't') goto yy1072; - goto yy822; -yy1062: - yych = *++p; - if (yych == 'D') goto yy1071; - if (yych == 'd') goto yy1071; - goto yy822; -yy1063: - yych = *++p; - if (yych == 'O') goto yy1064; - if (yych != 'o') goto yy822; -yy1064: - yych = *++p; - if (yych == 'C') goto yy1065; - if (yych != 'c') goto yy822; -yy1065: - yych = *++p; - if (yych == 'K') goto yy1066; - if (yych != 'k') goto yy822; -yy1066: - yych = *++p; - if (yych == 'Q') goto yy1067; - if (yych != 'q') goto yy822; -yy1067: - yych = *++p; - if (yych == 'U') goto yy1068; - if (yych != 'u') goto yy822; -yy1068: - yych = *++p; - if (yych == 'O') goto yy1069; - if (yych != 'o') goto yy822; -yy1069: - yych = *++p; - if (yych == 'T') goto yy1070; - if (yych != 't') goto yy822; -yy1070: - yych = *++p; - if (yych == 'E') goto yy981; - if (yych == 'e') goto yy981; - goto yy822; -yy1071: - yych = *++p; - if (yych == 'Y') goto yy981; - if (yych == 'y') goto yy981; - goto yy822; -yy1072: - yych = *++p; - if (yych == 'T') goto yy1073; - if (yych != 't') goto yy822; -yy1073: - yych = *++p; - if (yych == 'O') goto yy1074; - if (yych != 'o') goto yy822; -yy1074: - yych = *++p; - if (yych == 'N') goto yy981; - if (yych == 'n') goto yy981; - goto yy822; -yy1075: - yych = *++p; - if (yych == 'R') goto yy1076; - if (yych != 'r') goto yy822; -yy1076: - yych = *++p; - if (yych == 'A') goto yy1077; - if (yych != 'a') goto yy822; -yy1077: - yych = *++p; - if (yych == 'M') goto yy1078; - if (yych != 'm') goto yy822; -yy1078: - yych = *++p; - if (yych == 'E') goto yy981; - if (yych == 'e') goto yy981; - goto yy822; -yy1079: - yych = *++p; - if (yych == 'R') goto yy1084; - if (yych == 'r') goto yy1084; - goto yy822; -yy1080: - yych = *++p; - if (yych == 'A') goto yy1081; - if (yych != 'a') goto yy822; -yy1081: - yych = *++p; - if (yych == 'D') goto yy1082; - if (yych != 'd') goto yy822; -yy1082: - yych = *++p; - if (yych == 'E') goto yy1083; - if (yych != 'e') goto yy822; -yy1083: - yych = *++p; - if (yych == 'R') goto yy981; - if (yych == 'r') goto yy981; - goto yy822; -yy1084: - yych = *++p; - if (yych == 'O') goto yy1085; - if (yych != 'o') goto yy822; -yy1085: - yych = *++p; - if (yych == 'U') goto yy1086; - if (yych != 'u') goto yy822; -yy1086: - yych = *++p; - if (yych == 'P') goto yy981; - if (yych == 'p') goto yy981; - goto yy822; -yy1087: - yych = *++p; - if (yych == 'I') goto yy1093; - if (yych == 'i') goto yy1093; - goto yy822; -yy1088: - yych = *++p; - if (yych == 'T') goto yy1089; - if (yych != 't') goto yy822; -yy1089: - yych = *++p; - if (yych == 'I') goto yy1090; - if (yych != 'i') goto yy822; -yy1090: - yych = *++p; - if (yych == 'C') goto yy1091; - if (yych != 'c') goto yy822; -yy1091: - yych = *++p; - if (yych == 'L') goto yy1092; - if (yych != 'l') goto yy822; -yy1092: - yych = *++p; - if (yych == 'E') goto yy981; - if (yych == 'e') goto yy981; - goto yy822; -yy1093: - yych = *++p; - if (yych == 'D') goto yy1094; - if (yych != 'd') goto yy822; -yy1094: - yych = *++p; - if (yych == 'E') goto yy981; - if (yych == 'e') goto yy981; - goto yy822; -yy1095: - yych = *++p; - if (yych <= 'O') { - if (yych == 'E') goto yy981; - if (yych <= 'N') goto yy822; - } else { - if (yych <= 'e') { - if (yych <= 'd') goto yy822; - goto yy981; - } else { - if (yych != 'o') goto yy822; - } - } - yych = *++p; - if (yych == 'G') goto yy1097; - if (yych != 'g') goto yy822; -yy1097: - yych = *++p; - if (yych == 'R') goto yy1098; - if (yych != 'r') goto yy822; -yy1098: - yych = *++p; - if (yych == 'E') goto yy1099; - if (yych != 'e') goto yy822; -yy1099: - yych = *++p; - if (yych == 'S') goto yy1100; - if (yych != 's') goto yy822; -yy1100: - ++p; - if ((yych = *p) == 'S') goto yy981; - if (yych == 's') goto yy981; - goto yy822; -} - -} - -// Try to match a URL in a link or reference, return number of chars matched. -// This may optionally be contained in <..>; otherwise -// whitespace and unbalanced right parentheses aren't allowed. -// Newlines aren't ever allowed. -int _scan_link_url(const unsigned char *p) -{ - const unsigned char *marker = NULL; - const unsigned char *start = p; - -{ - unsigned char yych; - unsigned int yyaccept = 0; - static const unsigned char yybm[] = { - 0, 64, 64, 64, 64, 64, 64, 64, - 64, 64, 8, 64, 64, 64, 64, 64, - 64, 64, 64, 64, 64, 64, 64, 64, - 64, 64, 64, 64, 64, 64, 64, 64, - 72, 112, 112, 112, 112, 112, 112, 112, - 64, 64, 112, 112, 112, 112, 112, 112, - 112, 112, 112, 112, 112, 112, 112, 112, - 112, 112, 112, 112, 16, 112, 16, 112, - 112, 112, 112, 112, 112, 112, 112, 112, - 112, 112, 112, 112, 112, 112, 112, 112, - 112, 112, 112, 112, 112, 112, 112, 112, - 112, 112, 112, 112, 128, 112, 112, 112, - 112, 112, 112, 112, 112, 112, 112, 112, - 112, 112, 112, 112, 112, 112, 112, 112, - 112, 112, 112, 112, 112, 112, 112, 112, - 112, 112, 112, 112, 112, 112, 112, 112, - 112, 112, 112, 112, 112, 112, 112, 112, - 112, 112, 112, 112, 112, 112, 112, 112, - 112, 112, 112, 112, 112, 112, 112, 112, - 112, 112, 112, 112, 112, 112, 112, 112, - 112, 112, 112, 112, 112, 112, 112, 112, - 112, 112, 112, 112, 112, 112, 112, 112, - 112, 112, 112, 112, 112, 112, 112, 112, - 112, 112, 112, 112, 112, 112, 112, 112, - 112, 112, 112, 112, 112, 112, 112, 112, - 112, 112, 112, 112, 112, 112, 112, 112, - 112, 112, 112, 112, 112, 112, 112, 112, - 112, 112, 112, 112, 112, 112, 112, 112, - 112, 112, 112, 112, 112, 112, 112, 112, - 112, 112, 112, 112, 112, 112, 112, 112, - 112, 112, 112, 112, 112, 112, 112, 112, - 112, 112, 112, 112, 112, 112, 112, 112, - }; - yych = *p; - if (yych <= '(') { - if (yych <= 0x1F) { - if (yych == '\n') goto yy1104; - goto yy1112; - } else { - if (yych <= ' ') goto yy1106; - if (yych <= '\'') goto yy1108; - goto yy1111; - } - } else { - if (yych <= '<') { - if (yych <= ')') goto yy1112; - if (yych <= ';') goto yy1108; - goto yy1107; - } else { - if (yych == '\\') goto yy1109; - goto yy1108; - } - } -yy1103: - { return (p - start); } -yy1104: - yyaccept = 0; - marker = ++p; - yych = *p; -yy1105: - if (yybm[0+yych] & 8) { - goto yy1104; - } - if (yych <= ')') { - if (yych <= ' ') goto yy1103; - if (yych <= '\'') goto yy1117; - if (yych <= '(') goto yy1113; - goto yy1103; - } else { - if (yych <= '<') { - if (yych <= ';') goto yy1117; - goto yy1120; - } else { - if (yych == '\\') goto yy1119; - goto yy1117; - } - } -yy1106: - yyaccept = 0; - yych = *(marker = ++p); - goto yy1105; -yy1107: - yyaccept = 0; - yych = *(marker = ++p); - if (yybm[0+yych] & 32) { - goto yy1120; - } - if (yych <= '\'') { - if (yych <= 0x00) goto yy1103; - if (yych == '\n') goto yy1103; - goto yy1127; - } else { - if (yych <= ')') { - if (yych <= '(') goto yy1125; - goto yy1127; - } else { - if (yych <= '=') goto yy1117; - if (yych <= '>') goto yy1122; - goto yy1124; - } - } -yy1108: - yyaccept = 0; - yych = *(marker = ++p); - goto yy1118; -yy1109: - ++p; - if ((yych = *p) <= '@') { - if (yych <= ' ') goto yy1110; - if (yych <= '/') goto yy1117; - if (yych >= ':') goto yy1117; - } else { - if (yych <= '`') { - if (yych >= '[') goto yy1117; - } else { - if (yych <= 'z') goto yy1110; - if (yych <= '~') goto yy1117; - } - } -yy1110: - { return 0; } -yy1111: - yyaccept = 1; - yych = *(marker = ++p); - if (yych <= ' ') goto yy1110; - if (yych == '(') goto yy1110; - goto yy1114; -yy1112: - yych = *++p; - goto yy1110; -yy1113: - ++p; - yych = *p; -yy1114: - if (yybm[0+yych] & 16) { - goto yy1113; - } - if (yych <= '(') goto yy1115; - if (yych <= ')') goto yy1117; - goto yy1116; -yy1115: - p = marker; - if (yyaccept <= 1) { - if (yyaccept == 0) { - goto yy1103; - } else { - goto yy1110; - } - } else { - goto yy1123; - } -yy1116: - ++p; - yych = *p; - if (yych <= '@') { - if (yych <= ' ') goto yy1115; - if (yych <= '/') goto yy1113; - if (yych <= '9') goto yy1115; - goto yy1113; - } else { - if (yych <= '`') { - if (yych <= 'Z') goto yy1115; - goto yy1113; - } else { - if (yych <= 'z') goto yy1115; - if (yych <= '~') goto yy1113; - goto yy1115; - } - } -yy1117: - yyaccept = 0; - marker = ++p; - yych = *p; -yy1118: - if (yych <= '(') { - if (yych <= ' ') goto yy1103; - if (yych <= '\'') goto yy1117; - goto yy1113; - } else { - if (yych <= ')') goto yy1103; - if (yych != '\\') goto yy1117; - } -yy1119: - ++p; - yych = *p; - if (yych <= '@') { - if (yych <= ' ') goto yy1115; - if (yych <= '/') goto yy1117; - if (yych <= '9') goto yy1115; - goto yy1117; - } else { - if (yych <= '`') { - if (yych <= 'Z') goto yy1115; - goto yy1117; - } else { - if (yych <= 'z') goto yy1115; - if (yych <= '~') goto yy1117; - goto yy1115; - } - } -yy1120: - yyaccept = 0; - marker = ++p; - yych = *p; - if (yybm[0+yych] & 32) { - goto yy1120; - } - if (yych <= '\'') { - if (yych <= 0x00) goto yy1103; - if (yych == '\n') goto yy1103; - goto yy1127; - } else { - if (yych <= ')') { - if (yych <= '(') goto yy1125; - goto yy1127; - } else { - if (yych <= '=') goto yy1117; - if (yych >= '?') goto yy1124; - } - } -yy1122: - yyaccept = 2; - yych = *(marker = ++p); - if (yych <= ' ') goto yy1123; - if (yych != ')') goto yy1118; -yy1123: - { return (p - start); } -yy1124: - ++p; - yych = *p; - if (yych <= '>') { - if (yych <= ' ') { - if (yych <= 0x00) goto yy1115; - if (yych == '\n') goto yy1115; - goto yy1127; - } else { - if (yych <= '/') goto yy1120; - if (yych <= '9') goto yy1127; - if (yych <= '=') goto yy1120; - goto yy1137; - } - } else { - if (yych <= '\\') { - if (yych <= '@') goto yy1120; - if (yych <= 'Z') goto yy1127; - if (yych <= '[') goto yy1120; - goto yy1138; - } else { - if (yych <= '`') goto yy1120; - if (yych <= 'z') goto yy1127; - if (yych <= '~') goto yy1120; - goto yy1127; - } - } -yy1125: - ++p; - yych = *p; - if (yych <= ')') { - if (yych <= '\n') { - if (yych <= 0x00) goto yy1115; - if (yych >= '\n') goto yy1115; - } else { - if (yych <= ' ') goto yy1127; - if (yych <= '\'') goto yy1125; - if (yych >= ')') goto yy1120; - } - } else { - if (yych <= '=') { - if (yych == '<') goto yy1113; - goto yy1125; - } else { - if (yych <= '>') goto yy1133; - if (yych == '\\') goto yy1134; - goto yy1125; - } - } -yy1127: - ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy1127; - } - if (yych <= '=') goto yy1115; - if (yych >= '?') goto yy1130; -yy1129: - yych = *++p; - goto yy1123; -yy1130: - ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy1130; - } - if (yych <= '\n') { - if (yych <= 0x00) goto yy1115; - if (yych <= '\t') goto yy1127; - goto yy1115; - } else { - if (yych != '>') goto yy1127; - } - yyaccept = 2; - marker = ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy1127; - } - if (yych <= '=') goto yy1123; - if (yych <= '>') goto yy1129; - goto yy1130; -yy1133: - yyaccept = 2; - yych = *(marker = ++p); - if (yych <= ' ') goto yy1123; - if (yych == '(') goto yy1123; - goto yy1114; -yy1134: - ++p; - yych = *p; - if (yych <= '>') { - if (yych <= ' ') { - if (yych <= 0x00) goto yy1115; - if (yych == '\n') goto yy1115; - goto yy1127; - } else { - if (yych <= '/') goto yy1125; - if (yych <= '9') goto yy1127; - if (yych <= '=') goto yy1125; - } - } else { - if (yych <= '\\') { - if (yych <= '@') goto yy1125; - if (yych <= 'Z') goto yy1127; - if (yych <= '[') goto yy1125; - goto yy1136; - } else { - if (yych <= '`') goto yy1125; - if (yych <= 'z') goto yy1127; - if (yych <= '~') goto yy1125; - goto yy1127; - } - } -yy1135: - yyaccept = 2; - marker = ++p; - yych = *p; - if (yych <= ')') { - if (yych <= '\n') { - if (yych <= 0x00) goto yy1123; - if (yych <= '\t') goto yy1127; - goto yy1123; - } else { - if (yych <= ' ') goto yy1127; - if (yych <= '\'') goto yy1125; - if (yych <= '(') goto yy1127; - goto yy1120; - } - } else { - if (yych <= '=') { - if (yych == '<') goto yy1113; - goto yy1125; - } else { - if (yych <= '>') goto yy1133; - if (yych == '\\') goto yy1134; - goto yy1125; - } - } -yy1136: - ++p; - yych = *p; - if (yych <= '(') { - if (yych <= '\n') { - if (yych <= 0x00) goto yy1115; - if (yych <= '\t') goto yy1127; - goto yy1115; - } else { - if (yych <= ' ') goto yy1127; - if (yych <= '\'') goto yy1125; - goto yy1127; - } - } else { - if (yych <= '>') { - if (yych <= ')') goto yy1120; - if (yych <= '=') goto yy1125; - goto yy1135; - } else { - if (yych == '\\') goto yy1134; - goto yy1125; - } - } -yy1137: - yyaccept = 2; - marker = ++p; - yych = *p; - if (yybm[0+yych] & 32) { - goto yy1120; - } - if (yych <= '\'') { - if (yych <= 0x00) goto yy1123; - if (yych == '\n') goto yy1123; - goto yy1127; - } else { - if (yych <= ')') { - if (yych <= '(') goto yy1125; - goto yy1127; - } else { - if (yych <= '=') goto yy1117; - if (yych <= '>') goto yy1122; - goto yy1124; - } - } -yy1138: - yyaccept = 0; - marker = ++p; - yych = *p; - if (yych <= '(') { - if (yych <= '\n') { - if (yych <= 0x00) goto yy1103; - if (yych <= '\t') goto yy1127; - goto yy1103; - } else { - if (yych <= ' ') goto yy1127; - if (yych <= '\'') goto yy1120; - goto yy1125; - } - } else { - if (yych <= '>') { - if (yych <= ')') goto yy1127; - if (yych <= '=') goto yy1120; - goto yy1137; - } else { - if (yych == '\\') goto yy1124; - goto yy1120; - } - } -} - -} - -// Try to match a link title (in single quotes, in double quotes, or -// in parentheses), returning number of chars matched. Allow one -// level of internal nesting (quotes within quotes). -int _scan_link_title(const unsigned char *p) -{ - const unsigned char *marker = NULL; - const unsigned char *start = p; - -{ - unsigned char yych; - unsigned int yyaccept = 0; - static const unsigned char yybm[] = { - 0, 208, 208, 208, 208, 208, 208, 208, - 208, 208, 208, 208, 208, 208, 208, 208, - 208, 208, 208, 208, 208, 208, 208, 208, - 208, 208, 208, 208, 208, 208, 208, 208, - 208, 208, 80, 208, 208, 208, 208, 144, - 208, 192, 208, 208, 208, 208, 208, 208, - 208, 208, 208, 208, 208, 208, 208, 208, - 208, 208, 208, 208, 208, 208, 208, 208, - 208, 208, 208, 208, 208, 208, 208, 208, - 208, 208, 208, 208, 208, 208, 208, 208, - 208, 208, 208, 208, 208, 208, 208, 208, - 208, 208, 208, 208, 32, 208, 208, 208, - 208, 208, 208, 208, 208, 208, 208, 208, - 208, 208, 208, 208, 208, 208, 208, 208, - 208, 208, 208, 208, 208, 208, 208, 208, - 208, 208, 208, 208, 208, 208, 208, 208, - 208, 208, 208, 208, 208, 208, 208, 208, - 208, 208, 208, 208, 208, 208, 208, 208, - 208, 208, 208, 208, 208, 208, 208, 208, - 208, 208, 208, 208, 208, 208, 208, 208, - 208, 208, 208, 208, 208, 208, 208, 208, - 208, 208, 208, 208, 208, 208, 208, 208, - 208, 208, 208, 208, 208, 208, 208, 208, - 208, 208, 208, 208, 208, 208, 208, 208, - 208, 208, 208, 208, 208, 208, 208, 208, - 208, 208, 208, 208, 208, 208, 208, 208, - 208, 208, 208, 208, 208, 208, 208, 208, - 208, 208, 208, 208, 208, 208, 208, 208, - 208, 208, 208, 208, 208, 208, 208, 208, - 208, 208, 208, 208, 208, 208, 208, 208, - 208, 208, 208, 208, 208, 208, 208, 208, - 208, 208, 208, 208, 208, 208, 208, 208, - }; - yych = *p; - if (yych <= '"') { - if (yych == '\n') goto yy1141; - if (yych <= '!') goto yy1145; - goto yy1142; - } else { - if (yych <= '&') goto yy1145; - if (yych <= '\'') goto yy1143; - if (yych <= '(') goto yy1144; - goto yy1145; - } -yy1141: - { return 0; } -yy1142: - yyaccept = 0; - yych = *(marker = ++p); - if (yych <= 0x00) goto yy1141; - goto yy1162; -yy1143: - yyaccept = 0; - yych = *(marker = ++p); - if (yych <= 0x00) goto yy1141; - goto yy1155; -yy1144: - yyaccept = 0; - yych = *(marker = ++p); - if (yych <= 0x00) goto yy1141; - goto yy1147; -yy1145: - yych = *++p; - goto yy1141; -yy1146: - ++p; - yych = *p; -yy1147: - if (yybm[0+yych] & 16) { - goto yy1146; - } - if (yych <= 0x00) goto yy1148; - if (yych <= '[') goto yy1151; - goto yy1149; -yy1148: - p = marker; - if (yyaccept <= 1) { - if (yyaccept == 0) { - goto yy1141; - } else { - goto yy1152; - } - } else { - if (yyaccept == 2) { - goto yy1159; - } else { - goto yy1166; - } - } -yy1149: - ++p; - yych = *p; - if (yybm[0+yych] & 16) { - goto yy1146; - } - if (yych <= 0x00) goto yy1148; - if (yych <= '[') goto yy1153; - goto yy1149; -yy1151: - ++p; -yy1152: - { return (p - start); } -yy1153: - yyaccept = 1; - marker = ++p; - yych = *p; - if (yybm[0+yych] & 16) { - goto yy1146; - } - if (yych <= 0x00) goto yy1152; - if (yych <= '[') goto yy1151; - goto yy1149; -yy1154: - ++p; - yych = *p; -yy1155: - if (yybm[0+yych] & 64) { - goto yy1154; - } - if (yych <= 0x00) goto yy1148; - if (yych <= '[') goto yy1158; -yy1156: - ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy1154; - } - if (yych <= 0x00) goto yy1148; - if (yych <= '[') goto yy1160; - goto yy1156; -yy1158: - ++p; -yy1159: - { return (p - start); } -yy1160: - yyaccept = 2; - marker = ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy1154; - } - if (yych <= 0x00) goto yy1159; - if (yych <= '[') goto yy1158; - goto yy1156; -yy1161: - ++p; - yych = *p; -yy1162: - if (yybm[0+yych] & 128) { - goto yy1161; - } - if (yych <= 0x00) goto yy1148; - if (yych <= '[') goto yy1165; -yy1163: - ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy1161; - } - if (yych <= 0x00) goto yy1148; - if (yych <= '[') goto yy1167; - goto yy1163; -yy1165: - ++p; -yy1166: - { return (p - start); } -yy1167: - yyaccept = 3; - marker = ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy1161; - } - if (yych <= 0x00) goto yy1166; - if (yych <= '[') goto yy1165; - goto yy1163; -} - -} - -// Match space characters, including newlines. -int _scan_spacechars(const unsigned char *p) -{ - const unsigned char *start = p; \ - -{ - unsigned char yych; - static const unsigned char yybm[] = { - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 128, 128, 128, 128, 128, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 128, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - }; - yych = *p; - if (yych <= '\n') { - if (yych <= 0x08) goto yy1174; - if (yych <= '\t') goto yy1171; - goto yy1172; - } else { - if (yych <= '\r') goto yy1171; - if (yych == ' ') goto yy1171; - goto yy1174; - } -yy1170: - { return (p - start); } -yy1171: - yych = *++p; - goto yy1173; -yy1172: - ++p; - yych = *p; -yy1173: - if (yybm[0+yych] & 128) { - goto yy1172; - } - goto yy1170; -yy1174: - ++p; - { return 0; } -} - -} - -// Match ATX header start. -int _scan_atx_header_start(const unsigned char *p) -{ - const unsigned char *marker = NULL; - const unsigned char *start = p; - -{ - unsigned char yych; - static const unsigned char yybm[] = { - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 128, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - }; - yych = *p; - if (yych == '\n') goto yy1178; - if (yych == '#') goto yy1179; - goto yy1180; -yy1178: - { return 0; } -yy1179: - yych = *(marker = ++p); - if (yybm[0+yych] & 128) { - goto yy1183; - } - if (yych == '\n') goto yy1181; - if (yych == '#') goto yy1185; - goto yy1178; -yy1180: - yych = *++p; - goto yy1178; -yy1181: - ++p; -yy1182: - { return (p - start); } -yy1183: - ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy1183; - } - goto yy1182; -yy1185: - yych = *++p; - if (yybm[0+yych] & 128) { - goto yy1183; - } - if (yych == '\n') goto yy1181; - if (yych == '#') goto yy1187; -yy1186: - p = marker; - goto yy1178; -yy1187: - yych = *++p; - if (yybm[0+yych] & 128) { - goto yy1183; - } - if (yych == '\n') goto yy1181; - if (yych != '#') goto yy1186; - yych = *++p; - if (yybm[0+yych] & 128) { - goto yy1183; - } - if (yych == '\n') goto yy1181; - if (yych != '#') goto yy1186; - yych = *++p; - if (yybm[0+yych] & 128) { - goto yy1183; - } - if (yych == '\n') goto yy1181; - if (yych != '#') goto yy1186; - ++p; - if (yybm[0+(yych = *p)] & 128) { - goto yy1183; - } - if (yych == '\n') goto yy1181; - goto yy1186; -} - -} - -// Match sexext header line. Return 1 for level-1 header, -// 2 for level-2, 0 for no match. -int _scan_setext_header_line(const unsigned char *p) -{ - const unsigned char *marker = NULL; - -{ - unsigned char yych; - static const unsigned char yybm[] = { - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 32, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 64, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 128, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - }; - yych = *p; - if (yych <= ',') { - if (yych != '\n') goto yy1196; - } else { - if (yych <= '-') goto yy1195; - if (yych == '=') goto yy1194; - goto yy1196; - } -yy1193: - { return 0; } -yy1194: - yych = *(marker = ++p); - if (yybm[0+yych] & 128) { - goto yy1208; - } - if (yych == '\n') goto yy1206; - if (yych == ' ') goto yy1204; - goto yy1193; -yy1195: - yych = *(marker = ++p); - if (yybm[0+yych] & 32) { - goto yy1197; - } - if (yych == '\n') goto yy1200; - if (yych == '-') goto yy1202; - goto yy1193; -yy1196: - yych = *++p; - goto yy1193; -yy1197: - ++p; - yych = *p; - if (yybm[0+yych] & 32) { - goto yy1197; - } - if (yych == '\n') goto yy1200; -yy1199: - p = marker; - goto yy1193; -yy1200: - ++p; - { return 2; } -yy1202: - ++p; - yych = *p; - if (yybm[0+yych] & 32) { - goto yy1197; - } - if (yych == '\n') goto yy1200; - if (yych == '-') goto yy1202; - goto yy1199; -yy1204: - ++p; - yych = *p; - if (yych == '\n') goto yy1206; - if (yych == ' ') goto yy1204; - goto yy1199; -yy1206: - ++p; - { return 1; } -yy1208: - ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy1208; - } - if (yych == '\n') goto yy1206; - if (yych == ' ') goto yy1204; - goto yy1199; -} - -} - -// Scan a horizontal rule line: "...three or more hyphens, asterisks, -// or underscores on a line by themselves. If you wish, you may use -// spaces between the hyphens or asterisks." -int _scan_hrule(const unsigned char *p) -{ - const unsigned char *marker = NULL; - const unsigned char *start = p; - -{ - unsigned char yych; - static const unsigned char yybm[] = { - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 32, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 248, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 128, 0, 0, 16, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 64, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - }; - yych = *p; - if (yych <= '*') { - if (yych == '\n') goto yy1212; - if (yych <= ')') goto yy1216; - goto yy1213; - } else { - if (yych <= '-') { - if (yych <= ',') goto yy1216; - goto yy1215; - } else { - if (yych == '_') goto yy1214; - goto yy1216; - } - } -yy1212: - { return 0; } -yy1213: - yych = *(marker = ++p); - if (yych == ' ') goto yy1238; - if (yych == '*') goto yy1240; - goto yy1212; -yy1214: - yych = *(marker = ++p); - if (yych == ' ') goto yy1228; - if (yych == '_') goto yy1230; - goto yy1212; -yy1215: - yych = *(marker = ++p); - if (yybm[0+yych] & 8) { - goto yy1217; - } - if (yych == '-') goto yy1220; - goto yy1212; -yy1216: - yych = *++p; - goto yy1212; -yy1217: - ++p; - yych = *p; - if (yybm[0+yych] & 8) { - goto yy1217; - } - if (yych == '-') goto yy1220; -yy1219: - p = marker; - goto yy1212; -yy1220: - ++p; - yych = *p; - if (yych == ' ') goto yy1220; - if (yych != '-') goto yy1219; -yy1222: - ++p; - yych = *p; - if (yybm[0+yych] & 16) { - goto yy1222; - } - if (yych <= 0x08) goto yy1219; - if (yych <= '\t') goto yy1224; - if (yych <= '\n') goto yy1226; - goto yy1219; -yy1224: - ++p; - yych = *p; - if (yybm[0+yych] & 32) { - goto yy1224; - } - if (yych != '\n') goto yy1219; -yy1226: - ++p; - { return (p - start); } -yy1228: - ++p; - yych = *p; - if (yych == ' ') goto yy1228; - if (yych != '_') goto yy1219; -yy1230: - ++p; - yych = *p; - if (yych == ' ') goto yy1230; - if (yych != '_') goto yy1219; -yy1232: - ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy1232; - } - if (yych <= 0x08) goto yy1219; - if (yych <= '\t') goto yy1234; - if (yych <= '\n') goto yy1236; - goto yy1219; -yy1234: - ++p; - yych = *p; - if (yych <= '\n') { - if (yych <= 0x08) goto yy1219; - if (yych <= '\t') goto yy1234; - } else { - if (yych == ' ') goto yy1234; - goto yy1219; - } -yy1236: - ++p; - { return (p - start); } -yy1238: - ++p; - yych = *p; - if (yych == ' ') goto yy1238; - if (yych != '*') goto yy1219; -yy1240: - ++p; - yych = *p; - if (yych == ' ') goto yy1240; - if (yych != '*') goto yy1219; -yy1242: - ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy1242; - } - if (yych <= 0x08) goto yy1219; - if (yych <= '\t') goto yy1244; - if (yych <= '\n') goto yy1246; - goto yy1219; -yy1244: - ++p; - yych = *p; - if (yych <= '\n') { - if (yych <= 0x08) goto yy1219; - if (yych <= '\t') goto yy1244; - } else { - if (yych == ' ') goto yy1244; - goto yy1219; - } -yy1246: - ++p; - { return (p - start); } -} - -} - -// Scan an opening code fence. -int _scan_open_code_fence(const unsigned char *p) -{ - const unsigned char *marker = NULL; - const unsigned char *start = p; - -{ - unsigned char yych; - static const unsigned char yybm[] = { - 0, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 0, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 96, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 144, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - }; - yych = *p; - if (yych <= '_') { - if (yych != '\n') goto yy1253; - } else { - if (yych <= '`') goto yy1251; - if (yych == '~') goto yy1252; - goto yy1253; - } -yy1250: - { return 0; } -yy1251: - yych = *(marker = ++p); - if (yych == '`') goto yy1262; - goto yy1250; -yy1252: - yych = *(marker = ++p); - if (yych == '~') goto yy1254; - goto yy1250; -yy1253: - yych = *++p; - goto yy1250; -yy1254: - yych = *++p; - if (yybm[0+yych] & 16) { - goto yy1256; - } -yy1255: - p = marker; - goto yy1250; -yy1256: - marker = p + 1; - ++p; - yych = *p; - if (yybm[0+yych] & 32) { - goto yy1258; - } - if (yych <= 0x00) goto yy1255; - if (yych <= '}') goto yy1260; - goto yy1256; -yy1258: - ++p; - yych = *p; - if (yybm[0+yych] & 32) { - goto yy1258; - } - if (yych <= 0x00) goto yy1255; - if (yych >= '~') goto yy1255; -yy1260: - ++p; - p = marker; - { return (p - start); } -yy1262: - yych = *++p; - if (yybm[0+yych] & 64) { - goto yy1263; - } - goto yy1255; -yy1263: - marker = p + 1; - ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy1265; - } - if (yych <= 0x00) goto yy1255; - if (yych <= '_') goto yy1267; - goto yy1263; -yy1265: - ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy1265; - } - if (yych <= 0x00) goto yy1255; - if (yych >= '`') goto yy1255; -yy1267: - ++p; - p = marker; - { return (p - start); } -} - -} - -// Scan a closing code fence with length at least len. -int _scan_close_code_fence(const unsigned char *p) -{ - const unsigned char *marker = NULL; - const unsigned char *start = p; - -{ - unsigned char yych; - static const unsigned char yybm[] = { - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 64, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 64, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 128, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 32, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - }; - yych = *p; - if (yych <= '_') { - if (yych != '\n') goto yy1274; - } else { - if (yych <= '`') goto yy1272; - if (yych == '~') goto yy1273; - goto yy1274; - } -yy1271: - { return 0; } -yy1272: - yych = *(marker = ++p); - if (yych == '`') goto yy1283; - goto yy1271; -yy1273: - yych = *(marker = ++p); - if (yych == '~') goto yy1275; - goto yy1271; -yy1274: - yych = *++p; - goto yy1271; -yy1275: - yych = *++p; - if (yybm[0+yych] & 32) { - goto yy1277; - } -yy1276: - p = marker; - goto yy1271; -yy1277: - marker = p + 1; - ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy1279; - } - if (yych == '\n') goto yy1281; - if (yych == '~') goto yy1277; - goto yy1276; -yy1279: - ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy1279; - } - if (yych != '\n') goto yy1276; -yy1281: - ++p; - p = marker; - { return (p - start); } -yy1283: - yych = *++p; - if (yybm[0+yych] & 128) { - goto yy1284; - } - goto yy1276; -yy1284: - marker = p + 1; - ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy1284; - } - if (yych <= '\n') { - if (yych <= 0x08) goto yy1276; - if (yych >= '\n') goto yy1288; - } else { - if (yych != ' ') goto yy1276; - } -yy1286: - ++p; - yych = *p; - if (yych <= '\n') { - if (yych <= 0x08) goto yy1276; - if (yych <= '\t') goto yy1286; - } else { - if (yych == ' ') goto yy1286; - goto yy1276; - } -yy1288: - ++p; - p = marker; - { return (p - start); } -} - -} - -// Scans an entity. -// Returns number of chars matched. -int _scan_entity(const unsigned char *p) -{ - const unsigned char *marker = NULL; - const unsigned char *start = p; - -{ - unsigned char yych; - yych = *p; - if (yych == '\n') goto yy1292; - if (yych == '&') goto yy1293; - goto yy1294; -yy1292: - { return 0; } -yy1293: - yych = *(marker = ++p); - if (yych <= '@') { - if (yych == '#') goto yy1295; - goto yy1292; - } else { - if (yych <= 'Z') goto yy1297; - if (yych <= '`') goto yy1292; - if (yych <= 'z') goto yy1297; - goto yy1292; - } -yy1294: - yych = *++p; - goto yy1292; -yy1295: - yych = *++p; - if (yych <= 'W') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1332; - } else { - if (yych <= 'X') goto yy1331; - if (yych == 'x') goto yy1331; - } -yy1296: - p = marker; - goto yy1292; -yy1297: - yych = *++p; - if (yych <= '@') { - if (yych <= '/') goto yy1296; - if (yych >= ':') goto yy1296; - } else { - if (yych <= 'Z') goto yy1298; - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; - } -yy1298: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1301; - if (yych <= ':') goto yy1296; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy1296; - goto yy1301; - } else { - if (yych <= '`') goto yy1296; - if (yych <= 'z') goto yy1301; - goto yy1296; - } - } -yy1299: - ++p; - { return (p - start); } -yy1301: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1302; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; - } - } -yy1302: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1303; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; - } - } -yy1303: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1304; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; - } - } -yy1304: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1305; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; - } - } -yy1305: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1306; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; - } - } -yy1306: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1307; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; - } - } -yy1307: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1308; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; - } - } -yy1308: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1309; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; - } - } -yy1309: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1310; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; - } - } -yy1310: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1311; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; - } - } -yy1311: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1312; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; - } - } -yy1312: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1313; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; - } - } -yy1313: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1314; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; - } - } -yy1314: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1315; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; - } - } -yy1315: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1316; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; - } - } -yy1316: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1317; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; - } - } -yy1317: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1318; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; - } - } -yy1318: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1319; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; - } - } -yy1319: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1320; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; - } - } -yy1320: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1321; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; - } - } -yy1321: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1322; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; - } - } -yy1322: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1323; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; - } - } -yy1323: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1324; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; - } - } -yy1324: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1325; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; - } - } -yy1325: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1326; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; - } - } -yy1326: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1327; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; - } - } -yy1327: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1328; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; - } - } -yy1328: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1329; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; - } - } -yy1329: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1330; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; - } - } -yy1330: - yych = *++p; - if (yych == ';') goto yy1299; - goto yy1296; -yy1331: - yych = *++p; - if (yych <= '@') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1339; - goto yy1296; - } else { - if (yych <= 'F') goto yy1339; - if (yych <= '`') goto yy1296; - if (yych <= 'f') goto yy1339; - goto yy1296; - } -yy1332: - yych = *++p; - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1333; - if (yych == ';') goto yy1299; - goto yy1296; -yy1333: - yych = *++p; - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1334; - if (yych == ';') goto yy1299; - goto yy1296; -yy1334: - yych = *++p; - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1335; - if (yych == ';') goto yy1299; - goto yy1296; -yy1335: - yych = *++p; - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1336; - if (yych == ';') goto yy1299; - goto yy1296; -yy1336: - yych = *++p; - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1337; - if (yych == ';') goto yy1299; - goto yy1296; -yy1337: - yych = *++p; - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1338; - if (yych == ';') goto yy1299; - goto yy1296; -yy1338: - yych = *++p; - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1330; - if (yych == ';') goto yy1299; - goto yy1296; -yy1339: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1340; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'F') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= 'g') goto yy1296; - } - } -yy1340: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1341; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'F') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= 'g') goto yy1296; - } - } -yy1341: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1342; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'F') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= 'g') goto yy1296; - } - } -yy1342: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1343; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'F') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= 'g') goto yy1296; - } - } -yy1343: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1344; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'F') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= 'g') goto yy1296; - } - } -yy1344: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1345; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'F') { - if (yych <= '@') goto yy1296; - } else { - if (yych <= '`') goto yy1296; - if (yych >= 'g') goto yy1296; - } - } -yy1345: - ++p; - if ((yych = *p) <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1330; - if (yych <= ':') goto yy1296; - goto yy1299; - } else { - if (yych <= 'F') { - if (yych <= '@') goto yy1296; - goto yy1330; - } else { - if (yych <= '`') goto yy1296; - if (yych <= 'f') goto yy1330; - goto yy1296; - } - } -} - -} diff --git a/cmark/scanners.h b/cmark/scanners.h deleted file mode 100644 --- a/cmark/scanners.h +++ /dev/null @@ -1,39 +0,0 @@ -#include "cmark.h" -#include "chunk.h" - -#ifdef __cplusplus -extern "C" { -#endif - -int _scan_at(int (*scanner)(const unsigned char *), cmark_chunk *c, int offset); -int _scan_autolink_uri(const unsigned char *p); -int _scan_autolink_email(const unsigned char *p); -int _scan_html_tag(const unsigned char *p); -int _scan_html_block_tag(const unsigned char *p); -int _scan_link_url(const unsigned char *p); -int _scan_link_title(const unsigned char *p); -int _scan_spacechars(const unsigned char *p); -int _scan_atx_header_start(const unsigned char *p); -int _scan_setext_header_line(const unsigned char *p); -int _scan_hrule(const unsigned char *p); -int _scan_open_code_fence(const unsigned char *p); -int _scan_close_code_fence(const unsigned char *p); -int _scan_entity(const unsigned char *p); - -#define scan_autolink_uri(c, n) _scan_at(&_scan_autolink_uri, c, n) -#define scan_autolink_email(c, n) _scan_at(&_scan_autolink_email, c, n) -#define scan_html_tag(c, n) _scan_at(&_scan_html_tag, c, n) -#define scan_html_block_tag(c, n) _scan_at(&_scan_html_block_tag, c, n) -#define scan_link_url(c, n) _scan_at(&_scan_link_url, c, n) -#define scan_link_title(c, n) _scan_at(&_scan_link_title, c, n) -#define scan_spacechars(c, n) _scan_at(&_scan_spacechars, c, n) -#define scan_atx_header_start(c, n) _scan_at(&_scan_atx_header_start, c, n) -#define scan_setext_header_line(c, n) _scan_at(&_scan_setext_header_line, c, n) -#define scan_hrule(c, n) _scan_at(&_scan_hrule, c, n) -#define scan_open_code_fence(c, n) _scan_at(&_scan_open_code_fence, c, n) -#define scan_close_code_fence(c, n) _scan_at(&_scan_close_code_fence, c, n) -#define scan_entity(c, n) _scan_at(&_scan_entity, c, n) - -#ifdef __cplusplus -} -#endif diff --git a/cmark/utf8.c b/cmark/utf8.c deleted file mode 100644 --- a/cmark/utf8.c +++ /dev/null @@ -1,453 +0,0 @@ -#include -#include -#include - -#include "cmark_ctype.h" -#include "utf8.h" - -static const int8_t utf8proc_utf8class[256] = { - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0 -}; - -static void encode_unknown(cmark_strbuf *buf) -{ - static const uint8_t repl[] = {239, 191, 189}; - cmark_strbuf_put(buf, repl, 3); -} - -static int utf8proc_charlen(const uint8_t *str, int str_len) -{ - int length, i; - - if (!str_len) - return 0; - - length = utf8proc_utf8class[str[0]]; - - if (!length) - return -1; - - if (str_len >= 0 && length > str_len) - return -str_len; - - for (i = 1; i < length; i++) { - if ((str[i] & 0xC0) != 0x80) - return -i; - } - - return length; -} - -// Validate a single UTF-8 character according to RFC 3629. -static int utf8proc_valid(const uint8_t *str, int str_len) -{ - int length = utf8proc_charlen(str, str_len); - - if (length <= 0) - return length; - - switch (length) { - case 1: - if (str[0] == 0x00) { - // ASCII NUL is technically valid but rejected - // for security reasons. - return -length; - } - break; - - case 2: - if (str[0] < 0xC2) { - // Overlong - return -length; - } - break; - - case 3: - if (str[0] == 0xE0) { - if (str[1] < 0xA0) { - // Overlong - return -length; - } - } else if (str[0] == 0xED) { - if (str[1] >= 0xA0) { - // Surrogate - return -length; - } - } - break; - - case 4: - if (str[0] == 0xF0) { - if (str[1] < 0x90) { - // Overlong - return -length; - } - } else if (str[0] >= 0xF4) { - if (str[0] > 0xF4 || str[1] >= 0x90) { - // Above 0x10FFFF - return -length; - } - } - break; - } - - return length; -} - -void utf8proc_detab(cmark_strbuf *ob, const uint8_t *line, size_t size) -{ - static const uint8_t whitespace[] = " "; - - size_t i = 0, tab = 0; - - while (i < size) { - size_t org = i; - - while (i < size && line[i] != '\t' && line[i] != '\0' - && line[i] < 0x80) { - i++; - tab++; - } - - if (i > org) - cmark_strbuf_put(ob, line + org, i - org); - - if (i >= size) - break; - - if (line[i] == '\t') { - int numspaces = 4 - (tab % 4); - cmark_strbuf_put(ob, whitespace, numspaces); - i += 1; - tab += numspaces; - } else { - int charlen = utf8proc_valid(line + i, size - i); - - if (charlen >= 0) { - cmark_strbuf_put(ob, line + i, charlen); - } else { - encode_unknown(ob); - charlen = -charlen; - } - - i += charlen; - tab += 1; - } - } -} - -int utf8proc_iterate(const uint8_t *str, int str_len, int32_t *dst) -{ - int length; - int32_t uc = -1; - - *dst = -1; - length = utf8proc_charlen(str, str_len); - if (length < 0) - return -1; - - switch (length) { - case 1: - uc = str[0]; - break; - case 2: - uc = ((str[0] & 0x1F) << 6) + (str[1] & 0x3F); - if (uc < 0x80) uc = -1; - break; - case 3: - uc = ((str[0] & 0x0F) << 12) + ((str[1] & 0x3F) << 6) - + (str[2] & 0x3F); - if (uc < 0x800 || (uc >= 0xD800 && uc < 0xE000) || - (uc >= 0xFDD0 && uc < 0xFDF0)) uc = -1; - break; - case 4: - uc = ((str[0] & 0x07) << 18) + ((str[1] & 0x3F) << 12) - + ((str[2] & 0x3F) << 6) + (str[3] & 0x3F); - if (uc < 0x10000 || uc >= 0x110000) uc = -1; - break; - } - - if (uc < 0 || ((uc & 0xFFFF) >= 0xFFFE)) - return -1; - - *dst = uc; - return length; -} - -void utf8proc_encode_char(int32_t uc, cmark_strbuf *buf) -{ - uint8_t dst[4]; - int len = 0; - - assert(uc >= 0); - - if (uc < 0x80) { - dst[0] = uc; - len = 1; - } else if (uc < 0x800) { - dst[0] = 0xC0 + (uc >> 6); - dst[1] = 0x80 + (uc & 0x3F); - len = 2; - } else if (uc == 0xFFFF) { - dst[0] = 0xFF; - len = 1; - } else if (uc == 0xFFFE) { - dst[0] = 0xFE; - len = 1; - } else if (uc < 0x10000) { - dst[0] = 0xE0 + (uc >> 12); - dst[1] = 0x80 + ((uc >> 6) & 0x3F); - dst[2] = 0x80 + (uc & 0x3F); - len = 3; - } else if (uc < 0x110000) { - dst[0] = 0xF0 + (uc >> 18); - dst[1] = 0x80 + ((uc >> 12) & 0x3F); - dst[2] = 0x80 + ((uc >> 6) & 0x3F); - dst[3] = 0x80 + (uc & 0x3F); - len = 4; - } else { - encode_unknown(buf); - return; - } - - cmark_strbuf_put(buf, dst, len); -} - -void utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str, int len) -{ - int32_t c; - -#define bufpush(x) \ - utf8proc_encode_char(x, dest) - - while (len > 0) { - int char_len = utf8proc_iterate(str, len, &c); - - if (char_len >= 0) { -#include "case_fold_switch.inc" - } else { - encode_unknown(dest); - char_len = -char_len; - } - - str += char_len; - len -= char_len; - } -} - -// matches anything in the Zs class, plus LF, CR, TAB, FF. -int utf8proc_is_space(int32_t uc) -{ - return (uc == 9 || - uc == 10 || - uc == 12 || - uc == 13 || - uc == 32 || - uc == 160 || - uc == 5760 || - (uc >= 8192 && uc <= 8202) || - uc == 8239 || - uc == 8287 || - uc == 12288); -} - -// matches anything in the P[cdefios] classes. -int utf8proc_is_punctuation(int32_t uc) -{ - return ((uc < 128 && cmark_ispunct((char)uc)) || - uc == 161 || - uc == 167 || - uc == 171 || - uc == 182 || - uc == 183 || - uc == 187 || - uc == 191 || - uc == 894 || - uc == 903 || - (uc >= 1370 && uc <= 1375) || - uc == 1417 || - uc == 1418 || - uc == 1470 || - uc == 1472 || - uc == 1475 || - uc == 1478 || - uc == 1523 || - uc == 1524 || - uc == 1545 || - uc == 1546 || - uc == 1548 || - uc == 1549 || - uc == 1563 || - uc == 1566 || - uc == 1567 || - (uc >= 1642 && uc <= 1645) || - uc == 1748 || - (uc >= 1792 && uc <= 1805) || - (uc >= 2039 && uc <= 2041) || - (uc >= 2096 && uc <= 2110) || - uc == 2142 || - uc == 2404 || - uc == 2405 || - uc == 2416 || - uc == 2800 || - uc == 3572 || - uc == 3663 || - uc == 3674 || - uc == 3675 || - (uc >= 3844 && uc <= 3858) || - uc == 3860 || - (uc >= 3898 && uc <= 3901) || - uc == 3973 || - (uc >= 4048 && uc <= 4052) || - uc == 4057 || - uc == 4058 || - (uc >= 4170 && uc <= 4175) || - uc == 4347 || - (uc >= 4960 && uc <= 4968) || - uc == 5120 || - uc == 5741 || - uc == 5742 || - uc == 5787 || - uc == 5788 || - (uc >= 5867 && uc <= 5869) || - uc == 5941 || - uc == 5942 || - (uc >= 6100 && uc <= 6102) || - (uc >= 6104 && uc <= 6106) || - (uc >= 6144 && uc <= 6154) || - uc == 6468 || - uc == 6469 || - uc == 6686 || - uc == 6687 || - (uc >= 6816 && uc <= 6822) || - (uc >= 6824 && uc <= 6829) || - (uc >= 7002 && uc <= 7008) || - (uc >= 7164 && uc <= 7167) || - (uc >= 7227 && uc <= 7231) || - uc == 7294 || - uc == 7295 || - (uc >= 7360 && uc <= 7367) || - uc == 7379 || - (uc >= 8208 && uc <= 8231) || - (uc >= 8240 && uc <= 8259) || - (uc >= 8261 && uc <= 8273) || - (uc >= 8275 && uc <= 8286) || - uc == 8317 || - uc == 8318 || - uc == 8333 || - uc == 8334 || - (uc >= 8968 && uc <= 8971) || - uc == 9001 || - uc == 9002 || - (uc >= 10088 && uc <= 10101) || - uc == 10181 || - uc == 10182 || - (uc >= 10214 && uc <= 10223) || - (uc >= 10627 && uc <= 10648) || - (uc >= 10712 && uc <= 10715) || - uc == 10748 || - uc == 10749 || - (uc >= 11513 && uc <= 11516) || - uc == 11518 || - uc == 11519 || - uc == 11632 || - (uc >= 11776 && uc <= 11822) || - (uc >= 11824 && uc <= 11842) || - (uc >= 12289 && uc <= 12291) || - (uc >= 12296 && uc <= 12305) || - (uc >= 12308 && uc <= 12319) || - uc == 12336 || - uc == 12349 || - uc == 12448 || - uc == 12539 || - uc == 42238 || - uc == 42239 || - (uc >= 42509 && uc <= 42511) || - uc == 42611 || - uc == 42622 || - (uc >= 42738 && uc <= 42743) || - (uc >= 43124 && uc <= 43127) || - uc == 43214 || - uc == 43215 || - (uc >= 43256 && uc <= 43258) || - uc == 43310 || - uc == 43311 || - uc == 43359 || - (uc >= 43457 && uc <= 43469) || - uc == 43486 || - uc == 43487 || - (uc >= 43612 && uc <= 43615) || - uc == 43742 || - uc == 43743 || - uc == 43760 || - uc == 43761 || - uc == 44011 || - uc == 64830 || - uc == 64831 || - (uc >= 65040 && uc <= 65049) || - (uc >= 65072 && uc <= 65106) || - (uc >= 65108 && uc <= 65121) || - uc == 65123 || - uc == 65128 || - uc == 65130 || - uc == 65131 || - (uc >= 65281 && uc <= 65283) || - (uc >= 65285 && uc <= 65290) || - (uc >= 65292 && uc <= 65295) || - uc == 65306 || - uc == 65307 || - uc == 65311 || - uc == 65312 || - (uc >= 65339 && uc <= 65341) || - uc == 65343 || - uc == 65371 || - uc == 65373 || - (uc >= 65375 && uc <= 65381) || - (uc >= 65792 && uc <= 65794) || - uc == 66463 || - uc == 66512 || - uc == 66927 || - uc == 67671 || - uc == 67871 || - uc == 67903 || - (uc >= 68176 && uc <= 68184) || - uc == 68223 || - (uc >= 68336 && uc <= 68342) || - (uc >= 68409 && uc <= 68415) || - (uc >= 68505 && uc <= 68508) || - (uc >= 69703 && uc <= 69709) || - uc == 69819 || - uc == 69820 || - (uc >= 69822 && uc <= 69825) || - (uc >= 69952 && uc <= 69955) || - uc == 70004 || - uc == 70005 || - (uc >= 70085 && uc <= 70088) || - uc == 70093 || - (uc >= 70200 && uc <= 70205) || - uc == 70854 || - (uc >= 71105 && uc <= 71113) || - (uc >= 71233 && uc <= 71235) || - (uc >= 74864 && uc <= 74868) || - uc == 92782 || - uc == 92783 || - uc == 92917 || - (uc >= 92983 && uc <= 92987) || - uc == 92996 || - uc == 113823); -} diff --git a/cmark/utf8.h b/cmark/utf8.h deleted file mode 100644 --- a/cmark/utf8.h +++ /dev/null @@ -1,22 +0,0 @@ -#ifndef CMARK_UTF8_H -#define CMARK_UTF8_H - -#include -#include "buffer.h" - -#ifdef __cplusplus -extern "C" { -#endif - -void utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str, int len); -void utf8proc_encode_char(int32_t uc, cmark_strbuf *buf); -int utf8proc_iterate(const uint8_t *str, int str_len, int32_t *dst); -void utf8proc_detab(cmark_strbuf *dest, const uint8_t *line, size_t size); -int utf8proc_is_space(int32_t uc); -int utf8proc_is_punctuation(int32_t uc); - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/cmark/xml.c b/cmark/xml.c deleted file mode 100644 --- a/cmark/xml.c +++ /dev/null @@ -1,170 +0,0 @@ -#include -#include -#include -#include - -#include "config.h" -#include "cmark.h" -#include "node.h" -#include "buffer.h" -#include "houdini.h" - -// Functions to convert cmark_nodes to XML strings. - -static void escape_xml(cmark_strbuf *dest, const unsigned char *source, int length) -{ - if (source != NULL) { - if (length < 0) - length = strlen((char *)source); - - houdini_escape_html0(dest, source, (size_t)length, 0); - } -} - -struct render_state { - cmark_strbuf* xml; - int indent; -}; - -static inline void indent(struct render_state *state) -{ - int i; - for (i = 0; i < state->indent; i++) { - cmark_strbuf_putc(state->xml, ' '); - } -} - -static int -S_render_node(cmark_node *node, cmark_event_type ev_type, - struct render_state *state, int options) -{ - cmark_strbuf *xml = state->xml; - bool literal = false; - cmark_delim_type delim; - bool entering = (ev_type == CMARK_EVENT_ENTER); - - if (entering) { - indent(state); - cmark_strbuf_printf(xml, "<%s", - cmark_node_get_type_string(node)); - - if (options & CMARK_OPT_SOURCEPOS && node->start_line != 0) { - cmark_strbuf_printf(xml, " sourcepos=\"%d:%d-%d:%d\"", - node->start_line, - node->start_column, - node->end_line, - node->end_column); - } - - literal = false; - - switch (node->type) { - case CMARK_NODE_TEXT: - case CMARK_NODE_CODE: - case CMARK_NODE_HTML: - case CMARK_NODE_INLINE_HTML: - cmark_strbuf_puts(xml, ">"); - escape_xml(xml, node->as.literal.data, - node->as.literal.len); - cmark_strbuf_puts(xml, "as.header.level); - break; - case CMARK_NODE_CODE_BLOCK: - if (node->as.code.info.len > 0) { - cmark_strbuf_puts(xml, " info=\""); - escape_xml(xml, node->as.code.info.data, - node->as.code.info.len); - cmark_strbuf_putc(xml, '"'); - } - cmark_strbuf_puts(xml, ">"); - escape_xml(xml, node->as.code.literal.data, - node->as.code.literal.len); - cmark_strbuf_puts(xml, "as.link.url, -1); - cmark_strbuf_putc(xml, '"'); - cmark_strbuf_puts(xml, " title=\""); - escape_xml(xml, node->as.link.title, -1); - cmark_strbuf_putc(xml, '"'); - break; - default: - break; - } - if (node->first_child) { - state->indent += 2; - } else if (!literal) { - cmark_strbuf_puts(xml, " /"); - } - cmark_strbuf_puts(xml, ">\n"); - - - } else if (node->first_child) { - state->indent -= 2; - indent(state); - cmark_strbuf_printf(xml, "\n", - cmark_node_get_type_string(node)); - } - - return 1; -} - -char *cmark_render_xml(cmark_node *root, int options) -{ - char *result; - cmark_strbuf xml = GH_BUF_INIT; - cmark_event_type ev_type; - cmark_node *cur; - struct render_state state = { &xml, 0 }; - - cmark_iter *iter = cmark_iter_new(root); - - cmark_strbuf_puts(state.xml, - "\n"); - cmark_strbuf_puts(state.xml, - "\n"); - while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { - cur = cmark_iter_get_node(iter); - S_render_node(cur, ev_type, &state, options); - } - result = (char *)cmark_strbuf_detach(&xml); - - cmark_iter_free(iter); - return result; -}